Improve Code Coverage and Fix Bugs

CHANGELOG.md

@@ -12,11 +12,11 @@
 
   - [ ] Find a way to keep a new line between **@inject** anotation and property declarations.
 
-- [ ] Improve Code Coverage to reach 100%.
+- [x] Improve Code Coverage to reach 100%.
 
 ## RobotlegsJS-SignalCommandMap 0.1.0
 
-### v0.1.0
+### [v0.1.0](https://github.com/RobotlegsJS/RobotlegsJS-SignalCommandMap/releases/tag/0.1.0) - 2017-11-16
 
 - Update @robotlegsjs/signals to version 0.0.12 (see #26).
 
@@ -30,6 +30,8 @@
 
 - Add Pull Request Template (see #30).
 
+- Improve Code Coverage and Fix Bugs (see #31).
+
 - Update dev dependencies to latest version.
 
 ## RobotlegsJS-SignalCommandMap 0.0.1

src/robotlegs/bender/extensions/signalCommandMap/api/ISignalCommandMap.ts

@@ -5,7 +5,9 @@
 //  in accordance with the terms of the license agreement accompanying it.
 // ------------------------------------------------------------------------------
 
-import { ICommandMapper, ICommandUnmapper } from "@robotlegsjs/core";
+import { IClass, ICommandMapper, ICommandUnmapper } from "@robotlegsjs/core";
+
+import { ISignal } from "@robotlegsjs/signals";
 
 /**
  * The Signal Command Map allows you to bind Signals to Commands
@@ -17,14 +19,14 @@ export interface ISignalCommandMap {
      * @param signalClass The concrete Signal class
      * @return Command mapper
      */
-    map(signalClass: Object): ICommandMapper;
+    map(signalClass: IClass<ISignal>): ICommandMapper;
 
     /**
      * Unmaps a Signal based trigger from a command
      * @param signalClass The concrete Signal class
      * @return Command unmapper
      */
-    unmap(signalClass: Object): ICommandUnmapper;
+    unmap(signalClass: IClass<ISignal>): ICommandUnmapper;
 
     /**
      * Adds a handler to process mappings

src/robotlegs/bender/extensions/signalCommandMap/impl/SignalCommandMap.ts

@@ -8,6 +8,7 @@
 import {
     injectable,
     inject,
+    IClass,
     IInjector,
     IContext,
     ILogger,
@@ -17,6 +18,8 @@ import {
     CommandTriggerMap
 } from "@robotlegsjs/core";
 
+import { ISignal } from "@robotlegsjs/signals";
+
 import { ISignalCommandMap } from "../api/ISignalCommandMap";
 import { SignalCommandTrigger } from "./SignalCommandTrigger";
 
@@ -60,14 +63,14 @@ export class SignalCommandMap implements ISignalCommandMap {
     /**
      * @inheritDoc
      */
-    public map(signalClass: Object): ICommandMapper {
+    public map(signalClass: IClass<ISignal>): ICommandMapper {
         return this.getTrigger(signalClass).createMapper();
     }
 
     /**
      * @inheritDoc
      */
-    public unmap(signalClass: Object): ICommandUnmapper {
+    public unmap(signalClass: IClass<ISignal>): ICommandUnmapper {
         return this.getTrigger(signalClass).createMapper();
     }
 
@@ -83,19 +86,19 @@ export class SignalCommandMap implements ISignalCommandMap {
     /* Private Functions                                                          */
     /*============================================================================*/
 
-    private createTrigger(signalClass: Object): ICommandTrigger {
+    private createTrigger(signalClass: IClass<ISignal>): ICommandTrigger {
         return new SignalCommandTrigger(
             this._injector,
             signalClass,
             this._mappingProcessors
         );
     }
 
-    private getTrigger(signalClass: Object): SignalCommandTrigger {
+    private getTrigger(signalClass: IClass<ISignal>): SignalCommandTrigger {
         return <SignalCommandTrigger>this._triggerMap.getTrigger(signalClass);
     }
 
-    private getKey(signalClass: Object): Object {
+    private getKey(signalClass: IClass<ISignal>): IClass<ISignal> {
         return signalClass;
     }
 }

src/robotlegs/bender/extensions/signalCommandMap/impl/SignalCommandTrigger.ts

@@ -6,6 +6,7 @@
 // ------------------------------------------------------------------------------
 
 import {
+    IClass,
     IInjector,
     ILogger,
     ICommandExecutor,
@@ -26,7 +27,7 @@ export class SignalCommandTrigger implements ICommandTrigger {
     /* Private Properties                                                         */
     /*============================================================================*/
 
-    private _signalClass: any;
+    private _signalClass: IClass<ISignal>;
 
     private _signal: ISignal;
 
@@ -45,16 +46,20 @@ export class SignalCommandTrigger implements ICommandTrigger {
      */
     constructor(
         injector: IInjector,
-        signalClass: any,
+        signalClass: IClass<ISignal>,
         processors?: Function[],
         logger?: ILogger
     ) {
         this._injector = injector;
         this._signalClass = signalClass;
-        this._mappings = new CommandMappingList(this, processors, logger);
+        this._mappings = new CommandMappingList(
+            this,
+            processors ? processors : [],
+            logger
+        );
         this._executor = new CommandExecutor(
             injector,
-            this._mappings.removeMapping
+            this._mappings.removeMapping.bind(this._mappings)
         );
     }
 
@@ -78,7 +83,6 @@ export class SignalCommandTrigger implements ICommandTrigger {
                 .bind(this._signalClass)
                 .to(this._signalClass)
                 .inSingletonScope();
-            // this._injector.map(this._signalClass).asSingleton();
         }
         this._signal = this._injector.get<ISignal>(this._signalClass);
         this._signal.add(this.routePayloadToCommands);
@@ -101,11 +105,14 @@ export class SignalCommandTrigger implements ICommandTrigger {
     /* Private Functions                                                          */
     /*============================================================================*/
 
-    private routePayloadToCommands = (...valueObjects): void => {
+    private routePayloadToCommands = (...valueObjects: any[]): void => {
+        let valueClasses: any[] = this._signal.valueClasses;
+
         let payload: CommandPayload = new CommandPayload(
             valueObjects,
-            this._signal.valueClasses
+            valueClasses
         );
+
         this._executor.executeCommands(this._mappings.getList(), payload);
     };
 }

test/robotlegs/bender/extensions/signalCommandMap/impl/signalCommandMap.test.ts

@@ -0,0 +1,120 @@
+// ------------------------------------------------------------------------------
+//  Copyright (c) 2017 RobotlegsJS. All Rights Reserved.
+//
+//  NOTICE: You are permitted to use, modify, and distribute this file
+//  in accordance with the terms of the license agreement accompanying it.
+// ------------------------------------------------------------------------------
+
+import "../../../../../entry.ts";
+
+import sinon = require("sinon");
+
+import { assert } from "chai";
+
+import {
+    ISignal,
+    MonoSignal,
+    OnceSignal,
+    Signal,
+    DeluxeSignal,
+    PrioritySignal
+} from "@robotlegsjs/signals";
+
+import {
+    injectable,
+    IContext,
+    IInjector,
+    ICommandMapper,
+    ICommandUnmapper,
+    Context,
+    CommandMapper
+} from "@robotlegsjs/core";
+
+import { SignalCommandMap } from "../../../../../../src/robotlegs/bender/extensions/signalCommandMap/impl/SignalCommandMap";
+
+import { NullCommand } from "../support/NullCommand";
+
+describe("SignalCommandMap", () => {
+    let signal: ISignal;
+    let context: IContext;
+    let injector: IInjector;
+    let subject: SignalCommandMap;
+
+    beforeEach(() => {
+        signal = new Signal();
+        context = new Context();
+        injector = context.injector;
+        subject = new SignalCommandMap(context);
+    });
+
+    afterEach(() => {
+        signal.removeAll();
+        if (context.initialized) {
+            context.destroy();
+        }
+        signal = null;
+        context = null;
+        injector = null;
+        subject = null;
+    });
+
+    it("map_creates_mapper", () => {
+        let mapper: any = subject.map(Signal);
+
+        assert.instanceOf(mapper, CommandMapper);
+    });
+
+    it("test_map_returns_new_mapper_when_identical_signal", () => {
+        let mapper1: ICommandMapper = subject.map(Signal);
+        let mapper2: ICommandMapper = subject.map(Signal);
+
+        assert.isNotNull(mapper1);
+        assert.isNotNull(mapper2);
+        assert.notEqual(mapper1, mapper2);
+    });
+
+    it("test_unmap_returns_unmapper", () => {
+        let mapper: any = subject.unmap(Signal);
+
+        assert.instanceOf(mapper, CommandMapper);
+    });
+
+    it("test_robust_unmapping_non_existent_mappings", () => {
+        subject.unmap(Signal).fromCommand(NullCommand);
+    });
+
+    it("mapping_processor_is_called", () => {
+        let callCount: number = 0;
+        subject.addMappingProcessor((mapping: any) => {
+            callCount++;
+        });
+        subject.map(Signal).toCommand(NullCommand);
+        assert.equal(callCount, 1);
+    });
+
+    it("mapping_processors_are_called", () => {
+        let callCount: number = 0;
+        subject.addMappingProcessor((mapping: any) => {
+            callCount++;
+        });
+        subject.addMappingProcessor((mapping: any) => {
+            callCount++;
+        });
+        subject.addMappingProcessor((mapping: any) => {
+            callCount++;
+        });
+        subject.map(Signal).toCommand(NullCommand);
+        assert.equal(callCount, 3);
+    });
+
+    it("mapping_processor_added_twice_is_called_once", () => {
+        let callCount: number = 0;
+        let handler: Function = (mapping: any) => {
+            callCount++;
+        };
+        subject.addMappingProcessor(handler);
+        subject.addMappingProcessor(handler);
+        subject.map(Signal).toCommand(NullCommand);
+        assert.equal(callCount, 1);
+    });
+});