✅ Tipos de Checks en k6

Por Mariano Imende

- Lectura en 8 minutos - 1574 palabras

Tipos de Checks en k6

En k6, los checks son aserciones que permiten validar las respuestas de tus solicitudes HTTP. A continuación, se describen los tipos comunes de checks que puedes usar:

1. Checks de Código de Estado

Verifica que el código de estado de la respuesta sea el esperado.

check(res, {
    'el código de estado es 200': (r) => r.status === 200,
});

Checks de Tiempo de Respuesta

Comprueba que el tiempo de respuesta esté dentro de los límites aceptables.

check(res, {
    'el tiempo de respuesta es menor a 200ms': (r) => r.timings.duration < 200,
});

3. Checks del Cuerpo de la Respuesta

Valida contenido específico en el cuerpo de la respuesta. Útil para comprobar que los datos esperados se devuelvan.

check(res, {
    'el cuerpo contiene "success"': (r) => r.body.includes('success'),
});

// Para respuestas JSON:
const jsonResponse = JSON.parse(res.body);
check(jsonResponse, {
    'los datos existen': (j) => j.data !== undefined,
    'el id del usuario es 1': (j) => j.user.id === 1,
});

4. Checks de Cabeceras

Verifica que ciertas cabeceras estén presentes o tengan valores esperados.

check(res, {
    'Content-Type es application/json': (r) => r.headers['Content-Type'] === 'application/json',
});

5. Checks Combinados

Puedes combinar múltiples checks para validar completamente una respuesta.

check(res, {
    'el código de estado es 200': (r) => r.status === 200,
    'el cuerpo contiene "success"': (r) => r.body.includes('success'),
    'Content-Type es application/json': (r) => r.headers['Content-Type'] === 'application/json',
});

6. Checks con Lógica Personalizada

Implementa lógica personalizada para validaciones más complejas.

function validarUsuario(usuario) {
    return usuario.age > 18 && usuario.active === true;
}

check(jsonResponse, {
    'el usuario es válido': () => validarUsuario(jsonResponse),
});

7. Checks de Manejo de Errores

Valida respuestas específicas de error o códigos de estado para asegurarte de que tu aplicación falle de manera controlada.

if (res.status === 404) {
    check(jsonResponse, {
        'el mensaje de error es correcto': (obj) => obj.error === 'Not Found',
        'el código de error es 404': (obj) => obj.code === 404,
    });
}

8. Validación de JSON Anidado

Cuando trabajes con objetos JSON profundamente anidados, verifica la estructura y el contenido.

check(jsonResponse, {
    'los detalles del usuario son correctos': (obj) => obj.user && obj.user.id === 1 && obj.user.details.age > 18,
    'los títulos de las publicaciones están presentes': (obj) => Array.isArray(obj.posts) && obj.posts.every(post => post.title !== undefined),
});

9. Combinar Condiciones

Puedes combinar checks usando operadores lógicos.

check(res, {
    'el código de estado es 200 y Content-Type es JSON': (r) => r.status === 200 && r.headers['Content-Type'] === 'application/json',
});

10. Validación en Bucles

Verifica múltiples elementos en un arreglo.

const validPosts = jsonResponse.posts.filter(post => post.published);

check(validPosts, {
    'todas las publicaciones publicadas tienen títulos': () => validPosts.every(post => post.title !== undefined),
});

11. Checks con Funciones Personalizadas

Encapsula lógica compleja en funciones reutilizables.

function esUsuarioValido(usuario) {
    return usuario && usuario.id > 0 && usuario.active === true && usuario.roles.includes('user');
}

check(jsonResponse, {
    'el usuario es válido': () => esUsuarioValido(jsonResponse.user),
});

12. Checks Condicionales

Realiza checks que dependan de resultados previos.

let usuarioExiste = false;

if (res.status === 200) {
    const jsonResponse = JSON.parse(res.body);
    usuarioExiste = jsonResponse.user !== null;
}

check(res, {
    'el usuario existe': () => usuarioExiste,
});

13. Uso de Umbrales para Rendimiento y Validaciones

Puedes combinar verificaciones (checks) con umbrales de rendimiento para garantizar que las respuestas cumplan con los tiempos establecidos.

import { check } from 'k6';

check(res, {
    'el tiempo de respuesta es aceptable': (r) => r.timings.duration < 200,
    'el código de estado es 200': (r) => r.status === 200,
});

// Establecer umbrales para aplicar requerimientos de rendimiento
export const thresholds = {
    'response_time': ['p(95)<200'], // El 95% de las respuestas deben ser menores a 200ms
};

14. Verificación de Patrones Específicos en la Respuesta

Para APIs que devuelven patrones específicos (por ejemplo, IDs con formato específico), puedes usar expresiones regulares.

const jsonResponse = JSON.parse(res.body);

check(jsonResponse, {
    'el ID de usuario tiene un patrón válido': (obj) => /^user_\d+$/.test(obj.id),
});

15. Rendimiento y Validación Combinados

Puedes medir tiempos de respuesta mientras validas el contenido de las respuestas.

check(res, {
    'el tiempo de respuesta es aceptable': (r) => r.timings.duration < 300,
    'el cuerpo de la respuesta es válido': (r) => {
        const jsonResponse = JSON.parse(r.body);
        return jsonResponse && jsonResponse.success === true;
    },
});

16. Validación Cruzada de Datos

Cuando trabajas con múltiples puntos de datos, puedes validar las relaciones entre ellos.

const userResponse = http.get('https://api.example.com/users/1');
const postResponse = http.get('https://api.example.com/posts');

check(userResponse, {
    'el usuario existe': (r) => r.status === 200,
});

check(postResponse, {
    'todas las publicaciones pertenecen al usuario': (r) => {
        const posts = r.json();
        return posts.every(post => post.userId === userResponse.json().id);
    },
});

17. Resultados Agregados de Verificaciones

Puedes agregar resultados de múltiples verificaciones y proporcionar un resumen consolidado.

let checkResults = {
    validStatus: false,
    validContent: false,
};

check(res, {
    'el estado es 200': (r) => {
        checkResults.validStatus = r.status === 200;
        return checkResults.validStatus;
    },
    'la respuesta contiene datos esperados': (r) => {
        const jsonResponse = JSON.parse(r.body);
        checkResults.validContent = jsonResponse.data !== undefined;
        return checkResults.validContent;
    },
});

// Registrar resultados de las verificaciones
console.log(`Resultados: Estado válido? ${checkResults.validStatus}, Contenido válido? ${checkResults.validContent}`);

18. Validación con Librerías Externas

Si necesitas validaciones más avanzadas, puedes usar librerías externas como Ajv para validación de esquemas JSON.

import Ajv from 'ajv';
import { check } from 'k6';

const ajv = new Ajv();
const schema = {
    type: 'object',
    properties: {
        id: { type: 'integer' },
        name: { type: 'string' },
    },
    required: ['id', 'name'],
};

const jsonResponse = JSON.parse(res.body);
const validate = ajv.compile(schema);
const valid = validate(jsonResponse);

check(res, {
    'la respuesta cumple con el esquema': () => valid,
});

19. Validaciones Dinámicas

Para asegurar que los valores sigan reglas específicas, como IDs secuenciales o rangos de tiempo válidos.

const jsonResponse = JSON.parse(res.body);
const ids = jsonResponse.items.map(item => item.id);

check(res, {
    'los IDs son secuenciales': () => {
        return ids.every((id, index) => index === 0 || id === ids[index - 1] + 1);
    },
    'las marcas de tiempo son válidas': () => {
        return jsonResponse.items.every(item => {
            const date = new Date(item.timestamp);
            return date instanceof Date && !isNaN(date);
        });
    },
});

20. Validación Basada en Tiempos

Puedes validar que las operaciones no devuelvan datos antiguos.

const jsonResponse = JSON.parse(res.body);
const now = Date.now();

check(res, {
    'los datos son recientes': () => {
        return jsonResponse.items.every(item => {
            const itemDate = new Date(item.updatedAt).getTime();
            return now - itemDate < 24 * 60 * 60 * 1000; // Dentro de 24 horas
        });
    },
});

21. Chequeo Agregado de Métricas

Combina validaciones funcionales con métricas de rendimiento para un análisis más completo.

let totalChecksPassed = 0;

check(res, {
    'el estado es 200': (r) => {
        const result = r.status === 200;
        totalChecksPassed += result ? 1 : 0;
        return result;
    },
    'la respuesta es válida': (r) => {
        const jsonResponse = JSON.parse(r.body);
        const result = jsonResponse.success === true;
        totalChecksPassed += result ? 1 : 0;
        return result;
    },
});

// Registrar total de verificaciones aprobadas
console.log(`Verificaciones aprobadas: ${totalChecksPassed}`);

22. Ejecución Condicional Basada en Respuesta

Ejecuta dinámicamente verificaciones según la respuesta de una llamada previa.

const res = http.get('https://api.example.com/feature');

if (res.status === 200) {
    const jsonResponse = JSON.parse(res.body);
    check(jsonResponse, {
        'la característica está habilitada': (obj) => obj.enabled === true,
    });
} else {
    check(res, {
        'la característica está deshabilitada': (r) => r.status === 404,
    });
}

23. Integración con Herramientas de Monitoreo Externas

Envía resultados de métricas a herramientas como Grafana o Prometheus.

import { Trend } from 'k6/metrics';

let responseTimeTrend = new Trend('response_time');

export default function () {
    let res = http.get('https://api.example.com/resource');
    responseTimeTrend.add(res.timings.duration);

    check(res, {
        'el estado es 200': (r) => r.status === 200,
    });
}

24. Validación de Paginación

Comprueba que la lógica de paginación funcione correctamente.

const firstPage = http.get('https://api.example.com/items?page=1');
const secondPage = http.get('https://api.example.com/items?page=2');

check(firstPage, {
    'la primera página tiene elementos': (r) => r.json().items.length > 0,
});

check(secondPage, {
    'la segunda página tiene elementos': (r) => r.json().items.length > 0,
});

const firstItems = firstPage.json().items;
const secondItems = secondPage.json().items;

check(secondItems, {
    'los elementos de la segunda página son diferentes': () => {
        return !firstItems.some(item => secondItems.some(secondItem => secondItem.id === item.id));
    },
});

26. Validación de Respuestas en Paralelo

Para escenarios en los que necesitas validar múltiples respuestas de forma simultánea, puedes usar promesas.

import { check, group } from 'k6';
import http from 'k6/http';

export default function () {
    const urls = [
        'https://api.example.com/users/1',
        'https://api.example.com/posts',
        'https://api.example.com/comments',
    ];

    // Hacer múltiples solicitudes en paralelo
    const responses = http.batch(urls.map(url => ['GET', url]));

    // Verificar cada respuesta
    responses.forEach((res, idx) => {
        check(res, {
            [`response ${idx + 1} is valid`]: (r) => r.status === 200,
        });
    });
}

Dato importante:

r: El objeto pasado al callback de la función check: En el callback de la función check, r es el mismo objeto de respuesta que res. El propósito de r es simplemente proporcionar acceso a los datos de res dentro de la función callback, por lo que r es una referencia al mismo objeto que res en este caso.

Entonces, ¿por qué se usan nombres diferentes? El uso de nombres distintos es simplemente una convención de estilo de código. Se usa res fuera de la función check y r dentro de la función callback. Esto puede deberse a:

  • 1 Legibilidad: Dentro del callback, un nombre corto como r es más práctico para evitar repetir res cada vez.
  • 2 Scope local: El nombre r es local al callback y no afecta el uso de res en el nivel externo.

¿Es necesario usar nombres diferentes? No, puedes usar el mismo nombre (res) si lo prefieres:

const res = http.get('https://api.example.com/resource');
check(res, {
    'el tiempo de respuesta es aceptable bajo carga': (res) => res.timings.duration < 500,
});
comments powered by Disqus