@truedat/dd 8.13.5 → 8.13.7

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

@@ -0,0 +1,117 @@
+import { act, fireEvent, screen } from "@testing-library/react";
+import { render } from "@truedat/test/render";
+import { GraphGenerationDialog } from "../GraphGenerationDialog";
+
+beforeEach(() => jest.useFakeTimers());
+afterEach(() => {
+  jest.runOnlyPendingTimers();
+  jest.useRealTimers();
+});
+
+test("reveals choices after three seconds and keeps waiting without closing", () => {
+  const onBackground = jest.fn();
+  render(
+    <GraphGenerationDialog open requestKey="a" onBackground={onBackground} />,
+  );
+  act(() => jest.advanceTimersByTime(2999));
+  expect(
+    screen.queryByRole("button", { name: "lineage.graph.wait.continue" }),
+  ).not.toBeInTheDocument();
+  act(() => jest.advanceTimersByTime(1));
+  fireEvent.click(
+    screen.getByRole("button", { name: "lineage.graph.wait.continue" }),
+  );
+  expect(
+    screen.getByRole("button", { name: "lineage.graph.wait.waiting" }),
+  ).toBeDisabled();
+  expect(onBackground).not.toHaveBeenCalled();
+  fireEvent.click(
+    screen.getByRole("button", { name: "lineage.graph.wait.background" }),
+  );
+  expect(onBackground).toHaveBeenCalledTimes(1);
+});
+
+test("manual close is available before the delay without enabling notifications", () => {
+  const onClose = jest.fn();
+  const onBackground = jest.fn();
+  render(
+    <GraphGenerationDialog
+      open
+      requestKey="a"
+      onClose={onClose}
+      onBackground={onBackground}
+    />,
+  );
+  fireEvent.click(
+    screen.getByRole("button", { name: "lineage.graph.wait.close" }),
+  );
+  expect(onClose).toHaveBeenCalledTimes(1);
+  expect(onBackground).not.toHaveBeenCalled();
+});
+
+test("escape uses manual close and unmount cancels its timer", () => {
+  const onClose = jest.fn();
+  const onBackground = jest.fn();
+  const { unmount } = render(
+    <GraphGenerationDialog
+      open
+      requestKey="a"
+      onClose={onClose}
+      onBackground={onBackground}
+    />,
+  );
+  fireEvent.keyDown(document, { key: "Escape", keyCode: 27 });
+  expect(onClose).toHaveBeenCalled();
+  expect(onBackground).not.toHaveBeenCalled();
+  unmount();
+  act(() => jest.advanceTimersByTime(3000));
+});
+
+test("progress rerenders do not restart the timer, and a new request resets the choice", () => {
+  const onBackground = jest.fn();
+  const { rerender } = render(
+    <GraphGenerationDialog open requestKey="a" onBackground={onBackground} />,
+  );
+  act(() => jest.advanceTimersByTime(2000));
+  rerender(
+    <GraphGenerationDialog open requestKey="a" onBackground={onBackground} />,
+  );
+  act(() => jest.advanceTimersByTime(1000));
+  fireEvent.click(
+    screen.getByRole("button", { name: "lineage.graph.wait.continue" }),
+  );
+  rerender(
+    <GraphGenerationDialog open requestKey="b" onBackground={onBackground} />,
+  );
+  expect(
+    screen.queryByRole("button", { name: "lineage.graph.wait.waiting" }),
+  ).not.toBeInTheDocument();
+  act(() => jest.advanceTimersByTime(3000));
+  expect(
+    screen.getByRole("button", { name: "lineage.graph.wait.continue" }),
+  ).toBeEnabled();
+});
+
+test("traps keyboard focus inside the dialog and restores it after closing", () => {
+  const trigger = document.createElement("button");
+  document.body.appendChild(trigger);
+  trigger.focus();
+  const { unmount } = render(
+    <GraphGenerationDialog open requestKey="a" onBackground={jest.fn()} />,
+  );
+  const close = screen.getByRole("button", {
+    name: "lineage.graph.wait.close",
+  });
+  expect(close).toHaveFocus();
+  act(() => jest.advanceTimersByTime(3000));
+  fireEvent.keyDown(close, { key: "Tab", shiftKey: true });
+  const background = screen.getByRole("button", {
+    name: "lineage.graph.wait.background",
+  });
+  expect(background).toHaveFocus();
+  fireEvent.keyDown(background, { key: "Tab" });
+  expect(close).toHaveFocus();
+  unmount();
+  expect(trigger).toHaveFocus();
+  trigger.remove();
+});

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

@@ -0,0 +1,60 @@
+import { fireEvent, screen } from "@testing-library/react";
+import { render } from "@truedat/test/render";
+import { GraphGenerationNotices } from "../GraphGenerationNotices";
+
+test("completion gives an explicit link without automatic navigation", () => {
+  const dismiss = jest.fn();
+  render(
+    <GraphGenerationNotices
+      jobs={{
+        a: {
+          requestId: "a",
+          background: true,
+          notify: true,
+          status: "completed",
+          graphId: 42,
+        },
+      }}
+      dismissGraphGeneration={dismiss}
+    />,
+  );
+  expect(
+    screen.getByRole("link", { name: "lineage.graph.wait.open" }),
+  ).toHaveAttribute("href", "/graphs/42");
+  expect(dismiss).not.toHaveBeenCalled();
+  fireEvent.click(
+    screen.getByRole("button", { name: "lineage.graph.wait.dismiss" }),
+  );
+  expect(dismiss).toHaveBeenCalledWith("a");
+});
+
+test("a failure is announced and has no success link", () => {
+  render(
+    <GraphGenerationNotices
+      jobs={{ a: { requestId: "a", status: "failed" } }}
+      dismissGraphGeneration={jest.fn()}
+    />,
+  );
+  expect(screen.getByRole("alert")).toHaveTextContent(
+    "lineage.graph.wait.failed",
+  );
+  expect(screen.queryByRole("link")).not.toBeInTheDocument();
+});
+
+test("background work without explicit notification consent stays silent", () => {
+  render(
+    <GraphGenerationNotices
+      jobs={{
+        a: {
+          requestId: "a",
+          background: true,
+          status: "completed",
+          graphId: 42,
+        },
+      }}
+      dismissGraphGeneration={jest.fn()}
+    />,
+  );
+  expect(screen.queryByRole("link")).not.toBeInTheDocument();
+  expect(screen.queryByRole("status")).not.toBeInTheDocument();
+});

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

@@ -0,0 +1,74 @@
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { IntlProvider } from "react-intl";
+import { MemoryRouter } from "react-router";
+import { GraphGenerationDialog } from "../GraphGenerationDialog";
+import { GraphGenerationNotices } from "../GraphGenerationNotices";
+import en from "../../messages/en";
+import es from "../../messages/es";
+import migratedMessages from "./fixtures/graphGenerationMessages.json";
+
+beforeEach(() => jest.useFakeTimers());
+afterEach(() => jest.useRealTimers());
+
+test.each([
+  ["en", { ...en, ...migratedMessages.en }],
+  ["es", { ...es, ...migratedMessages.es }],
+])(
+  "renders translated generation controls and notices in %s",
+  (locale, messages) => {
+    const onError = jest.fn();
+    const view = render(
+      <IntlProvider locale={locale} messages={messages} onError={onError}>
+        <MemoryRouter>
+          <GraphGenerationDialog open requestKey="a" onBackground={jest.fn()} />
+          <GraphGenerationNotices
+            jobs={{
+              pending: {
+                requestId: "pending",
+                notify: true,
+                status: "pending",
+              },
+              completed: {
+                requestId: "completed",
+                notify: true,
+                status: "completed",
+                graphId: 42,
+              },
+              failed: { requestId: "failed", notify: true, status: "failed" },
+            }}
+            dismissGraphGeneration={jest.fn()}
+          />
+        </MemoryRouter>
+      </IntlProvider>,
+    );
+    act(() => jest.advanceTimersByTime(3000));
+    const text = (suffix) => messages[`lineage.graph.wait.${suffix}`];
+    ["explanation", "background.notice", "completed", "failed"].forEach(
+      (suffix) => {
+        expect(text(suffix)).toEqual(expect.any(String));
+        expect(screen.getByText(text(suffix))).toBeInTheDocument();
+      },
+    );
+    ["close", "continue", "background"].forEach((suffix) => {
+      expect(text(suffix)).toEqual(expect.any(String));
+      expect(
+        screen.getByRole("button", { name: text(suffix) }),
+      ).toBeInTheDocument();
+    });
+    expect(text("open")).toEqual(expect.any(String));
+    expect(text("dismiss")).toEqual(expect.any(String));
+    expect(
+      screen.getByRole("link", { name: text("open"), hidden: true }),
+    ).toHaveAttribute("href", "/graphs/42");
+    expect(
+      screen.getAllByRole("button", { name: text("dismiss"), hidden: true }),
+    ).toHaveLength(2);
+    fireEvent.click(screen.getByRole("button", { name: text("continue") }));
+    expect(text("waiting")).toEqual(expect.any(String));
+    expect(
+      screen.getByRole("button", { name: text("waiting") }),
+    ).toBeDisabled();
+    expect(onError).not.toHaveBeenCalled();
+    view.unmount();
+  },
+);

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

@@ -0,0 +1,83 @@
+import { fireEvent, screen } from "@testing-library/react";
+import { useDispatch } from "react-redux";
+import { Route, Routes, useLocation } from "react-router";
+import { render } from "@truedat/test/render";
+import ConnectedGraphLoader, { GraphLoader } from "../GraphLoader";
+import GraphRedirector from "../GraphRedirector";
+import { graph as graphReducer } from "../../reducers/graph";
+import { graphRedirect as redirectReducer } from "../../reducers/graphRedirect";
+import { createGraph, fetchGraph } from "../../routines";
+
+const GenerateGraph = () => {
+  const dispatch = useDispatch();
+  const { pathname } = useLocation();
+  return (
+    <>
+      <button
+        onClick={() =>
+          dispatch(
+            createGraph.success({ data: { id: 43, isRedirected: true } }),
+          )
+        }
+      >
+        Complete generation
+      </button>
+      <output>{pathname}</output>
+    </>
+  );
+};
+
+test("redirects to the generated graph without refetching the previous graph", () => {
+  const requests = jest.fn();
+  render(
+    <Routes>
+      <Route
+        path="/graphs/:id"
+        element={
+          <>
+            <GenerateGraph />
+            <GraphRedirector />
+            <ConnectedGraphLoader />
+          </>
+        }
+      />
+    </Routes>,
+    {
+      routes: ["/graphs/42"],
+      state: { graph: { id: 42 }, graphRedirect: "" },
+      reducer: (state, action) => {
+        if (action.type === fetchGraph.TRIGGER) requests(action.payload);
+        return {
+          graph: graphReducer(state.graph, action),
+          graphRedirect: redirectReducer(state.graphRedirect, action),
+        };
+      },
+    },
+  );
+  fireEvent.click(screen.getByRole("button", { name: "Complete generation" }));
+  expect(screen.getByText("/graphs/43")).toBeInTheDocument();
+  expect(requests).not.toHaveBeenCalled();
+});
+
+test("does not fetch repeatedly when a response is missing its graph id", () => {
+  const fetchGraph = jest.fn();
+  const clearGraph = jest.fn();
+  const view = (graph) => (
+    <Routes>
+      <Route
+        path="/graphs/:id"
+        element={
+          <GraphLoader
+            graph={graph}
+            fetchGraph={fetchGraph}
+            clearGraph={clearGraph}
+          />
+        }
+      />
+    </Routes>
+  );
+  const { rerender } = render(view({}), { routes: ["/graphs/42"] });
+  rerender(view({ data: { id: 42 } }));
+  rerender(view({ data: { id: 42 } }));
+  expect(fetchGraph).toHaveBeenCalledTimes(1);
+});

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

@@ -1,10 +1,11 @@
-import { fireEvent, screen, within } from "@testing-library/react";
+import { act, fireEvent, screen, within } from "@testing-library/react";
 import { Route, Routes, useLocation } from "react-router";
 import { render } from "@truedat/test/render";
 import { LineageGraph } from "../LineageGraph";
 import { GraphLoader } from "../GraphLoader";
 
 let mockGraphProps;
+let mockDeferInitialFit = false;
 
 jest.mock("@truedat/core/components/Graph", () => {
   const React = require("react");
@@ -12,10 +13,9 @@ jest.mock("@truedat/core/components/Graph", () => {
   return function Graph(props) {
     mockGraphProps = props;
     const [expanded, setExpanded] = React.useState(false);
-    React.useEffect(
-      () => props.onInitialFitComplete(),
-      [props.onInitialFitComplete],
-    );
+    React.useEffect(() => {
+      if (!mockDeferInitialFit) props.onInitialFitComplete();
+    }, [props.onInitialFitComplete]);
     const canvas = (name) => (
       <div className="td-graph-container" data-testid={name}>
         {props.nodes
@@ -50,7 +50,6 @@ const props = {
   graphId: "graph-1",
   loading: false,
   simplified: true,
-  cancelPoll: jest.fn(),
   groups: [],
   resources: [
     { id: "orders", name: "Orders", x: 0, y: 0, w: 288, h: 100 },
@@ -72,6 +71,55 @@ const renderGraph = (extra = {}) =>
     { state },
   );
 
+it("keeps the unanswered loading dialog through polling and until the graph is fitted", () => {
+  mockDeferInitialFit = true;
+  const backgroundGraph = jest.fn();
+  const onGraphReady = jest.fn();
+  const generationJob = { requestId: "slow-graph", status: "pending" };
+  const pendingProps = {
+    ...props,
+    simplified: false,
+    loading: true,
+    generationJob,
+    backgroundGraph,
+    onGraphReady,
+  };
+  const view = render(<LineageGraph {...pendingProps} />, { state });
+  try {
+    act(() => jest.advanceTimersByTime(3000));
+    const continueButton = screen.getByRole("button", {
+      name: "lineage.graph.wait.continue",
+    });
+    for (let retry = 1; retry <= 3; retry += 1) {
+      view.rerender(
+        <LineageGraph
+          {...pendingProps}
+          generationJob={{ ...generationJob, hash: "slow-hash", retry }}
+        />,
+      );
+      act(() => jest.advanceTimersByTime(3000));
+      expect(continueButton).toBeVisible();
+      expect(continueButton).toBeEnabled();
+    }
+    view.rerender(
+      <LineageGraph
+        {...pendingProps}
+        loading={false}
+        generationJob={{ ...generationJob, status: "completed" }}
+      />,
+    );
+    expect(continueButton).toBeVisible();
+    expect(onGraphReady).not.toHaveBeenCalled();
+    expect(backgroundGraph).not.toHaveBeenCalled();
+    act(() => mockGraphProps.onInitialFitComplete());
+    expect(continueButton).not.toBeInTheDocument();
+    expect(onGraphReady).toHaveBeenCalledTimes(1);
+  } finally {
+    mockDeferInitialFit = false;
+    view.unmount();
+  }
+});
+
 it("selects successive nodes through a real portal and keeps dependencies active on return", () => {
   renderGraph();
   fireEvent.click(screen.getByText("Toggle expanded"));
@@ -225,7 +273,6 @@ it.each([
               graph={graph}
               fetchGraph={fetchGraph}
               clearGraph={jest.fn()}
-              cancelPoll={jest.fn()}
             />
           }
         />
@@ -236,3 +283,27 @@ it.each([
     else expect(fetchGraph).not.toHaveBeenCalled();
   },
 );
+
+test.each([
+  { simplified: true },
+  { simplified: false },
+  {
+    simplified: true,
+    generationJob: { requestId: "other", status: "pending" },
+  },
+])("keeps loading inline without a background action: %j", (extra) => {
+  const backgroundGraph = jest.fn();
+  const view = renderGraph({ ...extra, loading: true, backgroundGraph });
+  act(() => jest.advanceTimersByTime(3000));
+  expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+  expect(
+    screen.getByText("lineage.graph.loading").closest("[role=status]"),
+  ).toBeInTheDocument();
+  expect(
+    screen.queryByRole("button", { name: "lineage.graph.wait.background" }),
+  ).not.toBeInTheDocument();
+  fireEvent.keyDown(document, { key: "Escape", keyCode: 27 });
+  expect(backgroundGraph).not.toHaveBeenCalled();
+  expect(screen.getByText("lineage.graph.loading")).toBeInTheDocument();
+  view.unmount();
+});

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

@@ -12,12 +12,14 @@ jest.mock("@truedat/ai/components/suggestions/SuggestionsWidget", () => ({
 
 let dynamicFormOnChange;
 let dynamicFormContent;
+let dynamicFormOriginalContent;
 
 jest.mock("@truedat/df/components/DynamicForm", () => ({
   __esModule: true,
-  default: ({ onChange, content }) => {
+  default: ({ onChange, content, originalContent }) => {
     dynamicFormOnChange = onChange;
     dynamicFormContent = content;
+    dynamicFormOriginalContent = originalContent;
     return <div data-testid="dynamic-form" />;
   },
 }));
@@ -27,6 +29,108 @@ describe("<StructureNotesEdit />", () => {
     jest.clearAllMocks();
     dynamicFormOnChange = undefined;
     dynamicFormContent = undefined;
+    dynamicFormOriginalContent = undefined;
+  });
+
+  describe("date restrictions when editing", () => {
+    const template = {
+      id: 2,
+      content: [
+        {
+          name: "dates",
+          fields: [
+            {
+              name: "fecha",
+              type: "date",
+              restrictions: { resolved: { min: null, max: "2026-10-15" } },
+            },
+            { name: "description", type: "string" },
+          ],
+        },
+      ],
+    };
+    const latestDfContent = {
+      fecha: { value: "2026-10-16", origin: "user" },
+      description: { value: "Original", origin: "user" },
+    };
+    const props = {
+      structure: { id: 1, domain_ids: [1] },
+      template,
+      applyTemplate: applyTemplate(template),
+      latestDfContent,
+      selectTemplate: jest.fn(),
+      selectDomains: jest.fn(),
+      doStructureNoteAction: jest.fn(),
+      structureNotes: { structureNotes: [] },
+    };
+
+    it("keeps Save enabled for an unchanged out-of-range date", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      expect(await rendered.findByText(/save/i)).toBeEnabled();
+    });
+
+    it("passes persisted originals to the widgets", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      expect(dynamicFormOriginalContent).toEqual(latestDfContent);
+    });
+
+    it("keeps Save enabled when only another field is edited", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      await act(async () => {
+        dynamicFormOnChange({
+          ...latestDfContent,
+          description: { value: "Updated", origin: "user" },
+        });
+      });
+
+      expect(await rendered.findByText(/save/i)).toBeEnabled();
+    });
+
+    it("disables Save when the date changes to another invalid value", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      await act(async () => {
+        dynamicFormOnChange({
+          ...latestDfContent,
+          fecha: { value: "2026-10-17", origin: "user" },
+        });
+      });
+
+      expect(await rendered.findByText(/save/i)).toBeDisabled();
+    });
+
+    it("restores the exemption when the original date is restored", async () => {
+      const rendered = render(<StructureNotesEdit {...props} />);
+      await waitForLoad(rendered);
+
+      await act(async () => {
+        dynamicFormOnChange({
+          ...latestDfContent,
+          fecha: { value: "2026-10-17", origin: "user" },
+        });
+      });
+      await act(async () => dynamicFormOnChange({ ...latestDfContent }));
+
+      expect(await rendered.findByText(/save/i)).toBeEnabled();
+    });
+
+    it("still validates dates on creation", async () => {
+      const rendered = render(
+        <StructureNotesEdit {...props} latestDfContent={{}} />,
+      );
+      await waitForLoad(rendered);
+
+      await act(async () => dynamicFormOnChange(latestDfContent));
+
+      expect(await rendered.findByText(/save/i)).toBeDisabled();
+    });
   });
 
   it("matches the latest snapshot", async () => {

package/src/components/__tests__/SystemForm.dateRestrictions.spec.js

@@ -0,0 +1,102 @@
+import { act } from "@testing-library/react";
+import { render, waitForLoad } from "@truedat/test/render";
+import DynamicForm from "@truedat/df/components/DynamicForm";
+import { SystemForm } from "../SystemForm";
+
+jest.mock("@truedat/df/components/DynamicForm", () => jest.fn(() => null));
+jest.mock("@truedat/df/templates/components/TemplateLoader", () => () => null);
+
+const content = { date: { value: "2025-01-01", origin: "user" } };
+const template = {
+  name: "system",
+  content: [
+    {
+      name: "dates",
+      fields: [
+        {
+          name: "date",
+          type: "date",
+          cardinality: "?",
+          restrictions: { max_date: { mode: "static", value: "2024-01-01" } },
+        },
+      ],
+    },
+  ],
+};
+const system = {
+  id: 1,
+  name: "System",
+  external_id: "system",
+  dynamic_content: content,
+};
+const formProps = () => DynamicForm.mock.calls.at(-1)[0];
+
+describe("<SystemForm /> date restrictions", () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it("passes persisted content to the dynamic form", async () => {
+    const rendered = render(
+      <SystemForm
+        system={system}
+        template={template}
+        createSystem={jest.fn()}
+      />,
+    );
+    await waitForLoad(rendered);
+    expect(formProps().originalContent).toEqual(content);
+  });
+
+  it("allows unchanged persisted dates outside the current range", async () => {
+    const rendered = render(
+      <SystemForm
+        system={system}
+        template={template}
+        createSystem={jest.fn()}
+      />,
+    );
+    await waitForLoad(rendered);
+    expect(
+      rendered.getByRole("button", { name: "actions.update" }),
+    ).toBeEnabled();
+  });
+
+  it("rejects changed dates outside the current range", async () => {
+    const rendered = render(
+      <SystemForm
+        system={system}
+        template={template}
+        createSystem={jest.fn()}
+      />,
+    );
+    await waitForLoad(rendered);
+    act(() =>
+      formProps().onChange({ date: { value: "2025-02-01", origin: "user" } }),
+    );
+    expect(
+      rendered.getByRole("button", { name: "actions.update" }),
+    ).toBeDisabled();
+  });
+
+  it("keeps the edit baseline after content changes", async () => {
+    const rendered = render(
+      <SystemForm
+        system={system}
+        template={template}
+        createSystem={jest.fn()}
+      />,
+    );
+    await waitForLoad(rendered);
+    act(() =>
+      formProps().onChange({ date: { value: "2023-01-01", origin: "user" } }),
+    );
+    expect(formProps().originalContent).toEqual(content);
+  });
+
+  it("does not supply an original for creation", async () => {
+    const rendered = render(
+      <SystemForm template={template} createSystem={jest.fn()} />,
+    );
+    await waitForLoad(rendered);
+    expect(formProps().originalContent).toBeUndefined();
+  });
+});