@cdx-ui/data-grid 0.3.11 → 0.3.12

package/src/adapter/filterOperators.test.ts

@@ -0,0 +1,292 @@
+import type { GridColDef, GridFilterOperator } from '../types';
+import {
+  coerceFilterInput,
+  filterValueToInputText,
+  getDefaultFilterOperator,
+  getFilterOperatorLabel,
+  getGridFilterOperators,
+  headerFilterValueFromText,
+  matchesOperatorFilter,
+} from './filterOperators';
+
+type Row = Record<string, unknown>;
+
+function matches(
+  col: GridColDef<Row>,
+  cell: unknown,
+  operator: GridFilterOperator,
+  value?: unknown,
+) {
+  return matchesOperatorFilter(col, cell, {}, { operator, value });
+}
+
+const text: GridColDef<Row> = { field: 'name', type: 'string' };
+const untyped: GridColDef<Row> = { field: 'name' };
+const num: GridColDef<Row> = { field: 'amount', type: 'number' };
+const date: GridColDef<Row> = { field: 'opened', type: 'date' };
+const dateTime: GridColDef<Row> = { field: 'at', type: 'dateTime' };
+const bool: GridColDef<Row> = { field: 'active', type: 'boolean' };
+const select: GridColDef<Row> = {
+  field: 'status',
+  type: 'singleSelect',
+  valueOptions: [
+    { value: 'a', label: 'Active' },
+    { value: 'p', label: 'Pending' },
+  ],
+};
+
+describe('getGridFilterOperators', () => {
+  it('lists the MUI operators per column type', () => {
+    expect(getGridFilterOperators('string')).toEqual([
+      'contains',
+      'doesNotContain',
+      'equals',
+      'doesNotEqual',
+      'startsWith',
+      'endsWith',
+      'isEmpty',
+      'isNotEmpty',
+      'isAnyOf',
+    ]);
+    expect(getGridFilterOperators('number')).toEqual([
+      '=',
+      '!=',
+      '>',
+      '>=',
+      '<',
+      '<=',
+      'isEmpty',
+      'isNotEmpty',
+      'isAnyOf',
+    ]);
+    expect(getGridFilterOperators('date')).toEqual(getGridFilterOperators('dateTime'));
+    expect(getGridFilterOperators('date')).toEqual([
+      'is',
+      'not',
+      'after',
+      'onOrAfter',
+      'before',
+      'onOrBefore',
+      'isEmpty',
+      'isNotEmpty',
+    ]);
+    expect(getGridFilterOperators('boolean')).toEqual(['is']);
+    expect(getGridFilterOperators('singleSelect')).toEqual(['is', 'not', 'isAnyOf']);
+    expect(getGridFilterOperators(undefined)).toEqual(getGridFilterOperators('string'));
+  });
+
+  it('preselects contains, =, and is', () => {
+    expect(getDefaultFilterOperator('string')).toBe('contains');
+    expect(getDefaultFilterOperator('number')).toBe('=');
+    expect(getDefaultFilterOperator('date')).toBe('is');
+    expect(getDefaultFilterOperator('boolean')).toBe('is');
+    expect(getDefaultFilterOperator('singleSelect')).toBe('is');
+  });
+});
+
+describe('matchesOperatorFilter', () => {
+  describe('text', () => {
+    it.each([
+      ['contains', 'ali', true],
+      ['contains', 'bob', false],
+      ['doesNotContain', 'bob', true],
+      ['doesNotContain', 'ali', false],
+      ['equals', 'ALICE', true],
+      ['equals', 'ali', false],
+      ['doesNotEqual', 'ali', true],
+      ['startsWith', 'AL', true],
+      ['startsWith', 'ice', false],
+      ['endsWith', 'ICE', true],
+      ['endsWith', 'al', false],
+    ] as const)('%s %s on "Alice" is %s', (operator, value, expected) => {
+      expect(matches(text, 'Alice', operator, value)).toBe(expected);
+      expect(matches(untyped, 'Alice', operator, value)).toBe(expected);
+    });
+
+    it('treats a null cell as empty text', () => {
+      expect(matches(text, null, 'contains', 'a')).toBe(false);
+      expect(matches(text, null, 'doesNotContain', 'a')).toBe(true);
+    });
+
+    it('matches isAnyOf against any listed value exactly', () => {
+      expect(matches(text, 'Alice', 'isAnyOf', ['Bob', 'Alice'])).toBe(true);
+      expect(matches(text, 'Alice', 'isAnyOf', ['Bob', 'Carol'])).toBe(false);
+      expect(matches(text, 'Alice', 'isAnyOf', 'Alice')).toBe(true);
+    });
+  });
+
+  describe('isEmpty / isNotEmpty', () => {
+    it.each([
+      [text, null, true],
+      [text, '', true],
+      [text, 'x', false],
+      [num, undefined, true],
+      [num, Number.NaN, true],
+      [num, 0, false],
+      [date, null, true],
+      [date, new Date(2026, 0, 1), false],
+    ] as const)('isEmpty on %# is %s', (col, cell, expected) => {
+      expect(matches(col as GridColDef<Row>, cell, 'isEmpty')).toBe(expected);
+      expect(matches(col as GridColDef<Row>, cell, 'isNotEmpty')).toBe(!expected);
+    });
+  });
+
+  describe('number', () => {
+    it.each([
+      ['=', 100, true],
+      ['=', 99, false],
+      ['!=', 99, true],
+      ['!=', 100, false],
+      ['>', 99, true],
+      ['>', 100, false],
+      ['>=', 100, true],
+      ['<', 101, true],
+      ['<', 100, false],
+      ['<=', 100, true],
+      ['<=', 99, false],
+    ] as const)('100 %s %s is %s', (operator, operand, expected) => {
+      expect(matches(num, 100, operator, operand)).toBe(expected);
+    });
+
+    it('coerces numeric strings and ignores unparseable operands', () => {
+      expect(matches(num, 100, '>', '50')).toBe(true);
+      expect(matches(num, 100, '>', 'abc')).toBe(true);
+      expect(matches(num, 100, '>', '')).toBe(true);
+    });
+
+    it('keeps null cells for != only', () => {
+      expect(matches(num, null, '=', 1)).toBe(false);
+      expect(matches(num, null, '>', 1)).toBe(false);
+      expect(matches(num, null, '!=', 1)).toBe(true);
+    });
+
+    it('supports isAnyOf', () => {
+      expect(matches(num, 2, 'isAnyOf', [1, '2'])).toBe(true);
+      expect(matches(num, 3, 'isAnyOf', [1, 2])).toBe(false);
+    });
+  });
+
+  describe('date', () => {
+    const cell = new Date(2026, 5, 15, 13, 45);
+
+    it.each([
+      ['is', new Date(2026, 5, 15, 1, 0), true],
+      ['is', new Date(2026, 5, 16), false],
+      ['not', new Date(2026, 5, 16), true],
+      ['after', new Date(2026, 5, 14), true],
+      ['after', new Date(2026, 5, 15), false],
+      ['onOrAfter', new Date(2026, 5, 15), true],
+      ['before', new Date(2026, 5, 16), true],
+      ['before', new Date(2026, 5, 15), false],
+      ['onOrBefore', new Date(2026, 5, 15), true],
+      ['onOrBefore', new Date(2026, 5, 14), false],
+    ] as const)('%s %s compares by calendar day', (operator, operand, expected) => {
+      expect(matches(date, cell, operator, operand)).toBe(expected);
+    });
+
+    it('parses date-only strings in local time', () => {
+      expect(matches(date, new Date(2026, 0, 1), 'is', '2026-01-01')).toBe(true);
+      expect(matches(date, new Date(2026, 0, 1), 'before', '2026-01-02')).toBe(true);
+    });
+
+    it('compares dateTime to the millisecond', () => {
+      const at = new Date(2026, 5, 15, 13, 45);
+      expect(matches(dateTime, at, 'is', new Date(at))).toBe(true);
+      expect(matches(dateTime, at, 'is', new Date(2026, 5, 15))).toBe(false);
+      expect(matches(dateTime, at, 'after', new Date(2026, 5, 15))).toBe(true);
+    });
+
+    it('ignores invalid operands and keeps null cells for not only', () => {
+      expect(matches(date, cell, 'is', 'not a date')).toBe(true);
+      expect(matches(date, null, 'is', new Date(2026, 5, 15))).toBe(false);
+      expect(matches(date, null, 'not', new Date(2026, 5, 15))).toBe(true);
+    });
+  });
+
+  describe('boolean', () => {
+    it('matches is against booleans and "true" / "false"', () => {
+      expect(matches(bool, true, 'is', true)).toBe(true);
+      expect(matches(bool, true, 'is', false)).toBe(false);
+      expect(matches(bool, false, 'is', 'false')).toBe(true);
+      expect(matches(bool, null, 'is', false)).toBe(false);
+    });
+
+    it('filters nothing for a blank operand', () => {
+      expect(matches(bool, true, 'is', '')).toBe(true);
+      expect(matches(bool, false, 'is', undefined)).toBe(true);
+    });
+  });
+
+  describe('singleSelect', () => {
+    it('compares stored values, not labels', () => {
+      expect(matches(select, 'a', 'is', 'a')).toBe(true);
+      expect(matches(select, 'a', 'is', 'Active')).toBe(false);
+      expect(matches(select, 'a', 'not', 'p')).toBe(true);
+      expect(matches(select, null, 'not', 'p')).toBe(true);
+    });
+
+    it('supports isAnyOf and numeric option values', () => {
+      expect(matches(select, 'p', 'isAnyOf', ['a', 'p'])).toBe(true);
+      expect(matches(select, 'p', 'isAnyOf', ['a'])).toBe(false);
+      expect(matches(select, 2, 'is', '2')).toBe(true);
+    });
+  });
+
+  it('filters nothing for blank operands and for operators the type does not accept', () => {
+    expect(matches(text, 'Alice', 'contains', '')).toBe(true);
+    expect(matches(text, 'Alice', 'isAnyOf', [])).toBe(true);
+    expect(matches(text, 'Alice', '>', 5)).toBe(true);
+    expect(matches(num, 5, 'contains', 'x')).toBe(true);
+  });
+});
+
+describe('header filter text', () => {
+  it('labels operators the way the menu shows them', () => {
+    expect(getFilterOperatorLabel('doesNotContain')).toBe('does not contain');
+    expect(getFilterOperatorLabel('>=')).toBe('>=');
+    expect(getFilterOperatorLabel('onOrBefore')).toBe('is on or before');
+  });
+
+  it('splits isAnyOf on commas and types numbers', () => {
+    expect(headerFilterValueFromText(text, 'isAnyOf', ' Bob, Alice ')).toEqual(['Bob', 'Alice']);
+    expect(headerFilterValueFromText(num, 'isAnyOf', '50, 1.50, 2')).toEqual([50, '1.50', 2]);
+    expect(headerFilterValueFromText(num, '>', '100')).toBe(100);
+    expect(headerFilterValueFromText(num, 'isEmpty', '100')).toBeUndefined();
+    expect(headerFilterValueFromText(select, 'is', 'Pending')).toBe('p');
+    expect(headerFilterValueFromText(select, 'isAnyOf', 'Active, p')).toEqual(['a', 'p']);
+  });
+});
+
+describe('coerceFilterInput', () => {
+  it('types numbers, dates, and booleans that round-trip', () => {
+    expect(coerceFilterInput(num, '>', '100')).toBe(100);
+    expect(coerceFilterInput(num, '>', '1.5')).toBe(1.5);
+    expect(coerceFilterInput(date, 'after', '2026-01-02')).toEqual(new Date(2026, 0, 2));
+    expect(coerceFilterInput(bool, 'is', 'true')).toBe(true);
+  });
+
+  it('keeps text that would be rewritten under the cursor', () => {
+    expect(coerceFilterInput(num, '>', '1.')).toBe('1.');
+    expect(coerceFilterInput(num, '>', '1.50')).toBe('1.50');
+    expect(coerceFilterInput(num, '>', '-')).toBe('-');
+    expect(coerceFilterInput(date, 'after', '2026-01')).toBe('2026-01');
+  });
+
+  it('keeps text for isAnyOf, text columns, and untyped columns', () => {
+    expect(coerceFilterInput(num, 'isAnyOf', '1')).toBe('1');
+    expect(coerceFilterInput(text, 'contains', '12')).toBe('12');
+    expect(coerceFilterInput(undefined, 'contains', '12')).toBe('12');
+  });
+});
+
+describe('filterValueToInputText', () => {
+  it('renders operands back as input text', () => {
+    expect(filterValueToInputText(undefined)).toBe('');
+    expect(filterValueToInputText('abc')).toBe('abc');
+    expect(filterValueToInputText(12.5)).toBe('12.5');
+    expect(filterValueToInputText(false)).toBe('false');
+    expect(filterValueToInputText(new Date(2026, 0, 2))).toBe('2026-01-02');
+    expect(filterValueToInputText(['a', 2])).toBe('a, 2');
+    expect(filterValueToInputText({})).toBe('');
+  });
+});