⚡ 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 { 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: [] });
});
});