Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

39.1 KB
Raw Blame
import { randomUUID } from "node:crypto";
import { and, eq, inArray } from "drizzle-orm";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";
import db, { schema } from "../../apps/api/src/database";
import { createApp } from "../../apps/api/src/index";
import { mockAuthenticatedSession } from "./helpers/auth";
import { resetTestDatabase } from "./helpers/database";
import {
  createProjectFixture,
  createWorkspaceMember,
} from "./helpers/fixtures";
import { readErrorBody } from "./helpers/error-body";

// Assignment notifications run in the background and can otherwise race the
// next test's TRUNCATE. Notification access/delivery has its own DB suite;
// these tests exercise the real authorization and resource mutations.
vi.mock(
  "../../apps/api/src/notification/controllers/create-notification",
  () => ({
    default: vi.fn(async () => null),
  }),
);

type CreateTaskBody = {
  title: string;
  description: string;
  priority: "low" | "medium" | "high";
  status: string;
};

async function seedTask(
  projectId: string,
  columnId: string | null,
  userId?: string,
  status = "to-do",
) {
  const [task] = await db
    .insert(schema.taskTable)
    .values({
      projectId,
      title: "Seeded task",
      description: "Existing",
      priority: "medium",
      status,
      columnId,
      number: 1,
      position: 1,
      ...(userId ? { userId } : {}),
    })
    .returning();
  return task;
}

async function createWorkspaceRoleRow(
  workspaceId: string,
  role: string,
  permission: Record<string, string[]> | string,
) {
  await db.insert(schema.workspaceRoleTable).values({
    workspaceId,
    role,
    permission:
      typeof permission === "string" ? permission : JSON.stringify(permission),
  });
}

async function postCreateTask(
  app: ReturnType<typeof createApp>["app"],
  projectId: string,
  body: Partial<CreateTaskBody> = {},
) {
  return app.request(`/api/task/${projectId}`, {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({
      title: "RBAC probe",
      description: "",
      priority: "low",
      status: "to-do",
      ...body,
    }),
  });
}

describe("API integration: workspace RBAC enforcement", () => {
  beforeEach(async () => {
    await resetTestDatabase();
  });

  describe("built-in roles", () => {
    it("allows a member to create a task (member role grants task:create)", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(200);
    });

    it("blocks a viewer from creating a task (viewer role lacks task:create)", async () => {
      const member = await createWorkspaceMember({ role: "viewer" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(403);
      expect(await readErrorBody(response)).toEqual({
        message: "Insufficient permissions",
        code: "MISSING_PERMISSION",
        missingPermissions: ["task:create"],
      });

      const persisted = await db.query.taskTable.findFirst({
        where: and(
          eq(schema.taskTable.projectId, project.id),
          eq(schema.taskTable.title, "RBAC probe"),
        ),
      });
      expect(persisted).toBeUndefined();
    });

    it("blocks a member from deleting a task (member role lacks task:delete)", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/${task.id}`, {
        method: "DELETE",
      });
      expect(response.status).toBe(403);

      const stillThere = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(stillThere).toBeDefined();
    });

    it("allows an admin to delete a task (admin role grants task:delete)", async () => {
      const member = await createWorkspaceMember({ role: "admin" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/${task.id}`, {
        method: "DELETE",
      });
      expect(response.status).toBe(200);

      const gone = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(gone).toBeUndefined();
    });

    it.each([
      ["To Do", "to-do", "todo"],
      ["In Progress", "in-progress", "inProgress"],
      ["In Review", "in-review", "inReview"],
      ["Done", "done", "done"],
    ] as const)(
      "allows an owner to delete a task from %s",
      async (_label, status, columnKey) => {
        const member = await createWorkspaceMember({ role: "owner" });
        const { project, columns } = await createProjectFixture({
          workspaceId: member.workspace.id,
        });
        const task = await seedTask(
          project.id,
          columns[columnKey].id,
          undefined,
          status,
        );

        mockAuthenticatedSession(member.user);
        const { app } = createApp();

        const response = await app.request(`/api/task/${task.id}`, {
          method: "DELETE",
        });
        expect(response.status).toBe(200);
        await expect(response.json()).resolves.toMatchObject({
          id: task.id,
          status,
        });

        const deletedTask = await db.query.taskTable.findFirst({
          where: eq(schema.taskTable.id, task.id),
        });
        expect(deletedTask).toBeUndefined();
      },
    );

    it("returns 404 when the user has no row in workspace_member for the workspace", async () => {
      const member = await createWorkspaceMember({ role: "admin" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });

      const outsiderId = `user-${randomUUID()}`;
      const [outsider] = await db
        .insert(schema.userTable)
        .values({
          id: outsiderId,
          email: `${outsiderId}@example.com`,
          emailVerified: true,
          name: "Outsider",
        })
        .returning();

      mockAuthenticatedSession(outsider);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      // workspaceAccess.fromProject runs first and rejects with its own message
      expect(response.status).toBe(404);
      expect(await response.text()).toContain("Project not found");
    });

    it("does not authorize a project through a conflicting workspaceId query", async () => {
      const attacker = await createWorkspaceMember({ role: "admin" });
      const victim = await createWorkspaceMember({ role: "admin" });
      const { project } = await createProjectFixture({
        workspaceId: victim.workspace.id,
      });

      mockAuthenticatedSession(attacker.user);
      const { app } = createApp();

      const response = await app.request(
        `/api/task/${project.id}?workspaceId=${attacker.workspace.id}`,
        {
          method: "POST",
          headers: { "content-type": "application/json" },
          body: JSON.stringify({
            title: "Cross-workspace probe",
            description: "",
            priority: "low",
            status: "to-do",
          }),
        },
      );

      expect(response.status).toBe(404);
    });
  });

  describe("bulk task mutations", () => {
    it("blocks a viewer from changing task priority in bulk", async () => {
      const viewer = await createWorkspaceMember({ role: "viewer" });
      const { project, columns } = await createProjectFixture({
        workspaceId: viewer.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(viewer.user);
      const { app } = createApp();

      const response = await app.request("/api/task/bulk", {
        method: "PATCH",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          taskIds: [task.id],
          operation: "updatePriority",
          value: "high",
        }),
      });
      expect(response.status).toBe(403);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted?.priority).toBe("medium");
    });

    it("allows a member to change task priority in bulk", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/task/bulk", {
        method: "PATCH",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          taskIds: [task.id],
          operation: "updatePriority",
          value: "high",
        }),
      });
      expect(response.status).toBe(200);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted?.priority).toBe("high");
    });

    it("preserves the not-found response for unknown tasks", async () => {
      const member = await createWorkspaceMember({ role: "member" });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/task/bulk", {
        method: "PATCH",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          taskIds: [randomUUID()],
          operation: "updatePriority",
          value: "high",
        }),
      });
      expect(response.status).toBe(404);
    });

    it("rejects bulk mutations that span workspaces", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const foreign = await createWorkspaceMember({ role: "admin" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const { project: foreignProject, columns: foreignColumns } =
        await createProjectFixture({
          workspaceId: foreign.workspace.id,
        });
      const task = await seedTask(project.id, columns.todo.id);
      const foreignTask = await seedTask(
        foreignProject.id,
        foreignColumns.todo.id,
      );

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/task/bulk", {
        method: "PATCH",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          taskIds: [task.id, foreignTask.id],
          operation: "updatePriority",
          value: "high",
        }),
      });
      expect(response.status).toBe(400);

      const persistedTasks = await db
        .select({ priority: schema.taskTable.priority })
        .from(schema.taskTable)
        .where(inArray(schema.taskTable.id, [task.id, foreignTask.id]));
      expect(persistedTasks).toHaveLength(2);
      expect(persistedTasks.every((task) => task.priority === "medium")).toBe(
        true,
      );
    });

    it("blocks a member from deleting a task in bulk", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/task/bulk", {
        method: "PATCH",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({ taskIds: [task.id], operation: "delete" }),
      });
      expect(response.status).toBe(403);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted).toBeDefined();
    });

    it("blocks a member from assigning a task in bulk", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/task/bulk", {
        method: "PATCH",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          taskIds: [task.id],
          operation: "updateAssignee",
          value: member.user.id,
        }),
      });
      expect(response.status).toBe(403);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted?.userId).toBeNull();
    });

    it("allows an admin to assign a task in bulk", async () => {
      const admin = await createWorkspaceMember({ role: "admin" });
      const { project, columns } = await createProjectFixture({
        workspaceId: admin.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(admin.user);
      const { app } = createApp();

      const response = await app.request("/api/task/bulk", {
        method: "PATCH",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          taskIds: [task.id],
          operation: "updateAssignee",
          value: admin.user.id,
        }),
      });
      expect(response.status).toBe(200);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted?.userId).toBe(admin.user.id);
    });

    it("does not copy a label from another workspace in bulk", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const foreign = await createWorkspaceMember({ role: "admin" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);
      const [foreignLabel] = await db
        .insert(schema.labelTable)
        .values({
          name: "private",
          color: "#000000",
          workspaceId: foreign.workspace.id,
        })
        .returning();

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/task/bulk", {
        method: "PATCH",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          taskIds: [task.id],
          operation: "addLabel",
          value: foreignLabel.id,
        }),
      });
      expect(response.status).toBe(400);

      const copiedLabel = await db.query.labelTable.findFirst({
        where: and(
          eq(schema.labelTable.taskId, task.id),
          eq(schema.labelTable.name, foreignLabel.name),
        ),
      });
      expect(copiedLabel).toBeUndefined();
    });
  });

  describe("custom workspace roles", () => {
    it("blocks a custom role that only grants task:read from creating a task", async () => {
      const member = await createWorkspaceMember({ role: "readonly" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      await createWorkspaceRoleRow(member.workspace.id, "readonly", {
        task: ["read"],
        project: ["read"],
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(403);
    });

    it("allows a custom role that grants task:create to create a task", async () => {
      const member = await createWorkspaceMember({ role: "creator" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      await createWorkspaceRoleRow(member.workspace.id, "creator", {
        task: ["create", "read"],
        project: ["read"],
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(200);
    });

    it("lets a workspace_role row override the built-in viewer permissions", async () => {
      // viewer's compiled-in statements have no task:create. A workspace_role
      // row for "viewer" with task:create should override and grant access.
      const member = await createWorkspaceMember({ role: "viewer" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      await createWorkspaceRoleRow(member.workspace.id, "viewer", {
        task: ["create", "read", "update"],
        project: ["read"],
        workspace: ["read"],
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(200);
    });

    it("returns 403 when the workspace_role permission JSON is malformed", async () => {
      const member = await createWorkspaceMember({ role: "broken" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      // Malformed permission payload. The middleware should refuse rather than
      // crash; with no built-in fallback for "broken", access is denied.
      await createWorkspaceRoleRow(member.workspace.id, "broken", "not-json");

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(403);
    });

    it("drops malformed permission entries instead of throwing", async () => {
      const member = await createWorkspaceMember({ role: "partial" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      // Some entries are valid string arrays, others are objects/strings/etc.
      // Middleware keeps the valid ones and ignores the rest.
      await createWorkspaceRoleRow(
        member.workspace.id,
        "partial",
        JSON.stringify({
          task: ["create"],
          project: "not-an-array",
          weird: { nested: true },
        }),
      );

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(200);
    });

    it("allows a member with several roles when any role grants the permission", async () => {
      const member = await createWorkspaceMember({ role: "readonly,member" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      await createWorkspaceRoleRow(member.workspace.id, "readonly", {
        task: ["read"],
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(200);
    });

    it("blocks a member with several roles when no role grants the permission", async () => {
      const member = await createWorkspaceMember({ role: "readonly,viewer" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      await createWorkspaceRoleRow(member.workspace.id, "readonly", {
        task: ["read"],
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(403);
      expect(await readErrorBody(response)).toEqual({
        message: "Insufficient permissions",
        code: "MISSING_PERMISSION",
        missingPermissions: ["task:create"],
      });
    });

    it("allows a role when any duplicate workspace_role row grants the permission", async () => {
      const member = await createWorkspaceMember({ role: "creator" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      await createWorkspaceRoleRow(member.workspace.id, "creator", {
        task: ["read"],
        project: ["read"],
      });
      await createWorkspaceRoleRow(member.workspace.id, "creator", {
        task: ["create", "read"],
        project: ["read"],
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(200);
    });

    it("falls back to built-in role when no workspace_role row exists for the name", async () => {
      // No workspace_role row, role is the compiled-in "admin"; should work.
      const member = await createWorkspaceMember({ role: "admin" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(200);
    });
  });

  describe("resource coverage: task:update", () => {
    it("allows a member to update a task", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/${task.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          title: "Updated by member",
          description: "edit",
          priority: "high",
          status: "to-do",
          projectId: project.id,
          position: 1,
        }),
      });
      expect(response.status).toBe(200);
    });

    it("allows a member to update an assigned task without changing its assignee", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id, member.user.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/${task.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          title: "Updated by member",
          description: "edit",
          priority: "high",
          status: "to-do",
          projectId: project.id,
          position: 1,
          userId: member.user.id,
        }),
      });
      expect(response.status).toBe(200);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted?.title).toBe("Updated by member");
      expect(persisted?.userId).toBe(member.user.id);
    });

    it("blocks a member from assigning an unassigned task through full update", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/${task.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          title: "Member attempt",
          description: "nope",
          priority: "low",
          status: "to-do",
          projectId: project.id,
          position: 1,
          userId: member.user.id,
        }),
      });
      expect(response.status).toBe(403);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted?.userId).toBeNull();
    });

    it("blocks a member from unassigning a task through full update", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id, member.user.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/${task.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          title: "Member attempt",
          description: "nope",
          priority: "low",
          status: "to-do",
          projectId: project.id,
          position: 1,
          userId: "",
        }),
      });
      expect(response.status).toBe(403);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted?.userId).toBe(member.user.id);
    });

    it("allows an admin to assign a task through full update", async () => {
      const admin = await createWorkspaceMember({ role: "admin" });
      const { project, columns } = await createProjectFixture({
        workspaceId: admin.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(admin.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/${task.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          title: "Assigned by admin",
          description: "",
          priority: "medium",
          status: "to-do",
          projectId: project.id,
          position: 1,
          userId: admin.user.id,
        }),
      });
      expect(response.status).toBe(200);

      const persisted = await db.query.taskTable.findFirst({
        where: eq(schema.taskTable.id, task.id),
      });
      expect(persisted?.userId).toBe(admin.user.id);
    });

    it("blocks a viewer from updating a task", async () => {
      const member = await createWorkspaceMember({ role: "viewer" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/${task.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          title: "Viewer attempt",
          description: "nope",
          priority: "low",
          status: "to-do",
          projectId: project.id,
          position: 1,
        }),
      });
      expect(response.status).toBe(403);
    });
  });

  describe("resource coverage: task:assign", () => {
    it("blocks a member from assigning a task (assign is admin-tier)", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/assignee/${task.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({ userId: member.user.id }),
      });
      expect(response.status).toBe(403);
    });

    it("allows an admin to assign a task", async () => {
      const member = await createWorkspaceMember({ role: "admin" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/task/assignee/${task.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({ userId: member.user.id }),
      });
      expect(response.status).toBe(200);
    });
  });

  describe("resource coverage: project:create / update / delete", () => {
    it("allows a member to create a project", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/project", {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          name: "Member-made",
          workspaceId: member.workspace.id,
          slug: "MEM",
          icon: "Folder",
        }),
      });
      expect(response.status).toBe(200);
    });

    it("blocks a viewer from creating a project", async () => {
      const member = await createWorkspaceMember({ role: "viewer" });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/project", {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          name: "Viewer attempt",
          workspaceId: member.workspace.id,
          slug: "VWR",
          icon: "Folder",
        }),
      });
      expect(response.status).toBe(403);
    });

    it("blocks a member from updating a project (project:update is admin-tier)", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/project/${project.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          name: "Member-rename",
          icon: "Folder",
          slug: project.slug,
          description: "",
          isPublic: false,
        }),
      });
      expect(response.status).toBe(403);
    });

    it("allows an admin to update a project", async () => {
      const member = await createWorkspaceMember({ role: "admin" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/project/${project.id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          name: "Admin-rename",
          icon: "Folder",
          slug: project.slug,
          description: "",
          isPublic: false,
        }),
      });
      expect(response.status).toBe(200);
    });

    it("blocks a member from deleting a project (project:delete is admin-tier)", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/project/${project.id}`, {
        method: "DELETE",
      });
      expect(response.status).toBe(403);
    });

    it("allows an admin to delete a project", async () => {
      const member = await createWorkspaceMember({ role: "admin" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/project/${project.id}`, {
        method: "DELETE",
      });
      expect(response.status).toBe(200);
    });
  });

  describe("resource coverage: label:create / delete", () => {
    it("allows a member to create a label", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/label", {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          name: "bug",
          color: "#ff0000",
          workspaceId: member.workspace.id,
        }),
      });
      expect(response.status).toBe(200);
    });

    it("blocks a viewer from creating a label", async () => {
      const member = await createWorkspaceMember({ role: "viewer" });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request("/api/label", {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          name: "nope",
          color: "#000000",
          workspaceId: member.workspace.id,
        }),
      });
      expect(response.status).toBe(403);
    });

    it("allows a member to delete a label", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);
      // deleteLabel requires the label to be attached to a task; without a
      // taskId the controller rejects with 400 before checking permissions.
      const [label] = await db
        .insert(schema.labelTable)
        .values({
          name: "scratch",
          color: "#abcdef",
          workspaceId: member.workspace.id,
          taskId: task.id,
        })
        .returning();

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/label/${label.id}`, {
        method: "DELETE",
      });
      expect(response.status).toBe(200);
    });

    it("blocks a viewer from deleting a label", async () => {
      const member = await createWorkspaceMember({ role: "viewer" });
      const { project, columns } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      const task = await seedTask(project.id, columns.todo.id);
      const [label] = await db
        .insert(schema.labelTable)
        .values({
          name: "scratch",
          color: "#abcdef",
          workspaceId: member.workspace.id,
          taskId: task.id,
        })
        .returning();

      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(`/api/label/${label.id}`, {
        method: "DELETE",
      });
      expect(response.status).toBe(403);
    });
  });

  describe("resource coverage: workspace:manage_settings", () => {
    // The integration endpoints (slack/discord/etc.) all gate on
    // workspace:manage_settings. Use Slack as the canonical surface; the
    // 403 fires in middleware before the handler ever tries to call out.
    it("blocks a member from creating a Slack integration", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(
        `/api/slack-integration/project/${project.id}`,
        {
          method: "POST",
          headers: { "content-type": "application/json" },
          body: JSON.stringify({
            webhookUrl: "https://hooks.slack.com/services/x/y/z",
          }),
        },
      );
      expect(response.status).toBe(403);
    });

    it("blocks a viewer from creating a Slack integration", async () => {
      const member = await createWorkspaceMember({ role: "viewer" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(
        `/api/slack-integration/project/${project.id}`,
        {
          method: "POST",
          headers: { "content-type": "application/json" },
          body: JSON.stringify({
            webhookUrl: "https://hooks.slack.com/services/x/y/z",
          }),
        },
      );
      expect(response.status).toBe(403);
    });

    it("blocks a member from deleting an integration", async () => {
      const member = await createWorkspaceMember({ role: "member" });
      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });
      mockAuthenticatedSession(member.user);
      const { app } = createApp();

      const response = await app.request(
        `/api/slack-integration/project/${project.id}`,
        {
          method: "DELETE",
        },
      );
      expect(response.status).toBe(403);
    });
  });

  describe("instance admin bypass", () => {
    it("bypasses the workspace permission check when user.role === 'admin'", async () => {
      const member = await createWorkspaceMember({ role: "viewer" });
      // Promote the user to instance admin
      await db
        .update(schema.userTable)
        .set({ role: "admin" })
        .where(eq(schema.userTable.id, member.user.id));

      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });

      // Reload the user so the mocked session reflects the admin role.
      const refreshedUser = await db.query.userTable.findFirst({
        where: eq(schema.userTable.id, member.user.id),
      });
      if (!refreshedUser) throw new Error("user vanished after update");

      mockAuthenticatedSession(refreshedUser);
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(200);
    });

    it("does not bypass for users with no role set", async () => {
      const member = await createWorkspaceMember({ role: "viewer" });
      // Explicitly null role on the user table; should NOT bypass.
      await db
        .update(schema.userTable)
        .set({ role: null })
        .where(eq(schema.userTable.id, member.user.id));

      const { project } = await createProjectFixture({
        workspaceId: member.workspace.id,
      });

      mockAuthenticatedSession({ ...member.user, role: null });
      const { app } = createApp();

      const response = await postCreateTask(app, project.id);
      expect(response.status).toBe(403);
    });
  });
});