Debian Codegraph @

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

raw
1 // Copyright 2008 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.TooltipTest');
16 goog.setTestOnly('goog.ui.TooltipTest');
17
18 goog.require('goog.dom');
19 goog.require('goog.dom.TagName');
20 goog.require('goog.events.Event');
21 goog.require('goog.events.EventHandler');
22 goog.require('goog.events.EventType');
23 goog.require('goog.events.FocusHandler');
24 goog.require('goog.html.testing');
25 goog.require('goog.math.Coordinate');
26 goog.require('goog.positioning.AbsolutePosition');
27 goog.require('goog.style');
28 goog.require('goog.testing.MockClock');
29 goog.require('goog.testing.TestQueue');
30 goog.require('goog.testing.events');
31 goog.require('goog.testing.jsunit');
32 goog.require('goog.ui.PopupBase');
33 goog.require('goog.ui.Tooltip');
34 goog.require('goog.userAgent');
35
36
37
38 /**
39 * A subclass of Tooltip that overrides {@code getPositioningStrategy}
40 * for testing purposes.
41 * @constructor
42 */
43 function TestTooltip(el, text, dom) {
44 goog.ui.Tooltip.call(this, el, text, dom);
45 }
46 goog.inherits(TestTooltip, goog.ui.Tooltip);
47
48
49 /** @override */
50 TestTooltip.prototype.getPositioningStrategy = function() {
51 return new goog.positioning.AbsolutePosition(13, 17);
52 };
53
54
55 var tt, clock, handler, eventQueue, dom;
56
57 // Allow positions to be off by one in gecko as it reports scrolling
58 // offsets in steps of 2.
59 var ALLOWED_OFFSET = goog.userAgent.GECKO ? 1 : 0;
60
61 function setUp() {
62 // We get access denied error when accessing the iframe in IE on the farm
63 // as IE doesn't have the same window size issues as firefox on the farm
64 // we bypass the iframe and use the current document instead.
65 if (goog.userAgent.EDGE_OR_IE) {
66 dom = goog.dom.getDomHelper(document);
67 } else {
68 var frame = document.getElementById('testframe');
69 var doc = goog.dom.getFrameContentDocument(frame);
70 dom = goog.dom.getDomHelper(doc);
71 }
72
73 // Host elements in fixed size iframe to avoid window size problems when
74 // running under Selenium.
75 dom.getDocument().body.innerHTML = '<p id="notpopup">Content</p>' +
76 '<p id="hovertarget">Hover Here For Popup</p>' +
77 '<p id="second">Secondary target</p>';
78
79 tt = new goog.ui.Tooltip(undefined, undefined, dom);
80 tt.setElement(
81 dom.createDom(
82 goog.dom.TagName.DIV, {id: 'popup', style: 'visibility:hidden'},
83 'Hello'));
84 clock = new goog.testing.MockClock(true);
85 eventQueue = new goog.testing.TestQueue();
86 handler = new goog.events.EventHandler(eventQueue);
87 handler.listen(tt, goog.ui.PopupBase.EventType.SHOW, eventQueue.enqueue);
88 handler.listen(tt, goog.ui.PopupBase.EventType.HIDE, eventQueue.enqueue);
89 }
90
91 function tearDown() {
92 // tooltip needs to be hidden as well as disposed of so that it doesn't
93 // leave global state hanging around to trip up other tests.
94 tt.onHide();
95 tt.dispose();
96 clock.uninstall();
97 handler.removeAll();
98 }
99
100 function testConstructor() {
101 var element = tt.getElement();
102 assertNotNull('Tooltip should have non-null element', element);
103 assertEquals(
104 'Tooltip element should be the DIV we created', dom.getElement('popup'),
105 element);
106 assertEquals(
107 'Tooltip element should be a child of the document body',
108 dom.getDocument().body, element.parentNode);
109 }
110
111 function testTooltipShowsAndHides() {
112 var hoverTarget = dom.getElement('hovertarget');
113 var elsewhere = dom.getElement('notpopup');
114 var element = tt.getElement();
115 var position = new goog.math.Coordinate(5, 5);
116 assertNotNull('Tooltip should have non-null element', element);
117 assertEquals(
118 'Initial state should be inactive', goog.ui.Tooltip.State.INACTIVE,
119 tt.getState());
120 tt.attach(hoverTarget);
121 tt.setShowDelayMs(100);
122 tt.setHideDelayMs(50);
123 goog.testing.events.fireMouseOverEvent(hoverTarget, elsewhere, position);
124 assertEquals(goog.ui.Tooltip.State.WAITING_TO_SHOW, tt.getState());
125 clock.tick(101);
126 assertEquals('visible', tt.getElement().style.visibility);
127 assertEquals(
128 'tooltip y position (10px margin below the cursor)', '15px',
129 tt.getElement().style.top);
130 assertEquals(goog.ui.Tooltip.State.SHOWING, tt.getState());
131 assertEquals(goog.ui.PopupBase.EventType.SHOW, eventQueue.dequeue().type);
132 assertTrue(eventQueue.isEmpty());
133
134 goog.testing.events.fireMouseOutEvent(hoverTarget, elsewhere);
135 assertEquals(goog.ui.Tooltip.State.WAITING_TO_HIDE, tt.getState());
136 clock.tick(51);
137 assertEquals('hidden', tt.getElement().style.visibility);
138 assertEquals(goog.ui.Tooltip.State.INACTIVE, tt.getState());
139 assertEquals(goog.ui.PopupBase.EventType.HIDE, eventQueue.dequeue().type);
140 assertTrue(eventQueue.isEmpty());
141 }
142
143 function testMultipleTargets() {
144 var firstTarget = dom.getElement('hovertarget');
145 var secondTarget = dom.getElement('second');
146 var elsewhere = dom.getElement('notpopup');
147 var element = tt.getElement();
148
149 tt.attach(firstTarget);
150 tt.attach(secondTarget);
151 tt.setShowDelayMs(100);
152 tt.setHideDelayMs(50);
153
154 // Move over first target
155 goog.testing.events.fireMouseOverEvent(firstTarget, elsewhere);
156 clock.tick(101);
157 assertEquals(goog.ui.PopupBase.EventType.SHOW, eventQueue.dequeue().type);
158 assertTrue(eventQueue.isEmpty());
159
160 // Move from first to second
161 goog.testing.events.fireMouseOutEvent(firstTarget, secondTarget);
162 goog.testing.events.fireMouseOverEvent(secondTarget, firstTarget);
163 assertEquals(goog.ui.Tooltip.State.UPDATING, tt.getState());
164 assertTrue(eventQueue.isEmpty());
165
166 // Move from second to element (before second shows)
167 goog.testing.events.fireMouseOutEvent(secondTarget, element);
168 goog.testing.events.fireMouseOverEvent(element, secondTarget);
169 assertEquals(goog.ui.Tooltip.State.SHOWING, tt.getState());
170 assertTrue(eventQueue.isEmpty());
171
172 // Move from element to second, and let it show
173 goog.testing.events.fireMouseOutEvent(element, secondTarget);
174 goog.testing.events.fireMouseOverEvent(secondTarget, element);
175 assertEquals(goog.ui.Tooltip.State.UPDATING, tt.getState());
176 clock.tick(101);
177 assertEquals(goog.ui.Tooltip.State.SHOWING, tt.getState());
178 assertEquals('Anchor should be second target', secondTarget, tt.anchor);
179 assertEquals(goog.ui.PopupBase.EventType.HIDE, eventQueue.dequeue().type);
180 assertEquals(goog.ui.PopupBase.EventType.SHOW, eventQueue.dequeue().type);
181 assertTrue(eventQueue.isEmpty());
182
183 // Move from second to first and then off without first showing
184 goog.testing.events.fireMouseOutEvent(secondTarget, firstTarget);
185 goog.testing.events.fireMouseOverEvent(firstTarget, secondTarget);
186 assertEquals(goog.ui.Tooltip.State.UPDATING, tt.getState());
187 goog.testing.events.fireMouseOutEvent(firstTarget, elsewhere);
188 assertEquals(goog.ui.Tooltip.State.WAITING_TO_HIDE, tt.getState());
189 clock.tick(51);
190 assertEquals('hidden', tt.getElement().style.visibility);
191 assertEquals(goog.ui.Tooltip.State.INACTIVE, tt.getState());
192 assertEquals(goog.ui.PopupBase.EventType.HIDE, eventQueue.dequeue().type);
193 assertTrue(eventQueue.isEmpty());
194 clock.tick(200);
195
196 // Move from element to second, but detach second before it shows.
197 goog.testing.events.fireMouseOutEvent(element, secondTarget);
198 goog.testing.events.fireMouseOverEvent(secondTarget, element);
199 assertEquals(goog.ui.Tooltip.State.WAITING_TO_SHOW, tt.getState());
200 tt.detach(secondTarget);
201 clock.tick(200);
202 assertEquals(goog.ui.Tooltip.State.INACTIVE, tt.getState());
203 assertEquals('Anchor should be second target', secondTarget, tt.anchor);
204 assertTrue(eventQueue.isEmpty());
205 }
206
207 function testRequireInteraction() {
208 var hoverTarget = dom.getElement('hovertarget');
209 var elsewhere = dom.getElement('notpopup');
210
211 tt.attach(hoverTarget);
212 tt.setShowDelayMs(100);
213 tt.setHideDelayMs(50);
214 tt.setRequireInteraction(true);
215
216 goog.testing.events.fireMouseOverEvent(hoverTarget, elsewhere);
217 clock.tick(101);
218 assertEquals(
219 'Tooltip should not show without mouse move event', 'hidden',
220 tt.getElement().style.visibility);
221 goog.testing.events.fireMouseMoveEvent(hoverTarget);
222 goog.testing.events.fireMouseOverEvent(hoverTarget, elsewhere);
223 clock.tick(101);
224 assertEquals(
225 'Tooltip should show because we had mouse move event', 'visible',
226 tt.getElement().style.visibility);
227
228 goog.testing.events.fireMouseOutEvent(hoverTarget, elsewhere);
229 clock.tick(51);
230 assertEquals('hidden', tt.getElement().style.visibility);
231 goog.testing.events.fireBrowserEvent(
232 new goog.events.Event(goog.events.EventType.FOCUS, hoverTarget));
233 clock.tick(101);
234 assertEquals(
235 'Tooltip should show because we had focus event', 'visible',
236 tt.getElement().style.visibility);
237 goog.testing.events.fireBrowserEvent(
238 new goog.events.Event(goog.events.EventType.BLUR, hoverTarget));
239 clock.tick(51);
240 assertEquals('hidden', tt.getElement().style.visibility);
241
242 goog.testing.events.fireMouseMoveEvent(hoverTarget);
243 goog.testing.events.fireMouseOverEvent(hoverTarget, elsewhere);
244 goog.testing.events.fireMouseOutEvent(hoverTarget, elsewhere);
245 goog.testing.events.fireMouseOverEvent(hoverTarget, elsewhere);
246 clock.tick(101);
247 assertEquals(
248 'A cancelled trigger should also cancel the seen interaction', 'hidden',
249 tt.getElement().style.visibility);
250 }
251
252 function testDispose() {
253 var element = tt.getElement();
254 tt.dispose();
255 assertTrue('Tooltip should have been disposed of', tt.isDisposed());
256 assertNull(
257 'Tooltip element reference should have been nulled out', tt.getElement());
258 assertNotEquals(
259 'Tooltip element should not be a child of the body', document.body,
260 element.parentNode);
261 }
262
263 function testNested() {
264 var ttNested;
265 tt.getElement().appendChild(
266 dom.createDom(goog.dom.TagName.SPAN, {id: 'nested'}, 'Goodbye'));
267 ttNested = new goog.ui.Tooltip(undefined, undefined, dom);
268 ttNested.setElement(
269 dom.createDom(goog.dom.TagName.DIV, {id: 'nestedPopup'}, 'hi'));
270 tt.setShowDelayMs(100);
271 tt.setHideDelayMs(50);
272 ttNested.setShowDelayMs(75);
273 ttNested.setHideDelayMs(25);
274 var nestedAnchor = dom.getElement('nested');
275 var hoverTarget = dom.getElement('hovertarget');
276 var outerTooltip = dom.getElement('popup');
277 var innerTooltip = dom.getElement('nestedPopup');
278 var elsewhere = dom.getElement('notpopup');
279
280 ttNested.attach(nestedAnchor);
281 tt.attach(hoverTarget);
282
283 // Test mouse into, out of nested tooltip
284 goog.testing.events.fireMouseOverEvent(hoverTarget, elsewhere);
285 clock.tick(101);
286 goog.testing.events.fireMouseOutEvent(hoverTarget, outerTooltip);
287 goog.testing.events.fireMouseOverEvent(outerTooltip, hoverTarget);
288 clock.tick(51);
289 assertEquals('visible', tt.getElement().style.visibility);
290 goog.testing.events.fireMouseOutEvent(outerTooltip, nestedAnchor);
291 goog.testing.events.fireMouseOverEvent(nestedAnchor, outerTooltip);
292 clock.tick(76);
293 assertEquals('visible', tt.getElement().style.visibility);
294 assertEquals('visible', ttNested.getElement().style.visibility);
295 goog.testing.events.fireMouseOutEvent(nestedAnchor, outerTooltip);
296 goog.testing.events.fireMouseOverEvent(outerTooltip, nestedAnchor);
297 clock.tick(100);
298 assertEquals('visible', tt.getElement().style.visibility);
299 assertEquals('hidden', ttNested.getElement().style.visibility);
300
301 // Go back in nested tooltip and then out through tooltip element.
302 goog.testing.events.fireMouseOutEvent(outerTooltip, nestedAnchor);
303 goog.testing.events.fireMouseOverEvent(nestedAnchor, outerTooltip);
304 clock.tick(76);
305 goog.testing.events.fireMouseOutEvent(nestedAnchor, innerTooltip);
306 goog.testing.events.fireMouseOverEvent(innerTooltip, nestedAnchor);
307 clock.tick(15);
308 assertEquals('visible', tt.getElement().style.visibility);
309 assertEquals('visible', ttNested.getElement().style.visibility);
310 goog.testing.events.fireMouseOutEvent(innerTooltip, elsewhere);
311 clock.tick(26);
312 assertEquals('hidden', ttNested.getElement().style.visibility);
313 clock.tick(51);
314 assertEquals('hidden', tt.getElement().style.visibility);
315
316 // Test with focus
317 goog.testing.events.fireBrowserEvent(
318 new goog.events.Event(goog.events.EventType.FOCUS, hoverTarget));
319 clock.tick(101);
320 goog.testing.events.fireBrowserEvent(
321 new goog.events.Event(goog.events.EventType.BLUR, hoverTarget));
322 goog.testing.events.fireBrowserEvent(
323 new goog.events.Event(goog.events.EventType.FOCUS, nestedAnchor));
324 clock.tick(76);
325 assertEquals('visible', tt.getElement().style.visibility);
326 assertEquals('visible', ttNested.getElement().style.visibility);
327 goog.testing.events.fireBrowserEvent(
328 new goog.events.Event(goog.events.EventType.BLUR, nestedAnchor));
329 goog.testing.events.fireBrowserEvent(
330 new goog.events.Event(goog.events.EventType.FOCUS, hoverTarget));
331 clock.tick(26);
332 assertEquals('visible', tt.getElement().style.visibility);
333 assertEquals('hidden', ttNested.getElement().style.visibility);
334
335 ttNested.onHide();
336 ttNested.dispose();
337 }
338
339 function testPosition() {
340 dom.getDocument().body.style.paddingBottom = '150%'; // force scrollbar
341 var scrollEl = dom.getDocumentScrollElement();
342
343 var anchor = dom.getElement('hovertarget');
344 var tooltip = new goog.ui.Tooltip(anchor, 'foo');
345 tooltip.getElement().style.position = 'absolute';
346
347 tooltip.cursorPosition.x = 100;
348 tooltip.cursorPosition.y = 100;
349 tooltip.showForElement(anchor);
350
351 assertEquals(
352 'Tooltip should be at cursor position',
353 '(110, 110)', // (100, 100) + padding (10, 10)
354 goog.style.getPageOffset(tooltip.getElement()).toString());
355
356 scrollEl.scrollTop = 50;
357
358 var offset = goog.style.getPageOffset(tooltip.getElement());
359 assertTrue(
360 'Tooltip should be at cursor position when scrolled',
361 Math.abs(offset.x - 110) <= ALLOWED_OFFSET); // 100 + padding 10
362 assertTrue(
363 'Tooltip should be at cursor position when scrolled',
364 Math.abs(offset.y - 110) <= ALLOWED_OFFSET); // 100 + padding 10
365
366 tooltip.dispose();
367 dom.getDocument().body.style.paddingTop = '';
368 scrollEl.scrollTop = 0;
369 }
370
371 function testPositionOverride() {
372 var anchor = dom.getElement('hovertarget');
373 var tooltip = new TestTooltip(anchor, 'foo', dom);
374
375 tooltip.showForElement(anchor);
376
377 assertEquals(
378 'Tooltip should be at absolute position', '(13, 17)',
379 goog.style.getPageOffset(tooltip.getElement()).toString());
380 tooltip.dispose();
381 }
382
383 function testHtmlContent() {
384 tt.setSafeHtml(
385 goog.html.testing.newSafeHtmlForTest(
386 '<span class="theSpan">Hello</span>'));
387 var spanEl = goog.dom.getElementByClass('theSpan', tt.getElement());
388 assertEquals('Hello', goog.dom.getTextContent(spanEl));
389 }
390
391 function testSetElementNull() {
392 tt.setElement(null);
393 }
394
395 function testFocusBlurElementsInTooltip() {
396 var anchorEl = dom.getElement('hovertarget');
397 goog.dom.setFocusableTabIndex(anchorEl, true);
398 tt.attach(anchorEl);
399 goog.testing.events.fireFocusEvent(anchorEl);
400 clock.tick(1000);
401 assertEquals('visible', tt.getElement().style.visibility);
402
403 goog.testing.events.fireBlurEvent(anchorEl);
404 tt.tooltipFocusHandler_.dispatchEvent(
405 goog.events.FocusHandler.EventType.FOCUSIN);
406 clock.tick(1000);
407 assertEquals('visible', tt.getElement().style.visibility);
408
409 // Run blur on the previous element followed by focus on the element being
410 // focused, as would normally happen when focus() is called on an element.
411 tt.tooltipFocusHandler_.dispatchEvent(
412 goog.events.FocusHandler.EventType.FOCUSOUT);
413 tt.tooltipFocusHandler_.dispatchEvent(
414 goog.events.FocusHandler.EventType.FOCUSIN);
415 clock.tick(1000);
416 assertEquals('visible', tt.getElement().style.visibility);
417
418 tt.tooltipFocusHandler_.dispatchEvent(
419 goog.events.FocusHandler.EventType.FOCUSOUT);
420 clock.tick(1000);
421 assertEquals('hidden', tt.getElement().style.visibility);
422 }
423
424 function testFocusElementInTooltipThenBackToAnchor() {
425 var anchorEl = dom.getElement('hovertarget');
426 goog.dom.setFocusableTabIndex(anchorEl, true);
427 tt.attach(anchorEl);
428 goog.testing.events.fireFocusEvent(anchorEl);
429 clock.tick(1000);
430 assertEquals('visible', tt.getElement().style.visibility);
431
432 // Run blur on the previous element followed by focus on the element being
433 // focused, as would normally happen when focus() is called on an element.
434 goog.testing.events.fireBlurEvent(anchorEl);
435 tt.tooltipFocusHandler_.dispatchEvent(
436 goog.events.FocusHandler.EventType.FOCUSIN);
437 clock.tick(1000);
438 assertEquals('visible', tt.getElement().style.visibility);
439
440 // Run blur on the previous element followed by focus on the element being
441 // focused, as would normally happen when focus() is called on an element.
442 tt.tooltipFocusHandler_.dispatchEvent(
443 goog.events.FocusHandler.EventType.FOCUSOUT);
444 goog.testing.events.fireFocusEvent(anchorEl);
445 clock.tick(1000);
446 assertEquals('visible', tt.getElement().style.visibility);
447
448 goog.testing.events.fireBlurEvent(anchorEl);
449 clock.tick(1000);
450 assertEquals('hidden', tt.getElement().style.visibility);
451 }