En esta página encontrarás el diseño de los scripts que se han realizado para las pruebas de performance en K6 por cada componente desarrollado [Account], [Card], [Customer] en el proyecto, en cada protocolo usado: Rest y gRPC.

Estructura del proyecto

...

La presente estructura se ha organizado con el propósito de proporcionar un orden claro y sistemático para el almacenamiento y manejo de las pruebas en K6. A continuación, se ofrece una descripción de su estructura:

• Mirror Strategy: Esta es una carpeta principal que reside dentro del directorio "tasks".

  • Aggregations: En la carpeta "Mirror Strategy", existen distintos subdirectorios que representan las diferentes agregaciones: "Account", "Card" y "Customer".

    • Integration: Cada agregación posee un subdirectorio denominado "Integration". En esta ubicación, se guardan scripts dedicados a pruebas de rest y grpc. Estos scripts especifican y exportan configuraciones, así como funciones de ejecución adaptadas para cada modalidad de prueba.

    • Proto: Es un directorio especializado en albergar los archivos .proto. Estos archivos definen las especificaciones para la serialización de datos en el formato Protocol Buffers, creado por Google. Los protos sirven para estandarizar y definir la estructura de los mensajes y servicios gRPC que se van a probar, garantizando que los datos intercambiados durante las pruebas sean consistentes y se ajusten a la definición establecida.

    • Services: Se alojan scripts de prueba individuales tanto para rest como para grpc. Cada script está diseñado para un endpoint particular perteneciente al aggregation correspondiente. Al ser ejecutados, estos scripts invocan a los endpoints con datos y parámetros predefinidos y analizan las respuestas obtenidas.

    • Test Data: Contiene archivos en formato .csv. Estos archivos almacenan los datos de prueba que se utilizan en las distintas ejecuciones de los scripts. Su función es suministrar la información esencial para que los scripts puedan llevar a cabo las pruebas utilizando diversos sets de datos.

Image Added

Services

REST

Importaciones

• group y check de k6 son funciones que permiten estructurar las pruebas y validar respuestas respectivamente.

• http de k6 se utiliza para realizar peticiones HTTP.

• Configuraciones específicas de ACCOUNT_AGGREGATION_REST son importadas desde un archivo de configuración config.js.

• papaparse biblioteca importada para analizar archivos CSV.

• SharedArray de k6/data permite compartir datos entre diferentes VUs (Unidades Virtuales) durante una prueba.

import { group, check } from 'k6';
import http from 'k6/http';
import { ACCOUNT_AGGREGATION_REST } from '../../../../config.js';
import papaparse from '../../../../../../../../../modules/papaparse.js';
import { SharedArray } from 'k6/data';

Configuración y Datos

• La constante url se construye combinando dos propiedades del objeto ACCOUNT_AGGREGATION_REST.

• Las params se extraen directamente de ACCOUNT_AGGREGATION_REST.

• Se definen las options para la ejecución de las pruebas basándose en ACCOUNT_AGGREGATION_REST.testOptions.

• Se utiliza papaparse para analizar un archivo CSV que contiene datos de prueba y se almacena en una estructura de datos SharedArray.

const url = `${ACCOUNT_AGGREGATION_REST.uri}${ACCOUNT_AGGREGATION_REST.account.details}`;

const params = ACCOUNT_AGGREGATION_REST.params;

export const options = {
    rps: ACCOUNT_AGGREGATION_REST.testOptions.rps,
    //discardResponseBodies: TEST_OPTIONS_INTEGRATION.discardResponseBodies,
    scenarios: {
        Scenario_AccountDetails: {
            exec: 'accountDetailsSuccessRestTask',
            executor: ACCOUNT_AGGREGATION_REST.testOptions.executor,
            vus: ACCOUNT_AGGREGATION_REST.testOptions.vus,
            iterations: ACCOUNT_AGGREGATION_REST.testOptions.iterations,
            maxDuration: ACCOUNT_AGGREGATION_REST.testOptions.maxDuration,
        }
    }
};
const csvData = new SharedArray('accountsTestData', function () {
    return papaparse.parse(open(`${ACCOUNT_AGGREGATION_REST.testDataPath}/accountsTestData.csv`), { header: true }).data;
});

Función de Prueba

• La función accountDetailsSuccessRestTask() define un escenario de prueba:

  • Selecciona aleatoriamente una cuenta del archivo CSV para posteriormente setearla como número de cuenta.

  • Se utiliza la función group para agrupar las acciones dentro de una etiqueta llamada 'AccountDetails'.

  • Dentro de este grupo, se crea una carga útil (payload) con un número de cuenta aleatoria tomada del csv y se realiza una solicitud HTTP POST a la URL definida anteriormente con dicha carga útil y los parámetros especificados.

  • Utiliza la función check para verificar si la respuesta HTTP tiene un estado de 200.

export function accountDetailsSuccessRestTask() {

    const randomAccount = csvData[Math.floor(Math.random() * csvData.length)];
    group('AccountDetails', function () {

        const payload = JSON.stringify({
            "accountNumber": randomAccount.account
        });

        const response = http.post(url, payload, params);

        check(response, {
            'status is 200': r => r.status === 200,
        });
    });
};

gRPC

Importaciones

• group y check de k6 son funciones que permiten estructurar las pruebas y validar respuestas respectivamente.

• grpc de k6/net/grpc: Proporciona funcionalidades para hacer llamadas gRPC.

• Configuraciones específicas de ACCOUNT_AGGREGATION_REST son importadas desde un archivo de configuración config.js.

• papaparse biblioteca importada para analizar archivos CSV.

• SharedArray de k6/data permite compartir datos entre diferentes VUs (Unidades Virtuales) durante una prueba.

import { check } from 'k6';
import grpc from 'k6/net/grpc';
import { ACCOUNT_AGGREGATION_GRPC } from '../../../../config.js';
import papaparse from '../../../../../../../../../modules/papaparse.js';
import { SharedArray } from 'k6/data';

Configuración del cliente gRPC y Datos

Se crea una nueva instancia del cliente gRPC y se cargan las definiciones desde el archivo proto mediante la configuración importada.

const client = new grpc.Client();
client.load([ACCOUNT_AGGREGATION_GRPC.protoPath], ACCOUNT_AGGREGATION_GRPC.protoFile);

Se definen las opciones que k6 empleará al ejecutar la prueba, tales como número de usuarios virtuales, iteraciones, duración máxima, entre otros.

export const options = {
    rps: ACCOUNT_AGGREGATION_GRPC.testOptions.rps,
    //discardResponseBodies: TEST_OPTIONS_INTEGRATION.discardResponseBodies,
    scenarios: {
        Scenario_BalanceDetails: {
            exec: 'balanceDetailsSuccessGrpcTask',
            executor: ACCOUNT_AGGREGATION_GRPC.testOptions.executor,
            vus: ACCOUNT_AGGREGATION_GRPC.testOptions.vus,
            iterations: ACCOUNT_AGGREGATION_GRPC.testOptions.iterations,
            maxDuration: ACCOUNT_AGGREGATION_GRPC.testOptions.maxDuration,
        }
    }
};

El archivo CSV es cargado en memoria a través de un SharedArray. Con el uso de papaparse, se analiza este archivo para luego acceder a la información que contiene.

const csvData = new SharedArray('accountsTestData', function () {
    return papaparse.parse(open(`${ACCOUNT_AGGREGATION_GRPC.testDataPath}/accountsTestData.csv`), { header: true }).data;
});

Función de Prueba

• La función balanceDetailsSuccessGrpcTask() define un escenario de prueba:

  • Selecciona aleatoriamente una cuenta del archivo CSV para posteriormente setearla como número de cuenta.

  • Una vez seleccionado el número de cuenta, se establece una conexión gRPC usando las configuraciones definidas. Posteriormente, se invoca un servicio gRPC usando este número de cuenta.

  • Después de obtener la respuesta de la llamada gRPC, utiliza la función check para verificar que el estado de la respuesta sea "OK" para gRPC, lo que sería equivalente a un estado HTTP de 200.

  • Una vez finalizada la verificación, se cierra la conexión gRPC.

export function balanceDetailsSuccessGrpcTask() {

    const randomAccount = csvData[Math.floor(Math.random() * csvData.length)];

    const data = {
        "accountNumber": randomAccount.account
    };

    client.connect(ACCOUNT_AGGREGATION_GRPC.uri, {
        plaintext: ACCOUNT_AGGREGATION_GRPC.plainText
    });

    const response = client.invoke(ACCOUNT_AGGREGATION_GRPC.service + ACCOUNT_AGGREGATION_GRPC.balance.balances, data);

    check(response, {
        'status is OK': (r) => r && r.status === grpc.StatusOK,
    });

    client.close();
};