Verificar el registro de evento utilizando Moq

Question

Estoy desarrollando un asp.net (clásico) de la aplicación, tratando de implementar el patrón MVP utilizando este ejemplo.En el intento de unidad de la prueba de mi presentador, y utilizando el modelo siguiente, el psuedocode por que se ve así

//base view interface
public interface IView
{
    event EventHandler Init;

    event EventHandler Load;

    bool IsPostBack { get; }

    void DataBind();

    bool IsValid { get;}
}

//presenter psuedo code
public class SomePresenter
{
     public SomePresenter(ISomeDomainService service, IView someView)
     {
           ...
           //HOW DO WE TEST/VERIFY THAT THIS REGISTRATION OCCURS?
           someView.Init += OnInit;
           someView.Load += OnLoad;
     }
}
...
//consuming code that exercises the above code, that needs to be tested
var presenter = new SomePresenter(someDomainService, someView);

¿Cómo puedo comprobar que el presentador está haciendo lo que se espera es decir,registrarse para el inicio y la Carga de los eventos?Mientras esto se hace fácilmente en el Phil Haack el ejemplo de el uso de Rhino mocks...

[Test]
public void VerifyAttachesToViewEvents()
{
    viewMock.Load += null;
    LastCall.IgnoreArguments();
    viewMock.PostSaved += null;
    LastCall.IgnoreArguments();
    mocks.ReplayAll();
    new PostEditController(viewMock, 
      this.dataServiceMock);
    mocks.VerifyAll();
}

...¿cómo podemos hacer esto usando MOQ?

Answer 1

Parece que esta funcionalidad es actualmente no disponibles en el moq, pero pueden aparecer en una versión futura (tenía una mirada en la 4.0.812.4 beta, pero parece ser que no hay).

Puede ser que vale la pena hacer la pregunta, "¿por qué no SomePresenter necesidad de suscribirse a la Vista Load y Init los acontecimientos?" Presumiblemente, esto es debido a que el SomePresenter las necesidades de la clase para responder a los eventos.Así que sería mejor utilizar el Raise método en su Mock<IView> para elevar el Load y Init eventos y, a continuación, afirmar que SomePresenter hizo lo correcto en respuesta a ellos.

Answer 2

Sé que tal vez sea demasiado tarde para #Dilip, pero esta respuesta puede ser útil para aquellos que intentan hacer lo mismo. Aquí está la clase de prueba

public delegate void SubscriptionHandler<T>(string name, T handler);

public class SomePresenterTest
{
    [Test]
    public void Subscription_Test()
    {
        var someServiceMock = new Mock<ISomeDomainService>();
        var viewMock = new Mock<IView>();
        //Setup your viewMock here

        var someView = new FakeView(viewMock.Object);
        EventHandler initHandler = null;            
        someView.Subscription += (n, h) => { if ((nameof(someView.Init)).Equals(n)) initHandler=h; };

        Assert.IsNull(initHandler);

        var presenter = new SomePresenter(someServiceMock.Object, someView);

        Assert.IsNotNull(initHandler);
        Assert.AreEqual("OnInit", initHandler.Method?.Name);
    }
}

FakeView es un decorador implementado de la siguiente manera (preste atención a Eventos: Init / Load {add; remove}):

public class FakeView : IView
{
    public event SubscriptionHandler<EventHandler> Subscription;
    public event SubscriptionHandler<EventHandler> Unsubscription;
    private IView _view;
    public FakeView(IView view)
    {
        Assert.IsNotNull(view);
        _view = view;
    }

    public bool IsPostBack => _view.IsPostBack;
    public bool IsValid => _view.IsValid;

    public event EventHandler Init
    {
        add
        {
            Subscription?.Invoke(nameof(Init), value);
            _view.Init += value;
        }

        remove
        {
            Unsubscription?.Invoke(nameof(Init), value);
            _view.Init -= value;
        }
    }
    public event EventHandler Load
    {

        add
        {
            Subscription?.Invoke(nameof(Load), value);
            _view.Init += value;
        }

        remove
        {
            Unsubscription?.Invoke(nameof(Load), value);
            _view.Init -= value;
        }
    }

    public void DataBind()
    {
        _view.DataBind();
    }
}

Answer 3

Pasé algún tiempo con esta pregunta y la solución que estoy usando en mi proyecto es:

Prueba de unidad:

// Arrange
TestedObject.Setup(x => x.OnEvent1());
TestedObject.Setup(x => x.OnEvent2());

// Act
TestedObject.Object.SubscribeEvents();
TestedObject.Raise(x => x.Event1 += null);
TestedObject.Raise(x => x.Event2 += null);

// Assert
TestedObject.Verify(x => x.OnEvent1(), Times.Once());
TestedObject.Verify(x => x.OnEvent2(), Times.Once());

Método probado:

this.Event1 += OnEvent1;
this.Event2 += OnEvent2;

Entonces, primero debe burlarse de los métodos a los que asignará los eventos, después de llamar al método que desea probar y finalmente generar todos los eventos suscritos. Si el evento está realmente suscrito, puede verificar con Moq si se llama al método asignado.

GLHF!