Mock.Of <Object> VS Mock <Object>()

Question

Attualmente sono confuso su come prendere in giro.

Sto usando Moq. Per simulare oggetti di solito scrivo in questo modo

var mockIRepo = new Mock<IRepo>(); 

Tuttavia, ho bisogno di creare oggetto mock per il mio setup.

Option1 È meglio prendere in giro il mio oggetto che contiene solo proprietà in questo modo?

var object = Mock.Of<Object>() 

Option2 O questo modo

var object = new Mock<Object>() 

Ho letto che l'opzione 2 ha setupproperties che è un pò discutibile perché ho potuto anche impostare le proprietà nell'opzione 1.

Allora qual è la differenza? O c'è un modo migliore?

Answer 1

Ecco perché non mi piace la parola chiave var per tutte le variabili. L'opzione 2 restituisce una simulazione <T> mentre l'opzione 1 restituisce T. Fondamentalmente è solo la differenza di sintassi. Puoi prendere in giro i metodi in un modo diverso. Vedi la documentazione.

Answer 2

Questo post mi ha aiutato a capire Mock.Of <T>: Old style imperative Mock<T> vs functional Mock.Of<T>

Come spiegato nel post, con Mock.Of <T> stai dicendo: "Dammi un modello che si comporta in questo modo" (o Mock s. Di <T> se è necessario ottenere molti oggetti (IEnumerable)). Rende la dichiarazione di una simulazione più concisa.

Esempio con Mock <T> (restituisce un 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; 

Stesso esempio utilizzando Mock.Of <T> (restituisce un'istanza della classe)

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"), 
});