@sparkleideas/testing 3.0.0-alpha.10

package/src/v2-compat/cli-compat.test.ts

@@ -0,0 +1,484 @@
+/**
+ * V2 CLI Compatibility Tests
+ *
+ * Tests all 25 V2 CLI commands work via compatibility layer or native V3 equivalents.
+ * Verifies flag compatibility and output format compatibility.
+ *
+ * @module v3/testing/v2-compat/cli-compat.test
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi, type Mock } from 'vitest';
+import {
+  V2CompatibilityValidator,
+  V2_CLI_COMMANDS,
+  type V2CLICommand,
+  type ValidationResult,
+} from './compatibility-validator.js';
+
+/**
+ * Mock CLI executor for testing
+ */
+interface MockCLIExecutor {
+  execute: Mock<(command: string, args: string[]) => Promise<{ success: boolean; output: string; exitCode: number }>>;
+  getCommands: Mock<() => string[]>;
+  parseOutput: Mock<(output: string) => Record<string, unknown>>;
+}
+
+/**
+ * Create mock CLI executor
+ */
+function createMockCLIExecutor(): MockCLIExecutor {
+  const v3Commands = [
+    'init', 'start', 'stop', 'status', 'config',
+    'agent spawn', 'agent list', 'agent terminate', 'agent status',
+    'swarm init', 'swarm status', 'swarm scale',
+    'memory list', 'memory search', 'memory clear',
+    'hooks pre-edit', 'hooks post-edit', 'hooks pre-command', 'hooks post-command',
+    'hooks route', 'hooks pretrain', 'hooks metrics',
+  ];
+
+  return {
+    execute: vi.fn().mockImplementation(async (command: string, args: string[]) => {
+      // Simulate V3 CLI behavior with V2 command translation
+      const commandTranslation: Record<string, string> = {
+        'hive-mind init': 'swarm init',
+        'hive-mind status': 'swarm status',
+        'hive-mind spawn': 'agent spawn',
+        'neural init': 'hooks pretrain',
+        'goal init': 'hooks pretrain',
+        'memory query': 'memory search',
+        'agent info': 'agent status',
+      };
+
+      const translatedCommand = commandTranslation[command] || command;
+      const isSupported = v3Commands.some(c =>
+        c === translatedCommand || translatedCommand.startsWith(c.split(' ')[0])
+      );
+
+      if (!isSupported) {
+        return {
+          success: false,
+          output: `Error: Command "${command}" not found`,
+          exitCode: 1,
+        };
+      }
+
+      // Simulate successful output
+      const outputMap: Record<string, string> = {
+        'status': JSON.stringify({ status: 'running', agents: 0, memory: 'healthy' }),
+        'agent list': JSON.stringify([]),
+        'swarm status': JSON.stringify({ topology: 'hierarchical-mesh', agents: 0 }),
+        'memory list': JSON.stringify([]),
+        'hooks metrics': JSON.stringify({ patterns: 0, successRate: 0 }),
+      };
+
+      return {
+        success: true,
+        output: outputMap[translatedCommand] || 'OK',
+        exitCode: 0,
+      };
+    }),
+    getCommands: vi.fn().mockReturnValue(v3Commands),
+    parseOutput: vi.fn().mockImplementation((output: string) => {
+      try {
+        return JSON.parse(output);
+      } catch {
+        return { raw: output };
+      }
+    }),
+  };
+}
+
+describe('V2 CLI Compatibility', () => {
+  let validator: V2CompatibilityValidator;
+  let mockCLI: MockCLIExecutor;
+
+  beforeEach(() => {
+    mockCLI = createMockCLIExecutor();
+    validator = new V2CompatibilityValidator({
+      verbose: false,
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Core Commands', () => {
+    const coreCommands = V2_CLI_COMMANDS.filter(c =>
+      ['init', 'start', 'stop', 'status', 'config'].includes(c.name)
+    );
+
+    it.each(coreCommands)('should support V2 command: $name', async (cmd: V2CLICommand) => {
+      const result = await mockCLI.execute(cmd.name, []);
+
+      expect(result.success).toBe(true);
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should support init command with --force flag', async () => {
+      const result = await mockCLI.execute('init', ['--force']);
+
+      expect(result.success).toBe(true);
+      expect(mockCLI.execute).toHaveBeenCalledWith('init', ['--force']);
+    });
+
+    it('should support init command with --template flag', async () => {
+      const result = await mockCLI.execute('init', ['--template', 'minimal']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support status command with --json flag', async () => {
+      const result = await mockCLI.execute('status', ['--json']);
+
+      expect(result.success).toBe(true);
+      const parsed = mockCLI.parseOutput(result.output);
+      expect(parsed).toHaveProperty('status');
+    });
+
+    it('should support config command with --list flag', async () => {
+      const result = await mockCLI.execute('config', ['--list']);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Agent Commands', () => {
+    const agentCommands = V2_CLI_COMMANDS.filter(c => c.name.startsWith('agent'));
+
+    it.each(agentCommands)('should support V2 command: $name', async (cmd: V2CLICommand) => {
+      const result = await mockCLI.execute(cmd.name, []);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support agent spawn with --type flag', async () => {
+      const result = await mockCLI.execute('agent spawn', ['--type', 'coder']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support agent spawn with --id flag', async () => {
+      const result = await mockCLI.execute('agent spawn', ['--id', 'my-agent']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support agent list with --status filter', async () => {
+      const result = await mockCLI.execute('agent list', ['--status', 'active']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support agent terminate with --force flag', async () => {
+      const result = await mockCLI.execute('agent terminate', ['--force', 'agent-1']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should translate agent info to agent status', async () => {
+      const result = await mockCLI.execute('agent info', ['agent-1']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support alias "a spawn" for "agent spawn"', async () => {
+      // Aliases should be handled by CLI framework
+      const result = await mockCLI.execute('agent spawn', ['--type', 'coder']);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Swarm Commands', () => {
+    const swarmCommands = V2_CLI_COMMANDS.filter(c => c.name.startsWith('swarm'));
+
+    it.each(swarmCommands)('should support V2 command: $name', async (cmd: V2CLICommand) => {
+      const result = await mockCLI.execute(cmd.name, []);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support swarm init with --topology flag', async () => {
+      const result = await mockCLI.execute('swarm init', ['--topology', 'hierarchical-mesh']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support swarm init with --max-agents flag', async () => {
+      const result = await mockCLI.execute('swarm init', ['--max-agents', '15']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support swarm status with --detailed flag', async () => {
+      const result = await mockCLI.execute('swarm status', ['--detailed']);
+
+      expect(result.success).toBe(true);
+      const parsed = mockCLI.parseOutput(result.output);
+      expect(parsed).toHaveProperty('topology');
+    });
+
+    it('should support swarm scale with --up flag', async () => {
+      const result = await mockCLI.execute('swarm scale', ['--up', '3']);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Memory Commands', () => {
+    const memoryCommands = V2_CLI_COMMANDS.filter(c => c.name.startsWith('memory'));
+
+    it.each(memoryCommands)('should support V2 command: $name', async (cmd: V2CLICommand) => {
+      const result = await mockCLI.execute(cmd.name, []);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support memory list with --type filter', async () => {
+      const result = await mockCLI.execute('memory list', ['--type', 'pattern']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should translate memory query to memory search', async () => {
+      const result = await mockCLI.execute('memory query', ['--search', 'test']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support memory clear with --force flag', async () => {
+      const result = await mockCLI.execute('memory clear', ['--force']);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Hooks Commands', () => {
+    const hooksCommands = V2_CLI_COMMANDS.filter(c => c.name.startsWith('hooks'));
+
+    it.each(hooksCommands)('should support V2 command: $name', async (cmd: V2CLICommand) => {
+      const result = await mockCLI.execute(cmd.name, []);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support hooks pre-edit with file path', async () => {
+      const result = await mockCLI.execute('hooks pre-edit', ['--file', '/path/to/file.ts']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support hooks post-edit with success flag', async () => {
+      const result = await mockCLI.execute('hooks post-edit', ['--file', '/path/to/file.ts', '--success', 'true']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support hooks route with task description', async () => {
+      const result = await mockCLI.execute('hooks route', ['--task', 'implement feature']);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should support hooks metrics with --dashboard flag', async () => {
+      const result = await mockCLI.execute('hooks metrics', ['--dashboard']);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Deprecated Commands', () => {
+    const deprecatedCommands = V2_CLI_COMMANDS.filter(c => c.deprecated);
+
+    it.each(deprecatedCommands)('should support deprecated command: $name (with warning)', async (cmd: V2CLICommand) => {
+      const result = await mockCLI.execute(cmd.name, []);
+
+      // Deprecated commands should still work
+      expect(result.success).toBe(true);
+    });
+
+    it('should translate hive-mind init to swarm init', async () => {
+      const result = await mockCLI.execute('hive-mind init', []);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should translate neural init to hooks pretrain', async () => {
+      const result = await mockCLI.execute('neural init', []);
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should translate goal init to hooks pretrain', async () => {
+      const result = await mockCLI.execute('goal init', []);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Output Format Compatibility', () => {
+    it('should return JSON output for status command', async () => {
+      const result = await mockCLI.execute('status', ['--json']);
+
+      expect(result.success).toBe(true);
+      const parsed = mockCLI.parseOutput(result.output);
+      expect(typeof parsed).toBe('object');
+    });
+
+    it('should return agent list as array', async () => {
+      const result = await mockCLI.execute('agent list', []);
+
+      expect(result.success).toBe(true);
+      const parsed = mockCLI.parseOutput(result.output);
+      expect(Array.isArray(parsed)).toBe(true);
+    });
+
+    it('should return swarm status as object', async () => {
+      const result = await mockCLI.execute('swarm status', []);
+
+      expect(result.success).toBe(true);
+      const parsed = mockCLI.parseOutput(result.output);
+      expect(parsed).toHaveProperty('topology');
+    });
+
+    it('should return memory list as array', async () => {
+      const result = await mockCLI.execute('memory list', []);
+
+      expect(result.success).toBe(true);
+      const parsed = mockCLI.parseOutput(result.output);
+      expect(Array.isArray(parsed)).toBe(true);
+    });
+
+    it('should return hooks metrics as object', async () => {
+      const result = await mockCLI.execute('hooks metrics', []);
+
+      expect(result.success).toBe(true);
+      const parsed = mockCLI.parseOutput(result.output);
+      expect(parsed).toHaveProperty('patterns');
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should return error for unknown command', async () => {
+      const result = await mockCLI.execute('unknown-command', []);
+
+      expect(result.success).toBe(false);
+      expect(result.exitCode).toBe(1);
+      expect(result.output).toContain('not found');
+    });
+
+    it('should handle missing required arguments gracefully', async () => {
+      // Most commands should work without arguments for listing operations
+      const result = await mockCLI.execute('agent list', []);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('Full CLI Validation', () => {
+    it('should pass full CLI validation', async () => {
+      const result: ValidationResult = await validator.validateCLI();
+
+      expect(result.category).toBe('cli');
+      expect(result.totalChecks).toBeGreaterThan(0);
+      expect(result.passedChecks).toBeGreaterThan(0);
+    });
+
+    it('should detect all 25 V2 CLI commands', async () => {
+      const result = await validator.validateCLI();
+      const commandChecks = result.checks.filter(c => c.name.startsWith('CLI:'));
+
+      // Should have checks for all 25 commands
+      expect(commandChecks.length).toBeGreaterThanOrEqual(25);
+    });
+
+    it('should identify deprecated commands', async () => {
+      const result = await validator.validateCLI();
+      const deprecatedChecks = result.checks.filter(c =>
+        c.name.includes('hive-mind') || c.name.includes('neural') || c.name.includes('goal')
+      );
+
+      expect(deprecatedChecks.length).toBeGreaterThan(0);
+    });
+
+    it('should verify flag compatibility', async () => {
+      const result = await validator.validateCLI();
+      const flagChecks = result.checks.filter(c => c.name.includes('Flag:'));
+
+      expect(flagChecks.length).toBeGreaterThan(0);
+    });
+
+    it('should report breaking changes for unsupported commands', async () => {
+      const result = await validator.validateCLI();
+
+      // All non-deprecated commands should be supported
+      const breakingNonDeprecated = result.checks.filter(c =>
+        c.breaking && !c.name.includes('deprecated')
+      );
+
+      // Expect minimal breaking changes in supported commands
+      expect(breakingNonDeprecated.length).toBeLessThan(5);
+    });
+
+    it('should provide migration paths', async () => {
+      const result = await validator.validateCLI();
+      const withMigration = result.checks.filter(c => c.migrationPath);
+
+      expect(withMigration.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Alias Compatibility', () => {
+    it('should check all command aliases', async () => {
+      const result = await validator.validateCLI();
+      const aliasChecks = result.checks.filter(c => c.name.includes('Alias:'));
+
+      expect(aliasChecks.length).toBeGreaterThan(0);
+    });
+
+    it('should verify common aliases work', async () => {
+      const commonAliases = ['i', 's', 'st', 'c', 'a spawn', 'a ls'];
+
+      for (const alias of commonAliases) {
+        // Aliases should map to valid commands
+        const aliasCmd = V2_CLI_COMMANDS.find(c => c.aliases.includes(alias));
+        expect(aliasCmd).toBeDefined();
+      }
+    });
+  });
+});
+
+describe('CLI Command Coverage', () => {
+  it('should test all 25 V2 CLI commands', () => {
+    expect(V2_CLI_COMMANDS.length).toBe(25);
+  });
+
+  it('should have V3 equivalents for all non-deprecated commands', () => {
+    const nonDeprecated = V2_CLI_COMMANDS.filter(c => !c.deprecated);
+
+    for (const cmd of nonDeprecated) {
+      expect(cmd.v3Equivalent).toBeDefined();
+      expect(cmd.v3Equivalent).not.toBe('');
+    }
+  });
+
+  it('should categorize commands correctly', () => {
+    const categories = {
+      core: ['init', 'start', 'stop', 'status', 'config'],
+      agent: V2_CLI_COMMANDS.filter(c => c.name.startsWith('agent')).map(c => c.name),
+      swarm: V2_CLI_COMMANDS.filter(c => c.name.startsWith('swarm')).map(c => c.name),
+      memory: V2_CLI_COMMANDS.filter(c => c.name.startsWith('memory')).map(c => c.name),
+      hooks: V2_CLI_COMMANDS.filter(c => c.name.startsWith('hooks')).map(c => c.name),
+      deprecated: V2_CLI_COMMANDS.filter(c => c.deprecated).map(c => c.name),
+    };
+
+    expect(categories.core.length).toBe(5);
+    expect(categories.agent.length).toBe(4);
+    expect(categories.swarm.length).toBe(3);
+    expect(categories.memory.length).toBe(3);
+    expect(categories.hooks.length).toBe(7);
+    expect(categories.deprecated.length).toBe(3);
+  });
+});