Moq: Come arrivare ad un parametro passato a un metodo di un servizio deriso

Question

Immaginate questa classe

public class Foo { 

    private Handler _h; 

    public Foo(Handler h) 
    { 
     _h = h; 
    } 

    public void Bar(int i) 
    { 
     _h.AsyncHandle(CalcOn(i)); 
    } 

    private SomeResponse CalcOn(int i) 
    { 
     ...; 
    } 
} 

Mo (q) cking Handler in una prova di Foo, come vorrei essere in grado di controllare ciò che Bar() è passato a _h.AsyncHandle?

Answer 1

È possibile utilizzare il metodo di Mock.Callback-:

var mock = new Mock<Handler>(); 
SomeResponse result = null; 
mock.Setup(h => h.AnsyncHandle(It.IsAny<SomeResponse>())) 
    .Callback<SomeResponse>(r => result = r); 

// do your test 
new Foo(mock.Object).Bar(22); 
Assert.NotNull(result); 

Se si vuole solo controllare qualcosa di semplice sul passato in argomento, è anche possibile farlo direttamente:

mock.Setup(h => h.AnsyncHandle(It.Is<SomeResponse>(response => response != null))); 

Answer 2

Gamlor di risposta funziona, ma un altro modo di farlo (e uno che considero più espressivo nel test) è ...

var mock = new Mock<Handler>(); 
var desiredParam = 47; // this is what you want to be passed to AsyncHandle 
new Foo(mock.Object).Bar(22); 
mock.Verify(h => h.AsyncHandle(desiredParam), Times.Once()); 

La verifica è molto potente e vale la pena prendersi il tempo per abituarsi.

Answer 3

È possibile utilizzare il Matcher It.Is<TValue>().

var mock = new Mock<Handler>(); new Foo(mock.Object).Bar(22); mock.Verify(h => h.AsyncHandle(It.Is<SomeResponse>(r => r != null)));

Answer 4

risposta di Gamlor lavorato per me, ma ho pensato di ampliare il commento di John Carpenter, perché ero alla ricerca di una soluzione che comprenda più di un parametro. Ho pensato che le altre persone che si imbattessero in questa pagina potrebbero trovarsi in una situazione simile. Ho trovato queste informazioni nel Moq documentation.

Userò l'esempio di Gamlor, ma supponiamo che il metodo AsyncHandle utilizzi due argomenti: uno string e un oggetto SomeResponse.

var mock = new Mock<Handler>(); 
string stringResult = string.Empty; 
SomeResponse someResponse = null; 
mock.Setup(h => h.AsyncHandle(It.IsAny<string>(), It.IsAny<SomeResponse>())) 
    .Callback<string, SomeResponse>((s, r) => 
    { 
     stringResult = s; 
     someResponse = r; 
    }); 

// do your test 
new Foo(mock.Object).Bar(22); 
Assert.AreEqual("expected string", stringResult); 
Assert.IsNotNull(someResponse); 

Fondamentalmente è solo bisogno di aggiungere un altro It.IsAny<>() con il tipo appropriato, aggiungere un altro tipo al metodo Callback, e cambiare l'espressione lambda a seconda dei casi.