Emit error if destroyed socket tries to connect

Author: jondubois

lib/scsocket.js

@@ -12,6 +12,7 @@ var clone = require('clone');
 var scErrors = require('sc-errors');
 var InvalidArgumentsError = scErrors.InvalidArgumentsError;
 var InvalidMessageError = scErrors.InvalidMessageError;
+var InvalidActionError = scErrors.InvalidActionError;
 var SocketProtocolError = scErrors.SocketProtocolError;
 var TimeoutError = scErrors.TimeoutError;
 var BadConnectionError = scErrors.BadConnectionError;
@@ -43,6 +44,7 @@ var SCSocket = function (opts) {
   // pingTimeout will be ackTimeout at the start, but it will
   // be updated with values provided by the 'connect' event
   this.pingTimeout = this.ackTimeout;
+  this.active = true;
 
   this._clientMap = opts.clientMap || {};
 
@@ -144,10 +146,13 @@ var SCSocket = function (opts) {
     self.disconnect();
   };
 
+  if (isBrowser && this.disconnectOnUnload && global.addEventListener) {
+    global.addEventListener('beforeunload', this._unloadHandler, false);
+  }
+  this._clientMap[this.clientId] = this;
+
   if (this.options.autoConnect) {
     this.connect();
-  } else {
-    this.activate();
   }
 };
 
@@ -254,7 +259,11 @@ SCSocket.prototype.deauthenticate = function (callback) {
 SCSocket.prototype.connect = SCSocket.prototype.open = function () {
   var self = this;
 
-  this.activate();
+  if (!this.active) {
+    var error = new InvalidActionError('Cannot connect a destroyed socket');
+    this._onSCError(error);
+    return;
+  }
 
   if (this.state == this.CLOSED) {
     this.pendingReconnect = false;
@@ -316,14 +325,6 @@ SCSocket.prototype.disconnect = function (code, data) {
   }
 };
 
-SCSocket.prototype.activate = function () {
-  if (isBrowser && this.disconnectOnUnload && global.addEventListener && !this.active) {
-    global.addEventListener('beforeunload', this._unloadHandler, false);
-  }
-  this._clientMap[this.clientId] = this;
-  this.active = true;
-};
-
 SCSocket.prototype.destroy = function (code, data) {
   if (isBrowser && global.removeEventListener) {
     global.removeEventListener('beforeunload', this._unloadHandler, false);
@@ -433,7 +434,6 @@ SCSocket.prototype.authenticate = function (signedAuthToken, callback) {
   var self = this;
 
   this.emit('#authenticate', signedAuthToken, function (err, authStatus) {
-
     if (authStatus && authStatus.isAuthenticated != null) {
       // If authStatus is correctly formatted (has an isAuthenticated property),
       // then we will rehydrate the authError.
@@ -915,7 +915,6 @@ SCSocket.prototype._tryUnsubscribe = function (channel) {
 };
 
 SCSocket.prototype.unsubscribe = function (channelName) {
-
   var channel = this.channels[channelName];
 
   if (channel) {

test/integration.js

@@ -1026,30 +1026,73 @@ describe('integration tests', function () {
       }, 1000);
     });
 
-    it('should reactivate and reconnect socket if emit is called on a destroyed socket', function (done) {
+    it('should emit an error event if emit is called on a destroyed socket', function (done) {
       client = socketClusterClient.create(clientOptions);
       assert.equal(client.active, true);
 
+      var disconnectTriggered = false;
+      var secondConnectTriggered = false;
       var clientError;
       client.on('error', function (err) {
         clientError = err;
       });
 
       client.once('connect', function () {
         assert.equal(client.active, true);
+
+        client.once('disconnect', function () {
+          disconnectTriggered = true;
+          assert.equal(client.active, false);
+        });
+
         client.destroy();
         assert.equal(client.active, false);
 
         client.once('connect', function () {
-          assert.equal(client.active, true);
-          done();
+          secondConnectTriggered = true;
         });
 
         client.emit('foo', 123);
 
+        assert.equal(client.active, false);
+        assert.equal(client.state, client.CLOSED);
+      });
+
+      setTimeout(function () {
+        assert.equal(secondConnectTriggered, false);
+        assert.equal(disconnectTriggered, true);
+        assert.notEqual(clientError, null);
+        assert.equal(clientError.name, 'InvalidActionError');
+        done();
+      }, 100);
+    });
+
+    it('should emit an error event if publish is called on a destroyed socket', function (done) {
+      client = socketClusterClient.create(clientOptions);
+      assert.equal(client.active, true);
+
+      var clientError;
+      client.on('error', function (err) {
+        clientError = err;
+      });
+
+      client.once('connect', function () {
         assert.equal(client.active, true);
-        assert.equal(client.state, client.CONNECTING);
+
+        client.destroy();
+        assert.equal(client.active, false);
+
+        client.publish('thisIsATestChannel', 123);
+
+        assert.equal(client.active, false);
+        assert.equal(client.state, client.CLOSED);
       });
+
+      setTimeout(function () {
+        assert.notEqual(clientError, null);
+        assert.equal(clientError.name, 'InvalidActionError');
+        done();
+      }, 100);
     });
 
     it('should correctly handle multiple successive connect and disconnect calls', function (done) {