k6ctl 1.2.0 → 1.3.1

package/src/utils/testRunManifestBuilder.ts

@@ -1,5 +1,5 @@
 import logger from '../utils/logger';
-import type { ArchivedFile, ConfigMapResult } from '../types/kubernetes.types';
+import type { ArchivedFile, ConfigMapResult, VolumeClaimResult } from '../types/kubernetes.types';
 import { K6Config } from '../types/config.types';
 import { TestRunManifest } from '../types/testRunManifest.types';
 
@@ -124,3 +124,41 @@ function addPrometheusEnvVars(cfg: K6Config, envMap: Map<string, RunnerEnvVar>)
         }
     }
 }
+
+export function buildTestRunManifestWithVolumeClaim(
+    volumeClaimResult: VolumeClaimResult,
+    cfg: K6Config,
+    envFromLoader?: Record<string, string>
+): TestRunManifest {
+    const testName = volumeClaimResult.volumeClaimName.replace('archive-', 'test-');
+    const argumentsString = buildArgumentsString(cfg.arguments, cfg, testName);
+    logger.debug('Constructed arguments string for TestRun manifest (volume):', argumentsString);
+    const testRun: TestRunManifest = {
+        apiVersion: `${K6_GROUP}/${K6_VERSION}`,
+        kind: K6_KIND,
+        metadata: {
+            name: testName,
+            namespace: volumeClaimResult.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: {
+                volumeClaim: {
+                    name: volumeClaimResult.volumeClaimName,
+                    file: volumeClaimResult.archiveFilename,
+                },
+            },
+        },
+    };
+    logger.debug('Constructed TestRun manifest (volume):', JSON.stringify(testRun, null, 2));
+    return testRun;
+}

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

@@ -3,19 +3,18 @@ import { join, resolve } from 'node:path';
 import { existsSync } from 'node:fs';
 import { createDefaultKubernetesService } from '../../src/services/kubernetes.service';
 import { ScriptService } from '../../src/services/script.service';
-import { ConfigMapResult } from '../../src/types/kubernetes.types';
+import { ConfigMapResult, VolumeClaimResult } 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';
+import { buildTestRunManifest, buildTestRunManifestWithVolumeClaim } from '../../src/utils/testRunManifestBuilder';
 import { saveLastRun } from '../../src/utils/lastRunStore';
 import { status } from '../../src/commands/status';
 import { logs } from '../../src/commands/logs';
 import { deleteLastRun } from '../../src/commands/delete';
 
-
 const samplesPath = resolve(__dirname, '..', 'samples');
 const scriptSample1 = join(samplesPath, 'k6_script_sample_1.js');
 const scriptSample2 = join(samplesPath, 'k6_script_sample_2.js');
@@ -27,8 +26,11 @@ const kubernetesService = createDefaultKubernetesService();
 let archiveOutput: ArchiveResult;
 let configMapResult: ConfigMapResult;
 
-describe('KubernetesService integration tests', () => {
+let volumeArchiveOutput: ArchiveResult;
+let volumeClaimResult: VolumeClaimResult;
+let volumeTestRunManifest: TestRunManifest;
 
+describe('KubernetesService integration tests', () => {
   test('create config map from archived script', async () => {
     archiveOutput = await scriptService.archiveTest(scriptSample2);
     expect(existsSync(archiveOutput.archivePath)).toBe(true);
@@ -70,4 +72,58 @@ describe('KubernetesService integration tests', () => {
     // Clean up the TestRun after successful creation and execution
     await deleteLastRun({ namespace: testRunManifest.metadata.namespace });
   }, 120000);
-});
+
+  test('archives a script and creates PVC', async () => {
+    volumeArchiveOutput = await scriptService.archiveTest(scriptSample1);
+    expect(existsSync(volumeArchiveOutput.archivePath)).toBe(true);
+
+    volumeClaimResult = await kubernetesService.createPVCWithArchive(volumeArchiveOutput, 'default');
+
+    expect(volumeClaimResult).toBeDefined();
+    expect(volumeClaimResult.volumeClaimName).toMatch(/^archive-/);
+    expect(volumeClaimResult.namespace).toBe('default');
+    expect(volumeClaimResult.archiveFilename).toMatch(/\.tar$/);
+
+    // createPVCWithArchive deletes the local archive file after uploading
+    expect(existsSync(volumeArchiveOutput.archivePath)).toBe(false);
+
+    logger.info(`PVC created: ${JSON.stringify(volumeClaimResult, null, 2)}`);
+  }, 120000);
+
+  test('creates and runs a TestRun from the PVC', async () => {
+    const cfg: K6Config = loadK6Config();
+    logger.debug('Loaded K6 Config:', JSON.stringify(cfg, null, 2));
+
+    volumeTestRunManifest = buildTestRunManifestWithVolumeClaim(volumeClaimResult, cfg);
+
+    expect(volumeTestRunManifest.spec.script.volumeClaim).toBeDefined();
+    expect(volumeTestRunManifest.spec.script.configMap).toBeUndefined();
+    expect(volumeTestRunManifest.spec.script.volumeClaim?.name).toBe(volumeClaimResult.volumeClaimName);
+    expect(volumeTestRunManifest.spec.script.volumeClaim?.file).toBe(volumeClaimResult.archiveFilename);
+
+    const response = await kubernetesService.createTestRun(volumeTestRunManifest);
+    expect(response).toBeDefined();
+    logger.info('TestRun result:', JSON.stringify(response));
+
+    await saveLastRun({
+      testRunName: volumeTestRunManifest.metadata.name,
+      namespace: volumeTestRunManifest.metadata.namespace,
+      volumeClaimName: volumeClaimResult.volumeClaimName,
+      scriptPath: volumeArchiveOutput.scriptPath,
+      createdAt: new Date().toISOString(),
+    });
+    logger.info(`Last run saved: ${volumeTestRunManifest.metadata.name} (namespace: ${volumeTestRunManifest.metadata.namespace})`);
+
+    // Wait for the TestRun to be created and start running
+    await new Promise((resolve) => setTimeout(resolve, 60000));
+
+    // Check status command output
+    await status({ namespace: volumeTestRunManifest.metadata.namespace });
+
+    // Check logs command output
+    await logs({ namespace: volumeTestRunManifest.metadata.namespace });
+
+    // Clean up the TestRun and PVC
+    await deleteLastRun({ namespace: volumeTestRunManifest.metadata.namespace });
+  }, 120000);
+});

package/test/unit/kubernetes.service.test.ts

@@ -5,14 +5,19 @@ import logger from '../../src/utils/logger';
 import { KubernetesService, createDefaultKubernetesService } from '../../src/services/kubernetes.service';
 import type { ArchivedFile } from '../../src/types/kubernetes.types';
 
-jest.mock('fs', () => ({
-  existsSync: jest.fn(),
-  promises: {
-    stat: jest.fn(),
-    readFile: jest.fn(),
-    unlink: jest.fn(),
-  },
-}));
+jest.mock('fs', () => {
+  const actualFs = jest.requireActual<typeof import('fs')>('fs');
+  return {
+    ...actualFs,
+    existsSync: jest.fn(),
+    promises: {
+      ...actualFs.promises,
+      stat: jest.fn(),
+      readFile: jest.fn(),
+      unlink: jest.fn(),
+    },
+  };
+});
 
 jest.mock('@kubernetes/client-node', () => {
   const mockApiClient = {

package/test/unit/script.service.test.ts

@@ -1,11 +1,16 @@
 import { beforeEach, describe, expect, jest, test } from '@jest/globals';
 import { ScriptService } from '../../src/services/script.service';
-import { existsSync } from 'fs';
+import { existsSync, statSync } from 'fs';
 import type { ExecFn } from '../../src/types/script.types';
 
-jest.mock('fs', () => ({
-  existsSync: jest.fn(),
-}));
+jest.mock('fs', () => {
+  const actualFs = jest.requireActual<typeof import('fs')>('fs');
+  return {
+    ...actualFs,
+    existsSync: jest.fn(),
+    statSync: jest.fn(),
+  };
+});
 
 jest.mock('../../src/utils/logger', () => ({
   __esModule: true,
@@ -13,6 +18,7 @@ jest.mock('../../src/utils/logger', () => ({
 }));
 
 const mockedExistsSync = existsSync as unknown as jest.Mock;
+const mockedStatSync = statSync as unknown as jest.Mock;
 
 describe('ScriptService', () => {
   let mockExec: jest.MockedFunction<ExecFn>;
@@ -22,6 +28,7 @@ describe('ScriptService', () => {
     jest.resetAllMocks();
     mockExec = jest.fn<ExecFn>();
     service = new ScriptService(mockExec);
+    mockedStatSync.mockReturnValue({ size: 1024 });
   });
 
   describe('archiveTest', () => {