swarmdo 1.45.0 → 1.54.1

package/v3/@swarmdo/testing/dist/fixtures/swarm-fixtures.js

@@ -0,0 +1,534 @@
+/**
+ * @swarmdo/testing - Swarm Fixtures
+ *
+ * Comprehensive mock swarm configurations, topologies, and coordination fixtures.
+ * Supports hierarchical-mesh, adaptive, and all consensus protocols.
+ *
+ * Based on ADR-003 (Single Coordination Engine) and V3 swarm specifications.
+ */
+import { vi } from 'vitest';
+/**
+ * Pre-defined swarm configurations for testing
+ */
+export const swarmConfigs = {
+    v3Default: {
+        topology: 'hierarchical-mesh',
+        maxAgents: 15,
+        name: 'V3 Default Swarm',
+        description: 'Standard V3 15-agent hierarchical-mesh swarm',
+        coordination: {
+            consensusProtocol: 'raft',
+            heartbeatInterval: 1000,
+            electionTimeout: 5000,
+            consensusRequired: true,
+            timeoutMs: 8000,
+            retryPolicy: { maxRetries: 3, backoffMs: 1000 },
+        },
+        communication: {
+            protocol: 'quic',
+            maxMessageSize: 1048576, // 1MB
+            retryAttempts: 3,
+            compressionEnabled: true,
+            encryptionEnabled: true,
+        },
+        autoScale: {
+            enabled: true,
+            minAgents: 5,
+            maxAgents: 15,
+            scaleUpThreshold: 0.8,
+            scaleDownThreshold: 0.3,
+            cooldownMs: 30000,
+        },
+        healthCheck: {
+            enabled: true,
+            interval: 5000,
+            timeout: 2000,
+            unhealthyThreshold: 3,
+            healthyThreshold: 2,
+        },
+    },
+    minimal: {
+        topology: 'mesh',
+        maxAgents: 5,
+        name: 'Minimal Swarm',
+        description: 'Lightweight swarm for testing',
+        coordination: {
+            consensusProtocol: 'gossip',
+            heartbeatInterval: 2000,
+            electionTimeout: 10000,
+            consensusRequired: false,
+            timeoutMs: 5000,
+            retryPolicy: { maxRetries: 5, backoffMs: 500 },
+        },
+        communication: {
+            protocol: 'tcp',
+            maxMessageSize: 65536, // 64KB
+            retryAttempts: 5,
+        },
+    },
+    highPerformance: {
+        topology: 'adaptive',
+        maxAgents: 50,
+        name: 'High Performance Swarm',
+        description: 'Optimized for maximum throughput',
+        coordination: {
+            consensusProtocol: 'pbft',
+            heartbeatInterval: 500,
+            electionTimeout: 3000,
+            consensusRequired: true,
+            timeoutMs: 5000,
+            retryPolicy: { maxRetries: 2, backoffMs: 250 },
+        },
+        communication: {
+            protocol: 'quic',
+            maxMessageSize: 4194304, // 4MB
+            retryAttempts: 2,
+            compressionEnabled: true,
+            encryptionEnabled: true,
+        },
+        autoScale: {
+            enabled: true,
+            minAgents: 10,
+            maxAgents: 50,
+            scaleUpThreshold: 0.7,
+            scaleDownThreshold: 0.2,
+            cooldownMs: 15000,
+        },
+    },
+    byzantineFault: {
+        topology: 'mesh',
+        maxAgents: 7,
+        name: 'Byzantine Fault Tolerant Swarm',
+        description: 'Tolerant to malicious actors',
+        coordination: {
+            consensusProtocol: 'byzantine',
+            heartbeatInterval: 1000,
+            electionTimeout: 10000,
+            consensusRequired: true,
+            timeoutMs: 15000,
+            retryPolicy: { maxRetries: 5, backoffMs: 2000 },
+        },
+        communication: {
+            protocol: 'tcp',
+            maxMessageSize: 1048576,
+            retryAttempts: 3,
+            encryptionEnabled: true,
+        },
+    },
+    hierarchicalOnly: {
+        topology: 'hierarchical',
+        maxAgents: 20,
+        name: 'Hierarchical Swarm',
+        description: 'Pure hierarchical coordination',
+        coordination: {
+            consensusProtocol: 'raft',
+            heartbeatInterval: 1000,
+            electionTimeout: 5000,
+            consensusRequired: false,
+            timeoutMs: 5000,
+            retryPolicy: { maxRetries: 3, backoffMs: 1000 },
+        },
+        communication: {
+            protocol: 'websocket',
+            maxMessageSize: 524288, // 512KB
+            retryAttempts: 3,
+        },
+    },
+    ringTopology: {
+        topology: 'ring',
+        maxAgents: 10,
+        name: 'Ring Topology Swarm',
+        description: 'Token-passing ring coordination',
+        coordination: {
+            consensusProtocol: 'gossip',
+            heartbeatInterval: 1500,
+            electionTimeout: 8000,
+            consensusRequired: true,
+            timeoutMs: 8000,
+            retryPolicy: { maxRetries: 4, backoffMs: 750 },
+        },
+        communication: {
+            protocol: 'tcp',
+            maxMessageSize: 262144, // 256KB
+            retryAttempts: 4,
+        },
+    },
+};
+/**
+ * Pre-defined swarm states for testing
+ */
+export const swarmStates = {
+    active: {
+        id: 'swarm-001',
+        topology: 'hierarchical-mesh',
+        status: 'active',
+        agentCount: 15,
+        activeAgentCount: 15,
+        leaderId: 'agent-queen-001',
+        createdAt: new Date('2024-01-01T00:00:00Z'),
+        lastHeartbeat: new Date(),
+    },
+    initializing: {
+        id: 'swarm-002',
+        topology: 'mesh',
+        status: 'initializing',
+        agentCount: 5,
+        activeAgentCount: 3,
+        createdAt: new Date(),
+    },
+    coordinating: {
+        id: 'swarm-003',
+        topology: 'adaptive',
+        status: 'coordinating',
+        agentCount: 10,
+        activeAgentCount: 10,
+        leaderId: 'agent-coordinator-001',
+        createdAt: new Date('2024-01-10T00:00:00Z'),
+        lastHeartbeat: new Date(),
+    },
+    consensus: {
+        id: 'swarm-004',
+        topology: 'hierarchical-mesh',
+        status: 'consensus',
+        agentCount: 15,
+        activeAgentCount: 14,
+        leaderId: 'agent-queen-001',
+        createdAt: new Date('2024-01-05T00:00:00Z'),
+        lastHeartbeat: new Date(),
+    },
+    error: {
+        id: 'swarm-005',
+        topology: 'mesh',
+        status: 'error',
+        agentCount: 8,
+        activeAgentCount: 3,
+        createdAt: new Date('2024-01-01T00:00:00Z'),
+        lastHeartbeat: new Date(Date.now() - 60000), // 1 minute ago
+    },
+    shutdown: {
+        id: 'swarm-006',
+        topology: 'hierarchical',
+        status: 'shutdown',
+        agentCount: 10,
+        activeAgentCount: 0,
+        createdAt: new Date('2024-01-01T00:00:00Z'),
+    },
+};
+/**
+ * Pre-defined swarm tasks for testing
+ */
+export const swarmTasks = {
+    securityScan: {
+        id: 'task-security-001',
+        name: 'Security Scan',
+        type: 'security',
+        payload: { target: './src', scanType: 'full', severity: 'high' },
+        priority: 100,
+        status: 'pending',
+        createdAt: new Date(),
+    },
+    codeReview: {
+        id: 'task-review-001',
+        name: 'Code Review',
+        type: 'review',
+        payload: { files: ['src/main.ts'], rules: ['security', 'performance'] },
+        priority: 80,
+        status: 'assigned',
+        assignedTo: 'agent-reviewer-001',
+        createdAt: new Date(),
+    },
+    implementation: {
+        id: 'task-impl-001',
+        name: 'Feature Implementation',
+        type: 'coding',
+        payload: { feature: 'path-validation', module: 'security' },
+        priority: 70,
+        status: 'running',
+        assignedTo: 'agent-coder-001',
+        createdAt: new Date(Date.now() - 60000),
+        startedAt: new Date(Date.now() - 30000),
+    },
+    testing: {
+        id: 'task-test-001',
+        name: 'Unit Testing',
+        type: 'testing',
+        payload: { framework: 'vitest', coverage: 0.90 },
+        priority: 75,
+        status: 'completed',
+        assignedTo: 'agent-tester-001',
+        createdAt: new Date(Date.now() - 120000),
+        startedAt: new Date(Date.now() - 90000),
+        completedAt: new Date(Date.now() - 30000),
+    },
+    orchestration: {
+        id: 'task-orch-001',
+        name: 'Task Orchestration',
+        type: 'coordination',
+        payload: { subtasks: ['task-impl-001', 'task-test-001'], parallel: true },
+        priority: 90,
+        status: 'running',
+        assignedTo: 'agent-queen-001',
+        dependencies: ['task-security-001'],
+        createdAt: new Date(Date.now() - 180000),
+        startedAt: new Date(Date.now() - 120000),
+    },
+};
+/**
+ * Pre-defined swarm messages for testing
+ */
+export const swarmMessages = {
+    taskAssignment: {
+        id: 'msg-001',
+        from: 'agent-queen-001',
+        to: 'agent-coder-001',
+        type: 'task',
+        payload: swarmTasks.implementation,
+        timestamp: new Date(),
+        correlationId: 'corr-001',
+        priority: 70,
+    },
+    taskResult: {
+        id: 'msg-002',
+        from: 'agent-coder-001',
+        to: 'agent-queen-001',
+        type: 'result',
+        payload: { taskId: 'task-impl-001', success: true, duration: 5000 },
+        timestamp: new Date(),
+        correlationId: 'corr-001',
+        replyTo: 'msg-001',
+    },
+    heartbeat: {
+        id: 'msg-003',
+        from: 'agent-queen-001',
+        to: 'broadcast',
+        type: 'heartbeat',
+        payload: { status: 'active', load: 0.6, taskCount: 5 },
+        timestamp: new Date(),
+        ttl: 5000,
+    },
+    election: {
+        id: 'msg-004',
+        from: 'agent-swarm-001',
+        to: 'broadcast',
+        type: 'election',
+        payload: { term: 5, candidateId: 'agent-swarm-001', lastLogIndex: 100 },
+        timestamp: new Date(),
+        priority: 100,
+    },
+    coordination: {
+        id: 'msg-005',
+        from: 'agent-queen-001',
+        to: 'agent-swarm-001',
+        type: 'coordination',
+        payload: { action: 'scale-up', targetAgents: 3 },
+        timestamp: new Date(),
+        correlationId: 'corr-002',
+    },
+    statusUpdate: {
+        id: 'msg-006',
+        from: 'agent-memory-001',
+        to: 'agent-queen-001',
+        type: 'status',
+        payload: { status: 'busy', currentTask: 'indexing', progress: 0.75 },
+        timestamp: new Date(),
+    },
+};
+/**
+ * Pre-defined coordination results for testing
+ */
+export const coordinationResults = {
+    successful: {
+        success: true,
+        completedTasks: 10,
+        failedTasks: 0,
+        totalDuration: 15000,
+        agentMetrics: new Map([
+            ['agent-queen-001', { tasksCompleted: 3, tasksFailed: 0, averageTaskDuration: 200, messagesProcessed: 50, totalDuration: 600 }],
+            ['agent-coder-001', { tasksCompleted: 4, tasksFailed: 0, averageTaskDuration: 2000, messagesProcessed: 20, totalDuration: 8000 }],
+            ['agent-tester-001', { tasksCompleted: 3, tasksFailed: 0, averageTaskDuration: 1500, messagesProcessed: 15, totalDuration: 4500 }],
+        ]),
+        consensusRounds: 2,
+    },
+    partialFailure: {
+        success: true,
+        completedTasks: 8,
+        failedTasks: 2,
+        totalDuration: 20000,
+        agentMetrics: new Map([
+            ['agent-queen-001', { tasksCompleted: 2, tasksFailed: 0, averageTaskDuration: 250, messagesProcessed: 40, totalDuration: 500 }],
+            ['agent-coder-001', { tasksCompleted: 4, tasksFailed: 1, averageTaskDuration: 2500, messagesProcessed: 25, totalDuration: 10000 }],
+            ['agent-tester-001', { tasksCompleted: 2, tasksFailed: 1, averageTaskDuration: 2000, messagesProcessed: 18, totalDuration: 4000 }],
+        ]),
+        consensusRounds: 3,
+    },
+    failed: {
+        success: false,
+        completedTasks: 2,
+        failedTasks: 8,
+        totalDuration: 30000,
+        agentMetrics: new Map([
+            ['agent-queen-001', { tasksCompleted: 1, tasksFailed: 2, averageTaskDuration: 500, messagesProcessed: 60, totalDuration: 500 }],
+            ['agent-coder-001', { tasksCompleted: 1, tasksFailed: 3, averageTaskDuration: 5000, messagesProcessed: 30, totalDuration: 5000 }],
+        ]),
+        consensusRounds: 5,
+    },
+};
+/**
+ * Factory function to create swarm config with overrides
+ */
+export function createSwarmConfig(base = 'v3Default', overrides) {
+    return mergeDeep(swarmConfigs[base], (overrides ?? {}));
+}
+/**
+ * Factory function to create swarm state with overrides
+ */
+export function createSwarmState(base = 'active', overrides) {
+    return {
+        ...swarmStates[base],
+        ...overrides,
+        id: overrides?.id ?? swarmStates[base].id,
+        createdAt: overrides?.createdAt ?? swarmStates[base].createdAt,
+    };
+}
+/**
+ * Factory function to create swarm task with overrides
+ */
+export function createSwarmTask(base = 'implementation', overrides) {
+    return {
+        ...swarmTasks[base],
+        ...overrides,
+        id: overrides?.id ?? `task-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+        createdAt: overrides?.createdAt ?? new Date(),
+    };
+}
+/**
+ * Factory function to create swarm message with overrides
+ */
+export function createSwarmMessage(type, payload, overrides) {
+    return {
+        id: `msg-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+        from: 'agent-sender',
+        to: 'agent-receiver',
+        type,
+        payload,
+        timestamp: new Date(),
+        ...overrides,
+    };
+}
+/**
+ * Factory function to create consensus request
+ */
+export function createConsensusRequest(topic, options, overrides) {
+    return {
+        topic,
+        options,
+        requiredVotes: 'majority',
+        timeout: 5000,
+        ...overrides,
+    };
+}
+/**
+ * Factory function to create coordination result
+ */
+export function createCoordinationResult(base = 'successful', overrides) {
+    return {
+        ...coordinationResults[base],
+        ...overrides,
+    };
+}
+/**
+ * Create a batch of swarm tasks for testing
+ */
+export function createSwarmTaskBatch(count, type = 'coding') {
+    return Array.from({ length: count }, (_, i) => ({
+        id: `batch-task-${i}`,
+        name: `Batch Task ${i + 1}`,
+        type,
+        payload: { index: i },
+        priority: Math.floor(Math.random() * 100),
+        status: 'pending',
+        createdAt: new Date(),
+    }));
+}
+/**
+ * Deep merge utility
+ */
+function mergeDeep(target, source) {
+    const output = { ...target };
+    for (const key of Object.keys(source)) {
+        const sourceValue = source[key];
+        if (sourceValue && typeof sourceValue === 'object' && !Array.isArray(sourceValue)) {
+            output[key] = mergeDeep(target[key] ?? {}, sourceValue);
+        }
+        else {
+            output[key] = sourceValue;
+        }
+    }
+    return output;
+}
+/**
+ * Invalid swarm configurations for error testing
+ */
+export const invalidSwarmConfigs = {
+    zeroAgents: createSwarmConfig('v3Default', { maxAgents: 0 }),
+    negativeHeartbeat: createSwarmConfig('v3Default', {
+        coordination: {
+            consensusProtocol: 'raft',
+            heartbeatInterval: -100,
+            electionTimeout: 5000,
+        },
+    }),
+    invalidTopology: {
+        ...swarmConfigs.v3Default,
+        topology: 'invalid-topology',
+    },
+    invalidProtocol: createSwarmConfig('v3Default', {
+        coordination: {
+            consensusProtocol: 'invalid-protocol',
+            heartbeatInterval: 1000,
+            electionTimeout: 5000,
+        },
+    }),
+    zeroMessageSize: createSwarmConfig('v3Default', {
+        communication: {
+            protocol: 'quic',
+            maxMessageSize: 0,
+            retryAttempts: 3,
+        },
+    }),
+};
+/**
+ * Create a mock swarm coordinator
+ */
+export function createMockSwarmCoordinator() {
+    return {
+        initialize: vi.fn().mockResolvedValue(swarmStates.active),
+        coordinate: vi.fn().mockResolvedValue(coordinationResults.successful),
+        shutdown: vi.fn().mockResolvedValue(undefined),
+        addAgent: vi.fn().mockResolvedValue(undefined),
+        removeAgent: vi.fn().mockResolvedValue(undefined),
+        getState: vi.fn().mockReturnValue(swarmStates.active),
+        broadcast: vi.fn().mockResolvedValue(undefined),
+        requestConsensus: vi.fn().mockResolvedValue({
+            topic: 'test',
+            decision: 'option-1',
+            votes: new Map(),
+            consensus: true,
+            votingDuration: 100,
+            participatingAgents: [],
+        }),
+    };
+}
+/**
+ * Create a mock message bus
+ */
+export function createMockMessageBus() {
+    return {
+        publish: vi.fn().mockResolvedValue(undefined),
+        subscribe: vi.fn().mockReturnValue(() => { }),
+        unsubscribe: vi.fn(),
+        request: vi.fn().mockResolvedValue(swarmMessages.taskResult),
+        getStats: vi.fn().mockReturnValue({ messagesSent: 0, messagesReceived: 0 }),
+    };
+}
+//# sourceMappingURL=swarm-fixtures.js.map

package/v3/@swarmdo/testing/dist/fixtures/tasks.d.ts

@@ -0,0 +1,106 @@
+/**
+ * V3 Swarmdo Task Fixtures
+ *
+ * Test data for task-related testing
+ * Following London School principle of explicit test data
+ */
+/**
+ * Task definition interface
+ */
+export interface TaskDefinition {
+    name: string;
+    type: string;
+    payload: unknown;
+    priority?: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Task instance interface
+ */
+export interface TaskInstance {
+    id: string;
+    name: string;
+    type: string;
+    status: TaskStatus;
+    payload: unknown;
+    priority: number;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    error?: string;
+}
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Task result interface
+ */
+export interface TaskResult {
+    taskId: string;
+    success: boolean;
+    output?: unknown;
+    error?: Error;
+    duration: number;
+    metrics?: TaskMetrics;
+}
+/**
+ * Task metrics interface
+ */
+export interface TaskMetrics {
+    cpuTime: number;
+    memoryUsage: number;
+    ioOperations: number;
+}
+/**
+ * Pre-defined task definitions for testing
+ */
+export declare const taskDefinitions: Record<string, TaskDefinition>;
+/**
+ * Pre-defined task instances for testing
+ */
+export declare const taskInstances: Record<string, TaskInstance>;
+/**
+ * Pre-defined task results for testing
+ */
+export declare const taskResults: Record<string, TaskResult>;
+/**
+ * Factory function to create task definition with overrides
+ */
+export declare function createTaskDefinition(base: keyof typeof taskDefinitions, overrides?: Partial<TaskDefinition>): TaskDefinition;
+/**
+ * Factory function to create task instance with overrides
+ */
+export declare function createTaskInstance(base: keyof typeof taskInstances, overrides?: Partial<TaskInstance>): TaskInstance;
+/**
+ * Factory function to create task result with overrides
+ */
+export declare function createTaskResult(base: keyof typeof taskResults, overrides?: Partial<TaskResult>): TaskResult;
+/**
+ * Invalid task definitions for error testing
+ */
+export declare const invalidTaskDefinitions: {
+    emptyName: {
+        name: string;
+        type: string;
+        payload: {};
+    };
+    emptyType: {
+        name: string;
+        type: string;
+        payload: {};
+    };
+    nullPayload: {
+        name: string;
+        type: string;
+        payload: null;
+    };
+    invalidPriority: {
+        name: string;
+        type: string;
+        payload: {};
+        priority: number;
+    };
+};
+/**
+ * Task batch for swarm testing
+ */
+export declare function createTaskBatch(count: number, type?: string): TaskDefinition[];
+//# sourceMappingURL=tasks.d.ts.map