Debian Codegraph @

tests/js/viewbasedjsonmodel.test.ts

raw
1 import { Signal } from '@lumino/signaling';
2 import { View } from '../../js/core/view';
3 import { ViewBasedJSONModel } from '../../js/core/viewbasedjsonmodel';
4 import { TransformStateManager } from '../../js/core/transformStateManager';
5 import { Transform } from '../../js/core/transform';
6 import { DataGenerator } from '../js/testUtils';
7
8 describe('Test interactions with View', () => {
9 test('.rowCount()', () => {
10 const model = Private.createSimpleModel();
11 const mock = jest.spyOn(View.prototype, 'rowCount');
12 model.rowCount('body');
13 expect(mock).toHaveBeenCalledWith('body');
14 });
15 test('.columnCount()', () => {
16 const model = Private.createSimpleModel();
17 const mock = jest.spyOn(View.prototype, 'columnCount');
18 model.columnCount('body');
19 expect(mock).toHaveBeenCalledWith('body');
20 });
21 test('.metadata()', () => {
22 const model = Private.createSimpleModel();
23 const mock = jest.spyOn(View.prototype, 'metadata');
24 model.metadata('body', 0, 0);
25 expect(mock).toHaveBeenCalledWith('body', 0, 0);
26 });
27 test('.getSchemaIndex()', () => {
28 const model = Private.createSimpleModel();
29 const mock = jest.spyOn(View.prototype, 'getSchemaIndex');
30 model.getSchemaIndex('column-header', 0);
31 expect(mock).toHaveBeenCalledWith('column-header', 0);
32 });
33 test('.data()', () => {
34 const model = Private.createSimpleModel();
35 const mock = jest.spyOn(View.prototype, 'data');
36 model.data('body', 0, 0);
37 expect(mock).toHaveBeenCalledWith('body', 0, 0);
38 });
39 });
40
41 describe('Test interactions with TransformStateManager', () => {
42 test('.addTransform()', () => {
43 const model = Private.createSimpleModel();
44 let mock = jest.spyOn(TransformStateManager.prototype, 'add');
45 const transform: Transform.TransformSpec = {
46 type: 'sort',
47 column: 'index',
48 desc: true,
49 };
50 model.addTransform(transform);
51 expect(mock).toBeCalledWith(transform);
52 });
53 test('.removeTransform()', () => {
54 const model = Private.createSimpleModel();
55 let mock = jest.spyOn(TransformStateManager.prototype, 'remove');
56 model.removeTransform('index', 'sort');
57 expect(mock).toBeCalledWith('index', 'sort');
58 });
59 test('.replaceTransform()', () => {
60 const model = Private.createSimpleModel();
61 let mock = jest.spyOn(TransformStateManager.prototype, 'replace');
62 const transforms: Transform.TransformSpec[] = [
63 {
64 type: 'sort',
65 column: 'index',
66 desc: true,
67 },
68 ];
69 model.replaceTransforms(transforms);
70 expect(mock).toBeCalledWith(transforms);
71 });
72 test('.clearTransform()', () => {
73 const model = Private.createSimpleModel();
74 let mock = jest.spyOn(TransformStateManager.prototype, 'clear');
75 model.clearTransforms();
76 expect(mock).toHaveBeenCalledTimes(1);
77 });
78 test('.transformMetadata()', () => {
79 const model = Private.createSimpleModel();
80 let mock = jest.spyOn(TransformStateManager.prototype, 'metadata');
81 model.transformMetadata('index');
82 expect(mock).toBeCalledWith('index');
83 });
84 });
85
86 describe('Test signal getters', () => {
87 test('.transformStateChanged()', () => {
88 const model = Private.createSimpleModel();
89 expect(model.transformStateChanged).toBeInstanceOf(Signal);
90 });
91 });
92
93 describe('Test mutable dataset', () => {
94 test('.setData()', () => {
95 const model = Private.createSimpleModel();
96 const row = 1,
97 column = 0;
98 const initialValue: number = model.data('body', row, column);
99 expect(initialValue).toBe(2);
100 model.setData('body', row, column, 1.23);
101 const newValue: number = model.data('body', row, column);
102 expect(newValue).toBe(1.23);
103 });
104
105 test('cell data changed signal received', async () => {
106 return new Promise<void>((resolve, reject) => {
107 const model = Private.createSimpleModel();
108 const row = 1,
109 column = 0;
110 model.changed.connect((model: ViewBasedJSONModel, args: any) => {
111 if (args.type === 'cells-changed') {
112 expect(args.row).toBe(row);
113 expect(args.column).toBe(column);
114 resolve();
115 }
116 });
117 model.setData('body', row, column, 1.23);
118 });
119 });
120 });
121
122 describe('Test .uniqueValues()', () => {
123 const testData = DataGenerator.multiCol({
124 length: 5,
125 data: [
126 { name: 'index', type: 'string', data: ['A', 'C', 'B', 'A', 'C'] },
127 { name: 'col1', type: 'number', data: [10, 20, 30, 40, 50] },
128 {
129 name: 'col2',
130 type: 'boolean',
131 data: [true, false, true, false, false],
132 },
133 { name: 'col3', type: 'number', data: [100, 200, 100, 300, 200] },
134 ],
135 });
136 const testModel = new ViewBasedJSONModel({ datasource: testData.data });
137 test('cellregion-column-header-0', async () => {
138 expect(await testModel.uniqueValues('column-header', 'col1')).toEqual([
139 10,
140 20,
141 30,
142 40,
143 50,
144 ]);
145 });
146 test('cellregion-column-header-1', async () => {
147 expect(await testModel.uniqueValues('column-header', 'col2')).toEqual([
148 true,
149 false,
150 ]);
151 });
152 test('cellregion-column-header-2', async () => {
153 expect(await testModel.uniqueValues('column-header', 'col3')).toEqual([
154 100,
155 200,
156 300,
157 ]);
158 });
159 test('cellregion-corner-header-0', async () => {
160 expect(await testModel.uniqueValues('corner-header', 'index')).toEqual([
161 'A',
162 'C',
163 'B',
164 ]);
165 });
166 });
167
168 namespace Private {
169 export function createSimpleModel(): ViewBasedJSONModel {
170 const testData = DataGenerator.singleCol({
171 name: 'test',
172 type: 'number',
173 data: [1, 2, 3, 4],
174 });
175 const model = new ViewBasedJSONModel({ datasource: testData.data });
176 return model;
177 }
178 }