Karate vs. Cucumber: Comparativa de Frameworks para Pruebas Automatizadas de APIs

Las empresas cada vez están adoptando más prácticas innovadoras para sus proyectos de software, para mejorar la calidad en el desarrollo y entrega de un proyecto.

Lo anterior implica dejar atrás metodologías tradicionales y sumar el desarrollo ágil como nueva forma de llevar a cabo los proyectos. 

Este ecosistema innovador, ágil, donde existe una integración y despliegue continuo, y que implica realizar iteraciones de manera frecuente, requiere de mayor cantidad de entregables que la tradicional, puesto que el producto va creciendo en funcionalidad en cada iteración y construyéndose integrando al cliente.

Al hablar de agilidad, es común que la primera palabra en la que pensemos sea Scrum, ya que es de las metodologías más usadas en el desarrollo ágil.  Sin embargo, hay muchas otras menos utilizadas o poco comunes, como XP, Kanban, Lean. 

Estas metodologías permiten lograr mejores resultados, y responder a los cambios con mayor rapidez y flexibilidad, integrando a los clientes en todo el proceso de desarrollo. La filosofía de estas metodologías está sostenida bajo el manifiesto ágil.

Sobre la aplicación de metodologías de desarrollo ágiles, debes considerar la construcción del producto bajo estos principios fundamentales:

• El software debe mantener simplicidad en lo posible.
• Debe tener una rápida retroalimentación.
• estructura debe permitir un cambio incremental.
• Que el software sea un trabajo de calidad.

Bajo estos principios y pensando en la naturaleza del desarrollo de software, donde se integran cambios de manera incremental y continua, es clave mantener la calidad y funcionalidad.

¿Cómo mantener la calidad y funcionalidad del software? 

Puedes lograrlo a través de pruebas automatizadas.

Las pruebas automatizadas ayudan en este proceso continuo de cambios y entregas, porque una vez que automatizas el set de pruebas, podrás visualizar de manera temprana que un cambio hizo perder alguna funcionalidad en el software o pieza modificada.

Frameworks para las pruebas Automatizadas

Karate y Cucumber son dos frameworks para pruebas automatizadas y queremos mostrarte cuál entrega mejores resultados en términos de usabilidad y compatibilidad.

Cucumber y Karate están basados en la metodología BDD (Behavior Driven Development), siendo ésta una mejora de TDD (Test Driven Development), una metodología de desarrollo basada en pruebas. BDD a diferencia de TDD, incluye al negocio y permite que tanto el equipo técnico como el de negocio se relacionen a través de un lenguaje común llamado Gherkin, usado para describir el comportamiento del software. Usa cinco sentencias generales:

• Feature: nos indica la característica del software.
• Scenario: nos indica en qué escenario se realizará la prueba.
• Given: nos indica que “dado que” exista un escenario se realizará la prueba.
• When: nos indica que “cuando exista una condición” se realizará la prueba.
• Then: nos indica que “entonces” ocurrirá un comportamiento esperado en la prueba.

Ahora que has visto cómo funciona el lenguaje gherkin, podemos revisar los frameworks que usaremos para hacer las pruebas automatizadas.

Cucumber

Para este ejercicio usaremos Cucumber con JVM.  Si estás usando otro lenguaje que no es Java, existen otras integraciones. Usaremos Maven para las dependencias.  En el  pom.xml se agrega lo siguiente: 

Cucumber Spring integration

Para agregar cucumber-jvm:

<dependency>    
	<groupId>io.cucumber</groupId>    
  <artifactId>cucumber-java</artifactId>    
  <version>6.8.0</version>    
  <scope>test</scope>
</dependency>

‍

Luego, agregamos la dependencia de Junit y cucumber:

<dependency>    
  <groupId>io.cucumber</groupId>    
  <artifactId>cucumber-junit</artifactId>    
  <version>6.8.0</version>    
  <scope>test</scope>
</dependency>

<dependency>    
  <groupId>io.cucumber</groupId>    
  <artifactId>cucumber-junit</artifactId>    
  <version>6.8.0</version>    
  <scope>test</scope>
</dependency>

Finalmente, agregamos, la dependencia de Spring:

<dependency>    
  <groupId>io.cucumber</groupId>    
  <artifactId>cucumber-spring</artifactId>    
  <version>6.8.0</version>    
  <scope>test</scope>
</dependency>

‍

Posteriormente debes configurar el servicio REST.  Para este ejemplo se usará una api REST con una lista de juegos disponibles.

Cucumber Steps Definitions

Para correr las pruebas cucumber con Junit, es necesario definir los pasos, crear una clase vacía con la anotación @RunWith(Cucumber.class) y @CucumberOptions para definir las opciones que usaremos.

Luego, en la ruta "src/test/resources/features/"  debes escribir los archivos que contienen las características de las pruebas escritas en lenguaje Gherkin.

Este escenario hace una llamada GET al servicio que entrega la lista de juegos y valida que la información se despliega correctamente.

Luego de tener este escenario creado en gherkin, debes codificar los steps de cada feature en java, para esto crea una clase que contenga los mismos pasos para que sean reconocidos los steps.

NOTA: debemos utilizar Rest-Assured para validar las respuestas de la Api.

Ahora tienes todo lo necesario para ejecutar la prueba. Ejecuta la prueba con Junit en la clase RunTest que hemos creado. Si todo está correcto, las pruebas se ejecutaron correctamente.

Para ver el reporte puedes usar cucumber-reporting.

Ahora pasamos a Karate.

Karate BDD

Karate es un framework sencillo de testing al igual que Cucumber y tiene herramientas incluidas que lo hacen muy eficaz. Así lo describen sus creadores: 

“Karate es la única herramienta de código abierto que combina la automatización de pruebas de API, simulaciones, pruebas de rendimiento e incluso la automatización de la interfaz de usuario en un marco único y unificado. La sintaxis BDD popularizada por Cucumber es un lenguaje neutro y fácil incluso para los no programadores. Se incorporan poderosas afirmaciones JSON y XML, y puede ejecutar pruebas en paralelo para mayor velocidad "

Para este ejemplo no utilizaremos todas las herramientas, pero si varias para realizar el mismo ejercicio que con Cucumber y hacer la comparación.

Primero Agrega al pom las siguientes dependencias:

<!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->        
<dependency>            
    <groupId>org.mockito</groupId>            
    <artifactId>mockito-core</artifactId>            
    <version>${mockito.version}</version>            
    <scope>test</scope>        
</dependency>

<!-- https://mvnrepository.com/artifact/com.intuit.karate/karate-apache -->        
<dependency>            
    <groupId>com.intuit.karate</groupId>            
    <artifactId>karate-apache</artifactId>            
    <version>${karate.version}</version>            
    <scope>test</scope>        
</dependency>

<!-- https://mvnrepository.com/artifact/com.intuit.karate/karate-junit5 -->        
<dependency>            
    <groupId>com.intuit.karate</groupId>            
    <artifactId>karate-junit5</artifactId>            
    <version>${karate.version}</version>            
    <scope>test</scope>        
</dependency>  
        
<dependency>	
    <groupId>com.intuit.karate</groupId>	
    <artifactId>karate-junit4</artifactId>
    <version>0.9.5</version>	
    <scope>test</scope>
</dependency>  
      
<build>        
    <testResources>            
        <testResource>                
            <directory>src/test/java</directory>                
            <excludes>                    
                <exclude>**/*.java</exclude>                
            </excludes>            
        </testResource>        
    </testResources>   
         
    <plugins>            
        <plugin>                
            <groupId>org.springframework.boot</groupId>                
            <artifactId>spring-boot-maven-plugin</artifactId>            
        </plugin>  
                  
        <plugin>                
            <groupId>org.apache.maven.plugins</groupId>                
            <artifactId>maven-surefire-plugin</artifactId>                
            <version>2.22.1</version>                
            <configuration>                    
                <excludes>                        
                    <exclude>karate/**/*.java</exclude>                    
                </excludes>                    
                <includes>                        
                    <include>com/**/*.java</include>                    
                </includes>                
            </configuration>            
        </plugin>        
    </plugins>
</build>

‍

Luego crea una clase runner para agregar las librerías de Karate y posteriormente ejecutar desde ahí las pruebas. En la clase, el método que ejecuta las pruebas debe tener la anotación @Karate.Test:

Luego crea el archivo feature que contendrá los escenarios y los steps a ejecutar:

@Tag games
Feature: Get list of games  
    Background:    
        * def baseUrl = 'https://api-gamelist.herokuapp.com'    
        * def gameBase = '/games'  
    Scenario: Get the game list    
        Given baseUrl+gameBase    
        And header Accept = 'application/json'    
        When method GET    
        Then status 200

‍

Luego corre las pruebas. Esto generará automáticamente un reporte en html:

Imagen: Resultados con Karate

Ahora que ya conocimos ambos frameworks podemos sacar conclusiones! 

Si bien ambos frameworks funcionan de manera similar, Karate es más simple de usar que Cucumber. Veamos las ventajas de ambos frameworks:

Ventajas de Karate:

• Con Karate no es necesario ser experto en programación para poder implementarlo.
• A diferencia de Cucumber, puedes ejecutar tests simultáneamente.
• En Karate realizamos las validaciones de las respuestas directamente en el archivo feature e incluso nos permite comparar respuestas, ya que funciona nativamente con archivos Json.
• Al incluir ciertas herramientas, genera de manera automática reportes para visualizar el resultado de las pruebas, mientras que Cucumber necesita ser configurado y además se debe agregar una dependencia que permita visualizar con una interfaz gráfica los resultados.
• Se necesita de menos configuraciones para lograr el mismo resultados.
• No necesitamos incluir otras librerías adicionales para realizar el mismo trabajo (Rest-assured, Serenity BDD, cucumber-report).

Ventajas de Cucumber:

• Cucumber puede ser ejecutado desde Maven o desde Junit usando la misma configuración.

• Cucumber permite usar distintas librerías o frameworks que interpretan los resultados para ser mostrados en gráficos de torta con una interfaz mucho más amigable y de mejor comprensión.

• Puedes usar los reportes generados por cucumber en herramientas de gestión de proyectos como Jira vía la integración de Xray.

• Puedes usar Cucumber con Selenium, si tus pruebas van más allá del backend y necesitas además testear el frontend.

¿Karate o Cucumber: Cual es mejor?

Ambas herramientas son potentes y la que elijas dependerá de cada caso y de la manera que necesites visualizar los resultados. Si lo que necesitas es entregar información a un nivel gerencial, con una mejor interfaz gráfica, y mejor interpretación de los resultados, Cucumber es la mejor alternativa si la complementas con Serenity BDD u otro componente para visualizar resultados. Si lo que necesitas es graficar los resultados para un área técnica, Karate es la alternativa más ágil, porque obtendrás los mismos resultados con menos pasos y complejidad.

¿Listo para optimizar tus pruebas de APIs con las mejores herramientas?

En Kranio, contamos con expertos en automatización de pruebas que te ayudarán a implementar frameworks como Karate y Cucumber, mejorando la calidad y eficiencia de tus desarrollos. Contáctanos y descubre cómo podemos impulsar tus proyectos tecnológicos.