Debian Codegraph @

closure-library/closure/goog/ui/modalpopup_test.js

raw
1 // Copyright 2011 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 goog.provide('goog.ui.ModalPopupTest');
16 goog.setTestOnly('goog.ui.ModalPopupTest');
17
18 goog.require('goog.a11y.aria');
19 goog.require('goog.a11y.aria.State');
20 goog.require('goog.dispose');
21 goog.require('goog.dom');
22 goog.require('goog.dom.TagName');
23 goog.require('goog.events');
24 goog.require('goog.events.EventTarget');
25 goog.require('goog.events.EventType');
26 goog.require('goog.fx.Transition');
27 goog.require('goog.fx.css3');
28 goog.require('goog.string');
29 goog.require('goog.style');
30 goog.require('goog.testing.MockClock');
31 goog.require('goog.testing.events');
32 goog.require('goog.testing.jsunit');
33 goog.require('goog.ui.ModalPopup');
34 goog.require('goog.ui.PopupBase');
35
36 var popup;
37 var main;
38 var mockClock;
39
40
41 function setUp() {
42 main = /** @type {!Element}*/ (goog.dom.getElement('main'));
43 mockClock = new goog.testing.MockClock(true);
44 }
45
46
47 function tearDown() {
48 goog.dispose(popup);
49 mockClock.dispose();
50 goog.a11y.aria.removeState(main, goog.a11y.aria.State.HIDDEN);
51 }
52
53
54 function testOrientationChange() {
55 var i = 0;
56 popup = new goog.ui.ModalPopup();
57 popup.resizeBackgroundTask_ = function() { i++; };
58 popup.render();
59 popup.setVisible(true);
60 var event = new goog.events.Event(
61 goog.events.EventType.ORIENTATIONCHANGE,
62 popup.getDomHelper().getWindow());
63
64 goog.testing.events.fireBrowserEvent(event);
65 assertEquals(1, i);
66
67 goog.testing.events.fireBrowserEvent(event);
68 assertEquals(2, i);
69
70 popup.setVisible(false);
71 goog.testing.events.fireBrowserEvent(event);
72 assertEquals(2, i);
73 }
74
75
76 function testDispose() {
77 popup = new goog.ui.ModalPopup();
78 popup.render();
79
80 goog.dispose(popup);
81 assertNull(goog.dom.getElementByClass('goog-modalpopup-bg'));
82 assertNull(goog.dom.getElementByClass('goog-modalpopup'));
83 assertEquals(
84 0, goog.dom.getElementsByTagNameAndClass(goog.dom.TagName.SPAN).length);
85 }
86
87
88 function testRenderWithoutIframeMask() {
89 popup = new goog.ui.ModalPopup();
90 popup.render();
91
92 assertEquals(
93 0, goog.dom
94 .getElementsByTagNameAndClass(
95 goog.dom.TagName.IFRAME, 'goog-modalpopup-bg')
96 .length);
97
98 var bg = goog.dom.getElementsByTagNameAndClass(
99 goog.dom.TagName.DIV, 'goog-modalpopup-bg');
100 assertEquals(1, bg.length);
101 var content = goog.dom.getElementByClass('goog-modalpopup');
102 assertNotNull(content);
103 var tabCatcher = goog.dom.getElementsByTagNameAndClass(goog.dom.TagName.SPAN);
104 assertEquals(1, tabCatcher.length);
105
106 assertTrue(goog.dom.compareNodeOrder(bg[0], content) < 0);
107 assertTrue(goog.dom.compareNodeOrder(content, tabCatcher[0]) < 0);
108 assertTrue(
109 goog.string.isEmptyOrWhitespace(
110 goog.string.makeSafe(
111 goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN))));
112 popup.setVisible(true);
113 assertTrue(
114 goog.string.isEmptyOrWhitespace(
115 goog.string.makeSafe(
116 goog.a11y.aria.getState(
117 popup.getElementStrict(), goog.a11y.aria.State.HIDDEN))));
118 assertEquals(
119 'true', goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN));
120 popup.setVisible(false);
121 assertTrue(
122 goog.string.isEmptyOrWhitespace(
123 goog.string.makeSafe(
124 goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN))));
125 }
126
127
128 function testRenderWithIframeMask() {
129 popup = new goog.ui.ModalPopup(true);
130 popup.render();
131
132 var iframe = goog.dom.getElementsByTagNameAndClass(
133 goog.dom.TagName.IFRAME, 'goog-modalpopup-bg');
134 assertEquals(1, iframe.length);
135 var bg = goog.dom.getElementsByTagNameAndClass(
136 goog.dom.TagName.DIV, 'goog-modalpopup-bg');
137 assertEquals(1, bg.length);
138 var content = goog.dom.getElementByClass('goog-modalpopup');
139 assertNotNull(content);
140 var tabCatcher = goog.dom.getElementsByTagNameAndClass(goog.dom.TagName.SPAN);
141 assertEquals(1, tabCatcher.length);
142
143 assertTrue(goog.dom.compareNodeOrder(iframe[0], bg[0]) < 0);
144 assertTrue(goog.dom.compareNodeOrder(bg[0], content) < 0);
145 assertTrue(goog.dom.compareNodeOrder(content, tabCatcher[0]) < 0);
146 assertTrue(
147 goog.string.isEmptyOrWhitespace(
148 goog.string.makeSafe(
149 goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN))));
150 popup.setVisible(true);
151 assertTrue(
152 goog.string.isEmptyOrWhitespace(
153 goog.string.makeSafe(
154 goog.a11y.aria.getState(
155 popup.getElementStrict(), goog.a11y.aria.State.HIDDEN))));
156 assertEquals(
157 'true', goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN));
158 popup.setVisible(false);
159 assertTrue(
160 goog.string.isEmptyOrWhitespace(
161 goog.string.makeSafe(
162 goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN))));
163 }
164
165
166 function testRenderWithAriaState() {
167 popup = new goog.ui.ModalPopup();
168 popup.render();
169
170 goog.a11y.aria.setState(main, goog.a11y.aria.State.HIDDEN, true);
171 popup.setVisible(true);
172 assertEquals(
173 'true', goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN));
174 popup.setVisible(false);
175 assertEquals(
176 'true', goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN));
177
178 goog.a11y.aria.setState(main, goog.a11y.aria.State.HIDDEN, false);
179 popup.setVisible(true);
180 assertEquals(
181 'false', goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN));
182 popup.setVisible(false);
183 assertEquals(
184 'false', goog.a11y.aria.getState(main, goog.a11y.aria.State.HIDDEN));
185 }
186
187
188 function testRenderDoesNotShowAnyElement() {
189 popup = new goog.ui.ModalPopup(true);
190 popup.render();
191
192 var iframe = goog.dom.getElementsByTagNameAndClass(
193 goog.dom.TagName.IFRAME, 'goog-modalpopup-bg');
194 assertFalse(goog.style.isElementShown(iframe[0]));
195 var bg = goog.dom.getElementsByTagNameAndClass(
196 goog.dom.TagName.DIV, 'goog-modalpopup-bg');
197 assertFalse(goog.style.isElementShown(bg[0]));
198 assertFalse(
199 goog.style.isElementShown(goog.dom.getElementByClass('goog-modalpopup')));
200 var tabCatcher = goog.dom.getElementsByTagNameAndClass(goog.dom.TagName.SPAN);
201 assertFalse(goog.style.isElementShown(tabCatcher[0]));
202 }
203
204
205 function testIframeOpacityIsSetToZero() {
206 popup = new goog.ui.ModalPopup(true);
207 popup.render();
208
209 var iframe = goog.dom.getElementsByTagNameAndClass(
210 goog.dom.TagName.IFRAME, 'goog-modalpopup-bg')[0];
211 assertEquals(0, goog.style.getOpacity(iframe));
212 }
213
214
215 function testEventFiredOnShow() {
216 popup = new goog.ui.ModalPopup(true);
217 popup.render();
218
219 var beforeShowCallCount = 0;
220 var beforeShowHandler = function() { beforeShowCallCount++; };
221 var showCallCount = false;
222 var showHandler = function() {
223 assertEquals(
224 'BEFORE_SHOW is not dispatched before SHOW', 1, beforeShowCallCount);
225 showCallCount++;
226 };
227
228 goog.events.listen(
229 popup, goog.ui.PopupBase.EventType.BEFORE_SHOW, beforeShowHandler);
230 goog.events.listen(popup, goog.ui.PopupBase.EventType.SHOW, showHandler);
231
232 popup.setVisible(true);
233
234 assertEquals(1, beforeShowCallCount);
235 assertEquals(1, showCallCount);
236 }
237
238
239 function testEventFiredOnHide() {
240 popup = new goog.ui.ModalPopup(true);
241 popup.render();
242 popup.setVisible(true);
243
244 var beforeHideCallCount = 0;
245 var beforeHideHandler = function() { beforeHideCallCount++; };
246 var hideCallCount = false;
247 var hideHandler = function() {
248 assertEquals(
249 'BEFORE_HIDE is not dispatched before HIDE', 1, beforeHideCallCount);
250 hideCallCount++;
251 };
252
253 goog.events.listen(
254 popup, goog.ui.PopupBase.EventType.BEFORE_HIDE, beforeHideHandler);
255 goog.events.listen(popup, goog.ui.PopupBase.EventType.HIDE, hideHandler);
256
257 popup.setVisible(false);
258
259 assertEquals(1, beforeHideCallCount);
260 assertEquals(1, hideCallCount);
261 }
262
263
264 function testShowEventFiredWithNoTransition() {
265 popup = new goog.ui.ModalPopup();
266 popup.render();
267
268 var showHandlerCalled = false;
269 goog.events.listen(popup, goog.ui.PopupBase.EventType.SHOW, function() {
270 showHandlerCalled = true;
271 });
272
273 popup.setVisible(true);
274 assertTrue(showHandlerCalled);
275 }
276
277 function testHideEventFiredWithNoTransition() {
278 popup = new goog.ui.ModalPopup();
279 popup.render();
280
281 var hideHandlerCalled = false;
282 goog.events.listen(popup, goog.ui.PopupBase.EventType.HIDE, function() {
283 hideHandlerCalled = true;
284 });
285
286 popup.setVisible(true);
287 popup.setVisible(false);
288 assertTrue(hideHandlerCalled);
289 }
290
291 function testTransitionsPlayedOnShow() {
292 popup = new goog.ui.ModalPopup();
293 popup.render();
294
295 var mockPopupShowTransition = new MockTransition();
296 var mockPopupHideTransition = new MockTransition();
297 var mockBgShowTransition = new MockTransition();
298 var mockBgHideTransition = new MockTransition();
299
300 var showHandlerCalled = false;
301 goog.events.listen(popup, goog.ui.PopupBase.EventType.SHOW, function() {
302 showHandlerCalled = true;
303 });
304
305 popup.setTransition(
306 mockPopupShowTransition, mockPopupHideTransition, mockBgShowTransition,
307 mockBgHideTransition);
308 assertFalse(mockPopupShowTransition.wasPlayed);
309 assertFalse(mockBgShowTransition.wasPlayed);
310
311 popup.setVisible(true);
312 assertTrue(mockPopupShowTransition.wasPlayed);
313 assertTrue(mockBgShowTransition.wasPlayed);
314
315 assertFalse(showHandlerCalled);
316 mockPopupShowTransition.dispatchEvent(goog.fx.Transition.EventType.END);
317 assertTrue(showHandlerCalled);
318 }
319
320
321 function testTransitionsPlayedOnHide() {
322 popup = new goog.ui.ModalPopup();
323 popup.render();
324
325 var mockPopupShowTransition = new MockTransition();
326 var mockPopupHideTransition = new MockTransition();
327 var mockBgShowTransition = new MockTransition();
328 var mockBgHideTransition = new MockTransition();
329
330 var hideHandlerCalled = false;
331 goog.events.listen(popup, goog.ui.PopupBase.EventType.HIDE, function() {
332 hideHandlerCalled = true;
333 });
334
335 popup.setTransition(
336 mockPopupShowTransition, mockPopupHideTransition, mockBgShowTransition,
337 mockBgHideTransition);
338 popup.setVisible(true);
339 assertFalse(mockPopupHideTransition.wasPlayed);
340 assertFalse(mockBgHideTransition.wasPlayed);
341
342 popup.setVisible(false);
343 assertTrue(mockPopupHideTransition.wasPlayed);
344 assertTrue(mockBgHideTransition.wasPlayed);
345
346 assertFalse(hideHandlerCalled);
347 mockPopupHideTransition.dispatchEvent(goog.fx.Transition.EventType.END);
348 assertTrue(hideHandlerCalled);
349 }
350
351
352 function testTransitionsAndDisposingOnHideWorks() {
353 popup = new goog.ui.ModalPopup();
354 popup.render();
355
356 goog.events.listen(
357 popup, goog.ui.PopupBase.EventType.HIDE, function() { popup.dispose(); });
358
359 var popupShowTransition =
360 goog.fx.css3.fadeIn(popup.getElement(), 0.1 /* duration */);
361 var popupHideTransition =
362 goog.fx.css3.fadeOut(popup.getElement(), 0.1 /* duration */);
363 var bgShowTransition =
364 goog.fx.css3.fadeIn(popup.getElement(), 0.1 /* duration */);
365 var bgHideTransition =
366 goog.fx.css3.fadeOut(popup.getElement(), 0.1 /* duration */);
367
368 popup.setTransition(
369 popupShowTransition, popupHideTransition, bgShowTransition,
370 bgHideTransition);
371 popup.setVisible(true);
372 popup.setVisible(false);
373 // Nothing to assert. We only want to ensure that there is no error.
374 }
375
376
377 function testSetVisibleWorksCorrectlyWithTransitions() {
378 popup = new goog.ui.ModalPopup();
379 popup.render();
380 popup.setTransition(
381 goog.fx.css3.fadeIn(popup.getElement(), 1),
382 goog.fx.css3.fadeIn(popup.getBackgroundElement(), 1),
383 goog.fx.css3.fadeOut(popup.getElement(), 1),
384 goog.fx.css3.fadeOut(popup.getBackgroundElement(), 1));
385
386 // Consecutive calls to setVisible works without needing to wait for
387 // transition to finish.
388 popup.setVisible(true);
389 assertTrue(popup.isVisible());
390 popup.setVisible(false);
391 assertFalse(popup.isVisible());
392 mockClock.tick(1100);
393
394 // Calling setVisible(true) immediately changed the state to visible.
395 popup.setVisible(true);
396 assertTrue(popup.isVisible());
397 mockClock.tick(1100);
398
399 // Consecutive calls to setVisible, in opposite order.
400 popup.setVisible(false);
401 popup.setVisible(true);
402 assertTrue(popup.isVisible());
403 mockClock.tick(1100);
404
405 // Calling setVisible(false) immediately changed the state to not visible.
406 popup.setVisible(false);
407 assertFalse(popup.isVisible());
408 mockClock.tick(1100);
409 }
410
411
412 function testTransitionsDisposed() {
413 popup = new goog.ui.ModalPopup();
414 popup.render();
415
416 var transition = goog.fx.css3.fadeIn(popup.getElement(), 0.1 /* duration */);
417
418 var hideHandlerCalled = false;
419 goog.events.listen(popup, goog.ui.PopupBase.EventType.HIDE, function() {
420 hideHandlerCalled = true;
421 });
422
423 popup.setTransition(transition, transition, transition, transition);
424 popup.dispose();
425
426 transition.dispatchEvent(goog.fx.Transition.EventType.END);
427 assertFalse(hideHandlerCalled);
428 }
429
430
431 function testBackgroundHeight() {
432 // Insert an absolutely-positioned element larger than the viewport.
433 var viewportSize = goog.dom.getViewportSize();
434 var w = viewportSize.width * 2;
435 var h = viewportSize.height * 2;
436 var dummy = goog.dom.createElement(goog.dom.TagName.DIV);
437 dummy.style.position = 'absolute';
438 goog.style.setSize(dummy, w, h);
439 document.body.appendChild(dummy);
440
441 try {
442 popup = new goog.ui.ModalPopup();
443 popup.render();
444 popup.setVisible(true);
445
446 var size = goog.style.getSize(popup.getBackgroundElement());
447 assertTrue(
448 'Background element must cover the size of the content',
449 size.width >= w && size.height >= h);
450 } finally {
451 goog.dom.removeNode(dummy);
452 }
453 }
454
455
456 function testSetupBackwardTabWrapResetsFlagAfterTimeout() {
457 popup.setupBackwardTabWrap();
458 assertTrue(
459 'Backward tab wrap should be in progress',
460 popup.backwardTabWrapInProgress_);
461 mockClock.tick(1);
462 assertFalse(
463 'Backward tab wrap flag should be reset after delay',
464 popup.backwardTabWrapInProgress_);
465 }
466
467
468 function testPopupGetsFocus() {
469 popup = new goog.ui.ModalPopup();
470 popup.render();
471 popup.setVisible(true);
472 assertTrue(
473 'Dialog must receive initial focus',
474 goog.dom.getActiveElement(document) == popup.getElement());
475 }
476
477
478 function testDecoratedPopupGetsFocus() {
479 var dialogElem = goog.dom.createElement(goog.dom.TagName.DIV);
480 document.body.appendChild(dialogElem);
481 popup = new goog.ui.ModalPopup();
482 popup.decorate(dialogElem);
483 popup.setVisible(true);
484 assertTrue(
485 'Dialog must receive initial focus',
486 goog.dom.getActiveElement(document) == popup.getElement());
487 goog.dom.removeNode(dialogElem);
488 }
489
490
491
492 /**
493 * @implements {goog.fx.Transition}
494 * @extends {goog.events.EventTarget}
495 * @constructor
496 */
497 var MockTransition = function() {
498 MockTransition.base(this, 'constructor');
499 this.wasPlayed = false;
500 };
501 goog.inherits(MockTransition, goog.events.EventTarget);
502
503
504 MockTransition.prototype.play = function() {
505 this.wasPlayed = true;
506 };
507
508
509 MockTransition.prototype.stop = goog.nullFunction;