Como testar sua atividade

Após implementar a nova atividade, teste se ela funciona conforme o esperado. Você pode testar sua atividade usando um destes métodos:

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

O exemplo de fragmento de código anterior cria uma nova instância de classe Calculator e chama a função ExecuteInternal . Não há nada específico relacionado a atividades neste contexto e os princípios básicos de testes de unidade se aplicam.

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

Testes de fluxo de trabalho

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

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

O fragmento de código anterior cria uma nova instância da atividade, mas em vez de chamar os métodos diretamente na instância, ele coloca a atividade dentro de um WorkflowInvoker e a executa como parte de um fluxo de trabalho. O fluxo de trabalho eventualmente chama a função Execute na classe Calculator . Observe que essa função está protegida e você não pode invocá-la diretamente, o que é um benefício indireto do uso dessa abordagem.

Essa abordagem é geralmente usada quando a atividade é dependente do resultado de outras atividades. Nesse caso, você precisa criar um fluxo de trabalho com várias atividades e deixar 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.