@truedat/core 8.12.12 → 8.13.1

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

@@ -0,0 +1,193 @@
+import { screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { render } from "@truedat/test/render";
+import { TrueModal } from "../index";
+
+const setupUser = () =>
+  userEvent.setup({ advanceTimers: jest.advanceTimersByTime });
+const renderModal = (props = {}) =>
+  render(<TrueModal open title="Title" {...props} />);
+
+describe("<TrueModal />", () => {
+  it("renders accessible content and preserves consumer classes and size", () => {
+    renderModal({
+      subtitle: "Subtitle",
+      icon: "rocket",
+      children: <p>Content</p>,
+      className: "custom-modal",
+      size: "large",
+      header: "Wrong header",
+      content: "Wrong content",
+      closeIcon: false,
+    });
+    const dialog = screen.getByRole("dialog", { name: "Title" });
+    expect(dialog).toHaveClass("true-modal", "custom-modal", "large");
+    expect(screen.getByText("Subtitle")).toBeInTheDocument();
+    expect(screen.getByText("Content")).toBeInTheDocument();
+    expect(dialog.querySelector(".rocket.icon")).toBeInTheDocument();
+    expect(screen.queryByText(/Wrong/)).not.toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Close" })).toBeInTheDocument();
+    expect(dialog.querySelector(".actions")).not.toBeInTheDocument();
+    expect(dialog.querySelector(".true-modal-banner")).not.toBeInTheDocument();
+  });
+
+  it.each([
+    [{ headerColor: "#123456" }, { background: "#123456" }],
+    [{ headerTextColor: "#ffffff" }, { color: "#ffffff" }],
+  ])("applies independent header colors %o", (props, style) => {
+    renderModal(props);
+    expect(screen.getByText("Title").closest(".header")).toHaveStyle(style);
+  });
+
+  it.each([
+    ["warning", "warning.sign"],
+    ["danger", "times.circle"],
+    ["success", "check.circle"],
+    ["info", "info.circle"],
+  ])("renders %s banner", (bannerType, iconClass) => {
+    renderModal({ bannerType, banner: <strong>Notice</strong> });
+    const banner = screen.getByText("Notice").closest(".true-modal-banner");
+    expect(banner).toHaveClass(bannerType);
+    expect(banner.querySelector(`.${iconClass}.icon`)).toBeInTheDocument();
+  });
+
+  it("supports a custom banner icon and an explicit accessible name", () => {
+    renderModal({
+      banner: "Notice",
+      bannerIcon: "rocket",
+      "aria-label": "Custom",
+    });
+    const dialog = screen.getByRole("dialog", { name: "Custom" });
+    expect(dialog).not.toHaveAttribute("aria-labelledby");
+    expect(
+      dialog.querySelector(".true-modal-banner .rocket.icon"),
+    ).toBeInTheDocument();
+  });
+
+  it.each([undefined, []])(
+    "resolves default callbacks for actions %o",
+    async (actions) => {
+      const onCancel = jest.fn();
+      const onCreate = jest.fn();
+      const onClose = jest.fn();
+      renderModal({ actions, onCancel, onCreate, onClose });
+      const user = setupUser();
+      await user.click(screen.getByRole("button", { name: "Cancel" }));
+      await user.click(screen.getByRole("button", { name: "Create" }));
+      expect(onCancel).toHaveBeenCalledTimes(1);
+      expect(onCreate).toHaveBeenCalledTimes(1);
+      expect(onClose).not.toHaveBeenCalled();
+    },
+  );
+
+  it.each(["onCancel", "onCreate"])(
+    "renders only the supplied %s callback",
+    (callback) => {
+      renderModal({ [callback]: jest.fn() });
+      expect(screen.getAllByRole("button")).toHaveLength(2);
+    },
+  );
+
+  it("renders three actions and blocks disabled and loading callbacks", async () => {
+    const onClick = jest.fn();
+    renderModal({
+      actions: [
+        { key: "one", content: "One", onClick },
+        { key: "two", content: "Two", disabled: true, onClick },
+        {
+          key: "three",
+          content: "Three",
+          loading: true,
+          disabled: false,
+          onClick,
+          type: "submit",
+        },
+      ],
+    });
+    const user = setupUser();
+    expect(screen.getByRole("button", { name: "One" })).toHaveAttribute(
+      "type",
+      "button",
+    );
+    expect(screen.getByRole("button", { name: "Two" })).toBeDisabled();
+    expect(screen.getByRole("button", { name: "Three" })).toBeDisabled();
+    expect(screen.getByRole("button", { name: "Three" })).toHaveClass(
+      "loading",
+    );
+    expect(screen.getByRole("button", { name: "Three" })).toHaveAttribute(
+      "type",
+      "submit",
+    );
+    await user.click(screen.getByRole("button", { name: "Two" }));
+    await user.click(screen.getByRole("button", { name: "Three" }));
+    expect(onClick).not.toHaveBeenCalled();
+    await user.click(screen.getByRole("button", { name: "One" }));
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+
+  it("gives custom footer precedence over both configured and default actions", () => {
+    renderModal({
+      footer: <button type="button">Custom</button>,
+      actions: [{ key: "one", content: "One" }],
+      onCancel: jest.fn(),
+    });
+    expect(screen.getByRole("button", { name: "Custom" })).toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "One" }),
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole("button", { name: "Cancel" }),
+    ).not.toBeInTheDocument();
+  });
+
+  it.each(["button", "escape", "overlay"])(
+    "closes through %s with the native callback contract",
+    async (method) => {
+      const onOpen = jest.fn();
+      const onClose = jest.fn();
+      render(
+        <TrueModal
+          title="Title"
+          trigger={<button type="button">Open</button>}
+          onOpen={onOpen}
+          onClose={onClose}
+        />,
+      );
+      const user = setupUser();
+      await user.click(screen.getByRole("button", { name: "Open" }));
+      expect(onOpen).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ open: true }),
+      );
+      if (method === "button")
+        await user.click(screen.getByRole("button", { name: "Close" }));
+      if (method === "escape") await user.keyboard("{Escape}");
+      if (method === "overlay")
+        await user.click(screen.getByRole("dialog").parentElement);
+      expect(onClose).toHaveBeenCalledTimes(1);
+      expect(onClose).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ open: false }),
+      );
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    },
+  );
+
+  it("respects controlled open and disabled Escape and overlay closing", async () => {
+    const onClose = jest.fn();
+    const { rerender } = renderModal({
+      onClose,
+      closeOnEscape: false,
+      closeOnDimmerClick: false,
+    });
+    const user = setupUser();
+    await user.keyboard("{Escape}");
+    await user.click(screen.getByRole("dialog").parentElement);
+    expect(onClose).not.toHaveBeenCalled();
+    await user.click(screen.getByRole("button", { name: "Close" }));
+    expect(onClose).toHaveBeenCalledTimes(1);
+    expect(screen.getByRole("dialog")).toBeInTheDocument();
+    rerender(<TrueModal open={false} title="Title" />);
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+  });
+});

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

@@ -1,6 +1,5 @@
 import { render, waitForLoad } from "@truedat/test/render";
 import userEvent from "@testing-library/user-event";
-import { waitFor } from "@testing-library/react";
 
 import { useUploadJob } from "../../hooks/useUploadJobs";
 import UploadJob from "../UploadJob";
@@ -13,25 +12,49 @@ jest.mock("react-router", () => ({
   useParams: () => ({ id: "123" }),
 }));
 
-describe("<UploadJob />", () => {
-  const user = userEvent.setup({ delay: null });
+const messages = {
+  en: {
+    "uploadJob.implementations.header": "Implementations upload detail",
+    "uploadJob.notes.header": "Structure notes upload detail",
+    "uploadJob.table.inserted_at": "Inserted At",
+    "uploadJob.summary.title": "Summary",
+    "uploadJob.summary.total": "Total processed",
+    "uploadJob.summary.failed": "Error processing the file: {detail}",
+    "uploadJob.parser.error.invalid_format": "Invalid file format",
+    "uploadJob.parser.result.summary.created": "Created",
+    "uploadJob.parser.result.summary.updated": "Updated",
+    "uploadJob.parser.result.summary.unchanged": "Unchanged",
+    "uploadJob.parser.result.summary.errors": "Errors",
+    "uploadJob.history.PENDING": "File received and pending processing.",
+    "uploadJob.history.STARTED": "Record reading and validation started.",
+    "uploadJob.history.COMPLETED": "File processed successfully.",
+    "uploadJob.history.FAILED": "The file could not be processed.",
+    "uploadJob.history.title": "File processing history",
+    "uploadJob.history.empty": "No processing history found.",
+    "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.column.structure": "Structure",
+    "uploadJob.parser.event.status.PENDING": "Pending",
+    "uploadJob.parser.event.status.STARTED": "Started",
+    "uploadJob.parser.event.status.COMPLETED": "Completed",
+    "uploadJob.parser.event.status.FAILED": "Failed",
+  },
+};
 
+describe("<UploadJob />", () => {
   beforeEach(() => {
     useUploadJob.mockReset();
   });
 
-  it("renders loading state", async () => {
-    useUploadJob.mockReturnValue({
-      loading: true,
-      data: null,
-    });
-
-    const rendered = render(<UploadJob />);
-
+  it("renders loading state", () => {
+    useUploadJob.mockReturnValue({ loading: true, data: null });
+    const rendered = render(<UploadJob />, { messages });
     expect(rendered.container.querySelector(".ui.loader")).toBeInTheDocument();
   });
 
-  it("renders empty state when no events", async () => {
+  it("renders the lifecycle pill with an accessible visually hidden Status header", async () => {
     useUploadJob.mockReturnValue({
       loading: false,
       data: {
@@ -40,71 +63,124 @@ describe("<UploadJob />", () => {
           hash: "abc123",
           latest_status: "COMPLETED",
           latest_event_at: "2023-01-01T00:00:00Z",
-          events: [],
+          latest_event_response: {
+            insert_count: 0,
+            update_count: 0,
+            unchanged_count: 0,
+            error_count: 0,
+          },
+          events: [
+            {
+              status: "COMPLETED",
+              inserted_at: "2023-01-01T00:00:00Z",
+              response: {},
+            },
+          ],
         },
       },
     });
 
-    const rendered = render(<UploadJob />);
+    const rendered = render(<UploadJob />, { messages });
     await waitForLoad(rendered);
 
     expect(rendered.getAllByText(/test.xlsx/i)).toHaveLength(2);
     expect(rendered.getByText(/abc123/i)).toBeInTheDocument();
-    expect(rendered.getByText(/no events found/i)).toBeInTheDocument();
+    expect(
+      rendered.getByRole("columnheader", { name: /uploadJob.table.status/i }),
+    ).toHaveClass("upload-job-visually-hidden");
+    expect(rendered.getAllByText("Completed")).toHaveLength(2);
+    expect(rendered.getByLabelText("Summary")).toHaveClass("positive");
   });
 
-  it("renders events grouped by status", async () => {
+  it("keeps row outcomes out of the processing history", async () => {
     useUploadJob.mockReturnValue({
       loading: false,
       data: {
         data: {
           filename: "test.xlsx",
           hash: "abc123",
-          latest_status: "COMPLETED",
+          latest_status: "FAILED",
           latest_event_at: "2023-01-01T00:00:00Z",
+          latest_event_response: { message: "invalid_format" },
           events: [
+            { status: "PENDING", inserted_at: "2023-01-01T00:00:00Z" },
+            { status: "STARTED", inserted_at: "2023-01-01T00:01:00Z" },
             {
-              status: "INFO",
-              inserted_at: "2023-01-01T00:00:00Z",
-              response: { type: "info_message" },
+              status: "ERROR",
+              inserted_at: "2023-01-01T00:01:30Z",
+              response: { type: "invalid_template_name" },
             },
             {
-              status: "ERROR",
-              inserted_at: "2023-01-01T00:00:00Z",
-              response: { type: "error_message" },
+              status: "FAILED",
+              inserted_at: "2023-01-01T00:02:00Z",
+              response: { message: "invalid_format" },
             },
+          ],
+        },
+      },
+    });
+
+    const rendered = render(<UploadJob />, { messages });
+    await waitForLoad(rendered);
+
+    const history = rendered.getByRole("heading", {
+      name: "File processing history",
+    }).parentElement;
+    expect(history).not.toHaveTextContent("invalid_template_name");
+    expect(history).toHaveTextContent("Failed");
+    expect(
+      rendered.getByRole("button", { name: /^Processing results/i }),
+    ).toBeDisabled();
+  });
+
+  it("renders structure-note results for the notes scope", async () => {
+    const user = userEvent.setup({ delay: null });
+    useUploadJob.mockReturnValue({
+      loading: false,
+      data: {
+        data: {
+          filename: "notes.xlsx",
+          hash: "notes-hash",
+          latest_status: "COMPLETED",
+          latest_event_at: "2023-01-01T00:00:00Z",
+          latest_event_response: {
+            insert_count: 1,
+            update_count: 0,
+            unchanged_count: 0,
+            error_count: 0,
+          },
+          events: [
             {
               status: "COMPLETED",
               inserted_at: "2023-01-01T00:00:00Z",
-              response: { type: "completed_message" },
+              response: { insert_count: 1 },
+            },
+            {
+              status: "INFO",
+              inserted_at: "2023-01-01T00:00:01Z",
+              response: {
+                type: "created",
+                details: { data_structure_id: 1, external_id: "NOTE-1" },
+              },
             },
           ],
         },
       },
     });
 
-    const rendered = render(<UploadJob />);
+    const rendered = render(<UploadJob scope="notes" />, { messages });
     await waitForLoad(rendered);
 
-    // Check group headers exist
-    expect(rendered.getByText(/info \(1\)/i)).toBeInTheDocument();
-    expect(rendered.getByText(/error \(1\)/i)).toBeInTheDocument();
-
-    // Expand INFO group
-    await user.click(rendered.getByText(/info \(1\)/i));
-    await waitFor(() => {
-      expect(rendered.getByText(/info_message/i)).toBeInTheDocument();
-    });
+    expect(
+      rendered.getByRole("heading", { name: "Structure notes upload detail" }),
+    ).toBeInTheDocument();
 
-    // Expand ERROR group
-    await user.click(rendered.getByText(/error \(1\)/i));
-    await waitFor(() => {
-      expect(rendered.getByText(/error_message/i)).toBeInTheDocument();
-    });
+    await user.click(
+      rendered.getByRole("button", { name: /^Processing results/i }),
+    );
 
-    // COMPLETED events are always visible
     expect(
-      rendered.getAllByText(/uploadJob.parser.event.status.COMPLETED/i),
-    ).toHaveLength(2);
+      rendered.getByRole("columnheader", { name: "Structure" }),
+    ).toBeInTheDocument();
   });
 });

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

@@ -19,6 +19,9 @@ describe("ImplementationUploadJobBreadcrumbs", () => {
     expect(
       rendered.getByText(/uploadJobs.myscope.header/i),
     ).toBeInTheDocument();
+    expect(
+      rendered.getByText(/uploadJobs.myscope.header/i).closest("a"),
+    ).toBeNull();
   });
 
   it("renders breadcrumbs with filename", async () => {

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

@@ -0,0 +1,71 @@
+import { render } from "@truedat/test/render";
+import UploadJobHistory, { getLifecycleEvents } from "../UploadJobHistory";
+
+const messages = {
+  en: {
+    "uploadJob.history.PENDING": "File received and pending processing.",
+    "uploadJob.history.STARTED": "Record reading and validation started.",
+    "uploadJob.history.COMPLETED": "File processed successfully.",
+    "uploadJob.history.FAILED": "The file could not be processed.",
+    "uploadJob.history.title": "File processing history",
+    "uploadJob.history.empty": "No processing history found.",
+    "uploadJob.table.status": "Status",
+    "uploadJob.table.inserted_at": "Processed at",
+    "uploadJob.table.response": "Detail",
+    "uploadJob.parser.event.status.PENDING": "Pending",
+    "uploadJob.parser.event.status.STARTED": "Started",
+    "uploadJob.parser.event.status.COMPLETED": "Completed",
+    "uploadJob.parser.event.status.FAILED": "Failed",
+  },
+};
+
+describe("<UploadJobHistory />", () => {
+  it("shows lifecycle only with generic final messages", () => {
+    const events = [
+      { status: "PENDING", inserted_at: "2026-01-01T10:00:00Z" },
+      { status: "STARTED", inserted_at: "2026-01-01T10:01:00Z" },
+      { status: "INFO", response: { type: "created" } },
+      { status: "ERROR", response: { type: "invalid_template_name" } },
+      {
+        status: "COMPLETED",
+        inserted_at: "2026-01-01T10:02:00Z",
+        response: { insert_count: 10 },
+      },
+      {
+        status: "FAILED",
+        inserted_at: "2026-01-01T10:03:00Z",
+        response: { message: "invalid_format" },
+      },
+    ];
+
+    const rendered = render(<UploadJobHistory events={events} />, { messages });
+
+    expect(getLifecycleEvents(events)).toHaveLength(4);
+    expect(rendered.queryByText(/created: 10/i)).not.toBeInTheDocument();
+    expect(
+      rendered.getByText("File received and pending processing."),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByText("Record reading and validation started."),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByText("File processed successfully."),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByText("The file could not be processed."),
+    ).toBeInTheDocument();
+    expect(
+      rendered.queryByText(/invalid_template_name/i),
+    ).not.toBeInTheDocument();
+    expect(rendered.queryByText(/invalid_format/i)).not.toBeInTheDocument();
+    expect(rendered.getByRole("columnheader", { name: "Status" })).toHaveClass(
+      "upload-job-visually-hidden",
+    );
+    expect(
+      rendered.getByRole("columnheader", { name: "Processed at" }),
+    ).toHaveClass("upload-job-visually-hidden");
+    expect(rendered.getByRole("columnheader", { name: "Detail" })).toHaveClass(
+      "upload-job-visually-hidden",
+    );
+  });
+});