Contextos Antes e Depois

Nos casos de teste, as execuções Antes e Depois permitem executar determinadas ações antes e depois da execução do caso de teste. Esses contextos são comumente usados para configurar e desmontar recursos, realizar registro em log e gerenciar o ambiente de teste.

• BeforeRunContext(Configuração): a execução Antes é usada para realizar ações antes da execução principal do caso de teste. Geralmente é usado para configurar o estado inicial do ambiente de teste e preparar recursos. Alguns casos de uso comuns para o contexto Antes incluem:
  • Inicialização de variáveis ou dados necessários para o teste.
  • Configuração de conexões com sistemas ou bancos de dados externos.
  • Registro em log do início da execução de teste.
  • Abertura de aplicativos ou páginas web com os quais o teste interage.
  • Configure exceções específicas antes de executar o caso de teste.
• AfterRunContext(desmontagem): a execução Depois é usada para realizar ações após a conclusão da execução principal do caso de teste. Geralmente é usado para limpar recursos, finalizar operações e gravar os resultados do teste. Os casos de uso comuns para o contexto Depois incluem:
  • Fechamento de aplicativos ou páginas web usados durante o teste.
  • Liberação de recursos, como conexões de banco de dados ou recursos de rede.
  • Capture e imprima exceções registradas no contexto Antes e na execução principal.

Em automações codificadas, você tem a opção de criar uma interface personalizada para ações a serem executadas antes e depois de uma execução. Isso pode ser conseguido declarando a IBeforeAfterRuninterface adjacente à classe principal e, em seguida, implementando sua própria lógica personalizada para essas ações.

BeforeRunContext

Ao explorar as definições de BeforeRunContext, você pode encontrar o seguinte 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 o estado antes da execução da automação. Ele contém informações sobre o caminho relativo do fluxo de trabalho que está sendo executado. Você pode configurar exceções aqui, de acordo com seu caso de uso.

AfterRunContext

Ao explorar as definições de AfterRunContext, você pode encontrar o seguinte 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 o estado depois da execução da automação. Inclui detalhes sobre o caminho relativo do fluxo de trabalho executado e qualquer exceção capturada antes e durante a execução.

Manuseio de exceção

As execuções Beforee main operam simultaneamente, capturando exceções que surgem durante a execução. Quaisquer exceções lançadas durante essas fases são capturadas e armazenadas no AfterRunContext, deixando-o como nulo se nenhuma exceção ocorrer.

Após a execução Beforee main, o Aftermétodo é executado. Se uma exceção for lançada durante a Afterexecução , a execução será encerrada e a exceção correspondente será lançada.

Se ocorrerem exceções nas execuções e BeforeAfter, , elas serão agrupadas em um AggregateException.

Como implementar execuções antes e depois

As execuções Antes e Depois permitem definir ações antes e depois dos casos de teste codificados, aprimorando as automações. Você pode criar essa implementação personalizada em um caso de teste codificado ou como uma classe parcial separada. Aprenda como integrar configuração, desmontagem e registro de log em seus casos de teste codificados neste tutorial.

Implementação em um caso de teste codificado

Você pode implementar a interface Antes e Depois diretamente em seu caso de teste codificado.

1. Dentro da classe pública onde reside seu caso de teste codificado, adicione IBeforeAfterRuninterface . Isso será destacado em vermelho, indicando possíveis correções.

   public class MyTest : CodedWorkflow, IBeforeAfterRun

2. Escolha Mostrar possíveis correções ou pressione Ctrl + .e selecione Implementar interface.
   Isso irá gerar uma interface padrão da seguinte forma:

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

3. Modifique a implementação de acordo com suas necessidades.
   No exemplo de código fornecido, o contexto registra uma mensagem antes da execução e verifica exceções posteriormente.

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

Implementação usando uma classe parcial personalizada

Você pode implementar a interface de execuções Antes e Depois apenas para certos arquivos .cs dentro de seu projeto, usando uma classe parcial personalizada.

1. Crie um arquivo de código-fonte. É aqui que você implementa a interface de execuções Antes e Depois. Para este exemplo, nomeie o arquivo TestCaseBase.
   1. Adicione a interface IBeforeAfterRun ao lado da classe pública. Isso será destacado em vermelho, indicando possíveis correções.
      Observação: a classe parcial personalizada (TestCaseBase neste exemplo) deve herdar a classe CodedWorkflow. Isso permite que outros arquivos cs, que herdam a classe parcial personalizada, sejam executados dentro do esperado.

      public class TestCaseBase : CodedWorkflow, IBeforeAfterRun

   2. Escolha Mostrar possíveis correções ou pressione Ctrl + . e selecione Implementar interface.
      Isso irá gerar uma interface padrão da seguinte forma:

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

   3. Modifique a implementação de acordo com suas necessidades.

      No exemplo fornecido, o contexto registra uma mensagem antes da execução e verifica exceções posteriormente.

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

   Agora você pode usar essa classe parcial personalizada para usar a mesma interface de execuções Antes e Depois apenas para os arquivos .cs que a herdam.
2. Criar uma automação codificada. Para este exemplo, crie um caso de teste codificado chamado TestCase. Para usar a mesma interface de execuções Antes e Depois da classe parcial personalizada, certifique-se de que o caso de teste codificado herde dessa classe parcial.

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

Para demonstrar como essa implementação específica funciona, consulte seus logs de saída abaixo:

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

Implementação usando a classe parcial CodedWorkflow

Você pode implementar a interface de contextos Antes e Depois usando a classe parcial CodedWorkflow, que qualquer outro caso de teste codificado ou fluxo de trabalho codificado dentro de seu projeto pode herdar. Essa implementação se aplica a todos os casos de teste codificados e fluxos de trabalho codificados dentro de seu projeto.

1. Crie um arquivo de código-fonte e nomeie-o de forma diferente de , caso CodedWorkflow.cscontrário, a classe parcial terá um conflito com a classe somente CodedWorkflowleitura existente.
2. Construa uma classe parcial que implemente a interface personalizada para contextos Antes e Depois.
3. Renomeie a classe para CodedWorkflow. Caso contrário, você não poderá utilizar os serviços disponíveis.
4. Certifique-se de que a classe em seu arquivo de origem codificado herde CodedWorkflowBasea classe .
5. Adicione o UiPath.CodedWorkflowsnamespace no início do seu arquivo de código-fonte.

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

6. Dentro da classe do seu arquivo de código-fonte, inclua IBeforeAfterRun.

   namespace TestAutomationProject1
   {
       public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRun

7. Passe o mouse sobre IBeforeAfterRune selecione Mostrar possíveis correções ou selecione-o e pressione Ctrl + ..
8. Selecione Implementar interface.
   Isso cria a implementação padrão abaixo:

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

9. Opcionalmente, você pode personalizar ainda mais a interface, de acordo com seu caso de uso. No exemplo de código abaixo, o contexto imprime uma mensagem antes da execução e, após a execução, verifica se alguma exceção foi gerada e a imprime novamente.

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