@emmahyde/thinking-patterns/dist/tests/helpers/mockFactories.js

MCP server combining systematic thinking, mental models, debugging approaches, and stochastic algorithms for comprehensive cognitive pattern support

/**
 * Mock factories for generating test data and mocking dependencies
 */
// Mock factory for creating SequentialThoughtData with customizable fields
export const createMockThoughtData = (overrides = {}) => ({
    thought: "Mock thought for testing",
    thoughtNumber: 1,
    totalThoughts: 3,
    nextThoughtNeeded: true,
    isRevision: false,
    revisesThought: undefined,
    branchFromThought: undefined,
    branchId: undefined,
    needsMoreThoughts: false,
    currentStep: undefined,
    previousSteps: undefined,
    remainingSteps: undefined,
    toolUsageHistory: undefined,
    ...overrides,
});
// Mock factory for ToolRecommendation
export const createMockToolRecommendation = (overrides = {}) => ({
    toolName: "sequential_thinking",
    confidence: 0.8,
    rationale: "Mock rationale for testing",
    priority: 1,
    alternativeTools: ["mental_model", "debugging"],
    ...overrides,
});
// Mock factory for CurrentStep
export const createMockCurrentStep = (overrides = {}) => ({
    stepDescription: "Mock step description",
    recommendedTools: [createMockToolRecommendation()],
    expectedOutcome: "Mock expected outcome",
    nextStepConditions: ["Condition 1", "Condition 2"],
    stepNumber: 1,
    estimatedDuration: "5 minutes",
    complexityLevel: "medium",
    ...overrides,
});
// Mock factory for MCP request
export const createMockMcpRequest = (toolName = "sequential_thinking", args = {}) => ({
    jsonrpc: "2.0",
    id: `mock-request-${Date.now()}`,
    method: "tools/call",
    params: {
        name: toolName,
        arguments: args,
    },
});
// Mock factory for MCP response
export const createMockMcpResponse = (content = "Mock response", isError = false) => ({
    content: [
        {
            type: "text",
            text: content,
        },
    ],
    isError,
});
// Mock factory for session data
export const createMockSessionData = (overrides = {}) => ({
    sessionId: `mock-session-${Date.now()}`,
    userId: `mock-user-${Date.now()}`,
    createdAt: new Date(),
    lastActivity: new Date(),
    thoughtHistory: [createMockThoughtData()],
    metadata: {
        userAgent: "test-agent/1.0",
        clientId: "test-client",
    },
    ...overrides,
});
// Mock BaseToolServer class
export const createMockBaseToolServer = () => {
    const mock = {
        run: vi.fn().mockReturnValue({
            content: [{ type: "text", text: "Mock server response" }],
            isError: false,
        })
    };
    return mock;
};
// Mock console methods for testing output
export const createMockConsole = () => ({
    log: vi.fn(),
    error: vi.fn(),
    warn: vi.fn(),
    info: vi.fn(),
    debug: vi.fn(),
});
// Mock file system operations
export const createMockFs = () => ({
    readFile: vi.fn(),
    writeFile: vi.fn(),
    exists: vi.fn(),
    mkdir: vi.fn(),
});
// Mock network/HTTP operations
export const createMockHttp = () => ({
    get: vi.fn(),
    post: vi.fn(),
    put: vi.fn(),
    delete: vi.fn(),
    request: vi.fn(),
});
// Mock timer functions for testing async behavior
export const createMockTimers = () => {
    vi.useFakeTimers();
    return {
        advanceTimersByTime: vi.advanceTimersByTime,
        runOnlyPendingTimers: vi.runOnlyPendingTimers,
        runAllTimers: vi.runAllTimers,
        clearAllTimers: vi.clearAllTimers,
        restoreTimers: () => vi.useRealTimers(),
    };
};
// Mock validation error for testing error scenarios
export const createMockValidationError = (message = "Mock validation error") => {
    const error = new Error(message);
    error.name = "ValidationError";
    return error;
};
// Mock network error for testing network failure scenarios
export const createMockNetworkError = (message = "Mock network error") => {
    const error = new Error(message);
    error.name = "NetworkError";
    return error;
};
// Mock timeout error for testing timeout scenarios
export const createMockTimeoutError = (message = "Mock timeout error") => {
    const error = new Error(message);
    error.name = "TimeoutError";
    return error;
};
// Helper to create a mock implementation of any function
export const createMockFunction = (implementation) => {
    const mockFn = vi.fn();
    if (implementation) {
        mockFn.mockImplementation(implementation);
    }
    return mockFn;
};
// Helper to create a spy on object methods
export const createMethodSpy = (object, method) => {
    return vi.spyOn(object, method);
};
// Helper to create a mock class instance
export const createMockInstance = (constructor) => {
    return {};
};
// Helper to reset all mocks
export const resetAllMocks = () => {
    vi.clearAllMocks();
    vi.resetAllMocks();
    vi.restoreAllMocks();
};
// Helper to wait for async operations in tests
export const waitForAsync = (ms = 0) => {
    return new Promise(resolve => setTimeout(resolve, ms));
};
// Helper to create random test data
export const createRandomString = (length = 10) => {
    return Math.random().toString(36).substring(2, 2 + length);
};
export const createRandomNumber = (min = 1, max = 100) => {
    return Math.floor(Math.random() * (max - min + 1)) + min;
};
export const createRandomBoolean = () => {
    return Math.random() < 0.5;
};
// Test data generators for stress testing
export const generateLargeThoughtHistory = (count = 100) => {
    return Array.from({ length: count }, (_, i) => createMockThoughtData({
        thought: `Thought ${i + 1}: ${createRandomString(50)}`,
        thoughtNumber: i + 1,
        totalThoughts: count,
        nextThoughtNeeded: i < count - 1,
    }));
};
export const generateLargeToolRecommendations = (count = 50) => {
    const tools = ["sequential_thinking", "mental_model", "debugging", "stochastic", "collaborative"];
    return Array.from({ length: count }, (_, i) => createMockToolRecommendation({
        toolName: tools[i % tools.length],
        confidence: Math.random(),
        priority: i + 1,
        rationale: `Rationale ${i + 1}: ${createRandomString(30)}`,
    }));
};