Merge PR #11 from 'nodech/noqueue-on-destroy'

lib/socket.js

@@ -875,6 +875,9 @@ class Socket extends EventEmitter {
     enforce(args.length > 0, 'event', 'string');
     enforce(typeof args[0] === 'string', 'event', 'string');
 
+    if (this.destroyed)
+      return Promise.reject(new Error('Socket destroyed.'));
+
     const id = this.sequence;
 
     this.sequence += 1;

test/socket-test.js

@@ -148,8 +148,14 @@ describe('Socket', () => {
       assert.bufferEqual(barData, 'baz', 'ascii');
     });
 
-    it('should close', (cb) => {
+    it('should not queue on destroyed socket', async () => {
       socket.destroy();
+      await assert.rejects(socket.call('foo'), {
+        message: 'Socket destroyed.'
+      });
+    });
+
+    it('should close', (cb) => {
       server.close(cb);
     });
   });
@@ -160,6 +166,8 @@ describe('Socket', () => {
 
     let socket = null;
     let barData = null;
+    let clientFailedCallDone = false;
+    let serverCallError = null;
 
     it('should setup server', (cb) => {
       io.attach(server);
@@ -190,6 +198,22 @@ describe('Socket', () => {
           io.leave(socket, name);
           io.to(name, 'test', 'testing again');
         });
+
+        socket.bind('trigger client hook and event', async (data) => {
+          await socket.call('client hook', data);
+          await socket.fire('client event', data);
+        });
+
+        socket.hook('socket call back with delay', async (n) => {
+          await timeout(n);
+          try {
+            await socket.call('call response');
+          } catch (e) {
+            serverCallError = e;
+          } finally {
+            clientFailedCallDone = true;
+          }
+        });
       });
 
       server.listen(8000, cb);
@@ -255,8 +279,51 @@ describe('Socket', () => {
       assert.deepStrictEqual(json, obj);
     });
 
-    it('should close', (cb) => {
+    it('should receive hook and event', async () => {
+      const hook = new Promise((resolve) => {
+        const hook = async (data) => {
+          resolve(data);
+          socket.unhook('client hook', hook);
+          return null;
+        };
+
+        socket.hook('client hook', hook);
+      });
+
+      const event = new Promise((resolve) => {
+        const event = async (data) => {
+          resolve(data);
+          socket.unbind('client event', event);
+        };
+
+        socket.bind('client event', event);
+      });
+
+      socket.fire('trigger client hook and event', 'hello');
+      assert.strictEqual(await hook, 'hello');
+      assert.strictEqual(await event, 'hello');
+    });
+
+    it('should not queue hook on destroyed socket (server)', async () => {
+      let callError = null;
+
+      socket
+        .call('socket call back with delay', 200)
+        .catch((err) => {
+          callError = err;
+        });
+
+      await timeout(100);
       socket.destroy();
+      await timeout(150);
+
+      assert.strictEqual(callError.message, 'Job timed out.');
+      assert.strictEqual(clientFailedCallDone, true);
+      assert(serverCallError);
+      assert.strictEqual(serverCallError.message, 'Socket destroyed.');
+    });
+
+    it('should close', (cb) => {
       server.close(cb);
     });
   });