@lovett/ui 0.0.11 → 0.2.0

package/src/filter-core/__tests__/filter-fns.test.ts

@@ -0,0 +1,519 @@
+/**
+ * Predicates and the combinator.
+ *
+ * Includes the regression tests for two of the three bugs carried by the
+ * source implementation:
+ *
+ *   BUG 1 — `filterValue.operator in ['is between', 'is not between']`
+ *           (filter-fns.ts:80). `in` on an ARRAY tests index keys, so the
+ *           guard never fired. The tests marked "BUG 1" fail against that
+ *           form, because it does not throw.
+ *
+ *   BUG 2 — the combinator listed only option/multiOption and fell through
+ *           to `return true` for text/number/date (issue-filter-columns.tsx:
+ *           187-188), silently disabling filtering on a date column. The
+ *           tests marked "BUG 2" fail against that form, because a date
+ *           filter there matches every row.
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  dateFilterFn,
+  defineColumns,
+  filterRows,
+  multiOptionFilterFn,
+  numberFilterFn,
+  optionFilterFn,
+  pruneFilters,
+  rowMatchesFilter,
+  textFilterFn,
+} from '../index'
+import type { AnyColumnConfig, FilterModel, FiltersState } from '../index'
+
+/* ------------------------------------------------------------------ */
+/* Fixtures                                                            */
+/* ------------------------------------------------------------------ */
+
+interface Task {
+  readonly id: string
+  readonly title: string | null
+  readonly points: number | null
+  readonly due: Date | null
+  readonly priority: string | null
+  readonly labels: readonly string[]
+}
+
+const d = (day: number): Date => new Date(2026, 0, day)
+
+function task(overrides: Partial<Task> & { id: string }): Task {
+  return {
+    title: null,
+    points: null,
+    due: null,
+    priority: null,
+    labels: [],
+    ...overrides,
+  }
+}
+
+const columns = defineColumns<Task>([
+  { id: 'title', type: 'text', displayName: 'Title', accessor: (t) => t.title },
+  {
+    id: 'points',
+    type: 'number',
+    displayName: 'Points',
+    accessor: (t) => t.points,
+  },
+  { id: 'due', type: 'date', displayName: 'Due', accessor: (t) => t.due },
+  {
+    id: 'priority',
+    type: 'option',
+    displayName: 'Priority',
+    accessor: (t) => t.priority,
+    options: [
+      { value: 'low', label: 'Low' },
+      { value: 'medium', label: 'Medium' },
+      { value: 'high', label: 'High' },
+    ],
+  },
+  {
+    id: 'labels',
+    type: 'multiOption',
+    displayName: 'Labels',
+    accessor: (t) => t.labels,
+    options: [
+      { value: 'bug', label: 'Bug' },
+      { value: 'ui', label: 'UI' },
+      { value: 'perf', label: 'Perf' },
+    ],
+  },
+])
+
+const text = (
+  operator: FilterModel<'text'>['operator'],
+  values: string[],
+): FilterModel<'text'> => ({ columnId: 'title', type: 'text', operator, values })
+
+const num = (
+  operator: FilterModel<'number'>['operator'],
+  values: number[],
+): FilterModel<'number'> => ({
+  columnId: 'points',
+  type: 'number',
+  operator,
+  values,
+})
+
+const date = (
+  operator: FilterModel<'date'>['operator'],
+  values: Date[],
+): FilterModel<'date'> => ({ columnId: 'due', type: 'date', operator, values })
+
+const option = (
+  operator: FilterModel<'option'>['operator'],
+  values: string[],
+): FilterModel<'option'> => ({
+  columnId: 'priority',
+  type: 'option',
+  operator,
+  values,
+})
+
+const multi = (
+  operator: FilterModel<'multiOption'>['operator'],
+  values: string[],
+): FilterModel<'multiOption'> => ({
+  columnId: 'labels',
+  type: 'multiOption',
+  operator,
+  values,
+})
+
+/* ------------------------------------------------------------------ */
+/* text                                                                */
+/* ------------------------------------------------------------------ */
+
+describe('textFilterFn', () => {
+  it('handles contains and does not contain', () => {
+    expect(textFilterFn('Ship the board', text('contains', ['board']))).toBe(true)
+    expect(textFilterFn('Ship the board', text('contains', ['rail']))).toBe(false)
+    expect(
+      textFilterFn('Ship the board', text('does not contain', ['rail'])),
+    ).toBe(true)
+    expect(
+      textFilterFn('Ship the board', text('does not contain', ['board'])),
+    ).toBe(false)
+  })
+
+  it('is case- and whitespace-insensitive', () => {
+    expect(textFilterFn('Ship The BOARD', text('contains', ['  board ']))).toBe(
+      true,
+    )
+  })
+
+  it('passes everything on an empty or blank needle', () => {
+    expect(textFilterFn('anything', text('contains', []))).toBe(true)
+    expect(textFilterFn('anything', text('contains', ['   ']))).toBe(true)
+  })
+
+  it('treats a missing value as the empty string, so the pair stays complementary', () => {
+    // The source returned false for BOTH halves on a null input, which made
+    // "contains x" and "does not contain x" simultaneously false.
+    expect(textFilterFn(null, text('contains', ['x']))).toBe(false)
+    expect(textFilterFn(null, text('does not contain', ['x']))).toBe(true)
+  })
+})
+
+/* ------------------------------------------------------------------ */
+/* number                                                              */
+/* ------------------------------------------------------------------ */
+
+describe('numberFilterFn', () => {
+  it('handles every comparison operator', () => {
+    expect(numberFilterFn(5, num('is', [5]))).toBe(true)
+    expect(numberFilterFn(5, num('is', [6]))).toBe(false)
+    expect(numberFilterFn(5, num('is not', [6]))).toBe(true)
+    expect(numberFilterFn(5, num('is greater than', [4]))).toBe(true)
+    expect(numberFilterFn(5, num('is greater than', [5]))).toBe(false)
+    expect(numberFilterFn(5, num('is greater than or equal to', [5]))).toBe(true)
+    expect(numberFilterFn(5, num('is less than', [6]))).toBe(true)
+    expect(numberFilterFn(5, num('is less than', [5]))).toBe(false)
+    expect(numberFilterFn(5, num('is less than or equal to', [5]))).toBe(true)
+  })
+
+  it('treats between as inclusive and order-insensitive', () => {
+    expect(numberFilterFn(5, num('is between', [1, 9]))).toBe(true)
+    expect(numberFilterFn(5, num('is between', [9, 1]))).toBe(true)
+    expect(numberFilterFn(1, num('is between', [1, 9]))).toBe(true)
+    expect(numberFilterFn(9, num('is between', [1, 9]))).toBe(true)
+    expect(numberFilterFn(10, num('is between', [1, 9]))).toBe(false)
+    expect(numberFilterFn(10, num('is not between', [1, 9]))).toBe(true)
+    expect(numberFilterFn(5, num('is not between', [1, 9]))).toBe(false)
+  })
+
+  it('excludes rows with no value', () => {
+    expect(numberFilterFn(null, num('is', [5]))).toBe(false)
+    expect(numberFilterFn(undefined, num('is not', [5]))).toBe(false)
+  })
+
+  it('passes everything on an empty value list', () => {
+    expect(numberFilterFn(5, num('is', []))).toBe(true)
+  })
+
+  // BUG 1
+  it('throws when a between operator does not get exactly two values', () => {
+    expect(() => numberFilterFn(5, num('is between', [1]))).toThrow(
+      /requires exactly two values/,
+    )
+    expect(() => numberFilterFn(5, num('is not between', [1, 2, 3]))).toThrow(
+      /requires exactly two values/,
+    )
+  })
+
+  it('throws when a single operator gets more than one value', () => {
+    expect(() => numberFilterFn(5, num('is', [1, 2]))).toThrow(
+      /takes at most one value/,
+    )
+  })
+})
+
+/* ------------------------------------------------------------------ */
+/* date                                                                */
+/* ------------------------------------------------------------------ */
+
+describe('dateFilterFn', () => {
+  it('compares at day granularity', () => {
+    const noon = new Date(2026, 0, 10, 12, 30)
+    expect(dateFilterFn(noon, date('is', [d(10)]))).toBe(true)
+    expect(dateFilterFn(noon, date('is', [d(11)]))).toBe(false)
+    expect(dateFilterFn(noon, date('is not', [d(11)]))).toBe(true)
+  })
+
+  it('handles before / on or after', () => {
+    const noon = new Date(2026, 0, 10, 12, 30)
+    expect(dateFilterFn(noon, date('is before', [d(11)]))).toBe(true)
+    expect(dateFilterFn(noon, date('is before', [d(10)]))).toBe(false)
+    expect(dateFilterFn(noon, date('is on or after', [d(10)]))).toBe(true)
+    expect(dateFilterFn(noon, date('is on or after', [d(11)]))).toBe(false)
+  })
+
+  it('handles after / on or before, and keeps them complementary', () => {
+    // The source used isAfter(value, startOfDay(d1)) for "is after", so a
+    // later time on the SAME day satisfied both "is after" and "is on or
+    // before". Day-granular comparison makes them exact complements.
+    const noon = new Date(2026, 0, 10, 12, 30)
+    expect(dateFilterFn(noon, date('is after', [d(10)]))).toBe(false)
+    expect(dateFilterFn(noon, date('is on or before', [d(10)]))).toBe(true)
+    expect(dateFilterFn(noon, date('is after', [d(9)]))).toBe(true)
+    expect(dateFilterFn(noon, date('is on or before', [d(9)]))).toBe(false)
+  })
+
+  it('treats between as inclusive of both whole days, order-insensitive', () => {
+    expect(dateFilterFn(d(5), date('is between', [d(1), d(9)]))).toBe(true)
+    expect(dateFilterFn(d(5), date('is between', [d(9), d(1)]))).toBe(true)
+    expect(
+      dateFilterFn(new Date(2026, 0, 9, 23, 59), date('is between', [d(1), d(9)])),
+    ).toBe(true)
+    expect(dateFilterFn(d(10), date('is between', [d(1), d(9)]))).toBe(false)
+    expect(dateFilterFn(d(10), date('is not between', [d(1), d(9)]))).toBe(true)
+    expect(dateFilterFn(d(5), date('is not between', [d(1), d(9)]))).toBe(false)
+  })
+
+  it('excludes rows with no date, and rejects Invalid Date', () => {
+    expect(dateFilterFn(null, date('is', [d(1)]))).toBe(false)
+    expect(dateFilterFn(new Date(Number.NaN), date('is', [d(1)]))).toBe(false)
+  })
+
+  it('passes everything on an empty value list', () => {
+    expect(dateFilterFn(d(1), date('is', []))).toBe(true)
+  })
+
+  // BUG 1 — this is the exact guard the source wrote as
+  //   `filterValue.operator in ['is between', 'is not between']`
+  // `in` on an array tests '0' / '1' / 'length', so it was never true and a
+  // one-value "is between" ran on into an interval with an undefined end.
+  it('throws when "is between" gets one value (the guard the source never fired)', () => {
+    expect(() => dateFilterFn(d(5), date('is between', [d(1)]))).toThrow(
+      /requires exactly two values/,
+    )
+  })
+
+  it('throws when "is not between" gets one value', () => {
+    expect(() => dateFilterFn(d(5), date('is not between', [d(1)]))).toThrow(
+      /requires exactly two values/,
+    )
+  })
+
+  it('throws when a between operator gets three values', () => {
+    expect(() =>
+      dateFilterFn(d(5), date('is between', [d(1), d(2), d(3)])),
+    ).toThrow(/requires exactly two values/)
+  })
+
+  it('throws when a singular operator gets more than one value', () => {
+    expect(() => dateFilterFn(d(5), date('is', [d(1), d(2)]))).toThrow(
+      /takes at most one value/,
+    )
+  })
+})
+
+/* ------------------------------------------------------------------ */
+/* option                                                              */
+/* ------------------------------------------------------------------ */
+
+describe('optionFilterFn', () => {
+  it('handles is / is not', () => {
+    expect(optionFilterFn('high', option('is', ['high']))).toBe(true)
+    expect(optionFilterFn('low', option('is', ['high']))).toBe(false)
+    expect(optionFilterFn('low', option('is not', ['high']))).toBe(true)
+    expect(optionFilterFn('high', option('is not', ['high']))).toBe(false)
+  })
+
+  it('ORs within the column for is any of', () => {
+    expect(optionFilterFn('medium', option('is any of', ['high', 'medium']))).toBe(
+      true,
+    )
+    expect(optionFilterFn('low', option('is any of', ['high', 'medium']))).toBe(
+      false,
+    )
+  })
+
+  it('handles is none of', () => {
+    expect(optionFilterFn('low', option('is none of', ['high', 'medium']))).toBe(
+      true,
+    )
+    expect(optionFilterFn('high', option('is none of', ['high', 'medium']))).toBe(
+      false,
+    )
+  })
+
+  it('matches option values exactly rather than case-folded', () => {
+    // The source lower-cased both sides, silently merging two option values
+    // that differ only by case.
+    expect(optionFilterFn('High', option('is', ['high']))).toBe(false)
+  })
+
+  it('treats a missing value as matching no positive operator and every negated one', () => {
+    expect(optionFilterFn(null, option('is', ['high']))).toBe(false)
+    expect(optionFilterFn(null, option('is any of', ['high']))).toBe(false)
+    expect(optionFilterFn(null, option('is not', ['high']))).toBe(true)
+    expect(optionFilterFn(null, option('is none of', ['high']))).toBe(true)
+  })
+
+  it('passes everything on an empty value list', () => {
+    expect(optionFilterFn('high', option('is any of', []))).toBe(true)
+  })
+})
+
+/* ------------------------------------------------------------------ */
+/* multiOption                                                         */
+/* ------------------------------------------------------------------ */
+
+describe('multiOptionFilterFn', () => {
+  const labels = ['bug', 'ui']
+
+  it('handles include / include any of as an OR', () => {
+    expect(multiOptionFilterFn(labels, multi('include', ['bug']))).toBe(true)
+    expect(multiOptionFilterFn(labels, multi('include', ['perf']))).toBe(false)
+    expect(
+      multiOptionFilterFn(labels, multi('include any of', ['perf', 'ui'])),
+    ).toBe(true)
+  })
+
+  it('handles include all of as an AND', () => {
+    expect(
+      multiOptionFilterFn(labels, multi('include all of', ['bug', 'ui'])),
+    ).toBe(true)
+    expect(
+      multiOptionFilterFn(labels, multi('include all of', ['bug', 'perf'])),
+    ).toBe(false)
+  })
+
+  it('handles exclude and exclude if any of', () => {
+    expect(multiOptionFilterFn(labels, multi('exclude', ['perf']))).toBe(true)
+    expect(multiOptionFilterFn(labels, multi('exclude', ['bug']))).toBe(false)
+    expect(
+      multiOptionFilterFn(labels, multi('exclude if any of', ['perf', 'bug'])),
+    ).toBe(false)
+    expect(
+      multiOptionFilterFn(labels, multi('exclude if any of', ['perf'])),
+    ).toBe(true)
+  })
+
+  it('handles exclude if all', () => {
+    expect(
+      multiOptionFilterFn(labels, multi('exclude if all', ['bug', 'ui'])),
+    ).toBe(false)
+    expect(
+      multiOptionFilterFn(labels, multi('exclude if all', ['bug', 'perf'])),
+    ).toBe(true)
+  })
+
+  it('treats a missing list as empty', () => {
+    expect(multiOptionFilterFn(null, multi('include', ['bug']))).toBe(false)
+    expect(multiOptionFilterFn(null, multi('exclude', ['bug']))).toBe(true)
+  })
+
+  it('passes everything on an empty value list', () => {
+    expect(multiOptionFilterFn(labels, multi('include any of', []))).toBe(true)
+  })
+})
+
+/* ------------------------------------------------------------------ */
+/* combinator                                                          */
+/* ------------------------------------------------------------------ */
+
+const rows: Task[] = [
+  task({ id: 'a', title: 'Ship board', points: 3, due: d(5), priority: 'high', labels: ['bug'] }),
+  task({ id: 'b', title: 'Rail stub', points: 8, due: d(12), priority: 'low', labels: ['ui'] }),
+  task({ id: 'c', title: 'Facet panel', points: 5, due: d(20), priority: 'high', labels: ['ui', 'perf'] }),
+  task({ id: 'd', title: 'Untriaged' }),
+]
+
+const ids = (result: readonly Task[]): string[] => result.map((t) => t.id)
+
+describe('filterRows', () => {
+  it('returns every row when there are no filters', () => {
+    expect(ids(filterRows(rows, columns, []))).toEqual(['a', 'b', 'c', 'd'])
+  })
+
+  it('does not hand back the caller its own array', () => {
+    const out = filterRows(rows, columns, [])
+    expect(out).not.toBe(rows)
+    expect(out).toEqual(rows)
+  })
+
+  it('ANDs across columns', () => {
+    const state: FiltersState = [option('is', ['high']), num('is greater than', [4])]
+    expect(ids(filterRows(rows, columns, state))).toEqual(['c'])
+  })
+
+  it('ORs within a column via is any of', () => {
+    expect(
+      ids(filterRows(rows, columns, [option('is any of', ['high', 'low'])])),
+    ).toEqual(['a', 'b', 'c'])
+  })
+
+  it('ANDs within a column via include all of', () => {
+    expect(
+      ids(filterRows(rows, columns, [multi('include all of', ['ui', 'perf'])])),
+    ).toEqual(['c'])
+    expect(
+      ids(filterRows(rows, columns, [multi('include any of', ['ui', 'perf'])])),
+    ).toEqual(['b', 'c'])
+  })
+
+  // BUG 2 — the source's combinator had no case for text/number/date and fell
+  // through to `return true`, so each of these three would return every row.
+  it('actually filters a text column', () => {
+    expect(ids(filterRows(rows, columns, [text('contains', ['rail'])]))).toEqual([
+      'b',
+    ])
+  })
+
+  it('actually filters a number column', () => {
+    expect(
+      ids(filterRows(rows, columns, [num('is less than', [6])])),
+    ).toEqual(['a', 'c'])
+  })
+
+  it('actually filters a date column', () => {
+    expect(
+      ids(filterRows(rows, columns, [date('is before', [d(15)])])),
+    ).toEqual(['a', 'b'])
+    expect(
+      ids(filterRows(rows, columns, [date('is between', [d(1), d(15)])])),
+    ).toEqual(['a', 'b'])
+  })
+
+  it('ignores a filter whose column is not in the set', () => {
+    const stale: FiltersState = [
+      { columnId: 'gone', type: 'option', operator: 'is', values: ['x'] },
+    ]
+    expect(ids(filterRows(rows, columns, stale))).toEqual(['a', 'b', 'c', 'd'])
+  })
+
+  it('ignores a filter whose type disagrees with its column', () => {
+    const tampered: FiltersState = [
+      { columnId: 'priority', type: 'text', operator: 'contains', values: ['q'] },
+    ]
+    expect(ids(filterRows(rows, columns, tampered))).toEqual(['a', 'b', 'c', 'd'])
+  })
+
+  it('applies only the first filter when a column is listed twice', () => {
+    const duplicated: FiltersState = [
+      option('is', ['high']),
+      option('is', ['low']),
+    ]
+    expect(ids(filterRows(rows, columns, duplicated))).toEqual(['a', 'c'])
+  })
+})
+
+describe('pruneFilters', () => {
+  it('drops unknown columns, type mismatches and duplicates', () => {
+    const state: FiltersState = [
+      option('is', ['high']),
+      { columnId: 'gone', type: 'option', operator: 'is', values: ['x'] },
+      { columnId: 'priority', type: 'number', operator: 'is', values: [1] },
+      option('is', ['low']),
+    ]
+    const pruned = pruneFilters(state, columns)
+    expect(pruned).toHaveLength(1)
+    expect(pruned[0]?.values).toEqual(['high'])
+  })
+})
+
+describe('rowMatchesFilter', () => {
+  function columnById(id: string): AnyColumnConfig<Task> {
+    const column = columns.find((candidate) => candidate.id === id)
+    if (!column) throw new Error(`no column ${id}`)
+    return column
+  }
+
+  it('throws when a filter type disagrees with its column type', () => {
+    const row = rows[0]
+    if (!row) throw new Error('fixture missing')
+    expect(() =>
+      rowMatchesFilter(row, columnById('priority'), text('contains', ['x'])),
+    ).toThrow(/is typed "text" but the column is "option"/)
+  })
+})