@goplusvn/core 0.1.74 → 0.1.76

package/src/workspace/__tests__/workspace-delegation.test.ts

@@ -0,0 +1,363 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import {
+  applyPermissionCeiling,
+  assertBoundaryIntact,
+  assertCanCreateUser,
+  assertCanUpdateUser,
+  assertFullyOwned,
+  assertNotProtected,
+  assertNotSelf,
+  assertRoleAssignable,
+  assertWorkspacesInScope,
+  assignableRoles,
+  canDelegateUsers,
+  DelegationError,
+  isDangerousPermission,
+} from "../delegation";
+import {
+  configureWorkspaces,
+  createWorkspaceScope,
+  resetWorkspaceConfig,
+} from "../scope";
+import type {
+  DelegationActor,
+  DelegationRole,
+  DelegationTarget,
+} from "../delegation";
+
+/**
+ * Bối cảnh: Tấn Lộc vận hành (toàn quyền), Spartronics là khách hàng chỉ quản
+ * trị nhánh `/spa/` của mình — gồm hai phòng ban con.
+ */
+function customerAdmin(over: Partial<DelegationActor> = {}): DelegationActor {
+  return {
+    userId: "u-spa-admin",
+    scope: createWorkspaceScope({
+      canViewAll: false,
+      rootIds: ["spa"],
+      allowedIds: ["spa", "spa-qc", "spa-kho"],
+      adminIds: ["spa", "spa-qc", "spa-kho"],
+    }),
+    canManageAll: false,
+    permissions: new Set([
+      "user:view",
+      "user:create",
+      "user:update",
+      "meal-order:view",
+      "meal-order:create",
+    ]),
+    rank: 50,
+    ...over,
+  };
+}
+
+function opsAdmin(): DelegationActor {
+  return {
+    userId: "u-ops",
+    scope: createWorkspaceScope({ canViewAll: true }),
+    canManageAll: true,
+    permissions: new Set(),
+    rank: 0,
+  };
+}
+
+function target(over: Partial<DelegationTarget> = {}): DelegationTarget {
+  return { id: "u-nv", workspaceIds: ["spa-qc"], ...over };
+}
+
+function role(over: Partial<DelegationRole> = {}): DelegationRole {
+  return {
+    id: "r-nv",
+    code: "NHAN_VIEN",
+    rank: 100,
+    permissions: ["meal-order:view", "meal-order:create"],
+    ...over,
+  };
+}
+
+beforeEach(() => {
+  resetWorkspaceConfig();
+  configureWorkspaces({ getUserId: () => undefined, canViewAll: () => false });
+});
+
+describe("D1 — chứa trong nhánh", () => {
+  it("gán trong nhánh mình thì qua", () => {
+    expect(() =>
+      assertWorkspacesInScope(customerAdmin(), ["spa-qc", "spa-kho"]),
+    ).not.toThrow();
+  });
+
+  it("gán workspace ngoài nhánh thì NÉM, không lặng lẽ cắt bớt", () => {
+    try {
+      assertWorkspacesInScope(customerAdmin(), ["spa-qc", "tanloc"]);
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect(error).toBeInstanceOf(DelegationError);
+      expect((error as DelegationError).code).toBe("D1_OUT_OF_SCOPE");
+      expect((error as DelegationError).message).toContain("tanloc");
+    }
+  });
+
+  it("người không được uỷ quyền ở đâu cả thì chặn ngay", () => {
+    const nobody = customerAdmin({
+      scope: createWorkspaceScope({
+        canViewAll: false,
+        rootIds: ["spa"],
+        allowedIds: ["spa"],
+        adminIds: [],
+      }),
+    });
+    expect(() => assertWorkspacesInScope(nobody, ["spa"])).toThrow(
+      /không được uỷ quyền/,
+    );
+    expect(canDelegateUsers(nobody)).toBe(false);
+  });
+
+  it("toàn quyền đi qua mọi thứ", () => {
+    expect(() =>
+      assertWorkspacesInScope(opsAdmin(), ["bat-ky", "cai-gi-do"]),
+    ).not.toThrow();
+    expect(canDelegateUsers(opsAdmin())).toBe(true);
+  });
+});
+
+describe("D3 — không tự nâng", () => {
+  it("sửa chính mình thì chặn", () => {
+    expect(() => assertNotSelf(customerAdmin(), "u-spa-admin")).toThrow(
+      DelegationError,
+    );
+  });
+
+  it("sửa người khác thì qua", () => {
+    expect(() => assertNotSelf(customerAdmin(), "u-nv")).not.toThrow();
+  });
+
+  it("toàn quyền tự sửa mình được", () => {
+    expect(() => assertNotSelf(opsAdmin(), "u-ops")).not.toThrow();
+  });
+});
+
+describe("D5 — sửa được thì phải sở hữu TRỌN", () => {
+  it("mọi membership nằm trong nhánh thì qua", () => {
+    expect(() =>
+      assertFullyOwned(customerAdmin(), target({ workspaceIds: ["spa-qc"] })),
+    ).not.toThrow();
+  });
+
+  it("người VẮT ra ngoài nhánh: đọc được, sửa KHÔNG được", () => {
+    try {
+      assertFullyOwned(
+        customerAdmin(),
+        target({ workspaceIds: ["spa-qc", "tanloc"] }),
+      );
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D5_NOT_FULLY_OWNED");
+    }
+  });
+
+  it("người chưa thuộc không gian nào thì không ai ngoài toàn quyền đụng được", () => {
+    expect(() =>
+      assertFullyOwned(customerAdmin(), target({ workspaceIds: [] })),
+    ).toThrow(DelegationError);
+    expect(() =>
+      assertFullyOwned(opsAdmin(), target({ workspaceIds: [] })),
+    ).not.toThrow();
+  });
+});
+
+describe("D6 — tài khoản được bảo vệ", () => {
+  it("chặn dù CÙNG workspace và D5 đã thoả", () => {
+    const protectedOps = target({
+      id: "u-ops-support",
+      workspaceIds: ["spa-qc"],
+      isProtected: true,
+    });
+    // D5 qua…
+    expect(() => assertFullyOwned(customerAdmin(), protectedOps)).not.toThrow();
+    // …nhưng D6 chặn. Đây chính là lỗ mà D5 một mình không bịt được.
+    expect(() => assertNotProtected(customerAdmin(), protectedOps)).toThrow(
+      DelegationError,
+    );
+  });
+
+  it("toàn quyền vẫn thao tác được", () => {
+    expect(() =>
+      assertNotProtected(opsAdmin(), target({ isProtected: true })),
+    ).not.toThrow();
+  });
+});
+
+describe("D2 + D4 — vai trò gán được", () => {
+  it("vai trò nằm trọn trong quyền của mình và rank thấp hơn thì qua", () => {
+    expect(() => assertRoleAssignable(customerAdmin(), role())).not.toThrow();
+  });
+
+  it("vai trò chứa quyền mình KHÔNG có thì chặn (trần quyền)", () => {
+    expect(() =>
+      assertRoleAssignable(
+        customerAdmin(),
+        role({ permissions: ["meal-order:view", "payment:approve"] }),
+      ),
+    ).toThrow(/payment:approve/);
+  });
+
+  it("vai trò chứa action nguy hiểm thì chặn KỂ CẢ khi trần quyền thoả", () => {
+    const actor = customerAdmin({
+      permissions: new Set(["role:update", "user:view"]),
+    });
+    try {
+      assertRoleAssignable(actor, role({ permissions: ["role:update"] }));
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D4_DANGEROUS_ROLE");
+    }
+  });
+
+  it("hậu tố view-all-* là nguy hiểm bất kể resource nào mang nó", () => {
+    expect(isDangerousPermission("user:view-all-workspaces")).toBe(true);
+    expect(isDangerousPermission("sales-order:view-all-branches")).toBe(true);
+    expect(isDangerousPermission("meal-order:view")).toBe(false);
+  });
+
+  it("vai trò hệ thống thì chặn", () => {
+    expect(() =>
+      assertRoleAssignable(customerAdmin(), role({ isSystem: true })),
+    ).toThrow(/vai trò hệ thống/);
+  });
+
+  it("vai trò ngang hoặc cao hơn cấp mình thì chặn", () => {
+    expect(() =>
+      assertRoleAssignable(customerAdmin(), role({ rank: 50 })),
+    ).toThrow(/ngang hoặc cao hơn/);
+    expect(() =>
+      assertRoleAssignable(customerAdmin(), role({ rank: 10 })),
+    ).toThrow(/ngang hoặc cao hơn/);
+  });
+
+  it("vai trò thuộc nhánh khác thì chặn", () => {
+    expect(() =>
+      assertRoleAssignable(customerAdmin(), role({ workspaceId: "tanloc" })),
+    ).toThrow(/ngoài phạm vi/);
+  });
+
+  it("assignableRoles lọc đúng cái picker được phép hiện", () => {
+    const roles = [
+      role({ id: "ok", code: "NV" }),
+      role({ id: "cao", code: "QL", rank: 10 }),
+      role({ id: "nguy", code: "ADMIN", permissions: ["role:update"] }),
+      role({ id: "vuot", code: "KT", permissions: ["payment:approve"] }),
+    ];
+    expect(assignableRoles(customerAdmin(), roles).map((r) => r.id)).toEqual([
+      "ok",
+    ]);
+    expect(assignableRoles(opsAdmin(), roles)).toHaveLength(4);
+  });
+});
+
+describe("D2 bản CHẠY — trần quyền là phép GIAO", () => {
+  it("không có trần thì giữ nguyên quyền vai trò", () => {
+    expect(applyPermissionCeiling(["a:x", "b:y"], null)).toEqual([
+      "a:x",
+      "b:y",
+    ]);
+    expect(applyPermissionCeiling(["a:x"], undefined)).toEqual(["a:x"]);
+  });
+
+  it("có trần thì cắt phần vượt", () => {
+    expect(applyPermissionCeiling(["a:x", "b:y"], ["a:x", "c:z"])).toEqual([
+      "a:x",
+    ]);
+  });
+
+  it("trần rỗng khác trần null: rỗng = không còn quyền nào", () => {
+    expect(applyPermissionCeiling(["a:x"], [])).toEqual([]);
+  });
+});
+
+describe("D7 — không tháo được rào", () => {
+  const base = target({
+    workspaceIds: ["spa-qc"],
+    permissionCeilingRoleId: "r-tran",
+    isProtected: false,
+  });
+
+  it("sửa trần quyền của người khác thì chặn", () => {
+    expect(() =>
+      assertBoundaryIntact(customerAdmin(), base, {
+        permissionCeilingRoleId: null,
+      }),
+    ).toThrow(/trần quyền/);
+  });
+
+  it("gửi lại đúng giá trị cũ thì không tính là sửa", () => {
+    expect(() =>
+      assertBoundaryIntact(customerAdmin(), base, {
+        permissionCeilingRoleId: "r-tran",
+      }),
+    ).not.toThrow();
+  });
+
+  it("tự bật cờ bảo vệ thì chặn", () => {
+    expect(() =>
+      assertBoundaryIntact(customerAdmin(), base, { isProtected: true }),
+    ).toThrow(/trạng thái bảo vệ/);
+  });
+
+  it("gỡ membership NGOÀI nhánh để đẩy nạn nhân ra rồi thao tác tiếp → chặn", () => {
+    const crossed = target({ workspaceIds: ["spa-qc", "tanloc"] });
+    try {
+      assertBoundaryIntact(customerAdmin(), crossed, {
+        workspaceIds: ["spa-qc"],
+      });
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D7_BOUNDARY_TAMPER");
+    }
+  });
+
+  it("gỡ membership TRONG nhánh mình thì được", () => {
+    const both = target({ workspaceIds: ["spa-qc", "spa-kho"] });
+    expect(() =>
+      assertBoundaryIntact(customerAdmin(), both, { workspaceIds: ["spa-qc"] }),
+    ).not.toThrow();
+  });
+});
+
+describe("cổng tổng hợp", () => {
+  it("assertCanUpdateUser chạy đủ D3/D5/D6/D7/D1", () => {
+    const actor = customerAdmin();
+    expect(() =>
+      assertCanUpdateUser(actor, target(), { workspaceIds: ["spa-kho"] }),
+    ).not.toThrow();
+
+    // D3
+    expect(() =>
+      assertCanUpdateUser(actor, target({ id: actor.userId })),
+    ).toThrow(/chính mình/);
+    // D6 chạy TRƯỚC D5 — thông báo phải nói về tài khoản bảo vệ, không phải phạm vi
+    expect(() =>
+      assertCanUpdateUser(actor, target({ isProtected: true })),
+    ).toThrow(/được bảo vệ/);
+    // D1 trên danh sách mới
+    expect(() =>
+      assertCanUpdateUser(actor, target(), { workspaceIds: ["tanloc"] }),
+    ).toThrow(DelegationError);
+  });
+
+  it("assertCanCreateUser bắt buộc chọn ít nhất một không gian trong nhánh", () => {
+    const actor = customerAdmin();
+    expect(() =>
+      assertCanCreateUser(actor, ["spa-qc"], [role()]),
+    ).not.toThrow();
+    expect(() => assertCanCreateUser(actor, [])).toThrow(
+      /ít nhất một không gian/,
+    );
+    expect(() =>
+      assertCanCreateUser(actor, ["spa-qc"], [role({ rank: 10 })]),
+    ).toThrow(DelegationError);
+    // Toàn quyền được phép tạo user chưa gắn không gian nào.
+    expect(() => assertCanCreateUser(opsAdmin(), [])).not.toThrow();
+  });
+});