it("should call the configFn before the errorConfigFn", (done) => {
        let middleware = function(req: restify.Request, res: restify.Response, next: restify.Next) { return; };
        let configFn = sinon.spy((app: restify.Server) => { app.use(middleware); });
        let errorConfigFn = sinon.spy((app: restify.Server) => { app.use(middleware); });
        let kernel = new Kernel();

        @injectable()
        class TestController {}

        kernel.bind(TYPE.Controller).to(TestController);
        let server = new InversifyRestifyServer(kernel);

        server.setConfig(configFn)
            .setErrorConfig(errorConfigFn);

        expect(configFn.called).to.be.false;
        expect(errorConfigFn.called).to.be.false;

        server.build();

        expect(configFn.calledOnce).to.be.true;
        expect(errorConfigFn.calledOnce).to.be.true;
        expect(configFn.calledBefore(errorConfigFn)).to.be.true;
        done();
    });

        testZone(async () => {
            const kernel = new inversify.Kernel();
            kernel.bind(TestService).to(TestService);
            kernel.applyMiddleware(
                interceptor.methodInterceptorMiddleware(kernel, {
                    targetClass: /TestService/
                }, TestInterceptor)
            );

            const testService = kernel.get(TestService);
            interceptorCall = false;
            await testService.invoke();
            expect(interceptorCall).toBeTruthy();

        }));

import {Kernel} from "inversify";

import {INinja, Ninja} from "./Ninja";
import {IKatana, Katana} from "./Katana";
import {IShuriken, Shuriken} from "./Shuriken";

var kernel = new Kernel();
kernel.bind<INinja>("INinja").to(Ninja);
kernel.bind<IKatana>("IKatana").to(Katana);
kernel.bind<IShuriken>("IShuriken").to(Shuriken);

export default kernel;

import { Kernel, makePropertyInjectDecorator, INewable } from 'inversify';
import { makeFluentProvideDecorator } from 'inversify-binding-decorators';
import Dockerode from 'dockerode';

export const kernel = new Kernel();

// bind 3rd party deps
kernel.bind(Dockerode).toConstantValue(Dockerode);

const provide = makeFluentProvideDecorator(kernel);

export function provideInstance (identifier: string|Symbol|INewable<any>) {
  return provide(identifier).done();
}

export function provideSingleton (identifier: string|Symbol|INewable<any>) {
  return provide(identifier).inSingletonScope().done();
}

export const inject = makePropertyInjectDecorator(kernel);

/// <reference path="../node_modules/inversify-dts/inversify/inversify.d.ts" />
/// <reference path="../node_modules/reflect-metadata/reflect-metadata.d.ts" />

import "reflect-metadata";
import * as express from 'express';
import { Kernel } from 'inversify';
import { Server } from './framework/server';
import { FooController } from './controllers/foo-controller';
import { FooService } from './services/foo-service';

// set up kernel
var kernel = new Kernel();
kernel.bind<FooService>('FooService').to(FooService);
kernel.bind<FooController>('FooController').to(FooController);

// create server
var server = new Server(kernel);

server
    .build()
    .listen(3000, 'localhost', callback);

function callback() {
    console.log('listening on http://localhost:3000');
}

export function registerUIElements() {
    let output = vscode.window.createOutputChannel("Test Kitchen");
    kernel.bind<vscode.OutputChannel>("KitchenOutput").toConstantValue(output);

    let statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
    statusBarItem.command = "kitchen.terminateProcess";
    kernel.bind<vscode.StatusBarItem>("KitchenStatusBarItem").toConstantValue(statusBarItem);
}

function get_i18n(lang_id: string) {
	const [ lang, region ] = lang_id.split('_')
	let defaults: IIntl[] = []
	if (region)
		defaults = defaults.concat(kernel.getAllTagged<IIntl>('intl', 'lang', lang_id))
	defaults = defaults.concat(kernel.getAllTagged<IIntl>('intl', 'lang', lang))
	return Object.assign.apply(undefined, [ {} ] .concat(defaults))
}

server.setConfig((app) => {

    app.use(bodyParser.urlencoded({ extended: true }));
    app.use(bodyParser.json());
    app.use(morgan('combined'));
    app.use(cors({
        origin: (origin, callback) => {
            try {
                let ok: boolean = config.originsWhitelist.indexOf(origin) !== -1
                callback(null, ok);
            } catch (e) {
                callback(e, null);
            }

        }
    }));
    app.use(jwt({ secret: config.appSecret })
        .unless({
            path: ['/api/account/login', '/setup', '/',
                {
                    url: '/api/donors',
                    methods: ['GET', 'POST']
                }]
        }));

   let feed: DonorsFeed = kernel.get<DonorsFeed>(TYPES.DonorsFeed);
   feed.start(httpServer);
});

export function expressMvc(...controllers: any[]): ExpressMvc {
    debug("Starting ExpressMVC");
    // Handle registering Controllers
    controllers.forEach(controller => {
        debug(`Binding controller (${controller.name})`);
        kernel.bind<mvcController>(controller).to(controller);
        debug(`Bound controller (${controller.name})`);
    });
    debug('Finished binding controllers...');
    return kernel.get<ExpressMvc>(ExpressMvc);
}

 @Get('/', 
     kernel.get<express.RequestHandler>('CustomMiddleware'),
     kernel.get<express.RequestHandler>('Morgan'))
 getUserName(req: any, res: any) {
     res.send(req.user.username);
 }