test: add lots of missing utils tests

Author: KevinVandy

packages/table-core/tests/unit/core/cells/coreCellsFeature.utils.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest'
+import { constructTable } from '../../../../src'
+import {
+  cell_getContext,
+  cell_getValue,
+  cell_renderValue,
+} from '../../../../src/static-functions'
+import { testFeatures } from '../../../fixtures/features'
+import type { ColumnDef } from '../../../../src'
+
+type Person = {
+  firstName: string
+  nickname: string | null
+}
+
+const features = testFeatures({})
+
+const columns: Array<ColumnDef<typeof features, Person, any>> = [
+  { accessorKey: 'firstName', id: 'firstName' },
+  { accessorKey: 'nickname', id: 'nickname' },
+]
+
+function makeTable() {
+  return constructTable<typeof features, Person>({
+    features,
+    columns,
+    data: [{ firstName: 'Tanner', nickname: null }],
+    renderFallbackValue: 'N/A',
+  })
+}
+
+function getCell(columnId: string) {
+  const table = makeTable()
+  const row = table.getRowModel().rows[0]!
+  return row.getAllCellsByColumnId()[columnId]!
+}
+
+describe('cell_getValue', () => {
+  it('should read the accessor value for the cell', () => {
+    expect(cell_getValue(getCell('firstName'))).toBe('Tanner')
+  })
+})
+
+describe('cell_renderValue', () => {
+  it('should return the accessor value when present', () => {
+    expect(cell_renderValue(getCell('firstName'))).toBe('Tanner')
+  })
+
+  it('should fall back to renderFallbackValue for nullish values', () => {
+    expect(cell_renderValue(getCell('nickname'))).toBe('N/A')
+  })
+})
+
+describe('cell_getContext', () => {
+  it('should expose the table, column, row, and cell with bound value helpers', () => {
+    const table = makeTable()
+    const row = table.getRowModel().rows[0]!
+    const cell = row.getAllCellsByColumnId()['firstName']!
+
+    const context = cell_getContext(cell)
+
+    expect(context.table).toBe(cell.table)
+    expect(context.column).toBe(cell.column)
+    expect(context.row).toBe(row)
+    expect(context.cell).toBe(cell)
+    expect(context.getValue()).toBe('Tanner')
+    expect(context.renderValue()).toBe('Tanner')
+  })
+})

packages/table-core/tests/unit/core/columns/coreColumnsFeature.utils.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, it } from 'vitest'
+import { constructTable } from '../../../../src'
+import {
+  column_getFlatColumns,
+  column_getLeafColumns,
+  table_getAllColumns,
+  table_getAllFlatColumns,
+  table_getAllFlatColumnsById,
+  table_getAllLeafColumns,
+  table_getAllLeafColumnsById,
+  table_getColumn,
+  table_getDefaultColumnDef,
+} from '../../../../src/static-functions'
+import { testFeatures } from '../../../fixtures/features'
+import type { ColumnDef } from '../../../../src'
+
+type Item = {
+  a: string
+  b: string
+  c: string
+}
+
+const features = testFeatures({})
+
+const columns: Array<ColumnDef<typeof features, Item, any>> = [
+  {
+    id: 'group',
+    header: 'Group',
+    columns: [
+      { accessorKey: 'a', id: 'a' },
+      { accessorKey: 'b', id: 'b' },
+    ],
+  },
+  { accessorKey: 'c', id: 'c' },
+]
+
+const data: Array<Item> = [{ a: 'a1', b: 'b1', c: 'c1' }]
+
+function makeTable() {
+  return constructTable<typeof features, Item>({
+    features,
+    columns,
+    data,
+  })
+}
+
+describe('table_getAllColumns', () => {
+  it('should build the nested column tree from column defs', () => {
+    const table = makeTable()
+    const allColumns = table_getAllColumns(table)
+
+    expect(allColumns.map((column) => column.id)).toEqual(['group', 'c'])
+    expect(allColumns[0]!.columns.map((column) => column.id)).toEqual([
+      'a',
+      'b',
+    ])
+    expect(allColumns[0]!.columns[0]!.parent?.id).toBe('group')
+    expect(allColumns[0]!.columns[0]!.depth).toBe(1)
+  })
+})
+
+describe('column_getFlatColumns', () => {
+  it('should flatten a group column with itself first', () => {
+    const table = makeTable()
+    const groupColumn = table.getColumn('group')!
+
+    expect(
+      column_getFlatColumns(groupColumn).map((column) => column.id),
+    ).toEqual(['group', 'a', 'b'])
+  })
+
+  it('should return only itself for a leaf column', () => {
+    const table = makeTable()
+    const leafColumn = table.getColumn('c')!
+
+    expect(
+      column_getFlatColumns(leafColumn).map((column) => column.id),
+    ).toEqual(['c'])
+  })
+})
+
+describe('column_getLeafColumns', () => {
+  it('should return the descendants of a group column', () => {
+    const table = makeTable()
+    const groupColumn = table.getColumn('group')!
+
+    expect(
+      column_getLeafColumns(groupColumn).map((column) => column.id),
+    ).toEqual(['a', 'b'])
+  })
+
+  it('should return only itself for a leaf column', () => {
+    const table = makeTable()
+    const leafColumn = table.getColumn('c')!
+
+    expect(
+      column_getLeafColumns(leafColumn).map((column) => column.id),
+    ).toEqual(['c'])
+  })
+})
+
+describe('table_getAllFlatColumns / table_getAllFlatColumnsById', () => {
+  it('should include group and leaf columns', () => {
+    const table = makeTable()
+
+    expect(table_getAllFlatColumns(table).map((column) => column.id)).toEqual([
+      'group',
+      'a',
+      'b',
+      'c',
+    ])
+
+    const byId = table_getAllFlatColumnsById(table)
+    expect(Object.keys(byId)).toEqual(['group', 'a', 'b', 'c'])
+    expect(byId['a']!.id).toBe('a')
+  })
+})
+
+describe('table_getAllLeafColumns / table_getAllLeafColumnsById', () => {
+  it('should exclude group columns', () => {
+    const table = makeTable()
+
+    expect(table_getAllLeafColumns(table).map((column) => column.id)).toEqual([
+      'a',
+      'b',
+      'c',
+    ])
+
+    const byId = table_getAllLeafColumnsById(table)
+    expect(Object.keys(byId)).toEqual(['a', 'b', 'c'])
+    expect(byId['group']).toBeUndefined()
+  })
+})
+
+describe('table_getColumn', () => {
+  it('should find group and leaf columns by id', () => {
+    const table = makeTable()
+
+    expect(table_getColumn(table, 'group')?.id).toBe('group')
+    expect(table_getColumn(table, 'b')?.id).toBe('b')
+  })
+
+  it('should return undefined for unknown column ids', () => {
+    const table = makeTable()
+
+    expect(table_getColumn(table, 'missing')).toBeUndefined()
+  })
+})
+
+describe('table_getDefaultColumnDef', () => {
+  it('should render accessor keys as the default header', () => {
+    const table = makeTable()
+    const defaultColumnDef = table_getDefaultColumnDef(table)
+
+    const header = defaultColumnDef.header as (props: any) => unknown
+    expect(
+      header({ header: { column: { columnDef: { accessorKey: 'a' } } } }),
+    ).toBe('a')
+    expect(
+      header({
+        header: {
+          column: { columnDef: { accessorFn: () => 1, id: 'fn-col' } },
+        },
+      }),
+    ).toBe('fn-col')
+    expect(header({ header: { column: { columnDef: {} } } })).toBeNull()
+  })
+
+  it('should stringify values in the default cell renderer', () => {
+    const table = makeTable()
+    const defaultColumnDef = table_getDefaultColumnDef(table)
+
+    const cell = defaultColumnDef.cell as (props: any) => unknown
+    expect(cell({ renderValue: () => 42 })).toBe('42')
+    expect(cell({ renderValue: () => null })).toBeNull()
+  })
+
+  it('should let options.defaultColumn win', () => {
+    const table = constructTable<typeof features, Item>({
+      features,
+      columns,
+      data,
+      defaultColumn: { header: 'custom header' },
+    })
+
+    expect(table_getDefaultColumnDef(table).header).toBe('custom header')
+  })
+})

packages/table-core/tests/unit/core/headers/coreHeadersFeature.utils.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest'
+import {
+  columnPinningFeature,
+  columnVisibilityFeature,
+  constructTable,
+} from '../../../../src'
+import {
+  header_getContext,
+  header_getLeafHeaders,
+  table_getHeaderGroups,
+  table_getLeafHeaders,
+} from '../../../../src/static-functions'
+import { testFeatures } from '../../../fixtures/features'
+import type { ColumnDef, Table, TableOptions } from '../../../../src'
+
+type Item = {
+  a: string
+  b: string
+  c: string
+}
+
+const features = testFeatures({
+  columnPinningFeature,
+  columnVisibilityFeature,
+})
+
+const columns: Array<ColumnDef<typeof features, Item, any>> = [
+  {
+    id: 'group',
+    header: 'Group',
+    columns: [
+      { accessorKey: 'a', id: 'a' },
+      { accessorKey: 'b', id: 'b' },
+    ],
+  },
+  { accessorKey: 'c', id: 'c' },
+]
+
+const data: Array<Item> = [{ a: 'a1', b: 'b1', c: 'c1' }]
+
+function makeTable(
+  options?: Partial<
+    Omit<TableOptions<typeof features, Item>, 'data' | 'columns' | 'features'>
+  >,
+): Table<typeof features, Item> {
+  return constructTable({
+    features,
+    columns,
+    data,
+    ...options,
+  })
+}
+
+describe('table_getHeaderGroups', () => {
+  it('should build one group per column depth', () => {
+    const table = makeTable()
+    const headerGroups = table_getHeaderGroups(table)
+
+    expect(headerGroups).toHaveLength(2)
+    expect(headerGroups[1]!.headers.map((header) => header.column.id)).toEqual([
+      'a',
+      'b',
+      'c',
+    ])
+  })
+
+  it('should order pinned columns first via the pin partitioning path', () => {
+    const table = makeTable({
+      initialState: { columnPinning: { left: ['c'], right: [] } },
+    })
+    const headerGroups = table_getHeaderGroups(table)
+
+    expect(headerGroups[1]!.headers.map((header) => header.column.id)).toEqual([
+      'c',
+      'a',
+      'b',
+    ])
+  })
+
+  it('should exclude hidden columns', () => {
+    const table = makeTable({
+      initialState: { columnVisibility: { b: false } },
+    })
+    const headerGroups = table_getHeaderGroups(table)
+
+    expect(headerGroups[1]!.headers.map((header) => header.column.id)).toEqual([
+      'a',
+      'c',
+    ])
+  })
+})
+
+describe('header_getLeafHeaders', () => {
+  it('should collect descendant leaf headers before the header itself', () => {
+    const table = makeTable()
+    const groupHeader = table_getHeaderGroups(table)[0]!.headers.find(
+      (header) => header.column.id === 'group',
+    )!
+
+    const leafHeaders = header_getLeafHeaders(groupHeader)
+
+    expect(leafHeaders.map((header) => header.column.id)).toEqual([
+      'a',
+      'b',
+      'group',
+    ])
+  })
+
+  it('should return only itself for a leaf header', () => {
+    const table = makeTable()
+    const leafHeader = table_getHeaderGroups(table)[1]!.headers.find(
+      (header) => header.column.id === 'a',
+    )!
+
+    expect(header_getLeafHeaders(leafHeader)).toEqual([leafHeader])
+  })
+})
+
+describe('header_getContext', () => {
+  it('should expose the header, column, and table', () => {
+    const table = makeTable()
+    const header = table_getHeaderGroups(table)[1]!.headers[0]!
+
+    const context = header_getContext(header)
+
+    expect(context.header).toBe(header)
+    expect(context.column).toBe(header.column)
+    expect(context.table).toBe(header.column.table)
+  })
+})
+
+describe('table_getLeafHeaders', () => {
+  it('should collect the leaf headers reachable from the top header row', () => {
+    const table = makeTable()
+    const ids = table_getLeafHeaders(table).map((header) => header.column.id)
+
+    expect(ids).toEqual(expect.arrayContaining(['a', 'b', 'c']))
+  })
+})