Debian Codegraph @

packages/widgets/tests/src/panellayout.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 { every } from '@lumino/algorithm';
13
14 import {
15 IMessageHandler,
16 IMessageHook,
17 Message,
18 MessageLoop
19 } from '@lumino/messaging';
20
21 import { PanelLayout, Widget } from '@lumino/widgets';
22
23 class LogHook implements IMessageHook {
24 messages: string[] = [];
25
26 messageHook(target: IMessageHandler, msg: Message): boolean {
27 this.messages.push(msg.type);
28 return true;
29 }
30 }
31
32 class LogPanelLayout extends PanelLayout {
33 methods: string[] = [];
34
35 protected init(): void {
36 super.init();
37 this.methods.push('init');
38 }
39
40 protected attachWidget(index: number, widget: Widget): void {
41 super.attachWidget(index, widget);
42 this.methods.push('attachWidget');
43 }
44
45 protected moveWidget(
46 fromIndex: number,
47 toIndex: number,
48 widget: Widget
49 ): void {
50 super.moveWidget(fromIndex, toIndex, widget);
51 this.methods.push('moveWidget');
52 }
53
54 protected detachWidget(index: number, widget: Widget): void {
55 super.detachWidget(index, widget);
56 this.methods.push('detachWidget');
57 }
58
59 protected onChildRemoved(msg: Widget.ChildMessage): void {
60 super.onChildRemoved(msg);
61 this.methods.push('onChildRemoved');
62 }
63 }
64
65 describe('@lumino/widgets', () => {
66 describe('PanelLayout', () => {
67 describe('#dispose()', () => {
68 it('should dispose of the resources held by the widget', () => {
69 let layout = new PanelLayout();
70 let widgets = [new Widget(), new Widget()];
71 widgets.forEach(w => {
72 layout.addWidget(w);
73 });
74 layout.dispose();
75 expect(every(widgets, w => w.isDisposed)).to.equal(true);
76 });
77 });
78
79 describe('#widgets', () => {
80 it('should be a read-only sequence of widgets in the layout', () => {
81 let layout = new PanelLayout();
82 let widget = new Widget();
83 layout.addWidget(widget);
84 let widgets = layout.widgets;
85 expect(widgets.length).to.equal(1);
86 expect(widgets[0]).to.equal(widget);
87 });
88 });
89
90 describe('[Symbol.iterator]()', () => {
91 it('should create an iterator over the widgets in the layout', () => {
92 let layout = new PanelLayout();
93 let widgets = [new Widget(), new Widget()];
94 widgets.forEach(w => {
95 layout.addWidget(w);
96 });
97 widgets.forEach(w => {
98 w.title.label = 'foo';
99 });
100 expect(every(layout, w => w.title.label === 'foo')).to.equal(true);
101 let it1 = layout[Symbol.iterator](),
102 it2 = layout[Symbol.iterator]();
103 expect(it1).to.not.equal(it2);
104 });
105 });
106
107 describe('#addWidget()', () => {
108 it('should add a widget to the end of the layout', () => {
109 let layout = new PanelLayout();
110 layout.addWidget(new Widget());
111 let widget = new Widget();
112 layout.addWidget(widget);
113 expect(layout.widgets[1]).to.equal(widget);
114 });
115
116 it('should move an existing widget to the end', () => {
117 let layout = new PanelLayout();
118 let widget = new Widget();
119 layout.addWidget(widget);
120 layout.addWidget(new Widget());
121 layout.addWidget(widget);
122 expect(layout.widgets[1]).to.equal(widget);
123 });
124 });
125
126 describe('#insertWidget()', () => {
127 it('should insert a widget at the specified index', () => {
128 let layout = new PanelLayout();
129 layout.addWidget(new Widget());
130 let widget = new Widget();
131 layout.insertWidget(0, widget);
132 expect(layout.widgets[0]).to.equal(widget);
133 });
134
135 it('should move an existing widget to the specified index', () => {
136 let layout = new PanelLayout();
137 layout.addWidget(new Widget());
138 let widget = new Widget();
139 layout.addWidget(widget);
140 layout.insertWidget(0, widget);
141 expect(layout.widgets[0]).to.equal(widget);
142 });
143
144 it('should clamp the index to the bounds of the widgets', () => {
145 let layout = new PanelLayout();
146 layout.addWidget(new Widget());
147 let widget = new Widget();
148 layout.insertWidget(-2, widget);
149 expect(layout.widgets[0]).to.equal(widget);
150 layout.insertWidget(10, widget);
151 expect(layout.widgets[1]).to.equal(widget);
152 });
153
154 it('should be a no-op if the index does not change', () => {
155 let layout = new PanelLayout();
156 let widget = new Widget();
157 layout.addWidget(widget);
158 layout.addWidget(new Widget());
159 layout.insertWidget(0, widget);
160 expect(layout.widgets[0]).to.equal(widget);
161 });
162 });
163
164 describe('#removeWidget()', () => {
165 it('should remove a widget by value', () => {
166 let layout = new PanelLayout();
167 let widget = new Widget();
168 layout.addWidget(widget);
169 layout.addWidget(new Widget());
170 layout.removeWidget(widget);
171 expect(layout.widgets.length).to.equal(1);
172 expect(layout.widgets[0]).to.not.equal(widget);
173 });
174 });
175
176 describe('#removeWidgetAt()', () => {
177 it('should remove a widget at a given index', () => {
178 let layout = new PanelLayout();
179 let widget = new Widget();
180 layout.addWidget(widget);
181 layout.addWidget(new Widget());
182 layout.removeWidgetAt(0);
183 expect(layout.widgets.length).to.equal(1);
184 expect(layout.widgets[0]).to.not.equal(widget);
185 });
186 });
187
188 describe('#init()', () => {
189 it('should be invoked when the layout is installed on its parent', () => {
190 let widget = new Widget();
191 let layout = new LogPanelLayout();
192 widget.layout = layout;
193 expect(layout.methods).to.contain('init');
194 });
195
196 it('should attach all widgets to the DOM', () => {
197 let parent = new Widget();
198 Widget.attach(parent, document.body);
199 let layout = new LogPanelLayout();
200 let widgets = [new Widget(), new Widget(), new Widget()];
201 widgets.forEach(w => {
202 layout.addWidget(w);
203 });
204 parent.layout = layout;
205 expect(every(widgets, w => w.parent === parent)).to.equal(true);
206 expect(every(widgets, w => w.isAttached)).to.equal(true);
207 parent.dispose();
208 });
209 });
210
211 describe('#attachWidget()', () => {
212 it("should attach a widget to the parent's DOM node", () => {
213 let panel = new Widget();
214 let layout = new LogPanelLayout();
215 let widget = new Widget();
216 panel.layout = layout;
217 layout.insertWidget(0, widget);
218 expect(layout.methods).to.contain('attachWidget');
219 expect(panel.node.children[0]).to.equal(widget.node);
220 panel.dispose();
221 });
222
223 it('should send before/after attach messages if the parent is attached', () => {
224 let panel = new Widget();
225 let layout = new LogPanelLayout();
226 let widget = new Widget();
227 let hook = new LogHook();
228 panel.layout = layout;
229 MessageLoop.installMessageHook(widget, hook);
230 Widget.attach(panel, document.body);
231 layout.insertWidget(0, widget);
232 expect(layout.methods).to.contain('attachWidget');
233 expect(hook.messages).to.contain('before-attach');
234 expect(hook.messages).to.contain('after-attach');
235 panel.dispose();
236 });
237 });
238
239 describe('#moveWidget()', () => {
240 it("should move a widget in the parent's DOM node", () => {
241 let panel = new Widget();
242 let layout = new LogPanelLayout();
243 let widget = new Widget();
244 panel.layout = layout;
245 layout.addWidget(widget);
246 layout.addWidget(new Widget());
247 layout.insertWidget(1, widget);
248 expect(layout.methods).to.contain('moveWidget');
249 expect(panel.node.children[1]).to.equal(widget.node);
250 panel.dispose();
251 });
252
253 it('should send before/after detach/attach messages if the parent is attached', () => {
254 let panel = new Widget();
255 let layout = new LogPanelLayout();
256 let widget = new Widget();
257 let hook = new LogHook();
258 MessageLoop.installMessageHook(widget, hook);
259 panel.layout = layout;
260 Widget.attach(panel, document.body);
261 layout.addWidget(widget);
262 layout.addWidget(new Widget());
263 layout.insertWidget(1, widget);
264 expect(layout.methods).to.contain('moveWidget');
265 expect(hook.messages).to.contain('before-detach');
266 expect(hook.messages).to.contain('after-detach');
267 expect(hook.messages).to.contain('before-attach');
268 expect(hook.messages).to.contain('after-attach');
269 panel.dispose();
270 });
271 });
272
273 describe('#detachWidget()', () => {
274 it("should detach a widget from the parent's DOM node", () => {
275 let panel = new Widget();
276 let layout = new LogPanelLayout();
277 let widget = new Widget();
278 panel.layout = layout;
279 layout.insertWidget(0, widget);
280 expect(panel.node.children[0]).to.equal(widget.node);
281 layout.removeWidget(widget);
282 expect(layout.methods).to.contain('detachWidget');
283 panel.dispose();
284 });
285
286 it('should send before/after detach message if the parent is attached', () => {
287 let panel = new Widget();
288 let layout = new LogPanelLayout();
289 let widget = new Widget();
290 let hook = new LogHook();
291 MessageLoop.installMessageHook(widget, hook);
292 panel.layout = layout;
293 Widget.attach(panel, document.body);
294 layout.insertWidget(0, widget);
295 expect(panel.node.children[0]).to.equal(widget.node);
296 layout.removeWidget(widget);
297 expect(layout.methods).to.contain('detachWidget');
298 expect(hook.messages).to.contain('before-detach');
299 expect(hook.messages).to.contain('after-detach');
300 panel.dispose();
301 });
302 });
303
304 describe('#onChildRemoved()', () => {
305 it('should be called when a widget is removed from its parent', () => {
306 let panel = new Widget();
307 let layout = new LogPanelLayout();
308 let widget = new Widget();
309 panel.layout = layout;
310 layout.addWidget(widget);
311 widget.parent = null;
312 expect(layout.methods).to.contain('onChildRemoved');
313 });
314
315 it('should remove the widget from the layout', () => {
316 let panel = new Widget();
317 let layout = new LogPanelLayout();
318 let widget = new Widget();
319 panel.layout = layout;
320 layout.addWidget(widget);
321 widget.parent = null;
322 expect(layout.widgets.length).to.equal(0);
323 });
324 });
325 });
326 });