@databiosphere/findable-ui 50.5.0 → 50.6.1

package/tests/rowSelectionValidation.test.ts

@@ -1,282 +0,0 @@
-import { jest } from "@jest/globals";
-import {
-  createColumnHelper,
-  getCoreRowModel,
-  Row,
-  Table,
-  TableOptions,
-  useReactTable,
-} from "@tanstack/react-table";
-import { renderHook, RenderHookResult } from "@testing-library/react";
-import { ROW_SELECTION_VALIDATION } from "../src/components/Table/features/RowSelectionValidation/constants";
-import { RowSelectionValidationOptions } from "../src/components/Table/features/RowSelectionValidation/types";
-import { getSelectionValidation } from "../src/components/Table/features/RowSelectionValidation/utils";
-
-type ValidationFn = NonNullable<
-  RowSelectionValidationOptions<RowData>["getRowSelectionValidation"]
->;
-
-interface RowData {
-  id: number;
-  isValid: boolean;
-  name: string;
-  status: "active" | "inactive";
-}
-
-const ACCESSOR_KEY: Record<string, keyof RowData> = {
-  ID: "id",
-  IS_VALID: "isValid",
-  NAME: "name",
-  STATUS: "status",
-};
-
-// Mock data.
-const DATA: RowData[] = [
-  { id: 1, isValid: true, name: "Item 1", status: "active" },
-  { id: 2, isValid: false, name: "Item 2", status: "inactive" },
-  { id: 3, isValid: true, name: "Item 3", status: "active" },
-  { id: 4, isValid: false, name: "Item 4", status: "inactive" },
-];
-
-const columnHelper = createColumnHelper<RowData>();
-
-// Mock column definitions.
-const COLUMNS = [
-  columnHelper.accessor(ACCESSOR_KEY.ID, { header: "ID" }),
-  columnHelper.accessor(ACCESSOR_KEY.NAME, { header: "Name" }),
-  columnHelper.accessor(ACCESSOR_KEY.IS_VALID, { header: "Valid" }),
-  columnHelper.accessor(ACCESSOR_KEY.STATUS, { header: "Status" }),
-];
-
-// Test constants.
-const VALIDATION_MESSAGE = {
-  INVALID: "This item is invalid",
-  VALID: "This item is valid",
-};
-
-const createTable = (
-  tableOptions?: Omit<
-    TableOptions<RowData>,
-    "columns" | "data" | "getCoreRowModel"
-  >,
-): RenderHookResult<Table<RowData>, unknown> => {
-  return renderHook(() =>
-    useReactTable({
-      _features: [ROW_SELECTION_VALIDATION],
-      columns: COLUMNS,
-      data: DATA,
-      enableRowSelectionValidation: true,
-      getCoreRowModel: getCoreRowModel(),
-      ...tableOptions,
-    }),
-  );
-};
-
-describe("RowSelectionValidation Feature", () => {
-  let tableWithoutValidation: any;
-  let firstRowWithoutValidation: any;
-  let tableWithValidation: any;
-  let firstRowWithValidation: any;
-
-  beforeEach(() => {
-    const resultWithoutValidation = createTable();
-    const resultWithValidation = createTable({
-      getRowSelectionValidation: () => VALIDATION_MESSAGE.INVALID,
-    });
-    tableWithoutValidation = resultWithoutValidation.result.current;
-    firstRowWithoutValidation = tableWithoutValidation.getRowModel().rows[0];
-    tableWithValidation = resultWithValidation.result.current;
-    firstRowWithValidation = tableWithValidation.getRowModel().rows[0];
-  });
-
-  describe("ROW_SELECTION_VALIDATION TableFeature", () => {
-    test("should have correct structure", () => {
-      expect(ROW_SELECTION_VALIDATION).toHaveProperty("createRow");
-      expect(ROW_SELECTION_VALIDATION).toHaveProperty("getDefaultOptions");
-      expect(typeof ROW_SELECTION_VALIDATION.createRow).toBe("function");
-      expect(typeof ROW_SELECTION_VALIDATION.getDefaultOptions).toBe(
-        "function",
-      );
-    });
-
-    test("getDefaultOptions should return correct default options", () => {
-      const { getDefaultOptions } = ROW_SELECTION_VALIDATION;
-      expect(getDefaultOptions!(tableWithoutValidation)).toEqual({
-        enableRowSelectionValidation: false,
-        getRowSelectionValidation: undefined,
-      });
-    });
-  });
-
-  describe("getSelectionValidation utility", () => {
-    test("should return undefined when no validation function is provided", () => {
-      expect(
-        getSelectionValidation(
-          firstRowWithoutValidation,
-          tableWithoutValidation,
-        ),
-      ).toBeUndefined();
-    });
-
-    test("should return validation message when validation function is provided", () => {
-      expect(
-        getSelectionValidation(firstRowWithValidation, tableWithValidation),
-      ).toBe(VALIDATION_MESSAGE.INVALID);
-    });
-
-    test("should return undefined when validation function returns undefined", () => {
-      const getRowSelectionValidation = jest
-        .fn<ValidationFn>()
-        .mockReturnValue(undefined);
-
-      const { result } = createTable({ getRowSelectionValidation });
-
-      const table = result.current;
-      const firstRow = table.getRowModel().rows[0];
-
-      const validationResult = getSelectionValidation(firstRow, table);
-
-      expect(validationResult).toBeUndefined();
-      expect(getRowSelectionValidation).toHaveBeenCalledWith(firstRow);
-    });
-
-    test("should work with different rows from the same table", () => {
-      const getRowSelectionValidation = jest
-        .fn<ValidationFn>()
-        .mockImplementation((row) => {
-          const status = row.getValue(ACCESSOR_KEY.STATUS);
-          return status === "inactive" ? VALIDATION_MESSAGE.INVALID : undefined;
-        });
-
-      const { result } = createTable({ getRowSelectionValidation });
-
-      const table = result.current;
-      const rows = table.getRowModel().rows;
-
-      expect(getSelectionValidation(rows[0], table)).toBeUndefined();
-      expect(getSelectionValidation(rows[2], table)).toBeUndefined();
-      expect(getSelectionValidation(rows[1], table)).toBe(
-        VALIDATION_MESSAGE.INVALID,
-      );
-      expect(getRowSelectionValidation).toHaveBeenCalledTimes(3);
-    });
-  });
-
-  describe("row.getSelectionValidation method", () => {
-    test("should be attached to rows when feature is included", () => {
-      const rows = tableWithoutValidation.getRowModel().rows;
-
-      rows.forEach((row: any) => {
-        expect(row).toHaveProperty("getSelectionValidation");
-        expect(typeof row.getSelectionValidation).toBe("function");
-      });
-    });
-
-    test("should return undefined when no validation function is configured", () => {
-      expect(
-        firstRowWithoutValidation.getSelectionValidation(),
-      ).toBeUndefined();
-    });
-
-    test("should return validation message when validation function is configured", () => {
-      expect(firstRowWithValidation.getSelectionValidation()).toBe(
-        VALIDATION_MESSAGE.INVALID,
-      );
-    });
-  });
-
-  describe("Integration with table options", () => {
-    test("should work with getRowSelectionValidation function", () => {
-      const enableRowSelection = jest
-        .fn<(row: Row<RowData>) => boolean>()
-        .mockImplementation((row) => row.getValue(ACCESSOR_KEY.IS_VALID));
-
-      const getRowSelectionValidation = jest
-        .fn<ValidationFn>()
-        .mockImplementation((row) => {
-          const isValid = row.getValue(ACCESSOR_KEY.IS_VALID);
-          return isValid ? undefined : VALIDATION_MESSAGE.INVALID;
-        });
-
-      const { result } = createTable({
-        enableRowSelection,
-        getRowSelectionValidation,
-      });
-
-      const table = result.current;
-      const rows = table.getRowModel().rows;
-
-      rows.forEach((row) => {
-        const isValid = row.getValue(ACCESSOR_KEY.IS_VALID);
-        const canSelect = row.getCanSelect();
-        const validationMessage = row.getSelectionValidation?.();
-
-        if (isValid) {
-          expect(canSelect).toBe(true);
-          expect(validationMessage).toBeUndefined();
-        } else {
-          expect(canSelect).toBe(false);
-          expect(validationMessage).toBe(VALIDATION_MESSAGE.INVALID);
-        }
-      });
-    });
-
-    test("should handle complex validation scenarios", () => {
-      const getRowSelectionValidation = jest
-        .fn<ValidationFn>()
-        .mockImplementation((row) => {
-          const id = row.getValue(ACCESSOR_KEY.ID);
-          const isValid = row.getValue(ACCESSOR_KEY.IS_VALID);
-
-          if (!isValid) return VALIDATION_MESSAGE.INVALID;
-          if (id === 1) return VALIDATION_MESSAGE.VALID;
-          return undefined;
-        });
-
-      const { result } = createTable({ getRowSelectionValidation });
-
-      const table = result.current;
-      const rows = table.getRowModel().rows;
-
-      expect(rows[0].getSelectionValidation?.()).toBe(VALIDATION_MESSAGE.VALID);
-      expect(rows[1].getSelectionValidation?.()).toBe(
-        VALIDATION_MESSAGE.INVALID,
-      );
-      expect(rows[2].getSelectionValidation?.()).toBeUndefined();
-      expect(rows[3].getSelectionValidation?.()).toBe(
-        VALIDATION_MESSAGE.INVALID,
-      );
-    });
-  });
-
-  describe("Edge cases", () => {
-    test("should work when feature is not included", () => {
-      const { result } = createTable({
-        _features: [],
-        enableRowSelectionValidation: false,
-      });
-
-      const table = result.current;
-      const firstRow = table.getRowModel().rows[0];
-
-      expect(firstRow).not.toHaveProperty("getSelectionValidation");
-    });
-
-    test("should return undefined when feature is disabled", () => {
-      const getRowSelectionValidation = jest
-        .fn<ValidationFn>()
-        .mockReturnValue(VALIDATION_MESSAGE.INVALID);
-
-      const { result } = createTable({
-        enableRowSelectionValidation: false,
-        getRowSelectionValidation,
-      });
-
-      const table = result.current;
-      const firstRow = table.getRowModel().rows[0];
-
-      expect(firstRow.getSelectionValidation?.()).toBeUndefined();
-      expect(getRowSelectionValidation).not.toHaveBeenCalled();
-    });
-  });
-});

package/tests/setup.ts

@@ -1,19 +0,0 @@
-import { jest } from "@jest/globals";
-import { setProjectAnnotations } from "@storybook/react";
-import { TextDecoder, TextEncoder } from "util";
-import { decorators } from "../src/storybook/decorators";
-import { parameters } from "../src/storybook/parameters";
-
-// Set project annotations once before all tests
-setProjectAnnotations({ decorators, parameters });
-
-// Polyfill ResizeObserver for environments (like Jest) where it's not globally available
-global.ResizeObserver = jest.fn().mockImplementation(() => ({
-  disconnect: jest.fn(),
-  observe: jest.fn(),
-  unobserve: jest.fn(),
-})) as unknown as typeof ResizeObserver;
-
-// Polyfill TextEncoder/TextDecoder for environments (like Jest) where they're not globally available
-global.TextEncoder = global.TextEncoder || TextEncoder;
-global.TextDecoder = global.TextDecoder || TextDecoder;

package/tests/stepIcon.test.tsx

@@ -1,42 +0,0 @@
-import { composeStories } from "@storybook/react";
-import { render, screen } from "@testing-library/react";
-import React from "react";
-import { STEP_ICON_TEST_ID } from "../src/components/Stepper/components/Step/components/StepIcon/constants";
-import * as stories from "../src/components/Stepper/components/Step/components/StepIcon/stories/stepIcon.stories";
-import { MUI_CLASSES } from "../src/tests/mui/constants";
-import { getClassNames, getTagName } from "../src/utils/tests";
-
-const { Active, Completed, Default } = composeStories(stories);
-
-describe("StepIcon", () => {
-  it("renders correctly", () => {
-    render(<Default testId={STEP_ICON_TEST_ID} />);
-    const stepIconEl = screen.getByTestId(STEP_ICON_TEST_ID);
-    expect(stepIconEl).not.toBeNull();
-  });
-
-  it("renders inactive step icon", () => {
-    render(<Default testId={STEP_ICON_TEST_ID} />);
-    const stepIconEl = screen.getByTestId(STEP_ICON_TEST_ID);
-    expect(stepIconEl.textContent).toEqual("1");
-    expect(getClassNames(stepIconEl)).not.toContain(MUI_CLASSES.ACTIVE);
-    expect(getClassNames(stepIconEl)).not.toContain(MUI_CLASSES.COMPLETED);
-  });
-
-  it("renders active step icon", () => {
-    render(<Active testId={STEP_ICON_TEST_ID} />);
-    const stepIconEl = screen.getByTestId(STEP_ICON_TEST_ID);
-    expect(stepIconEl.textContent).toEqual("1");
-    expect(getClassNames(stepIconEl)).toContain(MUI_CLASSES.ACTIVE);
-    expect(getClassNames(stepIconEl)).not.toContain(MUI_CLASSES.COMPLETED);
-  });
-
-  it("renders completed step icon", () => {
-    render(<Completed testId={STEP_ICON_TEST_ID} />);
-    const stepIconEl = screen.getByTestId(STEP_ICON_TEST_ID);
-    expect(stepIconEl.textContent).not.toEqual("1");
-    expect(getClassNames(stepIconEl)).not.toContain(MUI_CLASSES.ACTIVE);
-    expect(getClassNames(stepIconEl)).toContain(MUI_CLASSES.COMPLETED);
-    expect(getTagName(stepIconEl.firstElementChild)).toBe("path");
-  });
-});

package/tests/tableFilter.test.tsx

@@ -1,90 +0,0 @@
-import { composeStories } from "@storybook/react";
-import { render } from "@testing-library/react";
-import React from "react";
-import * as filterStories from "../src/components/Detail/components/Table/stories/filter/filter.stories";
-
-const COLUMN_INDEX = {
-  ARRAY: 1,
-  NUMBER: 3,
-  STRING: 0,
-};
-
-const {
-  FilterByArrayValue,
-  FilterByRangeBetweenValue,
-  FilterByRangeGreaterThanValue,
-  FilterByRangeLessThanValue,
-  FilterByStringValue,
-  FilterByStringValueWithNoMatch,
-} = composeStories(filterStories);
-
-describe("Table - Filtering", () => {
-  describe("Table filter stories", () => {
-    test("FilterByStringValueWithNoMatch shows no rows", () => {
-      const { container } = render(<FilterByStringValueWithNoMatch />);
-      const rows = container.querySelectorAll("tbody tr");
-      expect(rows).toHaveLength(0);
-    });
-
-    test("FilterByStringValue shows rows matching the filters of string values", () => {
-      const { container } = render(<FilterByStringValue />);
-      const rows = container.querySelectorAll("tbody tr");
-      expect(rows).toHaveLength(2);
-      rows.forEach((row) => {
-        const cell = row.querySelectorAll("td")[COLUMN_INDEX.STRING];
-        const text = cell.textContent;
-        expect(text).toMatch(
-          /Coronary Artery Disease Study|Myocardial Infarction Study/,
-        );
-        expect(text).not.toMatch(/Myocardial Infarction Study X/);
-      });
-    });
-
-    test("FilterByArrayValue shows rows matching the filters of array values", () => {
-      const { container } = render(<FilterByArrayValue />);
-      const rows = container.querySelectorAll("tbody tr");
-      expect(rows).toHaveLength(4);
-      rows.forEach((row) => {
-        const cell = row.querySelectorAll("td")[COLUMN_INDEX.ARRAY];
-        const text = cell.textContent;
-        expect(text).toMatch(/Exome|RNAseq/);
-        // Confirm that the text "Whole Genome" is not present in any row cell as a single value.
-        expect(text).not.toMatch(/^Whole Genome$/);
-      });
-    });
-
-    test("FilterByRangeBetweenValue shows rows matching filters between two number values", () => {
-      const { container } = render(<FilterByRangeBetweenValue />);
-      const rows = container.querySelectorAll("tbody tr");
-      expect(rows).toHaveLength(2);
-      rows.forEach((row) => {
-        const cell = row.querySelectorAll("td")[COLUMN_INDEX.NUMBER];
-        const value = Number(cell.textContent);
-        expect(value).toBeGreaterThanOrEqual(10);
-        expect(value).toBeLessThanOrEqual(100);
-      });
-    });
-
-    test("FilterByRangeGreaterThanValue shows rows matching filters greater than a number value", () => {
-      const { container } = render(<FilterByRangeGreaterThanValue />);
-      const rows = container.querySelectorAll("tbody tr");
-      expect(rows).toHaveLength(4);
-      rows.forEach((row) => {
-        const cell = row.querySelectorAll("td")[COLUMN_INDEX.NUMBER];
-        const value = Number(cell.textContent);
-        expect(value).toBeGreaterThanOrEqual(100);
-      });
-    });
-
-    test("FilterByRangeLessThanValue shows rows matching filters less than a number value", () => {
-      const { container } = render(<FilterByRangeLessThanValue />);
-      const rows = container.querySelectorAll("tbody tr");
-      expect(rows).toHaveLength(3);
-      rows.forEach((row) => {
-        const cell = row.querySelectorAll("td")[COLUMN_INDEX.NUMBER];
-        const value = Number(cell.textContent);
-        expect(value).toBeLessThanOrEqual(100);
-      });
-    });
-  });
-});

package/tests/terraProfileProvider.test.tsx

@@ -1,117 +0,0 @@
-import { jest } from "@jest/globals";
-import { render } from "@testing-library/react";
-import React from "react";
-import { DEFAULT_AUTHENTICATION_STATE } from "../src/providers/authentication/authentication/constants";
-import { authenticationComplete } from "../src/providers/authentication/authentication/dispatch";
-import { DEFAULT_CREDENTIALS_STATE } from "../src/providers/authentication/credentials/constants";
-import { updateCredentials } from "../src/providers/authentication/credentials/dispatch";
-
-const TOKEN = "test-token";
-
-const PROFILE_PENDING = {
-  isComplete: false,
-  isProfileActive: false,
-};
-
-const PROFILE_SETTLED_ACTIVE = {
-  isComplete: true,
-  isProfileActive: true,
-};
-
-const PROFILE_SETTLED_INACTIVE = {
-  isComplete: true,
-  isProfileActive: false,
-};
-
-jest.unstable_mockModule(
-  "../src/providers/authentication/authentication/hook",
-  () => ({
-    useAuthentication: jest.fn(),
-  }),
-);
-jest.unstable_mockModule(
-  "../src/providers/authentication/credentials/hook",
-  () => ({
-    useCredentials: jest.fn(),
-  }),
-);
-jest.unstable_mockModule(
-  "../src/providers/authentication/terra/hooks/useFetchProfiles",
-  () => ({
-    useFetchProfiles: jest.fn(),
-  }),
-);
-
-const { useAuthentication } =
-  await import("../src/providers/authentication/authentication/hook");
-const { useCredentials } =
-  await import("../src/providers/authentication/credentials/hook");
-const { useFetchProfiles } =
-  await import("../src/providers/authentication/terra/hooks/useFetchProfiles");
-const { TerraProfileProvider } =
-  await import("../src/providers/authentication/terra/provider");
-
-const MOCK_AUTHENTICATION_DISPATCH = jest.fn();
-const MOCK_CREDENTIALS_DISPATCH = jest.fn();
-const MOCK_USE_AUTHENTICATION = useAuthentication as jest.MockedFunction<
-  typeof useAuthentication
->;
-const MOCK_USE_CREDENTIALS = useCredentials as jest.MockedFunction<
-  typeof useCredentials
->;
-const MOCK_USE_FETCH_PROFILES = useFetchProfiles as jest.MockedFunction<
-  () => Partial<ReturnType<typeof useFetchProfiles>>
->;
-
-describe("TerraProfileProvider", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    MOCK_USE_AUTHENTICATION.mockReturnValue({
-      authenticationDispatch: MOCK_AUTHENTICATION_DISPATCH,
-      authenticationState: DEFAULT_AUTHENTICATION_STATE,
-    });
-    MOCK_USE_CREDENTIALS.mockReturnValue({
-      credentialsDispatch: MOCK_CREDENTIALS_DISPATCH,
-      credentialsState: DEFAULT_CREDENTIALS_STATE,
-    });
-    MOCK_USE_FETCH_PROFILES.mockReturnValue(PROFILE_PENDING);
-  });
-
-  it("does not dispatch actions when terra profile is incomplete", () => {
-    render(
-      <TerraProfileProvider token={TOKEN}>
-        <div>Child Component</div>
-      </TerraProfileProvider>,
-    );
-    expect(MOCK_AUTHENTICATION_DISPATCH).not.toHaveBeenCalled();
-    expect(MOCK_CREDENTIALS_DISPATCH).not.toHaveBeenCalled();
-  });
-
-  it("calls authenticationComplete dispatch when terra profile is SETTLED and INACTIVE", () => {
-    MOCK_USE_FETCH_PROFILES.mockReturnValue(PROFILE_SETTLED_INACTIVE);
-    render(
-      <TerraProfileProvider token={TOKEN}>
-        <div>Child Component</div>
-      </TerraProfileProvider>,
-    );
-    expect(MOCK_AUTHENTICATION_DISPATCH).toHaveBeenCalledWith(
-      authenticationComplete(),
-    );
-    expect(MOCK_CREDENTIALS_DISPATCH).not.toHaveBeenCalled();
-  });
-
-  it("dispatches authenticationComplete and updateCredentials when terra profile is SETTLED and ACTIVE", () => {
-    MOCK_USE_FETCH_PROFILES.mockReturnValue(PROFILE_SETTLED_ACTIVE);
-    render(
-      <TerraProfileProvider token={TOKEN}>
-        <div>Child Component</div>
-      </TerraProfileProvider>,
-    );
-    expect(MOCK_AUTHENTICATION_DISPATCH).toHaveBeenCalledWith(
-      authenticationComplete(),
-    );
-    expect(MOCK_CREDENTIALS_DISPATCH).toHaveBeenCalledWith(
-      updateCredentials(TOKEN),
-    );
-  });
-});