kitstore-cli 1.0.0 → 1.0.1

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

@@ -1,293 +0,0 @@
-import { loginCommand } from '../../commands/login';
-import * as config from '../../config';
-import * as apiClient from '../../api/client';
-import axios from 'axios';
-import inquirer from 'inquirer';
-
-// Mock dependencies
-jest.mock('../../config', () => ({
-  getConfig: jest.fn(),
-  saveConfig: jest.fn(),
-}));
-
-jest.mock('../../api/client', () => ({
-  createApi: jest.fn(),
-}));
-
-jest.mock('axios');
-jest.mock('inquirer', () => ({
-  prompt: jest.fn(),
-}));
-
-const mockInquirer = require('inquirer');
-
-// TC-UNIT-CLI-001 to TC-UNIT-CLI-002
-describe('Login Command', () => {
-  const mockGetConfig = config.getConfig as jest.MockedFunction<typeof config.getConfig>;
-  const mockSaveConfig = config.saveConfig as jest.MockedFunction<typeof config.saveConfig>;
-  const mockCreateApi = apiClient.createApi as jest.MockedFunction<typeof apiClient.createApi>;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    (axios.isAxiosError as unknown as jest.Mock).mockImplementation((err: any) => err?.isAxiosError === true);
-    jest.spyOn(console, 'log').mockImplementation();
-    jest.spyOn(console, 'error').mockImplementation();
-    jest.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => {
-      throw new Error(`Process exit with code ${code}`);
-    });
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  // TC-UNIT-CLI-001: Login command (success)
-  describe('login success', () => {
-    it('should login successfully and save token', async () => {
-      const mockAuthApi = {
-        authControllerLogin: jest.fn().mockResolvedValue({
-          data: {
-            token: 'test-token-123',
-            user: {
-              id: 'user-id',
-              username: 'testuser',
-              email: 'test@example.com',
-            },
-          },
-        }),
-      };
-
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: undefined,
-        user: undefined,
-        lastLogin: undefined,
-      });
-
-      mockCreateApi.mockResolvedValue({
-        authApi: mockAuthApi,
-        rulesApi: {} as any,
-      } as any);
-
-      await loginCommand({
-        email: 'test@example.com',
-        password: 'Password123!',
-      });
-
-      expect(mockCreateApi).toHaveBeenCalledWith({ server: 'http://localhost:3000' });
-      expect(mockAuthApi.authControllerLogin).toHaveBeenCalledWith({
-        email: 'test@example.com',
-        password: 'Password123!',
-      });
-      expect(mockSaveConfig).toHaveBeenCalledWith({
-        token: 'test-token-123',
-        server: 'http://localhost:3000',
-        user: {
-          id: 'user-id',
-          username: 'testuser',
-          email: 'test@example.com',
-        },
-        lastLogin: expect.any(String),
-      });
-    });
-  });
-
-  // TC-UNIT-CLI-002: Login command (failure)
-  describe('login failure', () => {
-    it('should handle 401 error', async () => {
-      const axiosError = {
-        isAxiosError: true,
-        response: {
-          status: 401,
-          data: { error: 'Invalid credentials' },
-        },
-        message: 'Request failed with status code 401',
-      } as any;
-
-      const mockAuthApi = {
-        authControllerLogin: jest.fn().mockRejectedValue(axiosError),
-      };
-
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: undefined,
-        user: undefined,
-        lastLogin: undefined,
-      });
-
-      mockCreateApi.mockResolvedValue({
-        authApi: mockAuthApi,
-        rulesApi: {} as any,
-      } as any);
-
-      await expect(
-        loginCommand({
-          email: 'test@example.com',
-          password: 'WrongPassword',
-        }),
-      ).rejects.toThrow();
-
-      expect(mockSaveConfig).not.toHaveBeenCalled();
-    });
-
-    // TC-UNIT-CLI-003: Interactive login prompts
-    it('should prompt for email and password when not provided', async () => {
-      mockInquirer.prompt
-        .mockResolvedValueOnce({ email: 'prompted@example.com' })
-        .mockResolvedValueOnce({ password: 'promptedpassword' });
-
-      const mockAuthApi = {
-        authControllerLogin: jest.fn().mockResolvedValue({
-          data: {
-            token: 'test-token-123',
-            user: {
-              id: 'user-id',
-              username: 'testuser',
-              email: 'prompted@example.com',
-            },
-          },
-        }),
-      };
-
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: undefined,
-        user: undefined,
-        lastLogin: undefined,
-      });
-
-      mockCreateApi.mockResolvedValue({
-        authApi: mockAuthApi,
-        rulesApi: {} as any,
-      } as any);
-
-      await loginCommand({});
-
-      expect(mockInquirer.prompt).toHaveBeenCalledTimes(2);
-      expect(mockInquirer.prompt).toHaveBeenNthCalledWith(1, [
-        { type: 'input', name: 'email', message: 'Email:' }
-      ]);
-      expect(mockInquirer.prompt).toHaveBeenNthCalledWith(2, [
-        { type: 'password', name: 'password', message: 'Password:' }
-      ]);
-      expect(mockAuthApi.authControllerLogin).toHaveBeenCalledWith({
-        email: 'prompted@example.com',
-        password: 'promptedpassword',
-      });
-    });
-
-    // TC-UNIT-CLI-004: Empty credentials after prompts
-    it('should exit with error when email/password are empty after prompts', async () => {
-      mockInquirer.prompt
-        .mockResolvedValueOnce({ email: '' })
-        .mockResolvedValueOnce({ password: '' });
-
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: undefined,
-        user: undefined,
-        lastLogin: undefined,
-      });
-
-      await expect(loginCommand({})).rejects.toThrow('Process exit with code 1');
-      expect(console.error).toHaveBeenCalledWith('❌ Login failed: Email and password are required');
-    });
-
-    // TC-UNIT-CLI-005: Login response without token
-    it('should handle login response without token', async () => {
-      const mockAuthApi = {
-        authControllerLogin: jest.fn().mockResolvedValue({
-          data: {
-            user: {
-              id: 'user-id',
-              username: 'testuser',
-              email: 'test@example.com',
-            },
-          },
-        }),
-      };
-
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: undefined,
-        user: undefined,
-        lastLogin: undefined,
-      });
-
-      mockCreateApi.mockResolvedValue({
-        authApi: mockAuthApi,
-        rulesApi: {} as any,
-      } as any);
-
-      await expect(loginCommand({ email: 'test@example.com', password: 'password123' }))
-        .rejects.toThrow('Process exit with code 1');
-
-      expect(console.error).toHaveBeenCalledWith('❌ Login failed');
-    });
-
-    // TC-UNIT-CLI-006: Other axios errors
-    it('should handle other axios errors', async () => {
-      const axiosError = {
-        isAxiosError: true,
-        response: {
-          status: 500,
-          data: { error: 'Internal server error' },
-        },
-        message: 'Request failed with status code 500',
-      } as any;
-
-      const mockAuthApi = {
-        authControllerLogin: jest.fn().mockRejectedValue(axiosError),
-      };
-
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: undefined,
-        user: undefined,
-        lastLogin: undefined,
-      });
-
-      mockCreateApi.mockResolvedValue({
-        authApi: mockAuthApi,
-        rulesApi: {} as any,
-      } as any);
-
-      await expect(
-        loginCommand({
-          email: 'test@example.com',
-          password: 'Password123!',
-        }),
-      ).rejects.toThrow('Process exit with code 1');
-
-      expect(console.error).toHaveBeenCalledWith('❌ Login failed: Internal server error');
-    });
-
-    // TC-UNIT-CLI-007: Non-axios errors
-    it('should handle non-axios errors', async () => {
-      const mockAuthApi = {
-        authControllerLogin: jest.fn().mockRejectedValue(new Error('Network error')),
-      };
-
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: undefined,
-        user: undefined,
-        lastLogin: undefined,
-      });
-
-      mockCreateApi.mockResolvedValue({
-        authApi: mockAuthApi,
-        rulesApi: {} as any,
-      } as any);
-
-      await expect(
-        loginCommand({
-          email: 'test@example.com',
-          password: 'Password123!',
-        }),
-      ).rejects.toThrow('Process exit with code 1');
-
-      expect(console.error).toHaveBeenCalledWith('❌ Login failed: Network error');
-    });
-  });
-});

package/src/__tests__/commands/rule-check.test.ts

@@ -1,52 +0,0 @@
-import { ruleCheckCommand } from '../../commands/rule-check';
-import * as fs from 'fs-extra';
-import chalk from 'chalk';
-
-jest.mock('fs-extra');
-
-describe('Rule Check Command', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.spyOn(console, 'log').mockImplementation();
-    jest.spyOn(console, 'error').mockImplementation();
-    jest.spyOn(console, 'warn').mockImplementation();
-    jest.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined) => {
-      throw new Error(`Process exit with code ${code}`);
-    }) as any;
-  });
-
-  it('should pass for a valid rule file', async () => {
-    (fs.pathExists as unknown as jest.Mock).mockResolvedValue(true);
-    (fs.readFile as unknown as jest.Mock).mockResolvedValue('@requirement TC-UNIT-001\nValid rule content');
-
-    await ruleCheckCommand('valid-rule.md');
-
-    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Rule validation passed!'));
-  });
-
-  it('should exit if file not found', async () => {
-    (fs.pathExists as unknown as jest.Mock).mockResolvedValue(false);
-
-    await expect(ruleCheckCommand('non-existent.md')).rejects.toThrow('Process exit with code 1');
-    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('File not found'));
-  });
-
-  it('should warn about missing @requirement tag', async () => {
-    (fs.pathExists as unknown as jest.Mock).mockResolvedValue(true);
-    (fs.readFile as unknown as jest.Mock).mockResolvedValue('Rule without requirement tag');
-
-    await ruleCheckCommand('no-tag.md');
-
-    expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Warning: Missing @requirement tag'));
-  });
-
-  it('should error if file is empty', async () => {
-    (fs.pathExists as unknown as jest.Mock).mockResolvedValue(true);
-    (fs.readFile as unknown as jest.Mock).mockResolvedValue('');
-
-    await ruleCheckCommand('empty.md');
-
-    expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Error: File is empty'));
-  });
-});
-

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

@@ -1,168 +0,0 @@
-import { searchCommand } from '../../commands/search';
-import * as config from '../../config';
-
-// Mock dependencies
-jest.mock('../../config', () => ({
-  getConfig: jest.fn(),
-}));
-
-jest.mock('../../api/client', () => ({
-  createApi: jest.fn(),
-}));
-
-describe('Search 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('search success', () => {
-    it('should search rules by query', 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: 'Authentication Rule',
-              tag: 'auth',
-              type: 'rule',
-              description: 'Handles user authentication',
-              version: '1.0.0',
-              author: { username: 'user1' },
-              createdAt: '2024-01-01T00:00:00.000Z',
-            },
-          ],
-        }),
-      };
-
-      mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
-
-      await searchCommand('auth', {});
-
-      expect(mockCreateApi).toHaveBeenCalledWith({ server: 'http://localhost:3000' });
-      expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({
-        name: 'auth',
-      });
-      expect(console.log).toHaveBeenCalledWith('🔍 Search results for "auth":');
-    });
-
-    it('should apply additional filters with search query', 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: 'Validation Rule',
-              tag: 'validation',
-              type: 'rule',
-              description: 'Input validation rule',
-              version: '1.0.0',
-              author: { username: 'user1' },
-              createdAt: '2024-01-01T00:00:00.000Z',
-            },
-          ],
-        }),
-      };
-
-      mockCreateApi.mockResolvedValue({ rulesApi: mockRulesApi });
-
-      await searchCommand('validation', { type: 'rule', limit: '5' });
-
-      expect(mockRulesApi.rulesControllerFindAll).toHaveBeenCalledWith({
-        name: 'validation',
-        type: 'rule',
-        limit: 5,
-      });
-    });
-
-    it('should handle no search 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 searchCommand('nonexistent', {});
-
-      expect(console.log).toHaveBeenCalledWith('🔍 No rules or commands found matching "nonexistent".');
-    });
-  });
-
-  describe('search failure', () => {
-    it('should exit with error when not logged in', async () => {
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: undefined,
-        user: undefined,
-      });
-
-      await expect(searchCommand('test', {})).rejects.toThrow('Process exit with code 1');
-      expect(console.error).toHaveBeenCalledWith('❌ Not logged in. Please run `kitstore login` first.');
-    });
-
-    it('should validate query parameter', async () => {
-      mockGetConfig.mockResolvedValue({
-        server: 'http://localhost:3000',
-        token: 'test-token',
-        user: { id: 'user-id', username: 'testuser' },
-        lastLogin: new Date().toISOString(),
-      });
-
-      await expect(searchCommand('', {})).rejects.toThrow('Process exit with code 1');
-      expect(console.error).toHaveBeenCalledWith('❌ Search query is required.');
-    });
-
-    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(searchCommand('test', {})).rejects.toThrow('Process exit with code 1');
-      expect(console.error).toHaveBeenCalledWith('❌ Search failed:', expect.any(Error));
-    });
-  });
-});