Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/auth-providers.server.test.ts
T

188 lines
6.8 KiB
TypeScript

import { readFileSync } from "node:fs";
import { dirname, resolve } from "node:path";
import { fileURLToPath } from "node:url";
import { describe, expect, it, vi } from "vitest";
import {
TENANT_USER_STATUS_ACTIVE,
WorkspaceContextRevalidationError,
listWorkspaceAuthProviders,
revalidateWorkspaceContext,
serializeWorkspaceAuthProvider,
type WorkspaceAuthProviderClient,
} from "./auth-providers.server.js";
const now = new Date("2026-05-08T15:30:00.000Z");
const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
function membership(overrides: Partial<ReturnType<typeof baseMembership>> = {}) {
return { ...baseMembership(), ...overrides };
}
function baseMembership() {
return {
id: "membership_1",
createdAt: now,
tenantId: "tenant_1",
userId: "user_1",
type: 2 as number,
joined: 1 as number,
status: TENANT_USER_STATUS_ACTIVE as number,
};
}
function provider(overrides: Partial<ReturnType<typeof baseProvider>> = {}) {
return { ...baseProvider(), ...overrides };
}
function baseProvider() {
return {
id: "provider_1",
createdAt: now,
updatedAt: now,
tenantId: "tenant_1",
kind: "oidc",
name: "Acme OIDC",
slug: "acme-oidc",
enabled: true,
issuer: "https://idp.example.com",
authorizationUrl: "https://idp.example.com/oauth/authorize",
tokenUrl: "https://idp.example.com/oauth/token",
jwksUrl: "https://idp.example.com/.well-known/jwks.json",
clientId: "public-client-id",
entityId: null as string | null,
ssoUrl: null as string | null,
certificateFingerprint: null as string | null,
metadataUpdatedAt: now,
};
}
function createAuthProviderClient(rows: ReturnType<typeof provider>[] = [], tenantMembership: ReturnType<typeof membership> | null = membership()): WorkspaceAuthProviderClient {
return {
workspaceAuthProvider: {
findMany: vi.fn().mockResolvedValue(rows),
},
tenantUser: {
findFirst: vi.fn().mockResolvedValue(tenantMembership),
},
} as unknown as WorkspaceAuthProviderClient;
}
describe("workspace context revalidation", () => {
it("returns a valid context for active tenant membership", async () => {
const activeMembership = membership();
const client = createAuthProviderClient([], activeMembership);
await expect(revalidateWorkspaceContext({ tenantId: " tenant_1 ", userId: " user_1 " }, client)).resolves.toEqual({
valid: true,
tenantId: "tenant_1",
userId: "user_1",
membership: activeMembership,
});
expect(client.tenantUser.findFirst).toHaveBeenCalledWith({
where: { tenantId: "tenant_1", userId: "user_1", tenant: { active: true } },
orderBy: { id: "asc" },
});
});
it("rejects missing membership and cross-tenant contexts", async () => {
const client = createAuthProviderClient([], null);
await expect(revalidateWorkspaceContext({ tenantId: "tenant_2", userId: "user_1" }, client)).rejects.toMatchObject({
code: "context_membership_not_found",
});
expect(client.tenantUser.findFirst).toHaveBeenCalledWith({
where: { tenantId: "tenant_2", userId: "user_1", tenant: { active: true } },
orderBy: { id: "asc" },
});
});
it("requires the tenant attached to the membership to still be active", async () => {
const client = createAuthProviderClient([], null);
await expect(revalidateWorkspaceContext({ tenantId: "tenant_1", userId: "user_1" }, client)).rejects.toMatchObject({
code: "context_membership_not_found",
});
expect(client.tenantUser.findFirst).toHaveBeenCalledWith({
where: { tenantId: "tenant_1", userId: "user_1", tenant: { active: true } },
orderBy: { id: "asc" },
});
});
it("rejects finalized or inactive memberships with stable non-secret codes", async () => {
const client = createAuthProviderClient([], membership({ status: 3 }));
await expect(revalidateWorkspaceContext({ tenantId: "tenant_1", userId: "user_1" }, client)).rejects.toBeInstanceOf(
WorkspaceContextRevalidationError,
);
await expect(revalidateWorkspaceContext({ tenantId: "tenant_1", userId: "user_1" }, client)).rejects.toMatchObject({
code: "context_membership_not_active",
message: "context_membership_not_active",
});
});
it("rejects malformed payloads before querying", async () => {
const client = createAuthProviderClient();
await expect(revalidateWorkspaceContext({ tenantId: "", userId: "user_1" }, client)).rejects.toMatchObject({
code: "context_missing_tenant_id",
});
await expect(revalidateWorkspaceContext({ tenantId: "tenant_1", userId: " " }, client)).rejects.toMatchObject({
code: "context_missing_user_id",
});
expect(client.tenantUser.findFirst).not.toHaveBeenCalled();
});
});
describe("workspace auth provider serialization", () => {
it("lists providers with tenant-scoped filters and enabled providers first", async () => {
const rows = [provider({ enabled: true }), provider({ id: "provider_2", slug: "acme-saml", kind: "saml", enabled: false })];
const client = createAuthProviderClient(rows);
await expect(listWorkspaceAuthProviders({ tenantId: "tenant_1", kind: "saml", enabled: false }, client)).resolves.toEqual([
expect.objectContaining({ id: "provider_1", status: "enabled" }),
expect.objectContaining({ id: "provider_2", status: "disabled" }),
]);
expect(client.workspaceAuthProvider.findMany).toHaveBeenCalledWith({
where: { tenantId: "tenant_1", kind: "saml", enabled: false },
orderBy: [{ enabled: "desc" }, { kind: "asc" }, { name: "asc" }, { id: "asc" }],
});
});
it("serializes disabled providers without secret-like fields", () => {
const dto = serializeWorkspaceAuthProvider(
provider({
kind: "saml",
enabled: false,
entityId: "urn:acme:saml",
ssoUrl: "https://idp.example.com/saml/sso",
certificateFingerprint: "SHA256:abc123",
}),
);
expect(dto).toEqual(
expect.objectContaining({
kind: "saml",
enabled: false,
status: "disabled",
entityId: "urn:acme:saml",
certificateFingerprint: "SHA256:abc123",
}),
);
expect(JSON.stringify(dto)).not.toMatch(/secret|privateKey|tokenHash|assertion/i);
});
it("guards the WorkspaceAuthProvider schema against secret-like columns", () => {
const schema = readFileSync(resolve(repoRoot, "prisma/schema/accounts.prisma"), "utf8");
const modelBody = schema.match(/model WorkspaceAuthProvider \{([\s\S]*?)\n\}/)?.[1] ?? "";
const fieldNames = modelBody
.split("\n")
.map((line) => line.trim().match(/^(\w+)\s/)?.[1])
.filter(Boolean);
const secretBearingFieldNames = fieldNames.filter((fieldName) => fieldName !== "tokenUrl").join("\n");
expect(secretBearingFieldNames).not.toMatch(/\b\w*(secret|privateKey|token|assertion)\w*\b/i);
});
});