Como testar sua atividade

Após implementar a nova atividade, é importante testar para ver se funciona como esperado. Teste sua atividade de uma das seguintes maneiras.

Testes de unidade

A maneira mais fácil e rápida de testar o código da atividade é escrever testes de unidade que isolam o código da atividade e testam cenários individuais.

Por exemplo:

[Theory]
[InlineData(1, Operation.Add, 1, 2)]
[InlineData(3, Operation.Subtract, 2, 1)]
[InlineData(3, Operation.Multiply, 2, 6)]
[InlineData(6, Operation.Divide, 2, 3)]
public void Calculator_ReturnsAsExpected(int firstNumber, Operation operation, int secondNumber, int expectedResult)
{
    var calculator = new Calculator()
    {
        SelectedOperation = operation
    };

    var result = calculator.ExecuteInternal(firstNumber, secondNumber);

    Assert.Equal(expectedResult, result);
}

Neste exemplo, simplesmente criamos uma instância nova da classe Calculator e chamamos a função ExecuteInternal . Não há nada específico relacionado a atividades neste contexto, e os princípios básicos do teste de unidade se aplicam.

Para ver um exemplo, acesse a atividade Calculator de exemplo no GitHub.

Testes de fluxo de trabalho

Os testes de fluxo de trabalho são um tipo de testes de unidade que dependem da classe WorkflowInvoker para colocar a atividade dentro de um fluxo de trabalho e executá-la como seria executada pelo UiPath Robot.

Vamos analisar este exemplo:

[Fact]
public void Divide_ReturnsAsExpected()
{
    var activity = new Calculator()
    {
        FirstNumber = 4,
        SecondNumber = 2,
        SelectedOperation = Operation.Divide
    };

    var runner = new WorkflowInvoker(activity);
    runner.Extensions.Add(() => workflowRuntimeMock.Object);

    var result = runner.Invoke(TimeSpan.FromSeconds(1)); //the runner will return a dictionary with the values of the OutArguments

    //verify that the result is as expected
    Assert.Equal(2, result["Result"]);

    //verify that we logged a message
    workflowRuntimeMock.Verify(x => x.LogMessage(It.IsAny<LogMessage>()), Times.Once);
}

De maneira semelhante ao teste de unidade, criamos uma nova instância da atividade, mas, em vez de chamar os métodos diretamente na instância, colocamos a atividade dentro de uma WorkflowInvoker e a executamos como parte de um fluxo de trabalho. O fluxo de trabalho eventualmente chamará a função Execute na classe Calculator . Observe que essa função está protegida e não podemos invocá-la diretamente, que é um benefício indireto do uso dessa abordagem.

Essa abordagem é geralmente usada quando a atividade é dependente do resultado de outras atividades. Nesse caso, criaremos um fluxo de trabalho com várias atividades e deixaremos o WorkflowInvoker executá-lo.

Anexação do UiPath Studio ao processo

Às vezes, é necessário testar o código da atividade dentro do executor do UiPath.Robot. Para conseguir isso, podemos usar uma de duas opções.

Opção 1: System.Diagnostics.Debugger.Launch()

1. Adicione Debugger.Launch() onde você deseja que o ponto de interrupção atinja seu código.
2. Construa o novo pacote e atualize a versão em seu projeto no UiPath.Studio, depois selecione Executar.

3. O Depurador JIT solicita que você escolha uma instância do Visual Studio a ser usada na depuração.

   
   

   

   
   
4. Após selecionar a instância, o JIT interromperá a execução na linha em que o Debugger.Launch() foi adicionado e, a partir dai, o processo de depuração normal poderá ser iniciado.
   
   

   

   
   

Opção 2: anexar ao processo no Visual Studio

Outra opção é adiar a execução e depois anexar o Visual Studio ao processo executor. Embora esse método exija mais sobrecarga, ele permite depurar o código da atividade sem modificações.

1. Para atrasar a execução, adicione a atividade Delay ou, em um projeto do Windows, a atividade Message Box .

   
   

   

   
   

2. Selecione Executar, vá para o Visual Studio e selecione Depurar > Anexar ao processo.

   
   

   

   
   
3. Filtre a lista de processos por UiPath.Executor, selecione todos os processos e, em seguida, clique em Anexar.
   
   

   

   
   

Depois que o atraso passar, a execução do processo será interrompida no ponto de interrupção que você adicionou no seu código.