Как я могу проверить, что событие содержит обработчик события?

Question

Я хочу проверить, что метод класса A RegisterEventHandlers() регистрирует один из его методов как EventHandler для события в классе B. Как я могу это сделать? Я использую moq, если это имеет значение.

• Не думаю, что есть способ осмотреть делегата обработчика событий вне класса (пожалуйста, исправьте меня, если я ошибаюсь).
• Было бы хорошо, если бы я мог вызвать событие и затем утверждать, что мой обратный вызов был вызван, но если я высмеиваю интерфейс класса A (и устанавливаю ожидание для обратного вызова), тогда я теряю реализацию RegisterEventHandlers(), который я тестирую в первую очередь.
• Лучше всего было бы посмеяться над событием класса B, но я не понимаю, какой метод мне пришлось бы перехватить, чтобы сделать это. Есть ли способ настроить макет для события и перехватить вызов метода +=?

Есть ли чистое решение для этого?

Answer 1

Вы правы в том, что не можете получить доступ к делегатам событий извне класса, это ограничение в языке C #.

Самый простой подход для проверки этого состоит в том, чтобы имитировать класс B изатем поднять его событие и затем наблюдать побочные эффекты от события, которое поднимается.Это немного отличается от того, что вы ищете, но демонстрирует поведение класса A, а не его реализацию (это то, к чему должны стремиться ваши тесты).

Чтобы это работало, класс B должен бытьmockable и событие, которое оно выставляет, также должно быть виртуальным.Moq не может перехватывать события, если они не объявлены как виртуальные.В качестве альтернативы, если B является интерфейсом, убедитесь, что событие объявлено там.

public interface IEventProvider
{
    event EventHandler OnEvent;
}

public class Example
{
    public Example(IEventProvider e)
    {
        e.OnEvent += PerformWork;
    }

    private void PerformWork(object sender, EventArgs e)
    {
        // perform work

        // event has an impact on this class that can be observed
        //   from the outside.  this is just an example...
        VisibleSideEffect = true;
    }

    public bool VisibleSideEffect
    {
       get; set;
    }
}

[TestClass]
public class ExampleFixture
{
    [TestMethod]
    public void DemonstrateThatTheClassRespondsToEvents()
    {
        var eventProvider = new Mock<IEventProvider>().Object;
        var subject = new Example(eventProvider.Object);

        Mock.Get(eventProvider)
            .Raise( e => e.OnEvent += null, EventArgs.Empty);

        Assert.IsTrue( subject.VisibleSideEffect, 
                       "the visible side effect of the event was not raised.");
    }
}

Если вам действительно необходимо протестировать реализацию, существуют другие доступные механизмы, такие как рука-rolled Test Spy / Test Double , или основанная на отражении стратегия, чтобы получить список делегатов.Я надеюсь, что вы должны быть более озабочены логикой обработки событий класса А, чем его назначением обработчика событий.В конце концов, если класс А не отвечает на событие и что-то с ним делает, назначение не должно иметь значения.

Answer 2

При макете B, объявляйте EventHandler следующим образом:

public class B : IB
{
  public int EventsRegistered;
  public event EventHandler Junk
  {
     add
     {
        this.EventsRegistered++;
     }
     remove
     {
        this.EventsRegistered--;
     }
  }
}

Я не уверен, что moq позволяет это, но я уверен, что вы можете создать свой собственный класс mock.

Answer 3

Вы можете получить список вызовов для события вне класса, объявляющего событие - но это включает отражение.Ниже приведен пример кода, показывающий, как можно определить, какие методы (на целевом экземпляре a ) добавляются к событию b.TheEvent после вызова a.RegisterEventHandlers ().Вставьте приведенный ниже код в файл кода и добавьте в форму или консольный проект: Test test = new Test ();test.Run ();

using System;
using System.Reflection;
using System.Diagnostics;
using System.Collections.Generic;

   public class A
   {
      B m_b = new B();

      public void RegisterEventHandlers()
      {
         m_b.TheEvent += new EventHandler(Handler_TheEvent);
         m_b.TheEvent += new EventHandler(AnotherHandler_TheEvent);
      }

      public A()
      { 
         m_b.TheEvent += new EventHandler(InitialHandler_TheEvent);
      }

      void InitialHandler_TheEvent(object sender, EventArgs e)
      { }

      void Handler_TheEvent(object sender, EventArgs e)
      { }

      void AnotherHandler_TheEvent(object sender, EventArgs e)
      { }
   }

   public class B
   {
      public event EventHandler TheEvent;
      //{
      //   //Note that if we declared TheEvent without the add/remove methods, the
      //   //following would still generated internally and the underlying member
      //   //(here m_theEvent) can be accessed via Reflection. The automatically
      //   //generated version has a private field with the same name as the event
      //   //(i.e. "TheEvent")

      //   add { m_theEvent += value; }
      //   remove { m_theEvent -= value; }
      //}
      //EventHandler m_theEvent; //"TheEvent" if we don't implement add/remove


      //The following shows how the event can be invoked using the underlying multicast delegate.
      //We use this knowledge when invoking via reflection (of course, normally we just write
      //if (TheEvent != null) TheEvent(this, EventArgs.Empty)
      public void ExampleInvokeTheEvent()
      {
         Delegate[] dels = TheEvent.GetInvocationList();
         foreach (Delegate del in dels)
         {
            MethodInfo method = del.Method;
            //This does the same as ThisEvent(this, EventArgs.Empty) for a single registered target
            method.Invoke(this, new object[] { EventArgs.Empty });
         }
      }
   }


   public class Test
   {
      List<Delegate> FindRegisteredDelegates(A instanceRegisteringEvents, B instanceWithEventHandler, string sEventName)
      {
         A a = instanceRegisteringEvents;
         B b = instanceWithEventHandler;

         //Lets assume that we know that we are looking for a private instance field with name sEventName ("TheEvent"), 
         //i.e the event handler does not implement add/remove.
         //(otherwise we would need more reflection to determine what we are looking for)
         BindingFlags filter = BindingFlags.Instance | BindingFlags.NonPublic;

         //Lets assume that TheEvent does not implement the add and remove methods, in which case
         //the name of the relevant field is just the same as the event itself
         string sName = sEventName; //("TheEvent")

         FieldInfo fieldTheEvent = b.GetType().GetField(sName, filter);

         //The field that we get has type EventHandler and can be invoked as in ExampleInvokeTheEvent
         EventHandler eh = (EventHandler)fieldTheEvent.GetValue(b);

         //If the event handler is null then nobody has registered with it yet (just return an empty list)
         if (eh == null) return new List<Delegate>();


         List<Delegate> dels = new List<Delegate>(eh.GetInvocationList());

         //Only return those elements in the invokation list whose target is a.
         return dels.FindAll(delegate(Delegate del) { return Object.ReferenceEquals(del.Target, a); });
      }

      public void Run()
      {
         A a = new A();

         //We would need to check the set of delegates returned before we call this

         //Lets assume we know how to find the all instances of B that A has registered with
         //For know, lets assume there is just one in the field m_b of A.
         FieldInfo fieldB = a.GetType().GetField("m_b", BindingFlags.Instance | BindingFlags.NonPublic);
         B b = (B)fieldB.GetValue(a);

         //Now we can find out how many times a.RegisterEventHandlers is registered with b
         List<Delegate> delsBefore = FindRegisteredDelegates(a, b, "TheEvent");

         a.RegisterEventHandlers();

         List<Delegate> delsAfter = FindRegisteredDelegates(a, b, "TheEvent");

         List<Delegate> delsAdded = new List<Delegate>();
         foreach (Delegate delAfter in delsAfter)
         {
            bool inBefore = false;
            foreach (Delegate delBefore in delsBefore)
            {
               if ((delBefore.Method == delAfter.Method)
                  && (Object.ReferenceEquals(delBefore.Target, delAfter.Target)))
               {
                  //NOTE: The check for Object.ReferenceEquals(delBefore.Target, delAfter.Target) above is not necessary 
                  //     here since we defined FindRegisteredDelegates to only return those for which .Taget == a)

                  inBefore = true;
                  break;
               }
            }
            if (!inBefore) delsAdded.Add(delAfter);
         }

         Debug.WriteLine("Handlers added to b.TheEvent in a.RegisterEventHandlers:");
         foreach (Delegate del in delsAdded)
         {
            Debug.WriteLine(del.Method.Name);
         }


      }
   }

Answer 4

Я не думаю, что у moq есть такая возможность - если вы готовы приобрести инструмент, я предлагаю вам использовать Typemock Isolator , который может проверить, что был вызван любой метод объекта - включая обработчик событий - посмотрите на ссылку .

Answer 5

Я не знаю много о модульном тестировании, но, возможно, эта ссылка может дать вам некоторые идеи. Обратите внимание, что ключевое слово virtual также работает там.