Debian Codegraph @

closure-library/closure/goog/messaging/portchannel_test.js

raw
1 // Copyright 2010 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.messaging.PortChannelTest');
16 goog.setTestOnly('goog.messaging.PortChannelTest');
17
18 goog.require('goog.Promise');
19 goog.require('goog.Timer');
20 goog.require('goog.dom');
21 goog.require('goog.dom.TagName');
22 goog.require('goog.events');
23 goog.require('goog.events.EventTarget');
24 goog.require('goog.events.EventType');
25 goog.require('goog.json');
26 goog.require('goog.messaging.PortChannel');
27 goog.require('goog.testing.MockControl');
28 goog.require('goog.testing.TestCase');
29 goog.require('goog.testing.jsunit');
30 goog.require('goog.testing.messaging.MockMessageEvent');
31
32
33 var mockControl;
34 var mockPort;
35 var portChannel;
36
37 var workerChannel;
38 var setUpPromise;
39 var timer;
40 var frameDiv;
41
42
43 function setUpPage() {
44 frameDiv = goog.dom.getElement('frame');
45
46 // Use a relatively long timeout because the iframe created by createIframe
47 // can take a couple seconds to load its JS.
48 goog.testing.TestCase.getActiveTestCase().promiseTimeout = 3 * 1000;
49
50 if (!('Worker' in goog.global)) {
51 return;
52 }
53
54 var worker = new Worker('testdata/portchannel_worker.js');
55 workerChannel = new goog.messaging.PortChannel(worker);
56
57 setUpPromise = new goog.Promise(function(resolve, reject) {
58 worker.onmessage = function(e) {
59 if (e.data == 'loaded') {
60 resolve();
61 }
62 };
63 });
64 }
65
66
67 function tearDownPage() {
68 goog.dispose(workerChannel);
69 }
70
71
72 function setUp() {
73 timer = new goog.Timer(50);
74 mockControl = new goog.testing.MockControl();
75 mockPort = new goog.events.EventTarget();
76 mockPort.postMessage = mockControl.createFunctionMock('postMessage');
77 portChannel = new goog.messaging.PortChannel(mockPort);
78
79 if ('Worker' in goog.global) {
80 // Ensure the worker channel has started before running each test.
81 return setUpPromise;
82 }
83 }
84
85
86 function tearDown() {
87 goog.dispose(timer);
88 portChannel.dispose();
89 goog.dom.removeChildren(frameDiv);
90 mockControl.$verifyAll();
91 }
92
93
94 /**
95 * Registers a service on a channel that will accept a single test message and
96 * then fire a Promise.
97 *
98 * @param {!goog.messaging.MessageChannel} channel
99 * @param {string} name The service name.
100 * @param {boolean=} opt_objectPayload Whether incoming payloads should be
101 * parsed as Objects instead of raw strings.
102 * @return {!goog.Promise<(string|!Object)>} A promise that resolves with the
103 * value of the first message received on the service.
104 */
105 function registerService(channel, name, opt_objectPayload) {
106 return new goog.Promise(function(resolve, reject) {
107 channel.registerService(name, resolve, opt_objectPayload);
108 });
109 }
110
111
112 function makeMessage(serviceName, payload) {
113 var msg = {'serviceName': serviceName, 'payload': payload};
114 msg[goog.messaging.PortChannel.FLAG] = true;
115 if (goog.messaging.PortChannel.REQUIRES_SERIALIZATION_) {
116 msg = goog.json.serialize(msg);
117 }
118 return msg;
119 }
120
121
122 function expectNoMessage() {
123 portChannel.registerDefaultService(
124 mockControl.createFunctionMock('expectNoMessage'));
125 }
126
127
128 function receiveMessage(serviceName, payload, opt_origin, opt_ports) {
129 mockPort.dispatchEvent(
130 goog.testing.messaging.MockMessageEvent.wrap(
131 makeMessage(serviceName, payload), opt_origin || 'http://google.com',
132 undefined, undefined, opt_ports));
133 }
134
135
136 function receiveNonChannelMessage(data) {
137 if (goog.messaging.PortChannel.REQUIRES_SERIALIZATION_ &&
138 !goog.isString(data)) {
139 data = goog.json.serialize(data);
140 }
141 mockPort.dispatchEvent(
142 goog.testing.messaging.MockMessageEvent.wrap(data, 'http://google.com'));
143 }
144
145
146 function testPostMessage() {
147 mockPort.postMessage(makeMessage('foobar', 'This is a value'), []);
148 mockControl.$replayAll();
149 portChannel.send('foobar', 'This is a value');
150 }
151
152
153 function testPostMessageWithPorts() {
154 if (!('MessageChannel' in goog.global)) {
155 return;
156 }
157 var channel = new MessageChannel();
158 var port1 = channel.port1;
159 var port2 = channel.port2;
160 mockPort.postMessage(
161 makeMessage('foobar', {
162 'val': [
163 {'_port': {'type': 'real', 'index': 0}},
164 {'_port': {'type': 'real', 'index': 1}}
165 ]
166 }),
167 [port1, port2]);
168 mockControl.$replayAll();
169 portChannel.send('foobar', {'val': [port1, port2]});
170 }
171
172 function testReceiveMessage() {
173 var promise = registerService(portChannel, 'foobar');
174 receiveMessage('foobar', 'This is a string');
175 return promise.then(function(msg) { assertEquals(msg, 'This is a string'); });
176 }
177
178
179 function testReceiveMessageWithPorts() {
180 if (!('MessageChannel' in goog.global)) {
181 return;
182 }
183 var channel = new MessageChannel();
184 var port1 = channel.port1;
185 var port2 = channel.port2;
186 var promise = registerService(portChannel, 'foobar', true);
187
188 receiveMessage(
189 'foobar', {
190 'val': [
191 {'_port': {'type': 'real', 'index': 0}},
192 {'_port': {'type': 'real', 'index': 1}}
193 ]
194 },
195 null, [port1, port2]);
196
197 return promise.then(function(msg) {
198 assertObjectEquals(msg, {'val': [port1, port2]});
199 });
200 }
201
202
203 function testReceiveNonChannelMessageWithStringBody() {
204 expectNoMessage();
205 mockControl.$replayAll();
206 receiveNonChannelMessage('Foo bar');
207 }
208
209
210 function testReceiveNonChannelMessageWithArrayBody() {
211 expectNoMessage();
212 mockControl.$replayAll();
213 receiveNonChannelMessage([5, 'Foo bar']);
214 }
215
216
217 function testReceiveNonChannelMessageWithNoFlag() {
218 expectNoMessage();
219 mockControl.$replayAll();
220 receiveNonChannelMessage(
221 {serviceName: 'foobar', payload: 'this is a payload'});
222 }
223
224
225 function testReceiveNonChannelMessageWithFalseFlag() {
226 expectNoMessage();
227 mockControl.$replayAll();
228 var body = {serviceName: 'foobar', payload: 'this is a payload'};
229 body[goog.messaging.PortChannel.FLAG] = false;
230 receiveNonChannelMessage(body);
231 }
232
233
234 // Integration tests
235
236
237 function testWorker() {
238 if (!('Worker' in goog.global)) {
239 return;
240 }
241 var promise = registerService(workerChannel, 'pong', true);
242 workerChannel.send('ping', {'val': 'fizzbang'});
243
244 return promise.then(function(msg) {
245 assertObjectEquals({'val': 'fizzbang'}, msg);
246 });
247 }
248
249
250 function testWorkerWithPorts() {
251 if (!('Worker' in goog.global) || !('MessageChannel' in goog.global)) {
252 return;
253 }
254 var messageChannel = new MessageChannel();
255 var promise = registerService(workerChannel, 'pong', true);
256 workerChannel.send('ping', {'port': messageChannel.port1});
257
258 return promise.then(function(msg) {
259 return assertPortsEntangled(msg['port'], messageChannel.port2);
260 });
261 }
262
263
264 function testPort() {
265 if (!('Worker' in goog.global) || !('MessageChannel' in goog.global)) {
266 return;
267 }
268 var messageChannel = new MessageChannel();
269 workerChannel.send('addPort', messageChannel.port1);
270 messageChannel.port2.start();
271 var realPortChannel = new goog.messaging.PortChannel(messageChannel.port2);
272 var promise = registerService(realPortChannel, 'pong', true);
273 realPortChannel.send('ping', {'val': 'fizzbang'});
274
275 return promise.then(function(msg) {
276 assertObjectEquals({'val': 'fizzbang'}, msg);
277
278 messageChannel.port2.close();
279 realPortChannel.dispose();
280 });
281 }
282
283
284 function testPortIgnoresOrigin() {
285 if (!('Worker' in goog.global) || !('MessageChannel' in goog.global)) {
286 return;
287 }
288 var messageChannel = new MessageChannel();
289 workerChannel.send('addPort', messageChannel.port1);
290 messageChannel.port2.start();
291 var realPortChannel = new goog.messaging.PortChannel(
292 messageChannel.port2, 'http://somewhere-else.com');
293 var promise = registerService(realPortChannel, 'pong', true);
294 realPortChannel.send('ping', {'val': 'fizzbang'});
295
296 return promise.then(function(msg) {
297 assertObjectEquals({'val': 'fizzbang'}, msg);
298
299 messageChannel.port2.close();
300 realPortChannel.dispose();
301 });
302 }
303
304
305 function testWindow() {
306 if (!('Worker' in goog.global) || !('MessageChannel' in goog.global)) {
307 return;
308 }
309
310 return createIframe().then(function(iframe) {
311 var peerOrigin = window.location.protocol + '//' + window.location.host;
312 var iframeChannel =
313 goog.messaging.PortChannel.forEmbeddedWindow(iframe, peerOrigin, timer);
314
315 var promise = registerService(iframeChannel, 'pong');
316 iframeChannel.send('ping', 'fizzbang');
317
318 return promise.then(function(msg) {
319 assertEquals('fizzbang', msg);
320
321 goog.dispose(iframeChannel);
322 });
323 });
324 }
325
326
327 function testWindowCanceled() {
328 if (!('Worker' in goog.global) || !('MessageChannel' in goog.global)) {
329 return;
330 }
331
332 return createIframe().then(function(iframe) {
333 var peerOrigin = window.location.protocol + '//' + window.location.host;
334 var iframeChannel =
335 goog.messaging.PortChannel.forEmbeddedWindow(iframe, peerOrigin, timer);
336 iframeChannel.cancel();
337
338 var promise = registerService(iframeChannel, 'pong').then(function(msg) {
339 fail('no messages should be received due to cancellation');
340 });
341 iframeChannel.send('ping', 'fizzbang');
342
343 // Leave plenty of time for the connection to be made if the test fails, but
344 // stop the test before the timeout is hit.
345 return goog.Promise.race([promise, goog.Timer.promise(500)])
346 .thenAlways(function() { iframeChannel.dispose(); });
347 });
348 }
349
350
351 function testWindowWontSendToWrongOrigin() {
352 if (!('Worker' in goog.global) || !('MessageChannel' in goog.global)) {
353 return;
354 }
355
356 return createIframe().then(function(iframe) {
357 var iframeChannel = goog.messaging.PortChannel.forEmbeddedWindow(
358 iframe, 'http://somewhere-else.com', timer);
359
360 var promise = registerService(iframeChannel, 'pong').then(function(msg) {
361 fail('Should not receive pong from unexpected origin');
362 });
363 iframeChannel.send('ping', 'fizzbang');
364
365 return goog.Promise.race([promise, goog.Timer.promise(500)])
366 .thenAlways(function() { iframeChannel.dispose(); });
367 });
368 }
369
370
371 function testWindowWontReceiveFromWrongOrigin() {
372 if (!('Worker' in goog.global) || !('MessageChannel' in goog.global)) {
373 return;
374 }
375
376 return createIframe('testdata/portchannel_wrong_origin_inner.html')
377 .then(function(iframe) {
378 var peerOrigin = window.location.protocol + '//' + window.location.host;
379 var iframeChannel = goog.messaging.PortChannel.forEmbeddedWindow(
380 iframe, peerOrigin, timer);
381
382 var promise =
383 registerService(iframeChannel, 'pong').then(function(msg) {
384 fail('Should not receive pong from unexpected origin');
385 });
386 iframeChannel.send('ping', 'fizzbang');
387
388 return goog.Promise.race([promise, goog.Timer.promise(500)])
389 .thenAlways(function() { iframeChannel.dispose(); });
390 });
391 }
392
393
394 /**
395 * Assert that two HTML5 MessagePorts are entangled by posting messages from
396 * each to the other.
397 *
398 * @param {!MessagePort} port1
399 * @param {!MessagePort} port2
400 * @return {!goog.Promise} Promise that settles when the assertion is complete.
401 */
402 function assertPortsEntangled(port1, port2) {
403 var port2Promise =
404 new goog.Promise(function(resolve, reject) { port2.onmessage = resolve; })
405 .then(function(e) {
406 assertEquals(
407 'First port 1 should send a message to port 2',
408 'port1 to port2', e.data);
409 port2.postMessage('port2 to port1');
410 });
411
412 var port1Promise =
413 new goog.Promise(function(resolve, reject) { port1.onmessage = resolve; })
414 .then(function(e) {
415 assertEquals(
416 'Then port 2 should respond to port 1', 'port2 to port1',
417 e.data);
418 });
419
420 port1.postMessage('port1 to port2');
421 return goog.Promise.all([port1Promise, port2Promise]);
422 }
423
424
425 /**
426 * @param {string=} opt_url A URL to use for the iframe src (defaults to
427 * "testdata/portchannel_inner.html").
428 * @return {!goog.Promise<HTMLIframeElement>} A promise that resolves with the
429 * loaded iframe.
430 */
431 function createIframe(opt_url) {
432 var iframe = goog.dom.createDom(goog.dom.TagName.IFRAME, {
433 style: 'display: none',
434 src: opt_url || 'testdata/portchannel_inner.html'
435 });
436
437 return new goog
438 .Promise(function(resolve, reject) {
439 goog.events.listenOnce(iframe, goog.events.EventType.LOAD, resolve);
440 goog.dom.appendChild(frameDiv, iframe);
441 })
442 .then(function(e) { return iframe.contentWindow; });
443 }