97 lines
4.6 KiB
JavaScript
97 lines
4.6 KiB
JavaScript
// Generated, do not edit. sha256:455789d5a2acadd3972e4561a3135c6234ab395e2d111780c60328e8b4850468
|
|
import { describe, it } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { initialState, chooseGroup, revealGroup } from '../../client/ui/table-state.js';
|
|
|
|
const columns = [
|
|
{ key: 'name' },
|
|
{ key: 'kind', group: { value: r => r.kind } },
|
|
{ key: 'place', group: { value: r => r.place } },
|
|
{ key: 'year', group: { value: r => r.year } },
|
|
];
|
|
|
|
describe('initialState', () => {
|
|
it('without stored state: no sort, no grouping, empty maps, no sticky', () => {
|
|
assert.deepEqual(initialState({ columns }), {
|
|
sort: null, groupKey: null, groupKey2: null, groupKey3: null, groupFilter: {}, groupCollapsed: {}, sticky: null,
|
|
});
|
|
});
|
|
|
|
it('a stored sort on a column that is gone falls back on defaultSort, and that one is checked too', () => {
|
|
assert.deepEqual(initialState({ columns, sort: { key: 'gone', dir: 'asc' }, defaultSort: { key: 'name', dir: 'desc' } }).sort, { key: 'name', dir: 'desc' });
|
|
assert.equal(initialState({ columns, sort: { key: 'gone' }, defaultSort: { key: 'also-gone' } }).sort, null);
|
|
});
|
|
|
|
it('a stored group on a column that is gone or cannot group is ignored, per level', () => {
|
|
const s = initialState({ columns, group: 'name', group2: 'gone', group3: 'year' });
|
|
assert.equal(s.groupKey, null);
|
|
assert.equal(s.groupKey2, null);
|
|
assert.equal(s.groupKey3, 'year');
|
|
});
|
|
|
|
it('copies what it takes, so the configuration is never changed through the state', () => {
|
|
const cfg = { columns, sort: { key: 'name', dir: 'asc' }, groupFilter: { kind: ['a'] }, groupCollapsed: { kind: ['b'] }, sticky: { name: 'x' } };
|
|
const s = initialState(cfg);
|
|
s.sort.dir = 'desc';
|
|
s.groupFilter.kind = [];
|
|
s.groupCollapsed.place = ['p'];
|
|
s.sticky.name = 'y';
|
|
assert.deepEqual(cfg.sort, { key: 'name', dir: 'asc' });
|
|
assert.deepEqual(cfg.groupFilter, { kind: ['a'] });
|
|
assert.deepEqual(cfg.groupCollapsed, { kind: ['b'] });
|
|
assert.deepEqual(cfg.sticky, { name: 'x' });
|
|
});
|
|
});
|
|
|
|
describe('chooseGroup', () => {
|
|
const all = { groupKey: 'kind', groupKey2: 'place', groupKey3: 'year' };
|
|
|
|
it('level 1 to none drops the deeper levels', () => {
|
|
assert.deepEqual(chooseGroup(all, 1, ''), { groupKey: null, groupKey2: null, groupKey3: null });
|
|
assert.deepEqual(chooseGroup(all, 1, null), { groupKey: null, groupKey2: null, groupKey3: null });
|
|
});
|
|
|
|
it('level 1 onto a column used deeper takes it from that level, and keeps the other', () => {
|
|
assert.deepEqual(chooseGroup(all, 1, 'place'), { groupKey: 'place', groupKey2: null, groupKey3: 'year' });
|
|
assert.deepEqual(chooseGroup(all, 1, 'year'), { groupKey: 'year', groupKey2: 'place', groupKey3: null });
|
|
});
|
|
|
|
it('level 2 to none drops level 3; level 2 onto level 3 clears level 3', () => {
|
|
assert.deepEqual(chooseGroup(all, 2, ''), { groupKey: 'kind', groupKey2: null, groupKey3: null });
|
|
assert.deepEqual(chooseGroup(all, 2, 'year'), { groupKey: 'kind', groupKey2: 'year', groupKey3: null });
|
|
});
|
|
|
|
it('level 3 only sets level 3, and the input is not modified', () => {
|
|
const keys = { ...all };
|
|
assert.deepEqual(chooseGroup(keys, 3, ''), { groupKey: 'kind', groupKey2: 'place', groupKey3: null });
|
|
assert.deepEqual(keys, all);
|
|
});
|
|
});
|
|
|
|
describe('revealGroup', () => {
|
|
it('takes the token out of the filter AND unfolds it, and says it changed', () => {
|
|
const r = revealGroup({ groupKey: 'kind', groupFilter: { kind: ['a', 'b'] }, groupCollapsed: { kind: ['a'] } }, 'a');
|
|
assert.deepEqual(r, { groupFilter: { kind: ['b'] }, groupCollapsed: { kind: [] }, changed: true });
|
|
});
|
|
|
|
it('only collapsed, or only hidden, is a change too', () => {
|
|
assert.equal(revealGroup({ groupKey: 'kind', groupFilter: {}, groupCollapsed: { kind: ['a'] } }, 'a').changed, true);
|
|
assert.equal(revealGroup({ groupKey: 'kind', groupFilter: { kind: ['a'] }, groupCollapsed: {} }, 'a').changed, true);
|
|
});
|
|
|
|
it('a visible group, or no grouping at all, changes nothing and returns the same maps', () => {
|
|
const groupFilter = { kind: ['b'] };
|
|
const groupCollapsed = {};
|
|
const r = revealGroup({ groupKey: 'kind', groupFilter, groupCollapsed }, 'a');
|
|
assert.equal(r.changed, false);
|
|
assert.equal(r.groupFilter, groupFilter);
|
|
assert.equal(revealGroup({ groupKey: null, groupFilter: { kind: ['a'] }, groupCollapsed: {} }, 'a').changed, false);
|
|
});
|
|
|
|
it('does not modify the maps it was given', () => {
|
|
const groupFilter = { kind: ['a'], place: ['x'] };
|
|
revealGroup({ groupKey: 'kind', groupFilter, groupCollapsed: {} }, 'a');
|
|
assert.deepEqual(groupFilter, { kind: ['a'], place: ['x'] });
|
|
});
|
|
});
|