feat: convert network-topology to a full plugin (B1)

plugins/network-topology/tests/backend/routes.test.ts

@@ -1,154 +1,81 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { Request, Response, Router } from "express";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { startServer, type TestServer } from "./helpers";
 
-const state = vi.hoisted(() => ({
-  currentUserId: "user-1" as string | undefined,
-  records: new Map<string, { userId: string; topology: string | null }>(),
-}));
+let server: TestServer;
 
-vi.mock("../../../../src/backend/database/db/index.js", () => ({ db: {} }));
-
-vi.mock("../../../../src/backend/utils/logger.js", () => ({
-  databaseLogger: {
-    error: vi.fn(),
-    warn: vi.fn(),
-    info: vi.fn(),
-    success: vi.fn(),
-  },
-}));
-
-vi.mock("../../../../src/backend/utils/auth-manager.js", () => ({
-  AuthManager: {
-    getInstance: () => ({
-      createAuthMiddleware:
-        () =>
-        (req: Record<string, unknown>, _res: unknown, next: () => void) => {
-          req.userId = state.currentUserId;
-          next();
-        },
-    }),
-  },
-}));
-
-vi.mock("../../../../src/backend/database/repositories/factory.js", () => ({
-  createCurrentNetworkTopologyRepository: () => ({
-    findByUserId: async (userId: string) => state.records.get(userId) ?? null,
-    upsertForUser: async (userId: string, topology: string) => {
-      state.records.set(userId, { userId, topology });
-    },
-  }),
-}));
-
-vi.mock(
-  "../../../../src/backend/database/routes/network-topology-dispatch.js",
-  () => ({
-    registerNetworkTopologyRouter: vi.fn(),
-    unregisterNetworkTopologyRouter: vi.fn(),
-  }),
-);
-
-const { router } = await import("../../src/backend/routes.js");
-
-function findLayer(method: string, path: string) {
-  const stack = (router as unknown as Router).stack as Array<{
-    route?: {
-      path: string;
-      methods: Record<string, boolean>;
-      stack: Array<{ handle: (req: Request, res: Response) => unknown }>;
-    };
-  }>;
-  const layer = stack.find(
-    (l) => l.route?.path === path && l.route?.methods[method],
-  );
-  if (!layer?.route) throw new Error(`No route for ${method} ${path}`);
-  return layer.route.stack[layer.route.stack.length - 1].handle;
-}
-
-function makeReqRes(overrides: { body?: Record<string, unknown> }) {
-  const req = {
-    userId: state.currentUserId,
-    body: overrides.body ?? {},
-    headers: {},
-  } as unknown as Request;
-
-  const res = {
-    statusCode: 200,
-    jsonBody: null as unknown,
-    status(code: number) {
-      (this as unknown as { statusCode: number }).statusCode = code;
-      return this;
-    },
-    json(payload: unknown) {
-      (this as unknown as { jsonBody: unknown }).jsonBody = payload;
-      return this;
-    },
-  } as unknown as Response & { statusCode: number; jsonBody: unknown };
-
-  return { req, res };
-}
-
-async function invoke(
-  method: string,
-  path: string,
-  overrides: { body?: Record<string, unknown> } = {},
-) {
-  const handler = findLayer(method, path);
-  const { req, res } = makeReqRes(overrides);
-  await handler(req, res);
-  return res as unknown as {
-    statusCode: number;
-    jsonBody: Record<string, unknown> | null;
-  };
-}
-
-beforeEach(() => {
-  state.currentUserId = "user-1";
-  state.records = new Map();
+beforeEach(async () => {
+  server = await startServer();
 });
 
-describe("GET /network-topology", () => {
+afterEach(async () => {
+  await server.close();
+});
+
+describe("GET /", () => {
   it("returns null when the user has no saved topology", async () => {
-    const res = await invoke("get", "/");
-    expect(res.jsonBody).toBeNull();
+    const res = await server.request("GET", "/");
+    expect(res.status).toBe(200);
+    expect(res.body).toBeNull();
   });
 
-  it("returns the parsed topology when one exists", async () => {
-    state.records.set("user-1", {
-      userId: "user-1",
-      topology: JSON.stringify({ nodes: [{ id: "host-1" }], edges: [] }),
+  it("returns the saved topology", async () => {
+    await server.request("POST", "/", {
+      body: { topology: { nodes: [{ data: { id: "host-1" } }], edges: [] } },
     });
 
-    const res = await invoke("get", "/");
-    expect(res.jsonBody).toEqual({ nodes: [{ id: "host-1" }], edges: [] });
+    const res = await server.request("GET", "/");
+    expect(res.body).toEqual({
+      nodes: [{ data: { id: "host-1" } }],
+      edges: [],
+    });
   });
 
-  it("rejects an unauthenticated request", async () => {
-    state.currentUserId = undefined;
-    const res = await invoke("get", "/");
-    expect(res.statusCode).toBe(401);
+  it("keeps each user's topology separate", async () => {
+    await server.request("POST", "/", {
+      user: "user-1",
+      body: { topology: { nodes: [{ data: { id: "a" } }], edges: [] } },
+    });
+
+    const res = await server.request("GET", "/", { user: "user-2" });
+    expect(res.body).toBeNull();
   });
 });
 
-describe("POST /network-topology", () => {
-  it("saves the topology and returns success", async () => {
-    const res = await invoke("post", "/", {
+describe("POST /", () => {
+  it("saves and overwrites the topology", async () => {
+    const first = await server.request("POST", "/", {
       body: { topology: { nodes: [], edges: [] } },
     });
+    expect(first.body).toEqual({ success: true });
 
-    expect(res.jsonBody).toEqual({ success: true });
-    expect(state.records.get("user-1")?.topology).toBe(
-      JSON.stringify({ nodes: [], edges: [] }),
-    );
+    await server.request("POST", "/", {
+      body: { topology: { nodes: [{ data: { id: "a" } }], edges: [] } },
+    });
+
+    const res = await server.request("GET", "/");
+    expect(res.body).toEqual({ nodes: [{ data: { id: "a" } }], edges: [] });
   });
 
   it("rejects a request with no topology", async () => {
-    const res = await invoke("post", "/", { body: {} });
-    expect(res.statusCode).toBe(400);
+    const res = await server.request("POST", "/", { body: {} });
+    expect(res.status).toBe(400);
   });
+});
 
-  it("rejects an unauthenticated request", async () => {
-    state.currentUserId = undefined;
-    const res = await invoke("post", "/", { body: { topology: {} } });
-    expect(res.statusCode).toBe(401);
+describe("permissions", () => {
+  it("refuses every route without network-topology.use", async () => {
+    const denied = await startServer({ permissions: [] });
+    try {
+      expect((await denied.request("GET", "/")).status).toBe(403);
+      expect(
+        (
+          await denied.request("POST", "/", {
+            body: { topology: { nodes: [], edges: [] } },
+          })
+        ).status,
+      ).toBe(403);
+    } finally {
+      await denied.close();
+    }
   });
 });