chore: add tests

Author: santipalenque

package.json

@@ -154,7 +154,7 @@
         "react-select": "^2.4.3",
         "react-star-ratings": "^2.3.0",
         "react-tooltip": "^3.11.1",
-        "redux": "^3.7.2",
+        "redux": "^3.7.2 || ^4.0.0",
         "redux-persist": "^5.10.0",
         "redux-thunk": "^2.3.0",
         "spark-md5": "^3.0.2",

src/components/mui/GridFilter/readme.md

@@ -33,7 +33,7 @@ import { GridFilter, OPERATORS } from "components/GridFilter";
             { value: 1, label: "OpenStack" },
             { value: 2, label: "FnTech" }
           ],
-          multi: true,
+          multiple: true,
           placeholder: "Select Tracks"
         }
       }
@@ -138,7 +138,9 @@ The hook reads from `allGridFiltersState` in the Redux store, so it stays in syn
 
 # hideJoinOperators
 
-By default the dialog shows an **All / Any** toggle that lets the user choose whether filters are ANDed or ORed together. Pass `hideJoinOperators` to hide it — useful when you always want a fixed join behavior (the default remains `"all"`).
+By default the dialog shows an **All / Any** toggle that lets the user choose whether filters are ANDed or ORed together. Pass `hideJoinOperators` to hide the toggle UI — but note that this **only removes the control from the dialog; it does not change the active join operator**. The dialog always initializes from the join operator last persisted in the Redux store (which defaults to `"all"` on first load). If the user previously applied filters with `"any"` and that value is still in the store, it will continue to be used when the toggle is hidden — silently producing OR-joined results.
+
+If you need a guaranteed fixed join behavior after hiding the toggle, call `resetFilters()` (from `useGridFilter`) before or after mounting the component to flush the store back to `"all"`.
 
 ```jsx
 <GridFilter

src/components/mui/__tests__/GridFilter.test.jsx

@@ -7,7 +7,7 @@ import "@testing-library/jest-dom";
 import { Provider } from "react-redux";
 import configureStore from "redux-mock-store";
 import thunk from "redux-thunk";
-import { GridFilter, OPERATORS } from "../GridFilter";
+import { GridFilter, OPERATORS, JOIN_OPERATORS, SAVE_FILTERS } from "../GridFilter";
 import Filter from "../GridFilter/components/Filter";
 
 jest.mock("i18n-react/dist/i18n-react", () => ({
@@ -234,3 +234,154 @@ describe("Filter - options as a function", () => {
     );
   });
 });
+
+// ─── parseFilter / handleSubmit ──────────────────────────────────────────────
+//
+// These are private closures; exercised by seeding the Redux store with filter
+// values so useGridFilter returns them, opening the dialog, and clicking Apply.
+
+describe("GridFilter – parseFilter / handleSubmit", () => {
+  // Build a mock store that makes useGridFilter("test-filter") return the given values.
+  const makeFilterStore = (filterValues, joinOperator = JOIN_OPERATORS.ALL) =>
+    mockStore({
+      allGridFiltersState: {
+        allFilters: [{ id: "test-filter", filterValues, joinOperator, parsedFilter: [] }]
+      }
+    });
+
+  const renderWithFilters = (filterValues, opts = {}) => {
+    const { joinOperator = JOIN_OPERATORS.ALL, onApply = jest.fn(), criterias: c } = opts;
+    const store = makeFilterStore(filterValues, joinOperator);
+    render(
+      <Provider store={store}>
+        <GridFilter
+          id="test-filter"
+          criterias={c ?? criterias}
+          onApply={onApply}
+        />
+      </Provider>
+    );
+    return { onApply, store };
+  };
+
+  // FilterButton renders a Chip when filterCount > 0; its label span contains
+  // "${n} grid_filter.filters". Clicking the span bubbles to the Chip's onClick.
+  const openFilterDialog = () =>
+    fireEvent.click(screen.getByText(/\d+ grid_filter\.filters/));
+
+  const applyFilters = () =>
+    fireEvent.click(screen.getByText("grid_filter.apply_filters"));
+
+  describe("filter serialization", () => {
+    test("single value → criteria+operator+value", () => {
+      const { onApply } = renderWithFilters([
+        { criteria: "sponsor", operator: "==", value: "alice" }
+      ]);
+
+      openFilterDialog();
+      applyFilters();
+
+      const [filters, joinOp] = onApply.mock.calls[0];
+      expect(filters).toHaveLength(1);
+      expect(filters[0].parsed).toEqual(["sponsor==alice"]);
+      expect(joinOp).toBe(JOIN_OPERATORS.ALL);
+    });
+
+    test("array value → items joined with ||", () => {
+      const { onApply } = renderWithFilters([
+        { criteria: "track", operator: "==", value: [1, 2, 3] }
+      ]);
+
+      openFilterDialog();
+      applyFilters();
+
+      const [filters] = onApply.mock.calls[0];
+      expect(filters[0].parsed).toEqual(["track==1||2||3"]);
+    });
+
+    test("delegates to customParser and uses its return value as parsed", () => {
+      const customParser = jest.fn().mockReturnValue(["custom==result"]);
+      const c = [
+        {
+          key: "status",
+          label: "Status",
+          operators: [OPERATORS.IS],
+          values: { type: "text", props: {} },
+          customParser
+        }
+      ];
+
+      const { onApply } = renderWithFilters(
+        [{ criteria: "status", operator: "==", value: "active" }],
+        { criterias: c }
+      );
+
+      openFilterDialog();
+      applyFilters();
+
+      expect(customParser).toHaveBeenCalledWith(
+        expect.objectContaining({ criteria: "status", operator: "==", value: "active" })
+      );
+      const [filters] = onApply.mock.calls[0];
+      expect(filters[0].parsed).toEqual(["custom==result"]);
+    });
+  });
+
+  describe("handleSubmit filter predicate", () => {
+    test.each([
+      // value: null avoids a render crash: with criteria=null there is no type, so ValueInput
+      // falls back to Dropdown with options=null; a non-null value would hit options.find(null).
+      ["null criteria",  { criteria: null,     operator: "==", value: null }],
+      ["null operator",  { criteria: "sponsor", operator: null, value: "v" }],
+      ["null value",     { criteria: "sponsor", operator: "==", value: null }],
+      ["empty string",   { criteria: "sponsor", operator: "==", value: "" }],
+      ["empty array",    { criteria: "track",   operator: "==", value: [] }]
+    ])("strips %s; valid sibling survives", (_, badFilter) => {
+      const { onApply } = renderWithFilters([
+        badFilter,
+        { criteria: "sponsor", operator: "==", value: "valid" }
+      ]);
+
+      openFilterDialog();
+      applyFilters();
+
+      const [filters] = onApply.mock.calls[0];
+      expect(filters).toHaveLength(1);
+      expect(filters[0].value).toBe("valid");
+    });
+  });
+
+  describe("action contracts", () => {
+    test("saveFilters and onApply both receive the parsed payload and active join operator", () => {
+      const onApply = jest.fn();
+      const { store } = renderWithFilters(
+        [{ criteria: "sponsor", operator: "=@", value: "bob" }],
+        { joinOperator: JOIN_OPERATORS.ANY, onApply }
+      );
+
+      openFilterDialog();
+      applyFilters();
+
+      const expectedFilter = expect.objectContaining({
+        criteria: "sponsor",
+        operator: "=@",
+        value: "bob",
+        parsed: ["sponsor=@bob"]
+      });
+
+      // The saveFilters thunk dispatches {type: SAVE_FILTERS, payload: {...}} to the store.
+      const savedAction = store.getActions().find((a) => a.type === SAVE_FILTERS);
+      expect(savedAction).toBeDefined();
+      expect(savedAction.payload).toMatchObject({
+        id: "test-filter",
+        joinOperator: JOIN_OPERATORS.ANY,
+        filters: expect.arrayContaining([expectedFilter])
+      });
+
+      expect(onApply).toHaveBeenCalledWith(
+        expect.arrayContaining([expectedFilter]),
+        JOIN_OPERATORS.ANY
+      );
+    });
+  });
+});

src/components/mui/__tests__/all-filters-reducer.test.js

@@ -0,0 +1,136 @@
+jest.mock("i18n-react/dist/i18n-react", () => ({
+  __esModule: true,
+  default: { translate: (key) => key }
+}));
+
+import allFiltersReducer from "../GridFilter/reducers/all-filters-reducer";
+import { JOIN_OPERATORS } from "../GridFilter/utils";
+import { SAVE_FILTERS } from "../GridFilter/actions/filter-actions";
+import { LOGOUT_USER } from "../../security/actions";
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+const saveAction = (id, filters = [], joinOperator = JOIN_OPERATORS.ALL) => ({
+  type: SAVE_FILTERS,
+  payload: { id, filters, joinOperator }
+});
+
+const withFilters = [
+  { criteria: "name",  operator: "==", value: "alice", parsed: ["name==alice"] },
+  { criteria: "track", operator: "==", value: [1, 2],  parsed: ["track==1||2"] }
+];
+
+// ─── add new entry ────────────────────────────────────────────────────────────
+
+describe("allFiltersReducer – SAVE_FILTERS: add new entry", () => {
+  test("appends an entry when the id is not yet in allFilters", () => {
+    const next = allFiltersReducer(undefined, saveAction("grid-a", withFilters, JOIN_OPERATORS.ALL));
+
+    expect(next.allFilters).toHaveLength(1);
+    expect(next.allFilters[0]).toMatchObject({
+      id: "grid-a",
+      filterValues: withFilters,
+      joinOperator: JOIN_OPERATORS.ALL,
+      parsedFilter: ["name==alice", "track==1||2"]
+    });
+  });
+
+  test("new entry is created via filterReducer(null, …): null bypasses INITIAL_STATE default and spreads as {}", () => {
+    // Default parameters only substitute for `undefined`, not `null`.
+    // allFiltersReducer passes null (not undefined) to filterReducer for new entries,
+    // so `...state` inside filterReducer is `...null`, which is a no-op in JS.
+    // The entry should contain exactly the four keys set by the return statement —
+    // no stale id: null or other INITIAL_STATE properties leaking through.
+    const { allFilters } = allFiltersReducer(
+      undefined,
+      saveAction("new-id", withFilters, JOIN_OPERATORS.ALL)
+    );
+    const entry = allFilters[0];
+
+    expect(entry.id).toBe("new-id");
+    expect(entry.filterValues).toBe(withFilters);
+    expect(Object.keys(entry).sort()).toEqual([
+      "filterValues",
+      "id",
+      "joinOperator",
+      "parsedFilter"
+    ]);
+  });
+});
+
+// ─── update existing entry ────────────────────────────────────────────────────
+
+describe("allFiltersReducer – SAVE_FILTERS: update existing entry", () => {
+  const initial = {
+    allFilters: [
+      { id: "grid-a", filterValues: [],   joinOperator: JOIN_OPERATORS.ALL, parsedFilter: [] },
+      { id: "grid-b", filterValues: [],   joinOperator: JOIN_OPERATORS.ALL, parsedFilter: [] }
+    ]
+  };
+
+  test("replaces the matching entry and passes current state into filterReducer", () => {
+    const updated = [{ criteria: "sponsor", operator: "=@", value: "bob", parsed: ["sponsor=@bob"] }];
+    const next = allFiltersReducer(initial, saveAction("grid-a", updated, JOIN_OPERATORS.ANY));
+
+    expect(next.allFilters).toHaveLength(2);
+    expect(next.allFilters.find((f) => f.id === "grid-a")).toMatchObject({
+      filterValues: updated,
+      joinOperator: JOIN_OPERATORS.ANY,
+      parsedFilter: ["or(sponsor=@bob)"]
+    });
+  });
+
+  test("leaves other entries untouched (same object reference)", () => {
+    const next = allFiltersReducer(initial, saveAction("grid-a", withFilters));
+
+    expect(next.allFilters.find((f) => f.id === "grid-b")).toBe(initial.allFilters[1]);
+  });
+});
+
+// ─── empty reset via saveFilters(id) ─────────────────────────────────────────
+
+describe("allFiltersReducer – SAVE_FILTERS: empty reset", () => {
+  test("saveFilters(id) with no args clears filterValues, parsedFilter, and resets joinOperator to ALL", () => {
+    // saveFilters(id) calls saveFilters(id, [], JOIN_OPERATORS.ALL) — the no-arg defaults.
+    const initial = {
+      allFilters: [
+        {
+          id: "grid-a",
+          filterValues: withFilters,
+          joinOperator: JOIN_OPERATORS.ANY,
+          parsedFilter: ["or(name==alice)", "or(track==1||2)"]
+        }
+      ]
+    };
+
+    const next = allFiltersReducer(initial, saveAction("grid-a")); // ← no filters, no joinOperator
+    const entry = next.allFilters[0];
+
+    expect(entry.filterValues).toEqual([]);
+    expect(entry.parsedFilter).toEqual([]);
+    expect(entry.joinOperator).toBe(JOIN_OPERATORS.ALL);
+  });
+});
+
+// ─── LOGOUT_USER ─────────────────────────────────────────────────────────────
+
+describe("allFiltersReducer – LOGOUT_USER", () => {
+  test("resets to DEFAULT_STATE regardless of how much was stored", () => {
+    const populated = {
+      allFilters: [
+        { id: "grid-a", filterValues: withFilters, joinOperator: JOIN_OPERATORS.ANY, parsedFilter: [] }
+      ]
+    };
+
+    expect(allFiltersReducer(populated, { type: LOGOUT_USER })).toEqual({ allFilters: [] });
+  });
+});
+
+// ─── default case ─────────────────────────────────────────────────────────────
+
+describe("allFiltersReducer – default case", () => {
+  test("returns the same state reference for unknown action types", () => {
+    const state = allFiltersReducer(undefined, { type: "@@INIT" });
+    expect(allFiltersReducer(state, { type: "UNKNOWN" })).toBe(state);
+  });
+});