Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/admin/system/jobs.test.tsx
T

172 lines
7.6 KiB
TypeScript

// @vitest-environment node
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ActionFunctionArgs, LoaderFunctionArgs } from "react-router";
import { getTranslations } from "~/locale/i18next.server";
import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService";
import { getUserInfo, validateCSRFToken } from "~/utils/session.server";
import { getUser } from "~/utils/db/users.db.server";
import { userHasPermission } from "~/utils/db/permissions/userRoles.db.server";
import {
getQueueFailedJobsSnapshot,
getQueueMonitorSnapshot,
pauseQueue,
QueueMonitorControlError,
resumeQueue,
retryQueueJob,
} from "~/services/admin/queue-monitor.server";
import { setOperatorPortalDomainKillSwitch } from "~/services/admin/portal-domain-operator.server";
import { action, loader } from "./jobs";
vi.mock("react-i18next", () => ({
useTranslation: () => ({ t: (key: string, params?: Record<string, string | number>) => (params ? `${key}:${Object.values(params).join(":")}` : key) }),
}));
vi.mock("~/components/ui/layouts/EditPageLayout", () => ({ default: () => null }));
vi.mock("~/components/ui/errors/ServerError", () => ({ default: () => null }));
vi.mock("~/components/ui/buttons/ButtonPrimary", () => ({ default: () => null }));
vi.mock("~/components/ui/buttons/ButtonSecondary", () => ({ default: () => null }));
vi.mock("~/utils/data/useRootData", () => ({ useRootData: () => ({ csrf: "csrf" }) }));
vi.mock("~/locale/format", () => ({
useLocaleFormatters: () => ({
dateTime: (value: Date) => value.toISOString(),
}),
}));
vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn() }));
vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: vi.fn() }));
vi.mock("~/utils/session.server", () => ({ getUserInfo: vi.fn(), validateCSRFToken: vi.fn() }));
vi.mock("~/utils/db/users.db.server", () => ({ getUser: vi.fn() }));
vi.mock("~/utils/db/permissions/userRoles.db.server", () => ({ userHasPermission: vi.fn() }));
vi.mock("~/services/admin/queue-monitor.server", () => ({
getQueueMonitorSnapshot: vi.fn(),
getQueueFailedJobsSnapshot: vi.fn(),
pauseQueue: vi.fn(),
resumeQueue: vi.fn(),
retryQueueJob: vi.fn(),
QueueMonitorControlError: class QueueMonitorControlError extends Error {
constructor(readonly code: string, message: string) {
super(message);
}
},
}));
vi.mock("~/services/admin/admin-action-audit.server", () => ({
AdminActionInputError: class AdminActionInputError extends Error {
readonly i18nKey = "admin.audit.errors.reasonRequired";
},
}));
vi.mock("~/services/admin/portal-domain-operator.server", () => ({
PORTAL_DOMAIN_KILL_SWITCH_PERMISSION: "admin.settings.danger.reset",
PortalDomainOperatorError: class PortalDomainOperatorError extends Error {},
setOperatorPortalDomainKillSwitch: vi.fn(),
}));
vi.mock("~/services/customer-portal/portal-domain.server", () => ({
PortalDomainError: class PortalDomainError extends Error {},
}));
function callLoader(url = "https://admin.example.test/system/jobs") {
return loader({ request: new Request(url), params: {}, context: {} } as LoaderFunctionArgs);
}
function callAction(form: Record<string, string>) {
return action({
request: new Request("https://admin.example.test/system/jobs", {
method: "POST",
body: new URLSearchParams(form),
}),
params: {},
context: {},
} as ActionFunctionArgs);
}
describe("admin jobs route", () => {
beforeEach(() => {
vi.clearAllMocks();
process.env.APP_NAME = "HiveGrid";
vi.mocked(verifyUserHasPermission).mockResolvedValue(undefined as never);
vi.mocked(getTranslations).mockResolvedValue({ t: (key: string) => key } as never);
vi.mocked(validateCSRFToken).mockResolvedValue(undefined as never);
vi.mocked(getUserInfo).mockResolvedValue({ userId: "admin_1" } as never);
vi.mocked(getUser).mockResolvedValue({ id: "admin_1", email: "admin@hivegrid.de" } as never);
vi.mocked(userHasPermission).mockResolvedValue(true);
vi.mocked(getQueueMonitorSnapshot).mockResolvedValue([
{ queueName: "hivegrid.email", group: "mail", active: 1, waiting: 2, delayed: 0, failed: 3, completed: 10, paused: false },
] as never);
vi.mocked(getQueueFailedJobsSnapshot).mockResolvedValue([
{
queueName: "hivegrid.email",
jobs: [{ id: "job_1", name: "deliver-webhook", failedReason: "Timeout", attemptsMade: 2, timestamp: 1783549200000 }],
},
] as never);
});
it("checks metrics permission and builds queue monitor data", async () => {
const data = await callLoader();
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "admin.metrics.view");
expect(getQueueMonitorSnapshot).toHaveBeenCalledOnce();
expect(getQueueFailedJobsSnapshot).toHaveBeenCalledWith(5);
expect(data.vm.status).toBe("ready");
if (data.vm.status !== "ready") return;
expect(data.vm.data.failedTotal).toBe(3);
expect(data.failedJobs[0].jobs[0].name).toBe("deliver-webhook");
expect(data.canManagePortalDomainKillSwitch).toBe(true);
});
it("returns a renderable error state when Redis/BullMQ is unavailable", async () => {
vi.mocked(getQueueMonitorSnapshot).mockRejectedValueOnce(new Error("redis missing"));
const data = await callLoader();
expect(data.vm.status).toBe("error");
expect(data.failedJobs).toEqual([]);
});
it("routes pause, resume, and retry actions to the audited queue service", async () => {
await callAction({ csrf: "csrf", action: "pause", queueName: "hivegrid.email" });
await callAction({ csrf: "csrf", action: "resume", queueName: "hivegrid.email" });
await callAction({ csrf: "csrf", action: "retry-job", queueName: "hivegrid.email", jobId: "job_1" });
expect(validateCSRFToken).toHaveBeenCalledTimes(3);
expect(pauseQueue).toHaveBeenCalledWith(expect.objectContaining({ queueName: "hivegrid.email", actorUserId: "admin_1" }));
expect(resumeQueue).toHaveBeenCalledWith(expect.objectContaining({ queueName: "hivegrid.email", actorEmail: "admin@hivegrid.de" }));
expect(retryQueueJob).toHaveBeenCalledWith(expect.objectContaining({ queueName: "hivegrid.email", jobId: "job_1" }));
});
it("preserves generation-aware recovery guidance for the financial provider queue", async () => {
vi.mocked(retryQueueJob).mockRejectedValueOnce(
new QueueMonitorControlError("DIRECT_OUTBOX_RETRY_FORBIDDEN", "use outbox replay"),
);
const response = await callAction({
csrf: "csrf",
action: "retry-job",
queueName: "outbox.billing-product-provider",
jobId: "job_1",
});
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({ error: "admin.jobs.errors.directOutboxRetryForbidden" });
});
it("requires the destructive operator permission and delegates the portal-domain kill switch", async () => {
const response = await callAction({
csrf: "csrf",
action: "portal-domain-kill-enable",
tenantId: "tenant_1",
reason: "Compromised routing",
});
expect(response.status).toBe(200);
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "admin.metrics.view");
expect(verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "admin.settings.danger.reset");
expect(setOperatorPortalDomainKillSwitch).toHaveBeenCalledWith(
expect.objectContaining({
tenantId: "tenant_1",
actorUserId: "admin_1",
enabled: true,
reason: "Compromised routing",
request: expect.any(Request),
}),
);
await expect(response.json()).resolves.toEqual({ success: "admin.jobs.portalDomainKillSwitch.enabled" });
});
});