added more tests and created a setup for mocking wow functions like C…

…reateFrame in the timer class

.vscode/launch.json

@@ -12,9 +12,26 @@
             "args": [
                 "-r",
                 "ts-node/register",
+                "-r",
+                "test/mocks/enableMocks.ts",
                 "${file}"
             ],
-            "internalConsoleOptions": "neverOpen"
+            "internalConsoleOptions": "openOnSessionStart"
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Debug All Test Files",
+            "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+            "args": [
+                "-r",
+                "ts-node/register",
+                "-r",
+                "test/mocks/enableMocks.ts",
+                "./test/**/*.spec.ts"
+            ],
+            "internalConsoleOptions": "openOnSessionStart",
+            "cwd": "${workspaceFolder}"
         }
     ]
 }

.vscode/tasks.json

@@ -10,6 +10,8 @@
             "args": [
                 "-r",
                 "ts-node/register",
+                "-r",
+                "test/mocks/enableMocks.ts",
                 "${file}"
             ],
             "options": {

package.json

@@ -4,8 +4,8 @@
   "description": "A Framework written in Typescript for World of Warcraft Addons",
   "main": "index.js",
   "scripts": {
-    "test": "./node_modules/.bin/mocha -r ts-node/register \"test/**/*.spec.ts\"",
-    "coverage": "./node_modules/.bin/nyc ./node_modules/.bin/mocha -r ts-node/register \"test/**/*.spec.ts\"",
+    "test": "./node_modules/.bin/mocha -r ts-node/register -r test/mocks/enableMocks.ts \"test/**/*.spec.ts\"",
+    "coverage": "./node_modules/.bin/nyc ./node_modules/.bin/mocha -r ts-node/register -r test/mocks/enableMocks.ts \"test/**/*.spec.ts\"",
     "coverage:send:coveralls": "nyc report --reporter=text-lcov | coveralls",
     "build": "node_modules/.bin/qhun-transpiler -p ./qhun-transpiler.json",
     "build-dev": "node ../../qhun-transpiler/dist/index.js -p ./qhun-transpiler.json",
@@ -34,6 +34,7 @@
   "devDependencies": {
     "@types/chai": "^4.1.7",
     "@types/mocha": "^5.2.5",
+    "@types/node": "^10.12.9",
     "chai": "^4.2.0",
     "coveralls": "^3.0.2",
     "dependency-cruiser": "^4.6.0",

src/core/AddonOptions.ts

@@ -1,5 +1,4 @@
 import { Singleton } from "./decorators/Singleton";
-import { Debugger } from "./debug/Debugger";
 import { ModuleConfig } from "./data/ModuleConfig";
 
 @Singleton()
@@ -24,11 +23,6 @@ export class AddonOptions {
      */
     public addonName: string;
 
-    /**
-     * the debugger instance if debigging is enabled
-     */
-    public debuggerInstance: Debugger;
-
     /**
      * module specific configuration
      */

src/core/async/Promise.ts

@@ -1,4 +1,3 @@
-import { AddonOption } from "../decorators/AddonOption";
 import { Logger } from "../debug/Logger";
 import { Inject } from "../decorators/Inject";
 import { Timer } from "./Timer";
@@ -28,7 +27,7 @@ enum PromiseState {
  */
 export class Promise<T> implements PromiseLike<T> {
 
-    @AddonOption("debuggerInstance")
+    @Inject(Logger)
     private logger: Logger;
 
     @Inject(Timer)
@@ -72,7 +71,7 @@ export class Promise<T> implements PromiseLike<T> {
             return this.doneInternal((_, value?: T) => {
                 if (typeof onFulfilled === "function") {
                     try {
-                        return resolve(onFulfilled(value) as any);
+                        return resolve(onFulfilled(_ !== undefined ? _ : value) as any);
                     } catch (e) {
                         return reject(e);
                     }
@@ -83,7 +82,7 @@ export class Promise<T> implements PromiseLike<T> {
 
                 if (typeof onRejected === "function") {
                     try {
-                        return resolve(onRejected(reason) as any);
+                        return resolve(onRejected(_ !== undefined ? _ : reason) as any);
                     } catch (e) {
                         return reject(e);
                     }

src/core/async/Timer.ts

@@ -136,6 +136,16 @@ export class Timer {
         return uuid;
     }
 
+    /**
+     * removes the timeout/interval request by its identifier
+     * @param identifier the identifier to remove
+     */
+    public remove(identifier: string): void {
+
+        delete this.listeners[identifier];
+        this.checkStartStopTimer();
+    }
+
     /**
      * updates the timer based on the event frame update
      * @param timePassed the time passed in milliseconds
@@ -161,16 +171,6 @@ export class Timer {
         });
     }
 
-    /**
-     * removes the timeout/interval request by its identifier
-     * @param identifier the identifier to remove
-     */
-    private remove(identifier: string): void {
-
-        delete this.listeners[identifier];
-        this.checkStartStopTimer();
-    }
-
     /**
      * observes the listener stack and starts/stops the timer when
      * the stack is full/empty

src/core/debug/Logger.ts

@@ -1,5 +1,4 @@
 import { Debugger } from "./Debugger";
-import { AddonOption } from "../decorators/AddonOption";
 import { Injectable } from "../decorators/Injectable";
 
 /**
@@ -8,22 +7,19 @@ import { Injectable } from "../decorators/Injectable";
 @Injectable()
 export class Logger implements Debugger {
 
-    @AddonOption("debuggerInstance")
-    private debugger: Debugger;
-
     public debug(...args: any[]): void {
-        this.debugger.debug(...args);
+        print("[DEBUG] ", ...args);
     }
 
     public info(...args: any[]): void {
-        this.debugger.info(...args);
+        print("[INFO] ", ...args);
     }
 
     public warning(...args: any[]): void {
-        this.debugger.warning(...args);
+        print("[WARNING] ", ...args);
     }
 
     public error(...args: any[]): void {
-        this.debugger.error(...args);
+        print("[ERROR] ", ...args);
     }
 }

src/core/decorators/QhunAddon.ts

@@ -16,11 +16,6 @@ export function QhunAddon(
     addonOptionsInstance.addonName = __FILE_META[1];
     addonOptionsInstance.moduleConfig = options.modules || {};
 
-    // bootstrap the debugger
-    if (options.debugger && options.debugger.instance) {
-        addonOptionsInstance.debuggerInstance = bootstrapDebugger(options.debugger.instance, [options.debugger.data]);
-    }
-
     // go on with dependency injection
     const injector = Injector.getInstance();
     return <ClassDecorator>(<Target extends Function>(target: ClassConstructor<Target>) => {

src/core/di/Injector.ts

@@ -32,7 +32,8 @@ export class Injector {
      */
     private instanceStorage: {
         ctor: Function,
-        instance: Object
+        instance: Object,
+        manual: boolean
     }[] = [];
 
     constructor() {
@@ -43,7 +44,34 @@ export class Injector {
         // create another instance
         this.instanceStorage.push({
             ctor: Injector,
-            instance: this
+            instance: this,
+            manual: false
+        });
+    }
+
+    /**
+     * adds the given instance to the internal stack
+     * @param ctor the constructor of the instance
+     * @param instance the instance itself
+     */
+    public addInstance<T extends Object>(ctor: ClassConstructor<T>, instance: Partial<T>): void {
+
+        if (!this.findExistingInstance(ctor)) {
+            this.instanceStorage.push({
+                ctor: ctor,
+                instance: instance as Required<T>,
+                manual: true
+            });
+        }
+    }
+
+    /**
+     * removes all manually added instances from the internal stack
+     */
+    public clearManual(): void {
+
+        this.instanceStorage = this.instanceStorage.filter(dependency => {
+            return dependency.manual === false;
         });
     }
 
@@ -94,7 +122,8 @@ export class Injector {
         const instance = new (ctor as ClassConstructor)(...resolvedDependencies);
         this.instanceStorage.push({
             ctor: ctor,
-            instance: instance
+            instance: instance,
+            manual: false
         });
         return instance as T;
     }

test/core/async/Promise.spec.ts

@@ -4,11 +4,94 @@ import { expect } from "chai";
 
 @suite class PromiseSpec {
 
-
     @test "Promise can be constructed"() {
 
-        /*const p = new Promise((resolve, reject) => {
+        const p = new Promise((resolve, reject) => {
             resolve(true);
-        });*/
+        });
+
+        expect(p).to.be.an.instanceof(Promise);
+    }
+
+    @test(timeout(1000)) "Promise can resolve"(done: Function) {
+
+        new Promise((resolve, reject) => {
+
+            resolve(1);
+        }).done(() => {
+
+            done();
+        });
+    }
+
+    @test(timeout(1000)) "Promise can reject"(done: Function) {
+
+        new Promise((resolve, reject) => {
+            reject(1);
+        }).done(() => {
+            console.log("HERE");
+        }, () => {
+            done();
+        });
+    }
+
+    @test(timeout(1000)) "Promise is asynchronous"(done: Function) {
+
+        new Promise(resolve => {
+            setTimeout(resolve, 10);
+        }).done(() => done());
+    }
+
+    @test(timeout(1000)) "Promises can be chained"(done: Function) {
+
+        new Promise(resolve => {
+
+            resolve(1);
+        }).done(val => {
+
+            return new Promise<string>(resolve => {
+                resolve(val.toString());
+            });
+        }).done(stringVal => {
+
+            expect(stringVal).to.equal("1");
+            done();
+        });
+    }
+
+    @test(timeout(1000)) "Promises should reject when an exception has been thrown (1)"(done: Function) {
+
+        new Promise(() => {
+            throw "error";
+        }).done(() => { }, error => {
+            expect(error).to.equal("error");
+            done();
+        });
+    }
+
+    @test(timeout(1000)) "Promises should reject when an exception has been thrown (2)"(done: Function) {
+
+        new Promise(() => {
+            throw "error text";
+        }).done(() => { }, error => {
+            return new Promise(resolve => {
+                resolve(error);
+            });
+        }).done(message => {
+            expect(message).to.equal("error text");
+            done();
+        });
+    }
+
+    @test(timeout(1000)) "Promises should reject when an exception has been thrown (3)"(done: Function) {
+
+        new Promise((resolve, reject) => {
+            resolve("text");
+        }).done(val => {
+            throw "error " + val;
+        }).done(() => { }, err => {
+            expect(err).to.equal("error text");
+            done();
+        });
     }
 }