⚡ 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 { once } from "node:events";
import { createRequire } from "node:module";
import { afterEach, beforeEach, describe, expect, it } from "vite-plus/test";
import { serve } from "../../apps/api/node_modules/@hono/node-server";
import type { NodeWebSocket } from "../../apps/api/node_modules/@hono/node-ws";
import { auth } from "../../apps/api/src/auth";
import { createApp } from "../../apps/api/src/index";
import { shutdownWebSocketAdapter } from "../../apps/api/src/ws";
import { signUpWithSession } from "./helpers/auth-session";
import { resetTestDatabase } from "./helpers/database";
type Socket = NodeWebSocket["wss"]["clients"] extends Set<infer S> ? S : never;
const apiRequire = createRequire(
new URL("../../apps/api/package.json", import.meta.url),
);
const nodeWsRequire = createRequire(apiRequire.resolve("@hono/node-ws"));
const WebSocket: new (
url: string,
options: { headers: Record<string, string> },
) => Socket = nodeWsRequire("ws").WebSocket;
const ORIGIN = "http://localhost:5173";
type App = ReturnType<typeof createApp>["app"];
type Account = { userId: string; cookies: string };
let app: App;
let server: ReturnType<typeof serve>;
let baseUrl: string;
let admin: Account;
let target: Account;
const sockets: Socket[] = [];
async function connectUserSocket(headers: Record<string, string>) {
const socket = new WebSocket(`${baseUrl}/api/ws/user`, { headers });
sockets.push(socket);
socket.on("error", () => {});
await once(socket, "open");
return socket;
}
function closeOf(socket: Socket) {
return once(socket, "close").then(([code, reason]) => ({
code,
reason: String(reason),
}));
}
/** A ping round trip proves the socket is still open after the revocation. */
async function isOpen(socket: Socket) {
const pong = once(socket, "pong");
socket.ping();
await pong;
return socket.readyState === 1;
}
beforeEach(async () => {
await resetTestDatabase();
const created = createApp();
app = created.app;
server = serve({ fetch: app.fetch, hostname: "127.0.0.1", port: 0 });
created.injectWebSocket(server);
if (!server.listening) await once(server, "listening");
const address = server.address();
if (!address || typeof address === "string") throw new Error("No test port");
baseUrl = `ws://127.0.0.1:${address.port}`;
admin = await signUpWithSession(app, {
email: "[email protected]",
name: "Ada Admin",
role: "admin",
});
target = await signUpWithSession(app, {
email: "[email protected]",
name: "Tom Target",
role: "user",
});
});
afterEach(async () => {
await shutdownWebSocketAdapter();
for (const socket of sockets.splice(0)) socket.terminate();
await new Promise<void>((resolve, reject) =>
server.close((error) => (error ? reject(error) : resolve())),
);
});
describe("API integration: user sockets of revoked API keys", () => {
async function connectTargetSockets() {
const revoked = await auth.api.createApiKey({
body: { userId: target.userId, name: "CI deploys" },
});
const kept = await auth.api.createApiKey({
body: { userId: target.userId, name: "Laptop" },
});
return {
revoked,
revokedSocket: await connectUserSocket({ "x-api-key": revoked.key }),
keptSocket: await connectUserSocket({ "x-api-key": kept.key }),
sessionSocket: await connectUserSocket({
cookie: target.cookies,
origin: ORIGIN,
}),
};
}
it("closes the key's sockets when an admin revokes it, and only those", async () => {
const { revoked, revokedSocket, keptSocket, sessionSocket } =
await connectTargetSockets();
const closed = closeOf(revokedSocket);
const response = await app.request(
`/api/admin/users/${target.userId}/api-keys/${revoked.id}`,
{ method: "DELETE", headers: { cookie: admin.cookies, origin: ORIGIN } },
);
expect(response.status).toBe(200);
expect(await closed).toEqual({ code: 1008, reason: "API key revoked" });
expect(await isOpen(keptSocket)).toBe(true);
expect(await isOpen(sessionSocket)).toBe(true);
});
it("closes the key's sockets when its owner deletes it", async () => {
const { revoked, revokedSocket, keptSocket, sessionSocket } =
await connectTargetSockets();
const closed = closeOf(revokedSocket);
const response = await app.request("/api/auth/api-key/delete", {
method: "POST",
headers: {
cookie: target.cookies,
origin: ORIGIN,
"content-type": "application/json",
},
body: JSON.stringify({ keyId: revoked.id }),
});
expect(response.status).toBe(200);
expect(await closed).toEqual({ code: 1008, reason: "API key revoked" });
expect(await isOpen(keptSocket)).toBe(true);
expect(await isOpen(sessionSocket)).toBe(true);
});
});