„Vor“- und „Nach“-Kontexte

In Testfällen können Sie mit „Nach“- und „Vor“-Ausführungen („Before“ und „After“) bestimmte Aktionen vor und nach der Ausführung des Testfalls ausführen. Diese Kontexte werden häufig verwendet, um Ressourcen einzurichten und zu entfernen, die Protokollierung durchzuführen und die Testumgebung zu verwalten.

• BeforeRunContext (Einrichten): Die „Vor“-Ausführung wird verwendet, um Aktionen vor der Hauptausführung des Testfalls auszuführen. Sie wird häufig zum Einrichten des Ausgangszustands der Testumgebung und zum Vorbereiten von Ressourcen verwendet. Einige häufige Anwendungsfälle für den „Vor“-Kontext:
  • Initialisieren von Variablen oder Daten, die für den Test erforderlich sind.
  • Einrichten von Verbindungen zu externen Systemen oder Datenbanken.
  • Protokollieren des Beginns der Testausführung.
  • Öffnen von Anwendungen oder Webseiten, mit denen der Test interagiert.
  • Einrichten von spezifischen Ausnahmen vor der Ausführung des Testfalls.
• AfterRunContext (Entfernen): Die „Nach“-Ausführung wird verwendet, um Aktionen nach Abschluss der Hauptausführung des Testfalls auszuführen. Sie wird normalerweise zum Bereinigen von Ressourcen, Abschließen von Vorgängen und Aufzeichnen der Testergebnisse verwendet. Einige häufige Anwendungsfälle für den „Nach“-Kontext:
  • Schließen von Anwendungen oder Webseiten, die während des Tests verwendet werden.
  • Freigeben von Ressourcen, z. B. Datenbankverbindungen oder Netzwerkressourcen.
  • Abfangen und Ausgeben von Ausnahmen, die im „Vor“-Kontext und in der Hauptausführung aufgezeichnet wurden.

Bei codierten Automatisierungen haben Sie die Möglichkeit, eine benutzerdefinierte Schnittstelle für Aktionen zu erstellen, die vor und nach einer Ausführung ausgeführt werden sollen. Dies kann erreicht werden, indem Sie die IBeforeAfterRun-Schnittstelle neben der Hauptklasse deklarieren und dann Ihre eigene benutzerdefinierte Logik für diese Aktionen implementieren.

BeforeRunContext

Bei den Definitionen von BeforeRunContext finden Sie das folgende Code- Snippet:

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

Dieser Kontext entspricht dem Status vor der Ausführung der Automatisierung. Er enthält Informationen über den relativen Pfad des ausgeführten Workflows. Sie können hier Ausnahmen entsprechend Ihrem Anwendungsfall einrichten.

AfterRunContext

Bei den Definitionen von AfterRunContext finden Sie das folgende Code- Snippet:

// 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; }
}

Dieser Kontext entspricht dem Status nach der Ausführung der Automatisierung. Er enthält Details zum relativen Pfad des ausgeführten Workflows und jegliche Ausnahmen, die vor und während der Ausführung abgefangen wurden.

Ausnahmebehandlung

Die Before- und Hauptausführungen werden gleichzeitig ausgeführt und es werden Ausnahmen erfasst, die während der Ausführung auftreten. Alle Ausnahmen, die während dieser Phasen ausgelöst werden, werden erfasst und in AfterRunContext gespeichert. Wenn keine Ausnahmen auftreten, bleibt der Wert null.

Nach den Before- und Hauptausführungen wird die After-Methode ausgeführt. Wenn während der After-Ausführung eine Ausnahme ausgelöst wird, wird die Ausführung beendet und die entsprechende Ausnahme ausgelöst.

Wenn Ausnahmen bei den Before- sowie After-Ausführungen auftreten, werden sie in einer AggregateException zusammengefasst.

Implementieren von „Vor“- und „Nach“-Ausführungen

Bei Vor- und Nach-Ausführungen können Sie Aktionen vor und nach Ihren codierten Testfällen definieren und so Ihre Automatisierungen verbessern. Sie können diese benutzerdefinierte Implementierung in einem codierten Testfall oder als separate partielle Klasse erstellen. In diesem Tutorial erfahren Sie, wie Sie die Einrichtung, Entfernung und Protokollierung in Ihre codierten Testfälle integrieren.

Implementieren in einem codierten Testfall

Sie können die Schnittstelle für „Vor“- und „Nach“-Ausführungen direkt in Ihren codierten Testfall implementieren.

1. Fügen Sie in der öffentlichen Klasse, in der sich Ihr codierter Testfall befindet, die Schnittstelle IBeforeAfterRun hinzu. Dies wird rot hervorgehoben, um auf mögliche Korrekturen hinzuweisen.

   public class MyTest : CodedWorkflow, IBeforeAfterRun

2. Wählen Sie Mögliche Korrekturen anzeigen aus oder drücken Sie Ctrl + . und wählen Sie Schnittstelle implementieren aus.
   Dadurch wird eine Standardschnittstelle wie folgt generiert:

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

3. Ändern Sie die Implementierung nach Ihren Anforderungen.
   Im angegebenen Codebeispiel protokolliert der Kontext eine Meldung vor der Ausführung und prüft danach auf Ausnahmen.

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

Implementieren mit einer benutzerdefinierten partiellen Klasse

Sie können die Schnittstelle für „Vor“- und „Nach“-Ausführungen nur für bestimmte .cs-Dateien in Ihrem Projekt implementieren, indem Sie eine benutzerdefinierte partielle Klasse verwenden.

1. Erstellen Sie eine Codequelldatei. Hier implementieren Sie die Schnittstelle für „Vor“- und „Nach“-Ausführungen. Benennen Sie die Datei in diesem Beispiel TestCaseBase.
   1. Fügen Sie die IBeforeAfterRun-Schnittstelle neben der öffentlichen Klasse hinzu. Sie wird rot hervorgehoben, um auf mögliche Korrekturen hinzuweisen.
      Hinweis: Die benutzerdefinierte partielle Klasse (in diesem Beispiel TestCaseBase) muss die Klasse CodedWorkflow erben. Dadurch können andere cs-Dateien, die die benutzerdefinierte partielle Klasse erben, wie erwartet ausgeführt werden.

      public class TestCaseBase : CodedWorkflow, IBeforeAfterRun

   2. Wählen Sie Mögliche Korrekturen anzeigen aus oder drücken Sie Ctrl + . und wählen Sie Schnittstelle implementieren aus.
      Dadurch wird eine Standardschnittstelle wie folgt generiert:

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

   3. Ändern Sie die Implementierung nach Ihren Anforderungen.

      Im angegebenen Beispiel protokolliert der Kontext eine Meldung vor der Ausführung und prüft danach auf Ausnahmen.

      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);
              }

   Sie können jetzt diese benutzerdefinierte partielle Klasse verwenden, um die gleiche Schnittstelle für „Vor“- und „Nach“-Ausführungen nur für die .cs-Dateien zu verwenden, die sie erben.
2. Erstellen Sie eine codierte Automatisierung. Erstellen Sie in diesem Beispiel einen codierten Testfall namens TestCase. Um die gleiche Schnittstelle für „Vor“- und „Nach“-Ausführungen von der benutzerdefinierten partiellen Klasse zu verwenden, stellen Sie sicher, dass der codierte Testfall von dieser partiellen Klasse erbt.

   public class TestCase : TestCaseBase
       {
           [TestCase]
           public void Execute()
           {
               Log("Executing the test...");
           }

Zur Veranschaulichung, wie diese spezifische Implementierung funktioniert, sehen Sie sich die folgenden Ausgabeprotokolle an:

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

Implementieren mit der partiellen Klasse CodedWorkflow

Sie können die Schnittstellen für „Vor“- und „Nach“-Kontexte mit der partiellen Klasse CodedWorkflow implementieren, die jeder andere codierte Testfall oder codierte Workflow in Ihrem Projekt erben kann. Diese Implementierung gilt für alle codierten Testfälle und codierten Workflows in Ihrem Projekt.

1. Erstellen Sie eine Codequelldatei und benennen Sie sie anders als CodedWorkflow.cs, da sonst ein Konflikt zwischen der partiellen Klasse und der vorhandenen schreibgeschützten CodedWorkflow-Klasse auftritt.
2. Erstellen Sie eine partielle Klasse, welche die benutzerdefinierte Schnittstelle für „Vor“- und „Nach“-Kontexte implementiert.
3. Benennen Sie die Klasse in CodedWorkflow um. Andernfalls können Sie die verfügbaren Dienste nicht nutzen.
4. Stellen Sie sicher, dass die Klasse in Ihrer codierten Quelldatei die Klasse CodedWorkflowBase erbt.
5. Fügen Sie den UiPath.CodedWorkflows-Namespace am Anfang Ihrer Codequelldatei hinzu.

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

6. Fügen Sie in die Klasse Ihrer Codequelldatei IBeforeAfterRun ein.

   namespace TestAutomationProject1
   {
       public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRun

7. Zeigen Sie mit der Maus auf IBeforeAfterRun und wählen Sie Mögliche Korrekturen anzeigen aus oder wählen Sie das Element aus und drücken Sie Ctrl + ..
8. Wählen Sie Schnittstelle implementieren aus.
   Dadurch wird die nachfolgende Standardimplementierung erstellt:

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

9. Optional können Sie die Schnittstelle weiter an Ihren Anwendungsfall anpassen. Im folgenden Codebeispiel gibt der Kontext vor der Ausführung eine Meldung aus. Nach der Ausführung prüft er, ob eine Ausnahme ausgelöst wurde, und gibt diese erneut aus.

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