Debian Codegraph @

closure-library/closure/goog/fx/dragger_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.fx.DraggerTest');
16 goog.setTestOnly('goog.fx.DraggerTest');
17
18 goog.require('goog.dom');
19 goog.require('goog.dom.TagName');
20 goog.require('goog.events');
21 goog.require('goog.events.BrowserEvent');
22 goog.require('goog.events.Event');
23 goog.require('goog.events.EventType');
24 goog.require('goog.fx.Dragger');
25 goog.require('goog.math.Rect');
26 goog.require('goog.style.bidi');
27 goog.require('goog.testing.StrictMock');
28 goog.require('goog.testing.events');
29 goog.require('goog.testing.jsunit');
30 goog.require('goog.userAgent');
31
32 var HAS_SET_CAPTURE = goog.fx.Dragger.HAS_SET_CAPTURE_;
33
34 var target;
35 var targetRtl;
36
37 function setUp() {
38 var sandbox = goog.dom.getElement('sandbox');
39 target = goog.dom.createDom(goog.dom.TagName.DIV, {
40 'id': 'target',
41 'style': 'display:none;position:absolute;top:15px;left:10px'
42 });
43 sandbox.appendChild(target);
44 sandbox.appendChild(goog.dom.createDom(goog.dom.TagName.DIV, {id: 'handle'}));
45
46 var sandboxRtl = goog.dom.getElement('sandbox_rtl');
47 targetRtl = goog.dom.createDom(goog.dom.TagName.DIV, {
48 'id': 'target_rtl',
49 'style': 'position:absolute; top:15px; right:10px; width:10px; ' +
50 'height: 10px; background: green;'
51 });
52 sandboxRtl.appendChild(targetRtl);
53 sandboxRtl.appendChild(goog.dom.createDom(goog.dom.TagName.DIV, {
54 'id': 'background_rtl',
55 'style': 'width: 10000px;height:50px;position:absolute;color:blue;'
56 }));
57 sandboxRtl.appendChild(
58 goog.dom.createDom(goog.dom.TagName.DIV, {id: 'handle_rtl'}));
59 }
60
61 function tearDown() {
62 goog.dom.removeChildren(goog.dom.getElement('sandbox'));
63 goog.dom.removeChildren(goog.dom.getElement('sandbox_rtl'));
64 goog.events.removeAll(document);
65 }
66
67 function testStartDrag() {
68 runStartDragTest('handle', target);
69 }
70
71 function testStartDrag_rtl() {
72 runStartDragTest('handle_rtl', targetRtl);
73 }
74
75 function runStartDragTest(handleId, targetElement) {
76 var dragger =
77 new goog.fx.Dragger(targetElement, goog.dom.getElement(handleId));
78 if (handleId == 'handle_rtl') {
79 dragger.enableRightPositioningForRtl(true);
80 }
81 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
82 e.type = goog.events.EventType.MOUSEDOWN;
83 e.clientX = 1;
84 e.clientY = 2;
85 e.isMouseActionButton().$returns(true);
86 e.preventDefault();
87 e.isMouseActionButton().$returns(true);
88 e.preventDefault();
89 e.$replay();
90
91 goog.events.listen(dragger, goog.fx.Dragger.EventType.START, function() {
92 targetElement.style.display = 'block';
93 });
94
95 dragger.startDrag(e);
96
97 assertTrue(
98 'Start drag with no hysteresis must actually start the drag.',
99 dragger.isDragging());
100 if (handleId == 'handle_rtl') {
101 assertEquals(10, goog.style.bidi.getOffsetStart(targetElement));
102 }
103 assertEquals(
104 'Dragger startX must match event\'s clientX.', 1, dragger.startX);
105 assertEquals(
106 'Dragger clientX must match event\'s clientX', 1, dragger.clientX);
107 assertEquals(
108 'Dragger startY must match event\'s clientY.', 2, dragger.startY);
109 assertEquals(
110 'Dragger clientY must match event\'s clientY', 2, dragger.clientY);
111 assertEquals(
112 'Dragger deltaX must match target\'s offsetLeft', 10, dragger.deltaX);
113 assertEquals(
114 'Dragger deltaY must match target\'s offsetTop', 15, dragger.deltaY);
115
116 dragger = new goog.fx.Dragger(targetElement, goog.dom.getElement(handleId));
117 dragger.setHysteresis(1);
118 dragger.startDrag(e);
119 assertFalse(
120 'Start drag with a valid non-zero hysteresis should not start ' +
121 'the drag.',
122 dragger.isDragging());
123 e.$verify();
124 }
125
126
127 /**
128 * @bug 1381317 Cancelling start drag didn't end the attempt to drag.
129 */
130 function testStartDrag_Cancel() {
131 var dragger = new goog.fx.Dragger(target);
132
133 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
134 e.type = goog.events.EventType.MOUSEDOWN;
135 e.clientX = 1;
136 e.clientY = 2;
137 e.isMouseActionButton().$returns(true);
138 e.$replay();
139
140 goog.events.listen(dragger, goog.fx.Dragger.EventType.START, function(e) {
141 // Cancel drag.
142 e.preventDefault();
143 });
144
145 dragger.startDrag(e);
146
147 assertFalse('Start drag must have been cancelled.', dragger.isDragging());
148 assertFalse(
149 'Dragger must not have registered mousemove handlers.',
150 goog.events.hasListener(
151 dragger.document_, goog.events.EventType.MOUSEMOVE,
152 !HAS_SET_CAPTURE));
153 assertFalse(
154 'Dragger must not have registered mouseup handlers.',
155 goog.events.hasListener(
156 dragger.document_, goog.events.EventType.MOUSEUP, !HAS_SET_CAPTURE));
157 e.$verify();
158 }
159
160
161 /**
162 * Tests that start drag happens on left mousedown.
163 */
164 function testStartDrag_LeftMouseDownOnly() {
165 var dragger = new goog.fx.Dragger(target);
166
167 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
168 e.type = goog.events.EventType.MOUSEDOWN;
169 e.clientX = 1;
170 e.clientY = 2;
171 e.isMouseActionButton().$returns(false);
172 e.$replay();
173
174 goog.events.listen(dragger, goog.fx.Dragger.EventType.START, function(e) {
175 fail('No drag START event should have been dispatched');
176 });
177
178 dragger.startDrag(e);
179
180 assertFalse('Start drag must have been cancelled.', dragger.isDragging());
181 assertFalse(
182 'Dragger must not have registered mousemove handlers.',
183 goog.events.hasListener(
184 dragger.document_, goog.events.EventType.MOUSEMOVE, true));
185 assertFalse(
186 'Dragger must not have registered mouseup handlers.',
187 goog.events.hasListener(
188 dragger.document_, goog.events.EventType.MOUSEUP, true));
189 e.$verify();
190 }
191
192
193 /**
194 * Tests that start drag happens on other event type than MOUSEDOWN.
195 */
196 function testStartDrag_MouseMove() {
197 var dragger = new goog.fx.Dragger(target);
198
199 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
200 e.type = goog.events.EventType.MOUSEMOVE;
201 e.clientX = 1;
202 e.clientY = 2;
203 // preventDefault is not called.
204 e.$replay();
205
206 var startDragFired = false;
207 goog.events.listen(dragger, goog.fx.Dragger.EventType.START, function(e) {
208 startDragFired = true;
209 });
210
211 dragger.startDrag(e);
212
213 assertTrue('Dragging should be in progress.', dragger.isDragging());
214 assertTrue('Start drag event should have fired.', startDragFired);
215 assertTrue(
216 'Dragger must have registered mousemove handlers.',
217 goog.events.hasListener(
218 dragger.document_, goog.events.EventType.MOUSEMOVE,
219 !HAS_SET_CAPTURE));
220 assertTrue(
221 'Dragger must have registered mouseup handlers.',
222 goog.events.hasListener(
223 dragger.document_, goog.events.EventType.MOUSEUP, !HAS_SET_CAPTURE));
224 e.$verify();
225 }
226
227
228 /**
229 * Tests that preventDefault is not called for TOUCHSTART event.
230 */
231 function testStartDrag_TouchStart() {
232 var dragger = new goog.fx.Dragger(target);
233
234 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
235 e.type = goog.events.EventType.TOUCHSTART;
236 // preventDefault is not called.
237 e.$replay();
238
239 var startDragFired = false;
240 goog.events.listen(dragger, goog.fx.Dragger.EventType.START, function(e) {
241 startDragFired = true;
242 });
243
244 dragger.startDrag(e);
245
246 assertTrue('Dragging should be in progress.', dragger.isDragging());
247 assertTrue('Start drag event should have fired.', startDragFired);
248 assertTrue(
249 'Dragger must have registered touchstart listener.',
250 goog.events.hasListener(
251 dragger.handle, goog.events.EventType.TOUCHSTART, false /*opt_cap*/));
252 e.$verify();
253 }
254
255
256 /**
257 * Tests that preventDefault is not called for TOUCHSTART event when hysteresis
258 * is set to be greater than zero.
259 */
260 function testStartDrag_TouchStart_NonZeroHysteresis() {
261 var dragger = new goog.fx.Dragger(target);
262 dragger.setHysteresis(5);
263 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
264 e.type = goog.events.EventType.TOUCHSTART;
265 // preventDefault is not called.
266 e.$replay();
267
268 var startDragFired = false;
269 goog.events.listen(dragger, goog.fx.Dragger.EventType.START, function(e) {
270 startDragFired = true;
271 });
272
273 dragger.startDrag(e);
274
275 assertFalse(
276 'Start drag must not start drag because of hysterisis.',
277 dragger.isDragging());
278 assertTrue(
279 'Dragger must have registered touchstart listener.',
280 goog.events.hasListener(
281 dragger.handle, goog.events.EventType.TOUCHSTART, false /*opt_cap*/));
282 e.$verify();
283 }
284
285
286 /**
287 * @bug 1381317 Cancelling start drag didn't end the attempt to drag.
288 */
289 function testHandleMove_Cancel() {
290 var dragger = new goog.fx.Dragger(target);
291 dragger.setHysteresis(5);
292
293 goog.events.listen(dragger, goog.fx.Dragger.EventType.START, function(e) {
294 // Cancel drag.
295 e.preventDefault();
296 });
297
298 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
299 e.clientX = 1;
300 e.clientY = 2;
301 e.isMouseActionButton().$returns(true).$anyTimes();
302 // preventDefault is not called.
303 e.$replay();
304 dragger.startDrag(e);
305 assertFalse(
306 'Start drag must not start drag because of hysterisis.',
307 dragger.isDragging());
308 assertTrue(
309 'Dragger must have registered mousemove handlers.',
310 goog.events.hasListener(
311 dragger.document_, goog.events.EventType.MOUSEMOVE,
312 !HAS_SET_CAPTURE));
313 assertTrue(
314 'Dragger must have registered mouseup handlers.',
315 goog.events.hasListener(
316 dragger.document_, goog.events.EventType.MOUSEUP, !HAS_SET_CAPTURE));
317
318 e.clientX = 10;
319 e.clientY = 10;
320 dragger.handleMove_(e);
321 assertFalse('Drag must be cancelled.', dragger.isDragging());
322 assertFalse(
323 'Dragger must unregistered mousemove handlers.',
324 goog.events.hasListener(
325 dragger.document_, goog.events.EventType.MOUSEMOVE, true));
326 assertFalse(
327 'Dragger must unregistered mouseup handlers.',
328 goog.events.hasListener(
329 dragger.document_, goog.events.EventType.MOUSEUP, true));
330 e.$verify();
331 }
332
333
334 /**
335 * @bug 1714667 IE<9 built in drag and drop handling stops dragging.
336 */
337 function testIeDragStartCancelling() {
338 // Testing only IE<9.
339 if (!goog.userAgent.IE || goog.userAgent.isVersionOrHigher(9)) {
340 return;
341 }
342
343 // Built in 'dragstart' cancelling not enabled.
344 var dragger = new goog.fx.Dragger(target);
345
346 var e = new goog.events.Event(goog.events.EventType.MOUSEDOWN);
347 e.clientX = 1;
348 e.clientY = 2;
349 e.button = 1; // IE only constant for left button.
350 var be = new goog.events.BrowserEvent(e);
351 dragger.startDrag(be);
352 assertTrue('The drag should have started.', dragger.isDragging());
353
354 e = new goog.events.Event(goog.events.EventType.DRAGSTART);
355 e.target = dragger.document_.documentElement;
356 assertTrue(
357 'The event should not be canceled.',
358 goog.testing.events.fireBrowserEvent(e));
359
360 dragger.dispose();
361
362 // Built in 'dragstart' cancelling enabled.
363 dragger = new goog.fx.Dragger(target);
364 dragger.setCancelIeDragStart(true);
365
366 e = new goog.events.Event(goog.events.EventType.MOUSEDOWN);
367 e.clientX = 1;
368 e.clientY = 2;
369 e.button = 1; // IE only constant for left button.
370 be = new goog.events.BrowserEvent(e);
371 dragger.startDrag(be);
372 assertTrue('The drag should have started.', dragger.isDragging());
373
374 e = new goog.events.Event(goog.events.EventType.DRAGSTART);
375 e.target = dragger.document_.documentElement;
376 assertFalse(
377 'The event should be canceled.', goog.testing.events.fireBrowserEvent(e));
378
379 dragger.dispose();
380 }
381
382
383 function testPreventMouseDown() {
384 var dragger = new goog.fx.Dragger(target);
385 dragger.setPreventMouseDown(false);
386
387 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
388 e.type = goog.events.EventType.MOUSEDOWN;
389 e.clientX = 1;
390 e.clientY = 2;
391 e.isMouseActionButton().$returns(true);
392 // preventDefault is not called.
393 e.$replay();
394
395 dragger.startDrag(e);
396
397 assertTrue('Dragging should be in progess.', dragger.isDragging());
398 e.$verify();
399 }
400
401 function testLimits() {
402 var dragger = new goog.fx.Dragger(target);
403
404 assertEquals(100, dragger.limitX(100));
405 assertEquals(100, dragger.limitY(100));
406
407 dragger.setLimits(new goog.math.Rect(10, 20, 30, 40));
408
409 assertEquals(10, dragger.limitX(0));
410 assertEquals(40, dragger.limitX(100));
411 assertEquals(20, dragger.limitY(0));
412 assertEquals(60, dragger.limitY(100));
413 }
414
415 function testWindowBlur() {
416 var dragger = new goog.fx.Dragger(target);
417 dragger.setAllowSetCapture(false);
418
419 var dragEnded = false;
420 goog.events.listen(dragger, goog.fx.Dragger.EventType.END, function(e) {
421 dragEnded = true;
422 });
423
424 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
425 e.type = goog.events.EventType.MOUSEDOWN;
426 e.clientX = 1;
427 e.clientY = 2;
428 e.isMouseActionButton().$returns(true);
429 e.preventDefault();
430 e.$replay();
431 dragger.startDrag(e);
432 e.$verify();
433
434 assertTrue(dragger.isDragging());
435
436 e = new goog.events.BrowserEvent();
437 e.type = goog.events.EventType.BLUR;
438 e.target = window;
439 e.currentTarget = window;
440 goog.testing.events.fireBrowserEvent(e);
441
442 assertTrue(dragEnded);
443 }
444
445 function testBlur() {
446 var dragger = new goog.fx.Dragger(target);
447 dragger.setAllowSetCapture(false);
448
449 var dragEnded = false;
450 goog.events.listen(dragger, goog.fx.Dragger.EventType.END, function(e) {
451 dragEnded = true;
452 });
453
454 var e = new goog.testing.StrictMock(goog.events.BrowserEvent);
455 e.type = goog.events.EventType.MOUSEDOWN;
456 e.clientX = 1;
457 e.clientY = 2;
458 e.isMouseActionButton().$returns(true);
459 e.preventDefault();
460 e.$replay();
461 dragger.startDrag(e);
462 e.$verify();
463
464 assertTrue(dragger.isDragging());
465
466 e = new goog.events.BrowserEvent();
467 e.type = goog.events.EventType.BLUR;
468 e.target = document.body;
469 e.currentTarget = document.body;
470 // Blur events do not bubble but the test event system does not emulate that
471 // part so we add a capturing listener on the target and stops the
472 // propagation at the target, preventing any event from bubbling.
473 goog.events.listen(document.body, goog.events.EventType.BLUR, function(e) {
474 e.propagationStopped_ = true;
475 }, true);
476 goog.testing.events.fireBrowserEvent(e);
477
478 assertFalse(dragEnded);
479 }
480
481 function testCloneNode() {
482 var element = goog.dom.createDom(goog.dom.TagName.DIV);
483 element.innerHTML = '<input type="hidden" value="v0">' +
484 '<textarea>v1</textarea>' +
485 '<textarea>v2</textarea>';
486 element.childNodes[0].value = '\'new\'\n"value"';
487 element.childNodes[1].value = '<' +
488 '/textarea>&lt;3';
489 element.childNodes[2].value = '<script>\n\talert("oops!");<' +
490 '/script>';
491 var clone = goog.fx.Dragger.cloneNode(element);
492 assertEquals(element.childNodes[0].value, clone.childNodes[0].value);
493 assertEquals(element.childNodes[1].value, clone.childNodes[1].value);
494 assertEquals(element.childNodes[2].value, clone.childNodes[2].value);
495 clone = goog.fx.Dragger.cloneNode(element.childNodes[2]);
496 assertEquals(element.childNodes[2].value, clone.value);
497 }