Menu

Execute casos de teste em paralelo e gere relatórios usando a ferramenta Karate

  • Principal
  • De Outros
  • Execute casos de teste em paralelo e gere relatórios usando a ferramenta Karate

run test cases parallel generate reports using karate tool

Experimente Nosso Instrumento Para Eliminar Problemas

qual ide é melhor para python

Este tutorial explica como realizar algumas operações básicas na API, executar casos de teste em paralelo e gerar relatórios com o Karate Framework:

Aprendemos como criar um script de teste básico em nosso tutorial anterior, agora podemos prosseguir com o aprendizado de algumas operações básicas que podem ser executadas enquanto trabalhamos com a API e o Karate Framework. Existem muitas dessas operações e discutiremos algumas das mais comumente usadas neste tutorial.

Devemos também nos aprofundar no processo de execução de casos de teste em paralelo, seguindo uma abordagem passo a passo. Também discutiremos o relatório atual que é gerado automaticamente e o compararemos com o relatório Cucumber que podemos gerar integrando um plugin.

Execução de várias operações, execução de casos de teste em paralelo e geração de relatórios

O que você aprenderá:

Trabalho com API e ferramenta de teste de caratê

Conforme discutido no tutorial anterior, no .recurso arquivo que criamos, poderíamos usar diferentes palavras-chave para realizar diferentes operações na API. Karatê framework nos fornece várias palavras-chave que podem ser usadas para realizar várias ações.

=> Leitura Recomendada: Teste de API com Karate Framework

Executando Várias Operações

# 1) Imprimir a resposta no console

Imprimir é uma palavra-chave fornecida pelo Karate Framework para imprimir o resultado no console ou no arquivo. Um dos usos mais comuns é imprimir a resposta da API. Isso pode ser muito útil para o usuário.

Podemos fazer isso usando as seguintes linhas de código:

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #We are printing the Response of the API using the print keyword# Then print response

As linhas de código acima fornecerão o seguinte resultado:

18:15:44.495 (main) INFO com.intuit.karate - (print) { 'ad': { 'company': 'StatusCode Weekly', 'text': 'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url': 'http://statuscode.org/' }, 'data': { 'last_name': 'Weaver', 'id': 2, 'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name': 'Janet', 'email': 'janet.weaver@reqres.in' } }

É assim que podemos imprimir a resposta da API no console para fins de leitura, que pode ser usada no momento da depuração.

# 2) Declarando as variáveis

Podemos declarar as variáveis ​​usando a palavra-chave def na estrutura do Karate e, em seguida, use as variáveis ​​declaradas no código sempre que necessário.

No exemplo abaixo, adicionamos mais algumas linhas de código ao existente userDetails.feature arquivo para ajudar a declarar as variáveis ​​no script.

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #We are printing the Response of the API using the print keyword Then print response # Declaring and assigning a string value: Given def varName = 'value' # using a variable Then print varName

# 3) Afirmar a resposta real à resposta esperada

Karate Framework ajuda a realizar as operações relacionadas a afirmações usando o Combine palavra-chave. O Combine é inteligente porque o espaço em branco não importa para ele e a ordem das teclas não é importante.

Para usar corresponder palavra-chave, precisamos fazer o uso do sinal de igual duplo “==” que representa uma comparação.

Agora vamos tentar elaborar alguns usos de Combine palavra-chave.

a) Quando toda a resposta esperada é mencionada no próprio arquivo .feature.

Em certos momentos temos alguns dados que gostaríamos de validar imediatamente no próprio arquivo. Normalmente, esses tipos de dados são mencionados durante a depuração do código.

Poderíamos fazer o mesmo no próprio arquivo .feature, conforme mostrado abaixo:

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Asserting the reponse #response variable is holding the Actual response from API #Right hand side value is holding the expected Response And match response == {'ad':{'company':'StatusCode Weekly','text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.','url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg','first_name':'Janet', 'email':'janet.weaver@reqres.in'}}

Se você enviar uma solicitação para o URL ‘Https://reqres.in/api/users/2’ no navegador, então você receberá a seguinte resposta:

{ 'ad': { 'company': 'StatusCode Weekly', 'text': 'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url': 'http://statuscode.org/' }, 'data': { 'last_name': 'Weaver', 'id': 2, 'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name': 'Janet', 'email': 'janet.weaver@reqres.in' } }

Estamos tentando validar a resposta acima mencionada usando o arquivo * .feature.

Nós usamos o Combine palavra-chave fornecida pelo Karate Framework, que ajuda a realizar diferentes tipos de Afirmações na resposta da API.

Observação : Precisamos transformar a resposta da API em uma linha para realizar a etapa acima. Você pode usar qualquer uma das ferramentas disponíveis conectados.

b) Quando a saída esperada é mantida em um arquivo JSON externo.

No exemplo acima, discutimos um cenário em que tínhamos dados limitados e a mesma resposta que era fácil de lidar, mas nos cenários reais, teremos conjuntos gigantescos de respostas JSON que podemos ter que avaliar.

Então, nesses casos, é melhor manter a resposta no arquivo externo e depois verificar o mesmo.

No exemplo a seguir, discutiremos o mesmo:

  • Precisa criar um ExpectedOutput.json arquivo em nossa pasta de projeto como mostrado na imagem abaixo.

Criar um novo recurso de pacote -> Criar um novo arquivo ExpectedOutput.json

E armazene a resposta JSON neste arquivo e salve-o.

ExpectedOutput.json1

Crie um novo pacote de recursos

Você precisaria escrever o seguinte código em seu userDetails.feature Arquivo:

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Verifying the JSON response by providing same in feature file And match response == {'ad':{'company':'StatusCode Weekly','text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.','url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg','first_name': 'Janet','email':'janet.weaver@reqres.in'}} #Reading the file ExpectedOutput.json and storing same response in variable expectedResult Given expectedResult=read('./resources/ExpectedOutput.json') #Asserting the Actual Response with the Expected Response And match response == expectedResult

No exemplo acima, estamos lendo primeiro o arquivo ExpectedOutput.json e armazenar a resposta dela na variável resultado esperado usando o seguintes linhas de código:

Given expectedResult=read('./resources/ExpectedOutput.json')

Então, estamos colocando a asserção usando as seguintes linhas de código, onde estamos combinando o Resposta real com o resultado esperado resposta com o “ == ' operador.

And match response == expectedResult

c) Correspondência / verificação de certos valores da resposta

Até agora, verificamos toda a resposta da API, mas todas as vezes você não gostaria de verificar a resposta inteira. Às vezes, você gostaria de avaliar apenas uma parte da resposta. Normalmente, fazemos o mesmo quando usamos as outras ferramentas para teste de API ou ao criar uma estrutura.

Para entender melhor, vamos usar a seguinte resposta JSON como exemplo:

{ 'ad': { 'company': 'StatusCode Weekly' } }

Se quisermos verificar se o parâmetro companhia deve ter o valor como StatusCode Weekly, então teremos que criar um caminho JSON. Isso pode ser feito percorrendo o arquivo JSON e usando o “.” (Operador de ponto)

O caminho JSON para a resposta acima será:

ad.company == “StatusCode Weekly”

Abaixo está o snippet de código que nos ajudará a avaliar os valores de um parâmetro específico. Este código pertence ao .recurso Arquivo.

Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Verifying the JSON response by providing same in feature file And match response == {'ad':{'company':'StatusCode Weekly', 'text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name':'Janet','email':'janet.weaver@reqres.in'}} #Reading the file ExpectedOutput.json and storing same response in variable expectedResult Given expectedResult=read('./resources/ExpectedOutput.json') #Asserting the Actual Response with the Expected Response And match response == expectedResult ##Creating JSON path to verify the values of particular parameters## And match response.ad.url == 'http://statuscode.org/' And match response.data.first_name == 'Janet'

Abaixo está a linha de código, que está realizando as afirmações paramétricas.

And match response.ad.url == 'http://statuscode.org/' And match response.data.first_name == 'Janet'

Usando o caminho JSON, estamos avaliando os valores dos parâmetros.

Executando pós-operações

Até agora, cobrimos os cenários básicos de teste de uma API quando o método era “ OBTER'. Mas quando estamos trabalhando no ambiente real, temos que enviar muitas informações para o servidor, então, nesse caso, usamos o “ PUBLICAR' método .

Esta seção lhe dará uma visão sobre como trabalhar com a solicitação POST básica.

Vamos obter algumas ideias resumidas sobre os parâmetros de que precisamos para enviar a solicitação POST.

# 1) Criar uma solicitação POST, quando o corpo JSON é mencionado no arquivo * .feature

  • Crie um userDetailsPost.feature usando as etapas semelhantes mencionadas no tutorial anterior.
  • Escreva as seguintes linhas de código:
Feature: Posting User Details Scenario: testing the POST call for User Creation Given url 'https://reqres.in/api/users' And request '{'name': 'morpheus','job': 'leader'}' When method POST Then status 201

Por se tratar de uma solicitação POST, que sempre precisa estar acompanhada de um corpo que precisa ser enviado ao servidor para uma determinada resposta, mencionamos isso no seguinte componente:

solicitação: Leva um corpo JSON como a solicitação que é necessária com o método POST.

# 2) Criar uma solicitação POST, quando o corpo JSON é mencionado em um arquivo externo

Normalmente, teremos um corpo de solicitação enorme, que seria difícil de mencionar no *.recurso Arquivo. Portanto, é melhor mantê-lo no arquivo externo.

  • É necessário criar um arquivo PostBody.json em nossa pasta de projetos, conforme mostrado abaixo. Criar um novo recurso de pacote -> Criar um novo arquivo PostBody.json e armazenar o corpo JSON neste arquivo e salvá-lo.

Criação de uma solicitação POST

quando o corpo JSON é mencionado no arquivo externo1

Observação: Mencionamos o corpo do método POST no arquivo JSON acima.

  • Você precisaria escrever o seguinte código em seu userDetailsPost .recurso Arquivo:
Feature: Posting User Details Scenario: testing the POST call for User Creation using External File Given url 'https://reqres.in/api/users' Given postBody=read('./resources/PostBody.json') And request postBody When method POST Then status 201

Estamos lendo o JSON Body do PostBody.json usando as seguintes linhas de código:

Given postBody=read('./resources/PostBody.json')

Observação: Todos userDeatils.feature arquivos que criamos até agora exigirão o básico TestRunner.java arquivo para executá-los, que criamos em nosso tutorial de script de teste básico, conforme mostrado abaixo:

import org.junit.runner.RunWith; import com.intuit.karate.junit4.Karate; @RunWith(Karate.class) public class TestRunner { }

Execute casos de teste em paralelo

Agora, como aprendemos as etapas para criar um script de teste básico e executamos algumas operações básicas na API, é hora de começarmos a trabalhar no ambiente real.

Normalmente, temos que rodar os Casos de Teste em paralelo, para tornar a execução mais rápida. Basicamente, a ideia é obter mais produção em menos tempo.

Este é um recurso central da estrutura e não depende do JUnit, Maven ou Grade. Isso nos permite:

  • Escolha facilmente os recursos e as tags para executar suítes de teste de maneira simples.
  • Veja os resultados paralelos na pasta do plugin surefire.
  • Podemos até integrar os relatórios JSON do Cucumber para uma melhor IU (que será discutida em breve).

No Karate Framework, não precisamos realizar muitas etapas para iniciar a execução paralela de nossos Casos de Teste. Só precisamos seguir as seguintes etapas:

1) Agora precisamos mudar o TestRunner.java arquivo que temos usado até agora. O código para a execução paralela precisa ser escrito no arquivo acima.

Lembre-se da seguinte linha, ao executar seu código em paralelo:

o melhor software de texto para fala

** Não podemos usar a anotação @RunWith (Karate.class) quando estamos tentando trabalhar em um ambiente paralelo.

Abra o original TestRunner.java arquivo e use o seguinte código agora:

import com.intuit.karate.Results; import com.intuit.karate.Runner; import org.junit.Test; // important: do not use @RunWith(Karate.class) ! public class TestRunner { @Test public void testParallel() { Results results = Runner.parallel(getClass(),5); } }

** O código a seguir será aplicável para Dependência de JUnit 4 Maven

No snippet de código acima, incluímos a linha de código abaixo

Resultados de resultados = Runner.parallel (getClass (), 5);

Esta linha está instruindo para executar a instância dos casos de teste em paralelo, buscando dinamicamente as classes no tempo de execução.

dois) Crie uma cópia userDetails.feature arquivo conforme mencionado abaixo sob o src / test / java pasta.

userDetails.feature

Agora estamos prontos para a execução paralela com dois . recursos Arquivo.

3) Vamos para TestRunner.java arquivo criado na etapa acima e execute-o como teste JUnit. Com isso, vamos executar nossos casos de teste em formato paralelo.

Para facilitar a leitura, algumas informações são apresentadas pelo Karate Framework no console, sempre que a execução do Teste é concluída.

O resultado é parecido com o seguinte:

console

Com a execução paralela, todos os recursos serão executados em paralelo e os cenários também serão executados em um formato paralelo.

Seguindo os passos acima, você será capaz de iniciar a Execução Paralela do Teste API, usando o Karate Framework.

** Você pode estudar sobre os testes paralelos percorrendo os vários filtros na página Execução Paralela

Integre o plug-in Cucumber para relatórios

Como estamos usando o Corredor JUnit para a execução de diferentes cenários que foram mencionados nas diferentes *.recurso arquivos, ele cria automaticamente um relatório para cada um dos arquivos de características que são armazenados no caminho relatórios-alvo / infalíveis.

Integrando o plugin Cucumber para relatórios

Isso gera um Relatório formatado de IU básico para apresentar os casos de teste que foram executados.

Porém, os relatórios que estão sendo gerados não são muito agradáveis ​​em termos de IU e, para compartilhar relatórios com as partes interessadas, precisamos de algo que seja mais amigável e compreensível.

A fim de alcançar esse formato de relatório, Karate Framework oferece uma opção para integrar Plugin de relatório de pepino o que nos ajudará na geração de um relatório formatado gráfico, que será mais apresentável.

A seguir estão as etapas para integrar o mesmo:

# 1) Adicione o seguinte Relatório de pepino dependência ao seu POM.xml

net.masterthought cucumber-reporting 3.8.0 test

#dois) Edite o arquivo TestRunner.java quando houver apenas um *.recurso arquivo no projeto.

Precisamos atualizar nosso arquivo TestRunner.java, com o seguinte método generateReport () para o plugin Cucumber.

public class TestRunner { @Test public void testParallel() { generateReport(results.getReportDir()); assertTrue(results.getErrorMessages(), results.getFailCount() == 0); } public static void generateReport(String karateOutputPath) { Collection jsonFiles = FileUtils.listFiles(new File(karateOutputPath), new String() {'json'}, true); final List jsonPaths = new ArrayList(jsonFiles.size()); jsonFiles.forEach(file -> jsonPaths.add(file.getAbsolutePath())); Configuration config = new Configuration(new File('target'), 'demo'); ReportBuilder reportBuilder = new ReportBuilder(jsonPaths, config); reportBuilder.generateReports(); } }

No código mencionado acima, estamos realizando as seguintes ações:

  • Criação de uma nova instância de Arquivo
  • Fornecendo o caminho para armazenar os arquivos na pasta de destino
  • Criação de um objeto ReportBuilder que criará um novo relatório Cucumber

Observação : O código acima funciona bem quando temos um único *. recurso arquivo em nosso projeto.

# 3) Edite o arquivo TestRunner.java quando houver vários * .feature arquivos no Projeto.

Precisaríamos adicionar uma linha de código (destacada em negrito abaixo) para garantir que a execução paralela seja realizada, enquanto os cenários estão sendo executados para a geração do relatório.

public class TestRunner { @Test public void testParallel() { System.setProperty('karate.env', 'demo'); // ensure reset if other tests (e.g. mock) had set env in CI Results results = Runner.parallel(getClass(),5); generateReport(results.getReportDir()); assertTrue(results.getErrorMessages(), results.getFailCount() == 0); } public static void generateReport(String karateOutputPath) { Collection jsonFiles = FileUtils.listFiles(new File(karateOutputPath), new String() {'json'}, true); final List jsonPaths = new ArrayList(jsonFiles.size()); jsonFiles.forEach(file -> jsonPaths.add(file.getAbsolutePath())); Configuration config = new Configuration(new File('target'), 'demo'); ReportBuilder reportBuilder = new ReportBuilder(jsonPaths, config); reportBuilder.generateReports(); } }

Depois de realizar as etapas mencionadas acima, seremos capazes de criar com sucesso um relatório de interface gráfica bem representado usando o Pepino - relatório plugar.

Podemos encontrar o relatório no seguinte caminho em nosso projeto, conforme mostrado na imagem abaixo:

Pepino - relatório

O seguinte relatório foi gerado para o nosso projeto, para todas as operações que realizamos até agora neste Tutorial do Karate Framework:

Relatório

Conclusão

Para resumir, neste tutorial, discutimos as operações básicas que são úteis no dia-a-dia ao trabalhar com o Karate Framework e como executar vários arquivos * .feature em paralelo. Também aprendemos a criar um relatório gráfico para os usuários usando o Relatório de pepino plugar.

Primeiro, discutimos as operações básicas que podem ser realizadas na API. Discutimos como podemos enviar o corpo / solicitação POST para o servidor, seja mencionando o corpo no próprio arquivo * .feature (o que geralmente não é uma prática recomendada) ou usando um arquivo externo (uma prática recomendada, a fim de manter um código limpo).

Em segundo lugar, depois de seguir alguns passos básicos, podemos executar com sucesso o resultado do teste para dois *.recurso arquivos que foram executados em paralelo, apenas adicionando algumas linhas de código no TestRunner.java arquivo que permite o início da execução paralela.

Além disso, aprendemos como transformar o relatório de teste JUnit nativo em um relatório Cucumber integrando o Relatório de pepino plugar. O plugin nos permite gerar relatórios que possuem uma IU melhor, são muito mais compreensíveis para o usuário e, portanto, fornecem uma melhor experiência de usuário para as partes interessadas com quem esses relatórios são compartilhados.

Agora, você deve ser capaz de realizar algumas operações básicas, executar os casos de teste paralelamente e gerar um relatório de fácil leitura para os usuários.

<

Leitura recomendada

^