Debian Codegraph @

packages/widgets/tests/src/focustracker.spec.ts

raw
1 // Copyright (c) Jupyter Development Team.
2 // Distributed under the terms of the Modified BSD License.
3 /*-----------------------------------------------------------------------------
4 | Copyright (c) 2014-2017, PhosphorJS Contributors
5 |
6 | Distributed under the terms of the BSD 3-Clause License.
7 |
8 | The full license is in the file LICENSE, distributed with this software.
9 |----------------------------------------------------------------------------*/
10 import { expect } from 'chai';
11
12 import { Platform } from '@lumino/domutils';
13
14 import { FocusTracker, Widget } from '@lumino/widgets';
15
16 describe('@lumino/widgets', () => {
17 let _trackers: FocusTracker<Widget>[] = [];
18 let _widgets: Widget[] = [];
19
20 function createTracker(): FocusTracker<Widget> {
21 let tracker = new FocusTracker<Widget>();
22 _trackers.push(tracker);
23 return tracker;
24 }
25
26 function createWidget(): Widget {
27 let widget = new Widget();
28 widget.node.tabIndex = -1;
29 Widget.attach(widget, document.body);
30 _widgets.push(widget);
31 return widget;
32 }
33
34 function focusWidget(widget: Widget): void {
35 widget.node.focus();
36 if (Platform.IS_IE) {
37 widget.node.dispatchEvent(new FocusEvent('focus', { bubbles: true }));
38 }
39 }
40
41 function blurWidget(widget: Widget): void {
42 widget.node.blur();
43 if (Platform.IS_IE) {
44 widget.node.dispatchEvent(new FocusEvent('blur', { bubbles: true }));
45 }
46 }
47
48 afterEach(() => {
49 while (_trackers.length > 0) {
50 _trackers.pop()!.dispose();
51 }
52 while (_widgets.length > 0) {
53 _widgets.pop()!.dispose();
54 }
55 });
56
57 describe('FocusTracker', () => {
58 describe('#constructor()', () => {
59 it('should create a FocusTracker', () => {
60 let tracker = new FocusTracker<Widget>();
61 expect(tracker).to.be.an.instanceof(FocusTracker);
62 });
63 });
64
65 describe('#dispose()', () => {
66 it('should dispose of the resources held by the tracker', () => {
67 let tracker = new FocusTracker<Widget>();
68 tracker.add(createWidget());
69 tracker.dispose();
70 expect(tracker.widgets.length).to.equal(0);
71 });
72
73 it('should be a no-op if already disposed', () => {
74 let tracker = new FocusTracker<Widget>();
75 tracker.dispose();
76 tracker.dispose();
77 expect(tracker.isDisposed).to.equal(true);
78 });
79 });
80
81 describe('#currentChanged', () => {
82 it('should be emitted when the current widget has changed', () => {
83 let tracker = createTracker();
84 let widget0 = createWidget();
85 let widget1 = createWidget();
86 tracker.add(widget0);
87 tracker.add(widget1);
88 focusWidget(widget0);
89 let emitArgs: FocusTracker.IChangedArgs<Widget> | null = null;
90 tracker.currentChanged.connect((sender, args) => {
91 emitArgs = args;
92 });
93 focusWidget(widget1);
94 expect(emitArgs).to.not.equal(null);
95 expect(emitArgs!.oldValue).to.equal(widget0);
96 expect(emitArgs!.newValue).to.equal(widget1);
97 });
98
99 it('should not be emitted when the current widget does not change', () => {
100 let tracker = createTracker();
101 let widget = createWidget();
102 focusWidget(widget);
103 tracker.add(widget);
104 let emitArgs: FocusTracker.IChangedArgs<Widget> | null = null;
105 tracker.currentChanged.connect((sender, args) => {
106 emitArgs = args;
107 });
108 blurWidget(widget);
109 focusWidget(widget);
110 expect(emitArgs).to.equal(null);
111 });
112 });
113
114 describe('#activeChanged', () => {
115 it('should be emitted when the active widget has changed', () => {
116 let tracker = createTracker();
117 let widget0 = createWidget();
118 let widget1 = createWidget();
119 tracker.add(widget0);
120 tracker.add(widget1);
121 focusWidget(widget0);
122 let emitArgs: FocusTracker.IChangedArgs<Widget> | null = null;
123 tracker.activeChanged.connect((sender, args) => {
124 emitArgs = args;
125 });
126 focusWidget(widget1);
127 expect(emitArgs).to.not.equal(null);
128 expect(emitArgs!.oldValue).to.equal(widget0);
129 expect(emitArgs!.newValue).to.equal(widget1);
130 });
131
132 it('should be emitted when the active widget is set to null', () => {
133 let tracker = createTracker();
134 let widget = createWidget();
135 focusWidget(widget);
136 tracker.add(widget);
137 let emitArgs: FocusTracker.IChangedArgs<Widget> | null = null;
138 tracker.activeChanged.connect((sender, args) => {
139 emitArgs = args;
140 });
141 blurWidget(widget);
142 expect(emitArgs).to.not.equal(null);
143 expect(emitArgs!.oldValue).to.equal(widget);
144 expect(emitArgs!.newValue).to.equal(null);
145 });
146 });
147
148 describe('#isDisposed', () => {
149 it('should indicate whether the tracker is disposed', () => {
150 let tracker = new FocusTracker<Widget>();
151 expect(tracker.isDisposed).to.equal(false);
152 tracker.dispose();
153 expect(tracker.isDisposed).to.equal(true);
154 });
155 });
156
157 describe('#currentWidget', () => {
158 it('should get the current widget in the tracker', () => {
159 let tracker = createTracker();
160 let widget = createWidget();
161 focusWidget(widget);
162 tracker.add(widget);
163 expect(tracker.currentWidget).to.equal(widget);
164 });
165
166 it('should not be updated when the current widget loses focus', () => {
167 let tracker = createTracker();
168 let widget = createWidget();
169 focusWidget(widget);
170 tracker.add(widget);
171 expect(tracker.currentWidget).to.equal(widget);
172 blurWidget(widget);
173 expect(tracker.currentWidget).to.equal(widget);
174 });
175
176 it('should be set to the widget that gained focus', () => {
177 let tracker = createTracker();
178 let widget0 = createWidget();
179 let widget1 = createWidget();
180 focusWidget(widget0);
181 tracker.add(widget0);
182 tracker.add(widget1);
183 expect(tracker.currentWidget).to.equal(widget0);
184 focusWidget(widget1);
185 expect(tracker.currentWidget).to.equal(widget1);
186 });
187
188 it('should revert to the previous widget if the current widget is removed', () => {
189 let tracker = createTracker();
190 let widget0 = createWidget();
191 let widget1 = createWidget();
192 focusWidget(widget0);
193 tracker.add(widget0);
194 tracker.add(widget1);
195 focusWidget(widget1);
196 expect(tracker.currentWidget).to.equal(widget1);
197 widget1.dispose();
198 expect(tracker.currentWidget).to.equal(widget0);
199 });
200
201 it('should be `null` if there is no current widget', () => {
202 let tracker = createTracker();
203 expect(tracker.currentWidget).to.equal(null);
204 let widget = createWidget();
205 focusWidget(widget);
206 tracker.add(widget);
207 expect(tracker.currentWidget).to.equal(widget);
208 widget.dispose();
209 expect(tracker.currentWidget).to.equal(null);
210 });
211 });
212
213 describe('#activeWidget', () => {
214 it('should get the active widget in the tracker', () => {
215 let tracker = createTracker();
216 let widget = createWidget();
217 focusWidget(widget);
218 tracker.add(widget);
219 expect(tracker.activeWidget).to.equal(widget);
220 });
221
222 it('should be set to `null` when the active widget loses focus', () => {
223 let tracker = createTracker();
224 let widget = createWidget();
225 focusWidget(widget);
226 tracker.add(widget);
227 expect(tracker.activeWidget).to.equal(widget);
228 blurWidget(widget);
229 expect(tracker.activeWidget).to.equal(null);
230 });
231
232 it('should be set to the widget that gained focus', () => {
233 let tracker = createTracker();
234 let widget0 = createWidget();
235 let widget1 = createWidget();
236 focusWidget(widget0);
237 tracker.add(widget0);
238 tracker.add(widget1);
239 expect(tracker.activeWidget).to.equal(widget0);
240 focusWidget(widget1);
241 expect(tracker.activeWidget).to.equal(widget1);
242 });
243
244 it('should be `null` if there is no active widget', () => {
245 let tracker = createTracker();
246 expect(tracker.currentWidget).to.equal(null);
247 let widget = createWidget();
248 focusWidget(widget);
249 tracker.add(widget);
250 expect(tracker.activeWidget).to.equal(widget);
251 widget.dispose();
252 expect(tracker.activeWidget).to.equal(null);
253 });
254 });
255
256 describe('#widgets', () => {
257 it('should be a read-only sequence of the widgets being tracked', () => {
258 let tracker = createTracker();
259 expect(tracker.widgets.length).to.equal(0);
260 let widget = createWidget();
261 tracker.add(widget);
262 expect(tracker.widgets.length).to.equal(1);
263 expect(tracker.widgets[0]).to.equal(widget);
264 });
265 });
266
267 describe('#focusNumber()', () => {
268 it('should get the focus number for a particular widget in the tracker', () => {
269 let tracker = createTracker();
270 let widget = createWidget();
271 focusWidget(widget);
272 tracker.add(widget);
273 expect(tracker.focusNumber(widget)).to.equal(0);
274 });
275
276 it('should give the highest number for the currentWidget', () => {
277 let tracker = createTracker();
278 let widget0 = createWidget();
279 let widget1 = createWidget();
280 focusWidget(widget0);
281 tracker.add(widget0);
282 tracker.add(widget1);
283 focusWidget(widget1);
284 expect(tracker.focusNumber(widget1)).to.equal(1);
285 expect(tracker.focusNumber(widget0)).to.equal(0);
286 focusWidget(widget0);
287 expect(tracker.focusNumber(widget0)).to.equal(2);
288 });
289
290 it('should start a widget with a focus number of `-1`', () => {
291 let tracker = createTracker();
292 let widget = createWidget();
293 tracker.add(widget);
294 expect(tracker.focusNumber(widget)).to.equal(-1);
295 });
296
297 it('should update when a widget gains focus', () => {
298 let tracker = createTracker();
299 let widget0 = createWidget();
300 let widget1 = createWidget();
301 focusWidget(widget0);
302 tracker.add(widget0);
303 tracker.add(widget1);
304 focusWidget(widget1);
305 expect(tracker.focusNumber(widget0)).to.equal(0);
306 focusWidget(widget0);
307 expect(tracker.focusNumber(widget0)).to.equal(2);
308 });
309 });
310
311 describe('#has()', () => {
312 it('should test whether the focus tracker contains a given widget', () => {
313 let tracker = createTracker();
314 let widget = createWidget();
315 expect(tracker.has(widget)).to.equal(false);
316 tracker.add(widget);
317 expect(tracker.has(widget)).to.equal(true);
318 });
319 });
320
321 describe('#add()', () => {
322 it('should add a widget to the focus tracker', () => {
323 let tracker = createTracker();
324 let widget = createWidget();
325 tracker.add(widget);
326 expect(tracker.has(widget)).to.equal(true);
327 });
328
329 it('should make the widget the currentWidget if focused', () => {
330 let tracker = createTracker();
331 let widget = createWidget();
332 focusWidget(widget);
333 tracker.add(widget);
334 expect(tracker.currentWidget).to.equal(widget);
335 });
336
337 it('should remove the widget from the tracker after it has been disposed', () => {
338 let tracker = createTracker();
339 let widget = createWidget();
340 tracker.add(widget);
341 widget.dispose();
342 expect(tracker.has(widget)).to.equal(false);
343 });
344
345 it('should be a no-op if the widget is already tracked', () => {
346 let tracker = createTracker();
347 let widget = createWidget();
348 tracker.add(widget);
349 tracker.add(widget);
350 expect(tracker.has(widget)).to.equal(true);
351 });
352 });
353
354 describe('#remove()', () => {
355 it('should remove a widget from the focus tracker', () => {
356 let tracker = createTracker();
357 let widget = createWidget();
358 tracker.add(widget);
359 tracker.remove(widget);
360 expect(tracker.has(widget)).to.equal(false);
361 });
362
363 it('should set the currentWidget to the previous one if the widget is the currentWidget', () => {
364 let tracker = createTracker();
365 let widget0 = createWidget();
366 let widget1 = createWidget();
367 let widget2 = createWidget();
368 focusWidget(widget0);
369 tracker.add(widget0);
370 tracker.add(widget1);
371 tracker.add(widget2);
372 focusWidget(widget1);
373 focusWidget(widget2);
374 tracker.remove(widget2);
375 expect(tracker.currentWidget).to.equal(widget1);
376 });
377
378 it('should be a no-op if the widget is not tracked', () => {
379 let tracker = createTracker();
380 let widget = createWidget();
381 tracker.remove(widget);
382 expect(tracker.has(widget)).to.equal(false);
383 });
384 });
385 });
386 });