Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,316 @@
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 });
});
});