// vérifie que myList ne contient aucun item
Assert.Empty(myList);
// vérifie que myList ne contient qu'un seul item
Assert.Single(myList);
// vérifie que myList contient 2 items
Assert.Collection(
myList,
item => Assert.NotNull(item.Prop1), // vérifie que Prop1 du 1er item n'est pas null
item => Assert.Null(item.Prop1), // vérifie que Prop1 du 2ème item est null
// vérifie la propriété Prop1 n'est pas null pour tous les items de myListAssert.All(myList, item => Assert.NotNull(item.Prop1));
// vérifie qu'une liste ne contient pas une valeur
Assert.DoesNotContain(myValue, myList);
# créer la solution
md MaSolution
cd MaSolution
dotnet new sln
# créer le projet à tester
md MyProject
cd MyProject
dotnet new console
# ajouter le projet à la solutioncd ..
dotnet sln add MyProject/MyProject.csproj
# créer le projet de test
dotnet new xunit -o MyProject.Tests
# ajouter une référence au projet à tester
dotnet add reference ../MyProject/MyProject.csproj
# ajouter le projet à la solutioncd ..
dotnet sln add MyProject.Tests/MyProject.Tests.csproj
// build an item and fill it with datavaritem = Builder<Item>.CreateNew()
.Build();
// build 10 items and fill them with datavaritems = Builder<Item>.CreateListOfSize(10)
.Build();
// fill name with a static valuevaritems = Builder<Item>.CreateListOfSize(10)
.All()
.With(x => x.Name = "Name")
.Build();
// force to use the ctor with User parametervaritems = Builder<Item>.CreateListOfSize(10)
.All()
.WithFactory(() => newItem(Builder<User>.CreateNew().Build()))
.Build();
MOQ
Permet la création de Fake Object afin de remplacer les dépendances de l'objet que l'on souhaite tester.
Installer avec NuGet Moq.
// créé un fake object DataServicevarmockDataService = newMock<IDataService>();
// le fake object DataServiceIDataServicedataService = mockDataService.Object;
// appel du ctor avec la dépendance à IDataServicevarmyObj = newMyClass(dataService);
// exécution de la méthode à tester
myObj.MethodToTest();
On veut tester la méthode MethodToTest de la classe MyClass.
Cette méthode fait appel à un objet DataService que nous n'avons pas besoin de tester.
On va donc créer un mock de DataService pour permettre l'exécution de la méthode MethodToTest.
// Si MOQ n'arrive pas à accéder aux éléments internes
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
Methods
// définit ce que la méthode GetPersons renvoievarpersons = newList<Person> { /* ... */ };
mockDataService.Setup(ds => ds.GetPersons())
.Returns(() => persons);
// définit ce que la méthode GetPersonById renvoievarperson = newPerson { /* ... */ };
// avec un int positif comme argument
mockDataService.Setup(ds => ds.GetPersonById(It.Is<int>(i => i >= 0))
.Returns(() => person);
// avec un int négatif comme argument
mockDataService.Setup(ds => ds.GetPersonById(It.Is<int>(i => i < 0)))
.Throws<ArgumentException>();
// utiliser le paramètre passé en argument
mockDataService.Setup(ds => ds.GetPersonById(It.Is<int>()))
.Returns((intid) => personList[i]);
// arguments
It.IsIn(1, 2, 3);
It.IsInRange(1, 9, Range.Inclusive);
It.IsRegex("[1-9]");
Permet de renvoyer des résultats différent pour une même méthode.
mockDataService.SetupSequence(ds => ds.GetPersons())
.Returns(() => firstListOfpersons) // the first list is returned during the first call
.Returns(() => secondListOfpersons); // the second list is returned during the second call
Permet de savoir si une méthode ou une propriété a été appelée.
// vérifier que la méthode GetPersons a été appelée
mockDataService.Verify(ds => ds.GetPersons(), "Custom error message");
// vérifier que la méthode GetPersonById a été appelée avec l'argument 1
mockDataService.Verify(m => m.GetPersonById(
It.Is<int>(fn => fn.Equals(1))));
// vérifier que la méthode GetPersons a été appelée 2 fois
mockDataService.Verify(ds => ds.GetPersons(), Times.Exactly(2));
// vérifier que la méthode GetPersons n'a jamais été appelée
mockDataService.Verify(ds => ds.GetPersons(), Times.Never);
// vérifier que la propriété Persons a bien été settée
mockDataService.VerifySet(m => m.Persons = It.IsAny<IList<Person>>());
// vérifier que la propriété Persons a bien été gettée
mockDataService.VerifyGet(m => m.Persons);
Strict / Loose Mocking
Strict
lance une exception si un membre de l'objet est appelée sans avoir été définie Setup.
Loose
ne lance pas d'exceptions et retourne la valeur par défaut.
// Par défaut c'est le comportement Loose qui est utilisévarmockDataService = newMock<IDataService>(MockBehavior.Strict);
Récursive Mocking
Permet d'accéder au mock résultant d'un membre de l'objet sans avoir à le définir manuellement.
// les méthodes et propriétés retourne des mocks si possible au lieu de nullvarmockDataService = newMock<IDataService>() { DefaultValue = DefaultValue.Mock };
IMyResultresult = mockDataService.Object.MyMethod(It.IsAny<string>());
Mock<IMyResult> mockResult = Mock.Get(result);
// vérifier que IMyResult.MyOtherMethod est bien appelé lors de l'exécution de IDataService.MyMethod// sans avoir besoin de définir manuellement un mock pour IMyResult
mockResult.Verify(m => m.MyOtherMethod());
Avec DefaultValue.Mock, Moq créé automatiquement un mock pour les interfaces, les classes abstraires et les classes non-sealed.
Mock Repository
Permet de mutualiser la configuration et la vérification des mock.
varmockFactory = newMockRepository(MockBehavior.Strick) { DefaultValue = DefaultValue.Mock };
// création des mock avec la même configurationvarmockDataService1 = mockFactory.Create<IDataService1>();
varmockDataService2 = mockFactory.Create<IDataService2>();
// vérification de tous les mock en une seule ligne
mockFactory.Verify();
Even if at compile time the extension method can be found, at runtime the mocking framework will have issues trying to mock it since it doesn't belong to the ISession type.
Since it is not possible to mock extension methods, try to mock the methods called in the extension method you want to mock.