Debian Codegraph @

packages/widgets/tests/src/stackedlayout.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 {
13 IMessageHandler,
14 IMessageHook,
15 Message,
16 MessageLoop
17 } from '@lumino/messaging';
18
19 import { StackedLayout, Widget } from '@lumino/widgets';
20
21 class LogHook implements IMessageHook {
22 messages: string[] = [];
23
24 messageHook(target: IMessageHandler, msg: Message): boolean {
25 this.messages.push(msg.type);
26 return true;
27 }
28 }
29
30 class LogStackedLayout extends StackedLayout {
31 methods: string[] = [];
32
33 protected init(): void {
34 super.init();
35 this.methods.push('init');
36 }
37
38 protected attachWidget(index: number, widget: Widget): void {
39 super.attachWidget(index, widget);
40 this.methods.push('attachWidget');
41 }
42
43 protected moveWidget(
44 fromIndex: number,
45 toIndex: number,
46 widget: Widget
47 ): void {
48 super.moveWidget(fromIndex, toIndex, widget);
49 this.methods.push('moveWidget');
50 }
51
52 protected detachWidget(index: number, widget: Widget): void {
53 super.detachWidget(index, widget);
54 this.methods.push('detachWidget');
55 }
56
57 protected onAfterShow(msg: Message): void {
58 super.onAfterShow(msg);
59 this.methods.push('onAfterShow');
60 }
61
62 protected onAfterAttach(msg: Message): void {
63 super.onAfterAttach(msg);
64 this.methods.push('onAfterAttach');
65 }
66
67 protected onChildShown(msg: Widget.ChildMessage): void {
68 super.onChildShown(msg);
69 this.methods.push('onChildShown');
70 }
71
72 protected onChildHidden(msg: Widget.ChildMessage): void {
73 super.onChildHidden(msg);
74 this.methods.push('onChildHidden');
75 }
76
77 protected onResize(msg: Widget.ResizeMessage): void {
78 super.onResize(msg);
79 this.methods.push('onResize');
80 }
81
82 protected onUpdateRequest(msg: Message): void {
83 super.onUpdateRequest(msg);
84 this.methods.push('onUpdateRequest');
85 }
86
87 protected onFitRequest(msg: Message): void {
88 super.onFitRequest(msg);
89 this.methods.push('onFitRequest');
90 }
91 }
92
93 describe('@lumino/widgets', () => {
94 describe('StackedLayout', () => {
95 describe('#attachWidget()', () => {
96 it("should attach a widget to the parent's DOM node", () => {
97 let layout = new LogStackedLayout();
98 let parent = new Widget();
99 let widget = new Widget();
100 parent.layout = layout;
101 layout.addWidget(widget);
102 expect(layout.methods).to.contain('attachWidget');
103 expect(parent.node.contains(widget.node)).to.equal(true);
104 });
105
106 it('should send before/after attach messages if the parent is attached', () => {
107 let layout = new LogStackedLayout();
108 let parent = new Widget();
109 let widget = new Widget();
110 let hook = new LogHook();
111 MessageLoop.installMessageHook(widget, hook);
112 parent.layout = layout;
113 Widget.attach(parent, document.body);
114 layout.addWidget(widget);
115 expect(hook.messages).to.contain('before-attach');
116 expect(hook.messages).to.contain('after-attach');
117 });
118
119 it('should post a fit request for the parent widget', done => {
120 let layout = new LogStackedLayout();
121 let parent = new Widget();
122 let widget = new Widget();
123 parent.layout = layout;
124 Widget.attach(parent, document.body);
125 layout.addWidget(widget);
126 requestAnimationFrame(() => {
127 expect(layout.methods).to.contain('onFitRequest');
128 done();
129 });
130 });
131 });
132
133 describe('#moveWidget()', () => {
134 it("should move a widget in the parent's DOM node", () => {
135 let layout = new LogStackedLayout();
136 let widgets = [new Widget(), new Widget(), new Widget()];
137 let parent = new Widget();
138 parent.layout = layout;
139 widgets.forEach(w => {
140 layout.addWidget(w);
141 });
142 layout.insertWidget(2, widgets[0]);
143 expect(layout.methods).to.contain('moveWidget');
144 expect(layout.widgets[2]).to.equal(widgets[0]);
145 });
146
147 it('should post an update request to the parent', done => {
148 let layout = new LogStackedLayout();
149 let widgets = [new Widget(), new Widget(), new Widget()];
150 let parent = new Widget();
151 parent.layout = layout;
152 widgets.forEach(w => {
153 layout.addWidget(w);
154 });
155 layout.insertWidget(2, widgets[0]);
156 requestAnimationFrame(() => {
157 expect(layout.methods).to.contain('onUpdateRequest');
158 done();
159 });
160 });
161 });
162
163 describe('#detachWidget()', () => {
164 it("should detach a widget from the parent's DOM node", () => {
165 let layout = new LogStackedLayout();
166 let widget = new Widget();
167 let parent = new Widget();
168 parent.layout = layout;
169 layout.addWidget(widget);
170 layout.removeWidget(widget);
171 expect(layout.methods).to.contain('detachWidget');
172 expect(parent.node.contains(widget.node)).to.equal(false);
173 parent.dispose();
174 });
175
176 it('should send before/after detach message if the parent is attached', () => {
177 let layout = new LogStackedLayout();
178 let parent = new Widget();
179 let widget = new Widget();
180 let hook = new LogHook();
181 MessageLoop.installMessageHook(widget, hook);
182 parent.layout = layout;
183 layout.addWidget(widget);
184 Widget.attach(parent, document.body);
185 layout.removeWidget(widget);
186 expect(layout.methods).to.contain('detachWidget');
187 expect(hook.messages).to.contain('before-detach');
188 expect(hook.messages).to.contain('after-detach');
189 parent.dispose();
190 });
191
192 it('should post a a layout request to the parent', done => {
193 let layout = new LogStackedLayout();
194 let parent = new Widget();
195 let widget = new Widget();
196 parent.layout = layout;
197 layout.addWidget(widget);
198 Widget.attach(parent, document.body);
199 layout.removeWidget(widget);
200 requestAnimationFrame(() => {
201 expect(layout.methods).to.contain('onFitRequest');
202 parent.dispose();
203 done();
204 });
205 });
206
207 it('should reset the z-index for the widget', done => {
208 let layout = new LogStackedLayout();
209 let parent = new Widget();
210 let widget1 = new Widget();
211 let widget2 = new Widget();
212 parent.layout = layout;
213 layout.addWidget(widget1);
214 layout.addWidget(widget2);
215 Widget.attach(parent, document.body);
216 requestAnimationFrame(() => {
217 // string casts are required for IE
218 expect(`${widget1.node.style.zIndex}`).to.equal('0');
219 expect(`${widget2.node.style.zIndex}`).to.equal('1');
220 layout.removeWidget(widget1);
221 expect(`${widget1.node.style.zIndex}`).to.equal('');
222 expect(`${widget2.node.style.zIndex}`).to.equal('1');
223 layout.removeWidget(widget2);
224 expect(`${widget2.node.style.zIndex}`).to.equal('');
225 parent.dispose();
226 done();
227 });
228 });
229 });
230
231 describe('#onAfterShow()', () => {
232 it('should post an update to the parent', done => {
233 let layout = new LogStackedLayout();
234 let parent = new Widget();
235 parent.layout = layout;
236 parent.hide();
237 Widget.attach(parent, document.body);
238 parent.show();
239 expect(layout.methods).to.contain('onAfterShow');
240 requestAnimationFrame(() => {
241 expect(layout.methods).to.contain('onUpdateRequest');
242 parent.dispose();
243 done();
244 });
245 });
246 });
247
248 describe('#onAfterAttach()', () => {
249 it('should post a layout request to the parent', done => {
250 let layout = new LogStackedLayout();
251 let parent = new Widget();
252 parent.layout = layout;
253 Widget.attach(parent, document.body);
254 expect(layout.methods).to.contain('onAfterAttach');
255 requestAnimationFrame(() => {
256 expect(layout.methods).to.contain('onFitRequest');
257 parent.dispose();
258 done();
259 });
260 });
261 });
262
263 describe('#onChildShown()', () => {
264 it('should post or send a fit request to the parent', done => {
265 let parent = new Widget();
266 let layout = new LogStackedLayout();
267 parent.layout = layout;
268 let widgets = [new Widget(), new Widget(), new Widget()];
269 widgets[0].hide();
270 widgets.forEach(w => {
271 layout.addWidget(w);
272 });
273 Widget.attach(parent, document.body);
274 widgets[0].show();
275 expect(layout.methods).to.contain('onChildShown');
276 requestAnimationFrame(() => {
277 expect(layout.methods).to.contain('onFitRequest');
278 parent.dispose();
279 done();
280 });
281 });
282 });
283
284 describe('#onChildHidden()', () => {
285 it('should post or send a fit request to the parent', done => {
286 let parent = new Widget();
287 let layout = new LogStackedLayout();
288 parent.layout = layout;
289 let widgets = [new Widget(), new Widget(), new Widget()];
290 widgets.forEach(w => {
291 layout.addWidget(w);
292 });
293 Widget.attach(parent, document.body);
294 widgets[0].hide();
295 expect(layout.methods).to.contain('onChildHidden');
296 requestAnimationFrame(() => {
297 expect(layout.methods).to.contain('onFitRequest');
298 parent.dispose();
299 done();
300 });
301 });
302 });
303 });
304 });