@lovett/ui 0.0.11 → 0.2.0

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

@@ -0,0 +1,193 @@
+/**
+ * Faceted counts.
+ *
+ * BUG 3 — the source computed counts inside a `useMemo` with an EMPTY
+ * dependency array (filter-value.tsx:481-489), so they froze at popover
+ * mount and disagreed with the board from the first filter onwards. These
+ * are pure functions of the rows passed in, so the same call with different
+ * rows must give different answers.
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  defineColumns,
+  facetedCounts,
+  facetedMinMax,
+  facetedRowsFor,
+  filterRows,
+} from '../index'
+import type { AnyColumnConfig, FiltersState } from '../index'
+
+interface Task {
+  readonly id: string
+  readonly priority: string | null
+  readonly labels: readonly string[]
+  readonly points: number | null
+}
+
+const columns = defineColumns<Task>([
+  {
+    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' },
+    ],
+  },
+  {
+    id: 'points',
+    type: 'number',
+    displayName: 'Points',
+    accessor: (t) => t.points,
+  },
+])
+
+function columnById(id: string): AnyColumnConfig<Task> {
+  const column = columns.find((candidate) => candidate.id === id)
+  if (!column) throw new Error(`no column ${id}`)
+  return column
+}
+
+const rows: Task[] = [
+  { id: 'a', priority: 'high', labels: ['bug'], points: 3 },
+  { id: 'b', priority: 'high', labels: ['ui', 'bug'], points: 8 },
+  { id: 'c', priority: 'low', labels: [], points: null },
+  { id: 'd', priority: null, labels: ['ui'], points: 5 },
+]
+
+describe('facetedCounts', () => {
+  it('counts option values', () => {
+    const counts = facetedCounts(rows, columnById('priority'))
+    expect(counts.get('high')).toBe(2)
+    expect(counts.get('low')).toBe(1)
+  })
+
+  it('keeps declared options with no rows as zero buckets', () => {
+    const counts = facetedCounts(rows, columnById('priority'))
+    expect(counts.has('medium')).toBe(true)
+    expect(counts.get('medium')).toBe(0)
+  })
+
+  it('lists declared options first, in declaration order', () => {
+    const counts = facetedCounts(rows, columnById('priority'))
+    expect([...counts.keys()]).toEqual(['low', 'medium', 'high'])
+  })
+
+  it('ignores rows with no value rather than inventing a bucket', () => {
+    const counts = facetedCounts(rows, columnById('priority'))
+    const total = [...counts.values()].reduce((sum, n) => sum + n, 0)
+    expect(total).toBe(3)
+  })
+
+  it('counts each member of a multiOption column', () => {
+    const counts = facetedCounts(rows, columnById('labels'))
+    expect(counts.get('bug')).toBe(2)
+    expect(counts.get('ui')).toBe(2)
+    expect(counts.get('perf')).toBe(0)
+  })
+
+  it('counts a row once per distinct value, not once per occurrence', () => {
+    const duplicated: Task[] = [
+      { id: 'x', priority: null, labels: ['bug', 'bug'], points: null },
+    ]
+    expect(facetedCounts(duplicated, columnById('labels')).get('bug')).toBe(1)
+  })
+
+  it('appends an undeclared value found in the data', () => {
+    const extra: Task[] = [
+      { id: 'x', priority: 'urgent', labels: [], points: null },
+    ]
+    const counts = facetedCounts(extra, columnById('priority'))
+    expect([...counts.keys()]).toEqual(['low', 'medium', 'high', 'urgent'])
+    expect(counts.get('urgent')).toBe(1)
+  })
+
+  it('throws for a column type with no facets', () => {
+    expect(() => facetedCounts(rows, columnById('points'))).toThrow(
+      /only defined for option and multiOption/,
+    )
+  })
+
+  // BUG 3
+  it('recomputes from the rows it is given, so counts cannot go stale', () => {
+    const priority = columnById('priority')
+    const before = facetedCounts(rows, priority)
+    expect(before.get('high')).toBe(2)
+
+    const narrowed = filterRows(rows, columns, [
+      { columnId: 'labels', type: 'multiOption', operator: 'include', values: ['ui'] },
+    ])
+    const after = facetedCounts(narrowed, priority)
+
+    expect(after.get('high')).toBe(1)
+    // And the first result was not mutated by the second call.
+    expect(before.get('high')).toBe(2)
+  })
+})
+
+describe('facetedRowsFor', () => {
+  const state: FiltersState = [
+    { columnId: 'priority', type: 'option', operator: 'is', values: ['high'] },
+    { columnId: 'labels', type: 'multiOption', operator: 'include', values: ['ui'] },
+  ]
+
+  it('excludes the column its own facet list is for', () => {
+    // Without this, picking "high" would zero every other priority bucket and
+    // the list could never be widened.
+    const forPriority = facetedRowsFor(rows, columns, state, 'priority')
+    expect(forPriority.map((t) => t.id)).toEqual(['b', 'd'])
+    const counts = facetedCounts(forPriority, columnById('priority'))
+    expect(counts.get('high')).toBe(1)
+    expect(counts.get('low')).toBe(0)
+  })
+
+  it('still applies every other column filter', () => {
+    const forLabels = facetedRowsFor(rows, columns, state, 'labels')
+    expect(forLabels.map((t) => t.id)).toEqual(['a', 'b'])
+  })
+})
+
+describe('facetedMinMax', () => {
+  it('reports the observed range', () => {
+    expect(facetedMinMax(rows, columnById('points'))).toEqual([3, 8])
+  })
+
+  it('returns null when no row has a value', () => {
+    expect(facetedMinMax([], columnById('points'))).toBeNull()
+  })
+
+  it('prefers declared bounds over observed ones', () => {
+    const bounded = defineColumns<Task>([
+      {
+        id: 'points',
+        type: 'number',
+        displayName: 'Points',
+        accessor: (t) => t.points,
+        min: 0,
+        max: 100,
+      },
+    ])
+    const column = bounded[0]
+    if (!column) throw new Error('fixture missing')
+    expect(facetedMinMax(rows, column)).toEqual([0, 100])
+  })
+
+  it('throws for a non-number column', () => {
+    expect(() => facetedMinMax(rows, columnById('priority'))).toThrow(
+      /only defined for number columns/,
+    )
+  })
+})