| 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 |
} |