317 lines
12 KiB
TypeScript
317 lines
12 KiB
TypeScript
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<string, string>): 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 });
|
|
});
|
|
});
|