@truedat/core 8.13.0 → 8.13.2

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

@@ -1,9 +1,58 @@
 import userEvent from "@testing-library/user-event";
 import { renderWithIntl as render } from "@truedat/test/renderWithIntl";
-import { StatusPill, ResponseCell } from "../UploadJobParser";
+import {
+  ResultDetailCell,
+  ResultEntityCell,
+  StatusPill,
+  ResponseCell,
+} from "../UploadJobParser";
 
-jest.mock("@truedat/dq/components/RuleImplementationLink", () => () => null);
-jest.mock("@truedat/dd/components/StructureNoteLink", () => () => null);
+jest.mock("@truedat/dq/components/RuleImplementationLink", () => ({
+  __esModule: true,
+  default: ({ implementation_key, implementation_ref }) => (
+    <>
+      <a href={`/implementations/${implementation_key}`}>
+        {implementation_key}
+      </a>
+      {implementation_ref != null && implementation_ref !== "" ? (
+        <small>{implementation_ref}</small>
+      ) : null}
+    </>
+  ),
+}));
+jest.mock("@truedat/dd/components/StructureNoteLink", () => ({
+  __esModule: true,
+  default: ({ alias, external_id, name }) => {
+    const label = alias?.trim() || name || external_id;
+    return (
+      <>
+        <a href={`/notes/${external_id}`}>{label}</a>
+        {external_id !== label ? <small>{external_id}</small> : null}
+      </>
+    );
+  },
+}));
+
+const changeMessages = {
+  en: {
+    "uploadJob.parser.info.implementation_updated": "Item updated",
+    "uploadJob.parser.info.updated": "Updated",
+    "uploadJob.results.changes.modifiedFields":
+      "{count, plural, one {# modified field} other {# modified fields}}",
+    "uploadJob.results.changes.field": "Field",
+    "uploadJob.results.changes.previous": "Previous value",
+    "uploadJob.results.changes.change": "Change",
+    "uploadJob.results.changes.new": "New value",
+    "uploadJob.results.errors.errorFields":
+      "{count, plural, one {# field with an error} other {# fields with errors}}",
+    "uploadJob.results.errors.field": "Field",
+    "uploadJob.results.errors.error": "Error",
+    "uploadJob.parser.error.field_validation_error": "Field validation error",
+    "uploadJob.parser.error.data_structure_not_found":
+      "Data structure not found",
+    "uploadJob.parser.detail.message": "Message",
+  },
+};
 
 describe("<StatusPill />", () => {
   it("renders with correct color based on status", async () => {
@@ -23,6 +72,174 @@ describe("<StatusPill />", () => {
   });
 });
 
+describe("<ResultEntityCell />", () => {
+  it("renders INFO implementation and structure-note links from row details", () => {
+    const implementation = render(
+      <ResultEntityCell
+        status="INFO"
+        response={{ details: { implementation_key: "impl" } }}
+      />,
+    );
+    expect(implementation.getByRole("link", { name: "impl" })).toHaveAttribute(
+      "href",
+      "/implementations/impl",
+    );
+
+    const note = render(
+      <ResultEntityCell
+        status="INFO"
+        response={{
+          details: { data_structure_id: 1, external_id: "note" },
+        }}
+      />,
+    );
+    expect(note.getByRole("link", { name: "note" })).toHaveAttribute(
+      "href",
+      "/notes/note",
+    );
+  });
+
+  it("renders implementation refs and preferred structure labels with external ids", () => {
+    const implementation = render(
+      <ResultEntityCell
+        status="INFO"
+        response={{
+          details: { implementation_key: "impl", implementation_ref: 0 },
+        }}
+      />,
+    );
+    expect(implementation.getByText("0")).toBeInTheDocument();
+
+    const alias = render(
+      <ResultEntityCell
+        status="INFO"
+        response={{
+          details: {
+            alias: "Structure alias",
+            data_structure_id: 1,
+            external_id: "EXT-001",
+            name: "Structure name",
+          },
+        }}
+      />,
+    );
+    expect(
+      alias.getByRole("link", { name: "Structure alias" }),
+    ).toHaveAttribute("href", "/notes/EXT-001");
+    expect(alias.getByText("EXT-001")).toBeInTheDocument();
+
+    const name = render(
+      <ResultEntityCell
+        status="INFO"
+        response={{
+          details: {
+            alias: "  ",
+            data_structure_id: 1,
+            external_id: "EXT-002",
+            name: "Structure name",
+          },
+        }}
+      />,
+    );
+    expect(name.getByRole("link", { name: "Structure name" })).toHaveAttribute(
+      "href",
+      "/notes/EXT-002",
+    );
+    expect(name.getByText("EXT-002")).toBeInTheDocument();
+  });
+
+  it("renders a structure-note link for errors with identified structures", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="ERROR"
+        response={{
+          type: "field_validation_error",
+          details: { data_structure_id: 1, external_id: "note" },
+        }}
+      />,
+    );
+
+    expect(rendered.getByRole("link", { name: "note" })).toHaveAttribute(
+      "href",
+      "/notes/note",
+    );
+  });
+
+  it("renders an implementation link for errors with identified implementations", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="ERROR"
+        response={{ details: { implementation_key: "impl" } }}
+      />,
+    );
+
+    expect(rendered.getByRole("link", { name: "impl" })).toHaveAttribute(
+      "href",
+      "/implementations/impl",
+    );
+  });
+
+  it("does not render an entity for data_structure_not_found errors", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="ERROR"
+        response={{
+          type: "data_structure_not_found",
+          details: {
+            data_structure_id: 1,
+            external_id: "unknown-note",
+            implementation_key: "impl",
+          },
+        }}
+      />,
+    );
+
+    expect(rendered.container.firstChild).toBeNull();
+  });
+
+  it.each([{ data_structure_id: 1 }, { external_id: "note" }])(
+    "does not render ERROR entities with incomplete structure identifiers",
+    (details) => {
+      const rendered = render(
+        <ResultEntityCell
+          status="ERROR"
+          response={{ type: "field_validation_error", details }}
+        />,
+      );
+
+      expect(rendered.container.firstChild).toBeNull();
+    },
+  );
+
+  it("does not render an entity for errors without reliable identifiers", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="ERROR"
+        response={{ type: "field_validation_error", details: {} }}
+      />,
+    );
+
+    expect(rendered.container.firstChild).toBeNull();
+  });
+
+  it("does not render an entity for non-result statuses", () => {
+    const rendered = render(
+      <ResultEntityCell
+        status="FAILED"
+        response={{
+          details: {
+            data_structure_id: 1,
+            external_id: "note",
+            implementation_key: "impl",
+          },
+        }}
+      />,
+    );
+
+    expect(rendered.container.firstChild).toBeNull();
+  });
+});
+
 describe("<ResponseCell />", () => {
   it("returns null when response is empty", () => {
     const rendered = render(
@@ -34,12 +251,66 @@ describe("<ResponseCell />", () => {
     expect(rendered2.container.firstChild).toBeNull();
   });
 
-  it("renders FAILED status with message", () => {
-    const response = { message: "missing_required_headers" };
+  it("renders FAILED status with a translated error code", () => {
+    const response = { message: "invalid_format" };
     const rendered = render(
       <ResponseCell response={response} status="FAILED" />,
+      {
+        messages: {
+          en: {
+            "uploadJob.parser.error.invalid_format": "Invalid file format",
+          },
+        },
+      },
+    );
+    expect(rendered.getByText("Invalid file format")).toBeInTheDocument();
+  });
+
+  it("replaces FAILED technical exception messages with an unexpected error", () => {
+    const technicalMessage = '%RuntimeError{message: "boom"}';
+    const rendered = render(
+      <ResponseCell response={{ message: technicalMessage }} status="FAILED" />,
+      {
+        messages: {
+          en: {
+            "uploadJob.parser.error.unexpected_error": "Unexpected error",
+          },
+        },
+      },
+    );
+
+    expect(rendered.getByText("Unexpected error")).toBeInTheDocument();
+    expect(rendered.queryByText(technicalMessage)).not.toBeInTheDocument();
+  });
+
+  it("preserves FAILED error codes and human messages", () => {
+    const code = render(
+      <ResponseCell
+        response={{ message: "missing_required_headers" }}
+        status="FAILED"
+      />,
+    );
+    expect(code.getByText(/missing_required_headers/i)).toBeInTheDocument();
+
+    const human = render(
+      <ResponseCell
+        response={{ message: "The file could not be processed" }}
+        status="FAILED"
+      />,
+    );
+    expect(
+      human.getByText("The file could not be processed"),
+    ).toBeInTheDocument();
+
+    const multiline = render(
+      <ResponseCell
+        response={{ message: "The file could not be processed\nPlease retry" }}
+        status="FAILED"
+      />,
+    );
+    expect(multiline.container).toHaveTextContent(
+      "The file could not be processed Please retry",
     );
-    expect(rendered.getByText(/missing_required_headers/i)).toBeInTheDocument();
   });
 
   it("renders ERROR status with details", () => {
@@ -85,10 +356,13 @@ describe("<ResponseCell />", () => {
         },
       },
     };
-    const rendered = render(<ResponseCell response={response} status="INFO" />);
-    expect(
-      rendered.getByText(/uploadJob.parser.info.implementation_updated/i),
-    ).toBeInTheDocument();
+    const rendered = render(
+      <ResponseCell response={response} status="INFO" />,
+      {
+        messages: changeMessages,
+      },
+    );
+    expect(rendered.getByText("Item updated")).toBeInTheDocument();
   });
 
   it("renders INFO status with deprecated_implementation specifically when unchanged and deprecated", () => {
@@ -99,7 +373,12 @@ describe("<ResponseCell />", () => {
         is_deprecated: true,
       },
     };
-    const rendered = render(<ResponseCell response={response} status="INFO" />);
+    const rendered = render(
+      <ResponseCell response={response} status="INFO" />,
+      {
+        messages: changeMessages,
+      },
+    );
     expect(
       rendered.getByText(/uploadJob.parser.info.deprecated_implementation/i),
     ).toBeInTheDocument();
@@ -306,23 +585,38 @@ describe("<ResponseCell />", () => {
       },
     };
     const user = userEvent.setup({ delay: null });
-    const rendered = render(<ResponseCell response={response} status="INFO" />);
-    expect(
-      rendered.getByText(/uploadJob.parser.info.implementation_updated/i),
-    ).toBeInTheDocument();
+    const rendered = render(
+      <ResponseCell response={response} status="INFO" />,
+      {
+        messages: changeMessages,
+      },
+    );
     expect(
-      rendered.getByText(/uploadJob.parser.result.prop.changes/i),
+      rendered.getByRole("button", { name: /2 modified fields/i }),
     ).toBeInTheDocument();
-    expect(rendered.getByText(/\(2\)/)).toBeInTheDocument();
     await user.click(
-      rendered
-        .getByText(/uploadJob.parser.result.prop.changes/i)
-        .closest("div"),
+      rendered.getByRole("button", { name: /2 modified fields/i }),
     );
     expect(rendered.getByText(/New Name/i)).toBeInTheDocument();
     expect(rendered.getByText(/Updated description/i)).toBeInTheDocument();
   });
 
+  it("does not render changes for created INFO events", () => {
+    const rendered = render(
+      <ResultDetailCell
+        response={{
+          type: "created",
+          details: { changes: { name: "Created name" } },
+        }}
+        status="INFO"
+      />,
+      { messages: changeMessages },
+    );
+
+    expect(rendered.queryByRole("button")).not.toBeInTheDocument();
+    expect(rendered.queryByRole("table")).not.toBeInTheDocument();
+  });
+
   it("renders INFO status with nested df_content in changes", async () => {
     const response = {
       type: "implementation_updated",
@@ -335,14 +629,118 @@ describe("<ResponseCell />", () => {
       },
     };
     const user = userEvent.setup({ delay: null });
-    const rendered = render(<ResponseCell response={response} status="INFO" />);
-    const changesHeader = rendered.getByText(
-      /uploadJob.parser.result.prop.changes/i,
+    const rendered = render(
+      <ResponseCell response={response} status="INFO" />,
+      {
+        messages: changeMessages,
+      },
+    );
+    await user.click(
+      rendered.getByRole("button", { name: /1 modified field/i }),
+    );
+    expect(rendered.getByText(/inner_key/i)).toBeInTheDocument();
+  });
+
+  it("renders change_details as a translated old/new values table", async () => {
+    const response = {
+      type: "updated",
+      details: {
+        change_details: {
+          goal: { old: 80, new: 90 },
+          df_content: {
+            frequency: {
+              old: {
+                value: "a very long previous value that must remain accessible",
+                origin: "user",
+              },
+              new: {
+                value: "a very long new value that must remain accessible",
+                origin: "file",
+              },
+            },
+          },
+        },
+      },
+    };
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(
+      <ResponseCell response={response} status="INFO" />,
+      {
+        messages: changeMessages,
+      },
     );
-    await user.click(changesHeader.closest("div"));
+
+    const toggle = rendered.getByRole("button", {
+      name: /2 modified fields/i,
+    });
+    expect(toggle).toHaveAttribute("aria-expanded", "false");
+    expect(toggle).toHaveAttribute("aria-controls");
+    await user.click(toggle);
+
+    expect(toggle).toHaveAttribute("aria-expanded", "true");
+    expect(rendered.getByText("Field")).toBeInTheDocument();
+    expect(rendered.getByText("Previous value")).toBeInTheDocument();
+    expect(rendered.getByText("New value")).toBeInTheDocument();
+    expect(rendered.getByText("80")).toBeInTheDocument();
+    expect(rendered.getByText("90")).toBeInTheDocument();
     expect(
-      rendered.getByText(/ruleImplementations.props.df_content/i),
-    ).toBeInTheDocument();
+      rendered.getByText(
+        "a very long previous value that must remain accessible",
+      ),
+    ).toHaveAttribute(
+      "title",
+      "a very long previous value that must remain accessible",
+    );
+    expect(
+      rendered.getByText("a very long new value that must remain accessible"),
+    ).toHaveAttribute(
+      "title",
+      "a very long new value that must remain accessible",
+    );
+    const arrows = rendered.getAllByText("→");
+    expect(arrows).toHaveLength(2);
+    arrows.forEach((arrow) => {
+      expect(arrow).toHaveAttribute("aria-hidden", "true");
+      expect(arrow.closest("span")).toHaveAttribute("aria-hidden", "true");
+      expect(arrow.closest("td")).not.toHaveAttribute("aria-hidden");
+    });
+  });
+
+  it("renders boolean, null and zero change values without losing their values", async () => {
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(
+      <ResponseCell
+        response={{
+          type: "updated",
+          details: {
+            change_details: {
+              enabled: { old: false, new: true },
+              nullable: { old: null, new: null },
+              count: { old: 0, new: 0 },
+            },
+          },
+        }}
+        status="INFO"
+      />,
+      { messages: changeMessages },
+    );
+
+    await user.click(
+      rendered.getByRole("button", { name: /3 modified fields/i }),
+    );
+
+    const falseValue = rendered.getByText("false");
+    const trueValue = rendered.getByText("true");
+    const emptyValues = rendered.getAllByText("—");
+    const zeroValues = rendered.getAllByText("0");
+
+    expect(falseValue).toHaveAttribute("title", "false");
+    expect(trueValue).toHaveAttribute("title", "true");
+    expect(emptyValues).toHaveLength(2);
+    expect(emptyValues[0]).toHaveAttribute("title", "—");
+    expect(zeroValues).toHaveLength(2);
+    expect(zeroValues[0]).toHaveAttribute("title", "0");
+    expect(falseValue).not.toHaveAttribute("aria-label");
   });
 
   it("renders ERROR with sheet and row_number in response", () => {
@@ -372,3 +770,139 @@ describe("<ResponseCell />", () => {
     expect(rendered.container.firstChild).toBeNull();
   });
 });
+
+describe("<ResultDetailCell /> errors", () => {
+  const response = {
+    type: "field_validation_error",
+    sheet: "Sheet1",
+    row_number: 5,
+    details: {
+      errors: [
+        { field: "name", message: "Required" },
+        { field: "external_id", message: "Already exists" },
+      ],
+    },
+  };
+
+  it("renders structured errors collapsed and expands them as a Field/Error table", async () => {
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(
+      <ResultDetailCell response={response} status="ERROR" />,
+      { messages: changeMessages },
+    );
+
+    const toggle = rendered.getByRole("button", {
+      name: "2 fields with errors",
+    });
+    expect(toggle).not.toHaveAccessibleName(/field validation error/i);
+    expect(toggle).toHaveAttribute("aria-expanded", "false");
+    expect(toggle).toHaveAttribute("aria-controls");
+    expect(rendered.queryByText("Required")).not.toBeInTheDocument();
+    expect(rendered.queryByText("Sheet1")).not.toBeInTheDocument();
+
+    await user.click(toggle);
+
+    expect(toggle).toHaveAttribute("aria-expanded", "true");
+    expect(
+      rendered.getByRole("columnheader", { name: "Field" }),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByRole("columnheader", { name: "Error" }),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByRole("rowheader", { name: "name" }),
+    ).toBeInTheDocument();
+    expect(
+      rendered.getByRole("rowheader", { name: "external_id" }),
+    ).toBeInTheDocument();
+    expect(rendered.getByText("Required")).toBeInTheDocument();
+    expect(rendered.getByText("Already exists")).toBeInTheDocument();
+  });
+
+  it("does not render an empty disclosure when the error has no details", () => {
+    const rendered = render(
+      <ResultDetailCell
+        response={{ type: "field_validation_error" }}
+        status="ERROR"
+      />,
+      { messages: changeMessages },
+    );
+
+    expect(rendered.queryByRole("button")).not.toBeInTheDocument();
+    expect(rendered.getByText("Field validation error")).toBeInTheDocument();
+  });
+
+  it("renders data_structure_not_found as a simple message without technical details", () => {
+    const rendered = render(
+      <ResultDetailCell
+        response={{
+          type: "data_structure_not_found",
+          details: { external_id: "unknown-note", data_structure_id: 123 },
+        }}
+        status="ERROR"
+      />,
+      { messages: changeMessages },
+    );
+
+    expect(rendered.getByText("Data structure not found")).toBeInTheDocument();
+    expect(rendered.queryByRole("button")).not.toBeInTheDocument();
+    expect(rendered.queryByRole("table")).not.toBeInTheDocument();
+    expect(rendered.queryByText("unknown-note")).not.toBeInTheDocument();
+  });
+
+  it("uses the singular error count for one field", () => {
+    const rendered = render(
+      <ResultDetailCell
+        response={{
+          type: "field_validation_error",
+          details: { errors: [{ field: "name", message: "Required" }] },
+        }}
+        status="ERROR"
+      />,
+      { messages: changeMessages },
+    );
+
+    expect(
+      rendered.getByRole("button", {
+        name: "1 field with an error",
+      }),
+    ).toBeInTheDocument();
+  });
+
+  it("renders notes change_details with previous and new values", async () => {
+    const user = userEvent.setup({ delay: null });
+    const rendered = render(
+      <ResultDetailCell
+        response={{
+          type: "updated",
+          details: {
+            external_id: "EXT-001",
+            data_structure_id: 123,
+            changes: { status: "published" },
+            change_details: {
+              status: { old: "draft", new: "published" },
+              df_content: {
+                field: {
+                  old: { value: "old_value", origin: "user" },
+                  new: { value: "new_value", origin: "file" },
+                },
+              },
+            },
+          },
+        }}
+        status="INFO"
+        scope="notes"
+      />,
+      { messages: changeMessages },
+    );
+
+    await user.click(
+      rendered.getByRole("button", { name: /2 modified fields/i }),
+    );
+
+    expect(rendered.getByText("draft")).toBeInTheDocument();
+    expect(rendered.getByText("published")).toBeInTheDocument();
+    expect(rendered.getByText("old_value")).toBeInTheDocument();
+    expect(rendered.getByText("new_value")).toBeInTheDocument();
+  });
+});