Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -1,90 +1,81 @@
// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { LoaderFunctionArgs } from "react-router";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { extractAdminSsoClaims as extractAdminSsoClaimsActual } from "~/modules/admin-sso/claims.server";
const { MockAdminSsoConfigError } = vi.hoisted(() => ({
MockAdminSsoConfigError: class MockAdminSsoConfigError extends Error {
code: "missing-env" | "discovery-failed" | "client-init-failed";
constructor(code: "missing-env" | "discovery-failed" | "client-init-failed") {
super(code);
this.name = "AdminSsoConfigError";
this.code = code;
}
},
}));
vi.mock("~/utils/db.server", () => ({
db: {},
const mocks = vi.hoisted(() => ({
consumeChallenge: vi.fn(),
extractClaims: vi.fn(),
getClient: vi.fn(),
readEnv: vi.fn(),
writeAudit: vi.fn(),
createSession: vi.fn(),
getUserInfo: vi.fn(),
bindIdentity: vi.fn(),
adminFind: vi.fn(),
}));
vi.mock("~/modules/admin-sso", () => ({
AdminSsoConfigError: MockAdminSsoConfigError,
consumeAdminSsoChallenge: vi.fn(),
extractAdminSsoClaims: vi.fn(),
getAdminSsoClient: vi.fn(),
jitProvisionAdmin: vi.fn(),
readAdminSsoEnv: vi.fn(),
AdminSsoConfigError: class AdminSsoConfigError extends Error {
code = "missing-env";
},
consumeAdminSsoChallenge: mocks.consumeChallenge,
extractAdminSsoClaims: mocks.extractClaims,
getAdminSsoClient: mocks.getClient,
readAdminSsoEnv: mocks.readEnv,
}));
vi.mock("~/modules/admin-sso/audit.server", () => ({ writeAdminSsoAuditEvent: mocks.writeAudit }));
vi.mock("~/modules/admin-sso/logout.server", () => ({
serializeIdTokenCookie: vi.fn((idToken: string) => `hivegrid_admin_sso_id_token=signed:${idToken}; Path=/auth/admin; HttpOnly`),
serializeIdTokenCookie: (token: string) => `__Host-hivegrid_admin_sso_id_token=${token}; Path=/; HttpOnly; Secure`,
}));
vi.mock("~/modules/admin-sso/audit.server", () => ({
writeAdminSsoAuditEvent: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
createUserSession: vi.fn(),
getUserInfo: vi.fn(),
setLoggedUser: vi.fn(),
createUserSession: mocks.createSession,
getUserInfo: mocks.getUserInfo,
}));
vi.mock("~/utils/db/users.db.server", () => ({
getUser: vi.fn(),
vi.mock("~/utils/db.server", () => ({
db: { adminUser: { findUnique: mocks.adminFind } },
}));
vi.mock("~/utils/db/permissions/userRoles.db.server", () => ({
ensureAdminUserRoleByName: vi.fn(),
vi.mock("@hivegrid/db/admin-sso.server", () => ({
AdminIdentityNotPreparedError: class AdminIdentityNotPreparedError extends Error {
code = "ADMIN_IDENTITY_NOT_PREPARED";
},
bindPreparedAuthentikAdminIdentity: mocks.bindIdentity,
}));
vi.mock("@hivegrid/db/rls-context.server", () => ({
runWithRlsContext: async (_context: unknown, operation: () => unknown) => operation(),
}));
vi.mock("@hivegrid/config", () => ({
loadRequiredWebConfig: vi.fn(() => ({ routing: { adminAppHost: "admin.example.test" } })),
loadRequiredWebConfig: () => ({
routing: {
protocol: "https",
webAppHost: "app.example.test",
adminAppHost: "admin.example.test",
apiHost: "api.example.test",
appBaseDomain: "example.test",
},
}),
}));
vi.mock("~/utils/app/CrossHostUrls", () => ({
absoluteAdminPath: vi.fn(() => "https://admin.example.test/dashboard"),
absoluteAdminPath: (_routing: unknown, path: string) => `https://admin.example.test/${path.replace(/^\//u, "")}`,
}));
import {
consumeAdminSsoChallenge,
extractAdminSsoClaims,
getAdminSsoClient,
jitProvisionAdmin,
readAdminSsoEnv,
} from "~/modules/admin-sso";
import { serializeIdTokenCookie } from "~/modules/admin-sso/logout.server";
import { writeAdminSsoAuditEvent } from "~/modules/admin-sso/audit.server";
import { createUserSession, getUserInfo, setLoggedUser } from "~/utils/session.server";
import { getUser } from "~/utils/db/users.db.server";
import { ensureAdminUserRoleByName } from "~/utils/db/permissions/userRoles.db.server";
import * as CallbackRoute from "./auth.admin.callback";
const env = { redirectUri: "https://admin.example.test/auth/admin/callback" };
const claims = {
subject: "sso-subject-1",
email: "admin@example.test",
emailVerified: true,
name: "Ada Admin",
groups: ["hivegrid-admin"],
authenticationMethods: ["pwd", "mfa"],
};
function callbackRequest(url = "https://admin.example.test/auth/admin/callback?code=abc&state=state_1") {
return new Request(url);
function request() {
return new Request("https://admin.example.test/auth/admin/callback?code=abc&state=state_1");
}
async function callLoader(request = callbackRequest()) {
return CallbackRoute.loader({ request, params: {}, context: {} } as LoaderFunctionArgs);
function callLoader() {
return CallbackRoute.loader({ request: request(), params: {}, context: {} } as LoaderFunctionArgs);
}
async function expectRedirect(promise: Promise<Response>) {
@@ -97,98 +88,131 @@ async function expectRedirect(promise: Promise<Response>) {
throw new Error("Expected redirect response");
}
describe("auth admin callback route", () => {
describe("admin Authentik callback", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(readAdminSsoEnv).mockReturnValue(env as ReturnType<typeof readAdminSsoEnv>);
vi.mocked(getAdminSsoClient).mockResolvedValue({
mocks.readEnv.mockReturnValue({ redirectUri: "https://admin.example.test/auth/admin/callback" });
mocks.getClient.mockResolvedValue({
callbackParams: vi.fn(() => ({ code: "abc", state: "state_1" })),
callback: vi.fn(async () => ({
id_token: "id-token-value",
claims: () => claims,
})),
} as Awaited<ReturnType<typeof getAdminSsoClient>>);
vi.mocked(consumeAdminSsoChallenge).mockReturnValue({
callback: vi.fn(async () => ({ id_token: "id-token", claims: () => claims })),
});
mocks.consumeChallenge.mockReturnValue({
ok: true,
payload: {
state: "state_1",
nonce: "nonce_1",
codeVerifier: "verifier_1",
returnTo: "/dashboard",
},
clearCookie: "hivegrid_admin_sso_challenge=; Path=/auth/admin; Max-Age=0",
} as ReturnType<typeof consumeAdminSsoChallenge>);
vi.mocked(extractAdminSsoClaims).mockReturnValue({ ok: true, claims } as ReturnType<typeof extractAdminSsoClaims>);
vi.mocked(jitProvisionAdmin).mockResolvedValue({
ok: true,
admin: { userId: "user_1", role: "admin", created: false, linkedExisting: true },
} as Awaited<ReturnType<typeof jitProvisionAdmin>>);
vi.mocked(getUser).mockResolvedValue({
id: "user_1",
email: "admin@example.test",
defaultTenantId: null,
locale: "de",
} as Awaited<ReturnType<typeof getUser>>);
vi.mocked(getUserInfo).mockResolvedValue({ userId: "old-user", lng: "en" } as Awaited<ReturnType<typeof getUserInfo>>);
vi.mocked(setLoggedUser).mockResolvedValue({ userId: "user_1" } as Awaited<ReturnType<typeof setLoggedUser>>);
vi.mocked(createUserSession).mockImplementation(
async (_session, redirectTo) => new Response(null, { status: 302, headers: { Location: redirectTo, "Set-Cookie": "app_session=fresh; HttpOnly" } })
payload: { state: "state_1", nonce: "nonce_1", codeVerifier: "verifier_1", returnTo: "/dashboard" },
clearCookie: "__Host-hivegrid_admin_sso_challenge=; Path=/; Max-Age=0; Secure",
});
mocks.extractClaims.mockReturnValue({ ok: true, claims });
mocks.bindIdentity.mockResolvedValue({ adminUserId: "admin-1", newSubjectBinding: true });
mocks.adminFind.mockResolvedValue({ id: "admin-1", email: "admin@example.test", locale: "de" });
mocks.getUserInfo.mockResolvedValue({ userId: undefined, lng: "en" });
mocks.createSession.mockImplementation(
async (_session: unknown, redirectTo: string) =>
new Response(null, { status: 302, headers: { Location: redirectTo, "Set-Cookie": "__Host-hivegrid_admin_session=fresh" } })
);
});
it("grants the SuperAdmin RBAC role on a super_admin SSO login", async () => {
vi.mocked(jitProvisionAdmin).mockResolvedValue({
ok: true,
admin: { userId: "user_1", email: "admin@example.test", role: "super_admin", created: true, linkedExisting: false },
} as Awaited<ReturnType<typeof jitProvisionAdmin>>);
await callLoader();
expect(ensureAdminUserRoleByName).toHaveBeenCalledWith("user_1", "SuperAdmin");
});
it("does not grant an RBAC role when the SSO role is not super_admin", async () => {
// default jit mock returns role "admin" (non-super_admin)
await callLoader();
expect(ensureAdminUserRoleByName).not.toHaveBeenCalled();
});
it("still completes login when the RBAC role grant throws (non-fatal)", async () => {
vi.mocked(jitProvisionAdmin).mockResolvedValue({
ok: true,
admin: { userId: "user_1", email: "admin@example.test", role: "super_admin", created: true, linkedExisting: false },
} as Awaited<ReturnType<typeof jitProvisionAdmin>>);
vi.mocked(ensureAdminUserRoleByName).mockRejectedValueOnce(new Error("db down"));
it("binds a prepared tenant-less AdminUser and creates an assured AdminSession without assigning roles", async () => {
const response = await callLoader();
expect(response.status).toBe(302);
expect(createUserSession).toHaveBeenCalled();
});
it("fails an invalid state challenge before token exchange or session creation", async () => {
vi.mocked(consumeAdminSsoChallenge).mockReturnValue({ ok: false, reason: "missing" } as ReturnType<typeof consumeAdminSsoChallenge>);
const response = await expectRedirect(callLoader());
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("/login?error=sso_state_invalid");
const client = await vi.mocked(getAdminSsoClient).mock.results[0]?.value;
expect(client.callback).not.toHaveBeenCalled();
expect(jitProvisionAdmin).not.toHaveBeenCalled();
expect(getUser).not.toHaveBeenCalled();
expect(createUserSession).not.toHaveBeenCalled();
expect(writeAdminSsoAuditEvent).toHaveBeenCalledWith(
expect(response.headers.get("Location")).toBe("/dashboard");
expect(mocks.bindIdentity).toHaveBeenCalledWith(expect.objectContaining({ subject: claims.subject, email: claims.email }));
expect(mocks.createSession).toHaveBeenCalledWith(
expect.objectContaining({ userId: "admin-1", lng: "de" }),
"/dashboard",
expect.objectContaining({
action: "admin.login.sso.failure",
meta: { stage: "consume-challenge", reason: "missing" },
rotate: true,
adminAuthenticationMethods: ["pwd", "mfa"],
adminMfaAssuredAt: expect.any(Date),
})
);
});
it("sanitizes unsafe return targets and appends cleanup cookies after session rotation", async () => {
vi.mocked(consumeAdminSsoChallenge).mockReturnValue({
it("passes canonicalized groups to subject binding when Authentik scope mappings overlap", async () => {
const duplicatedGroups = ["authentik Admins", "sogo-users", "hivegrid-admin", "authentik Admins", "sogo-users", "hivegrid-admin"];
const canonicalGroups = ["authentik Admins", "sogo-users", "hivegrid-admin"];
const rawClaims = {
sub: claims.subject,
email: claims.email,
email_verified: claims.emailVerified,
name: claims.name,
groups: duplicatedGroups,
amr: claims.authenticationMethods,
};
mocks.getClient.mockResolvedValueOnce({
callbackParams: vi.fn(() => ({ code: "abc", state: "state_1" })),
callback: vi.fn(async () => ({ id_token: "id-token", claims: () => rawClaims })),
});
mocks.extractClaims.mockReturnValueOnce(extractAdminSsoClaimsActual(rawClaims));
await callLoader();
expect(mocks.extractClaims).toHaveBeenCalledWith(rawClaims);
expect(mocks.bindIdentity).toHaveBeenCalledWith(expect.objectContaining({ groups: canonicalGroups }));
});
it("accepts both Authentik groups as coarse access gates without mapping either to a HiveGrid role", async () => {
mocks.extractClaims.mockReturnValueOnce({ ok: true, claims: { ...claims, groups: ["hivegrid-staff"] } });
await callLoader();
expect(mocks.bindIdentity).toHaveBeenCalledWith(expect.objectContaining({ groups: ["hivegrid-staff"] }));
});
it("keeps existing HiveGrid roles outside the Authentik callback", async () => {
mocks.extractClaims.mockReturnValueOnce({ ok: true, claims: { ...claims, groups: ["hivegrid-staff"] } });
mocks.bindIdentity.mockResolvedValueOnce({ adminUserId: "admin-1", newSubjectBinding: false });
await callLoader();
expect(mocks.bindIdentity).toHaveBeenCalledTimes(1);
expect(mocks.adminFind).toHaveBeenCalledTimes(1);
});
it("rejects an unprepared Authentik user with a clear fail-closed error", async () => {
mocks.bindIdentity.mockRejectedValueOnce({ code: "ADMIN_IDENTITY_NOT_PREPARED" });
const response = await expectRedirect(callLoader());
expect(response.headers.get("Location")).toBe("/login?error=sso_admin_not_prepared");
expect(mocks.createSession).not.toHaveBeenCalled();
expect(mocks.writeAudit).toHaveBeenCalledWith(
expect.objectContaining({
meta: expect.objectContaining({ stage: "identity-binding", reason: "admin-not-prepared" }),
})
);
});
it("rejects an allowed group without Authentik MFA assurance before binding", async () => {
mocks.extractClaims.mockReturnValueOnce({ ok: true, claims: { ...claims, authenticationMethods: ["pwd"] } });
const response = await expectRedirect(callLoader());
expect(response.headers.get("Location")).toBe("/login?error=sso_mfa_required");
expect(mocks.bindIdentity).not.toHaveBeenCalled();
expect(mocks.createSession).not.toHaveBeenCalled();
});
it("rejects forbidden Authentik groups before binding", async () => {
mocks.extractClaims.mockReturnValueOnce({ ok: true, claims: { ...claims, groups: ["unrelated"] } });
const response = await expectRedirect(callLoader());
expect(response.headers.get("Location")).toBe("/login?error=sso_forbidden_group");
expect(mocks.bindIdentity).not.toHaveBeenCalled();
});
it("fails closed when the challenge is invalid", async () => {
mocks.consumeChallenge.mockReturnValueOnce({ ok: false, reason: "missing" });
const response = await expectRedirect(callLoader());
expect(response.headers.get("Location")).toBe("/login?error=sso_state_invalid");
expect(mocks.bindIdentity).not.toHaveBeenCalled();
});
it("sanitizes external return targets and preserves callback cleanup cookies", async () => {
mocks.consumeChallenge.mockReturnValueOnce({
ok: true,
payload: {
state: "state_1",
@@ -196,37 +220,19 @@ describe("auth admin callback route", () => {
codeVerifier: "verifier_1",
returnTo: "https://evil.example.test/steal",
},
clearCookie: "hivegrid_admin_sso_challenge=; Path=/auth/admin; Max-Age=0",
} as ReturnType<typeof consumeAdminSsoChallenge>);
clearCookie: "__Host-hivegrid_admin_sso_challenge=; Path=/; Max-Age=0; Secure",
});
const response = await callLoader();
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("https://admin.example.test/dashboard");
expect(createUserSession).toHaveBeenCalledWith(
{
userId: "user_1",
lng: "de",
},
"https://admin.example.test/dashboard"
);
const setCookie = response.headers.get("Set-Cookie") ?? "";
expect(setCookie).toContain("app_session=fresh");
expect(setCookie).toContain("hivegrid_admin_sso_challenge=");
expect(setCookie).toContain("hivegrid_admin_sso_id_token=signed:id-token-value");
expect(serializeIdTokenCookie).toHaveBeenCalledWith("id-token-value");
expect(writeAdminSsoAuditEvent).toHaveBeenCalledWith(expect.objectContaining({ action: "admin.login.sso.success" }));
expect(setCookie).toContain("__Host-hivegrid_admin_session=fresh");
expect(setCookie).toContain("__Host-hivegrid_admin_sso_challenge=");
expect(setCookie).toContain("__Host-hivegrid_admin_sso_id_token=id-token");
});
it("keeps safe relative return targets for successful callbacks", async () => {
const response = await callLoader();
expect(response.status).toBe(302);
expect(response.headers.get("Location")).toBe("/dashboard");
expect(createUserSession).toHaveBeenCalledWith(expect.any(Object), "/dashboard");
});
it("has no action export, so non-GET callback methods are not handled here", () => {
it("has no action export", () => {
expect("action" in CallbackRoute).toBe(false);
});
});