Debian Codegraph @

closure-library/closure/goog/editor/seamlessfield_test.js

raw
1 // Copyright 2009 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 /**
16 * @fileoverview Trogedit unit tests for goog.editor.SeamlessField.
17 *
18 * @author [email protected] (Nick Santos)
19 * @suppress {missingProperties} There are many mocks in this unit test,
20 * and the mocks don't fit well in the type system.
21 */
22
23 /** @suppress {extraProvide} */
24 goog.provide('goog.editor.seamlessfield_test');
25
26 goog.require('goog.dom');
27 goog.require('goog.dom.DomHelper');
28 goog.require('goog.dom.Range');
29 goog.require('goog.dom.TagName');
30 goog.require('goog.editor.BrowserFeature');
31 goog.require('goog.editor.Field');
32 goog.require('goog.editor.SeamlessField');
33 goog.require('goog.events');
34 goog.require('goog.functions');
35 goog.require('goog.html.SafeHtml');
36 goog.require('goog.style');
37 goog.require('goog.testing.MockClock');
38 goog.require('goog.testing.MockRange');
39 goog.require('goog.testing.jsunit');
40
41 goog.setTestOnly('seamlessfield_test');
42
43 var fieldElem;
44 var fieldElemClone;
45
46 function setUp() {
47 fieldElem = goog.dom.getElement('field');
48 fieldElemClone = fieldElem.cloneNode(true);
49 }
50
51 function tearDown() {
52 fieldElem.parentNode.replaceChild(fieldElemClone, fieldElem);
53 }
54
55 // the following tests check for blended iframe positioning. They really
56 // only make sense on browsers without contentEditable.
57 function testBlankField() {
58 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
59 assertAttachSeamlessIframeSizesCorrectly(
60 initSeamlessField(' ', {}), createSeamlessIframe());
61 }
62 }
63
64 function testFieldWithContent() {
65 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
66 assertAttachSeamlessIframeSizesCorrectly(
67 initSeamlessField('Hi!', {}), createSeamlessIframe());
68 }
69 }
70
71 function testFieldWithPadding() {
72 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
73 assertAttachSeamlessIframeSizesCorrectly(
74 initSeamlessField('Hi!', {'padding': '2px 5px'}),
75 createSeamlessIframe());
76 }
77 }
78
79 function testFieldWithMargin() {
80 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
81 assertAttachSeamlessIframeSizesCorrectly(
82 initSeamlessField('Hi!', {'margin': '2px 5px'}),
83 createSeamlessIframe());
84 }
85 }
86
87 function testFieldWithBorder() {
88 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
89 assertAttachSeamlessIframeSizesCorrectly(
90 initSeamlessField('Hi!', {'border': '2px 5px'}),
91 createSeamlessIframe());
92 }
93 }
94
95 function testFieldWithOverflow() {
96 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
97 assertAttachSeamlessIframeSizesCorrectly(
98 initSeamlessField(
99 ['1', '2', '3', '4', '5', '6', '7'].join('<p/>'),
100 {'overflow': 'auto', 'position': 'relative', 'height': '20px'}),
101 createSeamlessIframe());
102 assertEquals(20, fieldElem.offsetHeight);
103 }
104 }
105
106 function testFieldWithOverflowAndPadding() {
107 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
108 var blendedField =
109 initSeamlessField(['1', '2', '3', '4', '5', '6', '7'].join('<p/>'), {
110 'overflow': 'auto',
111 'position': 'relative',
112 'height': '20px',
113 'padding': '2px 3px'
114 });
115 var blendedIframe = createSeamlessIframe();
116 assertAttachSeamlessIframeSizesCorrectly(blendedField, blendedIframe);
117 assertEquals(24, fieldElem.offsetHeight);
118 }
119 }
120
121 function testIframeHeightGrowsOnWrap() {
122 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
123 var clock = new goog.testing.MockClock(true);
124 var blendedField;
125 try {
126 blendedField = initSeamlessField(
127 '', {'border': '1px solid black', 'height': '20px'});
128 blendedField.makeEditable();
129 blendedField.setSafeHtml(
130 false,
131 goog.html.SafeHtml.htmlEscape(
132 'Content that should wrap after resize.'));
133
134 // Ensure that the field was fully loaded and sized before measuring.
135 clock.tick(1);
136
137 // Capture starting heights.
138 var unwrappedIframeHeight = blendedField.getEditableIframe().offsetHeight;
139
140 // Resize the field such that the text should wrap.
141 fieldElem.style.width = '200px';
142 blendedField.doFieldSizingGecko();
143
144 // Iframe should grow as a result.
145 var wrappedIframeHeight = blendedField.getEditableIframe().offsetHeight;
146 assertTrue(
147 'Wrapped text should cause iframe to grow - initial height: ' +
148 unwrappedIframeHeight + ', wrapped height: ' +
149 wrappedIframeHeight,
150 wrappedIframeHeight > unwrappedIframeHeight);
151 } finally {
152 blendedField.dispose();
153 clock.dispose();
154 }
155 }
156 }
157
158 function testDispatchIframeResizedForWrapperHeight() {
159 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
160 var clock = new goog.testing.MockClock(true);
161 var blendedField = initSeamlessField('Hi!', {'border': '2px 5px'});
162 var iframe = createSeamlessIframe();
163 blendedField.attachIframe(iframe);
164
165 var resizeCalled = false;
166 goog.events.listenOnce(
167 blendedField, goog.editor.Field.EventType.IFRAME_RESIZED,
168 function() { resizeCalled = true; });
169
170 try {
171 blendedField.makeEditable();
172 blendedField.setSafeHtml(
173 false,
174 goog.html.SafeHtml.htmlEscape(
175 'Content that should wrap after resize.'));
176
177 // Ensure that the field was fully loaded and sized before measuring.
178 clock.tick(1);
179
180 assertFalse('Iframe resize must not be dispatched yet', resizeCalled);
181
182 // Resize the field such that the text should wrap.
183 fieldElem.style.width = '200px';
184 blendedField.sizeIframeToWrapperGecko_();
185 assertTrue('Iframe resize must be dispatched for Wrapper', resizeCalled);
186 } finally {
187 blendedField.dispose();
188 clock.dispose();
189 }
190 }
191 }
192
193 function testDispatchIframeResizedForBodyHeight() {
194 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
195 var clock = new goog.testing.MockClock(true);
196 var blendedField = initSeamlessField('Hi!', {'border': '2px 5px'});
197 var iframe = createSeamlessIframe();
198 blendedField.attachIframe(iframe);
199
200 var resizeCalled = false;
201 goog.events.listenOnce(
202 blendedField, goog.editor.Field.EventType.IFRAME_RESIZED,
203 function() { resizeCalled = true; });
204
205 try {
206 blendedField.makeEditable();
207 blendedField.setSafeHtml(
208 false,
209 goog.html.SafeHtml.htmlEscape(
210 'Content that should wrap after resize.'));
211
212 // Ensure that the field was fully loaded and sized before measuring.
213 clock.tick(1);
214
215 assertFalse('Iframe resize must not be dispatched yet', resizeCalled);
216
217 // Resize the field to a different body height.
218 var bodyHeight = blendedField.getIframeBodyHeightGecko_();
219 blendedField.getIframeBodyHeightGecko_ = function() {
220 return bodyHeight + 1;
221 };
222 blendedField.sizeIframeToBodyHeightGecko_();
223 assertTrue('Iframe resize must be dispatched for Body', resizeCalled);
224 } finally {
225 blendedField.dispose();
226 clock.dispose();
227 }
228 }
229 }
230
231 function testDispatchBlur() {
232 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE &&
233 !goog.editor.BrowserFeature.CLEARS_SELECTION_WHEN_FOCUS_LEAVES) {
234 var blendedField = initSeamlessField('Hi!', {'border': '2px 5px'});
235 var iframe = createSeamlessIframe();
236 blendedField.attachIframe(iframe);
237
238 var blurCalled = false;
239 goog.events.listenOnce(
240 blendedField, goog.editor.Field.EventType.BLUR,
241 function() { blurCalled = true; });
242
243 var clearSelection = goog.dom.Range.clearSelection;
244 var cleared = false;
245 var clearedWindow;
246 blendedField.editableDomHelper = new goog.dom.DomHelper();
247 blendedField.editableDomHelper.getWindow =
248 goog.functions.constant(iframe.contentWindow);
249 var mockRange = new goog.testing.MockRange();
250 blendedField.getRange = function() { return mockRange; };
251 goog.dom.Range.clearSelection = function(opt_window) {
252 clearSelection(opt_window);
253 cleared = true;
254 clearedWindow = opt_window;
255 };
256 var clock = new goog.testing.MockClock(true);
257
258 mockRange.collapse(true);
259 mockRange.select();
260 mockRange.$replay();
261 blendedField.dispatchBlur();
262 clock.tick(1);
263
264 assertTrue('Blur must be dispatched.', blurCalled);
265 assertTrue('Selection must be cleared.', cleared);
266 assertEquals(
267 'Selection must be cleared in iframe', iframe.contentWindow,
268 clearedWindow);
269 mockRange.$verify();
270 clock.dispose();
271 }
272 }
273
274 function testSetMinHeight() {
275 if (!goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
276 var clock = new goog.testing.MockClock(true);
277 try {
278 var field = initSeamlessField(
279 ['1', '2', '3', '4', '5', '6', '7'].join('<p/>'),
280 {'position': 'relative', 'height': '60px'});
281
282 // Initially create and size iframe.
283 var iframe = createSeamlessIframe();
284 field.attachIframe(iframe);
285 field.iframeFieldLoadHandler(iframe, '', {});
286 // Need to process timeouts set by load handlers.
287 clock.tick(1000);
288
289 var normalHeight = goog.style.getSize(iframe).height;
290
291 var delayedChangeCalled = false;
292 goog.events.listen(
293 field, goog.editor.Field.EventType.DELAYEDCHANGE,
294 function() { delayedChangeCalled = true; });
295
296 // Test that min height is obeyed.
297 field.setMinHeight(30);
298 clock.tick(1000);
299 assertEquals(
300 'Iframe height must match min height.', 30,
301 goog.style.getSize(iframe).height);
302 assertFalse(
303 'Setting min height must not cause delayed change event.',
304 delayedChangeCalled);
305
306 // Test that min height doesn't shrink field.
307 field.setMinHeight(0);
308 clock.tick(1000);
309 assertEquals(normalHeight, goog.style.getSize(iframe).height);
310 assertFalse(
311 'Setting min height must not cause delayed change event.',
312 delayedChangeCalled);
313 } finally {
314 field.dispose();
315 clock.dispose();
316 }
317 }
318 }
319
320
321 /**
322 * @bug 1649967 This code used to throw a Javascript error.
323 */
324 function testSetMinHeightWithNoIframe() {
325 if (goog.editor.BrowserFeature.HAS_CONTENT_EDITABLE) {
326 try {
327 var field = initSeamlessField('&nbsp;', {});
328 field.makeEditable();
329 field.setMinHeight(30);
330 } finally {
331 field.dispose();
332 }
333 }
334 }
335
336 function testStartChangeEvents() {
337 if (goog.editor.BrowserFeature.USE_MUTATION_EVENTS) {
338 var clock = new goog.testing.MockClock(true);
339
340 try {
341 var field = initSeamlessField('&nbsp;', {});
342 field.makeEditable();
343
344 var changeCalled = false;
345 goog.events.listenOnce(
346 field, goog.editor.Field.EventType.CHANGE,
347 function() { changeCalled = true; });
348
349 var delayedChangeCalled = false;
350 goog.events.listenOnce(
351 field, goog.editor.Field.EventType.CHANGE,
352 function() { delayedChangeCalled = true; });
353
354 field.stopChangeEvents(true, true);
355 if (field.changeTimerGecko_) {
356 field.changeTimerGecko_.start();
357 }
358
359 field.startChangeEvents();
360 clock.tick(1000);
361
362 assertFalse(changeCalled);
363 assertFalse(delayedChangeCalled);
364 } finally {
365 clock.dispose();
366 field.dispose();
367 }
368 }
369 }
370
371 function testManipulateDom() {
372 // Test in blended field since that is what fires change events.
373 var editableField = initSeamlessField('&nbsp;', {});
374 var clock = new goog.testing.MockClock(true);
375
376 var delayedChangeCalled = 0;
377 goog.events.listen(
378 editableField, goog.editor.Field.EventType.DELAYEDCHANGE,
379 function() { delayedChangeCalled++; });
380
381 assertFalse(editableField.isLoaded());
382 editableField.manipulateDom(goog.nullFunction);
383 clock.tick(1000);
384 assertEquals(
385 'Must not fire delayed change events if field is not loaded.', 0,
386 delayedChangeCalled);
387
388 editableField.makeEditable();
389 var usesIframe = editableField.usesIframe();
390
391 try {
392 editableField.manipulateDom(goog.nullFunction);
393 clock.tick(1000); // Wait for delayed change to fire.
394 assertEquals(
395 'By default must fire a single delayed change event.', 1,
396 delayedChangeCalled);
397
398 editableField.manipulateDom(goog.nullFunction, true);
399 clock.tick(1000); // Wait for delayed change to fire.
400 assertEquals(
401 'Must prevent all delayed change events.', 1, delayedChangeCalled);
402
403 editableField.manipulateDom(function() {
404 this.handleChange();
405 this.handleChange();
406 if (this.changeTimerGecko_) {
407 this.changeTimerGecko_.fire();
408 }
409
410 this.dispatchDelayedChange_();
411 this.delayedChangeTimer_.fire();
412 }, false, editableField);
413 clock.tick(1000); // Wait for delayed change to fire.
414 assertEquals(
415 'Must ignore dispatch delayed change called within func.', 2,
416 delayedChangeCalled);
417 } finally {
418 // Ensure we always uninstall the mock clock and dispose of everything.
419 editableField.dispose();
420 clock.dispose();
421 }
422 }
423
424 function testAttachIframe() {
425 var blendedField = initSeamlessField('Hi!', {});
426 var iframe = createSeamlessIframe();
427 try {
428 blendedField.attachIframe(iframe);
429 } catch (err) {
430 fail('Error occurred while attaching iframe.');
431 }
432 }
433
434
435 function createSeamlessIframe() {
436 // NOTE(nicksantos): This is a reimplementation of
437 // TR_EditableUtil.getIframeAttributes, but untangled for tests, and
438 // specifically with what we need for blended mode.
439 return goog.dom.createDom(
440 goog.dom.TagName.IFRAME, {'frameBorder': '0', 'style': 'padding:0;'});
441 }
442
443
444 /**
445 * Initialize a new editable field for the field id 'field', with the given
446 * innerHTML and styles.
447 *
448 * @param {string} innerHTML html for the field contents.
449 * @param {Object} styles Key-value pairs for styles on the field.
450 * @return {goog.editor.SeamlessField} The field.
451 */
452 function initSeamlessField(innerHTML, styles) {
453 var field = new goog.editor.SeamlessField('field');
454 fieldElem.innerHTML = innerHTML;
455 goog.style.setStyle(fieldElem, styles);
456 return field;
457 }
458
459
460 /**
461 * Make sure that the original field element for the given goog.editor.Field has
462 * the same size before and after attaching the given iframe. If this is not
463 * true, then the field will fidget while we're initializing the field,
464 * and that's not what we want.
465 *
466 * @param {goog.editor.Field} fieldObj The field.
467 * @param {HTMLIFrameElement} iframe The iframe.
468 */
469 function assertAttachSeamlessIframeSizesCorrectly(fieldObj, iframe) {
470 var size = goog.style.getSize(fieldObj.getOriginalElement());
471 fieldObj.attachIframe(iframe);
472 var newSize = goog.style.getSize(fieldObj.getOriginalElement());
473
474 assertEquals(size.width, newSize.width);
475 assertEquals(size.height, newSize.height);
476 }