172 lines
7.6 KiB
TypeScript
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" });
|
|
});
|
|
});
|