k6ctl 1.1.0 → 1.3.0

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

@@ -1,23 +1,20 @@
-import { afterAll, describe, expect, test } from '@jest/globals';
+import { 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, printConfigMapsTable } from '../../src/services/kubernetes.service';
+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 { printTestRunsTable, printPodsTable } from '../../src/services/kubernetes.service';
+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');
@@ -29,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);
@@ -72,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,13 +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(),
-  },
-}));
+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 = {
@@ -49,6 +55,7 @@ jest.mock('../../src/utils/logger', () => ({
 const mockedExistsSync = existsSync as unknown as jest.Mock;
 const mockedStat = fs_promises.stat as unknown as jest.Mock;
 const mockedReadFile = fs_promises.readFile as unknown as jest.Mock;
+const mockedUnlink = fs_promises.unlink as unknown as jest.MockedFunction<typeof fs_promises.unlink>;
 const mockedLoggerInfo = logger.info as unknown as jest.Mock;
 
 const mockedK8sModule = k8s as unknown as {
@@ -119,6 +126,7 @@ describe('KubernetesService', () => {
     });
 
     test('creates configmap with binaryData and returns namespace/name', async () => {
+      mockedUnlink.mockResolvedValue(undefined);
       mockedExistsSync.mockReturnValue(true);
       mockedStat.mockImplementation(async () => ({ size: 512 }));
       mockedReadFile.mockImplementation(async () => 'YmFzZTY0');

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', () => {