Características del pepino: una descripción general

Introducción

Gherkin es un lenguaje que todavía se usa en muchos marcos de automatización de pruebas. A veces es porque el cliente nos exige que lo usemos, a veces es porque el equipo así lo decide.

Para ser honesto, no fue amor a primera vista para mí. Personalmente, tengo un viaje bastante largo con Gherkin, desde que me gusta al principio, hasta que detesto el idioma por un tiempo y luego me vuelve a gustar. En este artículo presentaré las características más importantes de Cucumber junto con la implementación de Java.

Aquí están todas las características de Cucumber cubiertas en este artículo:

archivo de características

En primer lugar, ¿qué es un archivo de características? En el mundo técnico, se creó un enfoque no técnico para permitir que personas no técnicas cooperen con el equipo durante el desarrollo de una aplicación. El lenguaje Gherkin se creó como una capa adicional en el enfoque BDD. Las pruebas de Gherkin se encuentran en los llamados archivos de características que se pegan con el código (Java, Kotlin, C#, etc.). Por lo general, Gherkin es muy fácil de usar y requiere un conocimiento mínimo de programación, pero hay funciones que requieren algo de codificación.

Comencemos con algo fácil.

Guión

Este es el ejemplo más básico y fácil de usar de la prueba Cucumber:

 Característica: Escenario

 Antecedentes: antes de los escenarios de prueba
   Dado que ejecuto antes del paso

 @Prueba
 Escenario: Escenario 
   Dado que uso el paso parametrizado del "Escenario 1"

Bloque de código 1. Escenario

El bloque de código 1. contiene algunas cosas que deben explicarse:

• Característica : el título del archivo de característica
• Fondo : la palabra clave que permite al usuario ejecutar pasos de prueba antes de cada escenario de prueba definido en el archivo de características
• @Test : etiqueta que le dice al marco de prueba qué escenario de prueba debe ejecutarse. “Prueba” es definida por el usuario. Podemos usar, por ejemplo, "@SmokeTest"
• Escenario : nombre del escenario de prueba

Las pruebas de pepinillo utilizan las palabras clave [Dado, Cuándo, Entonces, Pero] antes de cada paso de la prueba. En nuestro único paso de prueba, excepto el paso de fondo, usamos un parámetro en el que pasamos el valor "Escenario 1".

Ahora, veamos cómo se ve el código Java pegado:

 @Given("Ejecuto antes del paso")
public void iExecuteBeforeStep() {
   //alguna implementación
}

@Given("Utilizo el paso parametrizado de {cadena}")
public void iUseParametrizedStepOf(String p) {
   //alguna implementación
}

Bloque de código 2. Implementación de código Java de Scenario

Esquema del escenario

Hagamos algo más complejo:

 Característica: esquema del escenario

 @Prueba
 Esquema del escenario: Esquema del escenario
   Dado que ejecuto el paso con "<parámetro1>" y "<parámetro2>"
 Ejemplos:
     | parámetro1 | parámetro2 |
     | parámetro1a | parámetro2a |
     | parámetro1b | parámetro2b |

Bloque de código 3. Esquema del escenario

Esta vez usaremos el esquema de escenario que nos permite repetir escenarios de prueba con diferentes configuraciones de datos de prueba. El bloque de código 3 contiene algunas cosas que deben explicarse:

• Ejemplos : la matriz de datos de prueba que se utilizará en los escenarios de prueba. La primera fila es un encabezado con nombres de parámetros.

Y la implementación de Java:

 @Given("Ejecuto el paso con {cadena} y {cadena}")
vacío público iRunStepWithAnd(String p1, String p2) {
   //alguna implementación
}

Bloque de código 4. Implementación en Java del esquema de escenario

Tabla de datos

El esquema del escenario es muy útil, pero ¿qué pasa si no queremos repetir todo el escenario de prueba sino solo un paso de prueba? Gherkin tiene una forma de hacerlo y se llama "Tabla de datos".

 Característica: tabla de datos

@Prueba
Escenario: Escenario de tabla de datos
 Dado que verifico que la columna contiene el valor esperado
 | nombreColumna | valoresperado |
 | algúnNombreDeColumna | algún valor esperado |

Bloque de código 5. Tabla de datos

El Escenario con Tabla de Datos no difiere mucho del Esquema del Escenario. Lo único es que no ponemos la palabra clave “Ejemplos” antes de la tabla.

La implementación de Java parece un poco más compleja que en los casos anteriores:

 @Given("Verifico que la columna contiene el valor esperado")
public void iVerifyColumnValuesInTableUsingQueryFromFileOnSchema(DataTable dataTable) {
   List<Map<String, String>> data = dataTable.asMaps();
   for (Map<String, String> formulario: datos) {
       String nombreColumna = formulario.get("NombreColumna");
       String resultado esperado = form.get("valoresperado");
       //alguna implementación
       }
   }
}

Bloque de código 6. Implementación Java de tabla de datos

Para acceder a los datos de una tabla de datos, creamos una variable especial dataTable de tipo "DataTable". Todos los datos se almacenarán en la variable Lista.

Contexto del escenario

Usando el contexto del escenario podemos compartir datos entre pasos. Supongamos que tenemos un escenario de dos pasos en el que queremos pasar "datos" de valor del paso 1 al paso 2 (Bloque de código 7).

 @Prueba
Escenario: Contexto del escenario
 Dado que establecí el valor de contexto del escenario "datos"
 Dado que uso el valor de contexto del escenario

Bloque de código 7. Contexto del escenario

En primer lugar, necesitamos crear una clase especial llamada ScenarioContext con características de contexto de escenario para configurar y obtener datos (Bloque de código 8). Nuestro contexto de escenario es un HashMap con un par clave-valor. Estaremos identificando valores por su clave.

• escenarioContext() : HashMap del par clave-valor
• setContext() : método de clave-valor para almacenar datos de contexto de escenario
• getContext() : método para obtener datos proporcionando clave

 contexto de escenario de clase pública {

   privado Map<String, Object> escenarioContexto;

   escenario públicoContext(){
       escenarioContexto = new HashMap<>();
   }

   public void setContext (clave de contexto, valor del objeto) {
       escenarioContexto.put(clave.toString(), valor);
   }

   objeto público getContext (clave de contexto) {
       return escenarioContext.get(key.toString());
   }

}

Contexto de enumeración pública {
   IDENTIFICACIÓN;
}

Bloque de código 8. Implementación Java de la clase Scenario Context

Teniendo esto podemos hacer uso de los métodos implementados. En el paso 1, luego establecemos el valor en el contexto del escenario y en el paso 2 obtenemos el valor (Bloque de código 9).

 ScenarioContext escenarioContext = new ScenarioContext();

@Given("Configuré el valor de contexto del escenario {cadena}")
public void iSetScenarioContextValue(valor de cadena) {
   escenarioContext.setContext(Context.ID, valor);
}

@Given("Uso el valor de contexto del escenario")
vacío público iUseScenarioContextValue() {
   String sharedValue = escenarioContext.getContext(Context.ID).toString();
}

Bloque de código 9. Pasos del contexto del escenario

Tipos de datos de pepino

Cucumber maneja un número limitado de tipos de datos. Podemos definir cadenas, enteros y valores flotantes, pero en el caso de valores booleanos, necesitamos codificar algunas soluciones.

 @Prueba
Escenario: Escenario con variables
 Dado que uso string "string", int 1, float 1.1 y boolean "false"

Bloque de código 10. Tipos de datos de pepino

El código Java se vería así:

 @Given("Uso string {string}, int {int}, float {float} y boolean {string}")
public void iUseStringIntFloatAndBoolean(String var1, int var2, double var3, String var4) {
   booleano f = Boolean.valueOf(var4);
   // algún código
}

Bloque de código 11. Implementación Java de tipos de datos de pepino

Expresión regular de pepino

Esta es otra característica de uso frecuente. El bloque de código 12 muestra un escenario de dos pasos que difieren solo en el uso de diferentes valores de variables (var1 y var2). De hecho, esto es solo un paso, y en el código Java (Bloque de código 13) definimos solo un método pero con expresiones regulares y un parámetro var.

 @Prueba
Escenario: Escenario de expresiones regulares
 Dado que uso la variable var1
 Dado que uso la variable var2

Bloque de código 12. Expresión regular en Pepino

 @Given("^Uso variable (.*)")
public void examTimeTableInSummerSeason(String var) {
   si (var.equals("var1")){
       // algún código
   }
   else if(var.equals("var2")){
       // algún código
   }
}

Bloque de código 13. Implementación en Java de la expresión regular Cucumber

Ganchos de pepino

Por último, pero no menos importante: ganchos de pepino.

El bloque de código 14 presenta los 4 ganchos más importantes:

• @Before : ejecuta el código antes de cada escenario de prueba
• @After : ejecuta el código después de cada escenario de prueba
• @BeforeStep : ejecuta código antes de cada paso de prueba
• @AfterStep : ejecuta el código después de cada paso de prueba

 @Antes
public void beforeScenario() {
   // algún código
}

@Después
public void afterScenario() {
   // algún código
}

@AntesdelPaso
vacío público antes del paso () {
   // algún código
}

@después del paso
public void afterStep() {
   // algún código
}

Bloque de código 14. Ganchos de pepino

Resumen

Espero haberte convencido de usar Gherkin en tus pruebas. Estas pocas características harán que sus pruebas sean más legibles y fáciles de entender por personas sin conocimientos técnicos. Además, para los nuevos miembros será más fácil comprender la lógica empresarial y reducir el tiempo de incorporación.