TL;DR

  • Karate = testing de API BDD sin código Java (tests en archivos .feature)
  • Sintaxis: Given/When/Then con assertions JSON/XML incorporadas
  • No se necesitan step definitions separadas — assertions incorporadas en DSL
  • Incluye mocking, testing de performance, ejecución paralela
  • Corre en JVM pero tests escritos en sintaxis tipo Gherkin

Ideal para: Equipos que quieren BDD sin programación, desarrollo rápido de tests API Omite si: Necesitas control programático completo (usa REST Assured) Tiempo de lectura: 14 minutos

Tu equipo quiere tests de API estilo BDD pero no tiene desarrolladores Java. Escribir step definitions se siente como boilerplate. Necesitas algo más rápido que configuraciones tradicionales de Cucumber.

Karate combina sintaxis BDD con assertions incorporadas — no necesitas código glue. Escribe tests en archivos feature, ejecútalos inmediatamente. JSON matching, validación de schemas, data-driven testing — todo funciona out of the box.

¿Qué es Karate?

Karate es un framework open-source de testing de API que usa un DSL tipo Gherkin. A diferencia de Cucumber, no requiere step definitions — todo está incorporado en la sintaxis.

Por qué Karate:

  • Sin código Java — tests escritos en archivos .feature
  • Assertions incorporadas — matching JSON/XML sin código
  • Ejecución paralela — ejecuciones rápidas de test suites
  • Mocking — servidor mock incorporado
  • Performance — testing de carga con integración Gatling

Setup

Maven

<dependency>
    <groupId>com.intuit.karate</groupId>
    <artifactId>karate-junit5</artifactId>
    <version>1.4.1</version>
    <scope>test</scope>
</dependency>

Estructura del proyecto

src/test/java/
├── karate-config.js          # Config global
├── logback-test.xml          # Logging
└── examples/
    ├── users/
    │   ├── users.feature     # Escenarios de test
    │   └── UsersRunner.java  # JUnit runner
    └── products/
        └── products.feature

Tu primer test

Request GET básico

Feature: User API

  Scenario: Get all users
    Given url 'https://api.example.com/users'
    When method get
    Then status 200
    And match response == '#array'
    And match each response contains { id: '#number', name: '#string' }

POST con body JSON

Scenario: Create new user
  Given url 'https://api.example.com/users'
  And request { name: 'John Doe', email: 'john@example.com' }
  When method post
  Then status 201
  And match response contains { id: '#number', name: 'John Doe' }

JSON Assertions

Match exacto

* match response == { id: 1, name: 'John', active: true }

Match parcial

* match response contains { name: 'John' }

Verificación de tipos

# Match de tipos con marcadores
* match response.id == '#number'
* match response.name == '#string'
* match response.email == '#? _.contains("@")'
* match response.roles == '#array'
* match response.metadata == '#object'
* match response.deleted == '#null'
* match response.optional == '##string'  # Opcional (puede ser null)

Assertions de arrays

* match response == '#[3]'                    # Exactamente 3 items
* match response == '#[]'                      # Cualquier array
* match each response == { id: '#number' }     # Cada item coincide
* match response contains { id: 1 }            # Array contiene item
* match response !contains { id: 999 }         # Array no contiene

Variables y reutilización

Definir variables

Feature: User Management

  Background:
    * url 'https://api.example.com'
    * def authToken = 'Bearer abc123'

  Scenario: Get user profile
    Given path '/users/me'
    And header Authorization = authToken
    When method get
    Then status 200

Extraer de la respuesta

Scenario: Create and fetch user
  Given url 'https://api.example.com/users'
  And request { name: 'John' }
  When method post
  Then status 201
  * def userId = response.id

  Given url 'https://api.example.com/users/' + userId
  When method get
  Then status 200
  And match response.name == 'John'

Llamar otros features

# auth.feature
Feature: Authentication
  Scenario: Get token
    Given url 'https://api.example.com/auth'
    And request { username: 'test', password: 'secret' }
    When method post
    Then status 200
    * def token = response.token

# users.feature
Feature: Users
  Background:
    * def auth = call read('auth.feature')
    * def token = auth.token

  Scenario: Get protected resource
    Given url 'https://api.example.com/profile'
    And header Authorization = 'Bearer ' + token
    When method get
    Then status 200

Testing Data-Driven

Scenario Outline

Feature: User validation

  Scenario Outline: Validate user creation
    Given url 'https://api.example.com/users'
    And request { name: '<name>', email: '<email>' }
    When method post
    Then status <status>

    Examples:
      | name  | email             | status |
      | John  | john@example.com  | 201    |
      | ''    | test@example.com  | 400    |
      | Jane  | invalid-email     | 400    |

Configuración

karate-config.js

function fn() {
  var env = karate.env || 'dev';
  var config = {
    baseUrl: 'https://api.example.com'
  };

  if (env === 'dev') {
    config.baseUrl = 'https://dev-api.example.com';
  } else if (env === 'staging') {
    config.baseUrl = 'https://staging-api.example.com';
  }

  karate.configure('headers', { 'Content-Type': 'application/json' });

  return config;
}

Ejecución paralela

Parallel Runner

import com.intuit.karate.Results;
import com.intuit.karate.Runner;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class ParallelRunner {
    @Test
    void testParallel() {
        Results results = Runner.path("classpath:examples")
            .parallel(5);  // 5 threads
        assertEquals(0, results.getFailCount(), results.getErrorMessages());
    }
}

Integración CI/CD

GitHub Actions

name: API Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Java
        uses: actions/setup-java@v4
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Run Karate tests
        run: mvn test -Dkarate.env=staging

      - name: Upload reports
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: karate-reports
          path: target/karate-reports/

Karate con Asistencia de IA

Las herramientas de IA pueden ayudar a escribir y mantener tests de Karate.

Lo que la IA hace bien:

  • Generar archivos feature desde documentación de API
  • Crear expresiones de match JSON
  • Convertir colecciones de Postman a Karate
  • Sugerir escenarios de test data-driven

Lo que necesita humanos:

  • Diseñar estrategia de testing
  • Entender reglas de validación de negocio
  • Lógica condicional compleja
  • Configuración de tests de performance

FAQ

¿Qué es Karate?

Karate es un framework de testing de API BDD que usa sintaxis tipo Gherkin. A diferencia de Cucumber, no necesitas step definitions en Java — las assertions están incorporadas en el DSL. Escribe escenarios Given/When/Then en archivos .feature y ejecútalos inmediatamente. También incluye mocking, testing de performance y capacidades de automatización UI.

¿Karate vs REST Assured — cuál es mejor?

Karate no requiere programación Java — los tests se escriben en archivos .feature usando sintaxis DSL. REST Assured requiere código Java para todo. Karate es más rápido de aprender y más fácil para no-programadores. REST Assured ofrece más control programático y mejor soporte de IDE. Elige Karate para desarrollo rápido de tests, REST Assured para necesidades programáticas complejas.

¿Puede Karate testear GraphQL?

Sí, Karate maneja GraphQL como JSON sobre HTTP. Usa la misma sintaxis de request/response para queries y mutations. Las variables de GraphQL funcionan a través del manejo estándar de JSON. El framework no distingue GraphQL de REST — todo es HTTP con bodies JSON.

¿Karate soporta ejecución paralela?

Sí, la ejecución paralela está incorporada y es fácil de configurar. Ejecuta features en múltiples threads con una configuración simple de Runner. Karate maneja thread safety y aislamiento de recursos automáticamente. Esto lo hace ideal para suites de test grandes que necesitan feedback rápido de CI/CD.

Recursos Oficiales

Ver También