qa360 2.2.1 → 2.2.13

package/cli/src/commands/__tests__/monitor.test.ts

@@ -1,81 +0,0 @@
-/**
- * Unit Tests: Monitor Commands
- */
-
-import { describe, it, expect } from 'vitest';
-import { Command } from 'commander';
-import {
-  createMonitorCommands,
-  createDashboardCommand
-} from '../monitor.js';
-
-describe('Monitor Commands', () => {
-  describe('createMonitorCommands', () => {
-    it('should create command with correct structure', () => {
-      const cmd = createMonitorCommands();
-
-      expect(cmd.name()).toBe('monitor');
-      expect(cmd.description()).toBeDefined();
-    });
-  });
-
-  describe('createDashboardCommand', () => {
-    it('should create command with correct structure', () => {
-      const cmd = createDashboardCommand();
-
-      expect(cmd.name()).toBe('dashboard');
-      expect(cmd.description()).toBeDefined();
-    });
-
-    it('should have --port option', () => {
-      const cmd = createDashboardCommand();
-      const portOption = cmd.options.find(o => o.long === '--port');
-
-      expect(portOption).toBeDefined();
-    });
-
-    it('should have --host option', () => {
-      const cmd = createDashboardCommand();
-      const hostOption = cmd.options.find(o => o.long === '--host');
-
-      expect(hostOption).toBeDefined();
-    });
-
-    it('should have --no-auto-open option', () => {
-      const cmd = createDashboardCommand();
-      const autoOpenOption = cmd.options.find(o => o.long === '--no-auto-open');
-
-      expect(autoOpenOption).toBeDefined();
-    });
-  });
-
-  describe('monitor command options', () => {
-    it('should support --mode option', () => {
-      const cmd = createMonitorCommands();
-      const modeOption = cmd.options.find(o => o.long === '--mode');
-
-      expect(modeOption).toBeDefined();
-    });
-
-    it('should support --retries option', () => {
-      const cmd = createMonitorCommands();
-      const retriesOption = cmd.options.find(o => o.long === '--retries');
-
-      expect(retriesOption).toBeDefined();
-    });
-
-    it('should support --timeout option', () => {
-      const cmd = createMonitorCommands();
-      const timeoutOption = cmd.options.find(o => o.long === '--timeout');
-
-      expect(timeoutOption).toBeDefined();
-    });
-
-    it('should support --docker option', () => {
-      const cmd = createMonitorCommands();
-      const dockerOption = cmd.options.find(o => o.long === '--docker');
-
-      expect(dockerOption).toBeDefined();
-    });
-  });
-});

package/cli/src/commands/__tests__/ollama.test.ts

@@ -1,529 +0,0 @@
-/**
- * CLI Ollama Command Tests
- *
- * Tests the Ollama CLI commands for AI-powered test generation.
- * All external dependencies (Ollama, filesystem) are mocked.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Command } from 'commander';
-import {
-  ollamaTestCommand,
-  ollamaListCommand,
-  ollamaPullCommand,
-  ollamaGenerateCommand,
-  ollamaConfigCommand,
-  createOllamaCommands
-} from '../ollama.js';
-
-// Mock qa360-core imports
-vi.mock('qa360-core', () => ({
-  checkOllamaSetup: vi.fn(),
-  OllamaProvider: vi.fn().mockImplementation(() => ({
-    isAvailable: vi.fn(),
-    listModels: vi.fn(),
-    generate: vi.fn()
-  })),
-  OllamaError: class extends Error {
-    constructor(message: string) {
-      super(message);
-      this.name = 'OllamaError';
-    }
-  }
-}));
-
-// Mock ora (spinner)
-vi.mock('ora', () => ({
-  default: vi.fn(() => ({
-    start: vi.fn(() => ({
-      succeed: vi.fn(),
-      fail: vi.fn(),
-      stop: vi.fn()
-    })),
-    succeed: vi.fn(),
-    fail: vi.fn()
-  }))
-}));
-
-// Mock console methods
-const mockConsole = {
-  log: vi.fn(),
-  error: vi.fn(),
-  warn: vi.fn(),
-  info: vi.fn()
-};
-
-describe('Ollama CLI Commands', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Mock console
-    global.console.log = mockConsole.log;
-    global.console.error = mockConsole.error;
-    global.console.warn = mockConsole.warn;
-    global.console.info = mockConsole.info;
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  // ============================================================
-  // ollamaTestCommand Tests
-  // ============================================================
-  describe('ollamaTestCommand', () => {
-    it('should be exported as function', () => {
-      expect(typeof ollamaTestCommand).toBe('function');
-    });
-
-    it('should accept options object', async () => {
-      const { checkOllamaSetup } = await import('../core/index.js');
-      vi.mocked(checkOllamaSetup).mockResolvedValue({
-        available: true,
-        modelInstalled: true,
-        models: ['deepseek-coder:latest']
-      });
-
-      // Should not throw
-      await ollamaTestCommand({ model: 'deepseek-coder' });
-      expect(checkOllamaSetup).toHaveBeenCalledWith('deepseek-coder');
-    });
-
-    it('should use default model when none provided', async () => {
-      const { checkOllamaSetup } = await import('../core/index.js');
-      vi.mocked(checkOllamaSetup).mockResolvedValue({
-        available: true,
-        modelInstalled: true,
-        models: ['deepseek-coder:latest']
-      });
-
-      await ollamaTestCommand({});
-      expect(checkOllamaSetup).toHaveBeenCalledWith('deepseek-coder');
-    });
-
-    it('should handle Ollama not available', async () => {
-      const { checkOllamaSetup } = await import('../core/index.js');
-      vi.mocked(checkOllamaSetup).mockResolvedValue({
-        available: false,
-        modelInstalled: false,
-        models: []
-      });
-
-      await ollamaTestCommand();
-      // The command shows multiple lines of helpful output when Ollama is not available
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('not running'));
-    });
-
-    it('should handle no models found', async () => {
-      const { checkOllamaSetup } = await import('../core/index.js');
-      vi.mocked(checkOllamaSetup).mockResolvedValue({
-        available: true,
-        modelInstalled: false,
-        models: []
-      });
-
-      await ollamaTestCommand();
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('No models found'));
-    });
-
-    it('should display installed models', async () => {
-      const { checkOllamaSetup } = await import('../core/index.js');
-      vi.mocked(checkOllamaSetup).mockResolvedValue({
-        available: true,
-        modelInstalled: true,
-        models: ['deepseek-coder:latest', 'llama3.2:latest']
-      });
-
-      await ollamaTestCommand({ model: 'deepseek-coder' });
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('model'));
-    });
-  });
-
-  // ============================================================
-  // ollamaListCommand Tests
-  // ============================================================
-  describe('ollamaListCommand', () => {
-    it('should be exported as function', () => {
-      expect(typeof ollamaListCommand).toBe('function');
-    });
-
-    it('should list available models', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        listModels: vi.fn().mockResolvedValue([
-          { name: 'deepseek-coder:latest', size: 7000000000, modifiedAt: '2024-01-15T10:00:00Z' },
-          { name: 'llama3.2:latest', size: 2000000000, modifiedAt: '2024-01-10T10:00:00Z' }
-        ])
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaListCommand();
-      expect(mockProvider.listModels).toHaveBeenCalled();
-    });
-
-    it('should handle empty model list', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        listModels: vi.fn().mockResolvedValue([])
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaListCommand();
-      expect(mockProvider.listModels).toHaveBeenCalled();
-    });
-
-    it('should handle provider errors', async () => {
-      const { OllamaProvider, OllamaError } = await import('../core/index.js');
-      const mockProvider = {
-        listModels: vi.fn().mockRejectedValue(new OllamaError('Connection failed'))
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaListCommand();
-      expect(mockConsole.error).toHaveBeenCalled();
-    });
-  });
-
-  // ============================================================
-  // ollamaPullCommand Tests
-  // ============================================================
-  describe('ollamaPullCommand', () => {
-    it('should be exported as function', () => {
-      expect(typeof ollamaPullCommand).toBe('function');
-    });
-
-    it('should accept model name', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        listModels: vi.fn().mockResolvedValue([])
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaPullCommand('deepseek-coder');
-      expect(mockProvider.listModels).toHaveBeenCalled();
-    });
-
-    it('should handle already installed model', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        listModels: vi.fn().mockResolvedValue([
-          { name: 'deepseek-coder', size: 7000000000 }
-        ])
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaPullCommand('deepseek-coder');
-      // The command shows "Pulling model..." header, then checks if installed
-      // Since model name matches, it should show "already installed"
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('Pulling model'));
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('already installed'));
-    });
-
-    it('should show instructions for new model', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        listModels: vi.fn().mockResolvedValue([])
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaPullCommand('new-model');
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('ollama pull'));
-    });
-  });
-
-  // ============================================================
-  // ollamaGenerateCommand Tests
-  // ============================================================
-  describe('ollamaGenerateCommand', () => {
-    it('should be exported as function', () => {
-      expect(typeof ollamaGenerateCommand).toBe('function');
-    });
-
-    it('should generate tests from prompt', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        isAvailable: vi.fn().mockResolvedValue(true),
-        generate: vi.fn().mockResolvedValue({
-          content: 'function test() { return true; }',
-          usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
-          model: 'deepseek-coder:latest'
-        })
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaGenerateCommand('Write a test function', {});
-      expect(mockProvider.isAvailable).toHaveBeenCalled();
-      expect(mockProvider.generate).toHaveBeenCalled();
-    });
-
-    it('should use default model', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        isAvailable: vi.fn().mockResolvedValue(true),
-        generate: vi.fn().mockResolvedValue({
-          content: 'test code',
-          usage: { promptTokens: 5, completionTokens: 10, totalTokens: 15 },
-          model: 'deepseek-coder:latest'
-        })
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaGenerateCommand('Test prompt', {});
-      // Should use deepseek-coder by default
-      expect(mockProvider.generate).toHaveBeenCalledWith(
-        expect.objectContaining({
-          prompt: 'Test prompt'
-        })
-      );
-    });
-
-    it('should use custom model from options', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        isAvailable: vi.fn().mockResolvedValue(true),
-        generate: vi.fn().mockResolvedValue({
-          content: 'test code',
-          usage: { promptTokens: 5, completionTokens: 10, totalTokens: 15 },
-          model: 'llama3.2:latest'
-        })
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaGenerateCommand('Test', { model: 'llama3.2' });
-      expect(mockProvider.generate).toHaveBeenCalled();
-    });
-
-    it('should handle Ollama not available', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        isAvailable: vi.fn().mockResolvedValue(false),
-        generate: vi.fn()
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaGenerateCommand('Test', {});
-      expect(mockProvider.generate).not.toHaveBeenCalled();
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('not running'));
-    });
-
-    it('should output JSON when requested', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        isAvailable: vi.fn().mockResolvedValue(true),
-        generate: vi.fn().mockResolvedValue({
-          content: 'test code',
-          usage: { promptTokens: 5, completionTokens: 10, totalTokens: 15 },
-          model: 'deepseek-coder:latest'
-        })
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaGenerateCommand('Test', { json: true });
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining('"content"')
-      );
-    });
-
-    it('should support different test types', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        isAvailable: vi.fn().mockResolvedValue(true),
-        generate: vi.fn().mockResolvedValue({
-          content: 'test code',
-          usage: { promptTokens: 5, completionTokens: 10, totalTokens: 15 },
-          model: 'deepseek-coder:latest'
-        })
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaGenerateCommand('Test', { type: 'ui' });
-      expect(mockProvider.generate).toHaveBeenCalledWith(
-        expect.objectContaining({
-          systemPrompt: expect.stringContaining('UI/E2E')
-        })
-      );
-    });
-  });
-
-  // ============================================================
-  // ollamaConfigCommand Tests
-  // ============================================================
-  describe('ollamaConfigCommand', () => {
-    it('should be exported as function', () => {
-      expect(typeof ollamaConfigCommand).toBe('function');
-    });
-
-    it('should accept empty options', async () => {
-      await ollamaConfigCommand({});
-      expect(mockConsole.log).toHaveBeenCalled();
-    });
-
-    it('should accept set-url option', async () => {
-      await ollamaConfigCommand({ setUrl: 'http://localhost:11434' });
-      expect(mockConsole.log).toHaveBeenCalled();
-    });
-
-    it('should accept set-model option', async () => {
-      await ollamaConfigCommand({ setModel: 'llama3.2' });
-      expect(mockConsole.log).toHaveBeenCalled();
-    });
-
-    it('should display configuration info', async () => {
-      await ollamaConfigCommand({});
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('Configuration'));
-    });
-  });
-
-  // ============================================================
-  // createOllamaCommands Tests
-  // ============================================================
-  describe('createOllamaCommands', () => {
-    it('should create a Command instance', () => {
-      const cmd = createOllamaCommands();
-      expect(cmd).toBeInstanceOf(Command);
-    });
-
-    it('should have correct name', () => {
-      const cmd = createOllamaCommands();
-      expect(cmd.name()).toBe('ollama');
-    });
-
-    it('should have description', () => {
-      const cmd = createOllamaCommands();
-      expect(cmd.description()).toContain('Ollama');
-    });
-
-    it('should register all subcommands', () => {
-      const cmd = createOllamaCommands();
-      const commands = cmd.commands.map(c => c.name());
-
-      expect(commands).toContain('test');
-      expect(commands).toContain('list');
-      expect(commands).toContain('pull');
-      expect(commands).toContain('generate');
-      expect(commands).toContain('config');
-    });
-  });
-
-  // ============================================================
-  // Integration Scenarios
-  // ============================================================
-  describe('integration scenarios', () => {
-    it('should handle complete test workflow', async () => {
-      const { checkOllamaSetup, OllamaProvider } = await import('../core/index.js');
-
-      // Setup: Ollama available with models
-      vi.mocked(checkOllamaSetup).mockResolvedValue({
-        available: true,
-        modelInstalled: true,
-        models: ['deepseek-coder:latest']
-      });
-
-      // List models
-      const mockProvider = {
-        listModels: vi.fn().mockResolvedValue([
-          { name: 'deepseek-coder:latest', size: 7000000000 }
-        ]),
-        isAvailable: vi.fn().mockResolvedValue(true),
-        generate: vi.fn().mockResolvedValue({
-          content: 'test code',
-          usage: { promptTokens: 5, completionTokens: 10, totalTokens: 15 },
-          model: 'deepseek-coder:latest'
-        })
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      // Execute workflow
-      await ollamaTestCommand({ model: 'deepseek-coder' });
-      await ollamaListCommand();
-      await ollamaGenerateCommand('Write test', {});
-
-      expect(checkOllamaSetup).toHaveBeenCalled();
-      expect(mockProvider.listModels).toHaveBeenCalled();
-      expect(mockProvider.generate).toHaveBeenCalled();
-    });
-
-    it('should handle error scenarios gracefully', async () => {
-      const { OllamaProvider, OllamaError } = await import('../core/index.js');
-
-      const mockProvider = {
-        listModels: vi.fn().mockRejectedValue(new OllamaError('Connection failed')),
-        isAvailable: vi.fn().mockResolvedValue(false)
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      // Should not throw, but handle errors
-      await ollamaListCommand();
-      expect(mockConsole.error).toHaveBeenCalled();
-
-      await ollamaGenerateCommand('Test', {});
-      expect(mockConsole.log).toHaveBeenCalledWith(expect.stringContaining('not running'));
-    });
-  });
-
-  // ============================================================
-  // Edge Cases
-  // ============================================================
-  describe('edge cases', () => {
-    it('should handle empty prompt', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const mockProvider = {
-        isAvailable: vi.fn().mockResolvedValue(true),
-        generate: vi.fn().mockResolvedValue({
-          content: '',
-          usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-          model: 'deepseek-coder:latest'
-        })
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaGenerateCommand('', {});
-      expect(mockProvider.generate).toHaveBeenCalled();
-    });
-
-    it('should handle very long prompts', async () => {
-      const { OllamaProvider } = await import('../core/index.js');
-      const longPrompt = 'a'.repeat(10000);
-
-      const mockProvider = {
-        isAvailable: vi.fn().mockResolvedValue(true),
-        generate: vi.fn().mockResolvedValue({
-          content: 'test',
-          usage: { promptTokens: 8000, completionTokens: 100, totalTokens: 8100 },
-          model: 'deepseek-coder:latest'
-        })
-      };
-
-      vi.mocked(OllamaProvider).mockImplementation(() => mockProvider as any);
-
-      await ollamaGenerateCommand(longPrompt, {});
-      expect(mockProvider.generate).toHaveBeenCalled();
-    });
-
-    it('should handle special characters in model names', async () => {
-      const { checkOllamaSetup } = await import('../core/index.js');
-      vi.mocked(checkOllamaSetup).mockResolvedValue({
-        available: true,
-        modelInstalled: false,
-        models: []
-      });
-
-      await ollamaTestCommand({ model: 'model-with-special_chars.123' });
-      expect(checkOllamaSetup).toHaveBeenCalledWith('model-with-special_chars.123');
-    });
-  });
-});