Exemple de test simple piloté par les données
Cette section décrit plusieurs exemples de tests pilotés par les données et décrit des fonctionnalités spécifiques dans chaque exemple.
Le premier exemple est un test piloté par les données de base, appelé SimpleDataDrivenExample.
Dans l’exemple managé, vous trouverez un fichier XML qui ressemble à ceci :
1 <?xml version="1.0"?>
2 <Data>
3 <Table Id="Table1">
4 <ParameterTypes>
5 <ParameterType Name="Size">Int32</ParameterType>
6 <ParameterType Name="Color">String</ParameterType>
7 </ParameterTypes>
8 <Row>
9 <Parameter Name="Size">4</Parameter>
10 <Parameter Name="Color">White</Parameter>
11 </Row>
12 <Row>
13 <Parameter Name="Size">10</Parameter>
14 <Parameter Name="Color">Black</Parameter>
15 </Row>
16 <Row>
17 <Parameter Name="Size">9</Parameter>
18 <Parameter Name="Color">Orange</Parameter>
19 </Row>
20 <Row>
21 <Parameter Name="Size">9</Parameter>
22 <Parameter Name="Color">Blue</Parameter>
23 </Row>
24 </Table>
25 </Data>
Ce fichier XML définit les paramètres de données que notre test piloté par les données doit utiliser. Le nœud XML supérieur est la <balise Data> , qui peut contenir une ou plusieurs <balises Table> définies dans celle-ci. Chaque table doit être associée à un attribut « ID » unique. Les fonctions de test utilisent la valeur DE l’ID de table pour identifier la table particulière qu’elles utiliseront dans le fichier XML.
Dans la <balise Table>, vous avez une section ParameterTypes> facultative<. Ici, vous pouvez spécifier explicitement le type de données d’un paramètre donné à l’aide <des balises ParameterTypes> . Dans l’exemple ci-dessus, vous spécifiez explicitement que le paramètre « Size » est de type « Int32 » et que le paramètre « Color » est une chaîne. Pour résumer : la section ParameterTypes est facultative. Par défaut, si les informations de type de paramètre ne sont pas fournies, elles sont enregistrées sous forme de chaîne.
Si vous comparez les exemples Managé et Natif, vous remarquerez que la seule différence entre les deux est le <bloc ParameterTypes> . Le fichier XML natif spécifie size to be of the native integer type « int » et utilise le type par défaut WEX::Common::String comme type pour Color en ne le spécifiant pas. Pour votre commodité, l’exemple suivant montre le fichier XML de l’exemple natif.
1 <?xml version="1.0"?>
2 <Data>
3 <Table Id="SimpleTable">
4 <ParameterTypes>
5 <ParameterType Name="Size">int</ParameterType>
6 </ParameterTypes>
7 <Row>
8 <Parameter Name="Size">4</Parameter>
9 <Parameter Name="Color">White</Parameter>
10 </Row>
11 <Row>
12 <Parameter Name="Size">10</Parameter>
13 <Parameter Name="Color">Black</Parameter>
14 </Row>
15 <Row>
16 <Parameter Name="Size">9</Parameter>
17 <Parameter Name="Color">Orange</Parameter>
18 </Row>
19 <Row>
20 <Parameter Name="Size">9</Parameter>
21 <Parameter Name="Color">Blue</Parameter>
22 </Row>
23 </Table>
24 </Data>
Les types de paramètres pris en charge dans le code natif et le code managé sont répertoriés dans Types de paramètres dans les sources de données table.
Si un autre type de données est spécifié, le test lève un avertissement et le considère comme une chaîne.
Pour en revenir aux fichiers XML, après le <bloc ParameterTypes> dans les deux fichiers XML, vous disposez d’un jeu identique de <Lignes>, qui correspondent chacune à un ensemble de données dans nos exemples managés et natifs. Dans ce cas particulier, vous avez 4 jeux de données définis au moyen de 4 <blocs de ligne> , chacun spécifiant les valeurs des paramètres à l’aide <des balises de paramètre> .
Cela couvre les principes de base essentiels des différentes parties du fichier source de données. Voyons maintenant comment récupérer les valeurs que vous avez spécifiées dans le fichier XML ci-dessus.
Création d’un test pour être un test piloté par les données
Maintenant que les données sont spécifiées, vous avez besoin d’un moyen d’associer le code ou la méthode de test qui consommera les données avec ces données dans un fichier XML. Pour ce faire, dans les exemples managés et natifs, vous spécifiez les métadonnées « DataSource ». Les métadonnées DataSource sont en trois parties :
- 'Table:' : identifie la source de données comme étant une table XML.
- « DataDrivenTests.xml » : il s’agit du fichier qui contient la table XML.
- '#Table2' : après le délimètre '#', la valeur 'Table2' identifie la table particulière dans le document XML à utiliser. Une seule source de données Table XML peut contenir plusieurs tables. TAEF recherche dans le fichier XML un élément Table avec un attribut « Id » qui correspond à la valeur spécifiée.
Encore une fois, examinons rapidement le code qui couvre les aspects ci-dessus.
Code natif
1 class SimpleDataDrivenExample
2 {
3 BEGIN_TEST_CLASS(SimpleDataDrivenExample)
4 TEST_CLASS_PROPERTY(L"Description", L"Simple example in table-based data-driven tests")
5 END_TEST_CLASS()
6
7 TEST_METHOD_CLEANUP(TestCleanup);
8 TEST_METHOD_SETUP(TestSetup);
9
10 BEGIN_TEST_METHOD(DataDrivenTest)
11 TEST_METHOD_PROPERTY(L"DataSource", L"Table:SimpleDataDrivenExample.xml#SimpleTable")
11 END_TEST_METHOD()
12 ...
Code managé
1 [TestMethod]
2 [DataSource("Table:CSharpDataDrivenSimpleExample.xml#SimpleTable")]
3 public void DataDrivenTest()
4 {
5 ...
6 }
« DataSource » est une propriété connue dans Microsoft.VisualStudio.TestTools.UnitTesting.
En plus de ce qui précède, vous avez besoin d’étapes supplémentaires pour les tests pilotés par les données dans le code managé. Vous devez également définir une propriété TestContext privée. Pour plus d’informations, consultez Classe TestContext. Vous définissez également des évaluateurs publics pour cette propriété. En interne, TAEF définit cette propriété TestContext afin que vous puissiez accéder aux données via celle-ci. Examinons rapidement cette partie du code :
1 public TestContext TestContext
2 {
3 get;
4 set;
5 }
Récupération de données dans la méthode Test
Les API de récupération sont différentes dans le code managé et natif. Commençons par comprendre l’API de récupération native :
1 void SimpleDataDrivenExample::DataDrivenTest()
2 {
3 int size;
4 if (SUCCEEDED(TestData::TryGetValue(L"size", size)))
5 {
6 VERIFY_ARE_NOT_EQUAL(size, 0);
7 Log::Comment(String().Format(L"Size retrieved was %d", size));
8 }
9
10 String color;
11 if (SUCCEEDED(TestData::TryGetValue(L"color", color)))
12 {
13 Log::Comment(L"Size retrieved was " + color);
14 }
15
16 unsigned int index;
17 if (SUCCEEDED(TestData::TryGetValue(L"index", index)))
18 {
19 Log::Comment(String().Format(L"At index %d", index));
20 }
21 }
Portez une attention particulière aux lignes 4, 11 et 17. Avant chacune de ces lignes, définissez une variable locale pour enregistrer les données que vous allez récupérer. Il est important d’obtenir le type juste ici. Étant donné que vous avez défini « Size » comme un type « int » dans le fichier XML, vous devez définir une variable locale de type int pour la récupérer. L’API de récupération prend le nom du paramètre à récupérer sous la forme d’une valeur String comme premier paramètre. Le deuxième paramètre est la variable locale transmise par référence et définie par le code TAEF.
Cette API de récupération est définie dans TestData.h et incluse par l’en-tête WexTestClass.h inclus dans tous les tests TAEF.
Pour récupérer les données dans le code managé, utilisez la propriété TestContext que vous avez définie. Examinez le code ci-dessous (ou dans l’exemple) :
1 public void DataDrivenTest()
2 {
3 int size = (int)m_testContext.DataRow["Size"];
4 Verify.AreNotEqual(size, 0);
5 Log.Comment("Size is " + size.ToString());
6
7 Log.Comment("Color is " + m_testContext.DataRow["Color"]);
8 UInt32 index = (UInt32)m_testContext.DataRow["Index"];
9 Log.Comment("At index " + index.ToString());
10 }
Si vous connaissez VSTS, vous constaterez que l’exemple ci-dessus est similaire. Utilisez DataRow et spécifiez le nom de la colonne comme nom du paramètre que vous essayez de récupérer.
Si vous regardez dans l’exemple, il existe également un test non piloté par les données dans la même classe. En d’autres termes, vous avez la possibilité de combiner des tests DataDriven et NonDataDriven dans la même classe de test.
Exécution de SimpleDataDrivenExample avec TAEF
Assurez-vous que vous savez comment créer des tests pilotés par les données et comment exécuter des tests avec TAEF avant de commencer avec des conseils et des astuces pour exécuter DataDrivenTests avec TAEF. Il peut être utile d’actualiser votre mémoire sur le fonctionnement de La sélection avec TAEF.
L’invite de commandes pour l’exécution de tests pilotés par les données n’est pas très différente de l’exécution d’un test générique avec TAEF. Pour exécuter les deux exemples (natifs et managés) décrits ci-dessus, exécutez simplement la commande suivante :
TE.exe Examples\CPP.DataDriven.Example.dll Examples\CSharp.DataDriven.Example.dll /name:*Simple*
Le « /name » ajoute un critère de sélection basé sur le nom et choisit uniquement les classes qui vous intéressent. Pour sélectionner les tests à exécuter à partir des classes, vous devez d’abord répertorier toutes les propriétés de la dll. Ensuite, vous pouvez décider quelles propriétés utiliser pour les critères de sélection.
TE.exe Examples\CPP.DataDriven.Example.dll Examples\CSharp.DataDriven.Example.dll /name:*Simple* /listproperties
f:\Examples\CPP.DataDriven.Example.dll
WEX::TestExecution::Examples::SimpleDataDrivenExample
Property[Description] = Simple example in table-based data-driven tests
WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#0
Setup: TestSetup
Teardown: TestCleanup
Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable
Data[Color] = White
Data[Size] = 4
WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#1
Setup: TestSetup
Teardown: TestCleanup
Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable
Data[Color] = Black
Data[Size] = 10
WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#2
Setup: TestSetup
Teardown: TestCleanup
Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable
Data[Color] = Orange
Data[Size] = 9
WEX::TestExecution::Examples::SimpleDataDrivenExample::DataDrivenTest#3
Setup: TestSetup
Teardown: TestCleanup
Property[DataSource] = Table:SimpleDataDrivenExample.xml#SimpleTable
Data[Color] = Blue
Data[Size] = 9
WEX::TestExecution::Examples::SimpleDataDrivenExample::FirstNonDataDrivenTest
Setup: TestSetup
Teardown: TestCleanup
WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet0
Setup: TestSetup
Teardown: TestCleanup
Property[Data:Color] = {Purple, Maroon, Brown}
Data[Color] = Purple
WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet1
Setup: TestSetup
Teardown: TestCleanup
Property[Data:Color] = {Purple, Maroon, Brown}
Data[Color] = Maroon
WEX::TestExecution::Examples::SimpleDataDrivenExample::SetsOfDataTest#metadataSet2
Setup: TestSetup
Teardown: TestCleanup
Property[Data:Color] = {Purple, Maroon, Brown}
Data[Color] = Brown
WEX::TestExecution::Examples::SimpleDataDrivenExample::SecondNonDataDrivenTest
Setup: TestSetup
Teardown: TestCleanup
f:\Examples\CSharp.DataDriven.Example.dll
WEX.Examples.CSharpDataDrivenSimpleExample
Setup: MyClassInitialize
Property[Description] = Simple example in table-based data-driven tests
WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#0
Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable
Data[Color] = White
Data[Size] = 4
WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1
Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable
Data[Color] = Black
Data[Size] = 10
WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#2
Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable
Data[Color] = Orange
Data[Size] = 9
WEX.Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#3
Property[DataSource] = Table:CSharpDataDrivenSimpleExample.xml#SimpleTable
Data[Color] = Blue
Data[Size] = 9
WEX.Examples.CSharpDataDrivenSimpleExample.NonDataDrivenTest
WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet0
Property[Data:Color] = {Red, Green, Blue}
Data[Color] = Red
WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet1
Property[Data:Color] = {Red, Green, Blue}
Data[Color] = Green
WEX.Examples.CSharpDataDrivenSimpleExample.SetsOfMetadataTest#metadataSet2
Property[Data:Color] = {Red, Green, Blue}
Data[Color] = Blue
Pour l’instant, nous allons ignorer les éléments SetsOfMetadataTest et SetsOfDataTest répertoriés ci-dessus. Si vous êtes curieux d’en savoir plus, consultez test piloté par les données légères. Maintenant que vous connaissez les différentes propriétés et le nom et les valeurs des paramètres de données, vous pouvez sélectionner des tests spécifiques en fonction de cela. Essayez-les et suivez-les pour confirmer ce que vous sélectionnez.
Pour exécuter uniquement les tests non pilotés par les données, exécutez :
TE.exe Examples\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' And not(@DataSource=*) »
À présent, pour exécuter uniquement les tests pilotés par les données, où la couleur est spécifiée comme « Noir », exécutez :
TE.exe Examples\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' and @Data:Color='Black' »
Comme vous l’avez fait avec « Color », @Data:<DataDrivenParameterName>=<DataDrivenParameterValue> exécute des données spécifiques en fonction de la valeur du paramètre DataDriven spécifiée. Dans le cas ci-dessus, il exécute WEX::TestExecution::Examples:SimpleDataDrivenExample::D ataDrivenTest#1 et WEX. Examples.CSharpDataDrivenSimpleExample.DataDrivenTest#1
Notez les index de test dans la listepropriétés ci-dessus. Vous pouvez également sélectionner l’élément ci-dessus en fonction de l’index.
TE.exe Examples\CSharp.DataDriven.Example.dll Examples\CPP.DataDriven.Example.dll /select:"@Name='*Simple*' and @Data:Index=1»
Le fichier ci-dessus exécute les deux mêmes tests que @Data:Color=« Noir » sélectionnés. Vous ajoutez même des gardes à la sélection d’index avec @Data:Index > lowerGuardValue et @Data:index< upperGuardValue
Si vous comprenez les principes de base des tests pilotés par les données avec TAEF, suivez la classe suivante dans les mêmes exemples : Substitution de métadonnées au niveau de la ligne, Spécification des types de paramètres de tableau.