@databiosphere/findable-ui 29.0.2 → 30.0.0

package/tests/filterRange.test.tsx

@@ -1,9 +1,12 @@
+import { jest } from "@jest/globals";
 import { composeStories } from "@storybook/react";
-import { fireEvent, render, screen } from "@testing-library/react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import React from "react";
+import { VIEW_KIND } from "../src/common/categories/views/types";
 import * as stories from "../src/components/Filter/components/FilterRange/stories/filterRange.stories";
 import { MUI_CLASSES } from "../src/tests/mui/constants";
 import { TEST_IDS } from "../src/tests/testIds";
+import { getButton, getLabelText, getText } from "../src/tests/utils";
 import { getClassNames } from "../src/utils/tests";
 
 const BETWEEN = "Between";
@@ -12,76 +15,358 @@ const LESS_THAN = "Less Than";
 
 const { Default } = composeStories(stories);
 
-describe("FilterRange", () => {
-  let filterEl: HTMLFormElement;
+const TEST_VALUES = {
+  CATEGORY_KEY: Default.args.categoryKey,
+  MAX: Default.args.max,
+  MIN: Default.args.min,
+  ON_FILTER: jest.fn(),
+  SELECTED_MAX: 226,
+  SELECTED_MIN: 112,
+  UNIT: Default.args.unit,
+};
+
+const LABEL_TEXTS = {
+  GREATER_THAN: `Greater Than (${TEST_VALUES.UNIT})`,
+  LESS_THAN: `Less Than (${TEST_VALUES.UNIT})`,
+  MAX: `Max (${TEST_VALUES.UNIT})`,
+  MIN: `Min (${TEST_VALUES.UNIT})`,
+};
+
+const HELPER_TEXTS = {
+  GREATER_THAN: `Allowed values: \u2265 ${TEST_VALUES.MIN} and \u2264 ${TEST_VALUES.MAX}`,
+  LESS_THAN: `Allowed values: \u2265 ${TEST_VALUES.MIN} and \u2264 ${TEST_VALUES.MAX}`,
+  MAX: `Max allowed: ${TEST_VALUES.MAX}`,
+  MIN: `Min allowed: ${TEST_VALUES.MIN}`,
+};
+
+const ERROR_TEXTS = {
+  MIN_MAX_ERROR: "Min must be less than max",
+  REQUIRED_ERROR: "Value is required",
+  TYPE_ERROR: "Value must be a number",
+};
+
+const DESCRIBE_TITLES = {
+  BETWEEN: "Operator BETWEEN",
+  GREATER_THAN: "Operator GREATER THAN",
+  LESS_THAN: "Operator LESS THAN",
+};
 
+/**
+ * Tests for the FilterRange component.
+ * Excludes tests for min/max values outside of allowed range; the allowed range is not currently validated.
+ */
+
+describe("FilterRange", () => {
   beforeEach(() => {
-    render(<Default />);
-    filterEl = screen.getByTestId(TEST_IDS.FILTER_RANGE);
+    jest.clearAllMocks();
   });
 
-  describe("Operator BETWEEN", () => {
-    it("renders the toggle buttons with correct text", () => {
-      expect(screen.getByRole("button", { name: BETWEEN })).toBeDefined();
-      expect(screen.getByRole("button", { name: LESS_THAN })).toBeDefined();
-      expect(screen.getByRole("button", { name: GREATER_THAN })).toBeDefined();
+  describe("UI rendering for operator modes", () => {
+    let filterEl: HTMLFormElement;
+
+    beforeEach(() => {
+      render(<Default />);
+      filterEl = screen.getByTestId(TEST_IDS.FILTER_RANGE);
+      expect(filterEl).toBeDefined();
     });
 
-    it("renders BETWEEN toggle button as selected", () => {
-      expect(
-        getClassNames(screen.getByRole("button", { name: BETWEEN }))
-      ).toContain(MUI_CLASSES.SELECTED);
+    describe(DESCRIBE_TITLES.BETWEEN, () => {
+      it("renders the toggle buttons with correct text", () => {
+        expect(getButton(BETWEEN)).toBeDefined();
+        expect(getButton(LESS_THAN)).toBeDefined();
+        expect(getButton(GREATER_THAN)).toBeDefined();
+      });
+
+      it("renders BETWEEN toggle button as selected", () => {
+        expect(getClassNames(getButton(BETWEEN))).toContain(
+          MUI_CLASSES.SELECTED
+        );
+      });
+
+      it("renders BETWEEN input fields with correct labels", () => {
+        expect(filterEl.querySelectorAll("label")).toHaveLength(2);
+        expect(filterEl.querySelectorAll("input")).toHaveLength(2);
+        expect(getLabelText(LABEL_TEXTS.MIN)).toBeDefined();
+        expect(getLabelText(LABEL_TEXTS.MAX)).toBeDefined();
+        expect(getText(LABEL_TEXTS.MIN)).toBeDefined();
+        expect(getText(LABEL_TEXTS.MAX)).toBeDefined();
+      });
+
+      it("renders helper text for each input", () => {
+        expect(getText(HELPER_TEXTS.MIN)).toBeDefined();
+        expect(getText(HELPER_TEXTS.MAX)).toBeDefined();
+      });
+
+      it("renders filter button", () => {
+        expect(getFilterButton()).toBeDefined();
+      });
     });
 
-    it("renders BETWEEN input fields with correct labels", () => {
-      expect(filterEl.querySelectorAll("label")).toHaveLength(2);
-      expect(filterEl.querySelectorAll("input")).toHaveLength(2);
-      expect(filterEl.querySelector('label[for="between"]')).toBeDefined();
-      expect(filterEl.querySelector('label[for="between-to"]')).toBeDefined();
-      expect(filterEl.querySelector('input[name="between"]')).toBeDefined();
-      expect(filterEl.querySelector('input[name="between-to"]')).toBeDefined();
+    describe(DESCRIBE_TITLES.LESS_THAN, () => {
+      beforeEach(() => {
+        fireEvent.click(getButton(LESS_THAN));
+      });
+
+      it("renders LESS THAN toggle button as selected", () => {
+        expect(getClassNames(getButton(LESS_THAN))).toContain(
+          MUI_CLASSES.SELECTED
+        );
+      });
+
+      it("renders LESS THAN input field with correct label", () => {
+        expect(filterEl.querySelectorAll("label")).toHaveLength(1);
+        expect(filterEl.querySelectorAll("input")).toHaveLength(1);
+        expect(getLabelText(LABEL_TEXTS.LESS_THAN)).toBeDefined();
+        expect(getText(LABEL_TEXTS.LESS_THAN)).toBeDefined();
+      });
+
+      it("renders helper text", () => {
+        expect(getText(HELPER_TEXTS.LESS_THAN)).toBeDefined();
+      });
     });
 
-    it("renders filter button", () => {
-      expect(screen.getByText("Filter")).toBeDefined();
+    describe(DESCRIBE_TITLES.GREATER_THAN, () => {
+      beforeEach(() => {
+        fireEvent.click(getButton(GREATER_THAN));
+      });
+
+      it("renders GREATER THAN toggle button as selected", () => {
+        expect(getClassNames(getButton(GREATER_THAN))).toContain(
+          MUI_CLASSES.SELECTED
+        );
+      });
+
+      it("renders GREATER THAN input field with correct label", () => {
+        expect(filterEl.querySelectorAll("label")).toHaveLength(1);
+        expect(filterEl.querySelectorAll("input")).toHaveLength(1);
+        expect(getLabelText(LABEL_TEXTS.GREATER_THAN)).toBeDefined();
+        expect(getText(LABEL_TEXTS.GREATER_THAN)).toBeDefined();
+      });
+
+      it("renders helper text", () => {
+        expect(getText(HELPER_TEXTS.GREATER_THAN)).toBeDefined();
+      });
     });
   });
 
-  describe("Operator LESS THAN", () => {
-    beforeEach(() => {
-      fireEvent.click(screen.getByRole("button", { name: LESS_THAN }));
+  describe("Input rendering for selectedMin and selectedMax combinations", () => {
+    it("renders both min and max inputs with selected values when both selectedMin and selectedMax are defined", () => {
+      render(
+        <Default
+          selectedMax={TEST_VALUES.SELECTED_MAX}
+          selectedMin={TEST_VALUES.SELECTED_MIN}
+        />
+      );
+      expect(getClassNames(getButton(BETWEEN))).toContain(MUI_CLASSES.SELECTED);
+      expect(getLabelText<HTMLInputElement>(LABEL_TEXTS.MIN).value).toEqual(
+        TEST_VALUES.SELECTED_MIN.toString()
+      );
+      expect(getLabelText<HTMLInputElement>(LABEL_TEXTS.MAX).value).toEqual(
+        TEST_VALUES.SELECTED_MAX.toString()
+      );
     });
 
-    it("renders LESS THAN toggle button as selected", () => {
+    it("renders min input with selected value when only selectedMin is defined", () => {
+      render(
+        <Default selectedMax={null} selectedMin={TEST_VALUES.SELECTED_MIN} />
+      );
+      expect(getClassNames(getButton(GREATER_THAN))).toContain(
+        MUI_CLASSES.SELECTED
+      );
       expect(
-        getClassNames(screen.getByRole("button", { name: LESS_THAN }))
-      ).toContain(MUI_CLASSES.SELECTED);
+        getLabelText<HTMLInputElement>(LABEL_TEXTS.GREATER_THAN).value
+      ).toEqual(TEST_VALUES.SELECTED_MIN.toString());
     });
 
-    it("renders LESS THAN input field with correct label", () => {
-      expect(filterEl.querySelectorAll("label")).toHaveLength(1);
-      expect(filterEl.querySelectorAll("input")).toHaveLength(1);
-      expect(filterEl.querySelector('label[for="lessThan"]')).toBeDefined();
-      expect(filterEl.querySelector('input[name="lessThan"]')).toBeDefined();
+    it("renders max input with selected value when only selectedMax is defined", () => {
+      render(
+        <Default selectedMax={TEST_VALUES.SELECTED_MAX} selectedMin={null} />
+      );
+      expect(getClassNames(getButton(LESS_THAN))).toContain(
+        MUI_CLASSES.SELECTED
+      );
+      expect(
+        getLabelText<HTMLInputElement>(LABEL_TEXTS.LESS_THAN).value
+      ).toEqual(TEST_VALUES.SELECTED_MAX.toString());
     });
   });
 
-  describe("Operator GREATER THAN", () => {
-    beforeEach(() => {
-      fireEvent.click(screen.getByRole("button", { name: GREATER_THAN }));
+  describe("Filter button interaction", () => {
+    describe(DESCRIBE_TITLES.BETWEEN, () => {
+      it("calls onFilter with correct values when min and max are selected", async () => {
+        render(
+          <Default
+            selectedMin={TEST_VALUES.SELECTED_MIN}
+            selectedMax={TEST_VALUES.SELECTED_MAX}
+            onFilter={TEST_VALUES.ON_FILTER}
+          />
+        );
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(1);
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledWith(
+            TEST_VALUES.CATEGORY_KEY,
+            [TEST_VALUES.SELECTED_MIN, TEST_VALUES.SELECTED_MAX],
+            true,
+            undefined,
+            VIEW_KIND.RANGE
+          );
+        });
+      });
+
+      it("calls onFilter with correct values when only min is selected", async () => {
+        render(
+          <Default
+            selectedMin={TEST_VALUES.SELECTED_MIN}
+            selectedMax={null}
+            onFilter={TEST_VALUES.ON_FILTER}
+          />
+        );
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledWith(
+            TEST_VALUES.CATEGORY_KEY,
+            [TEST_VALUES.SELECTED_MIN, null],
+            true,
+            undefined,
+            VIEW_KIND.RANGE
+          );
+        });
+      });
+
+      it("calls onFilter with correct values when only max is selected", async () => {
+        render(
+          <Default
+            selectedMin={null}
+            selectedMax={TEST_VALUES.SELECTED_MAX}
+            onFilter={TEST_VALUES.ON_FILTER}
+          />
+        );
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledWith(
+            TEST_VALUES.CATEGORY_KEY,
+            [null, TEST_VALUES.SELECTED_MAX],
+            true,
+            undefined,
+            VIEW_KIND.RANGE
+          );
+        });
+      });
     });
+  });
 
-    it("renders GREATER THAN toggle button as selected", () => {
-      expect(
-        getClassNames(screen.getByRole("button", { name: GREATER_THAN }))
-      ).toContain(MUI_CLASSES.SELECTED);
+  describe("Error states", () => {
+    const STRING_VALUE = { target: { value: "test" } }; // Updater of input value from number to string value "test".
+
+    describe(DESCRIBE_TITLES.BETWEEN, () => {
+      it("shows error when min and max are missing", async () => {
+        render(<Default selectedMin={null} selectedMax={null} />);
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(0);
+          expect(getText("Min or Max is required")).toBeDefined();
+        });
+      });
+
+      it("shows error when min is not a number", async () => {
+        render(
+          <Default
+            selectedMin={TEST_VALUES.SELECTED_MIN}
+            selectedMax={TEST_VALUES.SELECTED_MAX}
+          />
+        );
+        fireEvent.change(getLabelText(LABEL_TEXTS.MIN), STRING_VALUE);
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(0);
+          expect(getText(ERROR_TEXTS.TYPE_ERROR)).toBeDefined();
+        });
+      });
+
+      it("shows error when max is not a number", async () => {
+        render(
+          <Default
+            selectedMin={TEST_VALUES.SELECTED_MIN}
+            selectedMax={TEST_VALUES.SELECTED_MAX}
+          />
+        );
+        fireEvent.change(getLabelText(LABEL_TEXTS.MAX), STRING_VALUE);
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(0);
+          expect(getText(ERROR_TEXTS.TYPE_ERROR)).toBeDefined();
+        });
+      });
+
+      it("shows error when min is greater than max", async () => {
+        render(
+          <Default
+            selectedMin={TEST_VALUES.SELECTED_MAX}
+            selectedMax={TEST_VALUES.SELECTED_MIN}
+          />
+        );
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(0);
+          expect(getText(ERROR_TEXTS.MIN_MAX_ERROR)).toBeDefined();
+        });
+      });
     });
 
-    it("renders GREATER THAN input field with correct label", () => {
-      expect(filterEl.querySelectorAll("label")).toHaveLength(1);
-      expect(filterEl.querySelectorAll("input")).toHaveLength(1);
-      expect(filterEl.querySelector('label[for="greaterThan"]')).toBeDefined();
-      expect(filterEl.querySelector('input[name="greaterThan"]')).toBeDefined();
+    describe(DESCRIBE_TITLES.LESS_THAN, () => {
+      beforeEach(() => {
+        render(<Default selectedMin={null} selectedMax={null} />);
+        fireEvent.click(getButton(LESS_THAN));
+      });
+      it("shows error when required max is missing", async () => {
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(0);
+          expect(getText(ERROR_TEXTS.REQUIRED_ERROR)).toBeDefined();
+        });
+      });
+
+      it("shows error when required max is not a number", async () => {
+        fireEvent.change(getLabelText(LABEL_TEXTS.LESS_THAN), STRING_VALUE);
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(0);
+          expect(getText(ERROR_TEXTS.TYPE_ERROR)).toBeDefined();
+        });
+      });
+    });
+
+    describe(DESCRIBE_TITLES.GREATER_THAN, () => {
+      beforeEach(() => {
+        render(<Default selectedMin={null} selectedMax={null} />);
+        fireEvent.click(getButton(GREATER_THAN));
+      });
+
+      it("shows error when required min is missing", async () => {
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(0);
+          expect(getText(ERROR_TEXTS.REQUIRED_ERROR)).toBeDefined();
+        });
+      });
+
+      it("shows error when required min is not a number", async () => {
+        fireEvent.change(getLabelText(LABEL_TEXTS.GREATER_THAN), STRING_VALUE);
+        fireEvent.click(getFilterButton());
+        await waitFor(() => {
+          expect(TEST_VALUES.ON_FILTER).toHaveBeenCalledTimes(0);
+          expect(getText(ERROR_TEXTS.TYPE_ERROR)).toBeDefined();
+        });
+      });
     });
   });
 });
+
+/**
+ * Retrieves the filter button.
+ * @returns The filter button element.
+ */
+function getFilterButton(): HTMLElement {
+  return getButton("Filter");
+}

package/tests/filters.test.tsx

@@ -0,0 +1,61 @@
+import { jest } from "@jest/globals";
+import { composeStories } from "@storybook/react";
+import { render, screen } from "@testing-library/react";
+import React from "react";
+import { CategoryView } from "../src/common/categories/views/types";
+import { CategoryFilter } from "../src/components/Filter/components/Filters/filters";
+import * as stories from "../src/components/Filter/components/Filters/stories/filters.stories";
+import { TEST_IDS } from "../src/tests/testIds";
+import { getButton, getStartsWithRegex, getText } from "../src/tests/utils";
+
+const { Default } = composeStories(stories);
+
+const CATEGORY_FILTERS = Default.args.categoryFilters;
+
+/**
+ * Tests for the Filters component.
+ */
+
+describe("Filters", () => {
+  let filtersEl: HTMLElement;
+
+  describe("UI rendering", () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+      render(<Default />);
+      filtersEl = screen.getByTestId(TEST_IDS.FILTERS);
+      expect(filtersEl).toBeDefined();
+    });
+
+    it("renders all category filter labels", () => {
+      for (const { label } of CATEGORY_FILTERS || []) {
+        if (!label) continue;
+        expect(getText(label)).toBeDefined();
+      }
+    });
+
+    it("renders all category view filters", () => {
+      const CATEGORY_VIEWS = getCategoryViews(CATEGORY_FILTERS);
+      expect(screen.getAllByRole("button")).toHaveLength(CATEGORY_VIEWS.length);
+      for (const { label } of CATEGORY_VIEWS) {
+        expect(getButton(getStartsWithRegex(label))).toBeDefined();
+      }
+    });
+  });
+
+  it("renders nothing if categoryFilters is empty", () => {
+    render(<Default categoryFilters={[]} />);
+    expect(screen.queryAllByRole("button")).toHaveLength(0);
+  });
+});
+
+/**
+ * Returns all category views from the given category filters.
+ * @param categoryFilters - Array of category filters.
+ * @returns Array of category views.
+ */
+function getCategoryViews(
+  categoryFilters: CategoryFilter[] = []
+): CategoryView[] {
+  return categoryFilters.flatMap(({ categoryViews }) => categoryViews);
+}

package/tests/getFacetedMinMaxValues.test.ts

@@ -0,0 +1,166 @@
+import { Row, RowData, RowModel, Table } from "@tanstack/react-table";
+import { getFacetedMinMaxValues } from "../src/components/Table/featureOptions/facetedColumn/getFacetedMinMaxValues";
+
+describe("getFacetedMinMaxValues", () => {
+  test.each([
+    {
+      expected: [10, 30],
+      name: "returns correct min and max for all valid numbers",
+      rows: [makeRow([10]), makeRow([20]), makeRow([30])],
+    },
+    {
+      expected: [5, 100],
+      name: "skips null and NaN values",
+      rows: [
+        makeRow([null]),
+        makeRow([15, NaN]),
+        makeRow([5, 25]),
+        makeRow([undefined, 100]),
+      ],
+    },
+    {
+      expected: [10, 30],
+      name: "skips non-numeric strings and includes numeric strings",
+      rows: [makeRow(["10", "not-a-number"]), makeRow([20]), makeRow(["30"])],
+    },
+    {
+      expected: undefined,
+      name: "returns undefined if all values are null or NaN",
+      rows: [
+        makeRow([null]),
+        makeRow([undefined]),
+        makeRow([NaN]),
+        makeRow([null, NaN]),
+      ],
+    },
+    {
+      expected: [-1000, 50000],
+      name: "handles negative, zero, and large numbers",
+      rows: [makeRow([-1000]), makeRow([0]), makeRow([50000]), makeRow([42])],
+    },
+    {
+      expected: [10, 60],
+      name: "computes min and max across multiple values per row",
+      rows: [makeRow([10, 20]), makeRow([30, 40]), makeRow([50, 60])],
+    },
+    {
+      expected: [10, 60],
+      name: "computes min and max across mixed arrays with null, undefined, and non-numeric value",
+      rows: [
+        makeRow([10, null, 20]),
+        makeRow([30, undefined, 40]),
+        makeRow([50, 60, "not-a-number"]),
+        makeRow([null, null, null]),
+      ],
+    },
+    {
+      expected: [10, 10],
+      name: "returns [value, value] for a single row/value",
+      rows: [makeRow([10])],
+    },
+    {
+      expected: undefined,
+      name: "returns undefined if all rows are empty arrays",
+      rows: [makeRow([]), makeRow([])],
+    },
+    {
+      expected: undefined,
+      name: "returns undefined if all values are non-numeric strings",
+      rows: [makeRow(["foo"]), makeRow(["bar"]), makeRow(["baz"])],
+    },
+    {
+      expected: [0, 0],
+      name: "handles negative zero correctly",
+      rows: [makeRow([-0]), makeRow([0]), makeRow([0])],
+    },
+    {
+      expected: [-Infinity, Infinity],
+      name: "handles Infinity and -Infinity as values",
+      rows: [makeRow([Infinity]), makeRow([-Infinity]), makeRow([10])],
+    },
+    {
+      expected: [0, 42],
+      name: "handles mixed valid and invalid types",
+      rows: [makeRow([null, "5", {}, [], 42, undefined, "abc", 0])],
+    },
+    {
+      expected: undefined,
+      name: "returns undefined for no rows",
+      rows: [],
+    },
+  ])("$name", ({ expected, rows }) => {
+    const COLUMN_ID = "columnId";
+    const result = getExpected(makeTable(rows, COLUMN_ID), COLUMN_ID);
+    expect(result).toEqual(expected);
+  });
+
+  it("returns undefined if column does not exist", () => {
+    const COLUMN_ID = "missing";
+    const ROWS = [makeRow([1]), makeRow([2])];
+    const expected = getExpected(makeTable(ROWS, "foo"), COLUMN_ID);
+    expect(expected).toBeUndefined();
+  });
+
+  it("returns undefined if facetedRowModel is undefined", () => {
+    const COLUMN_ID = "foo";
+    const table = {
+      getColumn: (): {
+        getFacetedRowModel: () => RowModel<RowData> | undefined;
+      } => ({
+        getFacetedRowModel: (): undefined => undefined,
+      }),
+    } as unknown as Table<RowData>;
+    const expected = getExpected(table, COLUMN_ID);
+    expect(expected).toBeUndefined();
+  });
+});
+
+/**
+ * Helper function to get the expected result from the getFacetedMinMaxValues function.
+ * @param table - The table to get the expected result from.
+ * @param columnId - The column id to get the expected result from.
+ * @returns The expected result from the getFacetedMinMaxValues function.
+ */
+function getExpected(
+  table: Table<RowData>,
+  columnId: string
+): [number, number] | undefined {
+  return getFacetedMinMaxValues()(table, columnId)();
+}
+
+/**
+ * Helper function to create a faceted row model.
+ * @param rows - The rows to create the faceted row model from.
+ * @returns The faceted row model.
+ */
+function makeFacetedRowModel(rows: Row<RowData>[]): RowModel<RowData> {
+  return {
+    flatRows: rows,
+  } as unknown as RowModel<RowData>;
+}
+
+/**
+ * Helper function to create a row with a specific set of values.
+ * @param values - The values to set for the row.
+ * @returns The row.
+ */
+function makeRow(values: unknown[]): Row<RowData> {
+  return {
+    getUniqueValues: <TValue>() => values as TValue[],
+  } as unknown as Row<RowData>;
+}
+
+/**
+ * Helper function to create a table with a specific set of rows.
+ * @param rows - The rows to set for the table.
+ * @param columnId - The column id to set for the table.
+ * @returns The table.
+ */
+function makeTable(rows: Row<RowData>[], columnId: string): Table<RowData> {
+  return {
+    getColumn: (id: string) =>
+      id === columnId
+        ? { getFacetedRowModel: () => makeFacetedRowModel(rows) }
+        : undefined,
+  } as unknown as Table<RowData>;
+}