@sparkleideas/testing 3.0.0-alpha.7

package/src/helpers/swarm-instance.ts

@@ -0,0 +1,326 @@
+/**
+ * V3 Claude-Flow Swarm Test Instance
+ *
+ * Creates isolated swarm instances for testing
+ * Supports 15-agent V3 swarm topology testing
+ */
+import { vi, type Mock } from 'vitest';
+import { createMock, type MockedInterface, InteractionRecorder } from './create-mock.js';
+
+/**
+ * Agent types for V3 15-agent swarm
+ */
+export type V3AgentType =
+  | 'queen-coordinator'
+  | 'security-architect'
+  | 'security-auditor'
+  | 'memory-specialist'
+  | 'swarm-specialist'
+  | 'integration-architect'
+  | 'performance-engineer'
+  | 'core-architect'
+  | 'test-architect'
+  | 'project-coordinator'
+  | 'coder'
+  | 'reviewer'
+  | 'tester'
+  | 'planner'
+  | 'researcher';
+
+/**
+ * Swarm topology types
+ */
+export type SwarmTopology = 'hierarchical' | 'mesh' | 'adaptive' | 'hierarchical-mesh';
+
+/**
+ * Agent interface for swarm testing
+ */
+export interface SwarmAgent {
+  id: string;
+  type: V3AgentType;
+  status: 'idle' | 'busy' | 'terminated';
+  capabilities: string[];
+  execute(task: SwarmTask): Promise<SwarmTaskResult>;
+  communicate(message: SwarmMessage): Promise<void>;
+}
+
+/**
+ * Swarm message interface
+ */
+export interface SwarmMessage {
+  from: string;
+  to: string | 'broadcast';
+  type: 'task' | 'result' | 'status' | 'coordination';
+  payload: unknown;
+  timestamp: Date;
+}
+
+/**
+ * Swarm task interface
+ */
+export interface SwarmTask {
+  id: string;
+  type: string;
+  payload: unknown;
+  priority: number;
+  assignedTo?: string;
+}
+
+/**
+ * Swarm task result
+ */
+export interface SwarmTaskResult {
+  taskId: string;
+  agentId: string;
+  success: boolean;
+  output?: unknown;
+  error?: Error;
+  duration: number;
+}
+
+/**
+ * Swarm coordination result
+ */
+export interface SwarmCoordinationResult {
+  success: boolean;
+  completedTasks: number;
+  failedTasks: number;
+  totalDuration: number;
+  agentMetrics: Map<string, AgentMetrics>;
+}
+
+/**
+ * Agent metrics
+ */
+export interface AgentMetrics {
+  tasksCompleted: number;
+  tasksFailed: number;
+  averageTaskDuration: number;
+  totalDuration: number;
+}
+
+/**
+ * Create a test swarm instance with mocked agents
+ */
+export function createSwarmTestInstance(config?: {
+  topology?: SwarmTopology;
+  agentTypes?: V3AgentType[];
+}): SwarmTestInstance {
+  const topology = config?.topology ?? 'hierarchical-mesh';
+  const agentTypes = config?.agentTypes ?? [
+    'queen-coordinator',
+    'security-architect',
+    'security-auditor',
+    'memory-specialist',
+    'swarm-specialist',
+  ];
+
+  return new SwarmTestInstance(topology, agentTypes);
+}
+
+/**
+ * Swarm test instance class
+ */
+export class SwarmTestInstance {
+  private agents: Map<string, MockedInterface<SwarmAgent>> = new Map();
+  private messages: SwarmMessage[] = [];
+  private taskResults: SwarmTaskResult[] = [];
+  private interactionRecorder: InteractionRecorder;
+  private isInitialized = false;
+
+  constructor(
+    public readonly topology: SwarmTopology,
+    private readonly agentTypes: V3AgentType[]
+  ) {
+    this.interactionRecorder = new InteractionRecorder();
+    this.initializeAgents();
+  }
+
+  private initializeAgents(): void {
+    for (const type of this.agentTypes) {
+      const id = `${type}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+      const agent = this.createMockAgent(id, type);
+      this.agents.set(id, agent);
+      this.interactionRecorder.track(id, agent);
+    }
+  }
+
+  private createMockAgent(id: string, type: V3AgentType): MockedInterface<SwarmAgent> {
+    const mock = createMock<SwarmAgent>();
+
+    // Set default properties
+    Object.defineProperty(mock, 'id', { value: id, writable: false });
+    Object.defineProperty(mock, 'type', { value: type, writable: false });
+    Object.defineProperty(mock, 'status', { value: 'idle', writable: true });
+    Object.defineProperty(mock, 'capabilities', {
+      value: this.getCapabilitiesForType(type),
+      writable: false
+    });
+
+    // Configure default behavior
+    mock.execute.mockImplementation(async (task: SwarmTask) => {
+      const result: SwarmTaskResult = {
+        taskId: task.id,
+        agentId: id,
+        success: true,
+        duration: Math.random() * 100 + 10,
+      };
+      this.taskResults.push(result);
+      return result;
+    });
+
+    mock.communicate.mockImplementation(async (message: SwarmMessage) => {
+      this.messages.push(message);
+    });
+
+    return mock;
+  }
+
+  private getCapabilitiesForType(type: V3AgentType): string[] {
+    const capabilities: Record<V3AgentType, string[]> = {
+      'queen-coordinator': ['orchestration', 'task-distribution', 'agent-management'],
+      'security-architect': ['security-design', 'threat-modeling', 'security-review'],
+      'security-auditor': ['cve-detection', 'vulnerability-scanning', 'security-testing'],
+      'memory-specialist': ['memory-optimization', 'agentdb-integration', 'caching'],
+      'swarm-specialist': ['coordination', 'consensus', 'communication'],
+      'integration-architect': ['api-design', 'system-integration', 'compatibility'],
+      'performance-engineer': ['optimization', 'benchmarking', 'profiling'],
+      'core-architect': ['ddd-design', 'architecture', 'domain-modeling'],
+      'test-architect': ['tdd', 'test-design', 'quality-assurance'],
+      'project-coordinator': ['project-management', 'scheduling', 'reporting'],
+      'coder': ['coding', 'implementation', 'debugging'],
+      'reviewer': ['code-review', 'quality-check', 'suggestions'],
+      'tester': ['testing', 'test-execution', 'coverage'],
+      'planner': ['planning', 'estimation', 'roadmap'],
+      'researcher': ['research', 'analysis', 'documentation'],
+    };
+    return capabilities[type];
+  }
+
+  /**
+   * Initialize the swarm
+   */
+  async initialize(): Promise<void> {
+    this.isInitialized = true;
+    // Simulate initialization delay
+    await new Promise(resolve => setTimeout(resolve, 1));
+  }
+
+  /**
+   * Get an agent by type
+   */
+  getAgent(type: V3AgentType): MockedInterface<SwarmAgent> | undefined {
+    for (const [_, agent] of this.agents) {
+      if ((agent as unknown as SwarmAgent).type === type) {
+        return agent;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Get all agents
+   */
+  getAllAgents(): MockedInterface<SwarmAgent>[] {
+    return Array.from(this.agents.values());
+  }
+
+  /**
+   * Get agent by ID
+   */
+  getAgentById(id: string): MockedInterface<SwarmAgent> | undefined {
+    return this.agents.get(id);
+  }
+
+  /**
+   * Get all messages
+   */
+  getMessages(): SwarmMessage[] {
+    return [...this.messages];
+  }
+
+  /**
+   * Get task results
+   */
+  getTaskResults(): SwarmTaskResult[] {
+    return [...this.taskResults];
+  }
+
+  /**
+   * Get interaction order for behavior verification
+   */
+  getInteractionOrder(): string[] {
+    return this.interactionRecorder.getInteractionOrder();
+  }
+
+  /**
+   * Get all interactions
+   */
+  getInteractions(): Array<{ name: string; method: string; args: unknown[] }> {
+    return this.interactionRecorder.getInteractions();
+  }
+
+  /**
+   * Coordinate a task across agents
+   */
+  async coordinate(task: SwarmTask): Promise<SwarmCoordinationResult> {
+    if (!this.isInitialized) {
+      throw new Error('Swarm not initialized');
+    }
+
+    const startTime = Date.now();
+    const results: SwarmTaskResult[] = [];
+
+    // Simulate coordination based on topology
+    const queen = this.getAgent('queen-coordinator');
+    if (queen && this.topology.includes('hierarchical')) {
+      await queen.communicate({
+        from: 'coordinator',
+        to: 'broadcast',
+        type: 'task',
+        payload: task,
+        timestamp: new Date(),
+      });
+    }
+
+    // Execute task on appropriate agent
+    for (const agent of this.agents.values()) {
+      const result = await agent.execute(task);
+      results.push(result);
+    }
+
+    const completedTasks = results.filter(r => r.success).length;
+    const failedTasks = results.filter(r => !r.success).length;
+
+    return {
+      success: failedTasks === 0,
+      completedTasks,
+      failedTasks,
+      totalDuration: Date.now() - startTime,
+      agentMetrics: new Map(),
+    };
+  }
+
+  /**
+   * Shutdown the swarm
+   */
+  async shutdown(): Promise<void> {
+    for (const agent of this.agents.values()) {
+      Object.defineProperty(agent, 'status', { value: 'terminated', writable: true });
+    }
+    this.isInitialized = false;
+  }
+
+  /**
+   * Reset the swarm state
+   */
+  reset(): void {
+    this.messages = [];
+    this.taskResults = [];
+    this.interactionRecorder.clear();
+
+    for (const agent of this.agents.values()) {
+      vi.clearAllMocks();
+    }
+  }
+}

package/src/helpers/test-application.ts

@@ -0,0 +1,310 @@
+/**
+ * V3 Claude-Flow Test Application Factory
+ *
+ * Creates isolated test instances of the application
+ * Following London School principles for dependency injection
+ */
+import { vi, type Mock } from 'vitest';
+import { createMock, type MockedInterface } from './create-mock.js';
+
+/**
+ * Core domain interfaces for testing
+ */
+export interface IEventBus {
+  publish(event: DomainEvent): Promise<void>;
+  subscribe(eventType: string, handler: EventHandler): void;
+  unsubscribe(eventType: string, handler: EventHandler): void;
+}
+
+export interface ITaskManager {
+  create(task: TaskDefinition): Promise<Task>;
+  execute(taskId: string): Promise<TaskResult>;
+  cancel(taskId: string): Promise<void>;
+  getStatus(taskId: string): Promise<TaskStatus>;
+}
+
+export interface IAgentLifecycle {
+  spawn(config: AgentConfig): Promise<Agent>;
+  terminate(agentId: string): Promise<void>;
+  getAgent(agentId: string): Promise<Agent | null>;
+  listAgents(): Promise<Agent[]>;
+}
+
+export interface IMemoryService {
+  store(key: string, value: unknown, metadata?: MemoryMetadata): Promise<void>;
+  retrieve(key: string): Promise<unknown>;
+  search(query: VectorQuery): Promise<SearchResult[]>;
+  delete(key: string): Promise<void>;
+}
+
+export interface ISecurityService {
+  validatePath(path: string): boolean;
+  hashPassword(password: string): Promise<string>;
+  verifyPassword(password: string, hash: string): Promise<boolean>;
+  executeSecurely(command: string, options?: ExecuteOptions): Promise<ExecuteResult>;
+}
+
+export interface ISwarmCoordinator {
+  initialize(config: SwarmConfig): Promise<void>;
+  coordinate(agents: Agent[], task: Task): Promise<CoordinationResult>;
+  shutdown(): Promise<void>;
+}
+
+/**
+ * Type definitions for domain objects
+ */
+export interface DomainEvent {
+  type: string;
+  payload: unknown;
+  timestamp: Date;
+  correlationId?: string;
+}
+
+export type EventHandler = (event: DomainEvent) => Promise<void>;
+
+export interface TaskDefinition {
+  name: string;
+  type: string;
+  payload: unknown;
+  priority?: number;
+}
+
+export interface Task {
+  id: string;
+  name: string;
+  type: string;
+  status: TaskStatus;
+  payload: unknown;
+  createdAt: Date;
+}
+
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+
+export interface TaskResult {
+  taskId: string;
+  success: boolean;
+  output?: unknown;
+  error?: Error;
+  duration: number;
+}
+
+export interface AgentConfig {
+  type: string;
+  name: string;
+  capabilities: string[];
+}
+
+export interface Agent {
+  id: string;
+  type: string;
+  name: string;
+  status: 'idle' | 'busy' | 'terminated';
+}
+
+export interface MemoryMetadata {
+  ttl?: number;
+  tags?: string[];
+  embedding?: number[];
+}
+
+export interface VectorQuery {
+  embedding: number[];
+  topK: number;
+  threshold?: number;
+}
+
+export interface SearchResult {
+  key: string;
+  value: unknown;
+  score: number;
+}
+
+export interface ExecuteOptions {
+  timeout?: number;
+  cwd?: string;
+  shell?: boolean;
+}
+
+export interface ExecuteResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export interface SwarmConfig {
+  topology: 'hierarchical' | 'mesh' | 'adaptive';
+  maxAgents: number;
+}
+
+export interface CoordinationResult {
+  success: boolean;
+  results: TaskResult[];
+  duration: number;
+}
+
+/**
+ * Test application builder with full dependency injection
+ *
+ * @example
+ * const app = createTestApplication()
+ *   .withMockEventBus()
+ *   .withMockTaskManager()
+ *   .build();
+ *
+ * await app.services.taskManager.create(task);
+ * expect(app.mocks.eventBus.publish).toHaveBeenCalled();
+ */
+export function createTestApplication(): TestApplicationBuilder {
+  return new TestApplicationBuilder();
+}
+
+/**
+ * Test application structure with mocked services
+ */
+export interface TestApplication {
+  services: {
+    eventBus: IEventBus;
+    taskManager: ITaskManager;
+    agentLifecycle: IAgentLifecycle;
+    memoryService: IMemoryService;
+    securityService: ISecurityService;
+    swarmCoordinator: ISwarmCoordinator;
+  };
+  mocks: {
+    eventBus: MockedInterface<IEventBus>;
+    taskManager: MockedInterface<ITaskManager>;
+    agentLifecycle: MockedInterface<IAgentLifecycle>;
+    memoryService: MockedInterface<IMemoryService>;
+    securityService: MockedInterface<ISecurityService>;
+    swarmCoordinator: MockedInterface<ISwarmCoordinator>;
+  };
+}
+
+/**
+ * Builder class for constructing test applications
+ */
+class TestApplicationBuilder {
+  private eventBus: MockedInterface<IEventBus> = createMock<IEventBus>();
+  private taskManager: MockedInterface<ITaskManager> = createMock<ITaskManager>();
+  private agentLifecycle: MockedInterface<IAgentLifecycle> = createMock<IAgentLifecycle>();
+  private memoryService: MockedInterface<IMemoryService> = createMock<IMemoryService>();
+  private securityService: MockedInterface<ISecurityService> = createMock<ISecurityService>();
+  private swarmCoordinator: MockedInterface<ISwarmCoordinator> = createMock<ISwarmCoordinator>();
+
+  /**
+   * Configure mock event bus with default behavior
+   */
+  withMockEventBus(configure?: (mock: MockedInterface<IEventBus>) => void): this {
+    this.eventBus = createMock<IEventBus>();
+    this.eventBus.publish.mockResolvedValue(undefined);
+    configure?.(this.eventBus);
+    return this;
+  }
+
+  /**
+   * Configure mock task manager with default behavior
+   */
+  withMockTaskManager(configure?: (mock: MockedInterface<ITaskManager>) => void): this {
+    this.taskManager = createMock<ITaskManager>();
+    this.taskManager.create.mockImplementation(async (def: TaskDefinition) => ({
+      id: `task-${Date.now()}`,
+      name: def.name,
+      type: def.type,
+      status: 'pending' as TaskStatus,
+      payload: def.payload,
+      createdAt: new Date(),
+    }));
+    this.taskManager.execute.mockResolvedValue({
+      taskId: 'test-task',
+      success: true,
+      duration: 100,
+    });
+    configure?.(this.taskManager);
+    return this;
+  }
+
+  /**
+   * Configure mock agent lifecycle with default behavior
+   */
+  withMockAgentLifecycle(configure?: (mock: MockedInterface<IAgentLifecycle>) => void): this {
+    this.agentLifecycle = createMock<IAgentLifecycle>();
+    this.agentLifecycle.spawn.mockImplementation(async (config: AgentConfig) => ({
+      id: `agent-${Date.now()}`,
+      type: config.type,
+      name: config.name,
+      status: 'idle' as const,
+    }));
+    this.agentLifecycle.listAgents.mockResolvedValue([]);
+    configure?.(this.agentLifecycle);
+    return this;
+  }
+
+  /**
+   * Configure mock memory service with default behavior
+   */
+  withMockMemoryService(configure?: (mock: MockedInterface<IMemoryService>) => void): this {
+    this.memoryService = createMock<IMemoryService>();
+    this.memoryService.store.mockResolvedValue(undefined);
+    this.memoryService.retrieve.mockResolvedValue(null);
+    this.memoryService.search.mockResolvedValue([]);
+    configure?.(this.memoryService);
+    return this;
+  }
+
+  /**
+   * Configure mock security service with default behavior
+   */
+  withMockSecurityService(configure?: (mock: MockedInterface<ISecurityService>) => void): this {
+    this.securityService = createMock<ISecurityService>();
+    this.securityService.validatePath.mockReturnValue(true);
+    this.securityService.hashPassword.mockResolvedValue('hashed');
+    this.securityService.verifyPassword.mockResolvedValue(true);
+    this.securityService.executeSecurely.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    configure?.(this.securityService);
+    return this;
+  }
+
+  /**
+   * Configure mock swarm coordinator with default behavior
+   */
+  withMockSwarmCoordinator(configure?: (mock: MockedInterface<ISwarmCoordinator>) => void): this {
+    this.swarmCoordinator = createMock<ISwarmCoordinator>();
+    this.swarmCoordinator.initialize.mockResolvedValue(undefined);
+    this.swarmCoordinator.coordinate.mockResolvedValue({
+      success: true,
+      results: [],
+      duration: 0,
+    });
+    this.swarmCoordinator.shutdown.mockResolvedValue(undefined);
+    configure?.(this.swarmCoordinator);
+    return this;
+  }
+
+  /**
+   * Build the test application with all configured mocks
+   */
+  build(): TestApplication {
+    return {
+      services: {
+        eventBus: this.eventBus as IEventBus,
+        taskManager: this.taskManager as ITaskManager,
+        agentLifecycle: this.agentLifecycle as IAgentLifecycle,
+        memoryService: this.memoryService as IMemoryService,
+        securityService: this.securityService as ISecurityService,
+        swarmCoordinator: this.swarmCoordinator as ISwarmCoordinator,
+      },
+      mocks: {
+        eventBus: this.eventBus,
+        taskManager: this.taskManager,
+        agentLifecycle: this.agentLifecycle,
+        memoryService: this.memoryService,
+        securityService: this.securityService,
+        swarmCoordinator: this.swarmCoordinator,
+      },
+    };
+  }
+}