import type { ActionFunctionArgs } from "react-router"; import { beforeEach, describe, expect, it, vi } from "vitest"; const globalMockStoreKey = "__importsDryRunRouteTestMocks__"; const globalMockStore = globalThis as typeof globalThis & { __importsDryRunRouteTestMocks__?: { requireAuth: ReturnType; createImportJob: ReturnType; markImportJobRunning: ReturnType; markImportJobSucceeded: ReturnType; markImportJobFailed: ReturnType; createImportDryRunPreview: ReturnType; verifyUserHasPermission: ReturnType; }; }; globalMockStore.__importsDryRunRouteTestMocks__ ??= { requireAuth: vi.fn(), createImportJob: vi.fn(), markImportJobRunning: vi.fn(), markImportJobSucceeded: vi.fn(), markImportJobFailed: vi.fn(), createImportDryRunPreview: vi.fn(), verifyUserHasPermission: vi.fn(), }; const mocks = globalMockStore[globalMockStoreKey]; const translations: Record = { "models.row.import.errors.dryRunFailed": "Import dry-run failed.", "models.row.import.errors.dryRunFailedBeforeCompletion": "The import dry-run failed before completion.", "models.row.import.errors.sourceStorageAccessDenied": "Import source storage access denied.", "models.row.import.errors.sourceRequired": "Source is required.", "models.row.import.errors.mappingsRequired": "Mappings must include at least one field mapping.", "models.row.import.errors.methodNotAllowed": "Method not allowed.", "models.row.import.errors.unsupportedFormat": "Unsupported import format.", "models.row.import.errors.unsupportedType": "Unsupported import type: {{importType}}", }; vi.mock("~/utils/loaders.middleware", () => ({ requireAuth: mocks.requireAuth, })); vi.mock("~/locale/i18next.server", () => ({ getTranslations: vi.fn(async () => ({ locale: "en", translations: {}, t: (key: string, options?: Record) => (translations[key] ?? key).replace("{{importType}}", String(options?.importType ?? "")), })), })); vi.mock("~/utils/helpers/.server/PermissionsService", () => ({ verifyUserHasPermission: mocks.verifyUserHasPermission, })); vi.mock("~/utils/session.server", () => ({ validateCSRFToken: vi.fn(), })); vi.mock("@toolctrl/db/import-jobs.server", () => ({ createImportJob: mocks.createImportJob, markImportJobRunning: mocks.markImportJobRunning, markImportJobSucceeded: mocks.markImportJobSucceeded, markImportJobFailed: mocks.markImportJobFailed, })); vi.mock("@toolctrl/imports", () => ({ createImportDryRunPreview: mocks.createImportDryRunPreview, createRedactedParserDiagnostic: (code: string, message: string, options: Record = {}) => ({ severity: "error", ...options, code, message: message.replace( /(?:api[_-]?key|authorization|bearer|password|secret|token|rawBody)\s*[:=]\s*[^\s,;]+/gi, (match) => `${match.split(/[:=]/, 1)[0]}: [REDACTED]` ), }), isSupportedImportFormat: (value: string) => ["csv", "json", "xlsx"].includes(value), redactDiagnosticMessage: (message: string) => message.replace( /(?:api[_-]?key|authorization|bearer|password|secret|token|rawBody)\s*[:=]\s*[^\s,;]+/gi, (match) => `${match.split(/[:=]/, 1)[0]}: [REDACTED]` ), })); const validBody = { format: "csv", importType: "members", source: { tenantId: "tenant_1", sourceKey: "tenants/tenant_1/uploads/import.csv", fileName: "import.csv", contentType: "text/csv", requestId: "request_1", }, fields: [{ targetField: "email", required: true, label: "Email" }], mappings: [{ sourceColumn: "Email", targetField: "email", required: true, label: "Email" }], rows: [{ rowNumber: 1, values: { Email: "ada@example.com" } }], }; const preview = { rows: [{ ok: true, rowNumber: 1, normalized: { email: "ada@example.com" }, warnings: undefined }], mappedRows: [{ rowNumber: 1, normalized: { email: "ada@example.com" }, sourceColumns: ["Email"] }], summary: { format: "csv", totalRows: 1, acceptedRows: 1, rejectedRows: 0, diagnostics: [] }, }; function makeRequest(method: string, body?: unknown) { return new Request("https://example.com/internal/imports/dry-run", { method, body: body === undefined || method === "GET" || method === "HEAD" ? undefined : JSON.stringify(body), headers: body === undefined ? undefined : { "Content-Type": "application/json", Authorization: "Bearer secret-token" }, }); } async function callAction(method = "POST", body: unknown = validBody) { const { action } = await import("./dry-run"); return action({ request: makeRequest(method, body), params: {}, context: {} } as unknown as ActionFunctionArgs) as Promise; } describe("/internal/imports/dry-run action", () => { beforeEach(() => { vi.clearAllMocks(); vi.resetModules(); mocks.requireAuth.mockResolvedValue({ userId: "user_1" }); mocks.createImportJob.mockResolvedValue({ id: "job_1" }); mocks.markImportJobRunning.mockResolvedValue(undefined); mocks.markImportJobSucceeded.mockResolvedValue(undefined); mocks.markImportJobFailed.mockResolvedValue(undefined); mocks.createImportDryRunPreview.mockReturnValue(preview); mocks.verifyUserHasPermission.mockResolvedValue(true); }); it("authenticates, builds a dry-run preview, persists scalar counters, and returns the redacted response shape", async () => { const response = await callAction(); expect(response.status).toBe(200); await expect(response.json()).resolves.toEqual({ jobId: "job_1", status: "COMPLETED", summary: preview.summary, rows: preview.rows, diagnostics: [], }); expect(mocks.requireAuth).toHaveBeenCalledWith({ request: expect.any(Request), params: {} }); expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.create", "tenant_1"); expect(mocks.createImportJob).toHaveBeenCalledWith( expect.objectContaining({ tenantId: "tenant_1", requestedByUserId: "user_1", importType: "members", format: "csv", requestId: "request_1", sourceBucket: "import-dry-run", sourceKey: "tenants/tenant_1/uploads/import.csv", attemptsMade: 0, }) ); expect(mocks.markImportJobRunning).toHaveBeenCalledWith({ id: "job_1", tenantId: "tenant_1", attemptsMade: 1 }); expect(mocks.createImportDryRunPreview).toHaveBeenCalledWith( expect.objectContaining({ format: "csv", fields: validBody.fields, mappings: validBody.mappings, rows: validBody.rows, }) ); expect(mocks.markImportJobSucceeded).toHaveBeenCalledWith({ id: "job_1", tenantId: "tenant_1", rowCount: 1, acceptedRows: 1, rejectedRows: 0, attemptsMade: 1, }); expect(mocks.markImportJobFailed).not.toHaveBeenCalled(); }); it("returns localized validation messages for missing source and mappings", async () => { const missingSource = await callAction("POST", { ...validBody, source: undefined }); await expect(missingSource.json()).resolves.toMatchObject({ error: "Source is required." }); const missingMappings = await callAction("POST", { ...validBody, mappings: [] }); await expect(missingMappings.json()).resolves.toMatchObject({ error: "Mappings must include at least one field mapping." }); }); it("rejects non-POST requests before auth or persistence", async () => { const response = await callAction("GET", undefined); expect(response.status).toBe(405); await expect(response.json()).resolves.toEqual({ error: "Method not allowed." }); expect(mocks.requireAuth).not.toHaveBeenCalled(); expect(mocks.createImportJob).not.toHaveBeenCalled(); }); it("rejects unsupported formats and redacts secret-bearing invalid payload details", async () => { const response = await callAction("POST", { ...validBody, format: "xml", apiKey: "secret-token" }); expect(response.status).toBe(400); const payload = await response.json(); expect(payload.error).toBe("Unsupported import format."); expect(payload.diagnostics[0]).toMatchObject({ code: "invalid_dry_run_request", message: "Unsupported import format." }); expect(JSON.stringify(payload)).not.toContain("secret-token"); expect(mocks.createImportJob).not.toHaveBeenCalled(); }); it("rejects missing mappings or rows without checking permissions or creating a job", async () => { const response = await callAction("POST", { ...validBody, mappings: [], rows: [] }); expect(response.status).toBe(400); await expect(response.json()).resolves.toMatchObject({ error: "Mappings must include at least one field mapping.", diagnostics: [expect.objectContaining({ code: "invalid_dry_run_request" })], }); expect(mocks.verifyUserHasPermission).not.toHaveBeenCalled(); expect(mocks.createImportJob).not.toHaveBeenCalled(); }); it("propagates permission denials before persistence, preview generation, or authorization leakage", async () => { const denial = new Response(null, { status: 302, headers: { Location: "/unauthorized/app.settings.members.create/tenant_2" } }); mocks.verifyUserHasPermission.mockRejectedValueOnce(denial); await expect(callAction("POST", { ...validBody, importType: "members", source: { ...validBody.source, tenantId: "tenant_2" } })).rejects.toBe(denial); expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.create", "tenant_2"); expect(mocks.createImportJob).not.toHaveBeenCalled(); expect(mocks.markImportJobRunning).not.toHaveBeenCalled(); expect(mocks.createImportDryRunPreview).not.toHaveBeenCalled(); expect(mocks.markImportJobSucceeded).not.toHaveBeenCalled(); expect(mocks.markImportJobFailed).not.toHaveBeenCalled(); expect(JSON.stringify(denial.headers)).not.toContain("secret-token"); }); it("rejects dry-run source keys outside the requested tenant prefix", async () => { const response = await callAction("POST", { ...validBody, source: { ...validBody.source, sourceKey: "tenants/tenant_2/uploads/import.csv" }, }); expect(response.status).toBe(403); await expect(response.json()).resolves.toEqual({ error: "Import source storage access denied.", reason: "tenant_mismatch", }); expect(mocks.verifyUserHasPermission).toHaveBeenCalledWith(expect.any(Request), "app.settings.members.create", "tenant_1"); expect(mocks.createImportJob).not.toHaveBeenCalled(); expect(mocks.createImportDryRunPreview).not.toHaveBeenCalled(); }); it("rejects unsupported import types before permissions or persistence", async () => { const response = await callAction("POST", { ...validBody, importType: "widgets" }); expect(response.status).toBe(400); await expect(response.json()).resolves.toMatchObject({ error: "Unsupported import type: widgets" }); expect(mocks.verifyUserHasPermission).not.toHaveBeenCalled(); expect(mocks.createImportJob).not.toHaveBeenCalled(); }); it("redacts helper failures, marks the import job failed, and does not leak raw body or tokens", async () => { mocks.createImportDryRunPreview.mockImplementationOnce(() => { throw new Error('Parser failed authorization: Bearer secret-token rawBody={"email":"ada@example.com"}'); }); const response = await callAction("POST", validBody); expect(response.status).toBe(500); const payload = await response.json(); expect(payload.error).toBe("Import dry-run failed."); expect(JSON.stringify(payload)).not.toContain("secret-token"); expect(JSON.stringify(payload)).not.toContain("ada@example.com"); expect(mocks.markImportJobFailed).toHaveBeenCalledWith( expect.objectContaining({ id: "job_1", attemptsMade: 1, errorName: "Error", errorMessage: expect.not.stringContaining("secret-token"), }) ); }); it("returns a redacted server error when DB helpers fail", async () => { mocks.markImportJobRunning.mockRejectedValueOnce(new Error("database token=secret-token is unavailable")); const response = await callAction(); expect(response.status).toBe(500); const payload = await response.json(); expect(payload).toMatchObject({ error: "Import dry-run failed.", diagnostics: [expect.objectContaining({ code: "dry_run_failed" })] }); expect(JSON.stringify(payload)).not.toContain("secret-token"); expect(mocks.markImportJobSucceeded).not.toHaveBeenCalled(); }); });