Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/internal/imports/dry-run.test.tsx
T

291 lines
12 KiB
TypeScript

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<typeof vi.fn>;
createImportJob: ReturnType<typeof vi.fn>;
markImportJobRunning: ReturnType<typeof vi.fn>;
markImportJobSucceeded: ReturnType<typeof vi.fn>;
markImportJobFailed: ReturnType<typeof vi.fn>;
createImportDryRunPreview: ReturnType<typeof vi.fn>;
verifyUserHasPermission: ReturnType<typeof vi.fn>;
};
};
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<string, string> = {
"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<string, unknown>) => (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<string, unknown> = {}) => ({
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<Response>;
}
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();
});
});