Mocking usando 'tradizionale' Record/Replay vs Moq modello

Question

Sono nuovo per i mock e sto decidendo su un modello finto. Le citazioni Moq home

Attualmente, è l'unico beffardo libreria che va contro i generalizzate e un po 'poco intuitiva (soprattutto per i novizi) Record/Risposta approccio da tutti gli altri quadri.

Qualcuno può spiegare semplicemente qual è l'approccio Record/Replay e come Moq è diverso? Quali sono i pro e i contro di ciascuno in particolare dal punto di decidere un quadro?

Grazie.

Answer 1

L'approccio di registrazione/riproduzione è supportato da RhinoMocks. L'idea di base è che l'esecuzione del test è divisa in due fasi, la fase di registrazione e la fase di riproduzione. Per essere un po 'più concreto

var repo = new MockRepository(); 
var dependency = repo.DynamicMock<IDependency>(); 
With.Mocks(repo).Expecting(delegate { 
     Expect.Call(dependency.AMethod(1)).Return(result);      
     }).Verify(delegate { 
     var sut = new Sut(wrappee); 
     sut.DoStuffThatCallsAMethod(); 
     Assert.IsTrue(sut.ResultState); 
     }); 

Quindi il blocco Prevedendo è la fase di registrazione e il blocco di verifica è la fase di riproduzione.

La variante Moq di questo codice sarebbe

var dependency = new Mock<IDependency>(); 
dependency.Expect(dep => dep.AMethod(1)).Returns(result);   
var sut = new Sut(wrappee.Object); 
sut.DoStuffThatCallsAMethod(); 
Assert.IsTrue(sut.ResultState); 

che come potete vedere è molto più bello da leggere. Ho usato RhinoMocks ma da quando ho scoperto Moq uso solo Moq. Trovo che sia un codice molto più leggibile. Quindi il mio consiglio sarebbe di andare per Moq.

Answer 2

Sono andato subito fuori Record/Replay perché rende difficile vedere nel setup cosa è stato stordito/deriso o solo codice in esecuzione. Credo che Rhino abbia diversi modi di lavorare. In particolare, è possibile utilizzare un blocco using() per isolare l'installazione da altre chiamate.

Answer 3

RhinoMocks è in realtà molto versatile, è possibile utilizzare entrambi gli approcci. RhinoMocks ha un aspetto leggermente migliore di Moq sotto lo stile expect/verify. Tuttavia, anche il fatto che tu possa usare questo stile è sepolto nella documentazione (l'ultima volta che ho guardato). Abbiamo scelto Moq su RhinoMocks sul mio attuale progetto perché non ci siamo resi conto che lo ha configurato/verificato.

La sintassi record/replay consente di modificare il valore restituito da un metodo nelle chiamate successive a tale metodo. Questo può essere utile a volte. Detto questo, la necessità di farlo è spesso un odore del fatto che il tuo design non è del tutto corretto. È utile anche quando riesci a vedere cosa c'è di sbagliato e devi andare avanti.

Moq ha la capacità di modificare il valore ma è un po 'goffo (dalla documentazione)

// returning different values on each invocation 
var mock = new Mock<IFoo>(); 
var calls = 0; 
mock.Setup(foo => foo.GetCountThing()) 
.Returns(() => calls) 
.Callback(() => calls++);