@truedat/core 8.13.0 → 8.13.1

package/src/components/__tests__/UploadJobResults.spec.js

@@ -0,0 +1,289 @@
+import { render } from "@truedat/test/render";
+import userEvent from "@testing-library/user-event";
+import UploadJobResults, {
+  getResultEvents,
+  getResultOutcome,
+} from "../UploadJobResults";
+
+const messages = {
+  en: {
+    "uploadJob.results.title": "Processing results",
+    "uploadJob.results.subtitle": "Browse and filter records by upload result.",
+    "uploadJob.results.expand": "Expand processing results",
+    "uploadJob.results.collapse": "Collapse processing results",
+    "uploadJob.results.filter.all": "All",
+    "uploadJob.results.filter.created": "Created",
+    "uploadJob.results.filter.updated": "Updated",
+    "uploadJob.results.filter.unchanged": "Unchanged",
+    "uploadJob.results.filter.error": "Errors",
+    "uploadJob.results.filter.label": "Filter results",
+    "uploadJob.results.column.outcome": "Result",
+    "uploadJob.results.column.processedAt": "Processed at",
+    "uploadJob.results.column.implementation": "Implementation",
+    "uploadJob.results.column.structure": "Structure",
+    "uploadJob.results.column.origin": "Origin",
+    "uploadJob.results.origin.row": "Row {rowNumber}",
+    "uploadJob.results.empty": "No results in this category.",
+    "uploadJob.table.detail": "Detail",
+    "uploadJob.parser.info.created": "Created",
+    "uploadJob.parser.info.updated": "Updated",
+    "uploadJob.parser.info.unchanged": "Unchanged",
+    "uploadJob.parser.event.status.ERROR": "Error",
+    "uploadJob.parser.event.status.INFO": "Info",
+    "uploadJob.parser.error.invalid_template_name": "Invalid template name",
+    "uploadJob.parser.detail.templateName": "Template name",
+  },
+};
+
+const events = [
+  {
+    status: "INFO",
+    inserted_at: "2026-01-01T10:00:00Z",
+    response: {
+      type: "created",
+      sheet: "Template A",
+      row_number: 2,
+      details: { implementation_key: "created-key" },
+    },
+  },
+  {
+    status: "INFO",
+    inserted_at: "2026-01-01T10:01:00Z",
+    response: {
+      type: "updated",
+      sheet: "Template A",
+      row_number: 3,
+      details: { implementation_key: "updated-key" },
+    },
+  },
+  {
+    status: "INFO",
+    inserted_at: "2026-01-01T10:02:00Z",
+    response: {
+      type: "unchanged",
+      sheet: "Template B",
+      row_number: 4,
+      details: { implementation_key: "unchanged-key" },
+    },
+  },
+  {
+    status: "ERROR",
+    inserted_at: "2026-01-01T10:03:00Z",
+    response: {
+      type: "invalid_template_name",
+      sheet: "Template C",
+      row_number: 5,
+      details: { template_name: "missing" },
+    },
+  },
+];
+
+describe("<UploadJobResults />", () => {
+  it.each(["PENDING", "STARTED", "FAILED"])(
+    "is collapsed and disabled for %s",
+    async (status) => {
+      const user = userEvent.setup({ delay: null });
+      const rendered = render(
+        <UploadJobResults events={events} lifecycleStatus={status} />,
+        { messages },
+      );
+      const toggle = rendered.getByRole("button", {
+        name: /^Processing results/i,
+      });
+
+      expect(toggle).toBeDisabled();
+      expect(toggle).toHaveAttribute("aria-expanded", "false");
+      await user.click(toggle);
+      expect(rendered.queryByRole("table")).not.toBeInTheDocument();
+    },
+  );
+
+  it("opens completed results and always displays every filter without counters", async () => {
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(
+      <UploadJobResults events={events} lifecycleStatus="COMPLETED" />,
+      { messages },
+    );
+    const toggle = rendered.getByRole("button", {
+      name: /^Processing results/i,
+    });
+
+    expect(toggle).toHaveAttribute("aria-expanded", "false");
+    expect(toggle).toHaveAttribute("aria-controls");
+    const resultsSection = rendered
+      .getByText("Processing results")
+      .closest("section");
+    expect(
+      resultsSection.querySelector(`#${toggle.getAttribute("aria-controls")}`),
+    ).toHaveAttribute("hidden");
+    await user.click(toggle);
+    expect(toggle).toHaveAttribute("aria-expanded", "true");
+
+    const filters = rendered.getByRole("group", { name: "Filter results" });
+    expect(filters).toHaveTextContent("All");
+    expect(filters).toHaveTextContent("Created");
+    expect(filters).toHaveTextContent("Updated");
+    expect(filters).toHaveTextContent("Unchanged");
+    expect(filters).toHaveTextContent("Errors");
+    expect(
+      rendered.getByRole("button", { name: "Created" }),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByRole("button", { name: "Updated" }),
+    ).toBeInTheDocument();
+    const allFilter = rendered.getByRole("button", { name: "All" });
+    const createdFilter = rendered.getByRole("button", { name: "Created" });
+    const errorFilter = rendered.getByRole("button", { name: "Errors" });
+
+    expect(allFilter).toHaveAttribute("aria-pressed", "true");
+    expect(allFilter).toHaveClass("active");
+    expect(createdFilter).toHaveAttribute("aria-pressed", "false");
+    expect(errorFilter).toHaveClass("upload-job-result-filter-error");
+    expect(filters).not.toHaveTextContent(/\d/);
+    expect(rendered.getByText("Implementation")).toBeInTheDocument();
+    expect(rendered.getByText("Detail")).toBeInTheDocument();
+    expect(rendered.getByText("updated-key")).toBeInTheDocument();
+    expect(rendered.getAllByText("Created")[1].closest(".label")).toHaveClass(
+      "upload-job-outcome-created",
+    );
+    expect(rendered.getAllByText("Updated")[1].closest(".label")).toHaveClass(
+      "upload-job-outcome-updated",
+    );
+    expect(
+      rendered.container
+        .querySelector(".upload-job-outcome-unchanged")
+        .closest(".label"),
+    ).toHaveClass("upload-job-outcome", "upload-job-outcome-unchanged", "grey");
+    expect(rendered.getByText("Error").closest(".label")).toHaveClass(
+      "upload-job-outcome",
+      "upload-job-outcome-error",
+      "red",
+    );
+    expect(rendered.getAllByText(/Template A/)).toHaveLength(2);
+
+    await user.click(createdFilter);
+
+    expect(allFilter).toHaveAttribute("aria-pressed", "false");
+    expect(allFilter).not.toHaveClass("active");
+    expect(createdFilter).toHaveAttribute("aria-pressed", "true");
+    expect(createdFilter).toHaveClass("active");
+  });
+
+  it("uses one trigger to label and control the results section", () => {
+    const rendered = render(
+      <UploadJobResults events={events} lifecycleStatus="COMPLETED" />,
+      { messages },
+    );
+    const trigger = rendered.getByRole("button", {
+      name: /^Processing results/i,
+    });
+    const section = trigger.closest("section");
+
+    expect(
+      rendered.getAllByRole("button", { name: /^Processing results/i }),
+    ).toHaveLength(1);
+    expect(section).toHaveAttribute("aria-labelledby");
+    expect(
+      section.querySelector(`#${section.getAttribute("aria-labelledby")}`),
+    ).toBeTruthy();
+  });
+
+  it("constrains table scrolling only when rendered in a modal", async () => {
+    const user = userEvent.setup({ delay: null });
+    const constrained = render(
+      <UploadJobResults
+        constrainResults
+        events={events}
+        lifecycleStatus="COMPLETED"
+      />,
+      { messages },
+    );
+
+    await user.click(
+      constrained.getByRole("button", { name: /^Processing results/i }),
+    );
+    expect(
+      constrained.container.querySelector(".upload-job-table-wrap"),
+    ).toHaveClass("upload-job-table-wrap-constrained");
+    expect(
+      constrained.container.querySelector(".upload-job-table-wrap"),
+    ).toHaveStyle({ maxHeight: "48vh", overflow: "auto" });
+    constrained.unmount();
+
+    const direct = render(
+      <UploadJobResults events={events} lifecycleStatus="COMPLETED" />,
+      { messages },
+    );
+    await user.click(
+      direct.getByRole("button", { name: /^Processing results/i }),
+    );
+    expect(
+      direct.container.querySelector(".upload-job-table-wrap"),
+    ).not.toHaveClass("upload-job-table-wrap-constrained");
+    expect(
+      direct.container.querySelector(".upload-job-table-wrap"),
+    ).not.toHaveAttribute("style");
+  });
+
+  it("filters categories and shows an empty state for a missing category", async () => {
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(
+      <UploadJobResults
+        events={events.slice(0, 2)}
+        lifecycleStatus="COMPLETED"
+      />,
+      { messages },
+    );
+
+    await user.click(
+      rendered.getByRole("button", { name: /^Processing results/i }),
+    );
+    await user.click(
+      rendered.getByRole("button", {
+        name: "Unchanged",
+      }),
+    );
+
+    expect(
+      rendered.getByText("No results in this category."),
+    ).toBeInTheDocument();
+  });
+
+  it("renders the entity header according to scope", async () => {
+    const user = userEvent.setup({ delay: null });
+    const renderExpanded = async (scope) => {
+      const rendered = render(
+        <UploadJobResults
+          events={events}
+          lifecycleStatus="COMPLETED"
+          scope={scope}
+        />,
+        { messages },
+      );
+      await user.click(
+        rendered.getByRole("button", { name: /^Processing results/i }),
+      );
+      return rendered;
+    };
+
+    const implementationsView = await renderExpanded("implementations");
+    expect(implementationsView.getByText("Implementation")).toBeInTheDocument();
+    expect(
+      implementationsView.queryByText("Structure"),
+    ).not.toBeInTheDocument();
+    implementationsView.unmount();
+
+    const notesView = await renderExpanded("notes");
+    expect(notesView.getByText("Structure")).toBeInTheDocument();
+    expect(notesView.queryByText("Implementation")).not.toBeInTheDocument();
+  });
+
+  it("classifies known outcomes and preserves unknown INFO safely", () => {
+    expect(getResultEvents(events)).toEqual(events);
+    expect(getResultOutcome(events[0])).toBe("created");
+    expect(getResultOutcome(events[1])).toBe("updated");
+    expect(getResultOutcome(events[2])).toBe("unchanged");
+    expect(getResultOutcome(events[3])).toBe("error");
+    expect(getResultOutcome({ status: "INFO", response: {} })).toBe("unknown");
+  });
+});

package/src/components/__tests__/UploadJobScope.spec.js

@@ -0,0 +1,38 @@
+import { getUploadJobScope, uploadJobScopes } from "../UploadJobScope";
+
+describe("Upload job scopes", () => {
+  it("defines implementation and notes upload routes and presentation metadata", () => {
+    expect(uploadJobScopes.implementations.listPath).toBe(
+      "/implementations/uploadJobs",
+    );
+    expect(uploadJobScopes.implementations.listHeaderId).toBe(
+      "uploadJobs.implementations.header",
+    );
+    expect(uploadJobScopes.implementations.detailHeaderId).toBe(
+      "uploadJob.implementations.header",
+    );
+    expect(uploadJobScopes.implementations.detailPath(12)).toBe(
+      "/implementations/uploadJobs/12",
+    );
+    expect(uploadJobScopes.notes.listPath).toBe("/structureNotes/uploadJobs");
+    expect(uploadJobScopes.notes.listHeaderId).toBe("uploadJobs.notes.header");
+    expect(uploadJobScopes.notes.detailHeaderId).toBe("uploadJob.notes.header");
+    expect(uploadJobScopes.notes.detailPath(12)).toBe(
+      "/structureNotes/uploadJobs/12",
+    );
+    expect(uploadJobScopes.notes.fieldMessageOverrides.status).toBe(
+      "structure.notes.status",
+    );
+  });
+
+  it("falls back to implementation semantics for unknown scopes", () => {
+    expect(getUploadJobScope("other")).toMatchObject({
+      listPath: null,
+      detailPath: null,
+      listHeaderId: "uploadJobs.other.header",
+      detailHeaderId: "uploadJob.other.header",
+      entityColumnMessageId: "uploadJob.results.column.implementation",
+      fieldMessagePrefix: "ruleImplementations.props",
+    });
+  });
+});

package/src/components/__tests__/UploadJobSummary.spec.js

@@ -0,0 +1,208 @@
+import { render } from "@truedat/test/render";
+
+import UploadJobSummary, {
+  getUploadJobStatus,
+  getUploadJobSummary,
+  classifyUploadJobErrorMessage,
+} from "../UploadJobSummary";
+
+const summaryMessages = {
+  en: {
+    "uploadJob.summary.title": "Summary",
+    "uploadJob.summary.total": "Total processed",
+    "uploadJob.summary.pending": "The file is pending processing.",
+    "uploadJob.summary.started": "The file is being processed.",
+    "uploadJob.summary.failed": "Error processing the file: {detail}",
+    "uploadJob.parser.error.invalid_format": "Invalid file format",
+    "uploadJob.parser.error.unknown": "Unknown error",
+    "uploadJob.parser.error.unexpected_error": "Unexpected error",
+    "uploadJob.parser.result.summary.created": "Created",
+    "uploadJob.parser.result.summary.updated": "Updated",
+    "uploadJob.parser.result.summary.unchanged": "Unchanged",
+    "uploadJob.parser.result.summary.errors": "Errors",
+  },
+};
+
+describe("<UploadJobSummary />", () => {
+  it("renders completed counters with the visual total first", () => {
+    const events = [
+      { status: "PENDING" },
+      { status: "STARTED" },
+      {
+        status: "COMPLETED",
+        response: {
+          insert_count: 2,
+          update_count: 1,
+          unchanged_count: 7,
+          error_count: 2,
+          invalid_sheet_count: 1,
+        },
+      },
+    ];
+
+    const rendered = render(
+      <UploadJobSummary events={events} latestStatus="COMPLETED" />,
+      { messages: summaryMessages },
+    );
+
+    const message = rendered.getByLabelText("Summary");
+    expect(message).toHaveClass("positive");
+    expect(message).toHaveTextContent("Total processed: 13");
+    expect(message).toHaveTextContent("Created: 2");
+    expect(message).toHaveTextContent("Updated: 1");
+    expect(message).toHaveTextContent("Unchanged: 7");
+    expect(message).toHaveTextContent("Errors: 3");
+    expect(message.textContent.indexOf("Total processed")).toBeLessThan(
+      message.textContent.indexOf("Created"),
+    );
+  });
+
+  it.each([
+    ["PENDING", "warning", "pending processing"],
+    ["STARTED", "info", "being processed"],
+  ])("renders %s as %s", (status, className, text) => {
+    const rendered = render(
+      <UploadJobSummary events={[{ status }]} latestStatus={status} />,
+      { messages: summaryMessages },
+    );
+
+    const message = rendered.getByLabelText("Summary");
+    expect(message).toHaveClass(className);
+    expect(message).toHaveTextContent(text);
+    expect(message).not.toHaveTextContent("Created:");
+  });
+
+  it("renders the translated processing error without counters", () => {
+    const rendered = render(
+      <UploadJobSummary
+        events={[
+          { status: "STARTED" },
+          { status: "FAILED", response: { message: "invalid_format" } },
+        ]}
+        latestStatus="FAILED"
+      />,
+      { messages: summaryMessages },
+    );
+
+    const message = rendered.getByLabelText("Summary");
+    expect(message).toHaveClass("negative");
+    expect(message).toHaveTextContent(
+      "Error processing the file: Invalid file format",
+    );
+    expect(message).not.toHaveTextContent("Created:");
+  });
+
+  it("renders the translated unknown error when FAILED has no message", () => {
+    const rendered = render(
+      <UploadJobSummary
+        events={[{ status: "FAILED" }]}
+        latestStatus="FAILED"
+      />,
+      { messages: summaryMessages },
+    );
+
+    expect(rendered.getByLabelText("Summary")).toHaveTextContent(
+      "Error processing the file: Unknown error",
+    );
+  });
+
+  it("replaces technical failure details with an unexpected error", () => {
+    const technicalMessage = "%KeyError{} key :foo not found in: %{}";
+    const rendered = render(
+      <UploadJobSummary
+        events={[{ status: "FAILED", response: { message: technicalMessage } }]}
+        latestStatus="FAILED"
+      />,
+      { messages: summaryMessages },
+    );
+
+    expect(rendered.getByLabelText("Summary")).toHaveTextContent(
+      "Error processing the file: Unexpected error",
+    );
+    expect(rendered.getByLabelText("Summary")).not.toHaveTextContent(
+      technicalMessage,
+    );
+  });
+
+  it("classifies Elixir tuple inspections as unexpected errors", () => {
+    expect(classifyUploadJobErrorMessage("{:error, :boom}")).toEqual({
+      type: "unexpected_error",
+    });
+  });
+
+  it("renders a human failure message", () => {
+    const rendered = render(
+      <UploadJobSummary
+        events={[
+          {
+            status: "FAILED",
+            response: { message: "The uploaded file is invalid" },
+          },
+        ]}
+        latestStatus="FAILED"
+      />,
+      { messages: summaryMessages },
+    );
+
+    expect(rendered.getByLabelText("Summary")).toHaveTextContent(
+      "Error processing the file: The uploaded file is invalid",
+    );
+  });
+
+  it("preserves multiline human failure messages", () => {
+    const humanMessage =
+      "The uploaded file is invalid\nPlease check its headers";
+    const rendered = render(
+      <UploadJobSummary
+        events={[{ status: "FAILED", response: { message: humanMessage } }]}
+        latestStatus="FAILED"
+      />,
+      { messages: summaryMessages },
+    );
+
+    expect(rendered.getByLabelText("Summary")).toHaveTextContent(
+      "Error processing the file: The uploaded file is invalid Please check its headers",
+    );
+  });
+
+  it("uses latest response as a historical completed fallback", () => {
+    expect(
+      getUploadJobSummary([{ status: "COMPLETED", response: {} }], {
+        insert_count: 1,
+        update_count: 2,
+        unchanged_count: 3,
+        error_count: 4,
+      }),
+    ).toEqual({
+      insert_count: 1,
+      update_count: 2,
+      unchanged_count: 3,
+      error_count: 4,
+    });
+  });
+
+  it("derives partial counters when no final response exists", () => {
+    expect(
+      getUploadJobSummary([
+        { status: "INFO", response: { type: "created" } },
+        { status: "INFO", response: { type: "updated" } },
+        { status: "INFO", response: { type: "unchanged" } },
+        { status: "ERROR", response: { type: "invalid_template_name" } },
+      ]),
+    ).toEqual({
+      insert_count: 1,
+      update_count: 1,
+      unchanged_count: 1,
+      error_count: 1,
+    });
+  });
+
+  it("ignores row statuses when determining processing status", () => {
+    expect(
+      getUploadJobStatus(
+        [{ status: "PENDING" }, { status: "STARTED" }, { status: "ERROR" }],
+        "ERROR",
+      ),
+    ).toBe("STARTED");
+  });
+});

package/src/components/__tests__/UploadJobs.spec.js

@@ -1,12 +1,144 @@
 import { render, waitForLoad } from "@truedat/test/render";
-import { useUploadJobs } from "../../hooks/useUploadJobs";
+import userEvent from "@testing-library/user-event";
+import { useUploadJob, useUploadJobs } from "../../hooks/useUploadJobs";
 import UploadJobs from "../UploadJobs";
 
 jest.mock("../../hooks/useUploadJobs", () => ({
   useUploadJobs: jest.fn(),
+  useUploadJob: jest.fn(),
 }));
 
+const messages = {
+  en: {
+    "uploadJob.implementations.header": "Implementations upload detail",
+    "uploadJob.notes.header": "Structure notes upload detail",
+    "uploadJob.results.title": "Processing results",
+    "uploadJob.results.subtitle": "Browse results",
+  },
+};
+
 describe("<UploadJobs />", () => {
+  beforeEach(() => {
+    useUploadJob.mockReset();
+    useUploadJob.mockReturnValue({ loading: false, data: null });
+  });
+
+  const mockJobs = [
+    {
+      id: 1,
+      filename: "test.csv",
+      latest_status: "completed",
+      latest_event_response: "Success",
+      latest_event_at: "2023-01-01T00:00:00Z",
+    },
+    {
+      id: 2,
+      filename: "other.csv",
+      latest_status: "completed",
+      latest_event_response: "Success",
+      latest_event_at: "2023-01-01T00:00:00Z",
+    },
+  ];
+
+  it("opens the TrueModal with the clicked job's detail without changing the route", async () => {
+    const user = userEvent.setup({ delay: null });
+    useUploadJobs.mockReturnValue({ loading: false, data: { data: mockJobs } });
+
+    const rendered = render(<UploadJobs scope="implementations" />, {
+      messages,
+    });
+    await waitForLoad(rendered);
+
+    expect(rendered.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(useUploadJob).not.toHaveBeenCalled();
+
+    await user.click(rendered.getByText("other.csv"));
+
+    expect(rendered.getByRole("dialog")).toBeInTheDocument();
+    expect(
+      rendered.getByText("Implementations upload detail"),
+    ).toBeInTheDocument();
+    expect(useUploadJob).toHaveBeenCalledTimes(1);
+    expect(useUploadJob).toHaveBeenCalledWith(2);
+  });
+
+  it("propagates the notes scope to the modal title", async () => {
+    const user = userEvent.setup({ delay: null });
+    useUploadJobs.mockReturnValue({ loading: false, data: { data: mockJobs } });
+
+    const rendered = render(<UploadJobs scope="notes" />, { messages });
+    await waitForLoad(rendered);
+
+    await user.click(rendered.getByText("test.csv"));
+
+    expect(
+      rendered.getByText("Structure notes upload detail"),
+    ).toBeInTheDocument();
+    expect(useUploadJob).toHaveBeenCalledWith(1);
+  });
+
+  it("constrains expanded results inside the modal", async () => {
+    const user = userEvent.setup({ delay: null });
+    useUploadJobs.mockReturnValue({ loading: false, data: { data: mockJobs } });
+    useUploadJob.mockReturnValue({
+      loading: false,
+      data: {
+        data: {
+          filename: "test.csv",
+          hash: "hash",
+          latest_status: "COMPLETED",
+          latest_event_at: "2023-01-01T00:00:00Z",
+          latest_event_response: {},
+          events: [{ status: "COMPLETED", response: {} }],
+        },
+      },
+    });
+
+    const rendered = render(<UploadJobs scope="implementations" />, {
+      messages,
+    });
+    await waitForLoad(rendered);
+    await user.click(rendered.getByText("test.csv"));
+    await user.click(
+      rendered.getByRole("button", { name: /^Processing results/i }),
+    );
+
+    expect(document.querySelector(".upload-job-table-wrap")).toHaveClass(
+      "upload-job-table-wrap-constrained",
+    );
+  });
+
+  it.each([
+    ["Enter", "{Enter}"],
+    ["Space", " "],
+  ])(
+    "opens the modal via keyboard (%s) and closes it clearing the selection",
+    async (_, key) => {
+      const user = userEvent.setup({ delay: null });
+      useUploadJobs.mockReturnValue({
+        loading: false,
+        data: { data: mockJobs },
+      });
+
+      const rendered = render(<UploadJobs scope="implementations" />, {
+        messages,
+      });
+      await waitForLoad(rendered);
+
+      const row = rendered.getByText("test.csv").closest("tr");
+      row.focus();
+      await user.keyboard(key);
+
+      expect(rendered.getByRole("dialog")).toBeInTheDocument();
+
+      await user.click(rendered.getByRole("button", { name: /close/i }));
+
+      expect(rendered.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(useUploadJob).toHaveBeenLastCalledWith(1);
+      expect(useUploadJob).not.toHaveBeenCalledWith(null);
+    },
+  );
+
   it("renders loading state", async () => {
     useUploadJobs.mockReturnValue({
       loading: true,