Mock.Of VS Mock ()

Je suis actuellement confus sur la façon de se moquer.

J’utilise Moq. Pour me moquer des objects, j’écris habituellement de cette façon

var mockIRepo = new Mock(); 

Cependant, je dois créer un object fictif pour ma configuration.

Option1 Est-il préférable de se moquer de mon object qui ne contient que des propriétés de cette façon?

  var object = Mock.Of() 

Option2 ou de cette façon

  var object = new Mock() 

J’ai lu que l’option 2 a setupproperties, ce qui est un peu discutable pour moi car je pourrais aussi définir les propriétés dans l’option 1.

Alors quelle est la différence? Ou y a-t-il un meilleur moyen?

Ce billet m’a aidé à comprendre Mock.Of : Ancien style impératif Mock vs fonctionnel Mock.Of

Comme expliqué dans le post, avec Mock.Of , vous dites “Donnez-moi un mock qui se comporte comme ceci” (ou Mock s .Of si vous devez obtenir plusieurs objects (IEnumerable)). Cela rend la déclaration d’une simulation plus concise.

Exemple avec Mock (retourne un Mock)

 var el1 = new Mock(); el1.Setup(x => x.Id).Returns(Guid.NewGuid()); el1.Setup(x => x.Multiplicity).Returns(Multiplicity.Single); var c1 = new Mock(); c1.Setup(x => x.Id).Returns(Guid.NewGuid()); c1.Setup(x => x.Multiplicity).Returns(Multiplicity.Multiple); var p1 = new Mock(); p1.Setup(x => x.Id).Returns(Guid.NewGuid()); p1.Setup(x => x.Name).Returns("Foo" + Guid.NewGuid().ToSsortingng()); p1.Setup(x => x.Type).Returns("System.Ssortingng"); var p2 = new Mock(); p2.Setup(x => x.Id).Returns(Guid.NewGuid()); p2.Setup(x => x.Name).Returns("Bar" + Guid.NewGuid().ToSsortingng()); p2.Setup(x => x.Type).Returns("System.Ssortingng"); var elementInfoMock = new Mock(); elementInfoMock.Setup(e => e.Id).Returns(Guid.NewGuid()); elementInfoMock.Setup(e => e.Multiplicity).Returns(Multiplicity.Multiple); elementInfoMock.Setup(e => e.Elements) .Returns(new List { el1.Object, c1.Object, }); elementInfoMock.Setup(x => x.Properties).Returns( new List { p1.Object, p2.Object, }); this.elementInfo = elementInfoMock.Object; 

Même exemple avec Mock.Of (retourne une instance de la classe)

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

C’est pourquoi je n’aime pas le mot clé var pour toutes les variables. L’option 2 renvoie Mock , tandis que l’option 1 renvoie T. En gros, il s’agit simplement d’une différence de syntaxe. Vous pouvez vous moquer des méthodes d’une manière différente. Voir la documentation.