Características do pepino: uma visão geral

Introdução

Gherkin é uma linguagem ainda usada em muitos frameworks de automação de testes. Às vezes é porque o cliente exige que usemos, às vezes é porque a equipe decide fazê-lo.

Para ser honesto, não foi amor à primeira vista para mim. Pessoalmente, tenho uma longa jornada com Gherkin – desde gostar no começo, detestar o idioma por um tempo e depois acabar gostando novamente. Neste artigo apresentarei os recursos mais importantes do Cucumber juntamente com a implementação Java.

Aqui estão todos os recursos do Cucumber abordados neste artigo:

Arquivo de recurso

Em primeiro lugar, o que é um arquivo de recurso? No mundo técnico, uma abordagem não técnica foi criada para permitir que pessoas não técnicas cooperem com a equipe durante o desenvolvimento de um aplicativo. A linguagem Gherkin foi criada como uma camada adicional na abordagem BDD. Os testes do Gherkin estão localizados nos chamados arquivos de recursos que são colados com o código (Java, Kotlin, C# etc.). Normalmente, o Gherkin é muito fácil de usar e requer conhecimento mínimo de programação, mas existem recursos que exigem alguma codificação.

Vamos começar com algo fácil.

Cenário

Aqui está o exemplo mais básico e fácil de usar do teste do Cucumber:

 Recurso: Cenário

 Histórico: Cenários de teste antes
   Dado que eu executo antes da etapa

 @Teste
 Cenário: Cenário 
   Dado que uso o passo parametrizado do "Cenário 1"

Bloco de código 1. Cenário

O Bloco de Código 1. contém algumas coisas a serem explicadas:

• Recurso : o título do arquivo de recurso
• Background : a palavra-chave que permite ao usuário executar etapas de teste antes de cada cenário de teste definido no arquivo de recursos
• @Test : Tag que informa ao framework de teste qual cenário de teste deve ser executado. “Teste” é definido pelo usuário. Podemos usar, por exemplo, “@SmokeTest”
• Cenário : nome do cenário de teste

Os testes Gherkin usam as palavras-chave [Given, When, Then, But] antes de cada etapa do teste. Em nossa única etapa de teste, exceto a etapa Background, usamos um parâmetro no qual passamos o valor “Cenário 1”.

Agora, vamos ver como é o código Java colado:

 @Given("Eu executo antes do passo")
public void iExecuteBeforeStep() {
   //alguma implementação
}

@Given("Eu uso a etapa parametrizada de {string}")
public void iUseParametrizedStepOf(String p) {
   //alguma implementação
}

Bloco de código 2. Implementação de código Java do cenário

Esboço do Cenário

Vamos fazer algo mais complexo:

 Recurso: esboço do cenário

 @Teste
 Esboço do Cenário: Esboço do Cenário
   Dado que eu executo a etapa com "<parameter1>" e "<parameter2>"
 Exemplos:
     | parâmetro1 | parâmetro2 |
     | parâmetro1a | parâmetro2a |
     | parâmetro1b | parâmetro2b |

Bloco de código 3. Esboço do cenário

Desta vez, usaremos o Scenario Outline, que nos permite repetir cenários de teste com diferentes configurações de dados de teste. O bloco de código 3 contém algumas coisas a serem explicadas:

• Exemplos : a matriz de dados de teste a ser usada pelos cenários de teste. A primeira linha é um cabeçalho com nomes de parâmetros.

E implementação java:

 @Given("Eu executo a etapa com {string} e {string}")
public void iRunStepWithAnd(String p1, String p2) {
   //alguma implementação
}

Bloco de código 4. Implementação Java do Scenario Outline

Tabela de dados

O Scenario Outline é muito útil, mas e se não quisermos repetir todo o cenário de teste, mas apenas uma etapa de teste? Gherkin tem uma maneira de fazer isso e é chamado de "Tabela de Dados".

 Recurso: Tabela de dados

@Teste
Cenário: Cenário da Tabela de Dados
 Dado que verifico que a coluna contém o valor esperado
 | nomedacoluna | valor esperado |
 | someColumnName | someExpectedValue |

Bloco de Código 5. Tabela de Dados

O Cenário com Tabela de Dados não difere muito do Esboço do Cenário. A única coisa é que não colocamos a palavra-chave “Exemplos” antes da tabela.

A implementação Java parece um pouco mais complexa do que nos casos anteriores:

 @Given("Verifico que a coluna contém o valor esperado")
public void iVerifyColumnValuesInTableUsingQueryFromFileOnSchema(DataTable dataTable) {
   List<Map<String, String>> data = dataTable.asMaps();
   for (Map<String, String> form : data) {
       String columnName = form.get("columnName");
       String resultado esperado = form.get("valor esperado");
       //alguma implementação
       }
   }
}

Bloco de Código 6. Implementação Java da Tabela de Dados

Para acessar dados de uma tabela de dados, criamos uma variável especial dataTable do tipo “DataTable”. Todos os dados serão armazenados na variável List.

Contexto do Cenário

Usando o Contexto do Cenário, podemos compartilhar dados entre as etapas. Vamos supor que temos um cenário de duas etapas no qual queremos passar o valor “dados” da etapa 1 para a etapa 2 (Bloco de código 7).

 @Teste
Cenário: Contexto do Cenário
 Dado que defino o valor do contexto do cenário "dados"
 Dado que eu uso o valor de contexto do cenário

Bloco de Código 7. Contexto do Cenário

Em primeiro lugar, precisamos construir uma classe especial chamada ScenarioContext com recursos de contexto de cenário de configuração e obtenção de dados (Bloco de Código 8). Nosso contexto de cenário é um HashMap com um par chave-valor. Estaremos identificando valores por sua chave.

• cenárioContext() : HashMap do par chave-valor
• setContext() : método de valor-chave para armazenar dados de contexto de cenário
• getContext() : método para obter dados fornecendo chave

 classe pública CenárioContext {

   private Map<String, Object> cenárioContext;

   público cenárioContext(){
       cenárioContext = new HashMap<>();
   }

   public void setContext(chave de contexto, valor do objeto) {
       cenárioContext.put(key.toString(), valor);
   }

   public Object getContext(chave de contexto){
       return cenárioContext.get(key.toString());
   }

}

public enum Contexto {
   EU IRIA;
}

Bloco de código 8. Implementação Java da classe Scenario Context

Tendo isso, podemos fazer uso de métodos implementados. Na etapa 1, definimos o valor no contexto do cenário e na etapa 2 obtemos o valor (Bloco de código 9).

 CenárioContext cenárioContext = new CenárioContext();

@Given("Eu defini o valor de contexto do cenário {string}")
public void iSetScenarioContextValue(valor da string) {
   cenárioContext.setContext(Context.ID, valor);
}

@Given("Eu uso o valor de contexto do cenário")
public void iUseScenarioContextValue() {
   String sharedValue = cenárioContext.getContext(Context.ID).toString();
}

Bloco de código 9. Etapas do contexto do cenário

Tipos de dados de pepino

O Cucumber lida com um número limitado de tipos de dados. Podemos definir strings, inteiros e valores float, mas no caso de valores booleanos, precisamos codificar algumas soluções alternativas.

 @Teste
Cenário: Cenário com variáveis
 Dado que uso string "string", int 1, float 1.1 e boolean "false"

Bloco de Código 10. Tipos de Dados Pepino

O código Java ficaria mais ou menos assim:

 @Given("Eu uso string {string}, int {int}, float {float} e boolean {string}")
public void iUseStringIntFloatAndBoolean(String var1, int var2, double var3, String var4) {
   boolean f = Boolean.valueOf(var4);
   //algum código
}

Bloco de Código 11. Implementação Java de Tipos de Dados Cucumber

Expressão Regular Pepino

Esse é outro recurso usado com frequência. O Bloco de Código 12 mostra um cenário de duas etapas que diferem apenas pelo uso de valores de variáveis ​​diferentes (var1 e var2). Na verdade, este é apenas um passo, e no código Java (Bloco de Código 13) definimos apenas um método, mas com regex e um parâmetro var.

 @Teste
Cenário: cenário de expressão regular
 Dado que eu uso a variável var1
 Dado que eu uso a variável var2

Bloco de código 12. Expressão regular em pepino

 @Given("^Eu uso variável (.*)")
public void examTimeTableInSummerSeason(String var) {
   if (var.equals("var1")){
       //algum código
   }
   else if(var.equals("var2")){
       //algum código
   }
}

Bloco de código 13. Implementação Java da expressão regular Cucumber

Ganchos de Pepino

Por último, mas não menos importante: ganchos de pepino.

O bloco de código 14 apresenta os 4 ganchos mais importantes:

• @Before : Executa o código antes de cada cenário de teste
• @After : Executa o código após cada cenário de teste
• @BeforeStep : Executa o código antes de cada etapa de teste
• @AfterStep : Executa o código após cada etapa de teste

 @Antes da
public void antes do Cenário() {
   //algum código
}

@Depois
public void após Cenário() {
   //algum código
}

@BeforeStep
public void antes da Etapa() {
   //algum código
}

@AfterStep
public void apósEtapa() {
   //algum código
}

Bloco de Código 14. Ganchos de Pepino

Resumo

Espero tê-lo convencido a usar Gherkin em seus testes. Esses poucos recursos tornarão seus testes mais legíveis e fáceis de entender por pessoas não técnicas. Também para os novos participantes, será mais fácil entender a lógica do negócio e diminuir o tempo de integração.