Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
import { NextRequest } from "next/server.js";
import { expect, test } from "vitest";
import type { ResolveActiveWorkspaceResult } from "./auth/resolve-active-workspace";
import {
createInnerTRPCContext,
createTRPCContext,
createTRPCRouter,
protectedProcedure,
} from "./trpc";
const testRouter = createTRPCRouter({
whoami: protectedProcedure.query(({ ctx }) => ({
userId: ctx.user.id,
workspaceSlug: ctx.workspace.slug,
})),
});
function makeRequest(cookie?: string) {
return new NextRequest("http://localhost:3000/api/trpc/lambda", {
headers: cookie ? { cookie } : undefined,
});
}
test("protected procedure rejects without a session", async () => {
const ctx = createInnerTRPCContext({ session: null });
const caller = testRouter.createCaller(ctx);
await expect(caller.whoami()).rejects.toThrow("UNAUTHORIZED");
});
test("protected procedure resolves seeded user and workspace", async () => {
const ctx = await createTRPCContext({
req: makeRequest("workspace-slug=love-openstatus"),
auth: async () => ({ user: { id: "1" } }),
});
const caller = testRouter.createCaller(ctx);
const result = await caller.whoami();
expect(result).toEqual({ userId: 1, workspaceSlug: "love-openstatus" });
});
test("falls back to the first workspace when the cookie slug is stale", async () => {
const ctx = await createTRPCContext({
req: makeRequest("workspace-slug=does-not-exist"),
auth: async () => ({ user: { id: "1" } }),
});
const caller = testRouter.createCaller(ctx);
const result = await caller.whoami();
expect(result).toEqual({ userId: 1, workspaceSlug: "love-openstatus" });
});
test("resolveWorkspace memoizes the resolution within one request context", async () => {
const ctx = await createTRPCContext({
req: makeRequest(),
auth: async () => ({ user: { id: "1" } }),
});
const first = ctx.resolveWorkspace?.();
const second = ctx.resolveWorkspace?.();
expect(second).toBe(first);
const resolved = await first;
expect(resolved?.ok).toBe(true);
});
test("resolveWorkspace is not shared across request contexts", async () => {
const auth = async () => ({ user: { id: "1" } });
const a = await createTRPCContext({ req: makeRequest(), auth });
const b = await createTRPCContext({ req: makeRequest(), auth });
const resolvedA = a.resolveWorkspace?.();
const resolvedB = b.resolveWorkspace?.();
expect(resolvedB).not.toBe(resolvedA);
await Promise.all([resolvedA, resolvedB]);
});
test("middleware uses the context resolver instead of querying directly", async () => {
let calls = 0;
const resolveWorkspace = (): Promise<ResolveActiveWorkspaceResult> => {
calls++;
// safe because the middleware only reads user.id and workspace.slug
return Promise.resolve({
ok: true,
value: { user: { id: 42 }, workspace: { slug: "stubbed-workspace" } },
} as unknown as ResolveActiveWorkspaceResult);
};
const ctx = createInnerTRPCContext({
session: { user: { id: "42" } },
resolveWorkspace,
});
const caller = testRouter.createCaller(ctx);
const result = await caller.whoami();
expect(result).toEqual({ userId: 42, workspaceSlug: "stubbed-workspace" });
expect(calls).toBe(1);
});
test("middleware surfaces workspace_not_found as UNAUTHORIZED", async () => {
const resolveWorkspace = (): Promise<ResolveActiveWorkspaceResult> =>
Promise.resolve({ ok: false, error: { kind: "workspace_not_found" } });
const ctx = createInnerTRPCContext({
session: { user: { id: "42" } },
resolveWorkspace,
});
const caller = testRouter.createCaller(ctx);
await expect(caller.whoami()).rejects.toThrow("Workspace Not Found");
});