687 lines
27 KiB
TypeScript
687 lines
27 KiB
TypeScript
// @vitest-environment node
|
|
import { CatalogError, foundationErrors } from "@hivegrid/foundation";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
|
|
const mocks = vi.hoisted(() => ({
|
|
KwpConnectError: class KwpConnectError extends Error {
|
|
readonly code: string;
|
|
readonly diagnosticCode?: string;
|
|
constructor(code: string, options?: { diagnosticCode?: string }) {
|
|
super(code);
|
|
this.name = "KwpConnectError";
|
|
this.code = code;
|
|
this.diagnosticCode = options?.diagnosticCode;
|
|
}
|
|
},
|
|
ProviderOAuthCallbackAccessError: class ProviderOAuthCallbackAccessError extends Error {
|
|
readonly failureCode: "session_mismatch" | "membership_inactive";
|
|
constructor(failureCode: "session_mismatch" | "membership_inactive") {
|
|
super("Provider OAuth callback access denied");
|
|
this.name = "ProviderOAuthCallbackAccessError";
|
|
this.failureCode = failureCode;
|
|
}
|
|
},
|
|
context: {
|
|
tenantId: "tenant-1",
|
|
userId: "user-1",
|
|
permissions: ["integrations.connect"],
|
|
hasModule: true,
|
|
},
|
|
loadIntegrationsContext: vi.fn(),
|
|
requireIntegrationsPermission: vi.fn(),
|
|
beginKwpOAuthConnection: vi.fn(),
|
|
cancelKwpOAuthConnectionAttempt: vi.fn(),
|
|
completeKwpOAuthConnection: vi.fn(),
|
|
loadKwpMandantSelection: vi.fn(),
|
|
finalizeKwpOAuthConnection: vi.fn(),
|
|
consumeChallenge: vi.fn(),
|
|
runAuthenticatedProviderOAuthCallback: vi.fn(),
|
|
validateCSRFToken: vi.fn(),
|
|
getUserInfo: vi.fn(),
|
|
getMyTenants: vi.fn(),
|
|
requireKwpIntegrationModule: vi.fn(),
|
|
loggerWarn: vi.fn(),
|
|
}));
|
|
|
|
vi.mock("~/components/auth/AuthShell", () => ({ AuthShell: () => null }));
|
|
vi.mock("~/components/ui/errors/ServerError", () => ({ default: () => null }));
|
|
vi.mock("~/locale/i18next.server", () => ({
|
|
getTranslations: () => Promise.resolve({ t: (key: string) => key }),
|
|
}));
|
|
vi.mock("~/modules/kwp/services/KwpConnectionService.server", () => ({
|
|
KwpConnectError: mocks.KwpConnectError,
|
|
beginKwpOAuthConnection: mocks.beginKwpOAuthConnection,
|
|
cancelKwpOAuthConnectionAttempt: mocks.cancelKwpOAuthConnectionAttempt,
|
|
completeKwpOAuthConnection: mocks.completeKwpOAuthConnection,
|
|
loadKwpMandantSelection: mocks.loadKwpMandantSelection,
|
|
finalizeKwpOAuthConnection: mocks.finalizeKwpOAuthConnection,
|
|
}));
|
|
vi.mock("~/modules/kwp/services/kwpOAuthChallenge.server", () => ({
|
|
consumeKwpOAuthChallenge: mocks.consumeChallenge,
|
|
}));
|
|
vi.mock("~/modules/kwp/routes/kwpAccess.server", () => ({
|
|
requireKwpIntegrationModule: mocks.requireKwpIntegrationModule,
|
|
}));
|
|
vi.mock("~/utils/integrations/integrationsAccess.server", () => ({
|
|
loadIntegrationsContext: mocks.loadIntegrationsContext,
|
|
notFoundResponse: () => new Response("Not Found", { status: 404 }),
|
|
requireIntegrationsPermission: mocks.requireIntegrationsPermission,
|
|
}));
|
|
vi.mock("~/utils/integrations/providerOAuthCallbackAccess.server", () => ({
|
|
ProviderOAuthCallbackAccessError: mocks.ProviderOAuthCallbackAccessError,
|
|
runAuthenticatedProviderOAuthCallback: mocks.runAuthenticatedProviderOAuthCallback,
|
|
}));
|
|
vi.mock("~/utils/session.server", () => ({
|
|
validateCSRFToken: mocks.validateCSRFToken,
|
|
getUserInfo: mocks.getUserInfo,
|
|
}));
|
|
vi.mock("~/utils/db/tenants.db.server", () => ({ getMyTenants: mocks.getMyTenants }));
|
|
vi.mock("~/utils/logger.server", () => ({
|
|
createScopedLogger: () => ({ warn: mocks.loggerWarn }),
|
|
}));
|
|
|
|
import { loader as callbackLoader } from "./integrations.kwp.oauth.callback";
|
|
import { action as setupAction, loader as setupLoader } from "./integrations.kwp.setup";
|
|
|
|
const CHALLENGE = {
|
|
tenantId: "tenant-1",
|
|
tenantSlug: "acme",
|
|
userId: "user-1",
|
|
connectionId: "connection-1",
|
|
connectionVersion: "2026-07-20T12:00:00.000Z",
|
|
customerCode: "geerkens2",
|
|
state: "a".repeat(64),
|
|
nonce: "b".repeat(64),
|
|
codeVerifier: "v".repeat(64),
|
|
codeChallenge: "c".repeat(43),
|
|
createdAt: 1_725_000_000_000,
|
|
} as const;
|
|
|
|
async function captureRejection(promise: Promise<unknown>): Promise<unknown> {
|
|
try {
|
|
await promise;
|
|
} catch (error) {
|
|
return error;
|
|
}
|
|
throw new Error("Expected promise to reject");
|
|
}
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
mocks.loadIntegrationsContext.mockResolvedValue(mocks.context);
|
|
mocks.requireIntegrationsPermission.mockImplementation((context: unknown) => context);
|
|
mocks.requireKwpIntegrationModule.mockImplementation(async (context: unknown) => context);
|
|
mocks.beginKwpOAuthConnection.mockResolvedValue({
|
|
authorizationUrl: "https://id.kwp-online.de/realms/kwp-federated/protocol/openid-connect/auth?state=signed",
|
|
setCookie: "__Host-hivegrid_kwp_oauth_challenge=signed; Secure; HttpOnly",
|
|
});
|
|
mocks.cancelKwpOAuthConnectionAttempt.mockResolvedValue(undefined);
|
|
mocks.completeKwpOAuthConnection.mockResolvedValue({
|
|
tenantId: "tenant-1",
|
|
tenantSlug: "acme",
|
|
connectionId: "connection-1",
|
|
});
|
|
mocks.loadKwpMandantSelection.mockResolvedValue({
|
|
connectionId: "connection-1",
|
|
customerCode: "geerkens2",
|
|
version: "2026-07-20T12:01:00.000Z",
|
|
mode: "available",
|
|
options: [
|
|
{ id: 1, code: "001", label: "Geerkens GmbH" },
|
|
{ id: 2, code: "002", label: "Geerkens Service GmbH" },
|
|
],
|
|
});
|
|
mocks.finalizeKwpOAuthConnection.mockResolvedValue({
|
|
tenantId: "tenant-1",
|
|
tenantSlug: "acme",
|
|
connectionId: "connection-1",
|
|
});
|
|
mocks.consumeChallenge.mockResolvedValue({
|
|
ok: true,
|
|
payload: CHALLENGE,
|
|
clearCookie: "__Host-hivegrid_kwp_oauth_challenge=; Max-Age=0; Secure; HttpOnly",
|
|
});
|
|
mocks.runAuthenticatedProviderOAuthCallback.mockImplementation(async ({ callback }: { callback: () => Promise<unknown> }) => callback());
|
|
mocks.validateCSRFToken.mockResolvedValue(undefined);
|
|
mocks.getUserInfo.mockResolvedValue({ userId: "user-1" });
|
|
mocks.getMyTenants.mockResolvedValue([{ id: "tenant-1", name: "Acme", slug: "acme" }]);
|
|
});
|
|
|
|
describe("KWP OAuth setup route", () => {
|
|
it("starts only from a CSRF-protected POST and emits the host-only challenge cookie", async () => {
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({ intent: "connect", csrf: "csrf-token", customerCode: "geerkens2" }),
|
|
});
|
|
const response = await setupAction({ request } as never);
|
|
|
|
expect(response.status).toBe(302);
|
|
expect(response.headers.get("location")).toContain("https://id.kwp-online.de/realms/kwp-federated/");
|
|
expect(response.headers.get("set-cookie")).toContain("__Host-hivegrid_kwp_oauth_challenge=");
|
|
expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { formData: expect.anything() });
|
|
expect(mocks.loadIntegrationsContext).toHaveBeenCalledWith({
|
|
request,
|
|
params: { tenant: "acme" },
|
|
requireModule: true,
|
|
});
|
|
expect(mocks.requireIntegrationsPermission).toHaveBeenCalledWith(mocks.context, "integrations.connect");
|
|
expect(mocks.requireKwpIntegrationModule).toHaveBeenCalledWith(mocks.context);
|
|
expect(mocks.runAuthenticatedProviderOAuthCallback).toHaveBeenCalledWith({
|
|
request,
|
|
tenantId: "tenant-1",
|
|
userId: "user-1",
|
|
callback: expect.any(Function),
|
|
});
|
|
expect(mocks.beginKwpOAuthConnection).toHaveBeenCalledWith({
|
|
tenantId: "tenant-1",
|
|
tenantSlug: "acme",
|
|
userId: "user-1",
|
|
customerCode: "geerkens2",
|
|
});
|
|
});
|
|
|
|
it("starts with the tenant fallback from the submitted form when the query string is absent", async () => {
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup", {
|
|
method: "POST",
|
|
body: new URLSearchParams({
|
|
intent: "connect",
|
|
csrf: "csrf-token",
|
|
tenant: "acme",
|
|
customerCode: "geerkens2",
|
|
}),
|
|
});
|
|
|
|
const response = await setupAction({ request } as never);
|
|
|
|
expect(response.status).toBe(302);
|
|
expect(response.headers.get("location")).toContain("https://id.kwp-online.de/realms/kwp-federated/");
|
|
expect(mocks.loadIntegrationsContext).toHaveBeenCalledWith({
|
|
request,
|
|
params: { tenant: "acme" },
|
|
requireModule: true,
|
|
});
|
|
expect(mocks.beginKwpOAuthConnection).toHaveBeenCalledWith(
|
|
expect.objectContaining({ tenantSlug: "acme", customerCode: "geerkens2" }),
|
|
);
|
|
});
|
|
|
|
it("rejects bad CSRF before tenant access and provider work", async () => {
|
|
mocks.validateCSRFToken.mockRejectedValueOnce(new Error("invalid csrf"));
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({ intent: "connect", csrf: "bad" }),
|
|
});
|
|
|
|
await expect(setupAction({ request } as never)).rejects.toThrow("invalid csrf");
|
|
expect(mocks.loadIntegrationsContext).not.toHaveBeenCalled();
|
|
expect(mocks.beginKwpOAuthConnection).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("keeps setup GET read-only and offers tenant selection", async () => {
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup");
|
|
const response = await setupLoader({ request } as never);
|
|
|
|
await expect(response.json()).resolves.toMatchObject({
|
|
title: "integrations.kwp.oauth.title | HiveGrid Test",
|
|
vm: {
|
|
status: "ready",
|
|
data: {
|
|
mode: "entry",
|
|
authenticated: true,
|
|
loginHref: "/login?redirectTo=%2Fintegrations%2Fkwp%2Fsetup",
|
|
tenants: [
|
|
{
|
|
id: "tenant-1",
|
|
name: "Acme",
|
|
slug: "acme",
|
|
setupHref: "/integrations/kwp/setup?tenant=acme",
|
|
},
|
|
],
|
|
feedback: null,
|
|
},
|
|
},
|
|
});
|
|
expect(mocks.beginKwpOAuthConnection).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("offers only tenants with KWP connect access on the entry page", async () => {
|
|
const deniedContext = { ...mocks.context, tenantId: "tenant-2", permissions: [] };
|
|
mocks.getMyTenants.mockResolvedValueOnce([
|
|
{ id: "tenant-1", name: "Acme", slug: "acme" },
|
|
{ id: "tenant-2", name: "Blocked", slug: "blocked" },
|
|
]);
|
|
mocks.loadIntegrationsContext.mockImplementation(async ({ params }: { params: { tenant: string } }) =>
|
|
params.tenant === "blocked" ? deniedContext : mocks.context
|
|
);
|
|
mocks.requireIntegrationsPermission.mockImplementation((context: typeof mocks.context) => {
|
|
if (context.tenantId === "tenant-2") {
|
|
throw new CatalogError(foundationErrors.notFound, { permission: "integrations.connect" });
|
|
}
|
|
return context;
|
|
});
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup");
|
|
const response = await setupLoader({ request } as never);
|
|
|
|
await expect(response.json()).resolves.toMatchObject({
|
|
vm: {
|
|
status: "ready",
|
|
data: {
|
|
mode: "entry",
|
|
authenticated: true,
|
|
tenants: [
|
|
{
|
|
id: "tenant-1",
|
|
name: "Acme",
|
|
slug: "acme",
|
|
setupHref: "/integrations/kwp/setup?tenant=acme",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
});
|
|
expect(mocks.requireKwpIntegrationModule).toHaveBeenCalledTimes(2);
|
|
expect(mocks.requireIntegrationsPermission).toHaveBeenCalledTimes(2);
|
|
expect(mocks.beginKwpOAuthConnection).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not hide unexpected entry access failures", async () => {
|
|
mocks.requireKwpIntegrationModule.mockRejectedValueOnce(new Error("database unavailable"));
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup");
|
|
|
|
await expect(setupLoader({ request } as never)).rejects.toThrow("database unavailable");
|
|
});
|
|
|
|
it("returns a real 404 response for a denied direct setup GET", async () => {
|
|
mocks.requireIntegrationsPermission.mockImplementationOnce(() => {
|
|
throw new CatalogError(foundationErrors.notFound, { permission: "integrations.connect" });
|
|
});
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme");
|
|
|
|
const error = await captureRejection(setupLoader({ request } as never));
|
|
expect(error).toBeInstanceOf(Response);
|
|
expect((error as Response).status).toBe(404);
|
|
expect(mocks.beginKwpOAuthConnection).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("loads the staged mandant selection without exposing credentials", async () => {
|
|
const request = new Request(
|
|
"https://app.example.test/integrations/kwp/setup?tenant=acme&connection=connection-1",
|
|
);
|
|
const response = await setupLoader({ request } as never);
|
|
|
|
const body = await response.json();
|
|
expect(body).toMatchObject({
|
|
title: "integrations.kwp.oauth.title | HiveGrid Test",
|
|
vm: {
|
|
status: "ready",
|
|
data: {
|
|
mode: "mandant",
|
|
tenantSlug: "acme",
|
|
settingsHref: "/acme/settings/integrations/kwp",
|
|
connectionId: "connection-1",
|
|
connectionVersion: "2026-07-20T12:01:00.000Z",
|
|
customerCode: "geerkens2",
|
|
discoveryMode: "available",
|
|
mandants: [
|
|
{ id: 1, code: "001", label: "Geerkens GmbH" },
|
|
{ id: 2, code: "002", label: "Geerkens Service GmbH" },
|
|
],
|
|
feedback: null,
|
|
},
|
|
},
|
|
});
|
|
expect(mocks.loadKwpMandantSelection).toHaveBeenCalledWith({
|
|
tenantId: "tenant-1",
|
|
userId: "user-1",
|
|
connectionId: "connection-1",
|
|
});
|
|
expect(mocks.runAuthenticatedProviderOAuthCallback).toHaveBeenCalledWith({
|
|
request,
|
|
tenantId: "tenant-1",
|
|
userId: "user-1",
|
|
callback: expect.any(Function),
|
|
});
|
|
expect(JSON.stringify(body)).not.toMatch(/access[_-]?token|refresh[_-]?token|client[_-]?secret/i);
|
|
});
|
|
|
|
it("confirms the selected mandant and activates the staged connection", async () => {
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({
|
|
intent: "confirm-mandant",
|
|
csrf: "csrf-token",
|
|
connectionId: "connection-1",
|
|
connectionVersion: "2026-07-20T12:01:00.000Z",
|
|
selectionKind: "selected",
|
|
mandantCode: "001",
|
|
}),
|
|
});
|
|
const response = await setupAction({ request } as never);
|
|
|
|
expect(response.status).toBe(303);
|
|
expect(response.headers.get("location")).toBe("/acme/settings/integrations/kwp?kwp=connected");
|
|
expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { formData: expect.anything() });
|
|
expect(mocks.finalizeKwpOAuthConnection).toHaveBeenCalledWith({
|
|
tenantId: "tenant-1",
|
|
userId: "user-1",
|
|
connectionId: "connection-1",
|
|
version: "2026-07-20T12:01:00.000Z",
|
|
mandantBinding: { kind: "selected", code: "001" },
|
|
});
|
|
expect(mocks.runAuthenticatedProviderOAuthCallback).toHaveBeenCalledWith({
|
|
request,
|
|
tenantId: "tenant-1",
|
|
userId: "user-1",
|
|
callback: expect.any(Function),
|
|
});
|
|
});
|
|
|
|
it("supports an explicit no-mandant binding", async () => {
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({
|
|
intent: "confirm-mandant",
|
|
csrf: "csrf-token",
|
|
connectionId: "connection-1",
|
|
connectionVersion: "2026-07-20T12:01:00.000Z",
|
|
selectionKind: "none",
|
|
}),
|
|
});
|
|
|
|
const response = await setupAction({ request } as never);
|
|
|
|
expect(response.status).toBe(303);
|
|
expect(mocks.finalizeKwpOAuthConnection).toHaveBeenCalledWith(
|
|
expect.objectContaining({ mandantBinding: { kind: "none" } }),
|
|
);
|
|
});
|
|
|
|
it("cancels the staged selection through a CSRF-protected POST and restores reconnect state", async () => {
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({
|
|
intent: "cancel-mandant",
|
|
csrf: "csrf-token",
|
|
connectionId: "connection-1",
|
|
connectionVersion: "2026-07-20T12:01:00.000Z",
|
|
}),
|
|
});
|
|
|
|
const response = await setupAction({ request } as never);
|
|
|
|
expect(response.status).toBe(303);
|
|
expect(response.headers.get("location")).toBe("/acme/settings/integrations/kwp");
|
|
expect(mocks.cancelKwpOAuthConnectionAttempt).toHaveBeenCalledWith({
|
|
tenantId: "tenant-1",
|
|
userId: "user-1",
|
|
connectionId: "connection-1",
|
|
version: "2026-07-20T12:01:00.000Z",
|
|
});
|
|
expect(mocks.finalizeKwpOAuthConnection).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("returns selection errors to the staged connection without activating it", async () => {
|
|
mocks.finalizeKwpOAuthConnection.mockRejectedValueOnce(new mocks.KwpConnectError("invalid_selection"));
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({
|
|
intent: "confirm-mandant",
|
|
csrf: "csrf-token",
|
|
connectionId: "connection-1",
|
|
connectionVersion: "2026-07-20T12:01:00.000Z",
|
|
selectionKind: "selected",
|
|
mandantCode: "999",
|
|
}),
|
|
});
|
|
|
|
const response = await setupAction({ request } as never);
|
|
|
|
expect(response.status).toBe(303);
|
|
expect(response.headers.get("location")).toBe(
|
|
"/integrations/kwp/setup?tenant=acme&connection=connection-1&kwp=selection-error",
|
|
);
|
|
});
|
|
|
|
it("restarts setup when the staged selection has expired", async () => {
|
|
mocks.finalizeKwpOAuthConnection.mockRejectedValueOnce(new mocks.KwpConnectError("selection_expired"));
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({
|
|
intent: "confirm-mandant",
|
|
csrf: "csrf-token",
|
|
connectionId: "connection-1",
|
|
connectionVersion: "2026-07-20T12:01:00.000Z",
|
|
selectionKind: "selected",
|
|
mandantCode: "001",
|
|
}),
|
|
});
|
|
|
|
const response = await setupAction({ request } as never);
|
|
|
|
expect(response.status).toBe(303);
|
|
expect(response.headers.get("location")).toBe(
|
|
"/integrations/kwp/setup?tenant=acme&kwp=selection-expired",
|
|
);
|
|
});
|
|
|
|
it("restarts setup when loading a staged selection reports expiry", async () => {
|
|
mocks.loadKwpMandantSelection.mockRejectedValueOnce(new mocks.KwpConnectError("selection_expired"));
|
|
const request = new Request(
|
|
"https://app.example.test/integrations/kwp/setup?tenant=acme&connection=connection-1",
|
|
);
|
|
|
|
const response = await setupLoader({ request } as never);
|
|
|
|
expect(response.status).toBe(303);
|
|
expect(response.headers.get("location")).toBe(
|
|
"/integrations/kwp/setup?tenant=acme&kwp=selection-expired",
|
|
);
|
|
});
|
|
|
|
it("returns a real 404 response for a denied setup POST before OAuth starts", async () => {
|
|
mocks.requireIntegrationsPermission.mockImplementationOnce(() => {
|
|
throw new CatalogError(foundationErrors.notFound, { permission: "integrations.connect" });
|
|
});
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({ intent: "connect", csrf: "csrf-token" }),
|
|
});
|
|
|
|
const error = await captureRejection(setupAction({ request } as never));
|
|
expect(error).toBeInstanceOf(Response);
|
|
expect((error as Response).status).toBe(404);
|
|
expect(mocks.loggerWarn).toHaveBeenCalledWith(
|
|
{
|
|
op: "kwp.oauth.setup.failed",
|
|
failureCode: "tenant_access_denied",
|
|
},
|
|
"KWP OAuth setup failed before provider authorization",
|
|
);
|
|
expect(mocks.runAuthenticatedProviderOAuthCallback).not.toHaveBeenCalled();
|
|
expect(mocks.beginKwpOAuthConnection).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("logs a stable identity bucket and returns 404 when setup revalidation fails", async () => {
|
|
mocks.runAuthenticatedProviderOAuthCallback.mockRejectedValueOnce(
|
|
new mocks.ProviderOAuthCallbackAccessError("session_mismatch"),
|
|
);
|
|
const request = new Request("https://app.example.test/integrations/kwp/setup?tenant=acme", {
|
|
method: "POST",
|
|
body: new URLSearchParams({
|
|
intent: "connect",
|
|
csrf: "csrf-token",
|
|
customerCode: "geerkens2",
|
|
}),
|
|
});
|
|
|
|
const error = await captureRejection(setupAction({ request } as never));
|
|
|
|
expect(error).toBeInstanceOf(Response);
|
|
expect((error as Response).status).toBe(404);
|
|
expect(mocks.loggerWarn).toHaveBeenCalledWith(
|
|
{
|
|
op: "kwp.oauth.setup.failed",
|
|
failureCode: "session_mismatch",
|
|
},
|
|
"KWP OAuth setup failed before provider authorization",
|
|
);
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain("geerkens2");
|
|
expect(mocks.beginKwpOAuthConnection).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("KWP OAuth callback route", () => {
|
|
it("clears an invalid challenge before any session, permission, or provider work", async () => {
|
|
mocks.consumeChallenge.mockResolvedValueOnce({
|
|
ok: false,
|
|
reason: "state-mismatch",
|
|
clearCookie: "kwp=; Max-Age=0",
|
|
});
|
|
const request = new Request("https://app.example.test/integrations/kwp/oauth/callback?code=code&state=tampered");
|
|
const response = await callbackLoader({ request } as never);
|
|
|
|
expect(response.status).toBe(302);
|
|
expect(response.headers.get("location")).toBe("/integrations/kwp/setup?kwp=error");
|
|
expect(response.headers.get("set-cookie")).toContain("Max-Age=0");
|
|
expect(mocks.runAuthenticatedProviderOAuthCallback).not.toHaveBeenCalled();
|
|
expect(mocks.completeKwpOAuthConnection).not.toHaveBeenCalled();
|
|
expect(mocks.loggerWarn).toHaveBeenCalledWith(
|
|
{
|
|
op: "kwp.oauth.callback.failed",
|
|
failureCode: "challenge_invalid",
|
|
diagnosticCode: "challenge_state_mismatch",
|
|
},
|
|
"KWP OAuth callback failed",
|
|
);
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain("tampered");
|
|
});
|
|
|
|
it("consumes provider errors, restores the reservation, and never exchanges the code", async () => {
|
|
const request = new Request(`https://app.example.test/integrations/kwp/oauth/callback?error=access_denied&state=${CHALLENGE.state}`);
|
|
const response = await callbackLoader({ request } as never);
|
|
|
|
expect(response.headers.get("location")).toBe("/acme/settings/integrations/kwp?kwp=error");
|
|
expect(response.headers.get("set-cookie")).toContain("Max-Age=0");
|
|
expect(mocks.runAuthenticatedProviderOAuthCallback).toHaveBeenCalledTimes(1);
|
|
expect(mocks.cancelKwpOAuthConnectionAttempt).toHaveBeenCalledWith({
|
|
tenantId: "tenant-1",
|
|
tenantSlug: "acme",
|
|
userId: "user-1",
|
|
connectionId: "connection-1",
|
|
version: CHALLENGE.connectionVersion,
|
|
});
|
|
expect(mocks.completeKwpOAuthConnection).not.toHaveBeenCalled();
|
|
expect(mocks.loggerWarn).toHaveBeenCalledWith(
|
|
{
|
|
op: "kwp.oauth.callback.failed",
|
|
failureCode: "provider_response_invalid",
|
|
diagnosticCode: "provider_access_denied",
|
|
},
|
|
"KWP OAuth callback failed"
|
|
);
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain(CHALLENGE.state);
|
|
});
|
|
|
|
it("rechecks session, tenant module, and permission before exchanging the code", async () => {
|
|
const request = new Request(
|
|
`https://app.example.test/integrations/kwp/oauth/callback?code=one-time-code&state=${CHALLENGE.state}&iss=${encodeURIComponent("https://id.kwp-online.de/realms/kwp-federated")}`
|
|
);
|
|
const response = await callbackLoader({ request } as never);
|
|
|
|
expect(response.status).toBe(302);
|
|
expect(response.headers.get("location")).toBe(
|
|
"/integrations/kwp/setup?tenant=acme&connection=connection-1",
|
|
);
|
|
expect(response.headers.get("set-cookie")).toContain("Max-Age=0");
|
|
expect(mocks.runAuthenticatedProviderOAuthCallback).toHaveBeenCalledWith({
|
|
request,
|
|
tenantId: "tenant-1",
|
|
userId: "user-1",
|
|
callback: expect.any(Function),
|
|
});
|
|
expect(mocks.loadIntegrationsContext).toHaveBeenCalledWith({
|
|
request,
|
|
params: { tenant: "acme" },
|
|
requireModule: true,
|
|
});
|
|
expect(mocks.requireIntegrationsPermission).toHaveBeenCalledWith(mocks.context, "integrations.connect");
|
|
expect(mocks.requireKwpIntegrationModule).toHaveBeenCalledWith(mocks.context);
|
|
expect(mocks.completeKwpOAuthConnection).toHaveBeenCalledWith({
|
|
callbackParameters: {
|
|
code: "one-time-code",
|
|
state: CHALLENGE.state,
|
|
iss: "https://id.kwp-online.de/realms/kwp-federated",
|
|
},
|
|
challenge: CHALLENGE,
|
|
});
|
|
});
|
|
|
|
it("rejects duplicate authorization parameters after consuming the challenge", async () => {
|
|
const request = new Request(`https://app.example.test/integrations/kwp/oauth/callback?code=one&code=two&state=${CHALLENGE.state}`);
|
|
const response = await callbackLoader({ request } as never);
|
|
|
|
expect(response.headers.get("location")).toBe("/acme/settings/integrations/kwp?kwp=error");
|
|
expect(mocks.consumeChallenge).toHaveBeenCalledWith(request, CHALLENGE.state);
|
|
expect(mocks.completeKwpOAuthConnection).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("logs only stable diagnostic codes when completion fails", async () => {
|
|
mocks.completeKwpOAuthConnection.mockRejectedValueOnce(new mocks.KwpConnectError("exchange_failed", { diagnosticCode: "missing_refresh_token" }));
|
|
const request = new Request(`https://app.example.test/integrations/kwp/oauth/callback?code=one-time-code&state=${CHALLENGE.state}`);
|
|
|
|
const response = await callbackLoader({ request } as never);
|
|
|
|
expect(response.headers.get("location")).toBe("/acme/settings/integrations/kwp?kwp=error");
|
|
expect(mocks.loggerWarn).toHaveBeenCalledWith(
|
|
{
|
|
op: "kwp.oauth.callback.failed",
|
|
failureCode: "exchange_failed",
|
|
diagnosticCode: "missing_refresh_token",
|
|
},
|
|
"KWP OAuth callback failed"
|
|
);
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain("one-time-code");
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain(CHALLENGE.state);
|
|
});
|
|
|
|
it("logs only the session bucket when callback access is no longer valid", async () => {
|
|
mocks.runAuthenticatedProviderOAuthCallback.mockRejectedValueOnce(
|
|
new mocks.ProviderOAuthCallbackAccessError("session_mismatch"),
|
|
);
|
|
const request = new Request(`https://app.example.test/integrations/kwp/oauth/callback?code=session-secret&state=${CHALLENGE.state}`);
|
|
|
|
const response = await callbackLoader({ request } as never);
|
|
|
|
expect(response.headers.get("location")).toBe("/acme/settings/integrations/kwp?kwp=error");
|
|
expect(mocks.loggerWarn).toHaveBeenCalledWith(
|
|
{
|
|
op: "kwp.oauth.callback.failed",
|
|
failureCode: "session_mismatch",
|
|
},
|
|
"KWP OAuth callback failed"
|
|
);
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain("session-secret");
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain(CHALLENGE.state);
|
|
});
|
|
|
|
it("redacts unexpected callback error details", async () => {
|
|
mocks.completeKwpOAuthConnection.mockRejectedValueOnce(new Error(`unexpected-secret ${CHALLENGE.state}`));
|
|
const request = new Request(`https://app.example.test/integrations/kwp/oauth/callback?code=one-time-code&state=${CHALLENGE.state}`);
|
|
|
|
const response = await callbackLoader({ request } as never);
|
|
|
|
expect(response.headers.get("location")).toBe("/acme/settings/integrations/kwp?kwp=error");
|
|
expect(mocks.loggerWarn).toHaveBeenCalledWith(
|
|
{
|
|
op: "kwp.oauth.callback.failed",
|
|
failureCode: "callback_access_or_unexpected",
|
|
errorName: "Error",
|
|
},
|
|
"KWP OAuth callback failed"
|
|
);
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain("unexpected-secret");
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain("one-time-code");
|
|
expect(JSON.stringify(mocks.loggerWarn.mock.calls)).not.toContain(CHALLENGE.state);
|
|
});
|
|
});
|