mission-control/tests/mocks/tauri-api.ts

/**
 * Mock implementation of @tauri-apps/api for testing
 *
 * This allows tests to run without a Tauri runtime.
 */

import { vi } from "vitest";

// Store for mock responses - tests can override these
export const mockResponses: Record<string, unknown> = {};

// Mock invoke function
export const invoke = vi.fn(async (cmd: string, _args?: unknown) => {
  if (cmd in mockResponses) {
    return mockResponses[cmd];
  }

  // Default responses
  switch (cmd) {
    case "greet":
      return "Hello from mock Tauri!";
    case "get_lore_status":
      return {
        last_sync: null,
        is_healthy: true,
        message: "Mock lore status",
        summary: null,
      };
    case "get_bridge_status":
      return {
        mapping_count: 0,
        pending_count: 0,
        suspect_count: 0,
        last_sync: null,
        last_reconciliation: null,
      };
    case "sync_now":
    case "reconcile":
      return { created: 0, closed: 0, skipped: 0, healed: 0, errors: [] };
    case "quick_capture":
      return { bead_id: "bd-mock-capture" };
    default:
      throw new Error(`Mock not implemented for command: ${cmd}`);
  }
});

// Helper to set mock responses in tests
export function setMockResponse(cmd: string, response: unknown): void {
  mockResponses[cmd] = response;
}

// Helper to reset all mocks
export function resetMocks(): void {
  invoke.mockClear();
  Object.keys(mockResponses).forEach((key) => delete mockResponses[key]);
  eventHandlers.clear();
  listen.mockClear();
}

// Event listener registry -- tests can trigger events via simulateEvent()
type EventHandler = (payload: { payload: unknown }) => void;
const eventHandlers: Map<string, Set<EventHandler>> = new Map();

// Mock event listener
export const listen = vi.fn(
  async (event: string, handler: EventHandler) => {
    if (!eventHandlers.has(event)) {
      eventHandlers.set(event, new Set());
    }
    eventHandlers.get(event)!.add(handler);

    // Return unlisten function
    const unlisten = vi.fn(() => {
      eventHandlers.get(event)?.delete(handler);
    });
    return unlisten;
  }
);

/** Simulate a Tauri event being emitted (for test use). */
export function simulateEvent(event: string, payload: unknown): void {
  const handlers = eventHandlers.get(event);
  if (handlers) {
    for (const handler of handlers) {
      handler({ payload });
    }
  }
}

// Mock event emitter
export const emit = vi.fn(async (_event: string, _payload?: unknown) => {});

// Core module exports
export const core = {
  invoke,
};

// Event module exports
export const event = {
  listen,
  emit,
};

// Window module mock
export const window = {
  getCurrent: vi.fn(() => ({
    label: "main",
    listen: vi.fn(),
    emit: vi.fn(),
    close: vi.fn(),
    hide: vi.fn(),
    show: vi.fn(),
    isVisible: vi.fn(async () => true),
    setTitle: vi.fn(),
  })),
};