@truedat/core 8.13.0 → 8.13.2

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",
+    );
+  });
+});