2016-05-05 18 views
8

Ich bin derzeit verwirrt, wie zu spotten.Mock.Of <Object> VS Mock <Object>()

Ich benutze Moq. Zum Mock Objekte schreibe ich normalerweise auf diese Weise

var mockIRepo = new Mock<IRepo>(); 

Allerdings muss ich Mock-Objekt für meine Einrichtung erstellen.

Option1 Ist es besser, mein Objekt zu verspotten, das nur Eigenschaften auf diese Weise enthält?

var object = Mock.Of<Object>() 

Option2 Oder diese Weise

var object = new Mock<Object>() 

ich gelesen habe, dass Option 2 setupproperties hat, die mir irgendwie fragwürdig ist, weil ich auch die Eigenschaften in Option könnte 1.

Was ist dann der Unterschied? Oder gibt es einen besseren Weg?

+1

die Antwort Hier ist - https : //cmatskas.com/improve-your-unit-tests-with-mock-of/ – niksofteng

Antwort

-2

Deshalb mag ich var Schlüsselwort für alle Variablen nicht. Die Option 2 gibt einen Mock <T> zurück, während Option 1 T zurückgibt. Im Grunde ist es nur Syntaxunterschied. Sie können Methoden auf andere Weise vortäuschen. Siehe Dokumentation.

+0

Kommentar zu negativer Rückmeldung? –

7

Dieser Beitrag half mir Mock.Of <T> zu verstehen: Old style imperative Mock<T> vs functional Mock.Of<T>

Wie erklärt in der Post, mit Mock.Of <T> Sie sagen: "Gib mir ein Modell, das so verhält" (oder Mock s. Von <T> wenn Sie viele Objekte (IEnumerable) erhalten müssen). Es macht die Deklaration eines Mocks prägnanter.

Beispiel mit Mock <T> (liefert ein Mock)

var el1 = new Mock<IElementInfo>(); 
el1.Setup(x => x.Id).Returns(Guid.NewGuid()); 
el1.Setup(x => x.Multiplicity).Returns(Multiplicity.Single); 

var c1 = new Mock<ICollectionInfo>(); 
c1.Setup(x => x.Id).Returns(Guid.NewGuid()); 
c1.Setup(x => x.Multiplicity).Returns(Multiplicity.Multiple); 

var p1 = new Mock<IPropertyInfo>(); 
p1.Setup(x => x.Id).Returns(Guid.NewGuid()); 
p1.Setup(x => x.Name).Returns("Foo" + Guid.NewGuid().ToString()); 
p1.Setup(x => x.Type).Returns("System.String"); 

var p2 = new Mock<IPropertyInfo>(); 
p2.Setup(x => x.Id).Returns(Guid.NewGuid()); 
p2.Setup(x => x.Name).Returns("Bar" + Guid.NewGuid().ToString()); 
p2.Setup(x => x.Type).Returns("System.String"); 

var elementInfoMock = new Mock<IElementInfo>(); 
elementInfoMock.Setup(e => e.Id).Returns(Guid.NewGuid()); 
elementInfoMock.Setup(e => e.Multiplicity).Returns(Multiplicity.Multiple); 
elementInfoMock.Setup(e => e.Elements) 
    .Returns(new List<IAbstractElementInfo> 
    { 
     el1.Object, 
     c1.Object, 
    }); 
elementInfoMock.Setup(x => x.Properties).Returns(
    new List<IPropertyInfo> 
    { 
     p1.Object, 
     p2.Object, 
    }); 

this.elementInfo = elementInfoMock.Object; 

Elbe Beispiel mit Mock.Of <T> (gibt eine Instanz der Klasse)

this.elementInfo = Mock.Of<IElementInfo>(x => 
x.Id == Guid.NewGuid() && 
x.Multiplicity == Multiplicity.Multiple && 
x.Elements == new List<IAbstractElementInfo> 
{ 
    Mock.Of<IElementInfo>(e => e.Id == Guid.NewGuid() && e.Multiplicity == Multiplicity.Single), 
    Mock.Of<ICollectionInfo>(e => e.Id == Guid.NewGuid() && e.Multiplicity == Multiplicity.Single), 
} && 
x.Properties == new List<IPropertyInfo> 
{ 
    Mock.Of<IPropertyInfo>(p => p.Id == Guid.NewGuid() && p.Name == "Foo" + Guid.NewGuid() && p.Type == "System.String"), 
    Mock.Of<IPropertyInfo>(p => p.Id == Guid.NewGuid() && p.Name == "Foo" + Guid.NewGuid() && p.Type == "System.String"), 
});