agent-inbox 0.0.1 → 0.1.1

package/test/federation/routing-engine.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { EventEmitter } from "node:events";
+import { RoutingEngine } from "../../src/federation/routing-engine.js";
+
+describe("RoutingEngine", () => {
+  let events: EventEmitter;
+  let engine: RoutingEngine;
+
+  beforeEach(() => {
+    events = new EventEmitter();
+    engine = new RoutingEngine(events, {
+      strategy: "table",
+      tableTTL: 5000,
+      refreshOnMiss: true,
+    });
+  });
+
+  describe("updateFromExposure", () => {
+    it("should populate routing table from peer exposure", () => {
+      engine.updateFromExposure("backend-team", [
+        { agentId: "agent-alpha" },
+        { agentId: "agent-beta", status: "active" },
+      ]);
+
+      expect(engine.lookupAgent("agent-alpha")).toBe("backend-team");
+      expect(engine.lookupAgent("agent-beta")).toBe("backend-team");
+    });
+
+    it("should emit routing.updated event", () => {
+      const spy = vi.fn();
+      events.on("routing.updated", spy);
+      engine.updateFromExposure("peer-1", [{ agentId: "a" }]);
+      expect(spy).toHaveBeenCalledWith({ peerId: "peer-1", agentCount: 1 });
+    });
+  });
+
+  describe("lookupAgent", () => {
+    it("should return null for unknown agent", () => {
+      expect(engine.lookupAgent("unknown")).toBeNull();
+    });
+
+    it("should return null for expired entry", () => {
+      vi.useFakeTimers();
+      engine.updateFromExposure("peer-1", [{ agentId: "agent-1" }]);
+      vi.advanceTimersByTime(5001);
+      expect(engine.lookupAgent("agent-1")).toBeNull();
+      vi.useRealTimers();
+    });
+
+    it("should not return expired-status agents", () => {
+      engine.updateFromExposure("peer-1", [
+        { agentId: "agent-1", status: "expired" },
+      ]);
+      expect(engine.lookupAgent("agent-1")).toBeNull();
+    });
+
+    it("should return away agents (still routable)", () => {
+      engine.updateFromExposure("peer-1", [
+        { agentId: "agent-1", status: "away" },
+      ]);
+      expect(engine.lookupAgent("agent-1")).toBe("peer-1");
+    });
+  });
+
+  describe("resolveRoute", () => {
+    it("should return system directly if specified", () => {
+      expect(engine.resolveRoute({ system: "backend-team" })).toBe(
+        "backend-team"
+      );
+    });
+
+    it("should look up agent in table", () => {
+      engine.updateFromExposure("ml-team", [{ agentId: "trainer" }]);
+      expect(engine.resolveRoute({ agent: "trainer" })).toBe("ml-team");
+    });
+
+    it("should return null for unresolvable address", () => {
+      expect(engine.resolveRoute({ agent: "unknown" })).toBeNull();
+    });
+  });
+
+  describe("removePeer", () => {
+    it("should remove all entries for a peer", () => {
+      engine.updateFromExposure("peer-1", [
+        { agentId: "a" },
+        { agentId: "b" },
+      ]);
+      engine.updateFromExposure("peer-2", [{ agentId: "c" }]);
+
+      const removed = engine.removePeer("peer-1");
+      expect(removed).toBe(2);
+      expect(engine.lookupAgent("a")).toBeNull();
+      expect(engine.lookupAgent("b")).toBeNull();
+      expect(engine.lookupAgent("c")).toBe("peer-2");
+    });
+  });
+
+  describe("knownPeers", () => {
+    it("should list unique peer IDs", () => {
+      engine.updateFromExposure("peer-1", [{ agentId: "a" }]);
+      engine.updateFromExposure("peer-2", [{ agentId: "b" }]);
+      expect(engine.knownPeers().sort()).toEqual(["peer-1", "peer-2"]);
+    });
+  });
+
+  describe("cleanup", () => {
+    it("should remove expired entries", () => {
+      vi.useFakeTimers();
+      engine.updateFromExposure("peer-1", [{ agentId: "old" }]);
+      vi.advanceTimersByTime(5001);
+      const removed = engine.cleanup();
+      expect(removed).toBe(1);
+      expect(engine.getTable()).toHaveLength(0);
+      vi.useRealTimers();
+    });
+  });
+});