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.

19.9 KB
Raw Blame
import * as email from "@kaneo/email";
import { and, eq } from "drizzle-orm";
import {
  afterEach,
  beforeEach,
  describe,
  expect,
  it,
  vi,
} from "vite-plus/test";
import { auth } from "../../apps/api/src/auth";
import db, { schema } from "../../apps/api/src/database";
import { createApp } from "../../apps/api/src/index";
import { invalidateInstanceSettings } from "../../apps/api/src/instance-settings/get-instance-settings";
import { activeIntegrationCondition } from "../../apps/api/src/plugins/active-integration-condition";
import { readAuditLog } from "./helpers/admin/read-audit-log";
import {
  insertInstanceRole,
  signInWithRole,
} from "./helpers/admin/instance-roles";
import { signInWithCustomOAuth } from "./helpers/custom-oauth";
import { resetTestDatabase } from "./helpers/database";
import { readErrorBody } from "./helpers/error-body";
import { createProjectFixture } from "./helpers/fixtures";

vi.hoisted(() => {
  process.env.CUSTOM_OAUTH_CLIENT_ID = "kaneo-test";
  process.env.CUSTOM_OAUTH_CLIENT_SECRET = "kaneo-test-secret";
  process.env.CUSTOM_OAUTH_AUTHORIZATION_URL =
    "https://idp.example.com/authorize";
  process.env.CUSTOM_OAUTH_TOKEN_URL = "https://idp.example.com/token";
});

const PASSWORD = "correct horse battery staple";
const json = {
  "content-type": "application/json",
  origin: "http://localhost:5173",
};

type App = ReturnType<typeof createApp>["app"];

function authPost(app: App, path: string, body: unknown, cookie?: string) {
  return app.request(`/api/auth${path}`, {
    method: "POST",
    headers: { ...json, ...(cookie ? { cookie } : {}) },
    body: JSON.stringify(body),
  });
}

function signUp(app: App, address: string) {
  return authPost(app, "/sign-up/email", {
    name: "New person",
    email: address,
    password: PASSWORD,
  });
}

async function userByEmail(address: string) {
  const [user] = await db
    .select()
    .from(schema.userTable)
    .where(eq(schema.userTable.email, address));
  return user;
}

/** An administrator, so later sign-ups are not the instance's first account. */
async function setUp() {
  const { app } = createApp();
  const admin = await signInWithRole(app, "admin");
  return { app, admin };
}

beforeEach(async () => {
  await resetTestDatabase();
  invalidateInstanceSettings();
});
afterEach(() => {
  vi.unstubAllEnvs();
  vi.unstubAllGlobals();
});

describe("instance settings API", () => {
  it("returns today's behavior on a fresh install", async () => {
    const { admin } = await setUp();
    const response = await admin.api("/settings");
    expect(response.status).toBe(200);
    expect(await response.json()).toMatchObject({
      instanceName: null,
      instanceUrl: "http://localhost:5173",
      registrationEnabled: true,
      passwordRegistrationEnabled: true,
      requireEmailVerification: false,
      defaultRole: "user",
      workspaceCreationRestricted: false,
      disabledIntegrations: [],
      lockedByEnv: [],
      emailDeliveryConfigured: false,
    });
    expect(await db.select().from(schema.instanceSettingsTable)).toEqual([]);
  });

  it("rejects users without instance:settings and API keys", async () => {
    const { app, admin } = await setUp();
    const plain = await signInWithRole(app, "user");
    expect((await plain.api("/settings")).status).toBe(403);
    expect(
      (
        await plain.api("/settings", {
          method: "PATCH",
          body: { instanceName: "X" },
        })
      ).status,
    ).toBe(403);

    const { key } = await auth.api.createApiKey({
      body: { userId: admin.userId, name: "Settings test" },
    });
    for (const headers of [
      { "x-api-key": key },
      { authorization: `Bearer ${key}` },
    ]) {
      const response = await app.request("/api/admin/settings", {
        method: "PATCH",
        headers: { ...json, ...headers },
        body: JSON.stringify({ registrationEnabled: false }),
      });
      expect(response.status).toBe(403);
    }
    expect(await readAuditLog()).toEqual([]);
  });

  it("saves changes, shows them in config, and audits only what changed", async () => {
    const { app, admin } = await setUp();
    const saved = await admin.api("/settings", {
      method: "PATCH",
      body: {
        instanceName: "  Acme Tasks ",
        passwordRegistrationEnabled: false,
        disabledIntegrations: ["slack", "slack", "discord"],
      },
    });
    expect(saved.status).toBe(200);
    expect(await saved.json()).toMatchObject({
      instanceName: "Acme Tasks",
      passwordRegistrationEnabled: false,
      disabledIntegrations: ["discord", "slack"],
    });
    // Repeating the same values records nothing.
    await admin.api("/settings", {
      method: "PATCH",
      body: {
        instanceName: "Acme Tasks",
        disabledIntegrations: ["slack", "discord"],
      },
    });

    const config = (await (await app.request("/api/config")).json()) as Record<
      string,
      unknown
    >;
    expect(config).toMatchObject({
      instanceName: "Acme Tasks",
      disablePasswordRegistration: true,
      disabledIntegrations: ["discord", "slack"],
      hasGuestAccess: false,
    });

    const entries = await readAuditLog();
    expect(entries).toHaveLength(1);
    expect(entries[0]).toMatchObject({
      action: "instance.settings_updated",
      targetType: "instance",
      actorUserId: admin.userId,
      metadata: {
        changes: [
          { setting: "instanceName", from: null, to: "Acme Tasks" },
          { setting: "passwordRegistrationEnabled", from: true, to: false },
          {
            setting: "disabledIntegrations",
            from: [],
            to: ["discord", "slack"],
          },
        ],
      },
    });
  });

  it("validates values", async () => {
    const { admin } = await setUp();
    const cases = [
      { body: {}, status: 400 },
      { body: { defaultRole: "admin" }, status: 400 },
      { body: { defaultRole: "missing" }, status: 400 },
      { body: { disabledIntegrations: ["jira"] }, status: 400 },
      { body: { requireEmailVerification: true }, status: 400 },
      { body: { instanceName: "x".repeat(61) }, status: 400 },
    ];
    for (const { body, status } of cases) {
      const response = await admin.api("/settings", { method: "PATCH", body });
      expect(response.status, JSON.stringify(body)).toBe(status);
    }
    expect(await readAuditLog()).toEqual([]);
  });

  it.each([
    ["DISABLE_REGISTRATION", "registrationEnabled", false],
    ["DISABLE_PASSWORD_REGISTRATION", "passwordRegistrationEnabled", false],
    ["DISABLE_WORKSPACE_CREATION", "workspaceCreationRestricted", true],
  ] as const)("lets %s lock %s", async (variable, setting, forced) => {
    const { admin } = await setUp();
    // A saved value does not override the environment.
    await admin.api("/settings", {
      method: "PATCH",
      body: { [setting]: !forced },
    });
    vi.stubEnv(variable, "true");

    const settings = (await (await admin.api("/settings")).json()) as Record<
      string,
      unknown
    >;
    expect(settings[setting]).toBe(forced);
    expect(settings.lockedByEnv).toEqual([setting]);

    const blocked = await admin.api("/settings", {
      method: "PATCH",
      body: { [setting]: !forced },
    });
    expect(blocked.status).toBe(409);
    expect(await readErrorBody(blocked)).toMatchObject({
      code: "SETTING_LOCKED_BY_ENV",
    });
  });
});

describe("registration settings", () => {
  it("closes registration to people without an invitation", async () => {
    const { app, admin } = await setUp();
    await admin.api("/settings", {
      method: "PATCH",
      body: { registrationEnabled: false },
    });
    const response = await signUp(app, "[email protected]");
    expect(response.status).toBe(403);
    expect(await readErrorBody(response)).toMatchObject({
      code: "REGISTRATION_NOT_ALLOWED",
    });
    expect((await authPost(app, "/sign-in/anonymous", {})).status).toBe(403);
    expect(await userByEmail("[email protected]")).toBeUndefined();
  });

  it("turns off password sign-up but keeps single sign-on", async () => {
    const { app, admin } = await setUp();
    await admin.api("/settings", {
      method: "PATCH",
      body: { passwordRegistrationEnabled: false },
    });
    expect((await signUp(app, "[email protected]")).status).toBe(403);
    expect(await userByEmail("[email protected]")).toBeUndefined();

    const callback = await signInWithCustomOAuth(app, {
      sub: "sso-1",
      email: "[email protected]",
      email_verified: true,
      name: "SSO",
    });
    expect(callback.status).toBe(302);
    expect(await userByEmail("[email protected]")).toBeDefined();
  });
});

describe("default role", () => {
  it("applies to password and OIDC sign-ups and admin-created users", async () => {
    const { app, admin } = await setUp();
    await insertInstanceRole("support", ["users:read"]);
    const saved = await admin.api("/settings", {
      method: "PATCH",
      body: { defaultRole: "support" },
    });
    expect(saved.status).toBe(200);

    expect((await signUp(app, "[email protected]")).status).toBe(200);
    expect((await userByEmail("[email protected]"))?.role).toBe("support");

    const callback = await signInWithCustomOAuth(app, {
      sub: "sso-2",
      email: "[email protected]",
      email_verified: true,
      name: "OIDC",
    });
    expect(callback.status).toBe(302);
    expect((await userByEmail("[email protected]"))?.role).toBe("support");

    const created = await admin.api("/users", {
      method: "POST",
      body: { name: "Created", email: "[email protected]" },
    });
    expect(created.status).toBe(201);
    expect((await userByEmail("[email protected]"))?.role).toBe("support");

    // An explicit role still wins.
    await admin.api("/users", {
      method: "POST",
      body: { name: "Plain", email: "[email protected]", role: "user" },
    });
    expect((await userByEmail("[email protected]"))?.role).toBe("user");
  });

  it("never applies to guests or the first account", async () => {
    const { app } = createApp();
    await db
      .insert(schema.instanceRoleTable)
      .values({ name: "support", permissions: [] });
    const [role] = await db.select().from(schema.instanceRoleTable);
    await db
      .insert(schema.instanceSettingsTable)
      .values({ defaultRoleId: role?.id });

    expect((await signUp(app, "[email protected]")).status).toBe(200);
    expect((await userByEmail("[email protected]"))?.role).toBe("admin");

    expect((await authPost(app, "/sign-in/anonymous", {})).status).toBe(200);
    const [guest] = await db
      .select({ role: schema.userTable.role })
      .from(schema.userTable)
      .where(eq(schema.userTable.isAnonymous, true));
    expect(guest?.role).toBe("user");
  });

  it("can't be a role with permissions the caller lacks", async () => {
    const { app } = await setUp();
    await insertInstanceRole("settings-only", ["instance:settings"]);
    await insertInstanceRole("deleter", ["users:delete"]);
    const manager = await signInWithRole(app, "settings-only");

    const blocked = await manager.api("/settings", {
      method: "PATCH",
      body: { defaultRole: "deleter" },
    });
    expect(blocked.status).toBe(403);
    expect(await readErrorBody(blocked)).toMatchObject({
      code: "ROLE_EXCEEDS_YOUR_PERMISSIONS",
    });
    const allowed = await manager.api("/settings", {
      method: "PATCH",
      body: { defaultRole: "settings-only" },
    });
    expect(allowed.status).toBe(200);
  });

  it("follows a rename and blocks deleting the role", async () => {
    const { admin } = await setUp();
    const role = await insertInstanceRole("support", []);
    await admin.api("/settings", {
      method: "PATCH",
      body: { defaultRole: "support" },
    });

    await admin.api(`/roles/${role?.id}`, {
      method: "PUT",
      body: { name: "help-desk", permissions: [] },
    });
    const settings = (await (await admin.api("/settings")).json()) as {
      defaultRole: string;
    };
    expect(settings.defaultRole).toBe("help-desk");

    const blocked = await admin.api(`/roles/${role?.id}`, { method: "DELETE" });
    expect(blocked.status).toBe(409);
    expect(await readErrorBody(blocked)).toMatchObject({
      code: "ROLE_IS_DEFAULT",
    });
  });
});

describe("email verification", () => {
  it("holds new password sign-ups back until the address is confirmed", async () => {
    vi.spyOn(email, "isSmtpConfigured").mockReturnValue(true);
    const sent = vi
      .spyOn(email, "sendEmailVerificationEmail")
      .mockResolvedValue({ success: true });
    const { app, admin } = await setUp();
    // Accounts from before the change keep signing in unverified.
    const existing = await signInWithRole(app, "user");
    const saved = await admin.api("/settings", {
      method: "PATCH",
      body: { requireEmailVerification: true },
    });
    expect(saved.status).toBe(200);

    const response = await signUp(app, "[email protected]");
    expect(response.status).toBe(200);
    expect(((await response.json()) as { token: unknown }).token).toBeNull();
    expect(response.headers.getSetCookie().join(";")).not.toContain(
      "session_token=",
    );
    const user = await userByEmail("[email protected]");
    expect(user).toMatchObject({
      emailVerified: false,
      emailVerificationRequired: true,
    });
    expect(
      await db
        .select()
        .from(schema.sessionTable)
        .where(eq(schema.sessionTable.userId, user?.id ?? "")),
    ).toEqual([]);
    expect(sent).toHaveBeenCalledTimes(1);
    const link = new URL(sent.mock.calls[0]?.[2].verificationLink ?? "");
    expect(link.pathname).toBe("/api/auth/verify-email");
    expect(link.searchParams.get("callbackURL")).toBe(
      "http://localhost:5173/auth/sign-in",
    );

    const signIn = await authPost(app, "/sign-in/email", {
      email: "[email protected]",
      password: PASSWORD,
    });
    expect(signIn.status).toBe(403);
    expect(await readErrorBody(signIn)).toMatchObject({
      code: "EMAIL_NOT_VERIFIED",
    });
    expect(sent).toHaveBeenCalledTimes(2);

    // A wrong password neither reveals the state nor sends a link.
    const wrong = await authPost(app, "/sign-in/email", {
      email: "[email protected]",
      password: "not the password",
    });
    expect(wrong.status).toBe(401);
    expect(sent).toHaveBeenCalledTimes(2);

    const verified = await app.request(link.pathname + link.search);
    expect(verified.status).toBe(302);
    expect(
      (
        await authPost(app, "/sign-in/email", {
          email: "[email protected]",
          password: PASSWORD,
        })
      ).status,
    ).toBe(200);
    expect(
      (
        await authPost(app, "/sign-in/email", {
          email: existing.email,
          password: PASSWORD,
        })
      ).status,
    ).toBe(200);
  });

  it("does not reveal existing accounts on sign-up", async () => {
    vi.spyOn(email, "isSmtpConfigured").mockReturnValue(true);
    vi.spyOn(email, "sendEmailVerificationEmail").mockResolvedValue({
      success: true,
    });
    const { app, admin } = await setUp();
    await admin.api("/settings", {
      method: "PATCH",
      body: { requireEmailVerification: true },
    });
    const response = await signUp(app, admin.email);
    expect(response.status).toBe(200);
    expect(((await response.json()) as { token: unknown }).token).toBeNull();
  });

  it("lets marked accounts in once the setting is off", async () => {
    vi.spyOn(email, "isSmtpConfigured").mockReturnValue(true);
    vi.spyOn(email, "sendEmailVerificationEmail").mockResolvedValue({
      success: true,
    });
    const { app, admin } = await setUp();
    await admin.api("/settings", {
      method: "PATCH",
      body: { requireEmailVerification: true },
    });
    await signUp(app, "[email protected]");
    await admin.api("/settings", {
      method: "PATCH",
      body: { requireEmailVerification: false },
    });
    expect(
      (
        await authPost(app, "/sign-in/email", {
          email: "[email protected]",
          password: PASSWORD,
        })
      ).status,
    ).toBe(200);
  });
});

describe("workspace creation", () => {
  it("restricts creating workspaces to administrators", async () => {
    const { app, admin } = await setUp();
    await admin.api("/settings", {
      method: "PATCH",
      body: { workspaceCreationRestricted: true },
    });
    const member = await signInWithRole(app, "user");
    const create = (cookie: string, slug: string) =>
      authPost(app, "/organization/create", { name: "Team", slug }, cookie);

    expect((await create(member.cookies, "member-team")).status).toBe(403);
    expect((await create(admin.cookies, "admin-team")).status).toBe(200);
  });
});

describe("integration providers", () => {
  it("stop acting and can't be connected while turned off", async () => {
    const { app, admin } = await setUp();
    const [workspace] = await db
      .insert(schema.workspaceTable)
      .values({
        id: "ws-int",
        name: "Int",
        slug: "ws-int",
        createdAt: new Date(),
      })
      .returning();
    await db.insert(schema.workspaceUserTable).values({
      workspaceId: workspace?.id ?? "",
      userId: admin.userId,
      role: "owner",
      joinedAt: new Date(),
    });
    const { project } = await createProjectFixture({ workspaceId: "ws-int" });
    await db.insert(schema.integrationTable).values([
      { projectId: project.id, type: "slack", config: "{}" },
      { projectId: project.id, type: "discord", config: "{}" },
    ]);
    const activeTypes = async () =>
      (
        await db
          .select({ type: schema.integrationTable.type })
          .from(schema.integrationTable)
          .where(and(activeIntegrationCondition()))
      )
        .map((row) => row.type)
        .sort();
    expect(await activeTypes()).toEqual(["discord", "slack"]);

    await admin.api("/settings", {
      method: "PATCH",
      body: { disabledIntegrations: ["slack"] },
    });
    expect(await activeTypes()).toEqual(["discord"]);

    const slack = (method: string) =>
      app.request(`/api/slack-integration/project/${project.id}`, {
        method,
        headers: { ...json, cookie: admin.cookies },
        body:
          method === "GET" || method === "DELETE"
            ? undefined
            : JSON.stringify({}),
      });
    for (const method of ["POST", "PATCH"]) {
      const response = await slack(method);
      expect(response.status, method).toBe(403);
      expect(await readErrorBody(response)).toMatchObject({
        code: "INTEGRATION_PROVIDER_DISABLED",
      });
    }
    expect((await slack("GET")).status).toBe(200);
    expect((await slack("DELETE")).status).not.toBe(403);
    // Other providers are untouched.
    const discord = await app.request(
      `/api/discord-integration/project/${project.id}`,
      {
        method: "PATCH",
        headers: { ...json, cookie: admin.cookies },
        body: JSON.stringify({}),
      },
    );
    expect(discord.status).not.toBe(403);

    // Sync rules and paused-link resumes write through the provider too.
    await admin.api("/settings", {
      method: "PATCH",
      body: { disabledIntegrations: ["slack", "github"] },
    });
    const sync = (method: string, suffix = "") =>
      app.request(
        `/api/integration-sync/project/${project.id}/github${suffix}`,
        {
          method,
          headers: { ...json, cookie: admin.cookies },
          body: method === "GET" ? undefined : JSON.stringify({}),
        },
      );
    for (const [method, suffix] of [
      ["PATCH", ""],
      ["POST", "/preview"],
      ["POST", "/links/link-1/resume"],
    ] as const) {
      const response = await sync(method, suffix);
      expect(response.status, `${method} ${suffix}`).toBe(403);
      expect(await readErrorBody(response)).toMatchObject({
        code: "INTEGRATION_PROVIDER_DISABLED",
      });
    }
    expect((await sync("GET")).status).not.toBe(403);
    const gitea = await app.request(
      `/api/integration-sync/project/${project.id}/gitea`,
      {
        method: "PATCH",
        headers: { ...json, cookie: admin.cookies },
        body: JSON.stringify({}),
      },
    );
    expect(gitea.status).not.toBe(403);
  });
});