kitstore-cli 1.0.0

package/src/__tests__/commands/install.test.ts

@@ -0,0 +1,449 @@
+import { installCommand } from '../../commands/install';
+import * as config from '../../config';
+import * as apiClient from '../../api/client';
+import axios from 'axios';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import inquirer from 'inquirer';
+
+// Mock dependencies
+jest.mock('../../config', () => ({
+  getConfig: jest.fn(),
+  getInstallPaths: jest.fn(),
+}));
+
+jest.mock('../../api/client', () => ({
+  createApi: jest.fn(),
+}));
+
+jest.mock('axios');
+jest.mock('fs-extra', () => ({
+  pathExists: jest.fn(),
+  ensureDir: jest.fn(),
+  writeFile: jest.fn(),
+  createReadStream: jest.fn(),
+}));
+jest.mock('inquirer', () => ({
+  prompt: jest.fn(),
+}));
+
+// TC-UNIT-CLI-003: Install command (success)
+describe('Install Command', () => {
+  const mockGetConfig = config.getConfig as jest.MockedFunction<typeof config.getConfig>;
+  const mockGetInstallPaths = config.getInstallPaths as jest.MockedFunction<typeof config.getInstallPaths>;
+  const mockCreateApi = apiClient.createApi as jest.MockedFunction<typeof apiClient.createApi>;
+  const mockAxiosGet = axios.get as jest.MockedFunction<typeof axios.get>;
+  const mockFsEnsureDir = fs.ensureDir as jest.MockedFunction<any>;
+  const mockFsPathExists = fs.pathExists as jest.MockedFunction<any>;
+  const mockFsWriteFile = fs.writeFile as jest.MockedFunction<any>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, 'log').mockImplementation();
+    jest.spyOn(console, 'error').mockImplementation();
+    // Re-establish process.exit mock for each test
+    jest.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => {
+      throw new Error(`Process exit with code ${code}`);
+    }) as any;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should install rule successfully', async () => {
+    mockGetConfig.mockResolvedValue({
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    });
+
+    mockGetInstallPaths.mockReturnValue({
+      rules: '/path/to/rules',
+      commands: '/path/to/commands',
+    });
+
+    const mockRulesApi = {
+      rulesControllerFindAll: jest.fn().mockResolvedValue({
+        data: [
+          {
+            id: 'rule-id-1',
+            name: 'Test Rule',
+            tag: 'test',
+            type: 'rule',
+          },
+        ],
+      }),
+      rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+        data: {
+          downloadUrl: 'https://signed-url.com/file',
+        },
+      }),
+    };
+
+    mockCreateApi.mockResolvedValue({
+      authApi: {} as any,
+      rulesApi: mockRulesApi as any,
+    } as any);
+
+    mockAxiosGet.mockResolvedValue({
+      data: 'rule content',
+    });
+
+    mockFsPathExists.mockResolvedValue(false);
+    mockFsEnsureDir.mockResolvedValue(undefined);
+    mockFsWriteFile.mockResolvedValue(undefined);
+
+    // Mock inquirer when multiple rules exist
+    const mockInquirer = require('inquirer');
+    mockInquirer.prompt = jest.fn().mockResolvedValue({ rule: 'rule-id-1' });
+
+    await installCommand({
+      tag: 'test',
+      type: 'rule',
+    });
+
+    expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalled();
+    expect(mockRulesApi.rulesControllerGetDownloadUrl).toHaveBeenCalledWith('rule-id-1');
+    expect(mockAxiosGet).toHaveBeenCalledWith('https://signed-url.com/file', {
+      responseType: 'text',
+    });
+    expect(mockFsWriteFile).toHaveBeenCalled();
+  });
+
+  // TC-UNIT-CLI-026: Install with tag filtering
+  it('should filter rules by tag', async () => {
+    mockGetConfig.mockResolvedValue({
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    });
+
+    mockGetInstallPaths.mockReturnValue({
+      rules: '/path/to/rules',
+      commands: '/path/to/commands',
+    });
+
+    const mockRulesApi = {
+      rulesControllerFindAll: jest.fn().mockResolvedValue({
+        data: [
+          {
+            id: 'rule-id-1',
+            name: 'Test Rule',
+            tag: 'test',
+            type: 'rule',
+            version: '1.0.0',
+            author: { username: 'testuser' },
+            description: 'A test rule',
+          },
+        ],
+      }),
+      rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+        data: { downloadUrl: 'https://signed-url.com/file' },
+      }),
+    };
+
+    mockCreateApi.mockResolvedValue({
+      authApi: {} as any,
+      rulesApi: mockRulesApi as any,
+    } as any);
+
+    mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+    mockFsPathExists.mockResolvedValue(false);
+    mockFsEnsureDir.mockResolvedValue(undefined);
+    mockFsWriteFile.mockResolvedValue(undefined);
+
+    await installCommand({ tag: 'test' });
+
+    expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({ tag: 'test' });
+  });
+
+  // TC-UNIT-CLI-027: Install with type filtering
+  it('should filter rules by type', async () => {
+    mockGetConfig.mockResolvedValue({
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    });
+
+    mockGetInstallPaths.mockReturnValue({
+      rules: '/path/to/rules',
+      commands: '/path/to/commands',
+    });
+
+    const mockRulesApi = {
+      rulesControllerFindAll: jest.fn().mockResolvedValue({
+        data: [
+          {
+            id: 'rule-id-1',
+            name: 'Test Rule',
+            tag: 'test',
+            type: 'rule',
+            version: '1.0.0',
+            author: { username: 'testuser' },
+          },
+        ],
+      }),
+      rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+        data: { downloadUrl: 'https://signed-url.com/file' },
+      }),
+    };
+
+    mockCreateApi.mockResolvedValue({
+      authApi: {} as any,
+      rulesApi: mockRulesApi as any,
+    } as any);
+
+    mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+    mockFsPathExists.mockResolvedValue(false);
+    mockFsEnsureDir.mockResolvedValue(undefined);
+    mockFsWriteFile.mockResolvedValue(undefined);
+
+    await installCommand({ type: 'rule' });
+
+    expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({ type: 'rule' });
+  });
+
+  // TC-UNIT-CLI-028: Install with file download failure
+  it('should handle file download failure', async () => {
+    mockGetConfig.mockResolvedValue({
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    });
+
+    mockGetInstallPaths.mockReturnValue({
+      rules: '/path/to/rules',
+      commands: '/path/to/commands',
+    });
+
+    const mockRulesApi = {
+      rulesControllerFindAll: jest.fn().mockResolvedValue({
+        data: [
+          {
+            id: 'rule-id-1',
+            name: 'Test Rule',
+            tag: 'test',
+            type: 'rule',
+            version: '1.0.0',
+            author: { username: 'testuser' },
+          },
+        ],
+      }),
+      rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+        data: { downloadUrl: 'https://signed-url.com/file' },
+      }),
+    };
+
+    mockCreateApi.mockResolvedValue({
+      authApi: {} as any,
+      rulesApi: mockRulesApi as any,
+    } as any);
+
+    // Mock axios download failure
+    mockAxiosGet.mockRejectedValue(new Error('Download failed'));
+    mockFsPathExists.mockResolvedValue(false);
+
+    await expect(installCommand({})).rejects.toThrow('Process exit with code 1');
+
+    expect(mockAxiosGet).toHaveBeenCalledWith('https://signed-url.com/file', {
+      responseType: 'text',
+    });
+    expect(console.error).toHaveBeenCalledWith('❌ Failed to download rule:', 'Download failed');
+  });
+
+  // TC-UNIT-CLI-029: Install with directory permission issues
+  it('should handle directory creation permission issues', async () => {
+    mockGetConfig.mockResolvedValue({
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    });
+
+    mockGetInstallPaths.mockReturnValue({
+      rules: '/path/to/rules',
+      commands: '/path/to/commands',
+    });
+
+    const mockRulesApi = {
+      rulesControllerFindAll: jest.fn().mockResolvedValue({
+        data: [
+          {
+            id: 'rule-id-1',
+            name: 'Test Rule',
+            tag: 'test',
+            type: 'rule',
+            version: '1.0.0',
+            author: { username: 'testuser' },
+          },
+        ],
+      }),
+      rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+        data: { downloadUrl: 'https://signed-url.com/file' },
+      }),
+    };
+
+    mockCreateApi.mockResolvedValue({
+      authApi: {} as any,
+      rulesApi: mockRulesApi as any,
+    } as any);
+
+    mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+    mockFsPathExists.mockResolvedValue(false);
+    mockFsEnsureDir.mockRejectedValue(new Error('Permission denied'));
+    mockFsWriteFile.mockResolvedValue(undefined);
+
+    await expect(installCommand({})).rejects.toThrow('Process exit with code 1');
+
+    expect(mockFsEnsureDir).toHaveBeenCalledWith('/path/to/rules');
+    expect(console.error).toHaveBeenCalledWith('❌ Failed to create installation directory:', 'Permission denied');
+  });
+
+  // TC-UNIT-CLI-030: Install with force overwrite
+  it('should handle force overwrite option', async () => {
+    mockGetConfig.mockResolvedValue({
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    });
+
+    mockGetInstallPaths.mockReturnValue({
+      rules: '/path/to/rules',
+      commands: '/path/to/commands',
+    });
+
+    const mockRulesApi = {
+      rulesControllerFindAll: jest.fn().mockResolvedValue({
+        data: [
+          {
+            id: 'rule-id-1',
+            name: 'Test Rule',
+            tag: 'test',
+            type: 'rule',
+            version: '1.0.0',
+            author: { username: 'testuser' },
+          },
+        ],
+      }),
+      rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+        data: { downloadUrl: 'https://signed-url.com/file' },
+      }),
+    };
+
+    mockCreateApi.mockResolvedValue({
+      authApi: {} as any,
+      rulesApi: mockRulesApi as any,
+    } as any);
+
+    mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+    mockFsPathExists.mockResolvedValue(true); // File already exists
+    mockFsEnsureDir.mockResolvedValue(undefined);
+    mockFsWriteFile.mockResolvedValue(undefined);
+
+    await installCommand({ force: true });
+
+    expect(mockFsWriteFile).toHaveBeenCalledWith(path.join('/path/to/rules', 'rule-id-1'), 'rule content');
+    expect(console.log).toHaveBeenCalledWith('✅ Successfully installed rule: Test Rule');
+  });
+
+  // TC-UNIT-CLI-031: Install with no rules found
+  it('should handle no rules found', async () => {
+    mockGetConfig.mockResolvedValue({
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    });
+
+    const mockRulesApi = {
+      rulesControllerFindAll: jest.fn().mockResolvedValue({
+        data: [],
+      }),
+    };
+
+    mockCreateApi.mockResolvedValue({
+      authApi: {} as any,
+      rulesApi: mockRulesApi as any,
+    } as any);
+
+    await installCommand({});
+
+    expect(console.log).toHaveBeenCalledWith('📭 No rules found matching the criteria.');
+  });
+
+  // TC-UNIT-CLI-032: Install with multiple rules (interactive selection)
+  it('should handle multiple rules with interactive selection', async () => {
+    const mockInquirer = require('inquirer');
+    mockInquirer.prompt = jest.fn().mockResolvedValue({ rule: 'rule-id-2' });
+
+    mockGetConfig.mockResolvedValue({
+      server: 'http://localhost:3000',
+      token: 'test-token',
+      user: { id: 'user-id', username: 'testuser' },
+      lastLogin: new Date().toISOString(),
+    });
+
+    mockGetInstallPaths.mockReturnValue({
+      rules: '/path/to/rules',
+      commands: '/path/to/commands',
+    });
+
+    const mockRulesApi = {
+      rulesControllerFindAll: jest.fn().mockResolvedValue({
+        data: [
+          {
+            id: 'rule-id-1',
+            name: 'Test Rule 1',
+            tag: 'test',
+            type: 'rule',
+            version: '1.0.0',
+            author: { username: 'testuser' },
+          },
+          {
+            id: 'rule-id-2',
+            name: 'Test Rule 2',
+            tag: 'test',
+            type: 'rule',
+            version: '1.0.0',
+            author: { username: 'testuser' },
+          },
+        ],
+      }),
+      rulesControllerGetDownloadUrl: jest.fn().mockResolvedValue({
+        data: { downloadUrl: 'https://signed-url.com/file' },
+      }),
+    };
+
+    mockCreateApi.mockResolvedValue({
+      authApi: {} as any,
+      rulesApi: mockRulesApi as any,
+    } as any);
+
+    mockAxiosGet.mockResolvedValue({ data: 'rule content' });
+    mockFsPathExists.mockResolvedValue(false);
+    mockFsEnsureDir.mockResolvedValue(undefined);
+    mockFsWriteFile.mockResolvedValue(undefined);
+
+    await installCommand({});
+
+    expect(mockInquirer.prompt).toHaveBeenCalledWith([
+      {
+        type: 'list',
+        name: 'rule',
+        message: 'Select a rule to install:',
+        choices: [
+          { name: 'Test Rule 1 (rule-id-1)', value: 'rule-id-1' },
+          { name: 'Test Rule 2 (rule-id-2)', value: 'rule-id-2' },
+        ],
+      },
+    ]);
+    expect(mockRulesApi.rulesControllerGetDownloadUrl).toHaveBeenCalledWith('rule-id-2');
+  });
+});
+

package/src/__tests__/commands/list.test.ts

@@ -0,0 +1,164 @@
+import { listCommand } from '../../commands/list';
+import * as config from '../../config';
+
+// Mock dependencies
+jest.mock('../../config', () => ({
+  getConfig: jest.fn(),
+}));
+
+jest.mock('../../api/client', () => ({
+  createApi: jest.fn(),
+}));
+
+describe('List Command', () => {
+  const mockGetConfig = config.getConfig as jest.MockedFunction<typeof config.getConfig>;
+  const mockCreateApi = require('../../api/client').createApi as jest.MockedFunction<any>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, 'log').mockImplementation();
+    jest.spyOn(console, 'error').mockImplementation();
+    // Re-establish process.exit mock for each test
+    jest.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => {
+      throw new Error(`Process exit with code ${code}`);
+    }) as any;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('list success', () => {
+    it('should list all rules when no filters provided', async () => {
+      mockGetConfig.mockResolvedValue({
+        server: 'http://localhost:3000',
+        token: 'test-token',
+        user: { id: 'user-id', username: 'testuser' },
+        lastLogin: new Date().toISOString(),
+      });
+
+      const mockRulesApi = {
+        rulesControllerFindAll: jest.fn().mockResolvedValue({
+          data: [
+            {
+              id: 'rule-1',
+              name: 'Test Rule 1',
+              tag: 'test',
+              type: 'rule',
+              description: 'First test rule',
+              version: '1.0.0',
+              author: { username: 'user1' },
+              createdAt: '2024-01-01T00:00:00.000Z',
+            },
+            {
+              id: 'rule-2',
+              name: 'Test Rule 2',
+              tag: 'util',
+              type: 'command',
+              description: 'Second test rule',
+              version: '2.0.0',
+              author: { username: 'user2' },
+              createdAt: '2024-01-02T00:00:00.000Z',
+            },
+          ],
+        }),
+      };
+
+      mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+
+      await listCommand({});
+
+      expect(mockCreateApi).toHaveBeenCalledWith({ server: 'http://localhost:3000' });
+      expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({});
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('📋 Found 2 rules/commands:'));
+    });
+
+    it('should apply filters when provided', async () => {
+      mockGetConfig.mockResolvedValue({
+        server: 'http://localhost:3000',
+        token: 'test-token',
+        user: { id: 'user-id', username: 'testuser' },
+        lastLogin: new Date().toISOString(),
+      });
+
+      const mockRulesApi = {
+        rulesControllerFindAll: jest.fn().mockResolvedValue({
+          data: [
+            {
+              id: 'rule-1',
+              name: 'Filtered Rule',
+              tag: 'test',
+              type: 'rule',
+              description: 'Filtered test rule',
+              version: '1.0.0',
+              author: { username: 'user1' },
+              createdAt: '2024-01-01T00:00:00.000Z',
+            },
+          ],
+        }),
+      };
+
+      mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+
+      await listCommand({ type: 'rule', tag: 'test', limit: '10' });
+
+      expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({
+        type: 'rule',
+        tag: 'test',
+        limit: 10,
+      });
+    });
+
+    it('should handle empty results', async () => {
+      mockGetConfig.mockResolvedValue({
+        server: 'http://localhost:3000',
+        token: 'test-token',
+        user: { id: 'user-id', username: 'testuser' },
+        lastLogin: new Date().toISOString(),
+      });
+
+      const mockRulesApi = {
+        rulesControllerFindAll: jest.fn().mockResolvedValue({
+          data: [],
+        }),
+      };
+
+      mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+
+      await listCommand({});
+
+      expect(console.log).toHaveBeenCalledWith(expect.stringContaining('📭 No rules or commands found.'));
+    });
+  });
+
+  describe('list failure', () => {
+    it('should exit with error when not logged in', async () => {
+      mockGetConfig.mockResolvedValue({
+        server: 'http://localhost:3000',
+        token: undefined,
+        user: undefined,
+      });
+
+      await expect(listCommand({})).rejects.toThrow('Process exit with code 1');
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining('❌ Not logged in. Please run `kitstore login` first.'));
+    });
+
+    it('should handle API errors gracefully', async () => {
+      mockGetConfig.mockResolvedValue({
+        server: 'http://localhost:3000',
+        token: 'test-token',
+        user: { id: 'user-id', username: 'testuser' },
+        lastLogin: new Date().toISOString(),
+      });
+
+      const mockRulesApi = {
+        rulesControllerFindAll: jest.fn().mockRejectedValue(new Error('API Error')),
+      };
+
+      mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
+
+      await expect(listCommand({})).rejects.toThrow('Process exit with code 1');
+      expect(console.error).toHaveBeenCalledWith(expect.stringContaining('❌ Failed to list rules:'));
+    });
+  });
+});