Verifica registrazione evento tramite Moq

Question

Sto sviluppando un'applicazione asp.net (classica) che tenta di implementare il pattern MVP using this example. Nel tentativo di unità di testare il mio presentatore e utilizzando il seguente modello, la psuedocodarlo per il quale assomiglia in modo

//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); 

Come faccio a verificare che il presentatore sta facendo ciò che è previsto vale a dire la registrazione per gli eventi Init e carico? Anche se questo è fatto facilmente nel Phil Haack's example usando Rhino prende in giro ...

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

... come possiamo farlo usando MOQ?

Answer 1

Sembrerebbe che questa funzionalità sia not currently available in moq, ma potrebbe apparire in una versione futura (ho avuto un aspetto nella versione 4.0.812.4 beta, ma non sembra esserci).

Può valere la pena di porre la domanda "perché SomePresenter è necessario sottoscrivere gli eventi Load e Init della Visualizzazione?" Presumibilmente è perché la classe SomePresenter deve rispondere a quegli eventi. Quindi potrebbe essere preferibile utilizzare il metodo Raise su Mock<IView> per aumentare gli eventi Load e Init e quindi asserire che SomePresenter ha fatto la cosa giusta in risposta a loro.

Answer 2

ho trascorso qualche tempo a questa domanda e la soluzione che sto utilizzando nel mio progetto è: prova

Unità:

// 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()); 

metodo collaudato:

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

Quindi, prima devi prendere in giro i metodi a cui assegnerai gli eventi, dopo che avrai chiamato me thod che vuoi testare e infine aumentare tutti gli eventi sottoscritti. Se l'evento è realmente sottoscritto, è possibile verificare con Moq se viene chiamato il metodo assegnato.

GLHF!

Answer 3

So che forse è troppo tardi per #Dilip, ma questa risposta può essere utile per coloro che stanno cercando di fare lo stesso. Ecco la classe di test

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 è un decoratore implementato come segue (prestare attenzione a Eventi: Init/Load {aggiungere, togliere}):

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(); 
    } 
}