feat(middleware): Add tests for all middleware classes and decorators

src/common/models/collection.spec.ts

@@ -1,11 +1,5 @@
-import {
-  it, xit,
-  inject,
-  describe, xdescribe, fdescribe,
-  beforeEachProviders,
-  expect
-} from '@angular/core/testing';
-import { UUID, Model, primary } from './model';
+import { it, describe, beforeEach, expect } from '@angular/core/testing';
+import { Model, primary } from './model';
 import { Collection } from './collection';
 
 class BasicModel extends Model {

src/common/models/model.spec.ts

@@ -1,4 +1,4 @@
-import { it, describe, expect } from '@angular/core/testing';
+import { it, describe, expect, beforeEach } from '@angular/core/testing';
 import { UUID, Model, primary } from './model';
 import { castDate } from '../types/date.decorator';
 import * as moment from 'moment';

src/common/services/consoleLogger.service.ts

@@ -1,7 +1,10 @@
 import { Logger, LogLevel } from './logger.service';
 import { yellow, red, bgRed, magenta, gray, blue, bgYellow } from 'chalk';
 import { inspect } from 'util';
+import { Injectable } from '@angular/core';
 import * as moment from 'moment';
+
+@Injectable()
 export class ConsoleLogger extends Logger {
 
   constructor() {

src/common/services/logger.service.spec.ts

@@ -0,0 +1,15 @@
+import { Logger, LogLevel } from './logger.service';
+import { Injectable } from '@angular/core';
+
+@Injectable()
+export class LoggerMock extends Logger {
+
+  constructor() {
+    super(LoggerMock);
+  }
+
+  public persistLog(logLevel: LogLevel, messages: any[]): Promise<this>|this {
+    return this;
+  }
+
+}

src/common/services/logger.service.ts

@@ -1,3 +1,5 @@
+import { Injectable } from '@angular/core';
+
 const tableModule  = require('table');
 const table: Table = tableModule.default;
 
@@ -69,6 +71,7 @@ export interface Table {
   (data: any[][], config?: TableConfig): string;
 }
 
+@Injectable()
 export abstract class Logger {
 
   protected sourceName: string;

src/server/controllers/abstract.controller.ts

@@ -1,5 +1,5 @@
 import { Server } from '../servers/abstract.server';
-import { Injectable, ReflectiveInjector } from '@angular/core';
+import { Injectable, Injector } from '@angular/core';
 import { Logger } from '../../common/services/logger.service';
 import { InjectableMiddlewareFactory, MiddlewareFactory } from '../middleware/index';
 import { PromiseFactory } from '../../common/util/serialPromise';
@@ -39,7 +39,7 @@ export abstract class AbstractController {
 
   protected routeBase: string;
   protected logger: Logger;
-  private injector: ReflectiveInjector;
+  private injector: Injector;
 
   constructor(protected server: Server, logger: Logger) {
     this.logger = logger.source('controller');
@@ -52,7 +52,7 @@ export abstract class AbstractController {
    * @param injector
    * @returns {AbstractController}
    */
-  public registerInjector(injector: ReflectiveInjector) {
+  public registerInjector(injector: Injector) {
     this.injector = injector;
     return this;
   }
@@ -99,7 +99,6 @@ export abstract class AbstractController {
     }
 
     return this;
-
   }
 
   /**
@@ -116,18 +115,19 @@ export abstract class AbstractController {
 
       if (this.registeredMiddleware){
         const methodMiddlewareFactories = this.registeredMiddleware.methods.get(methodSignature);
-        //wrap method registered factories with the class defined ones
-        methodMiddlewareFactories.before.unshift(...this.registeredMiddleware.all.before);
-        methodMiddlewareFactories.after.push(...this.registeredMiddleware.all.after);
+
+        //wrap method registered factories with the class defined ones [beforeAll, before, after, afterAll]
+        const beforeMiddleware = this.registeredMiddleware.all.before.concat(methodMiddlewareFactories.before);
+        const afterMiddleware = methodMiddlewareFactories.after.concat(this.registeredMiddleware.all.after);
 
         if (methodMiddlewareFactories) {
-          callStack.unshift(...methodMiddlewareFactories.before.map((middleware: MiddlewareFactory) => middleware(this.injector)));
-          callStack.push(...methodMiddlewareFactories.after.map((middleware: MiddlewareFactory) => middleware(this.injector)));
+          callStack.unshift(...beforeMiddleware.map((middleware: MiddlewareFactory) => middleware(this.injector)));
+          callStack.push(...afterMiddleware.map((middleware: MiddlewareFactory) => middleware(this.injector)));
         }
       }
 
-
       this.server.register({
+        methodName: methodSignature,
         method: methodDefinition.method,
         path: `/api/${this.routeBase}${methodDefinition.route}`,
         callStack: callStack,

src/server/middleware/debugLog.middleware.spec.ts

@@ -0,0 +1,96 @@
+import {
+  it,
+  inject,
+  beforeEachProviders,
+  expect,
+  describe,
+  fdescribe
+} from '@angular/core/testing';
+import { IsolatedMiddlewareFactory } from './index';
+import { Request } from '../controllers/request';
+import { Response } from '../controllers/response';
+import { Action } from '../controllers/action.decorator';
+import { AfterAll, BeforeAll, Before, After } from './middleware.decorator';
+import { AbstractController } from '../controllers/abstract.controller';
+import { Injectable, Injector, Provider, provide } from '@angular/core';
+import { Logger } from '../../common/services/logger.service';
+import { Server, RouteConfig } from '../servers/abstract.server';
+import { LoggerMock } from '../../common/services/logger.service.spec';
+import { ServerMock } from '../servers/abstract.server.spec';
+import { RemoteCli } from '../services/remoteCli.service';
+import { RemoteCliMock } from '../services/remoteCli.service.spec';
+import { PromiseFactory } from '../../common/util/serialPromise';
+import { debugLog, DebugLogMiddleware } from './debugLog.middleware';
+
+@Injectable()
+class MiddlewareController extends AbstractController {
+
+  constructor(server: Server, logger: Logger) {
+    super(server, logger);
+  }
+
+  @Action('GET', '/test')
+  @Before(debugLog('test log input'))
+  public testMethod(request: Request, response: Response): Response {
+    return response;
+  }
+
+}
+
+let source: string, logs: any[] = [];
+
+let mockLogger = {
+  source: (input: string) => {
+    source = input;
+    return mockLogger;
+  },
+  debug: (input: string) => {
+    logs.push(input);
+  }
+};
+
+const providers = [
+  MiddlewareController,
+  provide(Server, {useClass: ServerMock}),
+  provide(Logger, {useClass: LoggerMock}),
+  provide(RemoteCli, {useClass: RemoteCliMock}),
+  provide(DebugLogMiddleware, {
+    deps: [],
+    useFactory: () => {
+      return new DebugLogMiddleware(<Logger>mockLogger)
+    },
+  })
+];
+
+describe('debugLog middleware', () => {
+
+  let controller: MiddlewareController;
+
+  beforeEachProviders(() => providers);
+
+  it('Calls debug.log on the passed value to the middleware decorator',
+    inject([MiddlewareController, Injector, Server],
+      (c: MiddlewareController, i: Injector, s: Server) => {
+
+        controller = c.registerInjector(i)
+          .registerRoutes();
+
+        const callStackHandler: any = s.getRoutes()
+          .find((route: RouteConfig) => route.methodName == 'testMethod').callStackHandler;
+
+        let request  = new Request();
+        let response = new Response();
+
+        return callStackHandler(request, response)
+          .then(() => {
+
+            expect(source)
+              .toEqual('debugLog');
+            expect(logs)
+              .toEqual(['test log input']);
+
+          });
+
+      }));
+
+});

src/server/middleware/debugLog.middleware.ts

@@ -9,24 +9,24 @@ export class DebugLogMiddleware implements InjectableMiddleware {
   protected logger: Logger;
 
   constructor(loggerBase: Logger) {
-    console.log('initialized log middleware', loggerBase);
-    this.logger = loggerBase.source('Log middleware');
+    this.logger = loggerBase.source('debugLog');
   }
 
   public middlewareFactory(messages: string[]): Middleware {
 
     return function debugLog(request: Request, response: Response): Response {
       this.logger.debug(...messages);
       return response;
-    }
+    }.bind(this);
+
   }
 }
 
 export function debugLog(...messages: string[]): InjectableMiddlewareFactory {
 
   return (injector: ReflectiveInjector): Middleware => {
     return injector.get(DebugLogMiddleware)
-      .middlewareFactory(messages)
+      .middlewareFactory(messages);
   }
 
 }

src/server/middleware/index.ts

@@ -1,4 +1,4 @@
-import { ReflectiveInjector } from '@angular/core';
+import { Injector } from '@angular/core';
 import { Response } from '../controllers/response';
 import { Request } from '../controllers/request';
 
@@ -11,11 +11,11 @@ export interface InjectableMiddleware {
 }
 
 export interface InjectableMiddlewareFactory {
-  (injector: ReflectiveInjector): Middleware;
+  (injector: Injector): Middleware;
 }
 
 export interface IsolatedMiddlewareFactory {
-  (injector?: ReflectiveInjector): Middleware;
+  (injector?: Injector): Middleware;
 }
 
 export type MiddlewareFactory = InjectableMiddlewareFactory | IsolatedMiddlewareFactory;

src/server/middleware/middleware.decorator.ts

@@ -1,6 +1,5 @@
 import { AbstractController, MiddlewareRegistry } from '../controllers/abstract.controller';
 import { MiddlewareFactory } from './index';
-import { initializeRelationMap } from '../../common/relations/index';
 
 /**
  * Decorator for assigning before middleware method in a controller
@@ -51,7 +50,7 @@ export function initializeMiddlewareRegister(target: AbstractController): void {
 export function BeforeAll(...middlewareFactories: MiddlewareFactory[]): ClassDecorator {
   return function (target: Function): void {
     initializeMiddlewareRegister(target.prototype);
-    target.prototype.registeredMiddleware.all.before.push(...middlewareFactories);
+    target.prototype.registeredMiddleware.all.before = middlewareFactories;
   }
 }
 
@@ -64,6 +63,6 @@ export function BeforeAll(...middlewareFactories: MiddlewareFactory[]): ClassDec
 export function AfterAll(...middlewareFactories: MiddlewareFactory[]): ClassDecorator {
   return function (target: Function): void {
     initializeMiddlewareRegister(target.prototype);
-    target.prototype.registeredMiddleware.all.after.push(...middlewareFactories);
+    target.prototype.registeredMiddleware.all.after = middlewareFactories;
   }
 }