Contextos Antes y Después

Dentro de los casos de prueba, las ejecuciones Antes y Después te permiten ejecutar ciertas acciones antes y después de que se ejecute el caso de prueba. Estos contextos se utilizan comúnmente para configurar y eliminar recursos, realizar el registro y gestionar el entorno de prueba.

• BeforeRunContext (Configuración): la ejecución Antes se utiliza para realizar acciones antes de la ejecución principal del caso de prueba. A menudo se utiliza para configurar el estado inicial del entorno de prueba y preparar recursos. Algunos casos de uso comunes para el contexto Antes incluyen:
  • Inicializar variables o datos necesarios para la prueba.
  • Configurar conexiones a sistemas externos o bases de datos.
  • Registrar el inicio de la ejecución de la prueba.
  • Abrir aplicaciones o páginas web con las que interactúa la prueba.
  • Configurar excepciones específicas antes de ejecutar el caso de prueba.
• AfterRunContext (Desmontaje): la ejecución Después se utiliza para realizar acciones después de que se complete la ejecución principal del caso de prueba. Normalmente se utiliza para limpiar recursos, finalizar operaciones y registrar los resultados de la prueba. Los casos de uso comunes para el contexto Después incluyen:
  • Cerrar aplicaciones o páginas web utilizadas durante la prueba.
  • Liberar recursos, como las conexiones de la base de datos o los recursos de red.
  • Captura e imprime las excepciones registradas en el contexto Antes y la ejecución principal.

En las automatizaciones codificadas, tienes la opción de crear una interfaz personalizada para que las acciones se ejecuten antes y después de una ejecución. Esto puede lograrse declarando la interfaz IBeforeAfterRun adyacente a la clase principal y luego implementando tu propia lógica personalizada para estas acciones.

BeforeRunContext

Al explorar las definiciones de BeforeRunContext, puedes encontrar el siguiente fragmento de código:

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

Este contexto representa el estado antes de la ejecución de la automatización. Contiene información sobre la ruta relativa del flujo de trabajo que se ejecuta. Puedes configurar excepciones aquí, según tu caso de uso.

AfterRunContext

Al explorar las definiciones de AfterRunContext, puedes encontrar el siguiente fragmento de código:

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

Este contexto representa el estado después de la ejecución de la automatización. Incluye detalles sobre la ruta relativa del flujo de trabajo ejecutado y cualquier excepción capturada antes y durante la ejecución.

Manejo de excepciones

Before y las ejecuciones principales operan simultáneamente, capturando las excepciones que aparecen durante la ejecución. Cualquier excepción lanzada durante estas fases se captura y almacena en AfterRunContext, dejándolo como nulo si no se producen excepciones.

Después de ejecutar Before y las ejecuciones principales, se ejecuta el método After. Si se lanza una excepción durante la ejecución After, la ejecución finaliza y se lanza la excepción correspondiente.

Si se producen excepciones en las ejecuciones Before y After, , se agrupan en un AggregateException.

Implementar las ejecuciones antes y después

Las ejecuciones Antes y Después te permiten definir acciones antes y después de tus casos de prueba codificados, lo que mejora las automatizaciones. Puedes crear esta implementación personalizada dentro de un caso de prueba codificado o como una clase parcial independiente. Aprende a integrar la configuración, la eliminación y el inicio de sesión en tus casos de prueba codificados en este tutorial.

Implementar dentro de un caso de prueba codificado

Puedes implementar la interfaz de las ejecuciones Antes y Después directamente dentro de tu caso de prueba codificado.

1. Dentro de la clase pública donde reside tu caso de prueba codificado, añade la interfaz IBeforeAfterRun. Esto se resaltará en rojo, lo que indica posibles correcciones.

   public class MyTest : CodedWorkflow, IBeforeAfterRun

2. Elige Mostrar posibles correcciones o presiona Ctrl + . y selecciona Implementar interfaz.
   Esto generará una interfaz predeterminada de la siguiente manera:

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

3. Modifica la implementación según tus necesidades.
   En el ejemplo de código proporcionado, el contexto registra un mensaje antes de la ejecución y comprueba si hay excepciones después.

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

Implementar utilizando una clase parcial personalizada

Puedes implementar la interfaz de las ejecuciones antes y después solo para ciertos archivos .cs dentro de tu proyecto, utilizando una clase parcial personalizada.

1. Crea un archivo de código fuente. Aquí es donde implementas la interfaz de las ejecuciones antes y después. Para este ejemplo, nombra el archivo TestCaseBase.
   1. Añade la interfaz IBeforeAfterRun junto a la clase pública. Esto se resaltará en rojo, lo que indica posibles correcciones.
      Nota: la clase parcial personalizada ( TestCaseBase en este ejemplo) debe heredar la clase CodedWorkflow. Esto permite que otros archivos cs, que heredan la clase parcial personalizada, se ejecuten como se espera.

      public class TestCaseBase : CodedWorkflow, IBeforeAfterRun

   2. Elige Mostrar posibles correcciones o presiona Ctrl + . y selecciona Implementar interfaz.
      Esto generará una interfaz predeterminada de la siguiente manera:

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

   3. Modifica la implementación según tus necesidades.

      En el ejemplo proporcionado, el contexto registra un mensaje antes de la ejecución y comprueba si hay excepciones después.

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

   Ahora puedes utilizar esta clase parcial personalizada para utilizar la misma interfaz de las ejecuciones antes y después solo para los archivos .cs que la heredan.
2. Crea una automatización codificada. Para este ejemplo, crea un caso de prueba codificado llamado TestCase. Para utilizar la misma interfaz de las ejecuciones antes y después de la clase parcial personalizada, asegúrate de que el caso de prueba codificado hereda de esta clase parcial.

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

Para demostrar cómo funciona esta implementación específica, comprueba sus registros de salida a continuación:

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

Implementar utilizando la clase parcial CodedWorkflow

Puedes implementar la interfaz de contextos antes y después utilizando la clase CodedWorkflowparcial, que cualquier otro caso de prueba codificado o flujo de trabajo codificado dentro de tu proyecto puede heredar. Esta implementación se aplica a todos los casos de prueba codificados y flujos de trabajo codificados dentro de tu proyecto.

1. Crea un archivo de código fuente y nómbralo de forma diferente que CodedWorkflow.cs, de lo contrario la clase parcial tendrá un conflicto con la clase CodedWorkflow de solo lectura existente.
2. Construye una clase parcial que implemente la interfaz personalizada para los contextos Antes y Después.
3. Cambia el nombre de la clase a CodedWorkflow.De lo contrario, no podrás utilizar los servicios disponibles.
4. Asegúrate de que la clase dentro de tu archivo de origen codificado hereda la clase CodedWorkflowBase.
5. Añade el espacio de nombres UiPath.CodedWorkflows al inicio de tu archivo de código fuente.

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

6. Dentro de la clase de tu archivo de código fuente, incluye IBeforeAfterRun.

   namespace TestAutomationProject1
   {
       public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRun

7. Pasa el puntero del ratón sobre IBeforeAfterRun y selecciona Mostrar posibles correcciones o selecciónalo y presiona Ctrl + ..
8. Selecciona Implementar interfaz.
   Esto crea la siguiente implementación predeterminada:

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

9. Opcionalmente, puedes personalizar aún más la interfaz, según tu caso de uso. En la siguiente muestra de código, el contexto imprime un mensaje antes de la ejecución y después de la ejecución comprueba si se lanzó alguna excepción y lo imprime de nuevo.

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