remoting/webapp/base/js/protocol_extension_manager_unittest.js

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 /**
   6  * @fileoverview
   7  */
   8
   9 (function() {
  10
  11 'use strict';
  12
  13 /** @type {remoting.ProtocolExtensionManager} */
  14 var extensionManager;
  15
  16 /** @type {(sinon.Spy|function(string, string))} */
  17 var sendClientMessage;
  18
  19 /**
  20  * @constructor
  21  * @param {Array<string>} types
  22  * @implements {remoting.ProtocolExtension}
  23  */
  24 var DummyExtension = function(types) {
  25   /** @private {?function(string, string)} */
  26   this.sendMessageToHost_ = null;
  27   /** @private */
  28   this.types_ = types;
  29 };
  30
  31 DummyExtension.prototype.getExtensionTypes = function() {
  32   return this.types_.slice(0);
  33 }
  34
  35 /**
  36  * @param {function(string,string)} sendMessageToHost Callback to send a message
  37  *     to the host.
  38  */
  39 DummyExtension.prototype.startExtension = function(sendMessageToHost) {
  40   this.sendMessageToHost_ = sendMessageToHost;
  41 };
  42
  43 /**
  44  * Called when an extension message of a matching type is received.
  45  *
  46  * @param {string} type The message type.
  47  * @param {Object} message The parsed extension message data.
  48  * @return {boolean} True if the extension message was handled.
  49  */
  50 DummyExtension.prototype.onExtensionMessage = function(type, message){
  51   return this.types_.indexOf(type) !== 1;
  52 };
  53
  54
  55 QUnit.module('ProtocolExtensionManager', {
  56   beforeEach: function() {
  57     sendClientMessage = /** @type {function(string, string)} */ (sinon.spy());
  58     extensionManager = new remoting.ProtocolExtensionManager(sendClientMessage);
  59   },
  60   afterEach: function() {
  61   }
  62 });
  63
  64 QUnit.test('should route message to extension by type', function(assert) {
  65   var extension = new DummyExtension(['type1', 'type2']);
  66   var onExtensionMessage = /** @type {(sinon.Spy|function(string, string))} */ (
  67       sinon.spy(extension, 'onExtensionMessage'));
  68   assert.ok(extensionManager.register(extension));
  69   extensionManager.start();
  70
  71   extensionManager.onProtocolExtensionMessage('type1', '{"message": "hello"}');
  72   assert.ok(onExtensionMessage.called);
  73   onExtensionMessage.reset();
  74
  75   extensionManager.onProtocolExtensionMessage('type2', '{"message": "hello"}');
  76   assert.ok(onExtensionMessage.called);
  77   onExtensionMessage.reset();
  78
  79   extensionManager.onProtocolExtensionMessage('type3', '{"message": "hello"}');
  80   assert.ok(!onExtensionMessage.called);
  81   onExtensionMessage.reset();
  82 });
  83
  84 QUnit.test('startExtension() should only be called once', function(assert) {
  85   var extension = new DummyExtension(['type1', 'type2']);
  86   var startExtension = /** @type {(sinon.Spy|Function)} */ (
  87       sinon.spy(extension, 'startExtension'));
  88
  89   assert.ok(extensionManager.register(extension));
  90   extensionManager.start();
  91   assert.ok(startExtension.calledOnce);
  92 });
  93
  94
  95 QUnit.test('should not register extensions of the same type', function(assert) {
  96   var extension1 = new DummyExtension(['type1']);
  97   var extension2 = new DummyExtension(['type1']);
  98
  99   var onExtensionMessage1 = /** @type {(sinon.Spy|function(string, string))} */(
 100       sinon.spy(extension1, 'onExtensionMessage'));
 101   var onExtensionMessage2 = /** @type {(sinon.Spy|function(string, string))} */(
 102       sinon.spy(extension2, 'onExtensionMessage'));
 103
 104   assert.ok(extensionManager.register(extension1));
 105   assert.ok(!extensionManager.register(extension2));
 106   extensionManager.start();
 107
 108   extensionManager.onProtocolExtensionMessage('type1', '{"message": "hello"}');
 109   assert.ok(onExtensionMessage1.called);
 110   assert.ok(!onExtensionMessage2.called);
 111 });
 112
 113 QUnit.test('should handle extensions registration after it is started',
 114     function(assert) {
 115   var extension = new DummyExtension(['type']);
 116
 117   var onExtensionMessage = /** @type {(sinon.Spy|function(string, string))} */(
 118       sinon.spy(extension, 'onExtensionMessage'));
 119
 120   extensionManager.start();
 121   assert.ok(extensionManager.register(extension));
 122
 123   extensionManager.onProtocolExtensionMessage('type', '{"message": "hello"}');
 124   assert.ok(onExtensionMessage.called);
 125 });
 126
 127 })();