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.

9.9 KB
Raw Blame
import { createHash, randomUUID } from "node:crypto";
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";

type AdminUserList = {
  users: { id: string; name: string; email: string; banned: boolean }[];
  total: number;
};

async function createUser(
  overrides: Partial<typeof schema.userTable.$inferInsert> & {
    name: string;
    email: string;
  },
) {
  const [user] = await db
    .insert(schema.userTable)
    .values({
      id: `user-${randomUUID()}`,
      emailVerified: true,
      ...overrides,
    })
    .returning();
  return user;
}

async function listUsers(
  app: ReturnType<typeof createApp>["app"],
  query: Record<string, string> = {},
  headers: Record<string, string> = {},
) {
  const search = new URLSearchParams(query).toString();
  return app.request(`/api/admin/users${search ? `?${search}` : ""}`, {
    headers,
  });
}

describe("API integration: admin user listing", () => {
  beforeEach(async () => {
    await resetTestDatabase();
  });

  it("rejects users who are not instance administrators", async () => {
    const member = await createUser({
      name: "Regular Member",
      email: "[email protected]",
    });
    mockAuthenticatedSession(member);
    const { app } = createApp();

    const response = await listUsers(app);

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

  it("rejects API keys even when they belong to an administrator", async () => {
    const admin = await createUser({
      name: "Instance Admin",
      email: "[email protected]",
      role: "admin",
    });
    mockAnonymousSession();
    const key = `test_${randomUUID()}`;
    await db.insert(schema.apikeyTable).values({
      referenceId: admin.id,
      userId: admin.id,
      key: createHash("sha256").update(key).digest("base64url"),
      enabled: true,
      createdAt: new Date(),
      updatedAt: new Date(),
    });
    const { app } = createApp();

    const response = await listUsers(app, {}, { "x-api-key": key });

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

  it("accepts administrators whose role list includes admin", async () => {
    const admin = await createUser({
      name: "Multi Role Admin",
      email: "[email protected]",
      role: "user,admin",
    });
    mockAuthenticatedSession(admin);
    const { app } = createApp();

    const response = await listUsers(app);

    expect(response.status).toBe(200);
    const body = (await response.json()) as AdminUserList;
    expect(body.users.map((user) => user.id)).toEqual([admin.id]);
  });

  it("searches name and email case-insensitively", async () => {
    const admin = await createUser({
      name: "Instance Admin",
      email: "[email protected]",
      role: "admin",
    });
    const alice = await createUser({
      name: "Alice Wonder",
      email: "[email protected]",
    });
    const bob = await createUser({ name: "Bob Builder", email: "[email protected]" });
    await createUser({ name: "Carol", email: "[email protected]" });
    mockAuthenticatedSession(admin);
    const { app } = createApp();

    const byName = (await (
      await listUsers(app, { search: "ALICE" })
    ).json()) as AdminUserList;
    expect(byName.total).toBe(1);
    expect(byName.users.map((user) => user.id)).toEqual([alice.id]);

    const byEmail = (await (
      await listUsers(app, { search: "Corp" })
    ).json()) as AdminUserList;
    expect(byEmail.total).toBe(1);
    expect(byEmail.users.map((user) => user.id)).toEqual([bob.id]);

    const wildcard = (await (
      await listUsers(app, { search: "%" })
    ).json()) as AdminUserList;
    expect(wildcard.total).toBe(0);
    expect(wildcard.users).toEqual([]);
  });

  it("pages newest users first and reports the total across pages", async () => {
    const admin = await createUser({
      name: "Instance Admin",
      email: "[email protected]",
      role: "admin",
      createdAt: new Date("2026-01-01T00:00:00Z"),
    });
    const users = [];
    for (let index = 0; index < 4; index += 1) {
      users.push(
        await createUser({
          name: `Member ${index}`,
          email: `member-${index}@example.com`,
          createdAt: new Date(`2026-02-0${index + 1}T00:00:00Z`),
          banned: index === 3,
        }),
      );
    }
    mockAuthenticatedSession(admin);
    const { app } = createApp();

    const firstPage = (await (
      await listUsers(app, { limit: "2", page: "1" })
    ).json()) as AdminUserList;
    expect(firstPage.total).toBe(5);
    expect(firstPage.users.map((user) => user.id)).toEqual([
      users[3]?.id,
      users[2]?.id,
    ]);
    expect(firstPage.users[0]?.banned).toBe(true);
    expect(firstPage.users[1]?.banned).toBe(false);

    const lastPage = (await (
      await listUsers(app, { limit: "2", page: "3" })
    ).json()) as AdminUserList;
    expect(lastPage.total).toBe(5);
    expect(lastPage.users.map((user) => user.id)).toEqual([admin.id]);

    const beyond = (await (
      await listUsers(app, { limit: "2", page: "4" })
    ).json()) as AdminUserList;
    expect(beyond.users).toEqual([]);
    expect(beyond.total).toBe(5);
  });

  it("rejects invalid paging values", async () => {
    const admin = await createUser({
      name: "Instance Admin",
      email: "[email protected]",
      role: "admin",
    });
    mockAuthenticatedSession(admin);
    const { app } = createApp();

    expect((await listUsers(app, { page: "0" })).status).toBe(400);
    expect((await listUsers(app, { limit: "101" })).status).toBe(400);
    expect((await listUsers(app, { limit: "abc" })).status).toBe(400);
  });

  it("filters by status, role, and email verification", async () => {
    const admin = await createUser({
      name: "Instance Admin",
      email: "[email protected]",
      role: "user,admin",
    });
    const banned = await createUser({
      name: "Banned",
      email: "[email protected]",
      banned: true,
    });
    const unverified = await createUser({
      name: "Unverified",
      email: "[email protected]",
      emailVerified: false,
      role: null,
    });
    mockAuthenticatedSession(admin);
    const { app } = createApp();
    const ids = async (query: Record<string, string>) => {
      const response = await listUsers(app, query);
      expect(response.status).toBe(200);
      const body = (await response.json()) as AdminUserList;
      expect(body.total).toBe(body.users.length);
      return body.users.map((user) => user.id).sort();
    };

    expect(await ids({ status: "deactivated" })).toEqual([banned.id]);
    expect(await ids({ status: "active" })).toEqual(
      [admin.id, unverified.id].sort(),
    );
    expect(await ids({ role: "admin" })).toEqual([admin.id]);
    expect(await ids({ role: "user" })).toEqual(
      [banned.id, unverified.id].sort(),
    );
    expect(await ids({ emailVerified: "false" })).toEqual([unverified.id]);
    expect(
      await ids({ emailVerified: "true", status: "active", role: "user" }),
    ).toEqual([]);
    expect((await listUsers(app, { status: "gone" })).status).toBe(400);
    expect((await listUsers(app, { emailVerified: "yes" })).status).toBe(400);
  });

  it("treats expired timed bans as active in filtered results and totals", async () => {
    const admin = await createUser({
      name: "Admin",
      email: "[email protected]",
      role: "admin",
    });
    const expired = await createUser({
      name: "Expired",
      email: "[email protected]",
      banned: true,
      banExpires: new Date(Date.now() - 60_000),
    });
    const future = await createUser({
      name: "Future",
      email: "[email protected]",
      banned: true,
      banExpires: new Date(Date.now() + 60_000),
    });
    mockAuthenticatedSession(admin);
    const { app } = createApp();
    const active = (await (
      await listUsers(app, { status: "active" })
    ).json()) as AdminUserList;
    expect(active.total).toBe(2);
    expect(active.users.map((user) => user.id).sort()).toEqual(
      [admin.id, expired.id].sort(),
    );
    expect(active.users.find((user) => user.id === expired.id)?.banned).toBe(
      false,
    );
    const deactivated = (await (
      await listUsers(app, { status: "deactivated" })
    ).json()) as AdminUserList;
    expect(deactivated.total).toBe(1);
    expect(deactivated.users.map((user) => user.id)).toEqual([future.id]);
    expect(deactivated.users[0]?.banned).toBe(true);
  });

  it("reports last session activity and linked sign-in methods", async () => {
    const admin = await createUser({
      name: "Instance Admin",
      email: "[email protected]",
      role: "admin",
    });
    const member = await createUser({
      name: "Member",
      email: "[email protected]",
    });
    const now = Date.now();
    for (const [index, updatedAt] of [
      new Date(now - 3_600_000),
      new Date(now - 60_000),
    ].entries()) {
      await db.insert(schema.sessionTable).values({
        id: `session-${index}`,
        token: `token-${index}`,
        userId: member.id,
        expiresAt: new Date(now + 3_600_000),
        updatedAt,
      });
    }
    for (const providerId of ["github", "credential", "github"]) {
      await db.insert(schema.accountTable).values({
        accountId: randomUUID(),
        providerId,
        userId: member.id,
      });
    }
    mockAuthenticatedSession(admin);
    const { app } = createApp();

    const body = (await (await listUsers(app)).json()) as {
      users: {
        id: string;
        lastActiveAt: string | null;
        signInMethods: string[];
      }[];
    };
    const listed = body.users.find((user) => user.id === member.id);
    expect(listed?.signInMethods).toEqual(["credential", "github"]);
    expect(listed?.lastActiveAt).toBe(new Date(now - 60_000).toISOString());
    const self = body.users.find((user) => user.id === admin.id);
    expect(self).toMatchObject({ lastActiveAt: null, signInMethods: [] });
  });
});