import { beforeEach, describe, expect, it, vi } from "vitest"; const mocks = vi.hoisted(() => ({ context: { tenantId: "tenant_1", userId: "user_1", permissions: ["integrations.read", "integrations.connect", "integrations.disconnect"], hasModule: true, }, loadIntegrationsContext: vi.fn(), listConnections: vi.fn(), createConnection: vi.fn(), reconnectConnection: vi.fn(), disconnectConnection: vi.fn(), runSyncForConnection: vi.fn(), getConnectionOrThrow: vi.fn(), listSyncRuns: vi.fn(), getSyncRunWithItems: vi.fn(), hasKwpIntegrationModule: vi.fn(), requireKwpIntegrationModule: vi.fn(), validateCSRFToken: vi.fn(), })); vi.mock("~/components/screens/integrations/IntegrationsCatalogPage", () => ({ IntegrationsCatalogPage: () => null, })); vi.mock("~/components/screens/integrations/ConnectionDetailPage", () => ({ ConnectionDetailPage: () => null, })); vi.mock("~/components/ui/errors/ServerError", () => ({ default: () => null })); vi.mock("~/locale/i18next.server", () => ({ getTranslations: () => Promise.resolve({ t: (key: string) => key }), })); vi.mock("~/utils/integrations/integrationsAccess.server", () => ({ badRequestResponse: () => new Response("Bad Request", { status: 400 }), integrationsActionErrorResponse: () => Response.json({ error: "integrations.errors.mutationFailed" }, { status: 400 }), integrationsHasPermission: () => true, loadIntegrationsContext: mocks.loadIntegrationsContext, notFoundResponse: () => new Response("Not Found", { status: 404 }), requireIntegrationsPermission: () => undefined, })); vi.mock("~/utils/integrations/appsEngineService.server", () => ({ createConnection: mocks.createConnection, disconnectConnection: mocks.disconnectConnection, getConnectionOrThrow: mocks.getConnectionOrThrow, getSyncRunWithItems: mocks.getSyncRunWithItems, listConnections: mocks.listConnections, listSyncRuns: mocks.listSyncRuns, reconnectConnection: mocks.reconnectConnection, runSyncForConnection: mocks.runSyncForConnection, })); vi.mock("~/modules/kwp/routes/kwpAccess.server", () => ({ hasKwpIntegrationModule: mocks.hasKwpIntegrationModule, requireKwpIntegrationModule: mocks.requireKwpIntegrationModule, })); vi.mock("~/utils/session.server", () => ({ validateCSRFToken: mocks.validateCSRFToken })); import { loader as catalogLoader } from "./integrations._index"; import { action as appAction, loader as appLoader } from "./integrations.$app._index"; import { loader as syncHistoryLoader } from "./integrations.$app.$connectionId.syncs._index"; import { loader as syncRunDetailLoader } from "./integrations.$app.$connectionId.syncs.$runId"; beforeEach(() => { vi.clearAllMocks(); mocks.loadIntegrationsContext.mockResolvedValue(mocks.context); mocks.listConnections.mockResolvedValue([]); mocks.createConnection.mockResolvedValue({ id: "connection_new" }); mocks.listSyncRuns.mockResolvedValue([]); mocks.runSyncForConnection.mockResolvedValue({ runId: "run_1", status: "completed" }); mocks.hasKwpIntegrationModule.mockResolvedValue(true); mocks.requireKwpIntegrationModule.mockImplementation(async (context: unknown) => context); mocks.validateCSRFToken.mockResolvedValue(undefined); }); describe("telephony integration routing", () => { it("links the Aircall and HalloPetra catalog cards to the dedicated telephony settings", async () => { const response = await catalogLoader({ request: new Request("https://app.example.test/acme/settings/integrations"), params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations", }); const body = (await response.json()) as { vm: { status: string; data?: { rows: Array<{ key: string; detailHref: string }> } }; }; expect(body.vm.data?.rows.find((row) => row.key === "aircall")?.detailHref).toBe("/acme/settings/integrations/telephony"); expect(body.vm.data?.rows.find((row) => row.key === "hallopetra")?.detailHref).toBe("/acme/settings/integrations/telephony"); }); it("hides KWP from the catalog when the dedicated add-on is unavailable", async () => { mocks.hasKwpIntegrationModule.mockResolvedValueOnce(false); const response = await catalogLoader({ request: new Request("https://app.example.test/acme/settings/integrations"), params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations", }); const body = (await response.json()) as { vm: { data?: { rows: Array<{ key: string }> } }; }; expect(body.vm.data?.rows.some((row) => row.key === "kwp")).toBe(false); }); it.each(["aircall", "hallopetra"])("redirects the generic %s detail loader to telephony settings", async (app) => { const thrown = await appLoader({ request: new Request(`https://app.example.test/acme/settings/integrations/${app}`), params: { tenant: "acme", app }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }).catch((error: unknown) => error); expect(thrown).toBeInstanceOf(Response); expect((thrown as Response).status).toBe(302); expect((thrown as Response).headers.get("location")).toBe("/acme/settings/integrations/telephony"); expect(mocks.listConnections).not.toHaveBeenCalled(); }); it.each(["aircall", "hallopetra"])("blocks generic lifecycle mutations for %s", async (app) => { for (const intent of ["connect", "reconnect", "disconnect", "manual-sync"]) { const request = new Request(`https://app.example.test/acme/settings/integrations/${app}`, { method: "POST", body: new URLSearchParams({ intent, connectionId: "connection_1", label: app }), }); const thrown = await appAction({ request, params: { tenant: "acme", app }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }).catch((error: unknown) => error); expect(thrown).toBeInstanceOf(Response); expect((thrown as Response).status).toBe(303); expect((thrown as Response).headers.get("location")).toBe("/acme/settings/integrations/telephony"); expect(mocks.createConnection).not.toHaveBeenCalled(); expect(mocks.reconnectConnection).not.toHaveBeenCalled(); expect(mocks.disconnectConnection).not.toHaveBeenCalled(); expect(mocks.runSyncForConnection).not.toHaveBeenCalled(); } }); it.each(["connect", "reconnect"])("routes the KWP %s mutation through the protected OAuth setup", async (intent) => { const request = new Request("https://app.example.test/acme/settings/integrations/kwp", { method: "POST", body: new URLSearchParams({ intent, connectionId: "connection_1", label: "KWP" }), }); const thrown = await appAction({ request, params: { tenant: "acme", app: "kwp" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }).catch((error: unknown) => error); expect(thrown).toBeInstanceOf(Response); expect((thrown as Response).status).toBe(303); expect((thrown as Response).headers.get("location")).toBe("/integrations/kwp/setup?tenant=acme"); expect(mocks.requireKwpIntegrationModule).toHaveBeenCalledWith(mocks.context); expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { formData: expect.anything() }); expect(mocks.createConnection).not.toHaveBeenCalled(); expect(mocks.reconnectConnection).not.toHaveBeenCalled(); }); it("renders callback feedback and hides manual sync for the callback-only KWP slice", async () => { mocks.listConnections.mockResolvedValueOnce([ { id: "connection_1", label: "KWP Geerkens", connectionStatus: "active", healthMessageKey: null, lastHealthCheck: null, tokenExpiresAt: null, }, ]); const response = await appLoader({ request: new Request("https://app.example.test/acme/settings/integrations/kwp?kwp=connected"), params: { tenant: "acme", app: "kwp" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }); await expect(response.json()).resolves.toMatchObject({ feedback: { variant: "success", titleKey: "integrations.kwp.oauth.connected", descriptionKey: "integrations.kwp.oauth.connectedBody", }, vm: { data: { connectHref: "/integrations/kwp/setup?tenant=acme", canDisconnect: false, canManualSync: false, rows: [{ id: "connection_1", syncsHref: null }], }, }, }); }); it("does not trust a connected query flag without an active KWP connection", async () => { const response = await appLoader({ request: new Request("https://app.example.test/acme/settings/integrations/kwp?kwp=connected"), params: { tenant: "acme", app: "kwp" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }); await expect(response.json()).resolves.toMatchObject({ feedback: null }); }); it("blocks the direct KWP sync-history route after the dedicated module gate", async () => { const thrown = await syncHistoryLoader({ request: new Request("https://app.example.test/acme/settings/integrations/kwp/connection_1/syncs"), params: { tenant: "acme", app: "kwp", connectionId: "connection_1" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app/:connectionId/syncs", }).catch((error: unknown) => error); expect(thrown).toBeInstanceOf(Response); expect((thrown as Response).status).toBe(404); expect(mocks.requireKwpIntegrationModule).toHaveBeenCalledWith(mocks.context); expect(mocks.getConnectionOrThrow).not.toHaveBeenCalled(); expect(mocks.listSyncRuns).not.toHaveBeenCalled(); }); it("blocks KWP manual sync before creating a false successful empty run", async () => { const request = new Request("https://app.example.test/acme/settings/integrations/kwp", { method: "POST", body: new URLSearchParams({ intent: "manual-sync", connectionId: "connection_1", csrf: "csrf-token" }), }); const thrown = await appAction({ request, params: { tenant: "acme", app: "kwp" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }).catch((error: unknown) => error); expect(thrown).toBeInstanceOf(Response); expect((thrown as Response).status).toBe(404); expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { formData: expect.anything() }); expect(mocks.runSyncForConnection).not.toHaveBeenCalled(); }); it("blocks a local-only KWP disconnect until provider revocation is verified", async () => { const request = new Request("https://app.example.test/acme/settings/integrations/kwp", { method: "POST", body: new URLSearchParams({ intent: "disconnect", connectionId: "connection_1", csrf: "csrf-token" }), }); const thrown = await appAction({ request, params: { tenant: "acme", app: "kwp" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }).catch((error: unknown) => error); expect(thrown).toBeInstanceOf(Response); expect((thrown as Response).status).toBe(404); expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { formData: expect.anything() }); expect(mocks.disconnectConnection).not.toHaveBeenCalled(); }); it("passes the URL app key into every generic connection mutation", async () => { await appAction({ request: new Request("https://app.example.test/acme/settings/integrations/sample-data-sync", { method: "POST", body: new URLSearchParams({ intent: "reconnect", connectionId: "connection_1", apiKey: "fixture" }), }), params: { tenant: "acme", app: "sample-data-sync" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }); expect(mocks.reconnectConnection).toHaveBeenCalledWith( expect.objectContaining({ connectionId: "connection_1", expectedAppId: "sample-data-sync" }), ); await appAction({ request: new Request("https://app.example.test/acme/settings/integrations/sample-data-sync", { method: "POST", body: new URLSearchParams({ intent: "disconnect", connectionId: "connection_1" }), }), params: { tenant: "acme", app: "sample-data-sync" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }); expect(mocks.disconnectConnection).toHaveBeenCalledWith( expect.objectContaining({ connectionId: "connection_1", expectedAppId: "sample-data-sync" }), ); await appAction({ request: new Request("https://app.example.test/acme/settings/integrations/sample-data-sync", { method: "POST", body: new URLSearchParams({ intent: "manual-sync", connectionId: "connection_1" }), }), params: { tenant: "acme", app: "sample-data-sync" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }); expect(mocks.runSyncForConnection).toHaveBeenCalledWith( expect.objectContaining({ connectionId: "connection_1", expectedAppId: "sample-data-sync" }), ); }); it.each([ ["connect", "integrations.connections.feedback.connected"], ["reconnect", "integrations.connections.feedback.reconnected"], ["disconnect", "integrations.connections.feedback.disconnected"], ["manual-sync", "integrations.connections.feedback.syncStarted"], ] as const)("returns action-specific toast feedback for %s", async (intent, messageKey) => { const response = await appAction({ request: new Request("https://app.example.test/acme/settings/integrations/sample-data-sync", { method: "POST", body: new URLSearchParams({ intent, connectionId: "connection_1", label: "Sample Sync", apiKey: "fixture", }), }), params: { tenant: "acme", app: "sample-data-sync" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }); await expect(response.json()).resolves.toMatchObject({ intent, ok: true, messageKey }); }); it("keeps the manual-sync intent on a mapped action error", async () => { mocks.runSyncForConnection.mockRejectedValueOnce(new Error("provider unavailable")); const response = await appAction({ request: new Request("https://app.example.test/acme/settings/integrations/sample-data-sync", { method: "POST", body: new URLSearchParams({ intent: "manual-sync", connectionId: "connection_1" }), }), params: { tenant: "acme", app: "sample-data-sync" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app", }); expect(response.status).toBe(400); await expect(response.json()).resolves.toEqual({ intent: "manual-sync", error: "integrations.errors.mutationFailed", }); }); it("passes the URL app key through sync history and run-detail reads", async () => { mocks.getSyncRunWithItems.mockResolvedValueOnce({ run: { id: "run_1", dataConnectionId: "connection_1", kind: "manual", status: "completed", itemsTotal: 0, itemsSucceeded: 0, itemsFailed: 0, summaryText: null, startedAt: null, completedAt: null, }, items: [], logs: [], }); await syncHistoryLoader({ request: new Request("https://app.example.test/acme/settings/integrations/sample-data-sync/connection_1/syncs"), params: { tenant: "acme", app: "sample-data-sync", connectionId: "connection_1" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app/:connectionId/syncs", }); expect(mocks.getConnectionOrThrow).toHaveBeenCalledWith("tenant_1", "connection_1", "sample-data-sync"); expect(mocks.listSyncRuns).toHaveBeenCalledWith("tenant_1", "connection_1", "sample-data-sync"); await syncRunDetailLoader({ request: new Request("https://app.example.test/acme/settings/integrations/sample-data-sync/connection_1/syncs/run_1"), params: { tenant: "acme", app: "sample-data-sync", connectionId: "connection_1", runId: "run_1" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app/:connectionId/syncs/:runId", }); expect(mocks.getSyncRunWithItems).toHaveBeenCalledWith( "tenant_1", "run_1", "connection_1", "sample-data-sync", ); }); it("blocks the direct KWP sync-run detail route after the dedicated module gate", async () => { const thrown = await syncRunDetailLoader({ request: new Request("https://app.example.test/acme/settings/integrations/kwp/connection_1/syncs/run_1"), params: { tenant: "acme", app: "kwp", connectionId: "connection_1", runId: "run_1" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/:app/:connectionId/syncs/:runId", }).catch((error: unknown) => error); expect(thrown).toBeInstanceOf(Response); expect((thrown as Response).status).toBe(404); expect(mocks.requireKwpIntegrationModule).toHaveBeenCalledWith(mocks.context); expect(mocks.getConnectionOrThrow).not.toHaveBeenCalled(); expect(mocks.getSyncRunWithItems).not.toHaveBeenCalled(); }); });