@truedat/bg 7.10.3 → 7.11.0

package/src/concepts/relations/components/ConceptSelector.js

@@ -1,14 +1,7 @@
 import _ from "lodash/fp";
 import PropTypes from "prop-types";
 import { connect } from "react-redux";
-import {
-  Button,
-  Table,
-  Message,
-  Label,
-  Icon,
-  Segment,
-} from "semantic-ui-react";
+import { Button, Table, Message, Label, Segment } from "semantic-ui-react";
 import { FormattedMessage, useIntl } from "react-intl";
 import SearchWidget from "@truedat/core/search/SearchWidget";
 import {
@@ -44,6 +37,7 @@ const ConceptSelectorRow = ({
   onClick,
   disabled,
   positive,
+  extraColumns = [],
 }) => {
   const { name, status, domain } = concept;
   return (
@@ -65,6 +59,12 @@ const ConceptSelectorRow = ({
           </Label>
         }
       />
+      {extraColumns.map((column, key) => (
+        <Table.Cell
+          key={key}
+          content={column.fieldDecorator(column.fieldSelector(concept))}
+        />
+      ))}
     </Table.Row>
   );
 };
@@ -77,20 +77,14 @@ ConceptSelectorRow.propTypes = {
   positive: PropTypes.bool,
 };
 
-export function ConceptSelectorContent({
+export const ConceptSelectorTable = ({
   businessConceptId,
-  handleConceptSelected,
+  concepts,
   selectedConcept,
-  showTitle = true,
+  handleConceptSelected,
   links,
-}) {
-  const { searchData, filterParams: searchParams } = useSearchContext();
-  const { trigger: triggerDownload, isMutating: downloading } =
-    useConceptLinksDownload();
-  const { formatMessage } = useIntl();
-  const concepts = searchData?.data;
-  const conceptsActions = _.propOr({}, "_actions")(searchData);
-
+  extraColumns = [],
+}) => {
   const selectedConceptIsFiltered = !_.reduce(
     (acc, c) => (selectedConcept && c.id == selectedConcept.id) || acc,
     false
@@ -104,7 +98,85 @@ export function ConceptSelectorContent({
         )(concept)
       : false;
   };
- 
+
+  return !_.isEmpty(concepts) || selectedConcept ? (
+    <Table selectable size="small">
+      <Table.Header>
+        <Table.Row>
+          <Table.HeaderCell
+            content={<FormattedMessage id="concepts.props.name" />}
+          />
+          <Table.HeaderCell
+            content={<FormattedMessage id="concepts.props.domain" />}
+          />
+          <Table.HeaderCell
+            content={<FormattedMessage id="concepts.props.status" />}
+          />
+          {extraColumns.map((column, key) => (
+            <Table.HeaderCell
+              key={key}
+              content={
+                <FormattedMessage id={`concepts.props.${column.name}`} />
+              }
+            />
+          ))}
+        </Table.Row>
+      </Table.Header>
+      <Table.Body>
+        {concepts.map((s, i) => (
+          <ConceptSelectorRow
+            disabled={
+              businessConceptId == s.business_concept_id || isDisabled(s)
+            }
+            key={i}
+            concept={s}
+            active={selectedConcept && selectedConcept.id == s.id}
+            onClick={handleConceptSelected}
+            positive={isPositive(
+              links,
+              s.business_concept_id,
+              businessConceptId
+            )}
+            extraColumns={extraColumns}
+          />
+        ))}
+        {selectedConcept && selectedConceptIsFiltered && (
+          <ConceptSelectorRow
+            concept={selectedConcept}
+            extraColumns={extraColumns}
+            active
+          />
+        )}
+      </Table.Body>
+    </Table>
+  ) : (
+    <Message header={<FormattedMessage id="concepts.search.results.empty" />} />
+  );
+};
+
+ConceptSelectorTable.propTypes = {
+  businessConceptId: PropTypes.number,
+  concepts: PropTypes.array,
+  selectedConcept: PropTypes.object,
+  handleConceptSelected: PropTypes.func,
+  links: PropTypes.array,
+  extraColumns: PropTypes.array,
+};
+
+export function ConceptSelectorContent({
+  businessConceptId,
+  handleConceptSelected,
+  selectedConcept,
+  showTitle = true,
+  links,
+}) {
+  const { formatMessage } = useIntl();
+  const { searchData, filterParams: searchParams } = useSearchContext();
+  const { trigger: triggerDownload, isMutating: downloading } =
+    useConceptLinksDownload();
+  const concepts = searchData?.data;
+  const conceptsActions = _.propOr({}, "_actions")(searchData);
+
   return (
     <>
       {showTitle && (
@@ -113,64 +185,34 @@ export function ConceptSelectorContent({
         </label>
       )}
       <Segment>
-        {conceptsActions?.downloadLinks && ( 
-         <>
-          <Button
-            icon="download"
-            floated="right"
-            secondary
-            loading={downloading}
-            onClick={() => triggerDownload(searchParams)}
-            data-tooltip={formatMessage({
-              id: "concepts.actions.downloadLinks.tooltip",
-            })}
-          />        
+        {conceptsActions?.downloadLinks && (
+          <>
+            <Button
+              icon="download"
+              floated="right"
+              secondary
+              loading={downloading}
+              onClick={() => triggerDownload(searchParams)}
+              data-tooltip={formatMessage({
+                id: "concepts.actions.downloadLinks.tooltip",
+              })}
+            />
             <ConceptLinksUploadButton />
-         </>
+          </>
         )}
         <SearchWidget />
-        {!_.isEmpty(concepts) || selectedConcept ? (
-          <Table selectable size="small">
-            <Table.Header>
-              <Table.Row>
-                <Table.HeaderCell
-                  content={<FormattedMessage id="concepts.props.name" />}
-                />
-                <Table.HeaderCell
-                  content={<FormattedMessage id="concepts.props.domain" />}
-                />
-                <Table.HeaderCell
-                  content={<FormattedMessage id="concepts.props.status" />}
-                />
-              </Table.Row>
-            </Table.Header>
-            <Table.Body>
-              {concepts.map((s, i) => (
-                <ConceptSelectorRow
-                  disabled={
-                    businessConceptId == s.business_concept_id || isDisabled(s)
-                  }
-                  key={i}
-                  concept={s}
-                  active={selectedConcept && selectedConcept.id == s.id}
-                  onClick={handleConceptSelected}
-                  positive={isPositive(
-                    links,
-                    s.business_concept_id,
-                    businessConceptId
-                  )}
-                />
-              ))}
-              {selectedConcept && selectedConceptIsFiltered && (
-                <ConceptSelectorRow concept={selectedConcept} active />
-              )}
-            </Table.Body>
-          </Table>
-        ) : (
-          <Message
-            header={<FormattedMessage id="concepts.search.results.empty" />}
-          />
-        )}
+        <ConceptSelectorTable
+          concepts={concepts}
+          showTitle={showTitle}
+          downloading={downloading}
+          selectedConcept={selectedConcept}
+          handleConceptSelected={handleConceptSelected}
+          links={links}
+          businessConceptId={businessConceptId}
+          triggerDownload={triggerDownload}
+          downloadLinks={conceptsActions?.downloadLinks}
+          searchParams={searchParams}
+        />
         <ConceptsPagination size="small" />
       </Segment>
     </>

package/src/concepts/relations/components/__tests__/ConceptLinksApprovalResults.spec.js

@@ -0,0 +1,123 @@
+import { render, waitForLoad } from "@truedat/test/render";
+import LinksApprovalResults from "../ConceptLinksApprovalResults";
+import { useLocation } from "react-router";
+
+jest.mock("react-router", () => {
+  const actual = jest.requireActual("react-router");
+  return {
+    ...actual,
+    useLocation: jest.fn(),
+  };
+});
+
+const mockFormatMessage = jest.fn(({ id }) => id);
+jest.mock("react-intl", () => ({
+  ...jest.requireActual("react-intl"),
+  useIntl: () => ({
+    formatMessage: mockFormatMessage,
+  }),
+}));
+
+describe("<LinksApprovalResults />", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("renders approval results with relations and errors", async () => {
+    useLocation.mockReturnValue({
+      state: {
+        status: "approved",
+        relations: [
+          {
+            id: 1,
+            source_id: 10,
+            source_name: "Source 1",
+            target_id: 20,
+            target_name: "Target 1",
+          },
+        ],
+        errors: {
+          permissions: {
+            message: "forbidden",
+            reason: "permissions",
+            relations: [
+              {
+                id: 2,
+                source_id: 11,
+                source_name: "Source 2",
+                target_id: 21,
+                target_name: "Target 2",
+              },
+            ],
+          },
+        },
+      },
+    });
+
+    const rendered = render(<LinksApprovalResults />);
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders rejection results", async () => {
+    useLocation.mockReturnValue({
+      state: {
+        status: "rejected",
+        relations: [
+          {
+            id: 3,
+            source_id: 12,
+            source_name: "Source 3",
+            target_id: 22,
+            target_name: "Target 3",
+          },
+        ],
+        errors: {},
+      },
+    });
+
+    const rendered = render(<LinksApprovalResults />);
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders with no errors", async () => {
+    useLocation.mockReturnValue({
+      state: {
+        status: "approved",
+        relations: [
+          {
+            id: 4,
+            source_id: 13,
+            source_name: "Source 4",
+            target_id: 23,
+            target_name: "Target 4",
+          },
+        ],
+        errors: {},
+      },
+    });
+
+    const rendered = render(<LinksApprovalResults />);
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders with empty relations and errors", async () => {
+    useLocation.mockReturnValue({
+      state: {
+        status: "approved",
+        relations: [],
+        errors: {},
+      },
+    });
+
+    const rendered = render(<LinksApprovalResults />);
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toMatchSnapshot();
+  });
+});

package/src/concepts/relations/components/__tests__/ConceptLinksApprovals.spec.js

@@ -0,0 +1,77 @@
+import { render, waitForLoad } from "@truedat/test/render";
+import { useSearchContext } from "@truedat/core/search/SearchContext";
+import { ConceptLinksApprovals } from "../ConceptLinksApprovals";
+
+jest.mock("@truedat/core/search/SearchContext", () => {
+  const originalModule = jest.requireActual(
+    "@truedat/core/search/SearchContext"
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useSearchContext: jest.fn(),
+  };
+});
+
+describe("<ConceptLinksApprovals />", () => {
+  it("matches the latest snapshot", async () => {
+    useSearchContext.mockReturnValue({
+      searchData: {
+        data: [
+          {
+            domain_ids: [2],
+            id: 1,
+            origin: null,
+            source_domain_ids: [2],
+            source_id: 11,
+            source_name: "Busines 11",
+            source_type: "business_concept",
+            status: "pending",
+            target_domain_ids: [2],
+            target_id: 21,
+            target_name: "Structure 21",
+            target_type: "data_structure",
+            updated_at: "2025-08-11T07:07:13.336631Z",
+          },
+          {
+            domain_ids: [2, 1],
+            id: 2,
+            origin: null,
+            source_domain_ids: [2],
+            source_id: 21,
+            source_name: "Busines 21",
+            source_type: "business_concept",
+            status: "pending",
+            target_domain_ids: [1],
+            target_id: 22,
+            target_name: "Structure 22",
+            target_type: "data_structure",
+            updated_at: "2025-08-11T07:07:13.336631Z",
+          },
+        ],
+        scroll_id: null,
+      },
+      searchMust: { status: ["pending"] },
+      setOnSearchChange: jest.fn(),
+    });
+    const rendered = render(<ConceptLinksApprovals />);
+
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("matches the latest snapshot for empty results", async () => {
+    useSearchContext.mockReturnValue({
+      searchData: [],
+      searchMust: { status: ["pending"] },
+      setOnSearchChange: jest.fn(),
+    });
+    const rendered = render(<ConceptLinksApprovals />);
+
+    await waitForLoad(rendered);
+
+    expect(rendered.container).toMatchSnapshot();
+  });
+});

package/src/concepts/relations/components/__tests__/ConceptLinksApprovalsLabelResults.spec.js

@@ -0,0 +1,47 @@
+import { render, waitForLoad } from "@truedat/test/render";
+import { useSearchContext } from "@truedat/core/search/SearchContext";
+import { ConceptLinksApprovalsLabelResults } from "../ConceptLinksApprovalsLabelResults";
+
+jest.mock("@truedat/core/search/SearchContext", () => {
+  const originalModule = jest.requireActual(
+    "@truedat/core/search/SearchContext"
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useSearchContext: jest.fn(),
+  };
+});
+
+describe("ConceptLinksApprovalsLabelResults", () => {
+  it("matches the latest snapshot", async () => {
+    useSearchContext.mockReturnValue({
+      count: 1,
+      loading: false,
+    });
+
+    const props = {
+      selectedCount: 1,
+      approveView: true,
+    };
+    const rendered = render(<ConceptLinksApprovalsLabelResults {...props} />);
+    await waitForLoad(rendered);
+    rendered.debug();
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("should not render results count when is loading", async () => {
+    useSearchContext.mockReturnValue({
+      count: 1,
+      loading: true,
+    });
+    const props = {
+      selectedCount: 1,
+      approveView: true,
+    };
+    const rendered = render(<ConceptLinksApprovalsLabelResults {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+});

package/src/concepts/relations/components/__tests__/ConceptLinksApprovalsRow.spec.js

@@ -0,0 +1,68 @@
+import { render, waitForLoad } from "@truedat/test/render";
+import { ConceptLinksApprovalsRow } from "../ConceptLinksApprovalsRow";
+
+describe("ConceptLinksApprovalsRow", () => {
+  const defaultProps = {
+    checked: false,
+    columns: [
+      {
+        key: "name",
+        textAlign: "left",
+      },
+    ],
+    onCheckboxChange: jest.fn(),
+    link: {
+      id: "123",
+      name: "Test Link",
+    },
+    approveView: false,
+  };
+
+  it("renders null when columns are empty", async () => {
+    const rendered = render(
+      <ConceptLinksApprovalsRow {...defaultProps} columns={[]} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders null when link is empty", async () => {
+    const rendered = render(
+      <ConceptLinksApprovalsRow {...defaultProps} link={{}} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders row with checkbox when approveView is true", async () => {
+    const rendered = render(
+      <ConceptLinksApprovalsRow {...defaultProps} approveView={true} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("renders row without checkbox when approveView is false", async () => {
+    const rendered = render(
+      <ConceptLinksApprovalsRow {...defaultProps} approveView={false} />
+    );
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("calls onCheckboxChange when checkbox is clicked", async () => {
+    const onCheckboxChange = jest.fn();
+    const rendered = render(
+      <ConceptLinksApprovalsRow
+        {...defaultProps}
+        approveView={true}
+        onCheckboxChange={onCheckboxChange}
+      />
+    );
+    await waitForLoad(rendered);
+
+    const checkbox = rendered.container.querySelector("input[type='checkbox']");
+    checkbox.click();
+    expect(onCheckboxChange).toHaveBeenCalled();
+  });
+});

package/src/concepts/relations/components/__tests__/ConceptLinksApprovalsTable.spec.js

@@ -0,0 +1,107 @@
+import { render, waitForLoad } from "@truedat/test/render";
+import { useSearchContext } from "@truedat/core/search/SearchContext";
+import { ConceptLinksApprovalsTable } from "../ConceptLinksApprovalsTable";
+
+jest.mock("@truedat/core/search/SearchContext", () => {
+  const originalModule = jest.requireActual(
+    "@truedat/core/search/SearchContext"
+  );
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    useSearchContext: jest.fn(),
+  };
+});
+
+describe("ConceptLinksApprovalsTable", () => {
+  const mockColumns = [
+    { name: "source_name", width: 4 },
+    { name: "target_name", width: 4 },
+    { name: "tag_type", width: 2 },
+    { name: "status", width: 2 },
+    { name: "updated_at", width: 2 },
+  ];
+
+  beforeEach(() => {
+    useSearchContext.mockReturnValue({
+      searchData: {
+        data: [
+          {
+            id: 1,
+            source_name: "Concept 1",
+            target_name: "Structure 1",
+            tag_type: "relates_to",
+            status: "pending",
+            updated_at: "2023-01-01",
+          },
+        ],
+      },
+      loading: false,
+      sortColumn: null,
+      sortDirection: null,
+      handleSortSelection: jest.fn(),
+    });
+  });
+
+  it("matches the latest snapshot with data", async () => {
+    const props = {
+      columns: mockColumns,
+      approveView: true,
+      checkedAll: false,
+      addAll: jest.fn(),
+      checkRow: jest.fn(),
+      isRowChecked: jest.fn(),
+    };
+
+    const rendered = render(<ConceptLinksApprovalsTable {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("matches the latest snapshot with empty data", async () => {
+    useSearchContext.mockReturnValue({
+      searchData: { data: [] },
+      loading: false,
+      sortColumn: null,
+      sortDirection: null,
+      handleSortSelection: jest.fn(),
+    });
+
+    const props = {
+      columns: mockColumns,
+      approveView: true,
+      checkedAll: false,
+      addAll: jest.fn(),
+      checkRow: jest.fn(),
+      isRowChecked: jest.fn(),
+    };
+
+    const rendered = render(<ConceptLinksApprovalsTable {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+
+  it("matches the latest snapshot while loading", async () => {
+    useSearchContext.mockReturnValue({
+      searchData: { data: [] },
+      loading: true,
+      sortColumn: null,
+      sortDirection: null,
+      handleSortSelection: jest.fn(),
+    });
+
+    const props = {
+      columns: mockColumns,
+      approveView: true,
+      checkedAll: false,
+      addAll: jest.fn(),
+      checkRow: jest.fn(),
+      isRowChecked: jest.fn(),
+    };
+
+    const rendered = render(<ConceptLinksApprovalsTable {...props} />);
+    await waitForLoad(rendered);
+    expect(rendered.container).toMatchSnapshot();
+  });
+});