import { beforeEach, describe, expect, it, vi } from "vitest"; import { CatalogError, foundationErrors } from "@hivegrid/foundation"; const mocks = vi.hoisted(() => ({ context: { tenantId: "tenant_1", userId: "user_1", tenantUserId: "tenant_user_1", permissions: ["telephony.manage"], hasModule: true, }, loadTelephonyContext: vi.fn(), requireTelephonyPermission: vi.fn(), connectHalloPetra: vi.fn(), loadTelephonyCalls: vi.fn(), loadTelephonyCallDetail: vi.fn(), loadTelephonySettings: vi.fn(), saveTelephonyCallNote: vi.fn(), overrideTelephonyCallMatch: vi.fn(), startTelephonyCallBack: vi.fn(), checkTelephonyConnection: vi.fn(), saveTelephonyUserBinding: vi.fn(), disconnectTelephonyConnection: vi.fn(), validateCSRFToken: vi.fn(), })); vi.mock("~/components/screens/telephony/TelephonyCallsPage", () => ({ TelephonyCallsPage: () => null, })); vi.mock("~/components/screens/telephony/TelephonyCallDetailPage", () => ({ TelephonyCallDetailPage: () => null, })); vi.mock("~/components/screens/telephony/TelephonySettingsPage", () => ({ TelephonySettingsPage: () => null, })); vi.mock("~/components/ui/errors/ServerError", () => ({ default: () => null })); vi.mock("~/locale/i18next.server", () => ({ getTranslations: () => Promise.resolve({ t: (key: string) => key }), })); vi.mock("~/modules/telephony/routes/telephonyAccess.server", () => ({ loadTelephonyContext: mocks.loadTelephonyContext, requireTelephonyPermission: mocks.requireTelephonyPermission, TELEPHONY_PERMISSIONS: { manage: "telephony.manage" }, })); vi.mock("~/modules/telephony/services/HalloPetraConnectionService.server", () => ({ HalloPetraConnectError: class HalloPetraConnectError extends Error {}, connectHalloPetra: mocks.connectHalloPetra, })); vi.mock("~/modules/telephony/services/TelephonyService.server", () => ({ TelephonyServiceError: class TelephonyServiceError extends Error { readonly messageKey: string; constructor(messageKey: string) { super(messageKey); this.messageKey = messageKey; } }, loadTelephonyCalls: mocks.loadTelephonyCalls, loadTelephonyCallDetail: mocks.loadTelephonyCallDetail, loadTelephonySettings: mocks.loadTelephonySettings, saveTelephonyCallNote: mocks.saveTelephonyCallNote, overrideTelephonyCallMatch: mocks.overrideTelephonyCallMatch, startTelephonyCallBack: mocks.startTelephonyCallBack, checkTelephonyConnection: mocks.checkTelephonyConnection, saveTelephonyUserBinding: mocks.saveTelephonyUserBinding, disconnectTelephonyConnection: mocks.disconnectTelephonyConnection, })); vi.mock("~/utils/session.server", () => ({ validateCSRFToken: mocks.validateCSRFToken, })); import { loader as callsLoader } from "./calls._index"; import { action as callDetailAction } from "./calls.$id"; import { action as settingsAction, loader as settingsLoader } from "./settings/integrations/telephony"; function postRequest(fields: Record): Request { return new Request("https://app.example.test/acme/calls/call_1", { method: "POST", body: new URLSearchParams({ ...fields, csrf: "csrf-token" }), }); } beforeEach(() => { vi.clearAllMocks(); mocks.loadTelephonyContext.mockResolvedValue(mocks.context); mocks.loadTelephonyCalls.mockResolvedValue({ status: "ready", data: { rows: [], canReadAll: true }, }); mocks.saveTelephonyCallNote.mockResolvedValue(undefined); mocks.overrideTelephonyCallMatch.mockResolvedValue(undefined); mocks.startTelephonyCallBack.mockResolvedValue({ accepted: true }); mocks.checkTelephonyConnection.mockResolvedValue(undefined); mocks.saveTelephonyUserBinding.mockResolvedValue(undefined); mocks.disconnectTelephonyConnection.mockResolvedValue(undefined); mocks.connectHalloPetra.mockResolvedValue({ dataConnectionId: "data_connection_1", telephonyConnectionId: "telephony_connection_1", webhookUrl: "https://api.example.test/v1/webhooks/telephony/hallopetra", webhookSecret: "separate-webhook-secret", }); mocks.validateCSRFToken.mockResolvedValue(undefined); }); describe("telephony tenant routes", () => { it("preserves a CatalogError status from the settings loader as an HTTP response", async () => { mocks.loadTelephonyContext.mockRejectedValueOnce( new CatalogError(foundationErrors.notFound, { module: "telephony" }), ); const result = settingsLoader({ request: new Request("https://app.example.test/acme/settings/integrations/telephony"), params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/telephony", }); await expect(result).rejects.toBeInstanceOf(Response); await expect(result).rejects.toMatchObject({ status: 404 }); }); it("preserves a CatalogError status from the settings action as an HTTP response", async () => { mocks.loadTelephonyContext.mockRejectedValueOnce( new CatalogError(foundationErrors.notFound, { module: "telephony" }), ); const result = settingsAction({ request: postRequest({ intent: "connectHallopetra", apiKey: "provider-api-key" }), params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/telephony", }); await expect(result).rejects.toBeInstanceOf(Response); await expect(result).rejects.toMatchObject({ status: 404 }); }); it("loads /calls with the module gate and tenant slug", async () => { const response = await callsLoader({ request: new Request("https://app.example.test/acme/calls"), params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/calls", }); expect(mocks.loadTelephonyContext).toHaveBeenCalledWith({ request: expect.any(Request), params: { tenant: "acme" }, requireModule: true, }); expect(mocks.loadTelephonyCalls).toHaveBeenCalledWith(mocks.context, "acme"); await expect(response.json()).resolves.toMatchObject({ title: `telephony.calls.title | ${process.env.APP_NAME}`, }); }); it("parses the call-detail match override before invoking the service", async () => { const request = postRequest({ intent: "overrideMatch", matchType: "project", matchId: "project_1", }); const response = await callDetailAction({ request, params: { tenant: "acme", id: "call_1" }, context: undefined, unstable_pattern: "/:tenant/calls/:id", }); expect(mocks.overrideTelephonyCallMatch).toHaveBeenCalledWith(mocks.context, { callId: "call_1", match: { type: "project", id: "project_1" }, }); expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { formData: expect.anything() }); expect(response.status).toBe(200); await expect(response.json()).resolves.toEqual({ intent: "overrideMatch", ok: true, messageKey: "telephony.callDetail.feedback.matchSaved", }); }); it("varies call-detail feedback for notes, removed matches and callbacks", async () => { const cases = [ { fields: { intent: "saveNote", noteMarkdown: "Rückruf am Montag" }, messageKey: "telephony.callDetail.feedback.noteSaved", }, { fields: { intent: "overrideMatch", matchType: "", matchId: "" }, messageKey: "telephony.callDetail.feedback.matchRemoved", }, { fields: { intent: "callBack" }, messageKey: "telephony.callDetail.feedback.callbackStarted", }, ] as const; for (const testCase of cases) { const response = await callDetailAction({ request: postRequest(testCase.fields), params: { tenant: "acme", id: "call_1" }, context: undefined, unstable_pattern: "/:tenant/calls/:id", }); await expect(response.json()).resolves.toMatchObject({ intent: testCase.fields.intent, ok: true, messageKey: testCase.messageKey, }); } }); it("parses a manual settings binding without trusting a tenant id from the form", async () => { const request = postRequest({ intent: "saveBinding", connectionId: "data_connection_1", providerUserId: "provider_user_1", tenantUserId: "tenant_user_2", }); const response = await settingsAction({ request, params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/telephony", }); expect(mocks.saveTelephonyUserBinding).toHaveBeenCalledWith(mocks.context, { dataConnectionId: "data_connection_1", providerUserId: "provider_user_1", tenantUserId: "tenant_user_2", }); expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { formData: expect.anything() }); expect(response.status).toBe(200); await expect(response.json()).resolves.toEqual({ intent: "saveBinding", ok: true, messageKey: "telephony.settings.feedback.bindingSaved", }); }); it.each([ ["healthCheck", "telephony.settings.feedback.healthChecked"], ["disconnect", "telephony.settings.feedback.disconnected"], ] as const)("returns action-specific settings feedback for %s", async (intent, messageKey) => { const response = await settingsAction({ request: postRequest({ intent, connectionId: "data_connection_1" }), params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/telephony", }); await expect(response.json()).resolves.toEqual({ intent, ok: true, messageKey }); }); it("requires telephony management permission and returns the one-time HalloPetra webhook setup", async () => { const request = postRequest({ intent: "connectHallopetra", apiKey: "provider-api-key", tenantId: "attacker-controlled-tenant", }); const response = await settingsAction({ request, params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/telephony", }); expect(mocks.requireTelephonyPermission).toHaveBeenCalledWith(mocks.context, "telephony.manage"); expect(mocks.connectHalloPetra).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1", apiKey: "provider-api-key", }); await expect(response.json()).resolves.toEqual({ intent: "connectHallopetra", ok: true, messageKey: "telephony.settings.feedback.connected", hallopetraSetup: { webhookUrl: "https://api.example.test/v1/webhooks/telephony/hallopetra", webhookSecret: "separate-webhook-secret", }, }); }); it("varies HalloPetra feedback when an existing connection is reconnected", async () => { const response = await settingsAction({ request: postRequest({ intent: "reconnectHallopetra", apiKey: "replacement-key" }), params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/telephony", }); await expect(response.json()).resolves.toMatchObject({ intent: "reconnectHallopetra", ok: true, messageKey: "telephony.settings.feedback.reconnected", }); }); it.each([ ["connected", { intent: "connect", ok: true, messageKey: "telephony.settings.feedback.connected" }], ["error", { intent: "connect", error: "telephony.settings.feedback.connectionFailed" }], ] as const)("maps the server-confirmed Aircall %s callback to toast feedback", async (outcome, callbackResult) => { mocks.loadTelephonySettings.mockResolvedValue({ status: "ready", data: {} }); const response = await settingsLoader({ request: new Request(`https://app.example.test/acme/settings/integrations/telephony?aircall=${outcome}`), params: { tenant: "acme" }, context: undefined, unstable_pattern: "/:tenant/settings/integrations/telephony", }); await expect(response.json()).resolves.toMatchObject({ callbackResult }); }); });