⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.
TypeScript honoissue-managementissue-trackerjira-alternativekanbanlinear-alternativemcpproject-managementreactself-hostedtypescript
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);
});
});
});