Improved testability of socket code

README.md

@@ -120,7 +120,7 @@ server in order to test your applications:
 ```javascript
     var $websocketBackend;
 
-    beforeEach(angular.mock.module('ngWebSocket', 'ngWebSocketMock');
+    beforeEach(angular.mock.module('ngWebSocket', 'ngWebSocketMock'));
 
     beforeEach(inject(function (_$websocketBackend_) {
       $websocketBackend = _$websocketBackend_;
@@ -137,8 +137,10 @@ name                           | arguments  | description
 -------------------------------|------------|-----------------------------------
 flush                          |            | Executes all pending requests
 expectConnect                  | url:String | Specify the url of an expected WebSocket connection
-expectClose                    |            | Expect "close" to be called on the WebSocket
+expectClose                    | url:String | Expect "close" to be called on the WebSocket
 expectSend                     | msg:String | Expectation of send to be called, with required message
+fakeClose                      | url:String | Used to fake close a socket and test corresponding close handlers
+fakeMessage                    | url:String, data:object | Used to fake a backend initialized send action, which can be handled in onMessage
 verifyNoOutstandingExpectation |            | Makes sure all expectations have been satisfied, should be called in afterEach
 verifyNoOutstandingRequest     |            | Makes sure no requests are pending, should be called in afterEach
 

dist/angular-websocket-mock.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
   if (typeof define === "function" && define.amd) {
-    define(['module', 'angular'], factory);
+    define(["module", "angular"], factory);
   } else if (typeof exports !== "undefined") {
-    factory(module, require('angular'));
+    factory(module, require("angular"));
   } else {
     var mod = {
       exports: {}
@@ -11,7 +11,7 @@
     global.angularWebsocketMock = mod.exports;
   }
 })(this, function (module, _angular) {
-  'use strict';
+  "use strict";
 
   var _angular2 = _interopRequireDefault(_angular);
 
@@ -28,11 +28,19 @@
     var pendingCloses = [];
     var sendQueue = [];
     var pendingSends = [];
+    var pendingMessages = [];
     var mock = false;
+    var existingMocks = {};
 
     function $MockWebSocket(url, protocols) {
+      this.url = url;
       this.protocols = protocols;
       this.ssl = /(wss)/i.test(this.url);
+      if (!existingMocks[url]) {
+        existingMocks[url] = [this];
+      } else {
+        existingMocks[url].push(this);
+      }
     }
 
     $MockWebSocket.prototype.send = function (msg) {
@@ -45,6 +53,19 @@
       }
     };
 
+    this.fakeClose = function (url, code) {
+      closeQueue.push(url);
+      if (existingMocks[url]) {
+        existingMocks[url].map(function (mockSocket) {
+          mockSocket.close(code);
+        });
+      }
+    };
+
+    this.fakeMessage = function (url, data) {
+      pendingMessages.push({ url: url, data: data });
+    };
+
     this.mock = function () {
       mock = true;
     };
@@ -57,8 +78,8 @@
       return connectQueue.indexOf(url) > -1;
     };
 
-    $MockWebSocket.prototype.close = function () {
-      pendingCloses.push(true);
+    $MockWebSocket.prototype.close = function (code) {
+      pendingCloses.push({ url: this.url, code: code ? code : 1000 });
     };
 
     function createWebSocketBackend(url, protocols) {
@@ -76,19 +97,61 @@
     this.create = createWebSocketBackend;
     this.createWebSocketBackend = createWebSocketBackend;
 
+    function callOpenCallbacks(url) {
+      existingMocks[url].map(function (socketMock) {
+        if (socketMock.onopen && typeof socketMock.onopen === "function") {
+          socketMock.onopen();
+        }
+      });
+    }
+
+    function callCloseCallbacks(url, code) {
+      existingMocks[url].map(function (socketMock) {
+        if (socketMock.onclose && typeof socketMock.onclose === "function") {
+          socketMock.onclose({ code: code });
+        }
+      });
+    }
+
+    function callMessageCallbacks(url, data) {
+      if (existingMocks[url]) {
+        existingMocks[url].map(function (socketMock) {
+          if (socketMock.onmessage && typeof socketMock.onmessage === "function") {
+            socketMock.onmessage({ data: JSON.stringify(data) });
+          }
+        });
+      }
+    }
+
+    function setReadyState(url, state) {
+      if (existingMocks[url]) {
+        existingMocks[url].map(function (socketMock) {
+          socketMock.readyState = state;
+        });
+      }
+    }
+
     this.flush = function () {
       var url, msg, config;
       while (url = pendingConnects.shift()) {
         var i = connectQueue.indexOf(url);
         if (i > -1) {
           connectQueue.splice(i, 1);
+          callOpenCallbacks(url);
+          setReadyState(url, 1);
         }
         // if (config && config.url) {
         // }
       }
 
-      while (pendingCloses.shift()) {
-        closeQueue.shift();
+      var pendingClose;
+      while (pendingClose = pendingCloses.shift()) {
+        var i = closeQueue.indexOf(pendingClose.url);
+        if (i > -1) {
+          closeQueue.splice(i, 1);
+          callCloseCallbacks(pendingClose.url, pendingClose.code);
+          setReadyState(pendingClose.url, 3);
+        }
       }
 
       while (msg = pendingSends.shift()) {
@@ -103,15 +166,19 @@
           sendQueue.splice(j, 1);
         }
       }
+
+      while (msg = pendingMessages.shift()) {
+        callMessageCallbacks(msg.url, msg.data);
+      }
     };
 
     this.expectConnect = function (url, protocols) {
       connectQueue.push(url);
       // connectQueue.push({url: url, protocols: protocols});
     };
 
-    this.expectClose = function () {
-      closeQueue.push(true);
+    this.expectClose = function (url) {
+      closeQueue.push(url);
     };
 
     this.expectSend = function (msg) {

dist/angular-websocket.js

@@ -25,12 +25,6 @@
     };
   }
 
-  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
-    return typeof obj;
-  } : function (obj) {
-    return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
-  };
-
   var Socket;
 
   if (typeof window === 'undefined') {
@@ -148,6 +142,13 @@
     };
 
     $WebSocket.prototype._connect = function _connect(force) {
+      if (this.socket) {
+        this.socket.onmessage = null;
+        this.socket.onopen = null;
+        this.socket.onerror = null;
+        this.socket.onclose = null;
+        this.socket.close();
+      }
       if (force || !this.socket || this.socket.readyState !== this._readyStateConstants.OPEN) {
         this.socket = $websocketBackend.create(this.url, this.protocols);
         this.socket.onmessage = _angular2.default.bind(this, this._onMessageHandler);
@@ -320,10 +321,6 @@
         return self;
       }
 
-      if ($websocketBackend.isMocked && $websocketBackend.isMocked() && $websocketBackend.isConnected(this.url)) {
-        this._onMessageHandler($websocketBackend.mockSend());
-      }
-
       return promise;
     };
 
@@ -412,4 +409,4 @@
 
   exports.default = _angular2.default.module('ngWebSocket');
   module.exports = exports['default'];
-});
+});