node-multi-socketservers - npm Package Compare versions

Comparing version 0.2.5 to 0.2.6

gulpfile.js

@@ -16,10 +16,15 @@
 
-// private
+	// reports
+	const istanbul = require("gulp-istanbul");
+	const coveralls = require("gulp-coveralls");
 
-	var _gulpFile = path.join(__dirname, "gulpfile.js"),
-		_libFiles = path.join(__dirname, "lib", "**", "*.js"),
-		_distFiles = path.join(__dirname, "dist", "**", "*.js"),
-		_unitTestsFiles = path.join(__dirname, "tests", "**", "*.js"),
-		_allJSFiles = [_gulpFile, _libFiles, _distFiles, _unitTestsFiles];
+// consts
 
+	const APP_FILES = [ path.join(__dirname, "lib", "*.js") ];
+	const UNITTESTS_FILES = [ path.join(__dirname, "tests", "*.js") ];
+
+	const ALL_FILES = [ path.join(__dirname, "gulpfile.js") ]
+		.concat(APP_FILES)
+		.concat(UNITTESTS_FILES);
+
 // tasks
@@ -29,19 +34,12 @@
 
-		return gulp.src(_allJSFiles)
+		return gulp.src(ALL_FILES)
 			.pipe(plumber())
 			.pipe(eslint({
+				"env": require(path.join(__dirname, "gulpfile", "eslint", "env.json")),
+				"globals": require(path.join(__dirname, "gulpfile", "eslint", "globals.json")),
 				"parserOptions": {
 					"ecmaVersion": 6
 				},
-				"rules": {
-					"linebreak-style": 0,
-					"quotes": [ 1, "double" ],
-					"indent": 0,
-					// "indent": [ 2, "tab" ],
-					"semi": [ 2, "always" ]
-				},
-				"env": {
-					"node": true, "es6": true, "mocha": true
-				},
-				"extends": "eslint:recommended"
+				// http://eslint.org/docs/rules/
+				"rules": require(path.join(__dirname, "gulpfile", "eslint", "rules.json"))
 			}))
@@ -53,14 +51,33 @@ .pipe(eslint.format())
 
-	gulp.task("mocha", ["eslint"], () => {
+	gulp.task("istanbul", [ "eslint" ], () => {
 
-		return gulp.src(_unitTestsFiles)
+		return gulp.src(APP_FILES)
 			.pipe(plumber())
-			.pipe(mocha({reporter: "spec"}));
+			.pipe(istanbul({ "includeUntested": true }))
+			.pipe(istanbul.hookRequire());
 
 	});
 
+	gulp.task("coveralls", [ "istanbul" ], () => {
+
+		return gulp.src(path.join(__dirname, "coverage", "lcov.info"))
+			.pipe(plumber())
+			.pipe(coveralls());
+
+	});
+
+	gulp.task("mocha", [ "coveralls" ], () => {
+
+		return gulp.src(UNITTESTS_FILES)
+			.pipe(plumber())
+			.pipe(mocha())
+			.pipe(istanbul.writeReports())
+			.pipe(istanbul.enforceThresholds({ "thresholds": { "global": 75 } }));
+
+	});
+
 // watcher
 
 	gulp.task("watch", () => {
-		gulp.watch(_allJSFiles, ["mocha"]);
+		gulp.watch(ALL_FILES, [ "mocha" ]);
 	});
@@ -71,3 +88,2 @@
 
-	gulp.task("default", ["mocha"]);
-	
+	gulp.task("default", [ "mocha" ]);

lib/main.js

@@ -11,3 +11,3 @@ "use strict";
 
-	constructor() {
+	constructor () {
 
@@ -17,18 +17,28 @@ super();
 		this._tmpOnConnection = [];
+		this._sockets = [];
 
 	}
 
-	listen(requestListener) {
+	listen (requestListener) {
 
-		if (this.listening()) {
-			return Promise.resolve();
-		}
-		else {
+		return Promise.resolve().then(() => {
 
-			// web server init
-			return super.listen(requestListener).then(() => {
+			if ("undefined" === typeof requestListener) {
+				return Promise.reject(new ReferenceError("There is no requestListener"));
+			}
+				else if ("function" !== typeof requestListener) {
+					return Promise.reject(new TypeError("requestListener is not a function"));
+				}
+			else {
+				return Promise.resolve();
+			}
 
-				// socket server init
-				return new Promise((resolve) => {
+		}).then(() => {
 
+			return this.listening() ?
+				Promise.resolve() :
+
+				// web server init
+				super.listen(requestListener).then(() => {
+
 					this.servers.forEach((server, i) => {
@@ -41,3 +51,3 @@
 
-							let _tmpOnConnection = this._tmpOnConnection.slice();
+							const _tmpOnConnection = this._tmpOnConnection.slice();
 
@@ -47,5 +57,10 @@ server.sockets.on("connection", (socket) => {
 								_tmpOnConnection.forEach((tmpOnConnection) => {
-									new Promise(() => {
+
+									try {
 										tmpOnConnection(socket, server);
-									});
+									}
+									catch (e) {
+										// nothing to do here
+									}
+
 								});
@@ -61,30 +76,32 @@
 
-					resolve();
+					return Promise.resolve();
 
 				});
 
-			}).catch((err) => {
-				(0, console).log(err);
-			});
+		});
 
-		}
-
 	}
 
-	connection(eventListener) {
+	connection (eventListener) {
 
-		if (!eventListener) {
-			return Promise.reject("There is no eventListener");
-		}
-			else if ("function" !== typeof eventListener) {
-				return Promise.reject("eventListener is not a function");
+		return Promise.resolve().then(() => {
+
+			if ("undefined" === typeof eventListener) {
+				return Promise.reject(new ReferenceError("There is no eventListener"));
 			}
-		else {
+				else if ("function" !== typeof eventListener) {
+					return Promise.reject(new TypeError("eventListener is not a function"));
+				}
+			else {
+				return Promise.resolve();
+			}
 
-			return new Promise((resolve) => {
+		}).then(() => {
 
-				if (!this.listening()) {
+			return !this.listening() ?
+				Promise.resolve().then(() => {
 					this._tmpOnConnection.push(eventListener);
-				}
-				else {
+					return Promise.resolve();
+				}) :
+				Promise.resolve().then(() => {
 
@@ -96,208 +113,257 @@ this.servers.forEach((server) => {
 							server.sockets.on("connection", (socket) => {
-								eventListener(socket, server);
+
+								socket.on("disconnect", () => {
+
+									for (let i = 0; i < this._sockets.length; ++i) {
+
+										if (socket.id === this._sockets[i].id && server.options.port === this._sockets[i].server) {
+
+											try {
+												this._sockets[i].close();
+											}
+											catch (e) {
+												// nothing to do here
+											}
+
+											this._sockets.splice(i, 1);
+
+											break;
+
+										}
+
+									}
+
+								});
+
+								this._sockets.push({
+									"server": server.options.port,
+									"id": socket.id,
+									"removeAllListeners": (eventNames) => {
+										socket.removeAllListeners(eventNames);
+									},
+									"close": () => {
+										socket.removeAllListeners();
+										socket.disconnect(true);
+									}
+								});
+
+								try {
+									eventListener(socket, server);
+								}
+								catch (e) {
+									// nothing to do here
+								}
+
 							});
-							
+
 						}
 
 					});
-					
-				}
 
-				resolve();
+					return Promise.resolve();
 
-			});
+				});
 
-		}
+		});
 
 	}
 
-	emit(eventName, data) {
+	emit (eventName, data) {
 
-		if (!eventName) {
-			return Promise.reject("There is no eventName");
-		}
-			else if ("string" !== typeof eventName) {
-				return Promise.reject("eventName is not a string");
+		return Promise.resolve().then(() => {
+
+			if ("undefined" === typeof eventName) {
+				return Promise.reject(new ReferenceError("There is no eventName"));
 			}
-		else {
+				else if ("string" !== typeof eventName) {
+					return Promise.reject(new TypeError("eventName is not a string"));
+				}
+				else if ("" === eventName.trim()) {
+					return Promise.reject(new TypeError("eventName is empty"));
+				}
+			else {
+				return Promise.resolve();
+			}
 
-			return new Promise((resolve) => {
-				
-				this.servers.forEach((server) => {
+		}).then(() => {
 
-					if (server.sockets) {
+			this.servers.forEach((server) => {
 
-						if (data) {
-							server.sockets.emit(eventName, data);
-						}
-						else {
-							server.sockets.emit(eventName);
-						}
+				if (server.sockets) {
 
+					if ("undefined" !== typeof data) {
+						server.sockets.emit(eventName, data);
 					}
+					else {
+						server.sockets.emit(eventName);
+					}
 
-				});
+				}
 
-				resolve();
-
 			});
 
-		}
+			return Promise.resolve();
 
+		});
+
 	}
 
-	broadcast(socket, server, eventName, data) {
+	broadcast (socket, server, eventName, data) {
 
-		if (!socket) {
-			return Promise.reject("There is no socket");
-		}
-			else if ("object" !== typeof socket) {
-				return Promise.reject("socket is not a object");
+		return Promise.resolve().then(() => {
+
+			if ("undefined" === typeof socket) {
+				return Promise.reject(new ReferenceError("There is no socket"));
 			}
-		else if (!server) {
-			return Promise.reject("There is no server");
-		}
-			else if ("object" !== typeof server) {
-				return Promise.reject("server is not a object");
+				else if ("object" !== typeof socket) {
+					return Promise.reject(new TypeError("socket is not an object"));
+				}
+			else if ("undefined" === typeof server) {
+				return Promise.reject(new ReferenceError("There is no server"));
 			}
-		else if (!eventName) {
-			return Promise.reject("There is no eventName");
-		}
-			else if ("string" !== typeof eventName) {
-				return Promise.reject("eventName is not a string");
+				else if ("object" !== typeof server) {
+					return Promise.reject(new TypeError("server is not an object"));
+				}
+			else if ("undefined" === typeof eventName) {
+				return Promise.reject(new ReferenceError("There is no eventName"));
 			}
-		else {
+				else if ("string" !== typeof eventName) {
+					return Promise.reject(new TypeError("eventName is not a string"));
+				}
+				else if ("" === eventName.trim()) {
+					return Promise.reject(new TypeError("eventName is empty"));
+				}
+			else {
+				return Promise.resolve();
+			}
 
-			return new Promise((resolve) => {
-				
-				this.servers.forEach((_server) => {
+		}).then(() => {
 
-					if (_server.sockets) {
+			this.servers.forEach((_server) => {
 
-						if (_server.options.port !== server.options.port) {
+				if (_server.sockets) {
 
-							if (data) {
-								_server.sockets.emit(eventName, data);
-							}
-							else {
-								_server.sockets.emit(eventName);
-							}
+					if (_server.options.port !== server.options.port) {
 
+						if ("undefined" !== typeof data) {
+							_server.sockets.emit(eventName, data);
 						}
 						else {
-
-							if (data) {
-								socket.broadcast.emit(eventName, data);
-							}
-							else {
-								socket.broadcast.emit(eventName);
-							}
-
+							_server.sockets.emit(eventName);
 						}
 
 					}
+					else if ("undefined" !== typeof data) {
+						socket.broadcast.emit(eventName, data);
+					}
+					else {
+						socket.broadcast.emit(eventName);
+					}
 
-				});
+				}
 
-				resolve();
-
 			});
 
-		}
+			return Promise.resolve();
 
+		});
+
 	}
 
-	removeAllListeners(eventNames) {
+	removeAllListeners (eventNames) {
 
-		if (!eventNames) {
-			return Promise.reject("There is no eventNames");
-		}
-			else if ("string" !== typeof eventNames && !(eventNames instanceof Array)) {
-				return Promise.reject("eventNames is not a string or an array");
+		return Promise.resolve().then(() => {
+
+			if ("undefined" === typeof eventNames) {
+				return Promise.reject(new ReferenceError("There is no eventNames"));
 			}
-		else {
+				else if ("string" !== typeof eventNames && !(eventNames instanceof Array)) {
+					return Promise.reject(new TypeError("eventNames is not an array"));
+				}
+			else {
+				return Promise.resolve();
+			}
 
-			return new Promise((resolve) => {
-				
-				if (!(eventNames instanceof Array)) {
-					eventNames = [eventNames];
+		}).then(() => {
+
+			("string" === typeof eventNames ? [ eventNames ] : eventNames).forEach((eventName) => {
+
+				for (let i = 0; i < this._sockets.length; ++i) {
+					this._sockets[i].removeAllListeners(eventName);
 				}
 
-				this.servers.forEach((server) => {
+			});
 
-					if (server.sockets && server.sockets.sockets) {
+			return Promise.resolve();
 
-						eventNames.forEach((eventName) => {
-							server.sockets.sockets.removeAllListeners(eventName);
-						});
+		}).then(() => {
 
-					}
+			this.servers.forEach((server) => {
 
-				});
-			
-				resolve();
+				if (server.sockets && server.sockets.sockets) {
 
-			});
+					("string" === typeof eventNames ? [ eventNames ] : eventNames).forEach((eventName) => {
+						server.sockets.sockets.removeAllListeners(eventName);
+					});
 
-		}
+				}
 
-	}
+			});
 
-	close() {
-
-		if (0 >= this.servers.length) {
 			return Promise.resolve();
-		}
-		else {
 
-			return new Promise((resolve) => {
+		});
 
-				this.servers.forEach((server) => {
+	}
 
-					if (server.sockets) {
+	close () {
 
-						server.sockets.close();
+		return Promise.resolve().then(() => {
 
-						if (server.sockets.sockets) {
+			return 0 >= this.servers.length ?
+				Promise.resolve() :
+				Promise.resolve().then(() => {
 
-							if (server.sockets.sockets._events) {
+					this.servers.forEach((server) => {
 
-								for (let event in server.sockets.sockets._events) {
-									server.sockets.sockets.removeAllListeners(event);
-								}
+						if (server.sockets) {
+							server.sockets.close();
+						}
 
-							}
+					});
 
-							if (server.sockets.sockets.sockets) {
+					for (let i = 0; i < this._sockets.length; ++i) {
 
-								for (let id in server.sockets.sockets.sockets) {
-									server.sockets.sockets.sockets[id].disconnect(true);
-								}
-
-							}
-							
+						try {
+							this._sockets[i].close();
 						}
+						catch (e) {
+							// nothing to do here
+						}
 
 					}
 
-				});
+					this._sockets = [];
 
-				resolve();
+					return Promise.resolve();
 
-			}).then(() => {
-				return super.close();
-			});
+				});
 
-		}
+		}).then(() => {
+			return super.close();
+		});
 
 	}
 
-	release() {
+	release () {
 
-		this._tmpOnConnection = [];
+		return Promise.resolve().then(() => {
 
-		return super.release();
+			this._tmpOnConnection = [];
+			return super.release();
 
+		});
+
 	}
 
 };

package.json

 {
   "name": "node-multi-socketservers",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "A multi http & socket servers manager, based on node-multi-webserver",
@@ -8,3 +8,4 @@ "main": "lib/main.js",
     "start": "node lib/main.js",
-    "test": "gulp mocha"
+    "test": "gulp mocha",
+    "test-travis": "gulp mocha"
   },
@@ -36,10 +37,12 @@ "pre-commit": [
     "node-multi-webserver": "^1.2.4",
-    "socket.io": "^2.0.3"
+    "socket.io": "^2.0.4"
   },
   "devDependencies": {
-    "gulp": "^3.9.1",
-    "gulp-plumber": "^1.1.0",
-    "gulp-eslint": "^3.0.1",
-    "gulp-mocha": "^4.3.1",
-    "pre-commit": "^1.2.2"
+    "gulp": "3.9.1",
+    "gulp-plumber": "1.1.0",
+    "gulp-eslint": "4.0.0",
+    "gulp-mocha": "3.0.1",
+    "gulp-istanbul": "1.1.2",
+    "gulp-coveralls": "0.1.4",
+    "pre-commit": "1.2.2"
   },
@@ -46,0 +49,0 @@ "homepage": "https://github.com/Psychopoulet/node-multi-socketservers#readme",

README.md

 # node-multi-socketservers
 A multi http and socket servers manager, based on node-multi-webserver
 
+[![Build Status](https://api.travis-ci.org/Psychopoulet/node-multi-socketservers.svg?branch=develop)](https://travis-ci.org/Psychopoulet/node-multi-socketservers)
+[![Coverage Status](https://coveralls.io/repos/github/Psychopoulet/node-multi-socketservers/badge.svg?branch=develop)](https://coveralls.io/github/Psychopoulet/node-multi-socketservers)
+[![Dependency Status](https://img.shields.io/david/Psychopoulet/node-multi-socketservers/develop.svg)](https://github.com/Psychopoulet/node-multi-socketservers)
+
 # Installation
@@ -5,0 +9,0 @@

tests/tests.js

@@ -0,1 +1,5 @@
+/*
+	eslint max-nested-callbacks: [ "error", 7 ]
+*/
+
 "use strict";
@@ -5,13 +9,9 @@
 
-	const 	path = require("path"),
-			assert = require("assert"),
+	const path = require("path");
+	const assert = require("assert");
 
-			ioClient = require("socket.io-client"),
+	const ioClient = require("socket.io-client");
 
-			multiservers = require(path.join(__dirname, "..", "lib", "main.js"));
+	const MultiServers = require(path.join(__dirname, "..", "lib", "main.js"));
 
-// private
-
-	var servers = new multiservers();
-
 // tests
@@ -21,2 +21,4 @@
 
+	const servers = new MultiServers();
+
 	describe("connection", () => {
@@ -26,6 +28,8 @@
 
-			return servers.connection().then(() => {
-				return Promise.reject("run with missing eventListener");
-			}).catch(() => {
-				return Promise.resolve();
+			return new Promise((resolve, reject) => {
+
+				servers.connection().then(() => {
+					reject(new Error("run with missing eventListener"));
+				}).catch(resolve);
+
 			});
@@ -37,6 +41,8 @@
 
-				return servers.connection("test").then(() => {
-					return Promise.reject("run with wrong eventListener");
-				}).catch(() => {
-					return Promise.resolve();
+				return new Promise((resolve, reject) => {
+
+					servers.connection("test").then(() => {
+						reject(new Error("run with wrong eventListener"));
+					}).catch(resolve);
+
 				});
@@ -48,2 +54,30 @@
 
+	describe("listen", () => {
+
+		it("should fail on missing requestListener", () => {
+
+			return new Promise((resolve, reject) => {
+
+				servers.listen().then(() => {
+					reject(new Error("run with missing requestListener"));
+				}).catch(resolve);
+
+			});
+
+		});
+
+			it("should fail on wrong requestListener", () => {
+
+				return new Promise((resolve, reject) => {
+
+					servers.listen(false).then(() => {
+						reject(new Error("run with wrong requestListener"));
+					}).catch(resolve);
+
+				});
+
+			});
+
+	});
+
 	describe("emit", () => {
@@ -53,6 +87,8 @@
 
-			return servers.emit().then(() => {
-				return Promise.reject("run with missing eventName");
-			}).catch(() => {
-				return Promise.resolve();
+			return new Promise((resolve, reject) => {
+
+				servers.emit().then(() => {
+					reject(new Error("run with missing eventName"));
+				}).catch(resolve);
+
 			});
@@ -64,6 +100,8 @@
 
-				return servers.emit(false).then(() => {
-					return Promise.reject("run with wrong eventName");
-				}).catch(() => {
-					return Promise.resolve();
+				return new Promise((resolve, reject) => {
+
+					servers.emit(false).then(() => {
+						reject(new Error("run with wrong eventName"));
+					}).catch(resolve);
+
 				});
@@ -73,2 +111,14 @@
 
+			it("should fail on empty eventName", () => {
+
+				return new Promise((resolve, reject) => {
+
+					servers.emit("").then(() => {
+						reject(new Error("run with empty eventName"));
+					}).catch(resolve);
+
+				});
+
+			});
+
 	});
@@ -80,6 +130,8 @@
 
-			return servers.broadcast().then(() => {
-				return Promise.reject("run with missing socket");
-			}).catch(() => {
-				return Promise.resolve();
+			return new Promise((resolve, reject) => {
+
+				servers.broadcast().then(() => {
+					reject(new Error("run with missing socket"));
+				}).catch(resolve);
+
 			});
@@ -91,6 +143,8 @@
 
-				return servers.broadcast(false).then(() => {
-					return Promise.reject("run with wrong socket");
-				}).catch(() => {
-					return Promise.resolve();
+				return new Promise((resolve, reject) => {
+
+					servers.broadcast(false).then(() => {
+						reject(new Error("run with wrong socket"));
+					}).catch(resolve);
+
 				});
@@ -102,6 +156,8 @@
 
-			return servers.broadcast({}).then(() => {
-				return Promise.reject("run with missing server");
-			}).catch(() => {
-				return Promise.resolve();
+			return new Promise((resolve, reject) => {
+
+				servers.broadcast({}).then(() => {
+					reject(new Error("run with missing server"));
+				}).catch(resolve);
+
 			});
@@ -113,6 +169,8 @@
 
-				return servers.broadcast({}, false).then(() => {
-					return Promise.reject("run with wrong server");
-				}).catch(() => {
-					return Promise.resolve();
+				return new Promise((resolve, reject) => {
+
+					servers.broadcast({}, false).then(() => {
+						reject(new Error("run with wrong server"));
+					}).catch(resolve);
+
 				});
@@ -124,6 +182,8 @@
 
-			return servers.broadcast({}, {}).then(() => {
-				return Promise.reject("run with missing eventName");
-			}).catch(() => {
-				return Promise.resolve();
+			return new Promise((resolve, reject) => {
+
+				servers.broadcast({}, {}).then(() => {
+					reject(new Error("run with missing eventName"));
+				}).catch(resolve);
+
 			});
@@ -133,8 +193,10 @@
 
-			it("should fail on wrong server", () => {
+			it("should fail on wrong eventName", () => {
 
-				return servers.broadcast({}, {}, false).then(() => {
-					return Promise.reject("run with wrong eventName");
-				}).catch(() => {
-					return Promise.resolve();
+				return new Promise((resolve, reject) => {
+
+					servers.broadcast({}, {}, false).then(() => {
+						reject(new Error("run with wrong eventName"));
+					}).catch(resolve);
+
 				});
@@ -144,2 +206,14 @@
 
+			it("should fail on empty eventName", () => {
+
+				return new Promise((resolve, reject) => {
+
+					servers.broadcast({}, {}, "").then(() => {
+						reject(new Error("run with empty eventName"));
+					}).catch(resolve);
+
+				});
+
+			});
+
 	});
@@ -151,6 +225,8 @@
 
-			return servers.removeAllListeners().then(() => {
-				return Promise.reject("run with missing eventName");
-			}).catch(() => {
-				return Promise.resolve();
+			return new Promise((resolve, reject) => {
+
+				servers.removeAllListeners().then(() => {
+					reject(new Error("run with missing eventName"));
+				}).catch(resolve);
+
 			});
@@ -162,6 +238,8 @@
 
-				return servers.removeAllListeners(false).then(() => {
-					return Promise.reject("run with wrong eventName");
-				}).catch(() => {
-					return Promise.resolve();
+				return new Promise((resolve, reject) => {
+
+					servers.removeAllListeners(false).then(() => {
+						reject(new Error("run with wrong eventName"));
+					}).catch(resolve);
+
 				});
@@ -177,2 +255,4 @@
 
+	const servers = new MultiServers();
+
 	it("should release servers", () => {
@@ -186,19 +266,26 @@ return servers.release();
 
-	before(() => { return servers.release(); });
-	after(() => { return servers.release(); });
+	const servers = new MultiServers();
 
+	after(() => {
+		return servers.release();
+	});
+
 	it("should create servers", () => {
 
 		return servers.addServer({
-			port: 1337,
-			name: "basic http server"
+			"port": 1337,
+			"name": "basic http server"
 		}).then(() => {
 
 			return servers.addServer({
-				port: 1338,
-				name: "basic http server 2"
+				"port": 1338,
+				"name": "basic http server 2"
 			});
 
 		}).then(() => {
-			return servers.listen(() => { });
+
+			return servers.listen(() => {
+				// nothing to do here
+			});
+
 		}).then(() => {
@@ -228,15 +315,18 @@
 
-		before(() => { return servers.release(); });
-		after(() => { return servers.release(); });
+		const servers = new MultiServers();
 
+		after(() => {
+			return servers.release();
+		});
+
 		it("should connect & disconnect on created servers", (done) => {
 
 			servers.addServer({
-				port: 1337,
-				name: "basic http server"
+				"port": 1337,
+				"name": "basic http server"
 			}).then(() => {
 
 				return servers.addServer({
-					port: 1338,
-					name: "basic http server 2"
+					"port": 1338,
+					"name": "basic http server 2"
 				});
@@ -246,3 +336,3 @@
 
-				let socket = ioClient("http://localhost:1337");
+				const socket = ioClient("http://localhost:1337");
 
@@ -258,3 +348,7 @@ socket.on("disconnect", () => {
 			}).then(() => {
-				return servers.listen(() => {});
+
+				return servers.listen(() => {
+					// nothing to do here
+				});
+
 			});
@@ -268,22 +362,29 @@
 
-		before(() => { return servers.release(); });
-		after(() => { return servers.release(); });
+		const servers = new MultiServers();
 
+		after(() => {
+			return servers.release();
+		});
+
 		it("should connect & disconnect on created servers", (done) => {
 
 			servers.addServer({
-				port: 1337,
-				name: "basic http server"
+				"port": 1337,
+				"name": "basic http server"
 			}).then(() => {
 
 				return servers.addServer({
-					port: 1338,
-					name: "basic http server 2"
+					"port": 1338,
+					"name": "basic http server 2"
 				});
 
 			}).then(() => {
-				return servers.listen(() => {});
+
+				return servers.listen(() => {
+					// nothing to do here
+				});
+
 			}).then(() => {
 
-				let socket = ioClient("http://localhost:1337");
+				const socket = ioClient("http://localhost:1337");
 
@@ -308,23 +409,158 @@ socket.on("disconnect", () => {
 
-	before(() => { return servers.release(); });
-	after(() => { return servers.release(); });
+	describe("global events", () => {
 
-	it("should remove all listeners from these servers", () => {
+		const servers = new MultiServers();
 
-		return servers.addServer({
-			port: 1337,
-			name: "basic http server"
+		after(() => {
+			return servers.release();
+		});
+
+		it("should remove all listeners from these servers", () => {
+
+			return servers.addServer({
+				"port": 1337,
+				"name": "basic http server"
+			}).then(() => {
+
+				return servers.addServer({
+					"port": 1338,
+					"name": "basic http server 2"
+				});
+
+			}).then(() => {
+
+				return servers.listen(() => {
+					// nothing to do here
+				});
+
+			}).then(() => {
+
+				return servers.connection(() => {
+					// nothing to do here
+				});
+
+			}).then(() => {
+
+				assert.strictEqual(2, servers.servers.length, "servers number is incorrect");
+				assert.strictEqual("object", typeof servers.servers[0].sockets, "server sockets object is incorrect");
+				assert.strictEqual("object", typeof servers.servers[0].sockets.sockets, "sockets manager object is incorrect");
+				assert.strictEqual("object", typeof servers.servers[0].sockets.sockets._events, "event manager object is incorrect");
+				assert.strictEqual("function", typeof servers.servers[0].sockets.sockets._events.connection, "connection event is incorrect");
+
+				return Promise.resolve();
+
+			}).then(() => {
+				return servers.removeAllListeners("connection");
+			}).then(() => {
+
+				assert.strictEqual(2, servers.servers.length, "servers number is incorrect");
+				assert.strictEqual("object", typeof servers.servers[0].sockets, "server sockets object is incorrect");
+				assert.strictEqual("object", typeof servers.servers[0].sockets.sockets, "sockets manager object is incorrect");
+				assert.strictEqual("object", typeof servers.servers[0].sockets.sockets._events, "event manager object is incorrect");
+				assert.strictEqual("undefined", typeof servers.servers[0].sockets.sockets._events.connection, "connection event is incorrect");
+
+				return Promise.resolve();
+
+			});
+
+		});
+
+	});
+
+	describe("removed events", () => {
+
+		const servers = new MultiServers();
+
+		after(() => {
+			return servers.release();
+		});
+
+		it("should remove all listeners from the sockets", (done) => {
+
+			servers.addServer({
+				"port": 1337,
+				"name": "basic http server"
+			}).then(() => {
+
+				return servers.addServer({
+					"port": 1338,
+					"name": "basic http server 2"
+				});
+
+			}).then(() => {
+
+				return servers.listen(() => {
+					// nothing to do here
+				});
+
+			}).then(() => {
+
+				return servers.connection((socket) => {
+
+					socket.on("disconnect", () => {
+						done();
+					}).on("test1", () => {
+						done(new Error("Impossible to remove \"test1\" event"));
+					}).on("test2", () => {
+						done(new Error("Impossible to remove \"test2\" event"));
+					}).on("test3", socket.disconnect).on("query", () => {
+
+						socket.removeAllListeners("test1");
+
+						servers.removeAllListeners("test2").then(() => {
+							socket.emit("answer");
+						});
+
+					});
+
+				});
+
+			}).then(() => {
+
+				const socketClient = ioClient("http://localhost:1337");
+
+				socketClient.on("connect", () => {
+					socketClient.emit("query");
+				}).on("answer", () => {
+
+					socketClient.emit("test1");
+					socketClient.emit("test2");
+					socketClient.emit("test3");
+
+				});
+
+				return Promise.resolve();
+
+			});
+
+		});
+
+	});
+
+});
+
+describe("emit", () => {
+
+	const servers = new MultiServers();
+
+	after(() => {
+		return servers.release();
+	});
+
+	it("should send data to the clients", (done) => {
+
+		servers.addServer({
+			"port": 1337,
+			"name": "basic http server"
 		}).then(() => {
 
 			return servers.addServer({
-				port: 1338,
-				name: "basic http server 2"
+				"port": 1338,
+				"name": "basic http server 2"
 			});
 
 		}).then(() => {
-			return servers.listen(() => {});
-		}).then(() => {
 
-			return servers.connection((socket) => {
-				socket.on("newconnection", () => { });
+			return servers.listen(() => {
+				// nothing to do here
 			});
@@ -334,20 +570,24 @@
 
-			assert.strictEqual(2, servers.servers.length, "servers number is incorrect");
-			assert.strictEqual("object", typeof servers.servers[0].sockets, "server sockets object is incorrect");
-			assert.strictEqual("object", typeof servers.servers[0].sockets.sockets, "sockets manager object is incorrect");
-			assert.strictEqual("object", typeof servers.servers[0].sockets.sockets._events, "event manager object is incorrect");
-			assert.strictEqual("function", typeof servers.servers[0].sockets.sockets._events.connection, "connection event is incorrect");
+			return servers.connection((socket) => {
 
-			return Promise.resolve();
+				socket.on("disconnect", () => {
+					done();
+				}).on("query", () => {
 
+					servers.emit("answertest", "test").then(() => {
+						return servers.emit("answer");
+					});
+
+				});
+
+			});
+
 		}).then(() => {
-			return servers.removeAllListeners("connection");
-		}).then(() => {
 
-			assert.strictEqual(2, servers.servers.length, "servers number is incorrect");
-			assert.strictEqual("object", typeof servers.servers[0].sockets, "server sockets object is incorrect");
-			assert.strictEqual("object", typeof servers.servers[0].sockets.sockets, "sockets manager object is incorrect");
-			assert.strictEqual("object", typeof servers.servers[0].sockets.sockets._events, "event manager object is incorrect");
-			assert.strictEqual("undefined", typeof servers.servers[0].sockets.sockets._events.connection, "connection event is incorrect");
+			const socketClient = ioClient("http://localhost:1337");
 
+			socketClient.on("answer", socketClient.disconnect).on("connect", () => {
+				socketClient.emit("query");
+			});
+
 			return Promise.resolve();
@@ -357,3 +597,3 @@
 
-	});
+	}).timeout(1000);
 
@@ -366,19 +606,26 @@ });
 
-		before(() => { return servers.release(); });
-		after(() => { return servers.release(); });
+		const servers = new MultiServers();
 
+		after(() => {
+			return servers.release();
+		});
+
 		it("should receive data from these servers", (done) => {
 
 			servers.addServer({
-				port: 1337,
-				name: "basic http server"
+				"port": 1337,
+				"name": "basic http server"
 			}).then(() => {
 
 				return servers.addServer({
-					port: 1338,
-					name: "basic http server 2"
+					"port": 1338,
+					"name": "basic http server 2"
 				});
 
 			}).then(() => {
-				return servers.listen(() => {});
+
+				return servers.listen(() => {
+					// nothing to do here
+				});
+
 			}).then(() => {
@@ -388,6 +635,5 @@
 
-					socket.on("newconnection", () => {
-						socket.disconnect();
+					socket.on("disconnect", () => {
 						done();
-					});
+					}).on("query", socket.disconnect);
 
@@ -398,6 +644,6 @@ });
 
-				let socket = ioClient("http://localhost:1337");
+				const socketClient = ioClient("http://localhost:1337");
 
-				socket.on("connect", () => {
-					socket.emit("newconnection");
+				socketClient.on("connect", () => {
+					socketClient.emit("query");
 				});
@@ -415,15 +661,18 @@
 
-		before(() => { return servers.release(); });
-		after(() => { return servers.release(); });
+		const servers = new MultiServers();
 
+		after(() => {
+			return servers.release();
+		});
+
 		it("should receive data from these servers", (done) => {
 
 			servers.addServer({
-				port: 1337,
-				name: "basic http server"
+				"port": 1337,
+				"name": "basic http server"
 			}).then(() => {
 
 				return servers.addServer({
-					port: 1338,
-					name: "basic http server 2"
+					"port": 1338,
+					"name": "basic http server 2"
 				});
@@ -435,6 +684,5 @@
 
-					socket.on("newconnection", () => {
-						socket.disconnect();
+					socket.on("disconnect", () => {
 						done();
-					});
+					}).on("query", socket.disconnect);
 
@@ -444,9 +692,13 @@ });
 			}).then(() => {
-				return servers.listen(() => {});
+
+				return servers.listen(() => {
+					// nothing to do here
+				});
+
 			}).then(() => {
 
-				let socket = ioClient("http://localhost:1337");
+				const socketClient = ioClient("http://localhost:1337");
 
-				socket.on("connect", () => {
-					socket.emit("newconnection");
+				socketClient.on("connect", () => {
+					socketClient.emit("query");
 				});
@@ -461,3 +713,3 @@
 	});
-	
+
 });
@@ -467,19 +719,26 @@
 
-	before(() => { return servers.release(); });
-	after(() => { return servers.release(); });
+	const servers = new MultiServers();
 
+	after(() => {
+		return servers.release();
+	});
+
 	it("should receive data from one servers", (done) => {
 
 		servers.addServer({
-			port: 1337,
-			name: "basic http server"
+			"port": 1337,
+			"name": "basic http server"
 		}).then(() => {
 
 			return servers.addServer({
-				port: 1338,
-				name: "basic http server 2"
+				"port": 1338,
+				"name": "basic http server 2"
 			});
 
 		}).then(() => {
-			return servers.listen(() => {});
+
+			return servers.listen(() => {
+				// nothing to do here
+			});
+
 		}).then(() => {
@@ -489,13 +748,12 @@
 
-				if(1338 === server.options.port) {
+				if (1338 === server.options.port) {
 
-					servers.broadcast(socket, server, "newconnection").then(() => {
+					servers.broadcast(socket, server, "answer").then(() => {
 						socket.disconnect();
 					});
-					
+
 				}
 				else {
 
-					socket.on("done", () => {
-						socket.disconnect();
+					socket.on("disconnect", () => {
 						done();
@@ -510,6 +768,8 @@ });
 
-			ioClient("http://localhost:1337").on("newconnection", function() {
-				this.emit("done");
-			}).on("connect", () => {
+			const socketClient = ioClient("http://localhost:1337");
+
+			socketClient.on("connect", () => {
 				ioClient("http://localhost:1338");
+			}).on("answer", () => {
+				socketClient.disconnect();
 			});
@@ -516,0 +776,0 @@

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Dynamic require

Supply chain risk

Dynamic require can indicate the package is performing dangerous or unsafe dynamic code execution.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

38745

increased by72.1%

Number of package files

11

increased by57.14%

Lines of code

1037

increased by84.52%

Number of lines in readme file

172

increased by2.38%

Worsened metrics

Dev dependency count

7

increased by40%

Number of low supply chain risk alerts

4

increased by300%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• Updatedsocket.io@^2.0.4