Debian Codegraph @

packages/properties/tests/src/index.spec.ts

raw
1 /* eslint-disable @typescript-eslint/no-empty-function */
2 // Copyright (c) Jupyter Development Team.
3 // Distributed under the terms of the Modified BSD License.
4 /*-----------------------------------------------------------------------------
5 | Copyright (c) 2014-2017, PhosphorJS Contributors
6 |
7 | Distributed under the terms of the BSD 3-Clause License.
8 |
9 | The full license is in the file LICENSE, distributed with this software.
10 |----------------------------------------------------------------------------*/
11 import { expect } from 'chai';
12
13 import { AttachedProperty } from '@lumino/properties';
14
15 class Model {
16 dummyValue = 42;
17 }
18
19 describe('@lumino/properties', () => {
20 describe('AttachedProperty', () => {
21 describe('#constructor()', () => {
22 it('should accept a single options argument', () => {
23 let p = new AttachedProperty<Model, number>({
24 name: 'p',
25 create: owner => 42,
26 coerce: (owner, value) => Math.max(0, value),
27 compare: (oldValue, newValue) => oldValue === newValue,
28 changed: (owner, oldValue, newValue) => {}
29 });
30 expect(p).to.be.an.instanceof(AttachedProperty);
31 });
32 });
33
34 describe('#name', () => {
35 it('should be the name provided to the constructor', () => {
36 let create = () => 0;
37 let p = new AttachedProperty<Model, number>({ name: 'p', create });
38 expect(p.name).to.equal('p');
39 });
40 });
41
42 describe('#get()', () => {
43 it('should return the current value of the property', () => {
44 let tick = 42;
45 let create = () => tick++;
46 let p1 = new AttachedProperty<Model, number>({ name: 'p1', create });
47 let p2 = new AttachedProperty<Model, number>({ name: 'p2', create });
48 let p3 = new AttachedProperty<Model, number>({ name: 'p3', create });
49 let m1 = new Model();
50 let m2 = new Model();
51 let m3 = new Model();
52 expect(p1.get(m1)).to.equal(42);
53 expect(p2.get(m1)).to.equal(43);
54 expect(p3.get(m1)).to.equal(44);
55 expect(p1.get(m2)).to.equal(45);
56 expect(p2.get(m2)).to.equal(46);
57 expect(p3.get(m2)).to.equal(47);
58 expect(p1.get(m3)).to.equal(48);
59 expect(p2.get(m3)).to.equal(49);
60 expect(p3.get(m3)).to.equal(50);
61 });
62
63 it('should not invoke the coerce function', () => {
64 let called = false;
65 let create = () => 0;
66 let coerce = (m: Model, v: number) => ((called = true), v);
67 let p1 = new AttachedProperty<Model, number>({
68 name: 'p1',
69 create,
70 coerce
71 });
72 let p2 = new AttachedProperty<Model, number>({
73 name: 'p2',
74 create,
75 coerce
76 });
77 let p3 = new AttachedProperty<Model, number>({
78 name: 'p3',
79 create,
80 coerce
81 });
82 let m1 = new Model();
83 let m2 = new Model();
84 let m3 = new Model();
85 p1.get(m1);
86 p2.get(m1);
87 p3.get(m1);
88 p1.get(m2);
89 p2.get(m2);
90 p3.get(m2);
91 p1.get(m3);
92 p2.get(m3);
93 p3.get(m3);
94 expect(called).to.equal(false);
95 });
96
97 it('should not invoke the compare function', () => {
98 let called = false;
99 let create = () => 0;
100 let compare = (v1: number, v2: number) => ((called = true), v1 === v2);
101 let p1 = new AttachedProperty<Model, number>({
102 name: 'p1',
103 create,
104 compare
105 });
106 let p2 = new AttachedProperty<Model, number>({
107 name: 'p2',
108 create,
109 compare
110 });
111 let p3 = new AttachedProperty<Model, number>({
112 name: 'p3',
113 create,
114 compare
115 });
116 let m1 = new Model();
117 let m2 = new Model();
118 let m3 = new Model();
119 p1.get(m1);
120 p2.get(m1);
121 p3.get(m1);
122 p1.get(m2);
123 p2.get(m2);
124 p3.get(m2);
125 p1.get(m3);
126 p2.get(m3);
127 p3.get(m3);
128 expect(called).to.equal(false);
129 });
130
131 it('should not invoke the changed function', () => {
132 let called = false;
133 let create = () => 0;
134 let changed = () => {
135 called = true;
136 };
137 let p1 = new AttachedProperty<Model, number>({
138 name: 'p1',
139 create,
140 changed
141 });
142 let p2 = new AttachedProperty<Model, number>({
143 name: 'p2',
144 create,
145 changed
146 });
147 let p3 = new AttachedProperty<Model, number>({
148 name: 'p3',
149 create,
150 changed
151 });
152 let m1 = new Model();
153 let m2 = new Model();
154 let m3 = new Model();
155 p1.get(m1);
156 p2.get(m1);
157 p3.get(m1);
158 p1.get(m2);
159 p2.get(m2);
160 p3.get(m2);
161 p1.get(m3);
162 p2.get(m3);
163 p3.get(m3);
164 expect(called).to.equal(false);
165 });
166 });
167
168 describe('#set()', () => {
169 it('should set the current value of the property', () => {
170 let create = () => 0;
171 let p1 = new AttachedProperty<Model, number>({ name: 'p1', create });
172 let p2 = new AttachedProperty<Model, number>({ name: 'p2', create });
173 let p3 = new AttachedProperty<Model, number>({ name: 'p3', create });
174 let m1 = new Model();
175 let m2 = new Model();
176 let m3 = new Model();
177 p1.set(m1, 1);
178 p1.set(m2, 2);
179 p1.set(m3, 3);
180 p2.set(m1, 4);
181 p2.set(m2, 5);
182 p2.set(m3, 6);
183 p3.set(m1, 7);
184 p3.set(m2, 8);
185 p3.set(m3, 9);
186 expect(p1.get(m1)).to.equal(1);
187 expect(p1.get(m2)).to.equal(2);
188 expect(p1.get(m3)).to.equal(3);
189 expect(p2.get(m1)).to.equal(4);
190 expect(p2.get(m2)).to.equal(5);
191 expect(p2.get(m3)).to.equal(6);
192 expect(p3.get(m1)).to.equal(7);
193 expect(p3.get(m2)).to.equal(8);
194 expect(p3.get(m3)).to.equal(9);
195 });
196
197 it('should invoke the changed function if the value changes', () => {
198 let oldvals: number[] = [];
199 let newvals: number[] = [];
200 let changed = (m: Model, o: number, n: number) => {
201 oldvals.push(o);
202 newvals.push(n);
203 };
204 let create = () => 0;
205 let p1 = new AttachedProperty<Model, number>({
206 name: 'p1',
207 create,
208 changed
209 });
210 let p2 = new AttachedProperty<Model, number>({
211 name: 'p2',
212 create,
213 changed
214 });
215 let p3 = new AttachedProperty<Model, number>({
216 name: 'p3',
217 create,
218 changed
219 });
220 let m1 = new Model();
221 let m2 = new Model();
222 let m3 = new Model();
223 p1.set(m1, 1);
224 p1.set(m2, 2);
225 p1.set(m3, 3);
226 p2.set(m1, 4);
227 p2.set(m2, 5);
228 p2.set(m3, 6);
229 p3.set(m1, 7);
230 p3.set(m2, 8);
231 p3.set(m3, 9);
232 expect(oldvals).to.deep.equal([0, 0, 0, 0, 0, 0, 0, 0, 0]);
233 expect(newvals).to.deep.equal([1, 2, 3, 4, 5, 6, 7, 8, 9]);
234 });
235
236 it('should invoke the coerce function on the new value', () => {
237 let create = () => 0;
238 let coerce = (o: Model, v: number) => Math.max(0, v);
239 let p = new AttachedProperty<Model, number>({
240 name: 'p',
241 create,
242 coerce
243 });
244 let m = new Model();
245 p.set(m, -10);
246 expect(p.get(m)).to.equal(0);
247 p.set(m, 10);
248 expect(p.get(m)).to.equal(10);
249 p.set(m, -42);
250 expect(p.get(m)).to.equal(0);
251 p.set(m, 42);
252 expect(p.get(m)).to.equal(42);
253 p.set(m, 0);
254 expect(p.get(m)).to.equal(0);
255 });
256
257 it('should not invoke the compare function if there is no changed function', () => {
258 let called = false;
259 let create = () => 0;
260 let compare = (v1: number, v2: number) => ((called = true), v1 === v2);
261 let p = new AttachedProperty<Model, number>({
262 name: 'p',
263 create,
264 compare
265 });
266 let m = new Model();
267 p.set(m, 42);
268 expect(called).to.equal(false);
269 });
270
271 it('should invoke the compare function if there is a changed function', () => {
272 let called = false;
273 let create = () => 0;
274 let changed = () => {};
275 let compare = (v1: number, v2: number) => ((called = true), v1 === v2);
276 let p = new AttachedProperty<Model, number>({
277 name: 'p',
278 create,
279 compare,
280 changed
281 });
282 let m = new Model();
283 p.set(m, 42);
284 expect(called).to.equal(true);
285 });
286
287 it('should not invoke the changed function if the value does not change', () => {
288 let called = false;
289 let create = () => 1;
290 let changed = () => {
291 called = true;
292 };
293 let compare = (v1: number, v2: number) => true;
294 let p1 = new AttachedProperty<Model, number>({
295 name: 'p1',
296 create,
297 changed
298 });
299 let p2 = new AttachedProperty<Model, number>({
300 name: 'p2',
301 create,
302 compare,
303 changed
304 });
305 let m = new Model();
306 p1.set(m, 1);
307 p1.set(m, 1);
308 p2.set(m, 1);
309 p2.set(m, 2);
310 p2.set(m, 3);
311 p2.set(m, 4);
312 expect(called).to.equal(false);
313 });
314 });
315
316 describe('#coerce()', () => {
317 it('should coerce the current value of the property', () => {
318 let min = 20;
319 let max = 50;
320 let create = () => 0;
321 let coerce = (m: Model, v: number) => Math.max(min, Math.min(v, max));
322 let p = new AttachedProperty<Model, number>({
323 name: 'p',
324 create,
325 coerce
326 });
327 let m = new Model();
328 p.set(m, 10);
329 expect(p.get(m)).to.equal(20);
330 min = 30;
331 p.coerce(m);
332 expect(p.get(m)).to.equal(30);
333 min = 10;
334 max = 20;
335 p.coerce(m);
336 expect(p.get(m)).to.equal(20);
337 });
338
339 it('should invoke the changed function if the value changes', () => {
340 let called = false;
341 let create = () => 0;
342 let coerce = (m: Model, v: number) => Math.max(20, v);
343 let changed = () => {
344 called = true;
345 };
346 let p = new AttachedProperty<Model, number>({
347 name: 'p',
348 create,
349 coerce,
350 changed
351 });
352 let m = new Model();
353 p.coerce(m);
354 expect(called).to.equal(true);
355 });
356
357 it('should use the default value as old value if value is not yet set', () => {
358 let oldval = -1;
359 let newval = -1;
360 let create = () => 0;
361 let coerce = (m: Model, v: number) => Math.max(20, v);
362 let changed = (m: Model, o: number, n: number) => {
363 oldval = o;
364 newval = n;
365 };
366 let p = new AttachedProperty<Model, number>({
367 name: 'p',
368 create,
369 coerce,
370 changed
371 });
372 let m = new Model();
373 p.coerce(m);
374 expect(oldval).to.equal(0);
375 expect(newval).to.equal(20);
376 });
377
378 it('should not invoke the compare function if there is no changed function', () => {
379 let called = false;
380 let create = () => 0;
381 let compare = (v1: number, v2: number) => ((called = true), v1 === v2);
382 let p = new AttachedProperty<Model, number>({
383 name: 'p',
384 create,
385 compare
386 });
387 let m = new Model();
388 p.coerce(m);
389 expect(called).to.equal(false);
390 });
391
392 it('should invoke the compare function if there is a changed function', () => {
393 let called = false;
394 let create = () => 0;
395 let changed = () => {};
396 let compare = (v1: number, v2: number) => ((called = true), v1 === v2);
397 let p = new AttachedProperty<Model, number>({
398 name: 'p',
399 create,
400 compare,
401 changed
402 });
403 let m = new Model();
404 p.coerce(m);
405 expect(called).to.equal(true);
406 });
407
408 it('should not invoke the changed function if the value does not change', () => {
409 let called = false;
410 let create = () => 0;
411 let changed = () => {
412 called = true;
413 };
414 let p = new AttachedProperty<Model, number>({
415 name: 'p',
416 create,
417 changed
418 });
419 let m = new Model();
420 p.coerce(m);
421 expect(called).to.equal(false);
422 });
423 });
424
425 describe('.clearData()', () => {
426 it('should clear all property data for a property owner', () => {
427 let create = () => 42;
428 let p1 = new AttachedProperty<Model, number>({ name: 'p1', create });
429 let p2 = new AttachedProperty<Model, number>({ name: 'p2', create });
430 let p3 = new AttachedProperty<Model, number>({ name: 'p3', create });
431 let m1 = new Model();
432 let m2 = new Model();
433 let m3 = new Model();
434 p1.set(m1, 1);
435 p1.set(m2, 2);
436 p1.set(m3, 3);
437 p2.set(m1, 4);
438 p2.set(m2, 5);
439 p2.set(m3, 6);
440 p3.set(m1, 7);
441 p3.set(m2, 8);
442 p3.set(m3, 9);
443 expect(p1.get(m1)).to.equal(1);
444 expect(p1.get(m2)).to.equal(2);
445 expect(p1.get(m3)).to.equal(3);
446 expect(p2.get(m1)).to.equal(4);
447 expect(p2.get(m2)).to.equal(5);
448 expect(p2.get(m3)).to.equal(6);
449 expect(p3.get(m1)).to.equal(7);
450 expect(p3.get(m2)).to.equal(8);
451 expect(p3.get(m3)).to.equal(9);
452 AttachedProperty.clearData(m1);
453 expect(p1.get(m1)).to.equal(42);
454 expect(p1.get(m2)).to.equal(2);
455 expect(p1.get(m3)).to.equal(3);
456 expect(p2.get(m1)).to.equal(42);
457 expect(p2.get(m2)).to.equal(5);
458 expect(p2.get(m3)).to.equal(6);
459 expect(p3.get(m1)).to.equal(42);
460 expect(p3.get(m2)).to.equal(8);
461 expect(p3.get(m3)).to.equal(9);
462 AttachedProperty.clearData(m2);
463 expect(p1.get(m1)).to.equal(42);
464 expect(p1.get(m2)).to.equal(42);
465 expect(p1.get(m3)).to.equal(3);
466 expect(p2.get(m1)).to.equal(42);
467 expect(p2.get(m2)).to.equal(42);
468 expect(p2.get(m3)).to.equal(6);
469 expect(p3.get(m1)).to.equal(42);
470 expect(p3.get(m2)).to.equal(42);
471 expect(p3.get(m3)).to.equal(9);
472 AttachedProperty.clearData(m3);
473 expect(p1.get(m1)).to.equal(42);
474 expect(p1.get(m2)).to.equal(42);
475 expect(p1.get(m3)).to.equal(42);
476 expect(p2.get(m1)).to.equal(42);
477 expect(p2.get(m2)).to.equal(42);
478 expect(p2.get(m3)).to.equal(42);
479 expect(p3.get(m1)).to.equal(42);
480 expect(p3.get(m2)).to.equal(42);
481 expect(p3.get(m3)).to.equal(42);
482 });
483 });
484 });
485 });