@goplusvn/core 0.1.75 → 0.1.77

package/src/workspace/__tests__/workspace-member-handlers.test.ts

@@ -0,0 +1,407 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Đường GHI membership — nơi một admin khách hàng có thể tự bành trướng nếu
+// hàng rào hở.
+//
+// Mọi ca gọi thẳng handler như một client tự chế (curl), không đi qua giao diện:
+// trang có ẩn nút hay không là chuyện khác, hàng rào phải nằm ở đây. Ba đường
+// leo thang được soi riêng: hút người của tenant khác về nhánh mình (D5), tự
+// nâng chính mình (D3), và đẩy nạn nhân ra khỏi nhánh khác để chiếm (D7).
+
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { createWorkspaceMemberHandlers } from "../route-handlers";
+import { configureWorkspaces, resetWorkspaceConfig } from "../scope";
+import { subtreePrefix } from "../tree";
+
+beforeEach(() => {
+  resetWorkspaceConfig();
+});
+
+/**
+ *   grp                (tập đoàn)
+ *   ├── tanloc         (Nhà ăn Tấn Lộc — vận hành)
+ *   └── spa            (Spartronics — khách hàng)
+ *       └── spa-qc     (phòng QC của khách hàng)
+ */
+const WORKSPACES = [
+  { id: "grp", path: "/grp/" },
+  { id: "tanloc", path: "/grp/tanloc/" },
+  { id: "spa", path: "/grp/spa/" },
+  { id: "spa-qc", path: "/grp/spa/spa-qc/" },
+];
+
+interface FakeUser {
+  id: string;
+  name: string;
+  email: string;
+  isActive: boolean;
+  isProtected?: boolean;
+  permissionCeilingRoleId?: string | null;
+  workspaceIds: string[];
+}
+
+function fakeDb(users: FakeUser[]) {
+  const calls: { fn: string; args: any }[] = [];
+  const members = users.flatMap((u) =>
+    u.workspaceIds.map((workspaceId) => ({
+      userId: u.id,
+      workspaceId,
+      isAdmin: false,
+      isDefault: false,
+    })),
+  );
+
+  const findUser = (id: string) => users.find((u) => u.id === id) ?? null;
+
+  return {
+    calls,
+    members,
+    user: {
+      async findUnique(args: any) {
+        const u = findUser(args?.where?.id);
+        if (!u) return null;
+        return {
+          id: u.id,
+          isProtected: u.isProtected ?? false,
+          permissionCeilingRoleId: u.permissionCeilingRoleId ?? null,
+          userWorkspaces: members
+            .filter((m) => m.userId === u.id)
+            .map((m) => ({ workspaceId: m.workspaceId })),
+        };
+      },
+      async findMany(args: any) {
+        calls.push({ fn: "user.findMany", args });
+        // Không mô phỏng lại engine Prisma — ca kiểm tra `where` gửi xuống, còn
+        // ở đây chỉ cần trả một tập ổn định để handler chạy hết đường.
+        return users
+          .filter(
+            (u) =>
+              !members.some(
+                (m) => m.userId === u.id && m.workspaceId === "spa-qc",
+              ),
+          )
+          .map((u) => ({
+            id: u.id,
+            name: u.name,
+            email: u.email,
+            isActive: u.isActive,
+          }));
+      },
+    },
+    userWorkspace: {
+      async findMany(args: any) {
+        calls.push({ fn: "userWorkspace.findMany", args });
+        return members
+          .filter((m) => m.workspaceId === args?.where?.workspaceId)
+          .map((m) => ({
+            isAdmin: m.isAdmin,
+            isDefault: m.isDefault,
+            user: findUser(m.userId),
+          }));
+      },
+      async upsert(args: any) {
+        calls.push({ fn: "userWorkspace.upsert", args });
+        const { userId, workspaceId } = args.where.userId_workspaceId;
+        const found = members.find(
+          (m) => m.userId === userId && m.workspaceId === workspaceId,
+        );
+        if (found) Object.assign(found, args.update);
+        else members.push({ userId, workspaceId, ...args.create });
+        return { userId, workspaceId };
+      },
+      async updateMany(args: any) {
+        calls.push({ fn: "userWorkspace.updateMany", args });
+        return { count: 0 };
+      },
+      async deleteMany(args: any) {
+        calls.push({ fn: "userWorkspace.deleteMany", args });
+        const before = members.length;
+        for (let i = members.length - 1; i >= 0; i -= 1) {
+          const m = members[i];
+          if (
+            m.userId === args.where.userId &&
+            m.workspaceId === args.where.workspaceId
+          ) {
+            members.splice(i, 1);
+          }
+        }
+        return { count: before - members.length };
+      },
+    },
+    async $transaction(fn: any) {
+      return fn(this);
+    },
+  };
+}
+
+type Session = { userId: string; adminOf: string[]; viewAll?: boolean };
+
+/** Quản trị viên phía khách hàng: quản trị nhánh `spa` (và con cháu). */
+const customerAdmin: Session = { userId: "u-spa-admin", adminOf: ["spa"] };
+/** Vận hành Tấn Lộc — toàn quyền, miễn D1–D7. */
+const opsAdmin: Session = { userId: "u-ops", adminOf: [], viewAll: true };
+
+function configure(db: ReturnType<typeof fakeDb>) {
+  void db;
+  configureWorkspaces<Session>({
+    canViewAll: (session) => Boolean(session?.viewAll),
+    getUserId: (session) => session?.userId ?? null,
+    getMemberships: (session) =>
+      (session?.adminOf ?? []).map((workspaceId) => ({
+        workspaceId,
+        isAdmin: true,
+      })),
+    expandDescendants: async (rootIds) => {
+      const prefixes = WORKSPACES.filter((w) => rootIds.includes(w.id)).map(
+        (w) => subtreePrefix(w.path),
+      );
+      return WORKSPACES.filter((w) =>
+        prefixes.some((p) => w.path.startsWith(p)),
+      ).map((w) => w.id);
+    },
+  });
+}
+
+const deps = (db: any, session: Session | null) => ({
+  prisma: db,
+  getSession: () => session,
+  canManageAll: (s: Session) => Boolean(s?.viewAll),
+});
+
+const ctx = (id: string) => ({ params: { id } });
+
+const postReq = (body: unknown) =>
+  new Request("http://test/api/workspaces/x/members", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+
+const deleteReq = (userId: string) =>
+  new Request(`http://test/api/workspaces/x/members?userId=${userId}`, {
+    method: "DELETE",
+  });
+
+const baseUsers = (): FakeUser[] => [
+  {
+    id: "u-qc",
+    name: "Nhân viên QC",
+    email: "qc@spa.vn",
+    isActive: true,
+    workspaceIds: ["spa"],
+  },
+  {
+    id: "u-tanloc",
+    name: "Nhân viên Tấn Lộc",
+    email: "nv@tanloc.vn",
+    isActive: true,
+    workspaceIds: ["tanloc"],
+  },
+  {
+    id: "u-orphan",
+    name: "Chưa gán",
+    email: "orphan@x.vn",
+    isActive: true,
+    workspaceIds: [],
+  },
+  {
+    id: "u-spa-admin",
+    name: "Admin Spartronics",
+    email: "admin@spa.vn",
+    isActive: true,
+    workspaceIds: ["spa"],
+  },
+];
+
+describe("gán người vào không gian — đường hợp lệ", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  it("admin nhánh gán được người của chính nhánh mình xuống phòng ban con", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(postReq({ userId: "u-qc" }), ctx("spa-qc"));
+
+    expect(res.status).toBe(201);
+    expect(
+      db.members.some((m) => m.userId === "u-qc" && m.workspaceId === "spa-qc"),
+    ).toBe(true);
+  });
+
+  it("đặt cờ mặc định thì HẠ cờ mặc định cũ — mỗi người chỉ một không gian mặc định", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    await POST(postReq({ userId: "u-qc", isDefault: true }), ctx("spa-qc"));
+
+    const cleared = db.calls.find((c) => c.fn === "userWorkspace.updateMany");
+    expect(cleared).toBeDefined();
+    expect(cleared!.args.where).toMatchObject({
+      userId: "u-qc",
+      isDefault: true,
+      NOT: { workspaceId: "spa-qc" },
+    });
+  });
+
+  it("gán lại người đã ở trong = đổi cờ, không đẻ bản ghi trùng", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(
+      postReq({ userId: "u-qc", isAdmin: true }),
+      ctx("spa"),
+    );
+
+    expect(res.status).toBe(200);
+    expect(
+      db.members.filter((m) => m.userId === "u-qc" && m.workspaceId === "spa"),
+    ).toHaveLength(1);
+    expect(
+      db.members.find((m) => m.userId === "u-qc" && m.workspaceId === "spa")
+        ?.isAdmin,
+    ).toBe(true);
+  });
+});
+
+describe("gán người vào không gian — ba đường leo thang", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  it("D1 — không gán được vào nhánh ngoài phạm vi quản trị", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(postReq({ userId: "u-qc" }), ctx("tanloc"));
+
+    expect(res.status).toBe(403);
+    expect(
+      db.members.some((m) => m.workspaceId === "tanloc" && m.userId === "u-qc"),
+    ).toBe(false);
+  });
+
+  it("D5 — không hút được người của tenant khác về nhánh mình", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(postReq({ userId: "u-tanloc" }), ctx("spa"));
+
+    expect(res.status).toBe(403);
+    expect(await res.json()).toMatchObject({ code: "D5_NOT_FULLY_OWNED" });
+  });
+
+  it("D5 — người chưa thuộc không gian nào thì admin nhánh KHÔNG tự nhận về", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(postReq({ userId: "u-orphan" }), ctx("spa"));
+
+    expect(res.status).toBe(403);
+    expect(await res.json()).toMatchObject({ code: "D5_NOT_FULLY_OWNED" });
+  });
+
+  it("nhưng vận hành toàn quyền thì gán được người chưa thuộc đâu cả", async () => {
+    const { POST } = createWorkspaceMemberHandlers(deps(db, opsAdmin) as any);
+    const res = await POST(postReq({ userId: "u-orphan" }), ctx("spa"));
+
+    expect(res.status).toBe(201);
+  });
+
+  it("D3 — không tự sửa membership của chính mình", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(
+      postReq({ userId: "u-spa-admin", isAdmin: true }),
+      ctx("spa-qc"),
+    );
+
+    expect(res.status).toBe(403);
+    expect(await res.json()).toMatchObject({ code: "D3_SELF_ESCALATION" });
+  });
+});
+
+describe("gỡ người khỏi không gian", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  it("chặn gỡ không gian CUỐI CÙNG — gỡ xong thì chính mình cũng hết đụng được", async () => {
+    const { DELETE } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await DELETE(deleteReq("u-qc"), ctx("spa"));
+
+    expect(res.status).toBe(400);
+    expect(db.members.some((m) => m.userId === "u-qc")).toBe(true);
+  });
+
+  it("gỡ được khi người đó còn không gian khác trong phạm vi", async () => {
+    const { POST, DELETE } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    await POST(postReq({ userId: "u-qc" }), ctx("spa-qc"));
+    const res = await DELETE(deleteReq("u-qc"), ctx("spa"));
+
+    expect(res.status).toBe(200);
+    expect(
+      db.members.some((m) => m.userId === "u-qc" && m.workspaceId === "spa"),
+    ).toBe(false);
+  });
+
+  it("không gỡ được người thuộc nhánh ngoài phạm vi", async () => {
+    const { DELETE } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await DELETE(deleteReq("u-tanloc"), ctx("tanloc"));
+
+    expect(res.status).toBe(403);
+    expect(db.members.some((m) => m.userId === "u-tanloc")).toBe(true);
+  });
+});
+
+describe("tìm ứng viên để thêm", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  it("chỉ tìm trong nhánh QUẢN TRỊ được, và loại người đã ở trong", async () => {
+    const { GET } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await GET(
+      new Request("http://test/api/workspaces/x/members?candidates=1&q=nh"),
+      ctx("spa-qc"),
+    );
+    expect(res.status).toBe(200);
+
+    const call = db.calls.find((c) => c.fn === "user.findMany");
+    const and = call!.args.where.AND;
+    // Ràng buộc phạm vi phải bám `adminIds` (spa + spa-qc), KHÔNG phải allowedIds.
+    expect(JSON.stringify(and[0])).toContain("spa-qc");
+    expect(JSON.stringify(and[0])).not.toContain("tanloc");
+    expect(and[1]).toMatchObject({
+      userWorkspaces: { none: { workspaceId: "spa-qc" } },
+    });
+  });
+
+  it("người thường (không quản trị nhánh nào) không tìm được ứng viên", async () => {
+    const plain: Session = { userId: "u-plain", adminOf: [] };
+    const { GET } = createWorkspaceMemberHandlers(deps(db, plain) as any);
+    const res = await GET(
+      new Request("http://test/api/workspaces/x/members?candidates=1"),
+      ctx("spa"),
+    );
+
+    expect(res.status).toBe(403);
+  });
+});