Debian Codegraph @

tests/js/datagrid.test.ts

raw ◀ ▶
1 Debian patch touch this file
1 import { DataGridModel, DataGridView } from '../../js/';
2
3 import {
4 DataGenerator,
5 MockWidgetManager,
6 MockComm,
7 emulateCustomCommMessage,
8 } from '../js/testUtils';
9
10 import { ViewBasedJSONModel } from '../../js/core/viewbasedjsonmodel';
11
12 import { Transform } from '../../js/core/transform';
13
14 import { CellRenderer, DataModel } from '@lumino/datagrid';
15 import { IClassicComm } from '@jupyter-widgets/base';
16
17 /**
18 * Tests that assigning new data to the `data` attribute of the widget behaves
19 * as intended.
20 */
21 describe('Test trait: data', () => {
22 test('Data model is updated on trait update', async () => {
23 const testData = Private.createBasicTestData();
24 const grid = await Private.createGridWidget({ data: testData.set1 });
25 grid.model.set('_data', testData.set2.data);
26 expect(grid.model.data_model.dataset.data).toEqual(
27 testData.set2.data.data,
28 );
29 });
30
31 test('Comm message sent to backend on frontend cell update', async () => {
32 const testData = Private.createBasicTestData();
33 const grid = await Private.createGridWidget({ data: testData.set1 });
34 let dataModel = grid.model.data_model;
35 grid.model.set('_data', testData.set2.data);
36 dataModel = grid.model.data_model
37 const mock = jest.spyOn((grid.model.comm as IClassicComm), 'send');
38 dataModel.setData('body', 1, 0, 1.23);
39 expect(mock).toBeCalled();
40 });
41
42 test('Comm message sent to frontend on backend cell update', async () => {
43 const testData = Private.createBasicTestData();
44 const grid = await Private.createGridWidget({ data: testData.set1 });
45 const row = 1,
46 column = 0;
47 const value = 1.23;
48 grid.model.set('_data', testData.set2.data);
49
50 return new Promise<void>((resolve, reject) => {
•51 // @ts-ignore
52 grid.model.on('msg:custom', (content) => {
53 if (content.event_type === 'cell-changed') {
54 expect(content.row).toBe(row);
55 expect(content.column_index).toBe(column);
56 expect(content.value).toBe(value);
57 resolve();
58 }
59 });
60
61 emulateCustomCommMessage(grid.model, 'iopub', {
62 event_type: 'cell-changed',
63 row: row,
64 column_index: column,
65 value: value,
66 });
67 });
68 });
69
70 test('Backend driven cell update propagates properly', async () => {
71 const testData = Private.createBasicTestData();
72 const grid = await Private.createGridWidget({ data: testData.set1 });
73 const row = 1,
74 column = 0;
75 const value = 1.23;
76 grid.model.set('_data', testData.set2.data);
77
78 return new Promise<void>((resolve, reject) => {
79 grid.model.data_model.changed.connect(
80 (model: ViewBasedJSONModel, args: any) => {
81 if (args.type === 'cells-changed') {
82 const updatedValue = model.data(args.region, args.row, args.column);
83 expect(args.row).toBe(row);
84 expect(args.column).toBe(column);
85 expect(updatedValue).toBe(value);
86 resolve();
87 }
88 },
89 );
90
91 emulateCustomCommMessage(grid.model, 'iopub', {
92 event_type: 'cell-changed',
93 row: row,
94 column_index: column,
95 value: value,
96 });
97 });
98 });
99
100 test('Backend driven row update propagates properly', async () => {
101 const testData = Private.createBasicTestData();
102 const grid = await Private.createGridWidget({ data: testData.set1 });
103 const row = 1;
104 const value = [1.23];
105 grid.model.set('_data', testData.set2.data);
106
107 return new Promise<void>((resolve, reject) => {
108 grid.model.data_model.changed.connect(
109 (model: ViewBasedJSONModel, args: any) => {
110 if (args.type === 'cells-changed') {
111 const updatedValue = [model.data(args.region, args.row, 0)];
112 expect(args.row).toBe(row);
113 expect(updatedValue).toStrictEqual(value);
114 resolve();
115 }
116 },
117 );
118
119 emulateCustomCommMessage(grid.model, 'iopub', {
120 event_type: 'row-changed',
121 row: row,
122 value: value,
123 });
124 });
125 });
126
127 test('Selection model updated on trait update', async () => {
128 const testData = Private.createBasicTestData();
129 const grid = await Private.createGridWidget({
130 data: testData.set1,
131 modelAttributes: { selection_mode: 'cell' },
132 });
133 const oldSelectionModel = grid.model.selectionModel;
134 grid.model.set('_data', testData.set2.data);
135 expect(grid.model.selectionModel).not.toBe(oldSelectionModel);
136 });
137
138 test('Transforms are copied to new model', async () => {
139 const testData = Private.createBasicTestData();
140 const transform: Transform.TransformSpec = {
141 type: 'sort',
142 column: 'index',
143 desc: true,
144 };
145 const grid = await Private.createGridWidget({
146 data: testData.set1,
147 modelAttributes: {
148 selection_mode: 'cell',
149 _transforms: [transform],
150 },
151 });
152 const oldTransforms = grid.model.data_model.transformMetadata(
153 transform.column,
154 );
155 grid.model.set('_data', testData.set2.data);
156 expect(
157 grid.model.data_model.transformMetadata(transform.column),
158 ).toEqual(oldTransforms);
159 });
160
161 test('HeaderRenderer keeps same data model ref on data change (same model, new data)', async () => {
162 const testData = Private.createBasicTestData();
163 const grid = await Private.createGridWidget({
164 data: testData.set1,
165 modelAttributes: { selection_mode: 'cell' },
166 });
167 const cornerCellConfig = Private.createCellConfig('corner-header');
168 const columnCellConfig = Private.createCellConfig('column-header');
169 const oldCornerHead = grid.view.grid.cellRenderers.get(cornerCellConfig);
170 const oldColHead = grid.view.grid.cellRenderers.get(columnCellConfig);
171 grid.model.set('_data', testData.set2.data);
172 expect(grid.view.grid.cellRenderers.get(cornerCellConfig)).toBe(
173 oldCornerHead,
174 );
175 expect(grid.view.grid.cellRenderers.get(columnCellConfig)).toBe(oldColHead);
176 });
177
178 test('Correct index of the grid is determined from column name', async () => {
179 const testData = Private.createMultiIndexData();
180 const grid = await Private.createGridWidget({
181 data: testData.set1,
182 });
183
184 // Testing primary keys
185 expect(grid.model.data_model.columnNameToIndex('index1')).toBe(0);
186 expect(grid.model.data_model.columnNameToIndex('index2')).toBe(1);
187
188 // Testing columns
189 expect(grid.model.data_model.columnNameToIndex('col1')).toBe(0);
190 expect(grid.model.data_model.columnNameToIndex('col2')).toBe(1);
191 });
192
193 test('Correct column name is determined from column index', async () => {
194 const testData = Private.createMultiIndexData();
195 const grid = await Private.createGridWidget({
196 data: testData.set1,
197 });
198
199 // Testing primary keys
200 expect(grid.model.data_model.columnIndexToName(0, 'row-header')).toBe(
201 'index1',
202 );
203 expect(grid.model.data_model.columnIndexToName(1, 'row-header')).toBe(
204 'index2',
205 );
206
207 // Testing columns
208 expect(grid.model.data_model.columnIndexToName(0, 'body')).toBe('col1');
209 expect(grid.model.data_model.columnIndexToName(1, 'body')).toBe('col2');
210 });
211
212 test('Correct column region is determined from column name', async () => {
213 const testData = Private.createMultiIndexData();
214 const grid = await Private.createGridWidget({
215 data: testData.set1,
216 });
217
218 // Testing primary keys
219 expect(grid.model.data_model.columnNameToRegion('index1')).toBe(
220 'row-header',
221 );
222 expect(grid.model.data_model.columnNameToRegion('index2')).toBe(
223 'row-header',
224 );
225
226 // Testing columns
227 expect(grid.model.data_model.columnNameToRegion('col1')).toBe('body');
228 expect(grid.model.data_model.columnNameToRegion('col2')).toBe('body');
229 });
230 });
231
232 test('Testing resizeColumns() is called upon model update', async () => {
233 const testData = Private.createMultiIndexData();
234 const grid = await Private.createGridWidget({
235 data: testData.set1,
236 });
237 const mock = jest.spyOn(grid.view.grid.grid, 'resizeColumn');
238
239 let mockDict = { col1: 200 };
240 grid.model.set('column_widths', mockDict);
241 grid.model.save_changes();
242
243 expect(mock).toHaveBeenCalledWith('body', 0, 200);
244 });
245
246 namespace Private {
247 /**
248 * Creates a model and view instance for the front-end of the widget.
249 *
250 * @param options - The options to create a grid widget
251 */
252 export function createGridWidget(
253 options: ICreateGridWidgetOptions,
254 ): Promise<GridWidgetComponents> {
255 return new Promise(async (resolve) => {
256 const widgetManager = new MockWidgetManager();
257 const comm = new MockComm();
258 const gridModel = new DataGridModel(
•259 // @ts-ignore
260 { ...options.modelAttributes, _data: options.data },
261 {
262 model_id: 'testModel',
263 comm: comm,
264 widget_manager: widgetManager,
265 } as any,
266 );
267 const gridView = new DataGridView({ model: gridModel });
268 await gridView.render();
269 resolve({ model: gridModel, view: gridView });
270 });
271 }
272
273 /**
274 * An options object to create a grid widget for testing.
275 */
276 export interface ICreateGridWidgetOptions {
277 /**
278 * Attributes to be passed along to the model constructor.
279 */
280 modelAttributes?: { [key: string]: any };
281
282 /**
283 * The grid data to instantiate the model with.
284 */
285 data: DataGridModel.IData;
286 }
287
288 /**
289 * An object that contains references to a linked datagrid model and view.
290 */
291 export interface GridWidgetComponents {
292 /**
293 * The widget model instance.
294 */
295 model: DataGridModel;
296
297 /**
298 * A widget view
299 */
300 view: DataGridView;
301 }
302
303 /**
304 * Creates 2 sets of data in the JSON Table Schema format for testing.
305 */
306 export function createBasicTestData(): BasicModelTestData {
307 const data1 = DataGenerator.singleCol({
308 data: [1, 2, 3],
309 name: 'test',
310 type: 'number',
311 });
312
313 const data2 = DataGenerator.singleCol({
314 data: [4, 5, 6],
315 name: 'test2',
316 type: 'number',
317 });
318
319 const set1: DataGridModel.IData = {
320 data: data1.data,
321 schema: data1.schema,
322 fields: data1.schema.fields.map((field: DataGridModel.IField) => {
323 let tempObject: { [key: string]: null } = {};
324 tempObject[field.name] = null;
325 return tempObject;
326 }),
327 };
328
329 const set2: DataGridModel.IData = {
330 data: data2.data,
331 schema: data2.schema,
332 fields: data2.schema.fields.map((field: DataGridModel.IField) => {
333 let tempObject: { [key: string]: null } = {};
334 tempObject[field.name] = null;
335 return tempObject;
336 }),
337 };
338
339 return { set1: set1, set2: set2 };
340 }
341
342 export interface BasicModelTestData {
343 set1: DataGridModel.IData;
344 set2: DataGridModel.IData;
345 }
346
347 /**
348 *
349 * Creates test data for multi index and multi column data
350 */
351 export function createMultiIndexData(): BasicModelTestData {
352 const data1 = DataGenerator.multiIndexCol(
353 {
354 data: [
355 { data: [0, 0, 0], name: 'index1', type: 'number' },
356 { data: [0, 0, 0], name: 'index2', type: 'number' },
357 { data: [1, 2, 3], name: 'col1', type: 'number' },
358 { data: [1, 2, 3], name: 'col2', type: 'number' },
359 ],
360 length: 2,
361 primaryKeyData: ['index1', 'index2', 'ipydguuid'],
362 },
363 'ipydguuid',
364 );
365
366 const set1: DataGridModel.IData = {
367 data: data1.data,
368 schema: data1.schema,
369 fields: data1.schema.fields.map((field: DataGridModel.IField) => {
370 let tempObject: { [key: string]: null } = {};
371 tempObject[field.name] = null;
372 return tempObject;
373 }),
374 };
375
376 const data2 = DataGenerator.multiIndexCol(
377 {
378 data: [
379 { data: [7, 8, 9], name: 'index3', type: 'number' },
380 { data: [7, 8, 9], name: 'index4', type: 'number' },
381 { data: [4, 5, 6], name: 'col3', type: 'number' },
382 { data: [4, 5, 6], name: 'col4', type: 'number' },
383 ],
384 length: 2,
385 primaryKeyData: ['index1', 'index2', 'ipydguuid'],
386 },
387 'ipydguuid',
388 );
389
390 const set2: DataGridModel.IData = {
391 data: data2.data,
392 schema: data2.schema,
393 fields: data2.schema.fields.map((field: DataGridModel.IField) => {
394 let tempObject: { [key: string]: null } = {};
395 tempObject[field.name] = null;
396 return tempObject;
397 }),
398 };
399
400 return { set1: set1, set2: set2 };
401 }
402
403 /**
404 * Returns a CellConfig for getting CellRenderers
405 *
406 * @param region The CellRegion to be added to the CellConfig
407 */
408 export function createCellConfig(
409 region: DataModel.CellRegion,
410 ): CellRenderer.CellConfig {
411 return {
412 column: 0,
413 height: 0,
414 metadata: {},
415 region: region,
416 row: 0,
417 value: 0,
418 width: 0,
419 x: 0,
420 y: 0,
421 };
422 }
423 }