Debian Codegraph @

tests/js/datagrid.test.ts

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