@agentick/gateway 0.0.1

package/src/__tests__/gateway-methods.spec.ts

@@ -0,0 +1,262 @@
+/**
+ * Gateway Method Dispatch Tests
+ *
+ * Integration tests for Gateway custom method dispatch, including:
+ * - Method initialization and path resolution
+ * - Role and custom guard middleware
+ * - Schema validation
+ * - Auth hydrateUser hook
+ * - Express middleware
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { z } from "zod";
+import { Gateway, createGateway, type ExpressRequestHandler } from "../gateway.js";
+import { method, type AuthResult, type AuthConfig, type GatewayConfig } from "../types.js";
+import { Context, type UserContext } from "@agentick/kernel";
+import { createMockApp } from "@agentick/core/testing";
+
+// ============================================================================
+// Gateway initialization tests
+// ============================================================================
+
+describe("Gateway method initialization", () => {
+  it("should initialize simple function methods", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      methods: {
+        ping: async () => ({ pong: true }),
+      },
+    });
+
+    // Gateway should be created without errors
+    expect(gateway).toBeInstanceOf(Gateway);
+  });
+
+  it("should initialize method() definition methods", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      methods: {
+        create: method({
+          schema: z.object({ title: z.string() }),
+          handler: async (params) => ({ id: "1", title: params.title }),
+        }),
+      },
+    });
+
+    expect(gateway).toBeInstanceOf(Gateway);
+  });
+
+  it("should initialize nested namespace methods", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      methods: {
+        tasks: {
+          list: async () => [],
+          create: method({
+            schema: z.object({ title: z.string() }),
+            handler: async (params) => ({ id: "1", title: params.title }),
+          }),
+          admin: {
+            archive: method({
+              roles: ["admin"],
+              handler: async () => ({ archived: true }),
+            }),
+          },
+        },
+      },
+    });
+
+    expect(gateway).toBeInstanceOf(Gateway);
+  });
+
+  it("should handle deeply nested namespaces", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      methods: {
+        level1: {
+          level2: {
+            level3: {
+              level4: {
+                deepMethod: async () => ({ deep: true }),
+              },
+            },
+          },
+        },
+      },
+    });
+
+    expect(gateway).toBeInstanceOf(Gateway);
+  });
+});
+
+// ============================================================================
+// Auth configuration tests
+// ============================================================================
+
+describe("Auth configuration", () => {
+  it("should support auth type none", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      auth: { type: "none" },
+    });
+
+    expect(gateway).toBeInstanceOf(Gateway);
+  });
+
+  it("should support auth type token", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      auth: { type: "token", token: "secret-token" },
+    });
+
+    expect(gateway).toBeInstanceOf(Gateway);
+  });
+
+  it("should support auth type custom with validate function", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      auth: {
+        type: "custom",
+        validate: async (token) => ({
+          valid: token === "valid-token",
+          user: { id: "user-1" },
+        }),
+      },
+    });
+
+    expect(gateway).toBeInstanceOf(Gateway);
+  });
+
+  it("should support hydrateUser hook on any auth type", () => {
+    const hydrateUser = vi.fn(
+      async (authResult: AuthResult): Promise<UserContext> => ({
+        id: authResult.user?.id ?? "unknown",
+        roles: ["user", "premium"],
+        email: "test@example.com",
+      }),
+    );
+
+    // With token auth
+    const gateway1 = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      auth: {
+        type: "token",
+        token: "secret",
+        hydrateUser,
+      },
+    });
+    expect(gateway1).toBeInstanceOf(Gateway);
+
+    // With custom auth
+    const gateway2 = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      auth: {
+        type: "custom",
+        validate: async () => ({ valid: true, user: { id: "1" } }),
+        hydrateUser,
+      },
+    });
+    expect(gateway2).toBeInstanceOf(Gateway);
+  });
+});
+
+// ============================================================================
+// Gateway status and lifecycle tests
+// ============================================================================
+
+describe("Gateway status", () => {
+  it("should return correct status before start", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+    });
+
+    expect(gateway.running).toBe(false);
+    expect(gateway.status.uptime).toBe(0);
+    expect(gateway.status.clients).toBe(0);
+    expect(gateway.status.sessions).toBe(0);
+    expect(gateway.status.apps).toContain("test");
+  });
+
+  it("should have a unique id when provided", () => {
+    const gateway1 = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      id: "gateway-1",
+    });
+
+    const gateway2 = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      id: "gateway-2",
+    });
+
+    expect(gateway1.id).toBe("gateway-1");
+    expect(gateway2.id).toBe("gateway-2");
+    expect(gateway1.id).not.toBe(gateway2.id);
+  });
+
+  it("should auto-generate id when not provided", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+    });
+
+    expect(gateway.id).toBeTruthy();
+    expect(gateway.id).toMatch(/^gw-/);
+  });
+
+  it("should use provided id", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+      id: "custom-gateway-id",
+    });
+
+    expect(gateway.id).toBe("custom-gateway-id");
+  });
+});
+
+// ============================================================================
+// Config validation tests
+// ============================================================================
+
+describe("Gateway config validation", () => {
+  it("should throw if no apps provided", () => {
+    expect(() =>
+      createGateway({
+        apps: {},
+        defaultApp: "test",
+      }),
+    ).toThrow("At least one app is required");
+  });
+
+  it("should throw if no defaultApp provided", () => {
+    expect(() =>
+      createGateway({
+        apps: { test: createMockApp() as any },
+        defaultApp: "",
+      } as any),
+    ).toThrow("defaultApp is required");
+  });
+
+  it("should use default port and host", () => {
+    const gateway = createGateway({
+      apps: { test: createMockApp() as any },
+      defaultApp: "test",
+    });
+
+    // Gateway should be created with defaults
+    expect(gateway).toBeInstanceOf(Gateway);
+  });
+});

package/src/__tests__/gateway.spec.ts

@@ -0,0 +1,404 @@
+/**
+ * Gateway Integration Tests
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { Gateway, createGateway } from "../gateway.js";
+import { createMockApp as createCoreMockApp, type MockApp } from "@agentick/core/testing";
+import WebSocket from "ws";
+
+describe("Gateway", () => {
+  const TEST_PORT = 19998;
+  const TEST_HOST = "127.0.0.1";
+  let gateway: Gateway;
+  let chatApp: MockApp;
+  let researchApp: MockApp;
+
+  beforeEach(() => {
+    chatApp = createCoreMockApp();
+    researchApp = createCoreMockApp();
+  });
+
+  afterEach(async () => {
+    if (gateway?.running) {
+      await gateway.stop();
+    }
+  });
+
+  describe("createGateway", () => {
+    it("creates gateway with config", () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp },
+        defaultApp: "chat",
+      });
+
+      expect(gateway).toBeInstanceOf(Gateway);
+      expect(gateway.id).toBeDefined();
+    });
+
+    it("throws if no apps provided", () => {
+      expect(() =>
+        createGateway({
+          apps: {},
+          defaultApp: "chat",
+        }),
+      ).toThrow("At least one app is required");
+    });
+
+    it("throws if default app not found", () => {
+      expect(() =>
+        createGateway({
+          apps: { chat: chatApp },
+          defaultApp: "research",
+        }),
+      ).toThrow('Default app "research" not found');
+    });
+  });
+
+  describe("start/stop", () => {
+    it("starts and stops gateway", async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp },
+        defaultApp: "chat",
+      });
+
+      await gateway.start();
+      expect(gateway.running).toBe(true);
+
+      await gateway.stop();
+      expect(gateway.running).toBe(false);
+    });
+
+    it("emits started event", async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp },
+        defaultApp: "chat",
+      });
+
+      const startedPromise = new Promise<{ port: number; host: string }>((resolve) => {
+        gateway.on("started", resolve);
+      });
+
+      await gateway.start();
+      const event = await startedPromise;
+
+      expect(event.port).toBe(TEST_PORT);
+      expect(event.host).toBe(TEST_HOST);
+    });
+
+    it("throws if started twice", async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp },
+        defaultApp: "chat",
+      });
+
+      await gateway.start();
+      await expect(gateway.start()).rejects.toThrow("already running");
+    });
+  });
+
+  describe("status", () => {
+    it("reports gateway status", async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp, research: researchApp },
+        defaultApp: "chat",
+      });
+
+      await gateway.start();
+
+      const status = gateway.status;
+      expect(status.id).toBeDefined();
+      expect(status.uptime).toBeGreaterThanOrEqual(0);
+      expect(status.clients).toBe(0);
+      expect(status.sessions).toBe(0);
+      expect(status.apps).toEqual(["chat", "research"]);
+    });
+  });
+
+  describe("client connection", () => {
+    it("accepts client and emits connected event", async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp },
+        defaultApp: "chat",
+      });
+
+      await gateway.start();
+
+      const connectedPromise = new Promise<{ clientId: string }>((resolve) => {
+        gateway.on("client:connected", resolve);
+      });
+
+      const client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((r) => client.on("open", () => r()));
+
+      const event = await connectedPromise;
+      expect(event.clientId).toBeDefined();
+
+      client.close();
+    });
+
+    it("handles client disconnect", async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp },
+        defaultApp: "chat",
+      });
+
+      await gateway.start();
+
+      const disconnectedPromise = new Promise<{ clientId: string }>((resolve) => {
+        gateway.on("client:disconnected", resolve);
+      });
+
+      const client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((r) => client.on("open", () => r()));
+
+      // Connect
+      client.send(JSON.stringify({ type: "connect", clientId: "test" }));
+      await new Promise((r) => setTimeout(r, 50));
+
+      client.close();
+
+      const event = await disconnectedPromise;
+      expect(event.clientId).toBeDefined();
+    });
+  });
+
+  describe("RPC methods", () => {
+    let client: WebSocket;
+
+    beforeEach(async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp, research: researchApp },
+        defaultApp: "chat",
+      });
+
+      await gateway.start();
+
+      client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((r) => client.on("open", () => r()));
+
+      // Authenticate
+      client.send(JSON.stringify({ type: "connect", clientId: "test" }));
+      await new Promise((r) => setTimeout(r, 50));
+    });
+
+    afterEach(() => {
+      client?.close();
+    });
+
+    it("lists apps", async () => {
+      const responsePromise = new Promise<any>((resolve) => {
+        client.on("message", (data) => {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "res") resolve(msg);
+        });
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "req",
+          id: "req-1",
+          method: "apps",
+          params: {},
+        }),
+      );
+
+      const response = await responsePromise;
+      expect(response.ok).toBe(true);
+      expect(response.payload.apps).toHaveLength(2);
+      expect(response.payload.apps[0].id).toBeDefined();
+    });
+
+    it("lists sessions", async () => {
+      const responsePromise = new Promise<any>((resolve) => {
+        client.on("message", (data) => {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "res") resolve(msg);
+        });
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "req",
+          id: "req-1",
+          method: "sessions",
+          params: {},
+        }),
+      );
+
+      const response = await responsePromise;
+      expect(response.ok).toBe(true);
+      expect(response.payload.sessions).toEqual([]);
+    });
+
+    it("returns gateway status", async () => {
+      const responsePromise = new Promise<any>((resolve) => {
+        client.on("message", (data) => {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "res") resolve(msg);
+        });
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "req",
+          id: "req-1",
+          method: "status",
+          params: {},
+        }),
+      );
+
+      const response = await responsePromise;
+      expect(response.ok).toBe(true);
+      expect(response.payload.gateway).toBeDefined();
+      expect(response.payload.gateway.apps).toContain("chat");
+    });
+
+    it("sends message to session", async () => {
+      const messages: any[] = [];
+      client.on("message", (data) => {
+        messages.push(JSON.parse(data.toString()));
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "req",
+          id: "req-1",
+          method: "send",
+          params: {
+            sessionId: "main",
+            message: "Hello!",
+          },
+        }),
+      );
+
+      // Wait for response and events
+      await new Promise((r) => setTimeout(r, 200));
+
+      const response = messages.find((m) => m.type === "res" && m.id === "req-1");
+      expect(response?.ok).toBe(true);
+      expect(response?.payload?.messageId).toBeDefined();
+
+      // Should have created a session and sent to it
+      expect(chatApp._sessions.size).toBeGreaterThan(0);
+    });
+
+    it("handles unknown method", async () => {
+      const responsePromise = new Promise<any>((resolve) => {
+        client.on("message", (data) => {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "res") resolve(msg);
+        });
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "req",
+          id: "req-1",
+          method: "unknown_method" as any,
+          params: {},
+        }),
+      );
+
+      const response = await responsePromise;
+      expect(response.ok).toBe(false);
+      expect(response.error.message).toContain("Unknown method");
+    });
+  });
+
+  describe("authentication", () => {
+    it("requires auth when configured", async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp },
+        defaultApp: "chat",
+        auth: { type: "token", token: "secret123" },
+      });
+
+      await gateway.start();
+
+      const client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((r) => client.on("open", () => r()));
+
+      const errorPromise = new Promise<any>((resolve) => {
+        client.on("message", (data) => {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "error") resolve(msg);
+        });
+      });
+
+      // Try to connect without token
+      client.send(JSON.stringify({ type: "connect", clientId: "test" }));
+
+      const error = await errorPromise;
+      expect(error.code).toBe("AUTH_FAILED");
+
+      client.close();
+    });
+
+    it("allows auth with valid token", async () => {
+      gateway = createGateway({
+        port: TEST_PORT,
+        host: TEST_HOST,
+        apps: { chat: chatApp },
+        defaultApp: "chat",
+        auth: { type: "token", token: "secret123" },
+      });
+
+      await gateway.start();
+
+      const client = new WebSocket(`ws://${TEST_HOST}:${TEST_PORT}`);
+      await new Promise<void>((r) => client.on("open", () => r()));
+
+      // Connect with valid token
+      client.send(
+        JSON.stringify({
+          type: "connect",
+          clientId: "test",
+          token: "secret123",
+        }),
+      );
+
+      // Should be able to make requests now
+      await new Promise((r) => setTimeout(r, 50));
+
+      const responsePromise = new Promise<any>((resolve) => {
+        client.on("message", (data) => {
+          const msg = JSON.parse(data.toString());
+          if (msg.type === "res") resolve(msg);
+        });
+      });
+
+      client.send(
+        JSON.stringify({
+          type: "req",
+          id: "req-1",
+          method: "apps",
+          params: {},
+        }),
+      );
+
+      const response = await responsePromise;
+      expect(response.ok).toBe(true);
+
+      client.close();
+    });
+  });
+});