k6ctl 1.0.0

package/src/utils/configLoader.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { readFileSync, existsSync } from "node:fs";
+import logger from './logger';
+
+const BASE_IMAGE = "grafana/k6:latest";
+const DEFAULT_NAMESPACE = "default";
+const DEFAULT_CONFIG_PATH = "k6ctl.config.json";
+const PROMETHEUS_DEFAULT_TREND_STATS = ["avg", "p(95)", "p(99)", "min", "max"];
+
+const ResourcesSchema = z.object({
+    limits: z.object({
+        cpu: z.string(),
+        memory: z.string(),
+    }),
+    requests: z.object({
+        cpu: z.string(),
+        memory: z.string(),
+    }),
+});
+
+const RunnerSchema = z
+    .object({
+        image: z.string(),
+        resources: ResourcesSchema.optional(),
+    })
+    .default({ image: BASE_IMAGE });
+
+const PrometheusSchema = z
+    .object({
+        serverUrl: z.string(),
+        trendStats: z.array(z.string()).default(PROMETHEUS_DEFAULT_TREND_STATS),
+    });
+
+const K6ConfigSchema = z.object({
+    namespace: z.string().default(DEFAULT_NAMESPACE),
+    parallelism: z.number().int().positive().default(1),
+    arguments: z
+        .array(z.string())
+        .optional(),
+    cleanup: z.boolean().default(false),
+    quiet: z.boolean().default(true),
+    separate: z.boolean().default(false),
+    runner: RunnerSchema,
+    prometheus: PrometheusSchema.optional(),
+});
+
+export type K6ConfigParsed = z.infer<typeof K6ConfigSchema>;
+
+export function loadK6Config(path = DEFAULT_CONFIG_PATH): K6ConfigParsed {
+    if (!existsSync(path)) {
+        logger.warn(`Config file '${path}' doesn't exist, using default values.`);
+        return K6ConfigSchema.parse({});
+    }
+    const raw = readFileSync(path, "utf-8");
+    let obj: unknown;
+    try {
+        obj = JSON.parse(raw);
+    } catch (e) {
+        throw new Error(`Config file '${path}' exists but is not valid JSON: ${(e as Error).message}`);
+    }
+    logger.info(`Loaded config from '${path}'`);
+    return K6ConfigSchema.parse(obj);
+}

package/src/utils/env.ts

@@ -0,0 +1,90 @@
+import * as fs from "fs";
+import * as path from "path";
+import { parse } from "dotenv";
+import logger from './logger';
+
+/**
+ * Configura tus patrones de validación aquí
+ */
+const DEFAULT_RULES = {
+  // Valida nombres tipo ENV clásico: MAYUSCULAS_NUMEROS_GUIONBAJO
+  keyPattern: /^[A-Z][A-Z0-9_]*$/,
+
+  // Valores permitidos: ASCII imprimible (no control chars). Permite espacios.
+  valuePattern: /^[\x20-\x7E]*$/,
+};
+
+type Rules = typeof DEFAULT_RULES;
+
+/**
+ * Lee y valida un archivo .env
+ * @param envFilePath - Ruta del archivo .env a cargar
+ * @param rules - Reglas de validación personalizadas (opcional)
+ * @returns Objeto con las variables de entorno validadas
+ */
+export function loadAndValidateEnv(
+  envFilePath: string = ".env",
+  rules: Rules = DEFAULT_RULES
+): Record<string, string> {
+  const errors: string[] = [];
+  const result: Record<string, string> = {};
+
+  // Validar que el archivo existe
+  const absolutePath = path.isAbsolute(envFilePath) 
+    ? envFilePath 
+    : path.resolve(process.cwd(), envFilePath);
+
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Archivo .env no encontrado: ${absolutePath}`);
+  }
+
+  logger.debug(`Loading .env file from: ${absolutePath}`);
+
+  // Leer el archivo .env
+  let fileContent: string;
+  try {
+    fileContent = fs.readFileSync(absolutePath, "utf-8");
+  } catch (error) {
+    throw new Error(`Error al leer el archivo .env: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  // Parsear el contenido del archivo .env
+  let envVars: Record<string, string>;
+  try {
+    envVars = parse(fileContent);
+  } catch (error) {
+    throw new Error(`Error al parsear el archivo .env: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
+  // Validar cada variable
+  for (const [key, val] of Object.entries(envVars)) {
+    // Validar nombre de la variable
+    if (!rules.keyPattern.test(key)) {
+      errors.push(`Nombre inválido: "${key}" (no cumple el patrón ${rules.keyPattern})`);
+      continue;
+    }
+
+    // Validar que el valor no esté vacío
+    if (val == null || val === "") {
+      errors.push(`Variable "${key}" no tiene valor`);
+      continue;
+    }
+
+    // Validar caracteres del valor
+    if (!rules.valuePattern.test(val)) {
+      errors.push(`Valor inválido en "${key}" (contiene caracteres no permitidos)`);
+      continue;
+    }
+
+    result[key] = val;
+  }
+
+  if (errors.length > 0) {
+    throw new Error(
+      "Errores en variables de ambiente:\n" + errors.map(e => `- ${e}`).join("\n")
+    );
+  }
+
+  logger.info(`Loaded ${Object.keys(result).length} environment variable(s) from '${absolutePath}'`);
+  return result;
+}

package/src/utils/logger.ts

@@ -0,0 +1,17 @@
+import { createLogger, format, transports } from 'winston';
+
+const { combine, colorize, printf, timestamp } = format;
+
+const logFormat = printf(({ level, message }) => `${level}: ${message}`);
+
+const logger = createLogger({
+  level: process.env.LOG_LEVEL ?? 'info',
+  format: combine(colorize(), logFormat),
+  transports: [new transports.Console()],
+});
+
+export function setLogLevel(level: string): void {
+  logger.level = level;
+}
+
+export default logger;

package/src/utils/table.util.ts

@@ -0,0 +1,23 @@
+import Table from "cli-table3";
+
+type TablePrinterOptions<T> = {
+    title?: string;
+    headers: string[];
+    items: T[];
+    toRows: (item: T) => Array<(string | number)[]>;
+    footer?: string;
+};
+
+export function printTableGeneric<T>(opts: TablePrinterOptions<T>): void {
+    const table = new Table({
+        head: opts.headers,
+        wordWrap: true,
+    });
+    for (const item of opts.items) {
+        const rows = opts.toRows(item);
+        for (const row of rows) table.push(row);
+    }
+    if (opts.title) console.log(opts.title);
+    console.log(table.toString());
+    if (opts.footer) console.log(opts.footer);
+}

package/src/utils/testRunManifestBuilder.ts

@@ -0,0 +1,102 @@
+import logger from '../utils/logger';
+import type { ArchivedFile, ConfigMapResult } from '../types/kubernetes.types';
+import { K6Config } from '../types/config.types';
+import { TestRunManifest } from '../types/testRunManifest.types';
+
+type RunnerEnvVar = { name: string; value: string };
+const K6_GROUP = "k6.io";
+const K6_VERSION = "v1alpha1";
+const K6_KIND = "TestRun";
+const K6_CLEANUP_LABEL = "post";
+const ARG_OUT = "--out";
+const ARG_TAG = "--tag";
+const ARG_OUT_PROMETHEUS = "experimental-prometheus-rw";
+const K6_PROMETHEUS_RW_SERVER_URL = "K6_PROMETHEUS_RW_SERVER_URL";
+const K6_PROMETHEUS_RW_TREND_STATS = "K6_PROMETHEUS_RW_TREND_STATS";
+
+export function buildTestRunManifest(
+    configMapResult: ConfigMapResult,
+    archiveOutput: ArchivedFile,
+    cfg: K6Config,
+    envFromLoader?: Record<string, string>
+): TestRunManifest {
+    const testName = configMapResult.configMapName.replace("archive-", "test-");
+    const argumentsString = buildArgumentsString(
+        cfg.arguments,
+        cfg,
+        testName
+    );
+    logger.debug("Constructed arguments string for TestRun manifest:", argumentsString);
+    const testRun: TestRunManifest = {
+        apiVersion: `${K6_GROUP}/${K6_VERSION}`,
+        kind: K6_KIND,
+        metadata: {
+            name: testName,
+            namespace: configMapResult.namespace,
+        },
+        spec: {
+            parallelism: cfg.parallelism,
+            arguments: argumentsString,
+            quiet: String(cfg.quiet),
+            ...(cfg.cleanup === true ? { cleanup: K6_CLEANUP_LABEL } : {}),
+            separate: cfg.separate,
+            runner: {
+                image: cfg.runner?.image,
+                env: buildRunnerEnv(cfg, envFromLoader),
+                ...(cfg.runner?.resources ? { resources: cfg.runner.resources } : {}),
+            },
+            script: {
+                configMap: {
+                    name: configMapResult.configMapName,
+                    file: archiveOutput.archiveFilename,
+                },
+            },
+        },
+    };
+    logger.debug("Constructed TestRun manifest:", JSON.stringify(testRun, null, 2));
+    return testRun;
+}
+
+function buildRunnerEnv(
+    cfg: K6Config,
+    envFromLoader?: Record<string, string>
+): RunnerEnvVar[] | undefined {
+    const envMap = new Map<string, string>();
+    if (envFromLoader) {
+        for (const [key, value] of Object.entries(envFromLoader)) {
+            if (value !== undefined && value !== null) {
+                envMap.set(key, String(value));
+            }
+        }
+    }
+    if (cfg.prometheus?.serverUrl) {
+        envMap.set(K6_PROMETHEUS_RW_SERVER_URL, cfg.prometheus.serverUrl);
+        if (cfg.prometheus.trendStats?.length) {
+            envMap.set(K6_PROMETHEUS_RW_TREND_STATS, cfg.prometheus.trendStats.join(","));
+        }
+    }
+    const envArray: RunnerEnvVar[] = Array.from(envMap.entries()).map(([name, value]) => ({
+        name,
+        value,
+    }));
+    return envArray.length > 0 ? envArray : undefined;
+}
+
+function buildArgumentsString(args: string[] | undefined, cfg: K6Config, name: string): string | undefined {
+    const finalArgs = [...(args ?? [])];
+    if (cfg.prometheus?.serverUrl) {
+        const hasOut = finalArgs.includes(ARG_OUT);
+        if (!hasOut) {
+            finalArgs.push(ARG_OUT);
+        }
+        const hasPrometheusOut = finalArgs.includes(ARG_OUT_PROMETHEUS);
+        if (!hasPrometheusOut) {
+            finalArgs.push(ARG_OUT_PROMETHEUS);
+        }
+        finalArgs.push(ARG_TAG, `testid=${name}`);
+    }
+    if (finalArgs.length === 0) {
+        return undefined;
+    }
+    return finalArgs.join(" ");
+}

package/test/integration/env.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from '@jest/globals';
+import * as fs from "fs";
+import * as path from "path";
+import { loadAndValidateEnv } from '../../src/utils/env';
+
+describe("Env integration tests", () => {
+  test("should load and print all variables from the .env file", () => {
+    // create a temporary .env file before each test
+    const envVariables = {
+      API_KEY: "12345",
+      DB_HOST: "localhost"
+    };
+    createTempEnvFile(envVariables);
+    const env = loadAndValidateEnv(".env");
+    expect(env).toEqual(envVariables);
+    deleteTempEnvFile();
+  });
+});
+
+function createTempEnvFile(env: Record<string, string>) {
+  const envPath = path.resolve(__dirname, "../../.env");
+  const envContent = Object.entries(env)
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n");
+  fs.writeFileSync(envPath, envContent);
+}
+
+function deleteTempEnvFile() {
+  const envPath = path.resolve(__dirname, "../../.env");
+  if (fs.existsSync(envPath)) {
+    fs.unlinkSync(envPath);
+  }
+}

package/test/integration/kubernetes.service.test.ts

@@ -0,0 +1,70 @@
+import { afterAll, describe, expect, test } from '@jest/globals';
+import { join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { unlink } from 'node:fs/promises';
+import { createDefaultKubernetesService } from '../../src/services/kubernetes.service';
+import { ScriptService } from '../../src/services/script.service';
+import { ConfigMapResult } from '../../src/types/kubernetes.types';
+import { ArchiveResult } from '../../src/types/script.types';
+import logger from '../../src/utils/logger';
+import { TestRunManifest } from '../../src/types/testRunManifest.types';
+import { K6Config } from '../../src/types/config.types';
+import { loadK6Config } from '../../src/utils/configLoader';
+import { buildTestRunManifest } from '../../src/utils/testRunManifestBuilder';
+
+const samplesPath = resolve(__dirname, '..', 'samples');
+const scriptSample1 = join(samplesPath, 'k6_script_sample_1.js');
+const scriptSample2 = join(samplesPath, 'k6_script_sample_2.js');
+const archivedFiles: string[] = [];
+const configMaps: ConfigMapResult[] = [];
+
+const scriptService = new ScriptService();
+const kubernetesService = createDefaultKubernetesService();
+let archiveOutput: ArchiveResult;
+let configMapResult: ConfigMapResult;
+
+describe('KubernetesService integration tests', () => {
+  afterAll(async () => {
+    // Clean up archived files after tests
+    await Promise.all(
+      archivedFiles.map(file => unlink(file).catch(error => console.error(`Error deleting file ${file}:`, error)))
+    );
+
+    // Clean up created config maps in Kubernetes
+    await Promise.all(
+      configMaps.map(cm => kubernetesService.deleteConfigMap(cm.configMapName, cm.namespace)
+        .catch(error => console.error(`Error deleting config map ${cm.configMapName}:`, error)))
+    );
+  });
+
+  test('create config map from archived script', async () => {
+    archiveOutput = await scriptService.archiveTest(scriptSample2);
+    expect(existsSync(archiveOutput.archivePath)).toBe(true);
+    archivedFiles.push(archiveOutput.archivePath);
+
+    configMapResult = await kubernetesService.createConfigMap(archiveOutput, 'default');
+    expect(configMapResult).toBeDefined();
+    console.log(JSON.stringify(configMapResult, null, 2));
+    configMaps.push(configMapResult);
+  });
+
+  test('Create TestRun from the ConfigMap previously created', async () => {
+    const cfg: K6Config = loadK6Config();
+    logger.debug("Loaded K6 Config:", JSON.stringify(cfg, null, 2));
+    const testRunManifest: TestRunManifest = buildTestRunManifest(configMapResult, archiveOutput, cfg);
+    const response = await kubernetesService.createTestRun(testRunManifest);
+    expect(response).toBeDefined();
+    logger.info("TestRun result:", JSON.stringify(response));
+
+    // Wait for some time to allow the TestRun to be created and start running
+    await new Promise((resolve) => setTimeout(resolve, 40000));
+
+    // List TestRuns, Pods, and ConfigMaps to verify they are created and running
+    await kubernetesService.listTestRuns();
+    await kubernetesService.listPods();
+    await kubernetesService.listConfigMaps();
+
+    // Clean up the TestRun after successful creation and execution
+    await kubernetesService.deleteTestRun(testRunManifest);
+  }, 120000);
+});

package/test/integration/script.service.test.ts

@@ -0,0 +1,64 @@
+import { afterAll, beforeAll, describe, expect, test } from '@jest/globals';
+import { join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { mkdir, rmdir, unlink } from 'node:fs/promises';
+import { ScriptService } from '../../src/services/script.service';
+
+const samplesPath = resolve(__dirname, '..', 'samples');
+const scriptSample1 = join(samplesPath, 'k6_script_sample_1.js');
+const scriptSample2 = join(samplesPath, 'k6_script_sample_2.js');
+const archivedFiles: string[] = [];
+const outputDirectory = resolve(__dirname, '..', 'archive_output');
+
+const scriptService = new ScriptService();
+
+describe('ScriptService integration tests', () => {
+  beforeAll(() => {
+    // Create the output directory if it doesn't exist
+    if (!existsSync(outputDirectory)) {
+      mkdir(outputDirectory, { recursive: true });
+    }
+  });
+
+  afterAll(async () => {
+    // Clean up archived files after tests
+    await Promise.all(
+      archivedFiles.map(file => unlink(file).catch(error => console.error(`Error deleting file ${file}:`, error)))
+    );
+    // Clean up output directory after tests
+    await rmdir(outputDirectory)
+      .catch(error => console.error(`Error deleting output directory ${outputDirectory}:`, error));
+  });
+
+  test('throws an error when the script does not exist', async () => {
+    await expect(scriptService.archiveTest('./non_existent_script.js'))
+      .rejects.toThrow("Script file not found at path");
+  });
+
+  test.skip('throws an error when k6 is not installed', async () => {
+    await expect(scriptService.archiveTest(scriptSample1)).rejects.toThrow("k6 is not installed");
+  });
+
+  test('archives the script successfully - sample #1', async () => {
+    const archiveOutput = await scriptService.archiveTest(scriptSample1);
+    expect(existsSync(archiveOutput.archivePath)).toBe(true);
+    archivedFiles.push(archiveOutput.archivePath);
+  });
+
+  test('archives the script successfully - sample #2', async () => {
+    const archiveOutput = await scriptService.archiveTest(scriptSample2);
+    expect(existsSync(archiveOutput.archivePath)).toBe(true);
+    archivedFiles.push(archiveOutput.archivePath);
+  });
+
+  test('non-existent output directory', async () => {
+    await expect(scriptService.archiveTest(scriptSample1, './fake-output'))
+      .rejects.toThrow("Output directory does not exist at path");
+  });
+
+  test('archives the script successfully using output directory - sample #1', async () => {
+    const archiveOutput = await scriptService.archiveTest(scriptSample1, outputDirectory);
+    expect(existsSync(archiveOutput.archivePath)).toBe(true);
+    archivedFiles.push(archiveOutput.archivePath);
+  });
+});

package/test/jest.config.integration.js

@@ -0,0 +1,20 @@
+const { createDefaultPreset } = require("ts-jest");
+
+const tsJestTransformCfg = createDefaultPreset().transform;
+
+/** @type {import("jest").Config} **/
+module.exports = {
+  testEnvironment: "node",
+  testMatch: [
+    '**/test/integration/**/*.test.ts'
+  ],
+  transform: {
+    ...tsJestTransformCfg,
+    '^.+\\.js$': ['ts-jest', {
+      useESM: false,
+    }],
+  },
+  transformIgnorePatterns: [
+    'node_modules/(?!(@kubernetes/client-node|openid-client|oauth4webapi|jose))'
+  ],
+};

package/test/jest.config.unit.js

@@ -0,0 +1,14 @@
+const { createDefaultPreset } = require("ts-jest");
+
+const tsJestTransformCfg = createDefaultPreset().transform;
+
+/** @type {import("jest").Config} **/
+module.exports = {
+  testEnvironment: "node",
+  testMatch: [
+    '**/test/unit/**/*.test.ts'
+  ],
+  transform: {
+    ...tsJestTransformCfg,
+  },
+};

package/test/samples/data_sample_1.csv

@@ -0,0 +1,4 @@
+foo,bar
+1,2
+3,4
+5,6

package/test/samples/k6_script_sample_1.js

@@ -0,0 +1,9 @@
+// 1. basic test script for k6, without any external dependencies
+
+import http from 'k6/http';
+import { sleep } from 'k6';
+
+export default function () {
+  http.get('https://test.k6.io');
+  sleep(1);
+}

package/test/samples/k6_script_sample_2.js

@@ -0,0 +1,18 @@
+// 2. test script for k6, loading papaparse and using it to parse a CSV file, which is stored in the SharedArray
+
+import { sleep } from 'k6';
+import { SharedArray } from 'k6/data';
+import http from 'k6/http';
+import papaparse from 'https://jslib.k6.io/papaparse/5.1.1/index.js';
+
+const csvData = new SharedArray('data_sample_1', function () {
+  return papaparse.parse(open('./data_sample_1.csv'), { header: true }).data;
+});
+
+export default function () {
+  const randomIndex = Math.floor(Math.random() * csvData.length);
+  const randomData = csvData[randomIndex];
+  console.log(randomData);
+  http.get('https://test.k6.io');
+  sleep(1);
+}

package/test/unit/configLoader.test.ts

@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
+import { loadK6Config } from "../../src/utils/configLoader";
+import { existsSync, readFileSync } from "node:fs";
+
+jest.mock("node:fs", () => ({
+    existsSync: jest.fn(),
+    readFileSync: jest.fn(),
+}));
+
+const mockedExistsSync = existsSync as unknown as jest.Mock;
+const mockedReadFileSync = readFileSync as unknown as jest.Mock;
+
+describe("loadK6Config", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test("File does not exist, returns defaults", () => {
+        mockedExistsSync.mockReturnValue(false);
+        const cfg = loadK6Config("k6ctl.config.json");
+        expect(cfg.namespace).toBe("default");
+        expect(cfg.cleanup).toBe(false);
+        expect(cfg.quiet).toBe(true);
+        expect(cfg.separate).toBe(false);
+        expect(cfg.parallelism).toBe(1);
+        expect(cfg.runner.image).toBe("grafana/k6:latest");
+        expect(cfg.arguments).toBeUndefined();
+    });
+    
+    test("File exists, applies JSON + defaults", () => {
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue(
+            JSON.stringify({
+                namespace: "performance",
+                parallelism: 40,
+                prometheus: { serverUrl: "http://prom-rw:9090" },
+            })
+        );
+        const cfg = loadK6Config("k6ctl.config.json");
+        expect(cfg.namespace).toBe("performance");
+        expect(cfg.parallelism).toBe(40);
+        expect(cfg.cleanup).toBe(false);
+        expect(cfg.runner.image).toBe("grafana/k6:latest");
+        expect(cfg.prometheus?.serverUrl).toBe("http://prom-rw:9090");
+        expect(cfg.prometheus?.trendStats).toEqual(["avg", "p(95)", "p(99)", "min", "max"]);
+    });
+
+    test("If JSON is invalid, throws error with clear message", () => {
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue("{ invalid json");
+        expect(() => loadK6Config("k6ctl.config.json")).toThrow(/Config file 'k6ctl\.config\.json' exists but is not valid JSON:/i);
+    });
+});