await inject([InjectorService], (injector: InjectorService) => {
      this.locals = new Map<string | Function, any>();
      const provider = injector.getProvider(ProductsCtrl)!;
      const target = provider.useClass;

      this.rebuildHandler = provider.scope !== ProviderScope.SINGLETON;

      this.instance = injector.invoke(target, this.locals, undefined, true);
    })();

    before(inject([InjectorService], (injectorService: InjectorService) => {
      this.memoryStorage = {
        set: () => {
        },
        get: () => {

        }
      };

      const locals = new Map<any, any>();
      locals.set(MemoryStorage, this.memoryStorage);

      this.calendarsService = injectorService.invoke<CalendarsService>(CalendarsService, locals);
    }));

    it("should do something", inject([InjectorService], (injector: InjectorService) => {
      // create locals map
      const locals = new Map<any, any>();

      // replace DbService by a faker
      locals.set(DbService, {
        getData: () => {
          return "test";
        }
      });

      // give the locals map to the invoke method
      const instance: MyCtrl = injector.invoke<MyCtrl>(MyCtrl, locals);

      // and test it
      expect(!!instance).to.be.true;
      expect(instance.getData()).to.equals("test");
    }));

 inject([InjectorService], (injectorService: InjectorService) => {
   instance = injectorService.invoke(CalendarCtrl);
 })

  /**
   *
   * @param target
   * @param scope
   * @param promise
   * @returns {(args: any[]) => Promise<any[]>}
   */
  private bindMiddleware(target: any, scope: any, promise: Promise<any>): Promise<any> {
    const provider = this.injector.getProvider(target);

    if (provider) {
      const instance = provider.instance;
      const handlerMetadata: ISocketProviderMetadata = Store.from(instance).get("socketIO");

      if (handlerMetadata.type === SocketProviderTypes.MIDDLEWARE) {
        if (handlerMetadata.error) {
          return promise.catch((error: any) => this.invoke(instance, handlerMetadata.handlers.use, {error, ...scope}));
        }

        return promise
          .then(() => this.invoke(instance, handlerMetadata.handlers.use, scope))
          .then((result: any) => {
            if (result) {
              scope.args = [].concat(result);
            }
          });
      }
    }

    return promise;
  }