Debian Codegraph @

tests/js/transformStateManager.test.ts

raw
1 import { TransformStateManager } from '../../js/core/transformStateManager';
2 import { Transform } from '../../js/core/transform';
3 import { DataGenerator } from './testUtils';
4 import { View } from '../../js/core/view';
5
6 describe('Test .add()', () => {
7 const testCases: Transform.TransformSpec[] = [
8 { type: 'sort', column: 'test', desc: true },
9 { type: 'filter', column: 'test', operator: '<', value: 5 },
10 ];
11 testCases.forEach((testCase) => {
12 test(`State is update: ${testCase.type}-${testCase.columnIndex}`, () => {
13 const tsm = new TransformStateManager();
14 tsm.add(testCase);
15 expect(tsm.activeTransforms[0]).toBe(testCase);
16 });
17 });
18 test('Only allow one sort transform', () => {
19 const tsm = new TransformStateManager();
20 const transform1 = Private.simpleSort();
21 const transform2: Transform.Sort = {
22 type: 'sort',
23 column: 'test2',
24 desc: true,
25 };
26 tsm.add(transform1);
27 tsm.add(transform2);
28 // @ts-ignore
29 expect(tsm._state[transform1.column][transform1.type]).toBeUndefined();
30 });
31 test('Clear state on error', () => {
32 const tsm = new TransformStateManager();
33 const transform = Private.simpleSort();
34 const invalidTransform = {
35 type: 'bad',
36 columnIndex: 0,
37 desc: true,
38 };
39 tsm.add(transform);
40 // @ts-ignore
41 tsm.add(invalidTransform);
42 expect(tsm.activeTransforms.length).toBe(0);
43 });
44 test('Test that signal is emitted', () => {
45 const tsm = new TransformStateManager();
46 // @ts-ignore
47 const mock = jest.spyOn(tsm._changed, 'emit');
48 expect(mock).toBeCalledTimes(0);
49 const transform = Private.simpleSort();
50 tsm.add(transform);
51 expect(mock).toBeCalledTimes(1);
52 });
53 });
54
55 describe('Test .replace()', () => {
56 test('Bail on no change', () => {
57 const tsm = new TransformStateManager();
58 const state = Private.simpleState();
59 tsm.replace([state.sort!, state.filter!]);
60 // @ts-ignore
61 const mock = jest.spyOn(tsm._changed, 'emit');
62 tsm.replace([state.sort!, state.filter!]);
63
64 // Testing that no signal was emitted
65 expect(mock).toBeCalledTimes(0);
66 });
67 test('State updated', () => {
68 const tsm = new TransformStateManager();
69 const state = Private.simpleState();
70 const transform3: Transform.TransformSpec = {
71 type: 'filter',
72 column: 'test',
73 operator: '=',
74 value: 765,
75 };
76
77 tsm.add(transform3);
78 tsm.replace([state.sort!, state.filter!]);
79 expect(tsm.activeTransforms).toEqual([state.sort!, state.filter!]);
80 });
81 test('Clear on error', () => {
82 const tsm = new TransformStateManager();
83 const state = Private.simpleState();
84 // @ts-ignore
85 tsm.replace([state.sort!, state.filter!, {}]);
86 expect(tsm.activeTransforms).toEqual([]);
87 });
88 });
89
90 describe('Test .createView()', () => {
91 test('View() is returned', () => {
92 const data = DataGenerator.singleCol({
93 name: 'test',
94 type: 'number',
95 data: [1, 2, 3],
96 });
97 const tsm = new TransformStateManager();
98 const view = tsm.createView(data.data);
99 expect(view).toBeInstanceOf(View);
100 });
101 test('View() has transformed data - filter', () => {
102 const data = DataGenerator.singleCol({
103 name: 'test',
104 type: 'number',
105 data: [-1, -2, 6, 7],
106 });
107 const tsm = new TransformStateManager();
108 const transform = Private.simpleFilter();
109 tsm.add(transform);
110 const view = tsm.createView(data.data);
111 const testData = view.dataset.data['test'];
112 expect(testData).toEqual([-1, -2]);
113 });
114 test('View() has transformed data - sort', () => {
115 const data = DataGenerator.singleCol({
116 name: 'test',
117 type: 'number',
118 data: [3, 2, 4, 7],
119 });
120 const tsm = new TransformStateManager();
121 const transform = Private.simpleSort();
122 tsm.add(transform);
123 const view = tsm.createView(data.data);
124 const testData = view.dataset.data['test'];
125 expect(testData).toEqual([7, 4, 3, 2]);
126 });
127 });
128
129 describe('Test .remove()', () => {
130 test('Remove sort transform', () => {
131 const state = Private.simpleState();
132 const tsm = new TransformStateManager();
133 tsm.replace([state.sort!, state.filter!]);
134 tsm.remove(state.filter!.column, state.filter!.type);
135 expect(tsm.activeTransforms).toEqual([state.sort]);
136 });
137 test('Remove filter transform', () => {
138 const state = Private.simpleState();
139 const tsm = new TransformStateManager();
140 tsm.replace([state.sort!, state.filter!]);
141 tsm.remove(state.filter!.column, state.filter!.type);
142 expect(tsm.activeTransforms).toEqual([state.sort]);
143 });
144 test('State cleared after error', () => {
145 const state = Private.simpleState();
146 const tsm = new TransformStateManager();
147 tsm.replace([state.sort!, state.filter!]);
148 tsm.remove(state.filter!.column, 'transformThatDoesntExist');
149 expect(tsm.activeTransforms).toEqual([]);
150 });
151 test('State entry cleared if no sort or filter', () => {
152 const transform1 = Private.simpleSort();
153 const tsm = new TransformStateManager();
154 tsm.add(transform1);
155 tsm.remove(transform1.column, transform1.type);
156 // @ts-ignore
157 expect(tsm._state[transform1.column]).toBeUndefined();
158 });
159 test('No state change on invalid column', () => {
160 const state = Private.simpleState();
161 const tsm = new TransformStateManager();
162 tsm.replace([state.sort!, state.filter!]);
163 tsm.remove(state.filter!.column + 1, state.filter!.type);
164 expect(tsm.activeTransforms).toEqual([state.sort!, state.filter!]);
165 });
166 });
167
168 describe('Test .metadata()', () => {
169 test('Get metadata for column - sort', () => {
170 const transform1 = Private.simpleSort();
171 const tsm = new TransformStateManager();
172 tsm.add(transform1);
173 const test = { filter: undefined, sort: transform1 };
174 expect(tsm.metadata(transform1.column)).toEqual(test);
175 expect(tsm.metadata(transform1.column + 1)).toBeUndefined();
176 });
177 test('Get metadata for column - filter', () => {
178 const transform1 = Private.simpleFilter();
179 const tsm = new TransformStateManager();
180 tsm.add(transform1);
181 const test = { filter: transform1, sort: undefined };
182 expect(tsm.metadata(transform1.column)).toEqual(test);
183 expect(tsm.metadata(transform1.column + 1)).toBeUndefined();
184 });
185 });
186
187 describe('Test .clear()', () => {
188 test('State is cleared', () => {
189 const state = Private.simpleState();
190 const tsm = new TransformStateManager();
191 tsm.replace([state.sort!, state.filter!]);
192 tsm.clear();
193 expect(tsm.activeTransforms).toEqual([]);
194 });
195 });
196
197 describe('Test .changed()', () => {
198 test('Returns signal', () => {
199 const tsm = new TransformStateManager();
200 expect(tsm.changed).toHaveProperty('connect');
201 expect(tsm.changed).toHaveProperty('disconnect');
202 });
203 });
204
205 describe('Test .activeTransforms()', () => {
206 test('.activeTransforms returns current state', () => {
207 const state = Private.simpleState();
208 const tsm = new TransformStateManager();
209 tsm.replace([state.sort!, state.filter!]);
210 expect(tsm.activeTransforms).toEqual([state.sort, state.filter]);
211 });
212 });
213
214 /**
215 * A namespace for functions that generate transforms for testing.
216 */
217 namespace Private {
218 /**
219 * Returns a simple sort transform.
220 */
221 export function simpleSort(): Transform.Sort {
222 return { type: 'sort', column: 'test', desc: true };
223 }
224
225 /**
226 * Returns a simple filter transform.
227 */
228 export function simpleFilter(): Transform.Filter {
229 return { type: 'filter', column: 'test', operator: '<', value: 0 };
230 }
231
232 /**
233 * Returns a simple column of transform state.
234 */
235 export function simpleState(): TransformStateManager.IColumn {
236 return { filter: simpleFilter(), sort: simpleSort() };
237 }
238 }