@zhin.js/client 1.1.4 → 1.1.6

package/client/transport/console-transport.test.ts

@@ -0,0 +1,394 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockApplyConsoleEvent = vi.fn(async () => undefined);
+
+vi.mock("../persistence/idb-store.js", () => ({
+  applyConsoleEvent: (...args: unknown[]) => mockApplyConsoleEvent(...args),
+}));
+
+import { ConsoleTransport } from "./console-transport.js";
+import { ConnectionState } from "./types.js";
+
+function mockStorage(map: Record<string, string> = {}): Storage {
+  return {
+    getItem: (key: string) => map[key] ?? null,
+    setItem: (key: string, value: string) => {
+      map[key] = value;
+    },
+    removeItem: (key: string) => {
+      delete map[key];
+    },
+    clear: () => {
+      for (const key of Object.keys(map)) delete map[key];
+    },
+    key: () => null,
+    length: 0,
+  };
+}
+
+function installBrowserGlobals(storage: Storage = mockStorage()) {
+  const win = {
+    location: { origin: "http://localhost:5173", protocol: "http:", host: "localhost:5173" },
+    __ZHIN_API_TOKEN: undefined as string | undefined,
+    dispatchEvent: vi.fn(),
+  };
+  vi.stubGlobal("window", win);
+  vi.stubGlobal("localStorage", storage);
+  vi.stubGlobal("sessionStorage", mockStorage());
+  return { win, storage };
+}
+
+function sseResponse(status = 200, body?: ReadableStream<Uint8Array> | null) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    body: body === undefined
+      ? new ReadableStream<Uint8Array>({
+        start(controller) {
+          // Keep the stream open until abort; tests control lifecycle via disconnect().
+          void controller;
+        },
+      })
+      : body,
+    json: async () => ({}),
+  } as Response;
+}
+
+function eventHistoryResponse(items: unknown[] = [], runtimeId = 'runtime-test', latestEventId?: number) {
+  const inferredLatest = (items.at(-1) as { eventId?: number } | undefined)?.eventId ?? 0;
+  return {
+    ok: true,
+    status: 200,
+    json: async () => ({
+      success: true,
+      data: {
+        runtimeId,
+        items,
+        oldestAvailableEventId: items.length ? 1 : null,
+        latestEventId: latestEventId ?? inferredLatest,
+        nextAfter: inferredLatest,
+        hasMore: false,
+        gap: false,
+      },
+    }),
+  } as Response;
+}
+
+function mockConsoleTransport(sse: () => Response | Promise<Response>) {
+  return vi.fn(async (input: RequestInfo | URL, _init?: RequestInit) => {
+    return String(input).includes('/api/events/history') ? eventHistoryResponse() : await sse();
+  });
+}
+
+describe("ConsoleTransport REST/SSE transport", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockApplyConsoleEvent.mockClear();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it("connects SSE without a token (local Host with empty TokenRegistry)", async () => {
+    installBrowserGlobals();
+    const fetchMock = mockConsoleTransport(() => sseResponse(200));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new ConsoleTransport({ reconnectInterval: 100, maxReconnectAttempts: 3 });
+    const states: boolean[] = [];
+    manager.onConnectionChange((c) => states.push(c));
+    manager.connect();
+
+    await vi.advanceTimersByTimeAsync(0);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(fetchMock).toHaveBeenCalled();
+    const sseCall = fetchMock.mock.calls.find(([input]) => !String(input).includes('/history'))!;
+    const init = sseCall[1] as RequestInit;
+    const headers = init.headers as Record<string, string>;
+    expect(headers.Accept).toBe("text/event-stream");
+    expect(headers.Authorization).toBeUndefined();
+    expect(manager.getState()).toBe(ConnectionState.CONNECTED);
+    expect(manager.isConnected()).toBe(true);
+    manager.disconnect();
+  });
+
+  it("sends Authorization when a token is stored", async () => {
+    installBrowserGlobals(mockStorage({ zhin_api_token: "secret" }));
+    const fetchMock = mockConsoleTransport(() => sseResponse(200));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new ConsoleTransport();
+    manager.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    const sseCall = fetchMock.mock.calls.find(([input]) => !String(input).includes('/history'))!;
+    const init = sseCall[1] as RequestInit;
+    expect((init.headers as Record<string, string>).Authorization).toBe("Bearer secret");
+    manager.disconnect();
+  });
+
+  it("reconnects after a transient SSE failure (no ERROR deadlock)", async () => {
+    installBrowserGlobals();
+    let sseCalls = 0;
+    const fetchMock = mockConsoleTransport(() => {
+      sseCalls += 1;
+      if (sseCalls === 1) return sseResponse(503, null);
+      return sseResponse(200);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new ConsoleTransport({
+      reconnectInterval: 100,
+      maxReconnectAttempts: 5,
+    });
+    manager.connect();
+
+    // First attempt fails → RECONNECTING
+    await vi.advanceTimersByTimeAsync(0);
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(manager.getState()).toBe(ConnectionState.RECONNECTING);
+    expect(sseCalls).toBe(1);
+
+    // scheduleReconnect delay = 100 * attempt(1) = 100ms
+    await vi.advanceTimersByTimeAsync(100);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(sseCalls).toBeGreaterThanOrEqual(2);
+    expect(manager.getState()).toBe(ConnectionState.CONNECTED);
+    manager.disconnect();
+  });
+
+  it("sendRequest posts without Authorization when no token is stored", async () => {
+    installBrowserGlobals();
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        success: true,
+        data: {
+          source: "http:\n  port: 1\n",
+          format: 'yaml',
+          revision: 'a'.repeat(64),
+          configKeys: [],
+        },
+      }),
+    } as Response));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new ConsoleTransport();
+    const data = await manager.getConfigSource();
+    expect(data.source).toContain("port");
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    expect((init.headers as Record<string, string>).Authorization).toBeUndefined();
+    expect(init.method).toBe("POST");
+  });
+
+  it("sendRequest includes Bearer token when present", async () => {
+    installBrowserGlobals(mockStorage({ zhin_api_token: "t" }));
+    const fetchMock = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      json: async () => ({ success: true, data: { ok: true } }),
+    } as Response));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new ConsoleTransport();
+    await manager.setConfig("sandbox", { endpoints: [] });
+    const init = fetchMock.mock.calls[0]![1] as RequestInit;
+    expect((init.headers as Record<string, string>).Authorization).toBe("Bearer t");
+  });
+
+  it('exposes marketplace discovery and lifecycle methods for Console pages', async () => {
+    installBrowserGlobals(mockStorage({ zhin_api_token: 'token' }));
+    const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => ({
+      ok: true,
+      status: 200,
+      json: async () => ({
+        success: true,
+        data: String(input).includes('/marketplace/search') ? { items: [] } : { ok: true },
+      }),
+      headers: init?.headers,
+    } as Response));
+    const manager = new ConsoleTransport({ fetch: fetchMock });
+
+    await manager.searchMarketplace({ keyword: 'telegram', official: true });
+    await manager.getMarketplacePlugin('@zhin.js/adapter-telegram');
+    await manager.getPluginUpdates();
+    await manager.setPluginEnabled('telegram', false);
+
+    expect(String(fetchMock.mock.calls[0]![0])).toContain('/pub/marketplace/search?q=telegram&official=true');
+    expect(String(fetchMock.mock.calls[1]![0])).toContain('%40zhin.js%2Fadapter-telegram');
+    expect(String(fetchMock.mock.calls[2]![0])).toContain('/api/marketplace/updates');
+    const lifecycleBody = JSON.parse(String((fetchMock.mock.calls[3]![1] as RequestInit).body));
+    expect(lifecycleBody).toMatchObject({
+      type: 'plugin:set-enabled',
+      instanceKey: 'telegram',
+      enabled: false,
+    });
+  });
+
+  it("stops reconnecting after maxReconnectAttempts", async () => {
+    installBrowserGlobals();
+    const fetchMock = mockConsoleTransport(() => sseResponse(500, null));
+    vi.stubGlobal("fetch", fetchMock);
+
+    const manager = new ConsoleTransport({
+      reconnectInterval: 10,
+      maxReconnectAttempts: 2,
+    });
+    manager.connect();
+
+    for (let i = 0; i < 6; i++) {
+      await vi.advanceTimersByTimeAsync(50);
+      await Promise.resolve();
+      await Promise.resolve();
+    }
+
+    expect(manager.getState()).toBe(ConnectionState.ERROR);
+    const sseCalls = fetchMock.mock.calls.filter(([input]) => !String(input).includes('/history'));
+    expect(sseCalls.length).toBeLessThanOrEqual(3);
+    manager.disconnect();
+  });
+
+  it('recovers typed history before live SSE and preserves event metadata', async () => {
+    installBrowserGlobals();
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(encoder.encode([
+          'id: 2',
+          'event: message.receive',
+          'runtime: runtime-a',
+          'timestamp: 200',
+          'data: {"adapter":"sandbox","endpointKey":"bot","content":"live"}',
+          '',
+          '',
+        ].join('\n')));
+      },
+    });
+    const historyEvent = {
+      runtimeId: 'runtime-a', eventId: 1, type: 'message.receive', timestamp: 100,
+      data: { adapter: 'sandbox', endpointKey: 'bot', content: 'history' },
+    };
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => (
+      String(input).includes('/history')
+        ? eventHistoryResponse([historyEvent], 'runtime-a')
+        : sseResponse(200, stream)
+    ));
+    vi.stubGlobal('fetch', fetchMock);
+    const received: Array<{ eventId: number; delivery?: string }> = [];
+    const manager = new ConsoleTransport();
+    manager.onConsoleEvent('message.receive', (event) => received.push({ eventId: event.eventId, delivery: event.delivery }));
+    manager.connect();
+    await vi.advanceTimersByTimeAsync(0);
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(received).toEqual([
+      { eventId: 1, delivery: 'history' },
+      { eventId: 2, delivery: 'live' },
+    ]);
+    expect(mockApplyConsoleEvent).toHaveBeenCalledTimes(2);
+    manager.disconnect();
+  });
+
+  it('keeps an in-memory cursor when localStorage is unavailable', async () => {
+    const storage = mockStorage();
+    storage.setItem = () => { throw new Error('storage disabled'); };
+    installBrowserGlobals(storage);
+    const historyEvent = {
+      runtimeId: 'runtime-a', eventId: 1, type: 'message.receive', timestamp: 100,
+      data: { adapter: 'sandbox', endpointKey: 'bot', content: 'history' },
+    };
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const after = new URL(String(input)).searchParams.get('after');
+      return after === '1'
+        ? eventHistoryResponse([], 'runtime-a', 1)
+        : eventHistoryResponse([historyEvent], 'runtime-a', 1);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+    const received: number[] = [];
+    const manager = new ConsoleTransport();
+    manager.onConsoleEvent('message.receive', (event) => received.push(event.eventId));
+    const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
+    await recover.recoverEventHistory(new AbortController().signal);
+    await recover.recoverEventHistory(new AbortController().signal);
+
+    expect(received).toEqual([1]);
+    expect(fetchMock.mock.calls[1]?.[0]).toContain('after=1');
+  });
+
+  it('exposes a typed recovery gap instead of silently treating it as complete', async () => {
+    installBrowserGlobals();
+    const response = eventHistoryResponse([], 'runtime-new', 9);
+    const originalJson = response.json;
+    response.json = async () => {
+      const body = await originalJson() as { data: Record<string, unknown> };
+      return { ...body, data: { ...body.data, gap: true, oldestAvailableEventId: 8 } };
+    };
+    vi.stubGlobal('fetch', vi.fn(async () => response));
+    const manager = new ConsoleTransport();
+    const gaps: unknown[] = [];
+    manager.onConsoleEventRecoveryGap((gap) => gaps.push(gap));
+    const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
+    await recover.recoverEventHistory(new AbortController().signal);
+
+    expect(gaps).toEqual([expect.objectContaining({
+      page: expect.objectContaining({ runtimeId: 'runtime-new', gap: true }),
+    })]);
+  });
+
+  it('does not persist a cursor past an inbox event that failed durable storage', async () => {
+    const stored: Record<string, string> = {};
+    installBrowserGlobals(mockStorage(stored));
+    mockApplyConsoleEvent.mockRejectedValueOnce(new Error('IndexedDB unavailable'));
+    const historyEvent = {
+      runtimeId: 'runtime-a', eventId: 1, type: 'message.receive', timestamp: 100,
+      data: { adapter: 'sandbox', endpointKey: 'bot', content: 'history' },
+    };
+    vi.stubGlobal('fetch', vi.fn(async () => eventHistoryResponse([historyEvent], 'runtime-a', 1)));
+    const manager = new ConsoleTransport();
+    const recover = manager as unknown as { recoverEventHistory(signal: AbortSignal): Promise<void> };
+    await recover.recoverEventHistory(new AbortController().signal);
+
+    expect(Object.keys(stored).filter((key) => key.includes('event-cursor'))).toEqual([]);
+  });
+
+  it('makes disposal terminal and idempotent', () => {
+    const transport = new ConsoleTransport();
+    transport.dispose();
+    transport.dispose();
+
+    expect(transport.getState()).toBe(ConnectionState.DISCONNECTED);
+    expect(() => transport.connect()).toThrow('ConsoleTransport has been disposed');
+    expect(() => transport.onConnectionChange(() => {}))
+      .toThrow('ConsoleTransport has been disposed');
+  });
+
+  it('rejects a stale connection result after disposal', async () => {
+    installBrowserGlobals();
+    let resolveHistory!: (response: Response) => void;
+    const fetchMock = vi.fn(() => new Promise<Response>((resolve) => {
+      resolveHistory = resolve;
+    }));
+    const transport = new ConsoleTransport({ fetch: fetchMock });
+
+    transport.connect();
+    transport.dispose();
+    resolveHistory(eventHistoryResponse());
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(transport.getState()).toBe(ConnectionState.DISCONNECTED);
+    expect(fetchMock).toHaveBeenCalledOnce();
+  });
+});