[BUG thoov#72, thoov#209] Change server callback argument to socket (thoov#214)

Fixes: thoov#72 thoov#209

Author: thoov

README.md

@@ -60,9 +60,9 @@ import { Server } from 'mock-socket';
 describe('Chat Unit Test', () => {
   it('basic test', (done) => {
     const mockServer = new Server('ws://localhost:8080');
-    mockServer.on('connection', server => {
-      mockServer.send('test message 1');
-      mockServer.send('test message 2');
+    mockServer.on('connection', socket => {
+      socket.send('test message 1');
+      socket.send('test message 2');
     });
 
     // Now when Chat tries to do new WebSocket() it
@@ -100,7 +100,7 @@ import { SocketIO, Server } from 'mock-socket';
 describe('Chat Unit Test', () => {
   it('basic test', (done) => {
     const mockServer = new Server('http://localhost:8080');
-    mockServer.on('connection', server => {
+    mockServer.on('connection', socket => {
       mockServer.emit('chat-message', 'test message 1');
       mockServer.emit('chat-message', 'test message 2');
     });

src/helpers/proxy-factory.js

@@ -0,0 +1,45 @@
+import { CLOSE_CODES } from '../constants';
+import { closeWebSocketConnection } from '../algorithms/close';
+import normalizeSendData from './normalize-send';
+import { createMessageEvent } from '../event/factory';
+
+export default function proxyFactory(target) {
+  const handler = {
+    get(obj, prop) {
+      if (prop === 'close') {
+        return function close(options = {}) {
+          const code = options.code || CLOSE_CODES.CLOSE_NORMAL;
+          const reason = options.reason || '';
+
+          closeWebSocketConnection(target, code, reason);
+        };
+      }
+
+      if (prop === 'send') {
+        return function send(data) {
+          data = normalizeSendData(data);
+
+          target.dispatchEvent(
+            createMessageEvent({
+              type: 'message',
+              data,
+              origin: this.url,
+              target
+            })
+          );
+        };
+      }
+
+      if (prop === 'on') {
+        return function onWrapper(type, cb) {
+          target.addEventListener(`server::${type}`, cb);
+        };
+      }
+
+      return obj[prop];
+    }
+  };
+
+  const proxy = new Proxy(target, handler);
+  return proxy;
+}

src/server.js

@@ -1,20 +1,14 @@
 import URL from 'url-parse';
 import WebSocket from './websocket';
+import dedupe from './helpers/dedupe';
 import EventTarget from './event/target';
-import networkBridge from './network-bridge';
 import { CLOSE_CODES } from './constants';
+import networkBridge from './network-bridge';
 import globalObject from './helpers/global-object';
-import dedupe from './helpers/dedupe';
 import normalizeSendData from './helpers/normalize-send';
 import { createEvent, createMessageEvent, createCloseEvent } from './event/factory';
 
-/*
-* https://github.com/websockets/ws#server-example
-*/
 class Server extends EventTarget {
-  /*
-  * @param {string} url
-  */
   constructor(url, options = {}) {
     super();
     const urlRecord = new URL(url);
@@ -42,13 +36,12 @@ class Server extends EventTarget {
     }
 
     this.options = options;
-
     this.start();
   }
 
   /*
-  * Attaches the mock websocket object to the global object
-  */
+   * Attaches the mock websocket object to the global object
+   */
   start() {
     const globalObj = globalObject();
 
@@ -60,8 +53,8 @@ class Server extends EventTarget {
   }
 
   /*
-  * Removes the mock websocket object from the global object
-  */
+   * Removes the mock websocket object from the global object
+   */
   stop(callback = () => {}) {
     const globalObj = globalObject();
 
@@ -81,30 +74,51 @@ class Server extends EventTarget {
   }
 
   /*
-  * This is the main function for the mock server to subscribe to the on events.
-  *
-  * ie: mockServer.on('connection', function() { console.log('a mock client connected'); });
-  *
-  * @param {string} type - The event key to subscribe to. Valid keys are: connection, message, and close.
-  * @param {function} callback - The callback which should be called when a certain event is fired.
-  */
+   * This is the main function for the mock server to subscribe to the on events.
+   *
+   * ie: mockServer.on('connection', function() { console.log('a mock client connected'); });
+   *
+   * @param {string} type - The event key to subscribe to. Valid keys are: connection, message, and close.
+   * @param {function} callback - The callback which should be called when a certain event is fired.
+   */
   on(type, callback) {
     this.addEventListener(type, callback);
   }
 
   /*
-  * This send function will notify all mock clients via their onmessage callbacks that the server
-  * has a message for them.
-  *
-  * @param {*} data - Any javascript object which will be crafted into a MessageObject.
-  */
-  send(data, options = {}) {
-    this.emit('message', data, options);
+   * Closes the connection and triggers the onclose method of all listening
+   * websockets. After that it removes itself from the urlMap so another server
+   * could add itself to the url.
+   *
+   * @param {object} options
+   */
+  close(options = {}) {
+    const { code, reason, wasClean } = options;
+    const listeners = networkBridge.websocketsLookup(this.url);
+
+    // Remove server before notifications to prevent immediate reconnects from
+    // socket onclose handlers
+    networkBridge.removeServer(this.url);
+
+    listeners.forEach(socket => {
+      socket.readyState = WebSocket.CLOSE;
+      socket.dispatchEvent(
+        createCloseEvent({
+          type: 'close',
+          target: socket,
+          code: code || CLOSE_CODES.CLOSE_NORMAL,
+          reason: reason || '',
+          wasClean
+        })
+      );
+    });
+
+    this.dispatchEvent(createCloseEvent({ type: 'close' }), this);
   }
 
   /*
-  * Sends a generic message event to all mock clients.
-  */
+   * Sends a generic message event to all mock clients.
+   */
   emit(event, data, options = {}) {
     let { websockets } = options;
 
@@ -144,48 +158,18 @@ class Server extends EventTarget {
   }
 
   /*
-  * Closes the connection and triggers the onclose method of all listening
-  * websockets. After that it removes itself from the urlMap so another server
-  * could add itself to the url.
-  *
-  * @param {object} options
-  */
-  close(options = {}) {
-    const { code, reason, wasClean } = options;
-    const listeners = networkBridge.websocketsLookup(this.url);
-
-    // Remove server before notifications to prevent immediate reconnects from
-    // socket onclose handlers
-    networkBridge.removeServer(this.url);
-
-    listeners.forEach(socket => {
-      socket.readyState = WebSocket.CLOSE;
-      socket.dispatchEvent(
-        createCloseEvent({
-          type: 'close',
-          target: socket,
-          code: code || CLOSE_CODES.CLOSE_NORMAL,
-          reason: reason || '',
-          wasClean
-        })
-      );
-    });
-
-    this.dispatchEvent(createCloseEvent({ type: 'close' }), this);
-  }
-
-  /*
-  * Returns an array of websockets which are listening to this server
-  */
+   * Returns an array of websockets which are listening to this server
+   * TOOD: this should return a set and not be a method
+   */
   clients() {
     return networkBridge.websocketsLookup(this.url);
   }
 
   /*
-  * Prepares a method to submit an event to members of the room
-  *
-  * e.g. server.to('my-room').emit('hi!');
-  */
+   * Prepares a method to submit an event to members of the room
+   *
+   * e.g. server.to('my-room').emit('hi!');
+   */
   to(room, broadcaster, broadcastList = []) {
     const self = this;
     const websockets = dedupe(broadcastList.concat(networkBridge.websocketsLookup(this.url, room, broadcaster)));

src/websocket.js

@@ -1,21 +1,22 @@
-import lengthInUtf8Bytes from './helpers/byte-length';
-import urlVerification from './helpers/url-verification';
-import protocolVerification from './helpers/protocol-verification';
 import delay from './helpers/delay';
-import normalizeSendData from './helpers/normalize-send';
+import logger from './helpers/logger';
 import EventTarget from './event/target';
 import networkBridge from './network-bridge';
+import proxyFactory from './helpers/proxy-factory';
+import lengthInUtf8Bytes from './helpers/byte-length';
 import { CLOSE_CODES, ERROR_PREFIX } from './constants';
-import logger from './helpers/logger';
+import urlVerification from './helpers/url-verification';
+import normalizeSendData from './helpers/normalize-send';
+import protocolVerification from './helpers/protocol-verification';
 import { createEvent, createMessageEvent, createCloseEvent } from './event/factory';
 import { closeWebSocketConnection, failWebSocketConnection } from './algorithms/close';
 
 /*
-* The main websocket class which is designed to mimick the native WebSocket class as close
-* as possible.
-*
-* https://html.spec.whatwg.org/multipage/web-sockets.html
-*/
+ * The main websocket class which is designed to mimick the native WebSocket class as close
+ * as possible.
+ *
+ * https://html.spec.whatwg.org/multipage/web-sockets.html
+ */
 class WebSocket extends EventTarget {
   constructor(url, protocols) {
     super();
@@ -30,19 +31,19 @@ class WebSocket extends EventTarget {
     const server = networkBridge.attachWebSocket(this, this.url);
 
     /*
-    * This delay is needed so that we dont trigger an event before the callbacks have been
-    * setup. For example:
-    *
-    * var socket = new WebSocket('ws://localhost');
-    *
-    * // If we dont have the delay then the event would be triggered right here and this is
-    * // before the onopen had a chance to register itself.
-    *
-    * socket.onopen = () => { // this would never be called };
-    *
-    * // and with the delay the event gets triggered here after all of the callbacks have been
-    * // registered :-)
-    */
+     * This delay is needed so that we dont trigger an event before the callbacks have been
+     * setup. For example:
+     *
+     * var socket = new WebSocket('ws://localhost');
+     *
+     * If we dont have the delay then the event would be triggered right here and this is
+     * before the onopen had a chance to register itself.
+     *
+     * socket.onopen = () => { // this would never be called };
+     *
+     * and with the delay the event gets triggered here after all of the callbacks have been
+     * registered :-)
+     */
     delay(function delayCallback() {
       if (server) {
         if (
@@ -79,7 +80,7 @@ class WebSocket extends EventTarget {
           }
           this.readyState = WebSocket.OPEN;
           this.dispatchEvent(createEvent({ type: 'open', target: this }));
-          server.dispatchEvent(createEvent({ type: 'connection' }), server, this);
+          server.dispatchEvent(createEvent({ type: 'connection' }), proxyFactory(this));
         }
       } else {
         this.readyState = WebSocket.CLOSED;
@@ -135,7 +136,7 @@ class WebSocket extends EventTarget {
     // TODO: handle bufferedAmount
 
     const messageEvent = createMessageEvent({
-      type: 'message',
+      type: 'server::message',
       origin: this.url,
       data: normalizeSendData(data)
     });
@@ -144,7 +145,7 @@ class WebSocket extends EventTarget {
 
     if (server) {
       delay(() => {
-        server.dispatchEvent(messageEvent, data);
+        this.dispatchEvent(messageEvent, data);
       }, server);
     }
   }

tests/functional/websockets.test.js

@@ -66,8 +66,8 @@ test.cb('that verifyClient is only invoked if it is a function', t => {
 test.cb('that onmessage is called after the server sends a message', t => {
   const testServer = new Server('ws://localhost:8080');
 
-  testServer.on('connection', server => {
-    server.send('Testing');
+  testServer.on('connection', socket => {
+    socket.send('Testing');
   });
 
   const mockSocket = new WebSocket('ws://localhost:8080');
@@ -81,8 +81,8 @@ test.cb('that onmessage is called after the server sends a message', t => {
 test.cb('that onclose is called after the client closes the connection', t => {
   const testServer = new Server('ws://localhost:8080');
 
-  testServer.on('connection', server => {
-    server.send('Testing');
+  testServer.on('connection', socket => {
+    socket.send('Testing');
   });
 
   const mockSocket = new WebSocket('ws://localhost:8080');
@@ -100,9 +100,11 @@ test.cb('that onclose is called after the client closes the connection', t => {
 test.cb('that the server gets called when the client sends a message', t => {
   const testServer = new Server('ws://localhost:8080');
 
-  testServer.on('message', data => {
-    t.is(data, 'Testing', 'on message fires as expected');
-    t.end();
+  testServer.on('connection', socket => {
+    socket.on('message', data => {
+      t.is(data, 'Testing', 'on message fires as expected');
+      t.end();
+    });
   });
 
   const mockSocket = new WebSocket('ws://localhost:8080');

tests/issues/143.test.js

@@ -40,8 +40,8 @@ test.cb('reassigning websocket onmessage listener should replace previous listen
     secondListenerCalled = true;
   };
 
-  mockServer.on('connection', () => {
-    mockServer.send('test message');
+  mockServer.on('connection', socket => {
+    socket.send('test message');
     t.false(firstListenerCalled, 'The first listener should not be called');
     t.true(secondListenerCalled, 'Only the second listener should be called');
     mockServer.close();

tests/issues/157.test.js

@@ -9,8 +9,8 @@ test.cb('websocket onmessage fired before onopen', t => {
 
   let onOpenCalled = false;
 
-  mockServer.on('connection', () => {
-    mockServer.send('test message');
+  mockServer.on('connection', socket => {
+    socket.send('test message');
   });
 
   mockSocket.onopen = () => {