k6ctl 1.0.0

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

@@ -0,0 +1,197 @@
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
+import { existsSync, promises as fs_promises } from 'fs';
+import * as k8s from '@kubernetes/client-node';
+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('@kubernetes/client-node', () => {
+  const mockApiClient = {
+    createNamespacedConfigMap: jest.fn(),
+    deleteNamespacedConfigMap: jest.fn(),
+  };
+
+  const mockLoadFromDefault = jest.fn();
+  const mockSetCurrentContext = jest.fn();
+  const mockMakeApiClient = jest.fn(() => mockApiClient);
+
+  const KubeConfig = jest.fn().mockImplementation(() => ({
+    loadFromDefault: mockLoadFromDefault,
+    setCurrentContext: mockSetCurrentContext,
+    makeApiClient: mockMakeApiClient,
+  }));
+
+  return {
+    KubeConfig,
+    CoreV1Api: jest.fn(),
+    __mocks: {
+      mockApiClient,
+      mockLoadFromDefault,
+      mockSetCurrentContext,
+      mockMakeApiClient,
+    },
+  };
+});
+
+jest.mock('../../src/utils/logger', () => ({
+  __esModule: true,
+  default: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+
+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 mockedLoggerInfo = logger.info as unknown as jest.Mock;
+
+const mockedK8sModule = k8s as unknown as {
+  KubeConfig: jest.Mock;
+  CoreV1Api: unknown;
+  __mocks: {
+    mockApiClient: {
+      createNamespacedConfigMap: jest.Mock;
+      deleteNamespacedConfigMap: jest.Mock;
+    };
+    mockLoadFromDefault: jest.Mock;
+    mockSetCurrentContext: jest.Mock;
+    mockMakeApiClient: jest.Mock;
+  };
+};
+
+describe('KubernetesService', () => {
+  let service: KubernetesService;
+  let mockCoreV1Api: {
+    createNamespacedConfigMap: jest.Mock;
+    deleteNamespacedConfigMap: jest.Mock;
+  };
+  let mockCustomObjectsApi: {
+    createNamespacedCustomObject: jest.Mock;
+    deleteNamespacedCustomObject: jest.Mock;
+  };
+
+  const archiveFile: ArchivedFile = {
+    archivePath: '/tmp/archive-script.tar',
+    archiveFilename: 'archive-script.tar',
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockCoreV1Api = {
+      createNamespacedConfigMap: jest.fn(),
+      deleteNamespacedConfigMap: jest.fn(),
+    };
+    mockCustomObjectsApi = {
+      createNamespacedCustomObject: jest.fn(),
+      deleteNamespacedCustomObject: jest.fn(),
+    };
+
+    service = new KubernetesService(mockCoreV1Api as unknown as k8s.CoreV1Api, mockCustomObjectsApi as unknown as k8s.CustomObjectsApi);
+  });
+
+  describe('createConfigMap', () => {
+    test('throws when archive file does not exist', async () => {
+      mockedExistsSync.mockReturnValue(false);
+
+      await expect(service.createConfigMap(archiveFile, 'default'))
+        .rejects.toThrow('Archive file not found at path: /tmp/archive-script.tar');
+
+      expect(mockedStat).not.toHaveBeenCalled();
+      expect(mockCoreV1Api.createNamespacedConfigMap).not.toHaveBeenCalled();
+    });
+
+    test('throws when archive file is larger than 1MB', async () => {
+      mockedExistsSync.mockReturnValue(true);
+      mockedStat.mockImplementation(async () => ({ size: 1024 * 1024 + 1 }));
+
+      await expect(service.createConfigMap(archiveFile, 'default'))
+        .rejects.toThrow('Archive file is too large to be stored in a configmap');
+
+      expect(mockedReadFile).not.toHaveBeenCalled();
+      expect(mockCoreV1Api.createNamespacedConfigMap).not.toHaveBeenCalled();
+    });
+
+    test('creates configmap with binaryData and returns namespace/name', async () => {
+      mockedExistsSync.mockReturnValue(true);
+      mockedStat.mockImplementation(async () => ({ size: 512 }));
+      mockedReadFile.mockImplementation(async () => 'YmFzZTY0');
+      mockCoreV1Api.createNamespacedConfigMap.mockImplementation(async () => ({}));
+
+      const result = await service.createConfigMap(archiveFile, 'performance');
+
+      expect(mockedReadFile).toHaveBeenCalledWith('/tmp/archive-script.tar', 'base64');
+      expect(mockCoreV1Api.createNamespacedConfigMap).toHaveBeenCalledWith({
+        namespace: 'performance',
+        body: {
+          apiVersion: 'v1',
+          kind: 'ConfigMap',
+          metadata: {
+            name: 'archive-script',
+            namespace: 'performance',
+          },
+          binaryData: {
+            'archive-script.tar': 'YmFzZTY0',
+          },
+        },
+      });
+      expect(result).toEqual({
+        namespace: 'performance',
+        configMapName: 'archive-script',
+      });
+      expect(mockedLoggerInfo).toHaveBeenCalledWith('ConfigMap archive-script created in namespace performance');
+    });
+  });
+
+  describe('deleteConfigMap', () => {
+    test('deletes configmap and logs message on success', async () => {
+      mockCoreV1Api.deleteNamespacedConfigMap.mockImplementation(async () => ({}));
+
+      await service.deleteConfigMap('archive-script', 'default');
+
+      expect(mockCoreV1Api.deleteNamespacedConfigMap).toHaveBeenCalledWith({
+        name: 'archive-script',
+        namespace: 'default',
+      });
+      expect(mockedLoggerInfo).toHaveBeenCalledWith('ConfigMap archive-script deleted from namespace default');
+    });
+
+    test('wraps and throws error when delete fails', async () => {
+      mockCoreV1Api.deleteNamespacedConfigMap.mockImplementation(async () => {
+        throw new Error('kaboom');
+      });
+
+      await expect(service.deleteConfigMap('archive-script', 'default'))
+        .rejects.toThrow('Failed to delete ConfigMap archive-script from namespace default: kaboom');
+    });
+  });
+});
+
+describe('createDefaultKubernetesService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('loads kube config and creates KubernetesService without context', () => {
+    const service = createDefaultKubernetesService();
+
+    expect(service).toBeInstanceOf(KubernetesService);
+    expect(mockedK8sModule.KubeConfig).toHaveBeenCalledTimes(1);
+    expect(mockedK8sModule.__mocks.mockLoadFromDefault).toHaveBeenCalledTimes(1);
+    expect(mockedK8sModule.__mocks.mockSetCurrentContext).not.toHaveBeenCalled();
+    expect(mockedK8sModule.__mocks.mockMakeApiClient).toHaveBeenCalledWith(mockedK8sModule.CoreV1Api);
+  });
+
+  test('sets current context when context is provided', () => {
+    createDefaultKubernetesService('minikube');
+
+    expect(mockedK8sModule.__mocks.mockSetCurrentContext).toHaveBeenCalledWith('minikube');
+    expect(mockedK8sModule.__mocks.mockMakeApiClient).toHaveBeenCalledWith(mockedK8sModule.CoreV1Api);
+  });
+});

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

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, jest, test } from '@jest/globals';
+import { ScriptService } from '../../src/services/script.service';
+import { existsSync } from 'fs';
+import type { ExecFn } from '../../src/types/script.types';
+
+jest.mock('fs', () => ({
+  existsSync: jest.fn(),
+}));
+
+jest.mock('../../src/utils/logger', () => ({
+  __esModule: true,
+  default: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+
+const mockedExistsSync = existsSync as unknown as jest.Mock;
+
+describe('ScriptService', () => {
+  let mockExec: jest.MockedFunction<ExecFn>;
+  let service: ScriptService;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    mockExec = jest.fn<ExecFn>();
+    service = new ScriptService(mockExec);
+  });
+
+  describe('archiveTest', () => {
+    test('throws error if script does not exist', async () => {
+      mockedExistsSync.mockReturnValue(false);
+
+      await expect(service.archiveTest('/path/to/script.js'))
+        .rejects.toThrow('Script file not found at path: /path/to/script.js');
+    });
+
+    test('throws error if output directory does not exist', async () => {
+      mockedExistsSync
+        .mockReturnValueOnce(true)   // script exists
+        .mockReturnValueOnce(false); // output dir missing
+
+      await expect(service.archiveTest('/path/to/script.js', '/fake/output'))
+        .rejects.toThrow('Output directory does not exist at path: /fake/output');
+    });
+
+    test('throws error if k6 is not installed', async () => {
+      mockedExistsSync.mockReturnValue(true);
+      mockExec.mockRejectedValue(new Error('command not found: k6'));
+
+      await expect(service.archiveTest('/path/to/script.js'))
+        .rejects.toThrow('k6 is not installed. Please install k6 to archive scripts.');
+    });
+
+    test('throws error if archive file was not created', async () => {
+      mockedExistsSync
+        .mockReturnValueOnce(true)   // script exists
+        .mockReturnValueOnce(false); // archive file not created after command
+      mockExec.mockResolvedValue({ stdout: '', stderr: 'k6 internal error' });
+
+      await expect(service.archiveTest('/path/to/script.js'))
+        .rejects.toThrow('Failed to archive the script:');
+    });
+
+    test('returns correct ArchiveResult without output directory', async () => {
+      mockedExistsSync
+        .mockReturnValueOnce(true)  // script exists
+        .mockReturnValueOnce(true); // archive file created
+      mockExec.mockResolvedValue({ stdout: '', stderr: '' });
+
+      const result = await service.archiveTest('/path/to/script.js');
+
+      expect(result.scriptPath).toBe('/path/to/script.js');
+      expect(result.scriptFilename).toBe('script.js');
+      expect(result.archiveFilename).toMatch(/^archive-script-\d+\.tar$/);
+      expect(result.archivePath).toMatch(/^archive-script-\d+\.tar$/);
+    });
+
+    test('returns ArchiveResult with the specified output directory', async () => {
+      mockedExistsSync
+        .mockReturnValueOnce(true)  // script exists
+        .mockReturnValueOnce(true)  // output dir exists
+        .mockReturnValueOnce(true); // archive file created
+      mockExec.mockResolvedValue({ stdout: '', stderr: '' });
+
+      const result = await service.archiveTest('/path/to/script.js', '/output/dir');
+
+      expect(result.archivePath).toMatch(/^\/output\/dir[/\\]archive-script-\d+\.tar$/);
+    });
+
+    test('calls k6 version and then the archive command', async () => {
+      mockedExistsSync
+        .mockReturnValueOnce(true)
+        .mockReturnValueOnce(true);
+      mockExec.mockResolvedValue({ stdout: '', stderr: '' });
+
+      await service.archiveTest('/path/to/script.js');
+
+      expect(mockExec).toHaveBeenCalledTimes(2);
+      expect(mockExec).toHaveBeenNthCalledWith(1, 'k6 version');
+      expect((mockExec.mock.calls[1][0] as string)).toMatch(/^k6 archive -v -O .+ \/path\/to\/script\.js$/);
+    });
+
+    test('sanitizes underscores in script name', async () => {
+      mockedExistsSync
+        .mockReturnValueOnce(true)
+        .mockReturnValueOnce(true);
+      mockExec.mockResolvedValue({ stdout: '', stderr: '' });
+
+      const result = await service.archiveTest('/path/to/my_script_v2.js');
+
+      expect(result.archiveFilename).toMatch(/^archive-my-script-v2-\d+\.tar$/);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}