Contextes Avant (Before) et Après (After)

Dans les cas de test, les exécutions Avant (Before) et Après (After) vous permettent d'exécuter certaines actions avant et après l'exécution du cas de test. Ces contextes sont couramment utilisés pour configurer et supprimer les ressources, effectuer la journalisation et gérer l’environnement de test.

BeforeRunContext (configuration) : l'exécution Avant (Before) est utilisée pour effectuer des actions avant l'exécution principale du cas de test. Elle est souvent utilisée pour configurer l’état initial de l’environnement de test et préparer les ressources. Voici quelques cas d’utilisation courants du contexte Avant (Before) :
- Initialisation des variables ou des données requises pour le test.
- Configuration de connexions à des systèmes ou bases de données externes.
- Journalisation du début de l'exécution du test.
- Ouverture d'applications ou de pages Web avec lesquelles le test interagit.
- Configurez des exceptions spécifiques avant d’exécuter le cas de test.
AfterRunContext (nettoyage): l'exécution Après (After) est utilisée pour effectuer des actions une fois l'exécution principale du cas de test terminée. Elle est généralement utilisée pour nettoyer les ressources, finaliser les opérations et enregistrer les résultats du test. Les cas d'utilisation courants du contexte Après (After) sont les suivants :
- Fermeture des applications ou pages Web utilisées pendant le test.
- Libération des ressources, telles que les connexions de base de données ou les ressources réseau.
- Capturez et imprimez les exceptions enregistrées dans le contexte Avant (Before) et l'exécution principale.

Dans les automatisations codées, vous avez la possibilité de créer une interface personnalisée pour les actions à exécuter avant et après une exécution. Cela peut être réalisé en déclarant l'interface IBeforeAfterRun adjacente à la classe principale, puis en implémentant votre propre logique personnalisée pour ces actions.

`BeforeRunContext`

Lorsque vous parcourez les définitions de BeforeRunContext, vous pouvez trouver l'extrait de code suivant :

// Context of the run before the execution.
public class BeforeRunContext
{
    // The relative path of the workflow.
    public string RelativeFilePath { get; set; }
}// Context of the run before the execution.
public class BeforeRunContext
{
    // The relative path of the workflow.
    public string RelativeFilePath { get; set; }
}

Ce contexte représente l'état avant l'exécution de l'automatisation. Il contient des informations sur le chemin relatif du workflow en cours d'exécution. Vous pouvez configurer des exceptions ici, en fonction de votre cas d'utilisation.

`AfterRunContext`

Lorsque vous parcourez les définitions de AfterRunContext, vous pouvez trouver l'extrait de code suivant :

// Context of the run after the execution.
public class AfterRunContext
{
    // The relative path of the workflow.
    public string RelativeFilePath { get; set; }

    // The exception caught in execution if any.
    public Exception Exception { get; set; }
}// Context of the run after the execution.
public class AfterRunContext
{
    // The relative path of the workflow.
    public string RelativeFilePath { get; set; }

    // The exception caught in execution if any.
    public Exception Exception { get; set; }
}

Ce contexte représente l'état après l'exécution de l'automatisation. Il comprend des détails sur le chemin relatif du workflow exécuté et toute exception détectée avant et pendant l'exécution.

Gestion des exceptions

Les exécutions Before et principale fonctionnent simultanément et capturent les exceptions qui apparaissent lors de l'exécution. Toutes les exceptions levées pendant ces phases sont capturées et stockées dans le AfterRunContext, présentant une valeur nulle si aucune exception ne se produit.

Une fois les exécutions Before et principale exécutées, la méthode After est exécutée. Si une exception est levée lors de l'exécution After, l'exécution se termine et l'exception correspondante est générée.

Si des exceptions se produisent dans les exécutions Before et After, elles sont regroupées dans une AggregateException.

Implémentation des exécutions Avant (Before) et Après (After)

Les exécutions Avant (Before) et Après (After) vous permettent de définir des actions avant et après vos cas de test codés, améliorant ainsi les automatisations. Vous pouvez créer cette implémentation personnalisée dans un cas de test codé ou en tant que classe partielle distincte. Découvrez dans ce tutoriel comment intégrer la configuration, le nettoyage et la journalisation dans vos cas de test codés.

Implémentation dans un cas de test codé

Vous pouvez implémenter l'interface des exécutions Avant (Before) et Après (After) directement dans votre cas de test codé.

Dans la classe publique où se trouve votre cas de test codé, ajoutez l'interface IBeforeAfterRun . Ceci sera mis en évidence en rouge, indiquant les corrections potentielles.
```
public class MyTest : CodedWorkflow, IBeforeAfterRunpublic class MyTest : CodedWorkflow, IBeforeAfterRun
```

Sélectionnez Afficher les correctifs potentiels (Show potentiel correctifs) ou appuyez sur Ctrl + . et sélectionnez Implémenter l'interface (Implement interface).

Cela générera une interface par défaut comme suit :

public void After(AfterRunContext context)
        {
            throw new NotImplementedException();
        }

        public void Before(BeforeRunContext context)
        {
            throw new NotImplementedException();
        }public void After(AfterRunContext context)
        {
            throw new NotImplementedException();
        }

        public void Before(BeforeRunContext context)
        {
            throw new NotImplementedException();
        }

Modifiez l'implémentation en fonction de vos besoins.

Dans l'exemple de code fourni, le contexte consigne un message avant l'exécution et recherche des exceptions par la suite.

public void After(AfterRunContext context)
        {
            if (context.Exception != null)
			{
				Log(context.Exception.Message);
			}
        }

        public void Before(BeforeRunContext context)
        {
            Log("this is before");
        }public void After(AfterRunContext context)
        {
            if (context.Exception != null)
			{
				Log(context.Exception.Message);
			}
        }

        public void Before(BeforeRunContext context)
        {
            Log("this is before");
        }

Implémentation à l'aide d'une classe partielle personnalisée

Vous pouvez implémenter l’interface des exécutions Avant (Before) et Après (After) uniquement pour certains fichiers .cs de votre projet, en utilisant une classe partielle personnalisée.

Créez un fichier de code source. C’est ici que vous allez implémentez l’interface des exécutions Avant (Before) et Après (After). Dans le cadre de notre exemple, nommez le fichier TestCaseBase.
1. Ajoutez l’interface IBeforeAfterRun à côté de la classe publique. Ceci sera mis en évidence en rouge, indiquant les corrections potentielles.
  Remarque : la classe partielle personnalisée (TestCaseBase dans cet exemple) doit hériter de la classe CodedWorkflow. Cela permet aux autres fichiers cs héritant de la classe partielle personnalisée de s’exécuter comme prévu.
```
public class TestCaseBase : CodedWorkflow, IBeforeAfterRunpublic class TestCaseBase : CodedWorkflow, IBeforeAfterRun
```
2. Sélectionnez Afficher les correctifs potentiels (Show potentiel correctifs) ou appuyez sur Ctrl + . et sélectionnez Implémenter l’interface (Implement interface).
  Cela générera une interface par défaut comme suit :
```
public void After(AfterRunContext context)
        {
            throw new NotImplementedException();
        }

        public void Before(BeforeRunContext context)
        {
            throw new NotImplementedException();
        }public void After(AfterRunContext context)
        {
            throw new NotImplementedException();
        }

        public void Before(BeforeRunContext context)
        {
            throw new NotImplementedException();
        }
```
3. Modifiez l'implémentation en fonction de vos besoins.
  Dans l’exemple fourni, le contexte consigne un message avant l’exécution et recherche des exceptions par la suite.
```
public void After(AfterRunContext context)
        {
            if (context.Exception != null)
            {
                throw context.Exception;
            }
            else
            {
                Log("Test " + context.RelativeFilePath + " finished with no exception.");
            }
        }

        public void Before(BeforeRunContext context)
        {
            Log("Execution started for " + context.RelativeFilePath);
        }public void After(AfterRunContext context)
        {
            if (context.Exception != null)
            {
                throw context.Exception;
            }
            else
            {
                Log("Test " + context.RelativeFilePath + " finished with no exception.");
            }
        }

        public void Before(BeforeRunContext context)
        {
            Log("Execution started for " + context.RelativeFilePath);
        }
```
Vous pourrez à présent utiliser cette classe partielle personnalisée pour utiliser la même interface d’exécutions Avant et Après uniquement pour les fichiers .cs qui en héritent.
Créez une automatisation codée. Dans le cadre de cet exemple, créez un cas de test codé nommé TestCase. Pour utiliser la même interface d’exécutions Avant et Après à partir de la classe partielle personnalisée, assurez-vous que le cas de test codé hérite de cette classe partielle.
```
public class TestCase : TestCaseBase
    {
        [TestCase]
        public void Execute()
        {
            Log("Executing the test...");
        }public class TestCase : TestCaseBase
    {
        [TestCase]
        public void Execute()
        {
            Log("Executing the test...");
        }
```

Pour voir comment fonctionne cette implémentation spécifique, consultez ses journaux de sortie ci-dessous :

Execution started for file: TestCase.cs
 [Info] IBeforeAfterRunExamples execution started
 [Info] Execution started for TestCase.cs
 [Info] Executing the test...
 [Info] Test TestCase.cs finished with no exception.
 [Info] IBeforeAfterRunExamples execution ended in: 00:00:00 Execution started for file: TestCase.cs
 [Info] IBeforeAfterRunExamples execution started
 [Info] Execution started for TestCase.cs
 [Info] Executing the test...
 [Info] Test TestCase.cs finished with no exception.
 [Info] IBeforeAfterRunExamples execution ended in: 00:00:00

Implémentation à l’aide de la classe partielle `CodedWorkflow`

Vous pouvez implémenter l’interface des contextes Avant (Before) et Après (After) à l’aide de la classe partielle CodedWorkflow, dont tout autre cas de test ou workflow codé à l’intérieur de votre projet peut hériter. Cette implémentation s’applique à tous les cas de test codés et à tous les workflows codés de votre projet.

Créez un fichier source du code et donnez-lui un autre nom que CodedWorkflow.cs, sinon la classe partielle sera en conflit avec la classe en lecture seule CodedWorkflow existante.
Créez une classe partielle qui implémente l'interface personnalisée pour les contextes Avant (Before) et Après (After).
Renommez la classe CodedWorkflow. Sinon, vous ne pourrez pas utiliser les services disponibles.
Assurez-vous que la classe de votre fichier source codé hérite de la classe CodedWorkflowBase.

Ajoutez l'espace de noms UiPath.CodedWorkflows au début de votre fichier source du code.

using System;
using System.Collections.Generic;
using UiPath.CodedWorkflows;using System;
using System.Collections.Generic;
using UiPath.CodedWorkflows;

Dans la classe de votre fichier source du code, incluez IBeforeAfterRun.

namespace TestAutomationProject1
{
    public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRunnamespace TestAutomationProject1
{
    public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRun

Pointez sur IBeforeAfterRun et sélectionnez Afficher les correctifs potentiels (Show potential fixes), ou sélectionnez cet élément et appuyez sur Ctrl + ..

Sélectionnez Implémenter l'interface (Implement interface).

Cela crée l'implémentation par défaut ci-dessous :

public void After(AfterRunContext context)
        {
            throw new NotImplementedException();
        }

        public void Before(BeforeRunContext context)
        {
            throw new NotImplementedException();
        }public void After(AfterRunContext context)
        {
            throw new NotImplementedException();
        }

        public void Before(BeforeRunContext context)
        {
            throw new NotImplementedException();
        }

Vous pouvez également personnaliser davantage l'interface en fonction de votre cas d'utilisation. Dans l'exemple de code ci-dessous, le contexte imprime un message avant l'exécution. Après l'exécution, il vérifie si une exception a été levée et l'imprime à nouveau.

public void After(AfterRunContext context)
        {
            if (context.Exception != null)
			{
				Log(context.Exception.Message);
			}
        }

        public void Before(BeforeRunContext context)
        {
            Log("this is before");
        }public void After(AfterRunContext context)
        {
            if (context.Exception != null)
			{
				Log(context.Exception.Message);
			}
        }

        public void Before(BeforeRunContext context)
        {
            Log("this is before");
        }