Refresh HiveGrid Cloud reference snapshot
This commit is contained in:
1 parent
5e99e14772
commit
7f88026f79
5955 files changed
+1177325
-188362
No files matched your search
+686
@@ -0,0 +1,686 @@
|
||||
// @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);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user