Sehen Sie, was an einen Mock weitergegeben wurde?

Question

Ich habe einen meist arbeitenden Unit-Test, der eine Methode überprüft, die funktioniert. Ich möchte jedoch die Parameter überprüfen, die an diese Methode übergeben werden. Mit Verify kann ich überprüfen, ob ein bestimmter Satz von Argumenten übergeben wird, aber wenn diese nicht bestanden werden und der Test fehlschlägt, gibt es eine Möglichkeit zu sehen, was tatsächlich an die Methode übergeben wurde?

Beispiel:

sut.Setup(x => x.MyMethod(It.IsAny<myClass>()).Verifiable(); 
sut.Object.DoAThing(); 
sut.Verify(x => x.MyMethod(It.Is<myClass>(v => v.thing == 1))); 

In meinem Test dieses fehlschlagen wird (v.thing etwas anderes als 1 sein wird), aber was würde Ich mag wissen, was ist v.thing Set? Ich würde gerne wissen, wie ich finde, dass diese Art von Rückmeldung beim Debuggen von Code- und Komponententests sehr hilfreich ist.

Der Fehler, den ich bekomme, ist einfach, dass x.MyMethod (mit diesen erwarteten Parametern) nie aufgerufen wurde.

Gibt es eine Lösung? vermisse ich etwas Offensichtliches?

Minimal Beispiel meines Punkt zu illustrieren:

public class myClass 
{ 
    public struct myStruct { 
     public int thing; 
    } 
    public virtual void MyMethod(myStruct x) 
    { 
     // Code goes here 
    } 
} 

public class sutClass 
{ 
    public myClass target = new myClass(); 
    public void DoAThing() 
    { 
     myClass.myStruct toBePassed = new myClass.myStruct { thing = 8 }; 

     target.MyMethod(toBePassed); 
    } 
} 

[TestMethod] 
public void Test1() 
{ 
    Mock<myClass> mMyClass = new Mock<myClass>(); 
    sutClass sut = new sutClass(); 
    sut.target = mMyClass.Object; 

    mMyClass.Setup(x => x.MyMethod(It.IsAny<myClass.myStruct>())).Verifiable(); 

    sut.DoAThing(); 

    mMyClass.Verify(x => x.MyMethod(It.Is<myClass.myStruct>(v => v.thing == 1))); 
} 

Der obige einfache Test wird natürlich Rück eines fehlschlagen.

Expected invocation on the mock at least once, but was never performed: x => x.MyMethod(It.Is<myStruct>(v => v.thing == 1)) 

Was würde ich gerne sehen, ist ein Ausgang von dem, was zu MyMethod übergeben wurde, was der Unterschied zwischen dem, was erwartet wurde, und dem, was tatsächlich passiert ist. Ähnlich wie Assert.AreEqual(expected, actual) würde zurückkehren. (die erwartete Zeichenfolge und die tatsächliche Zeichenfolge zum Beispiel).

Answer 1

Sie können einen Rückruf in Ihrem Mock Setup implementieren:

[TestMethod] 
    public void Test1() 
    { 
     Mock<myClass> mMyClass = new Mock<myClass>(); 
     sutClass sut = new sutClass(); 
     sut.target = mMyClass.Object; 

     int passedValue = 0; 

     mMyClass.Setup(x => x.MyMethod(It.IsAny<myClass.myStruct>())).Callback<myClass.myStruct>((s) => { passedValue = s.thing; Console.Write(s.thing); }); 

     sut.DoAThing(); 

     mMyClass.Verify(x => x.MyMethod(It.Is<myClass.myStruct>(v => v.thing == 1))); 
    } 

Hier wird der Wert auf passedValue gesetzt und an die Konsole