k6ctl 1.0.0 → 1.2.0

package/src/services/kubernetes.service.ts

@@ -38,6 +38,9 @@ export class KubernetesService {
 
     await this.k8sApi.createNamespacedConfigMap({ namespace, body: configMap });
     logger.info(`ConfigMap ${configMapName} created in namespace ${namespace}`);
+
+    // Clean up the archive file after creating the ConfigMap
+    await fs_promises.unlink(archiveFile.archivePath).catch(error => console.error(`Error deleting file ${archiveFile.archivePath}:`, error));
     return { namespace, configMapName };
   }
 
@@ -70,20 +73,7 @@ export class KubernetesService {
   }
 
   async deleteTestRun(testRunManifest: TestRunManifest): Promise<void> {
-    try {
-      const response = await this.k8sCustomApi.deleteNamespacedCustomObject({
-        group: testRunManifest.apiVersion.split('/')[0],
-        version: testRunManifest.apiVersion.split('/')[1],
-        namespace: testRunManifest.metadata.namespace,
-        plural: "testruns",
-        name: testRunManifest.metadata.name,
-      });
-      logger.info(`TestRun ${testRunManifest.metadata.name} deleted from namespace ${testRunManifest.metadata.namespace}`);
-      logger.debug(`Delete response: ${JSON.stringify(response)}`);
-    } catch (error) {
-      const errorMessage = (error as Error).message ?? 'Unknown error';
-      throw new Error(`Failed to delete TestRun ${testRunManifest.metadata.name} from namespace ${testRunManifest.metadata.namespace}: ${errorMessage}`);
-    }
+    await this.deleteTestRunByName(testRunManifest.metadata.name, testRunManifest.metadata.namespace);
   }
 
   async listTestRuns(namespace: string = "default"): Promise<any> {
@@ -94,38 +84,100 @@ export class KubernetesService {
         namespace: namespace,
         plural: "testruns",
       });
-      // logger.debug(`List response: ${JSON.stringify(response)}`);
-      printTestRunsTable((response as any).items ?? []);
-      return response;
+      return response.items as TestRunManifest[];
     } catch (error) {
       const errorMessage = (error as Error).message ?? 'Unknown error';
       throw new Error(`Failed to list TestRuns in namespace ${namespace}: ${errorMessage}`);
     }
   }
 
-  async listPods(namespace: string = "default"): Promise<any> {
+  async listPods(namespace: string = "default"): Promise<k8s.V1PodList> {
     try {
       const response = await this.k8sApi.listNamespacedPod({ namespace });
-      printPodsTable(response);
-      // logger.debug(`List Pods: ${JSON.stringify(response)}`);
-      return response;
+      return response as k8s.V1PodList;
     } catch (error) {
       const errorMessage = (error as Error).message ?? 'Unknown error';
       throw new Error(`Failed to list Pods in namespace ${namespace}: ${errorMessage}`);
     }
   }
 
-  async listConfigMaps(namespace: string = "default"): Promise<any> {
+  async listConfigMaps(namespace: string = "default"): Promise<k8s.V1ConfigMapList> {
     try {
       const response = await this.k8sApi.listNamespacedConfigMap({ namespace });
-      printConfigMapsTable(response);
-      // logger.debug(`List ConfigMaps: ${JSON.stringify(response)}`);
-      return response;
+      response.items = response.items?.filter(cm => cm.metadata?.name?.startsWith('archive-'));
+      return response as k8s.V1ConfigMapList;
     } catch (error) {
       const errorMessage = (error as Error).message ?? 'Unknown error';
       throw new Error(`Failed to list ConfigMaps in namespace ${namespace}: ${errorMessage}`);
     }
   }
+
+  private getTestRunCustomObjectParams(testRunName: string, namespace: string = "default") {
+    return {
+      group: "k6.io",
+      version: "v1alpha1",
+      namespace,
+      plural: "testruns",
+      name: testRunName,
+    };
+  }
+
+  async deleteTestRunByName(testRunName: string, namespace: string = "default"): Promise<void> {
+    try {
+      await this.k8sCustomApi.deleteNamespacedCustomObject(this.getTestRunCustomObjectParams(testRunName, namespace));
+      logger.info(`TestRun ${testRunName} deleted from namespace ${namespace}`);
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to delete TestRun ${testRunName} from namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
+  async deletePodByName(podName: string, namespace: string = "default"): Promise<void> {
+    try {
+      await this.k8sApi.deleteNamespacedPod({ name: podName, namespace });
+      logger.info(`Pod ${podName} deleted from namespace ${namespace}`);
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to delete Pod ${podName} from namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
+  async getTestRun(testRunName: string, namespace: string = "default"): Promise<TestRunManifest> {
+    try {
+      const response = await this.k8sCustomApi.getNamespacedCustomObject(this.getTestRunCustomObjectParams(testRunName, namespace));
+      return response as TestRunManifest;
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to get TestRun ${testRunName} in namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
+  async getPodsForTestRun(testRunName: string, namespace: string = "default"): Promise<k8s.V1PodList> {
+    try {
+      const response = await this.k8sApi.listNamespacedPod({
+        namespace,
+        labelSelector: `k6_cr=${testRunName}`,
+      });
+      return response as k8s.V1PodList;
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to get pods for TestRun ${testRunName} in namespace ${namespace}: ${errorMessage}`);
+    }
+  }
+
+  async getPodLogs(podName: string, namespace: string = "default", container?: string): Promise<string> {
+    try {
+      const response = await this.k8sApi.readNamespacedPodLog({
+        name: podName,
+        namespace,
+        ...(container ? { container } : {}),
+      });
+      return response;
+    } catch (error) {
+      const errorMessage = (error as Error).message ?? 'Unknown error';
+      throw new Error(`Failed to get logs for pod ${podName} in namespace ${namespace}: ${errorMessage}`);
+    }
+  }
 }
 
 function fmt(v: any) {
@@ -231,7 +283,6 @@ export function printTestRunsTable(testRuns: TestRunManifest[]): void {
       const separate = tr.spec?.separate ?? "N/A";
       const quiet = tr.spec?.quiet ?? "N/A";
       const age = (tr as any)?.metadata?.creationTimestamp ?? "N/A";
-      // const age = ageSince((tr as any)?.metadata?.creationTimestamp) || "N/A";
       return [[name, namespace, parallelism, cleanup, separate, quiet, age]];
     }
   });

package/src/types/lastRun.types.ts

@@ -0,0 +1,7 @@
+export interface LastRunState {
+  testRunName: string;
+  namespace: string;
+  configMapName: string;
+  scriptPath: string;
+  createdAt: string;
+}

package/src/types/testRunManifest.types.ts

@@ -1,3 +1,5 @@
+import { RunnerEnvVar } from "../utils/testRunManifestBuilder";
+
 export interface TestRunManifest {
   apiVersion: string;
   kind: string;
@@ -13,10 +15,7 @@ export interface TestRunManifest {
     separate?: boolean;
     runner?: {
       image?: string;
-      env?: Array<{
-        name: string;
-        value: string;
-      }>;
+      env?: RunnerEnvVar[];
       resources?: {
         limits: {
           cpu: string

package/src/utils/lastRunStore.ts

@@ -0,0 +1,36 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import logger from './logger';
+import type { LastRunState } from '../types/lastRun.types';
+
+const LAST_RUN_FILE = '.k6ctl-last-run.json';
+
+function getFilePath(): string {
+  return path.join(process.cwd(), LAST_RUN_FILE);
+}
+
+export async function saveLastRun(state: LastRunState): Promise<void> {
+  const filePath = getFilePath();
+  await fs.writeFile(filePath, JSON.stringify(state, null, 2), 'utf8');
+  logger.debug(`Last run state saved to ${filePath}`);
+}
+
+export async function loadLastRun(): Promise<LastRunState | null> {
+  const filePath = getFilePath();
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return JSON.parse(content) as LastRunState;
+  } catch {
+    return null;
+  }
+}
+
+export async function clearLastRun(): Promise<void> {
+  const filePath = getFilePath();
+  try {
+    await fs.unlink(filePath);
+    logger.debug(`Last run state cleared (${filePath})`);
+  } catch {
+    logger.info('No last run state to clear.');
+  }
+}

package/src/utils/testRunManifestBuilder.ts

@@ -3,7 +3,9 @@ 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 };
+export type RunnerEnvVar =
+    | { name: string; value: string }
+    | { name: string; valueFrom: { secretKeyRef: { name: string; key: string } } };
 const K6_GROUP = "k6.io";
 const K6_VERSION = "v1alpha1";
 const K6_KIND = "TestRun";
@@ -61,24 +63,15 @@ function buildRunnerEnv(
     cfg: K6Config,
     envFromLoader?: Record<string, string>
 ): RunnerEnvVar[] | undefined {
-    const envMap = new Map<string, string>();
+    const envMap = new Map<string, RunnerEnvVar>();
     if (envFromLoader) {
-        for (const [key, value] of Object.entries(envFromLoader)) {
-            if (value !== undefined && value !== null) {
-                envMap.set(key, String(value));
-            }
+        for (const [key, raw] of Object.entries(envFromLoader)) {
+            if (raw === undefined || raw === null) continue;
+            addEnvToMap(key, raw, envMap);
         }
     }
-    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,
-    }));
+    addPrometheusEnvVars(cfg, envMap);
+    const envArray: RunnerEnvVar[] = Array.from(envMap.values());
     return envArray.length > 0 ? envArray : undefined;
 }
 
@@ -99,4 +92,35 @@ function buildArgumentsString(args: string[] | undefined, cfg: K6Config, name: s
         return undefined;
     }
     return finalArgs.join(" ");
-}
+}
+
+function parseSecretPlaceholder(value: string): { secretName: string; secretKey: string } | null {
+    const m = /^\{\{SECRETS\.([^.}]+)\.([^.}]+)\}\}$/.exec(value.trim());
+    if (!m) return null;
+    return { secretName: m[1], secretKey: m[2] };
+}
+
+function addEnvToMap(key: string, raw: string, envMap: Map<string, RunnerEnvVar>) {
+    const value = String(raw);
+    const secret = parseSecretPlaceholder(value);
+    if (secret) {
+        envMap.set(key, { name: key, valueFrom: { secretKeyRef: { name: secret.secretName, key: secret.secretKey } } });
+    } else {
+        envMap.set(key, { name: key, value });
+    }
+}
+
+function addPrometheusEnvVars(cfg: K6Config, envMap: Map<string, RunnerEnvVar>) {
+    if (cfg.prometheus?.serverUrl) {
+        envMap.set(K6_PROMETHEUS_RW_SERVER_URL, {
+            name: K6_PROMETHEUS_RW_SERVER_URL,
+            value: cfg.prometheus.serverUrl,
+        });
+        if (cfg.prometheus.trendStats?.length) {
+            envMap.set(K6_PROMETHEUS_RW_TREND_STATS, {
+                name: K6_PROMETHEUS_RW_TREND_STATS,
+                value: cfg.prometheus.trendStats.join(","),
+            });
+        }
+    }
+}

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

@@ -1,7 +1,6 @@
-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 } from '../../src/services/kubernetes.service';
 import { ScriptService } from '../../src/services/script.service';
 import { ConfigMapResult } from '../../src/types/kubernetes.types';
@@ -11,6 +10,11 @@ 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 { 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');
@@ -24,18 +28,6 @@ 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);
@@ -56,15 +48,26 @@ describe('KubernetesService integration tests', () => {
     expect(response).toBeDefined();
     logger.info("TestRun result:", JSON.stringify(response));
 
+    // Persist last run state for use by logs/status/delete commands
+    await saveLastRun({
+      testRunName: testRunManifest.metadata.name,
+      namespace: testRunManifest.metadata.namespace,
+      configMapName: configMapResult.configMapName,
+      scriptPath: archiveOutput.archivePath,
+      createdAt: new Date().toISOString(),
+    });
+    logger.info(`Last run saved: ${testRunManifest.metadata.name} (namespace: ${testRunManifest.metadata.namespace})`);
+
     // Wait for some time to allow the TestRun to be created and start running
-    await new Promise((resolve) => setTimeout(resolve, 40000));
+    await new Promise((resolve) => setTimeout(resolve, 60000));
+
+    // Check status command output
+    await status({ namespace: testRunManifest.metadata.namespace });
 
-    // List TestRuns, Pods, and ConfigMaps to verify they are created and running
-    await kubernetesService.listTestRuns();
-    await kubernetesService.listPods();
-    await kubernetesService.listConfigMaps();
+    // Check logs command output
+    await logs({ namespace: testRunManifest.metadata.namespace });
 
     // Clean up the TestRun after successful creation and execution
-    await kubernetesService.deleteTestRun(testRunManifest);
+    await deleteLastRun({ namespace: testRunManifest.metadata.namespace });
   }, 120000);
 });

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

@@ -10,6 +10,7 @@ jest.mock('fs', () => ({
   promises: {
     stat: jest.fn(),
     readFile: jest.fn(),
+    unlink: jest.fn(),
   },
 }));
 
@@ -49,6 +50,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 +121,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');