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.

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

describe("API integration: project creation", () => {
  beforeEach(async () => {
    await resetTestDatabase();
  });

  it("rejects unauthenticated project creation requests", async () => {
    mockAnonymousSession();
    const { app } = createApp();

    const response = await app.request("/api/project", {
      method: "POST",
      headers: {
        "content-type": "application/json",
      },
      body: JSON.stringify({
        workspaceId: "workspace-missing",
        name: "Unauthorized Project",
        icon: "Folder",
        slug: "unauthorized-project",
      }),
    });

    expect(response.status).toBe(401);
    expect(await readErrorBody(response)).toMatchObject({
      message: "Unauthorized",
      code: "UNAUTHORIZED",
    });
  });

  it("creates a project for a workspace member and seeds default columns", async () => {
    const member = await createWorkspaceMember();
    mockAuthenticatedSession(member.user);
    const { app } = createApp();

    const response = await app.request("/api/project", {
      method: "POST",
      headers: {
        "content-type": "application/json",
      },
      body: JSON.stringify({
        workspaceId: member.workspace.id,
        name: "Roadmap",
        icon: "FolderKanban",
        slug: "roadmap",
      }),
    });

    expect(response.status).toBe(200);
    const payload =
      (await response.json()) as typeof schema.projectTable.$inferSelect;

    expect(payload).toMatchObject({
      workspaceId: member.workspace.id,
      name: "Roadmap",
      icon: "FolderKanban",
      slug: "roadmap",
    });

    const persistedProject = await db.query.projectTable.findFirst({
      where: eq(schema.projectTable.id, payload.id),
    });

    expect(persistedProject).toMatchObject({
      id: payload.id,
      workspaceId: member.workspace.id,
      name: "Roadmap",
      slug: "roadmap",
    });

    const columns = await db.query.columnTable.findMany({
      where: eq(schema.columnTable.projectId, payload.id),
      orderBy: (column, { asc }) => [asc(column.position)],
    });

    expect(columns).toHaveLength(4);
    expect(columns.map((column) => column.slug)).toEqual([
      "to-do",
      "in-progress",
      "in-review",
      "done",
    ]);
    expect(columns.map((column) => column.isFinal)).toEqual([
      false,
      false,
      false,
      true,
    ]);
  });

  it("rejects project creation for users outside the workspace", async () => {
    const member = await createWorkspaceMember();
    const outsiderId = "user-outsider";

    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 app.request("/api/project", {
      method: "POST",
      headers: {
        "content-type": "application/json",
      },
      body: JSON.stringify({
        workspaceId: member.workspace.id,
        name: "Forbidden Project",
        icon: "Folder",
        slug: "forbidden-project",
      }),
    });

    expect(response.status).toBe(404);
    expect(await readErrorBody(response)).toMatchObject({
      message: "Workspace not found",
      code: "NOT_FOUND",
    });
  });

  it("rejects a project key already used in the workspace", async () => {
    const member = await createWorkspaceMember();
    const other = await createWorkspaceMember();
    await createProjectFixture({
      workspaceId: member.workspace.id,
      name: "Kanban",
      slug: "KAN",
    });
    mockAuthenticatedSession(member.user);
    const { app } = createApp();
    const create = (workspaceId: string, slug: string) =>
      app.request("/api/project", {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          workspaceId,
          name: "New",
          icon: "Folder",
          slug,
        }),
      });

    const duplicate = await create(member.workspace.id, "kan");
    expect(duplicate.status).toBe(409);
    const duplicateError = await readErrorBody(duplicate);
    expect(duplicateError.code).toBe("CONFLICT");
    expect(duplicateError.message).toContain('"kan" (Kanban)');
    expect((await create(member.workspace.id, "KAN")).status).toBe(409);

    mockAuthenticatedSession(other.user);
    expect((await create(other.workspace.id, "KAN")).status).toBe(200);
  });

  it("rejects renaming a project to a key already used in the workspace", async () => {
    const member = await createWorkspaceMember({ role: "admin" });
    await createProjectFixture({
      workspaceId: member.workspace.id,
      name: "Kanban",
      slug: "KAN",
    });
    const { project } = await createProjectFixture({
      workspaceId: member.workspace.id,
      name: "Design",
      slug: "DES",
    });
    const { project: twin } = await createProjectFixture({
      workspaceId: member.workspace.id,
      name: "Design Twin",
      slug: "des",
    });
    mockAuthenticatedSession(member.user);
    const { app } = createApp();
    const update = (id: string, name: string, slug: string) =>
      app.request(`/api/project/${id}`, {
        method: "PUT",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({
          name,
          icon: "Folder",
          slug,
          description: "",
          isPublic: false,
        }),
      });

    expect((await update(twin.id, "Design Twin Renamed", "des")).status).toBe(
      200,
    );
    expect((await update(project.id, "Design", "KAN")).status).toBe(409);
    expect((await update(project.id, "Design", "DSN")).status).toBe(200);
  });

  it("rejects unarchiving a project whose key another project uses", async () => {
    const member = await createWorkspaceMember({ role: "admin" });
    await createProjectFixture({
      workspaceId: member.workspace.id,
      name: "Kanban",
      slug: "KAN",
    });
    const { project: archived } = await createProjectFixture({
      workspaceId: member.workspace.id,
      slug: "kan",
    });
    const { project: archivedTwin } = await createProjectFixture({
      workspaceId: member.workspace.id,
      slug: "OLD",
    });
    const { project: otherArchived } = await createProjectFixture({
      workspaceId: member.workspace.id,
      slug: "old",
    });
    const { project: uniqueArchived } = await createProjectFixture({
      workspaceId: member.workspace.id,
      slug: "NEW",
    });
    await db
      .update(schema.projectTable)
      .set({ archivedAt: new Date() })
      .where(
        inArray(schema.projectTable.id, [
          archived.id,
          archivedTwin.id,
          otherArchived.id,
          uniqueArchived.id,
        ]),
      );
    mockAuthenticatedSession(member.user);
    const { app } = createApp();
    const unarchive = (id: string) =>
      app.request(`/api/project/${id}/unarchive`, { method: "PUT" });

    const conflict = await unarchive(archived.id);
    expect(conflict.status).toBe(409);
    await expect(conflict.text()).resolves.toContain("(Kanban)");
    expect((await unarchive(archivedTwin.id)).status).toBe(409);
    expect((await unarchive(uniqueArchived.id)).status).toBe(200);
  });
});