Groupes d’exécution

Article
06/15/2023

Vérifiez que vous êtes familiarisé avec l’exécution de base de TAEF et que vous savez comment créer des tests à l’aide de celui-ci, avant de passer à cette section. Vous pouvez également suivre un exemple de procédure pas à pas de test piloté par les données répertorié dans le Guide de l’utilisateur.

Test basé sur des scénarios avec TAEF

Lorsque vous parlez de tests au niveau du scénario, vous parlez en fait d’une série de tests, où l’exécution du test suivant n’a de sens que si le test précédent dans le scénario a réussi. Dans certains cas, vous ne disposez peut-être même pas de toutes les informations dont vous avez besoin pour exécuter le test suivant si le test précédent a échoué. À cette fin, tout en conservant l’unité d’exécution comme méthode de test et en autorisant les scénarios de test, TAEF prend en charge ce que l’on appelle « ExecutionGroup ». Vous pouvez avoir des tests basés sur des scénarios dans TAEF tout en ayant d’autres fonctionnalités telles que les tests pilotés par les données. Si vous concevez votre scénario pour tirer parti des tests pilotés par les données, vous pouvez appliquer la prise en charge pilotée par les données au niveau de la classe à l’aide de la fonctionnalité de classe pilotée par les données offerte par TAEF. En appliquant la prise en charge pilotée par les données au niveau de la classe, vous pouvez exécuter tous les tests au sein de votre classe de manière séquentielle pour chaque ligne.

Cette page se concentre sur la façon de spécifier une séquence de tests au sein d’une classe en tant que « ExecutionGroup ».

Groupes d’exécution

Avant d’aborder les groupes d’exécution, il est important de noter et de se rappeler que dans TAEF, l’ordre d’exécution des tests au sein d’une classe est l’ordre dans lequel vous les avez qualifiés en tant que TEST_METHOD (...) dans le cas de code natif, ou ajouté la propriété [TestMethod] avant la méthode en cas de code managé. TAEF ne garantit pas l’ordre d’exécution des classes elles-mêmes.

Désormais, dans les tests basés sur des scénarios, il peut ne pas suffire de garantir simplement l’ordre d’exécution, vous devez également garantir que tous les tests précédents dans le scénario ont réussi avant de passer au test suivant dans le scénario. C’est là que vous trouverez le concept de « ExecutionGroup » pour être utile.

Prenons un exemple natif :

1     class ExecutionDependencyExample
2     {
3         BEGIN_TEST_CLASS(ExecutionDependencyExample)
4             TEST_CLASS_PROPERTY(L"ExecutionGroup", L"DependentTests")
5         END_TEST_CLASS()
6
7         TEST_METHOD(Test1)
8         {
9             Log::Comment(L"Test1 passes.");
10        }
11
12        TEST_METHOD(Test2)
13        {
14            Log::Comment(L"Test2 fails.");
15            VERIFY_ARE_EQUAL(2, 3);
16        }
17
18        TEST_METHOD(Test3)
19        {
20            Log::Comment(L"Test3 is blocked; so you shouldn't see this.");
21        }
22    };

Consultez la ligne 4 de l’extrait de fichier C++ ci-dessus. Dans ce cas particulier, vous qualifiez tous les tests dans la classe ExecutionDependencyExample pour appartenir à un « ExecutionGroup » appelé « DependentTests ». Cela signifie que « Test1 », « Test2 » et « Test3 » font partie du groupe d’exécution « DependentTests ». Comme mentionné précédemment, Test2 est exécuté si et uniquement si Test1 est exécuté avec succès et réussit. De même, Test3 est exécuté si et uniquement si Test2 est exécuté avec succès et réussit.

Vous verrez que Test2 a été conçu pour échouer (voir les lignes 14 et 15 ci-dessus).

Étant donné que Test2 échoue dans notre « DependentTests » « ExecutionGroup », Test3 n’est pas exécuté et est marqué comme bloqué. Essayons d’exécuter le test ci-dessus et voyons si cela est vrai.

te Examples\CPP.ExecutionDependency.Example.dll
Test Authoring and Execution Framework v2.93k for x86

StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test1
Test1 passes.
EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test1 
    [Passed]

StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2
Test2 fails.
Error: Verify: AreEqual(2, 3) - Values (2, 3) [File: >f:source\executiondependencyexample\executiondependencyexample.cpp,
Function: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2, Line:21] 
EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2[Failed] 

StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test3
Blocked: This test belongs to an execution group and depends on the previous test being executed in the same environment successfully. The dependent test must be selected for execution, must request the same execution environment (e.g. 'ThreadingModel') and must be executed successfully.
EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test3 [Blocked]

Non-passing Tests:
    WEX::TestExecution::Examples::ExecutionDependencyExample::Test2 [Failed]
    WEX::TestExecution::Examples::ExecutionDependencyExample::Test3 [Blocked]

Summary: Total=3, Passed=1, Failed=1, Blocked=1, Not Run=0, Skipped=0

Notez que, comme prévu, Test1 a réussi, Test2 a échoué et Test3 a été bloqué. Avec Test3, TAEF enregistre un message indiquant que Test3 appartient à un groupe d’exécution et que le test précédent n’a pas été exécuté correctement.

Ce message d’erreur indique également que tous les tests avant l’exécution du test actuel qui appartiennent au même Groupe d’exécution doivent être sélectionnés. En d’autres termes, si vous essayez d’exécuter uniquement Test2 à l’aide d’un critère de sélection au moment de l’exécution, vous constaterez que Test2 sera bloqué, car son exécution dépend de Test1, faisant partie du même Groupe d’exécution.

te Examples\CPP.ExecutionDependency.Example.dll /name:*Test2*
Test Authoring and Execution Framework v2.9.3k for x86

StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2
Blocked: This test belongs to an execution group and depends on the previous test being executed in the same environment successfully. The dependent test must be selected for execution, must request the same execution environment (e.g. 'ThreadingModel') and must be executed successfully.

EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test2 [Blocked]

Summary: Total=1, Passed=0, Failed=0, Blocked=1, Not Run=0, Skipped=0

Si toutefois, vous sélectionnez Test1, qui est le premier test dans ExecutionGroup, il s’exécutera correctement.

te Examples\CPP.ExecutionDependency.Example.dll /name:*Test1*
Test Authoring and Execution Framework v2.9.3k for x86
StartGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test1
Test1 passes.
EndGroup: WEX::TestExecution::Examples::ExecutionDependencyExample::Test1 [Passed]

Summary: Total=1, Passed=1, Failed=0, Blocked=0, Not Run=0, Skipped=0

En outre, si vous avez des tests qui n’appartiennent pas à ExecutionGroup, ils sont exécutés quel que soit le résultat d’exécution des tests dans le groupe d’exécution qui les effectue. Il est également possible d’avoir plusieurs ExecutionGroup dans une classe. Notez toutefois que ExecutionGroup ne peut pas s’étendre à plusieurs classes. Si vous procédez ainsi, ils seront plutôt considérés comme deux ExecutionGroups distincts, un dans chaque classe.

Le message indique également que Test3 doit être exécuté dans le même environnement que Test2. Essayons de comprendre cet aspect un peu plus en détail. Étant donné que faire partie d’un ExecutionGroup signifie vraiment faire partie du test basé sur un scénario, il devient essentiel que tous les tests demandent et s’exécutent donc dans le même environnement. Par instance, si le modèle de threading change dans un ExecutionGroup, vous verrez des tests bloqués. Si, par exemple, dans l’exemple ci-dessus, Test2 a été conçu pour s’exécuter correctement, mais que la propriété « ThreadingModel » était définie sur « MTA », Test3 serait toujours bloqué.

Prenons un autre exemple : Examples\TAEF\CSharp\ExecutionDependentGroupsExample (reportez-vous au dernier partage de version TAEF)

1     [TestClass]
2     public class CSharpExecutionDependentGroupsExample
3     {
4         //First Execution Group: Test1, Test2
5         [TestMethod]
6         [TestProperty("ExecutionGroup", "First Execution Group")]
7         public void Test1()
8         {
9             Log.Comment("Part of First Execution Group");
10        }
11        [TestMethod]
12        [TestProperty("ExecutionGroup", "First Execution Group")]
13        public void Test2()
14        {
15            Log.Comment("Part of First Execution Group");
16        }
17
18        //Second Execution Group: Test3, Test4. Test4 fails
19        [TestMethod]
20        [TestProperty("ExecutionGroup", "Second Execution Group")]
21        public void Test3()
22        {
23            Log.Comment("Part of Second Execution Group");
24        }
25        [TestMethod]
26        [TestProperty("ExecutionGroup", "Second Execution Group")]
27        public void Test4()
28        {
29            Log.Comment("Part of Second Execution Group - last in group fails");
30            Verify.IsTrue(false);
31        }
32
33        //Third Execution Group: Test5, Test6, Test7. Test6 fails, Test7 will be blocked.
34        [TestMethod]
35        [TestProperty("ExecutionGroup", "Third Execution Group")]
36        public void Test5()
37        {
38            Log.Comment("Part of Third Execution Group");
39        }
40        [TestMethod]
41        [TestProperty("ExecutionGroup", "Third Execution Group")]
42        public void Test6()
43        {
44            Log.Comment("Part of Third Execution Group - middle in this set of 3 fails");
45            Verify.IsTrue(false);
46        }
47        [TestMethod]
48        [TestProperty("ExecutionGroup", "Third Execution Group")]
49        public void Test7()
50        {
51            Log.Comment("Part of Third Execution Group");
52        }
53
54        //Fourth Execution Group: Test8, Test9
55        [TestMethod]
56        [TestProperty("ExecutionGroup", "Fourth Execution Group")]
57        public void Test8()
58        {
59            Log.Comment("Part of Fourth Execution Group");
60        }
61        [TestMethod]
62        [TestProperty("ExecutionGroup", "Fourth Execution Group")]
63        public void Test9()
64        {
65            Log.Comment("Part of Fourth Execution Group");
66        }
67    }

Cet exemple comporte 4 groupes d’exécution différents :

« First Execution Group » contient Test1, Test2 ; les deux qui doivent réussir.
« Second Execution Group » contient Test3 et Test4. Test4 est le dernier test de ce ExecutionGroup et échoue.
Le « troisième groupe d’exécution » contient Test5, Test6 et Test7. Test5 s’exécute et réussit bien que Test4 du groupe d’exécution précédent ait échoué. Test6 est conçu pour échouer, ce qui entraîne le blocage de Test7.
« Quatrième groupe d’exécution » contient Test8 et Test9. Une fois de plus, bien que Test7 du groupe d’exécution précédent ait été bloqué en raison de l’échec de Test6, Test8 s’exécutera correctement, tout comme Test9.

Pour mieux comprendre les ExecutionGroups de cet exemple, nous allons répertorier les propriétés de cet exemple.

te Examples\CSharp.ExecutionDependentGroups.Example.dll /listproperties
Test Authoring and Execution Framework v2.9.3k for x86

        F:\ \Examples\CSharp.ExecutionDependentGroups.Example.dll
            WEX.Examples.CSharpExecutionDependentGroupsExample
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test1
                        Property[ExecutionGroup] = First Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test2
                        Property[ExecutionGroup] = First Execution Group

                WEX.Examples.CSharpExecutionDependentGroupsExample.Test3
                        Property[ExecutionGroup] = Second Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test4
                        Property[ExecutionGroup] = Second Execution Group

                WEX.Examples.CSharpExecutionDependentGroupsExample.Test5
                        Property[ExecutionGroup] = Third Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test6
                        Property[ExecutionGroup] = Third Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test7
                        Property[ExecutionGroup] = Third Execution Group

                WEX.Examples.CSharpExecutionDependentGroupsExample.Test8
                        Property[ExecutionGroup] = Fourth Execution Group
                WEX.Examples.CSharpExecutionDependentGroupsExample.Test9
                        Property[ExecutionGroup] = Fourth Execution Group

Lorsque vous exécutez le test ci-dessus, la sortie suivante confirme l’ordre d’exécution prédit.

te Examples\CSharp.ExecutionDependentGroups.Example.dll
Test Authoring and Execution Framework v2.9.3k for x86

StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test1

Part of First Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test1 [Passed]
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test2

Part of First Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test2 [Passed]

StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test3

Part of Second Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test3 [Passed]
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test4

Part of Second Execution Group - last in group fails
Error: Verify: IsTrue [File: Need_Symbols, Function: Test4, Line: 0] 
Error: [HRESULT: 0x80131604]. Operation failed: 'WEX.Examples.CSharpExecutionDependentGroupsExample.Test4'.
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test4 [Failed]

StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test5

Part of Third Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test5 [Passed]
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test6

Part of Third Execution Group - middle in this set of 3 fails
Error: Verify: IsTrue [File: Need_Symbols, Function: Test6, Line: 0] 
Error: [HRESULT: 0x80131604]. Operation failed: 'WEX.Examples.CSharpExecutionDependentGroupsExample.Test6'.
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test6 [Failed] 
Error: WEX.Examples.CSharpExecutionDependentGroupsExample.Test7 belongs to an execution group and depends
       on the previous test being executed in the same environment successfully.
Error: Please make sure that the dependent test is selected for execution, requests the same execution .
       environment metadata(e.g. 'ThreadingModel') and that it executed successfully.
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test7
Blocked EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test7 [Blocked]

StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test8

Part of Fourth Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test8 [Passed]
StartGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test9

Part of Fourth Execution Group
EndGroup: WEX.Examples.CSharpExecutionDependentGroupsExample.Test9 [Passed]

Failed Tests:
    WEX.Examples.CSharpExecutionDependentGroupsExample.Test4
    WEX.Examples.CSharpExecutionDependentGroupsExample.Test6

Summary: Total=9, Passed=6, Failed=2, Blocked=1, Not Run=0, Skipped=0

Notez que l’ordre d’exécution du test est celui attendu.

Partager via

Groupes d’exécution

Test basé sur des scénarios avec TAEF

Groupes d’exécution

Commentaires

Ressources supplémentaires