„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

Mit Vor- und Nach-Ausführungen können Sie Actions vor und nach Ihren codierten Testfällen definieren und so die Automatisierungen verbessern.Sie können diese benutzerdefinierte Implementierung innerhalb eines codierten Testfalls oder als separate Teilklasse erstellen. Erfahren Sie in diesem Tutorial, wie Sie Einrichtung, Abbau 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 Teilklasse (TestCaseBase in diesem Beispiel) muss von der CodedWorkflowKlasse erben.Dadurch können andere cs Dateien, die die benutzerdefinierte Teilklasse 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 gemäß Ihren Anforderungen. Im bereitgestellten Beispiel protokolliert der Kontext eine Nachricht vor der Ausführung und überprüft danach auf Ausnahmen.``` public void After(AfterRunContext context) { if (context.Exception != null) { throw context.Exception; } else { Log("Test " + context.RelativeFilePath + " ohne Ausnahme abgeschlossen.");} }

          public void Before(BeforeRunContext context)
          {
              Log("Execution started for " + context.RelativeFilePath);
          }
  ```

Sie können diese benutzerdefinierte Teilklasse jetzt verwenden, um dieselbe Schnittstelle für Vor- und Nach-Ausführungen nur für die .csDateien zu verwenden, die sie erben.2. Erstellen Sie eine codierte Automatisierung. Erstellen Sie für dieses Beispiel einen codierten Testfall mit dem Namen TestCase. Um dieselbe Schnittstelle für vor- und nachgelagerte Ausführungen aus der benutzerdefinierten Teilklasse zu verwenden, stellen Sie sicher, dass der codierte Testfall von dieser Teilklasse 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 mithilfe der TeilklasseCodedWorkflow

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