Merge 9e6898b into c43d17a

.eslintrc

@@ -22,7 +22,14 @@
 			"beforeColon": false,
 			"afterColon": true
 		}],
+		"no-debugger": "error",
+		"no-duplicate-case": "error",
+		"no-eval": "error",
+		"no-extra-bind": "error",
+		"no-extra-semi": "error",
 		"no-invalid-regexp": "error",
+		"no-lonely-if": "warn",
+		"no-multiple-empty-lines": ["error", {"max": 1}],
 		"no-multi-spaces": "error",
 		"no-trailing-spaces": "error",
 		"object-curly-spacing": "error",

src/DiscordBot.ts

@@ -6,19 +6,21 @@ import {DiscordUser} from "./wrappers/discord/DiscordUser";
 import {DiscordMessage} from "./wrappers/discord/DiscordMessage";
 import {EventEmitter} from "events";
 import {EventHandler} from "./utils/EventHandler";
+import {EventWrapper} from "./utils/EventWrapper";
 
 const Discord = require("discord.js");
 const client = new Discord.Client();
 
 export class DiscordBot implements IBot {
 	private _client: IClient;
 	private readonly _events: EventEmitter;
+	private readonly _token: string;
 	private readonly _apiEvents = {
 		error: {
 			name: "error",
 			returnClass: Error,
 			isWrapped: false,
-			isInitEvent: true
+			isInitEvent: false
 		},
 		serverMemberAdd: {
 			name: "guildMemberAdd",
@@ -48,31 +50,26 @@ export class DiscordBot implements IBot {
 
 	constructor(token: string) {
 		this._events = new EventEmitter();
+		this._token = token;
+	}
 
-		for (let name in this._apiEvents) {
+	onEvent(name: string, listener: (...args: any[]) => void): void {
+		if (this._apiEvents.hasOwnProperty(name)) {
 			let Event: EventHandler = new EventHandler(name, this._apiEvents);
+
 			if (Event.isInitEvent()) {
-				Event.wrap(client, this._events);
-			}
-		}
+				client.login(this._token).then(() => {
+					let eventWrapper: EventWrapper = new EventWrapper(client, this._events);
+					eventWrapper.registerEvents(this._apiEvents, true);
 
-		client.login(token).then(() => {
-			for (let name in this._apiEvents) { //register events
-				let Event: EventHandler = new EventHandler(name, this._apiEvents);
-				if (!Event.isInitEvent()) {
-					Event.wrap(client, this._events);
-				}
+					this._client = new DiscordClient(client);
+					listener();
+				}).catch((error) => {
+					ErrorHandler.throwError(error);
+				});
+			} else {
+				this._events.on(name, listener);
 			}
-
-			this._client = new DiscordClient(client);
-		}).catch(error => {
-			ErrorHandler.throwError(error);
-		});
-	}
-
-	onEvent(name: string, listener: (...args: any[]) => void): void {
-		if (this._apiEvents.hasOwnProperty(name)) {
-			this._events.on(name, listener);
 		} else {
 			ErrorHandler.throwErrorMessage(`The event '${name}' is not supported.`);
 		}

src/utils/EventWrapper.ts

@@ -0,0 +1,25 @@
+import {EventHandler} from "./EventHandler";
+import {EventEmitter} from "events";
+
+export class EventWrapper {
+	private readonly _originalEmitter: any;
+	private readonly _wrappedEmitter: EventEmitter;
+
+	constructor(originalEmitter: any, wrappedEmitter: EventEmitter) {
+		this._originalEmitter = originalEmitter;
+		this._wrappedEmitter = wrappedEmitter;
+	}
+
+	registerEvents(eventsToRegister: object, excludeInitEvents?: boolean) {
+		for (let name in eventsToRegister) {
+			if (eventsToRegister.hasOwnProperty(name)) {
+				let Event: EventHandler = new EventHandler(name, eventsToRegister);
+				let excludeEvent = excludeInitEvents ? Event.isInitEvent() : false;
+
+				if (!excludeEvent) {
+					Event.wrap(this._originalEmitter, this._wrappedEmitter);
+				}
+			}
+		}
+	}
+}

tests/discord/DiscordBotTest.ts

@@ -1,52 +1,48 @@
 import {DiscordClient} from "../../src/wrappers/discord/DiscordClient";
 import {IBot} from "../../src/interfaces/IBot";
-import {EventEmitter} from "events";
 
 const {DiscordBot} = require("../../src/DiscordBot");
 const assert = require("assert");
-const sinon = require("sinon");
 
 require("dotenv").config();
 const token = process.env.DISCORD_TOKEN;
 
-describe("The class DiscordBot", function() {
-	describe("The method onEvent", function() {
-		it("Throws an error if the event is not supported", function() {
+describe("The class DiscordBot", function () {
+	describe("The method onEvent", function () {
+		this.timeout(5000);
+		it("Throws an error when the event is not supported", function () {
 			//Arrange
 			let Bot: IBot = new DiscordBot(token);
 
 			try {
 				//Act
-				Bot.onEvent("test", () => {
-				});
+				Bot.onEvent("test", () => {});
 			} catch (e) {
 				//Assert
 				assert.strictEqual(e.toString(), "Error: The event 'test' is not supported.", "The correct error was thrown.");
 			}
 		});
 
-		it("Use the original event emitter", function() {
+		it("Initialises the client after the ready event was called", function () {
 			//Arrange
-			let listener = function() {};
-			let onEventEmitterStub = sinon.stub(EventEmitter.prototype, "on");
 			let Bot: IBot = new DiscordBot(token);
 
 			//Act
-			Bot.onEvent("ready", () => {
-				Bot.onEvent("message", listener);
+			let EventPromise = new Promise(resolve => {
+				Bot.onEvent("ready", () => {
+					resolve();
+				});
+			});
 
+			return EventPromise.then(() => {
 				//Assert
-				assert.strictEqual(onEventEmitterStub.getCall(0).args[0], "message", "The correct event name was handed over.");
-				assert.strictEqual(onEventEmitterStub.getCall(0).args[1], listener, "The correct listener was handed over.");
+				assert.strictEqual(Bot.getClient() instanceof DiscordClient, true, "The client was initialised correctly.");
 			});
-
-			//Cleanup
-			onEventEmitterStub.restore();
 		});
 	});
 
-	describe("The getter", function() {
-		it("Has a getter which returns the wrapped client object when it was initialized", function() {
+	describe("The getter", function () {
+		it("Has a getter which returns the wrapped client object when it was initialized", function () {
 			//Act
 			let Bot: IBot = new DiscordBot(token);
 
@@ -56,7 +52,7 @@ describe("The class DiscordBot", function() {
 			});
 		});
 
-		it("Returns an error because the bot has not been initialized yet", function() {
+		it("Returns an error because the bot has not been initialized yet", function () {
 			//Act
 			let Bot: IBot = new DiscordBot(token);
 

tests/utils/EventWrapperTest.ts

@@ -0,0 +1,50 @@
+import {EventEmitter} from "events";
+import {EventWrapper} from "../../src/utils/EventWrapper";
+
+const assert = require("assert");
+
+describe("The class EventWrapper", function() {
+	describe("The method registerEvents", function() {
+		beforeEach(function() {
+			this.originalEmitter = new EventEmitter();
+			this.eventsToRegister = {
+				ready: {
+					name: "ready",
+					returnClass: null,
+					isWrapped: false,
+					isInitEvent: true
+				},
+				serverMemberAdd: {
+					name: "guildMemberAdd",
+					returnClass: null,
+					isWrapped: false,
+					isInitEvent: false
+				}
+			};
+			this.wrappedEmitter = new EventEmitter();
+			this.EventWrapper = new EventWrapper(this.originalEmitter, this.wrappedEmitter);
+		});
+
+		afterEach(function() {
+			this.originalEmitter = null;
+			this.wrappedEmitter = null;
+			this.EventEmitter = null;
+		});
+
+		/*it("Registers all events including init events", function() {
+			//Act
+			this.EventWrapper.registerEvents(this.eventsToRegister);
+
+			this.originalEmitter.emit("ready");
+			this.originalEmitter.emit("guildMemberAdd");
+
+			//Assert
+			return new Promise(resolve => {
+				this.wrappedEmitter.on("serverMemberAdd", () => {
+					assert.strictEqual(this.wrappedEmitter, 2, "The correct amount of events was wrapped.");
+					resolve();
+				});
+			});
+		});*/
+	});
+});