@aria-cli/tools 1.0.8 → 1.0.10

package/tests/mcp/client-reconnect.test.ts

@@ -1,267 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { MCPClient } from "../../src/mcp/client.js";
-import type { MCPServerConfig } from "../../src/mcp/types.js";
-
-/**
- * Tests for MCPClient reconnect race conditions.
- *
- * aria-rfu.10: disconnect() during a pending reconnect timer did not cancel
- * the timer, so reconnect would fire after disconnect and create a zombie
- * connection.
- *
- * aria-288: Two rapid process exits trigger two reconnect() calls that race.
- * The second connect() throws 'already connected' because the first reconnect
- * already re-established the connection. Fixed with a servers.has() guard.
- */
-
-// We mock MCPServerConnection so we don't spawn real child processes.
-vi.mock("../../src/mcp/connection.js", () => {
-  const { EventEmitter } = require("events");
-
-  class MockMCPServerConnection extends EventEmitter {
-    config: MCPServerConfig;
-    _initialized = false;
-
-    constructor(config: MCPServerConfig) {
-      super();
-      this.config = config;
-    }
-
-    get name() {
-      return this.config.name;
-    }
-    get initialized() {
-      return this._initialized;
-    }
-
-    async initialize() {
-      this._initialized = true;
-      return {};
-    }
-
-    async shutdown() {
-      this._initialized = false;
-    }
-
-    async listTools() {
-      return [];
-    }
-    async listResources() {
-      return [];
-    }
-    async listPrompts() {
-      return [];
-    }
-    async callTool(_name: string, _args: unknown) {
-      return { success: true, message: "mock result" };
-    }
-  }
-
-  return { MCPServerConnection: MockMCPServerConnection };
-});
-
-describe("MCPClient reconnect race condition", () => {
-  let client: MCPClient;
-  const config: MCPServerConfig = {
-    name: "test-server",
-    command: "node",
-    args: ["fake-server.js"],
-  };
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    client = new MCPClient();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("disconnect() during pending reconnect cancels the reconnect", async () => {
-    // Connect normally
-    const conn = await client.connect(config);
-    expect(client.getConnectedServers()).toContain("test-server");
-
-    // Simulate an unexpected exit (non-zero code) to trigger auto-reconnect
-    conn.emit("exit", 1);
-
-    // At this point, reconnect() has been called and is awaiting its setTimeout.
-    // The server entry was already removed by the exit handler.
-    expect(client.getConnectedServers()).not.toContain("test-server");
-
-    // Now disconnect while the reconnect timer is pending
-    await client.disconnect("test-server");
-
-    // Advance time past the reconnect delay (1s for attempt 0)
-    await vi.advanceTimersByTimeAsync(2000);
-
-    // After advancing, reconnect should NOT have re-created the connection
-    expect(client.getConnectedServers()).not.toContain("test-server");
-  });
-
-  it("reconnect after disconnect does not create zombie connection", async () => {
-    // Connect, then trigger an unexpected exit
-    const conn = await client.connect(config);
-    conn.emit("exit", 1);
-
-    // Disconnect the server (should cancel pending reconnect)
-    await client.disconnect("test-server");
-
-    // Spy on connect to verify it is NOT called
-    const connectSpy = vi.spyOn(client, "connect");
-
-    // Advance timers well past all 3 retry attempts (1s + 2s + 4s = 7s)
-    await vi.advanceTimersByTimeAsync(10000);
-
-    // connect should not have been called — reconnect was cancelled
-    expect(connectSpy).not.toHaveBeenCalled();
-    expect(client.getConnectedServers()).toHaveLength(0);
-  });
-
-  it("reconnect proceeds normally when disconnect is not called", async () => {
-    const conn = await client.connect(config);
-    conn.emit("exit", 1);
-
-    // Do NOT disconnect — let reconnect run
-
-    // Advance past the 1s delay for attempt 0
-    await vi.advanceTimersByTimeAsync(1100);
-
-    // Reconnect should have re-established the connection
-    expect(client.getConnectedServers()).toContain("test-server");
-  });
-
-  it("disconnectAll cancels all pending reconnects", async () => {
-    // Connect two servers
-    const config2: MCPServerConfig = {
-      name: "test-server-2",
-      command: "node",
-      args: ["fake-server-2.js"],
-    };
-
-    const conn1 = await client.connect(config);
-    const conn2 = await client.connect(config2);
-
-    // Trigger unexpected exits on both
-    conn1.emit("exit", 1);
-    conn2.emit("exit", 1);
-
-    // disconnectAll should cancel both pending reconnects
-    await client.disconnectAll();
-
-    // Advance past all retry delays
-    await vi.advanceTimersByTimeAsync(10000);
-
-    // Neither should have reconnected
-    expect(client.getConnectedServers()).toHaveLength(0);
-  });
-});
-
-/**
- * aria-288: Double-reconnect race condition.
- *
- * When a server process exits twice in quick succession (e.g. the process
- * emits two 'exit' events, or the exit handler fires while a reconnect is
- * already in-flight), two reconnect() calls race. Without the servers.has()
- * guard, the second one calls connect() which throws 'already connected'.
- */
-describe("MCPClient double-reconnect race (aria-288)", () => {
-  let client: MCPClient;
-  const config: MCPServerConfig = {
-    name: "race-server",
-    command: "node",
-    args: ["fake-server.js"],
-  };
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    client = new MCPClient();
-  });
-
-  afterEach(async () => {
-    await client.disconnectAll();
-    vi.useRealTimers();
-  });
-
-  it("two rapid exit events do not cause 'already connected' error", async () => {
-    // Connect normally
-    const conn = await client.connect(config);
-    expect(client.getConnectedServers()).toContain("race-server");
-
-    // Simulate two rapid exit events — this is the core race scenario.
-    // The first exit removes the server from the map and queues a reconnect.
-    // The second exit fires while the first reconnect timer is still pending.
-    conn.emit("exit", 1);
-    conn.emit("exit", 1);
-
-    // Both reconnect() calls are now awaiting their setTimeout timers.
-    // The server should be removed from the connected list.
-    expect(client.getConnectedServers()).not.toContain("race-server");
-
-    // Advance time past the 1s delay for attempt 0. Both reconnects fire.
-    // Without the fix, the second would throw 'Server already connected'.
-    // With the fix, the second sees servers.has() is true and skips.
-    await vi.advanceTimersByTimeAsync(1100);
-
-    // Exactly one connection should exist — no error, no duplicate.
-    expect(client.getConnectedServers()).toContain("race-server");
-    expect(client.getConnectedServers()).toHaveLength(1);
-  });
-
-  it("second reconnect is a no-op when first reconnect succeeds", async () => {
-    const conn = await client.connect(config);
-
-    // Spy on connect to count calls
-    const connectSpy = vi.spyOn(client, "connect");
-
-    // Trigger two rapid exits
-    conn.emit("exit", 1);
-    conn.emit("exit", 1);
-
-    // Advance past the first reconnect delay
-    await vi.advanceTimersByTimeAsync(1100);
-
-    // connect() should have been called exactly once (by the first reconnect).
-    // The second reconnect should have bailed out via the servers.has() guard.
-    expect(connectSpy).toHaveBeenCalledTimes(1);
-    expect(client.getConnectedServers()).toContain("race-server");
-  });
-
-  it("reconnected server is functional after double-exit race", async () => {
-    const conn = await client.connect(config);
-
-    // Trigger the race
-    conn.emit("exit", 1);
-    conn.emit("exit", 1);
-
-    // Let reconnect complete
-    await vi.advanceTimersByTimeAsync(1100);
-
-    // The reconnected server should be usable — listAllTools should not throw.
-    const tools = await client.listAllTools();
-    expect(tools).toEqual([]);
-
-    // callTool should also work (returns success:false for missing tool,
-    // but the important thing is it doesn't throw 'Server not connected').
-    const result = await client.callTool("race-server", "some_tool", {});
-    // The mock connection doesn't support callTool, so it won't throw
-    // 'Server not connected' which would indicate the connection is broken.
-    expect(result).toBeDefined();
-  });
-
-  it("three rapid exits still result in exactly one connection", async () => {
-    const conn = await client.connect(config);
-
-    // Extreme case: three exits in quick succession
-    conn.emit("exit", 1);
-    conn.emit("exit", 1);
-    conn.emit("exit", 1);
-
-    // Advance past all reconnect timers
-    await vi.advanceTimersByTimeAsync(1100);
-
-    // Should still have exactly one connection
-    expect(client.getConnectedServers()).toHaveLength(1);
-    expect(client.getConnectedServers()).toContain("race-server");
-  });
-});