agenthub-multiagent-mcp 1.1.2 → 1.1.4

package/src/client.test.ts

@@ -1,208 +1,223 @@
-/**
- * Integration tests for AgentHub API client
- *
- * These tests require the AgentHub server to be running on localhost:8787
- * Run: cd server && go run ./cmd/agenthub serve --port 8787
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from "vitest";
-import { ApiClient } from "./client.js";
-
-const TEST_URL = process.env.AGENTHUB_URL || "http://localhost:8787";
-const TEST_API_KEY = process.env.AGENTHUB_API_KEY || "test-key-123";
-
-describe("ApiClient Integration", () => {
-  let client: ApiClient;
-  let testAgentId: string;
-  let testChannelName: string;
-
-  beforeAll(() => {
-    client = new ApiClient(TEST_URL, TEST_API_KEY);
-    testAgentId = `test-agent-${Date.now()}`;
-    testChannelName = `test-channel-${Date.now()}`;
-  });
-
-  afterAll(async () => {
-    // Cleanup - disconnect agent
-    try {
-      await client.disconnect(testAgentId);
-    } catch {
-      // Ignore cleanup errors
-    }
-  });
-
-  describe("Agent Operations", () => {
-    it("should register an agent", async () => {
-      const result = await client.registerAgent(testAgentId, "Test Agent");
-
-      expect(result.agent_id).toBe(testAgentId);
-      expect(result.registered_at).toBeDefined();
-    });
-
-    it("should get agent details", async () => {
-      const agent = await client.getAgent(testAgentId);
-
-      expect(agent.id).toBe(testAgentId);
-      expect(agent.name).toBe("Test Agent");
-      expect(agent.status).toBe("online");
-    });
-
-    it("should list agents", async () => {
-      const result = await client.listAgents();
-
-      expect(result.agents).toBeDefined();
-      expect(result.total).toBeGreaterThan(0);
-
-      const testAgent = result.agents.find((a) => a.id === testAgentId);
-      expect(testAgent).toBeDefined();
-    });
-
-    it("should filter agents by status", async () => {
-      const result = await client.listAgents("online");
-
-      expect(result.agents).toBeDefined();
-      for (const agent of result.agents) {
-        expect(agent.status).toBe("online");
-      }
-    });
-
-    it("should start work", async () => {
-      const result = await client.startWork(testAgentId, "Running tests", "TestProject");
-
-      expect(result.acknowledged).toBe(true);
-    });
-
-    it("should send heartbeat", async () => {
-      const result = await client.heartbeat(testAgentId, "busy");
-
-      expect(result.acknowledged).toBe(true);
-      expect(result.timestamp).toBeDefined();
-    });
-  });
-
-  describe("Channel Operations", () => {
-    let secondAgentId: string;
-
-    beforeAll(async () => {
-      secondAgentId = `test-agent-2-${Date.now()}`;
-      await client.registerAgent(secondAgentId, "Test Agent 2");
-    });
-
-    afterAll(async () => {
-      try {
-        await client.disconnect(secondAgentId);
-      } catch {
-        // Ignore cleanup errors
-      }
-    });
-
-    it("should list channels", async () => {
-      const result = await client.listChannels();
-
-      expect(result.channels).toBeDefined();
-      expect(typeof result.total).toBe("number");
-    });
-
-    it("should join channel", async () => {
-      // First ensure channel exists by trying to join
-      // If the channel doesn't exist, this will fail - we need to create it first
-      // But we don't have a createChannel method in the client
-
-      // For this test, we assume the channel exists or the server auto-creates
-      // Skip this test if the channel doesn't exist
-      try {
-        const result = await client.joinChannel(testChannelName, testAgentId);
-        expect(result.subscribed).toBe(true);
-      } catch (e) {
-        // Channel might not exist, skip
-        console.log("Channel join test skipped - channel may not exist");
-      }
-    });
-  });
-
-  describe("Message Operations", () => {
-    let secondAgentId: string;
-    let messageId: string;
-
-    beforeAll(async () => {
-      secondAgentId = `test-agent-msg-${Date.now()}`;
-      await client.registerAgent(secondAgentId, "Test Agent Msg");
-    });
-
-    afterAll(async () => {
-      try {
-        await client.disconnect(secondAgentId);
-      } catch {
-        // Ignore cleanup errors
-      }
-    });
-
-    it("should send a direct message", async () => {
-      const result = await client.sendMessage({
-        from_agent: testAgentId,
-        to_agent: secondAgentId,
-        type: "task",
-        subject: "Test Message",
-        body: "This is a test message",
-        priority: "normal",
-      });
-
-      expect(result.message_id).toBeDefined();
-      expect(result.status).toBe("pending");
-      messageId = result.message_id;
-    });
-
-    it("should get inbox messages", async () => {
-      const result = await client.getInbox(secondAgentId);
-
-      expect(result.messages).toBeDefined();
-      expect(result.total).toBeGreaterThan(0);
-
-      const testMessage = result.messages.find((m) => m.id === messageId);
-      expect(testMessage).toBeDefined();
-      expect(testMessage?.subject).toBe("Test Message");
-    });
-
-    it("should mark message as read", async () => {
-      // First need to mark as delivered
-      const patchUrl = `${TEST_URL}/messages/${messageId}/status`;
-      await fetch(patchUrl, {
-        method: "PATCH",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-Key": TEST_API_KEY,
-        },
-        body: JSON.stringify({ status: "delivered" }),
-      });
-
-      const result = await client.markRead(messageId);
-
-      expect(result.updated).toBe(true);
-    });
-
-    it("should send a broadcast message", async () => {
-      const result = await client.sendMessage({
-        from_agent: testAgentId,
-        broadcast: true,
-        type: "status",
-        subject: "Broadcast Test",
-        body: "This is a broadcast",
-      });
-
-      expect(result.message_id).toBeDefined();
-      expect(result.status).toBe("pending");
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("should throw error for non-existent agent", async () => {
-      await expect(client.getAgent("non-existent-agent-xyz")).rejects.toThrow();
-    });
-
-    it("should throw error for duplicate registration", async () => {
-      await expect(
-        client.registerAgent(testAgentId, "Duplicate Agent")
-      ).rejects.toThrow(/already registered/i);
-    });
-  });
-});
+/**
+ * Integration tests for AgentHub API client
+ *
+ * These tests require the AgentHub server to be running on localhost:8787
+ * Run: cd server && go run ./cmd/agenthub serve --port 8787
+ *
+ * Set AGENTHUB_INTEGRATION_TESTS=1 to run these tests
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { ApiClient } from "./client.js";
+
+const TEST_URL = process.env.AGENTHUB_URL || "http://localhost:8787";
+const TEST_API_KEY = process.env.AGENTHUB_API_KEY || "test-key-123";
+const RUN_INTEGRATION = process.env.AGENTHUB_INTEGRATION_TESTS === "1";
+
+// Helper to check if server is reachable
+async function isServerReachable(): Promise<boolean> {
+  try {
+    const response = await fetch(`${TEST_URL}/health`, {
+      signal: AbortSignal.timeout(2000)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+describe.skipIf(!RUN_INTEGRATION)("ApiClient Integration", () => {
+  let client: ApiClient;
+  let testAgentId: string;
+  let testChannelName: string;
+
+  beforeAll(() => {
+    client = new ApiClient(TEST_URL, TEST_API_KEY);
+    testAgentId = `test-agent-${Date.now()}`;
+    testChannelName = `test-channel-${Date.now()}`;
+  });
+
+  afterAll(async () => {
+    // Cleanup - disconnect agent
+    try {
+      await client.disconnect(testAgentId);
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("Agent Operations", () => {
+    it("should register an agent", async () => {
+      const result = await client.registerAgent(testAgentId, "Test Agent");
+
+      expect(result.agent_id).toBe(testAgentId);
+      expect(result.registered_at).toBeDefined();
+    });
+
+    it("should get agent details", async () => {
+      const agent = await client.getAgent(testAgentId);
+
+      expect(agent.id).toBe(testAgentId);
+      expect(agent.name).toBe("Test Agent");
+      expect(agent.status).toBe("online");
+    });
+
+    it("should list agents", async () => {
+      const result = await client.listAgents();
+
+      expect(result.agents).toBeDefined();
+      expect(result.total).toBeGreaterThan(0);
+
+      const testAgent = result.agents.find((a) => a.id === testAgentId);
+      expect(testAgent).toBeDefined();
+    });
+
+    it("should filter agents by status", async () => {
+      const result = await client.listAgents("online");
+
+      expect(result.agents).toBeDefined();
+      for (const agent of result.agents) {
+        expect(agent.status).toBe("online");
+      }
+    });
+
+    it("should start work", async () => {
+      const result = await client.startWork(testAgentId, "Running tests", "TestProject");
+
+      expect(result.acknowledged).toBe(true);
+    });
+
+    it("should send heartbeat", async () => {
+      const result = await client.heartbeat(testAgentId, "busy");
+
+      expect(result.acknowledged).toBe(true);
+      expect(result.timestamp).toBeDefined();
+    });
+  });
+
+  describe("Channel Operations", () => {
+    let secondAgentId: string;
+
+    beforeAll(async () => {
+      secondAgentId = `test-agent-2-${Date.now()}`;
+      await client.registerAgent(secondAgentId, "Test Agent 2");
+    });
+
+    afterAll(async () => {
+      try {
+        await client.disconnect(secondAgentId);
+      } catch {
+        // Ignore cleanup errors
+      }
+    });
+
+    it("should list channels", async () => {
+      const result = await client.listChannels();
+
+      expect(result.channels).toBeDefined();
+      expect(typeof result.total).toBe("number");
+    });
+
+    it("should join channel", async () => {
+      // First ensure channel exists by trying to join
+      // If the channel doesn't exist, this will fail - we need to create it first
+      // But we don't have a createChannel method in the client
+
+      // For this test, we assume the channel exists or the server auto-creates
+      // Skip this test if the channel doesn't exist
+      try {
+        const result = await client.joinChannel(testChannelName, testAgentId);
+        expect(result.subscribed).toBe(true);
+      } catch (e) {
+        // Channel might not exist, skip
+        console.log("Channel join test skipped - channel may not exist");
+      }
+    });
+  });
+
+  describe("Message Operations", () => {
+    let secondAgentId: string;
+    let messageId: string;
+
+    beforeAll(async () => {
+      secondAgentId = `test-agent-msg-${Date.now()}`;
+      await client.registerAgent(secondAgentId, "Test Agent Msg");
+    });
+
+    afterAll(async () => {
+      try {
+        await client.disconnect(secondAgentId);
+      } catch {
+        // Ignore cleanup errors
+      }
+    });
+
+    it("should send a direct message", async () => {
+      const result = await client.sendMessage({
+        from_agent: testAgentId,
+        to_agent: secondAgentId,
+        type: "task",
+        subject: "Test Message",
+        body: "This is a test message",
+        priority: "normal",
+      });
+
+      expect(result.message_id).toBeDefined();
+      expect(result.status).toBe("pending");
+      messageId = result.message_id;
+    });
+
+    it("should get inbox messages", async () => {
+      const result = await client.getInbox(secondAgentId);
+
+      expect(result.messages).toBeDefined();
+      expect(result.total).toBeGreaterThan(0);
+
+      const testMessage = result.messages.find((m) => m.id === messageId);
+      expect(testMessage).toBeDefined();
+      expect(testMessage?.subject).toBe("Test Message");
+    });
+
+    it("should mark message as read", async () => {
+      // First need to mark as delivered
+      const patchUrl = `${TEST_URL}/messages/${messageId}/status`;
+      await fetch(patchUrl, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": TEST_API_KEY,
+        },
+        body: JSON.stringify({ status: "delivered" }),
+      });
+
+      const result = await client.markRead(messageId);
+
+      expect(result.updated).toBe(true);
+    });
+
+    it("should send a broadcast message", async () => {
+      const result = await client.sendMessage({
+        from_agent: testAgentId,
+        broadcast: true,
+        type: "status",
+        subject: "Broadcast Test",
+        body: "This is a broadcast",
+      });
+
+      expect(result.message_id).toBeDefined();
+      expect(result.status).toBe("pending");
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should throw error for non-existent agent", async () => {
+      await expect(client.getAgent("non-existent-agent-xyz")).rejects.toThrow();
+    });
+
+    it("should throw error for duplicate registration", async () => {
+      await expect(
+        client.registerAgent(testAgentId, "Duplicate Agent")
+      ).rejects.toThrow(/already registered/i);
+    });
+  });
+});