describe("Calendars", () => {

  // bootstrap your expressApplication in first
  before(TestContext.bootstrap(Server));
  before(TestContext.inject([ExpressApplication], (expressApplication: ExpressApplication) => {
    this.app = expressApplication;
  }));
  after(TestContext.reset);

  // then run your test
  describe("GET /rest/calendars", () => {
    it("should return all calendars", (done) => {
      SuperTest(this.app)
        .get("/rest/calendars")
        .expect(200)
        .end((err, response: any) => {
          if (err) {
            throw (err);
          }

          let obj = JSON.parse(response.text);

          expect(obj).to.be.an("array");

          done();
        });

    });
  });

});

describe("Upload", () => {

  // bootstrap the express application
  before(TestContext.bootstrap(Server));
  before(TestContext.inject([ExpressApplication], (expressApplication: ExpressApplication) => {
    this.app = expressApplication;
  }));
  after(TestContext.reset);

  describe("PUT /rest/upload", () => { // work if you enable the MultipartFileMiddlewareOverrided ;)
    it("should return 400", (done) => {
      SuperTest(this.app)
        .put("/rest/upload")
        .attach("file", Path.join(__dirname, "/test.txt"))
        .expect(400)
        .end((err, res: any) => {
          if (err) {
            throw (err);
          }

          expect(res.text).to.eq("This should be thrown and seen on the test failure.");

          done();
        });
    });
  });
});

      it("should call attach method", inject([ServerSettingsService], async (serverSettingsService: ServerSettingsService) => {
        // GIVEN
        const socketIOServer = {attach: Sinon.stub(), adapter: Sinon.stub()};
        const httpServer = {type: "http", get: Sinon.stub().returns("httpServer")};
        const httpsServer = {type: "https", get: Sinon.stub().returns("httpsServer")};
        const socketIOService = {addSocketProvider: Sinon.stub()};

        serverSettingsService.set("socketIO", {config: "config"});
        serverSettingsService.set("http", false);

        const socketIOModule = TestContext.invoke(SocketIOModule, [
          {provide: HttpServer, use: httpServer},
          {provide: HttpsServer, use: httpsServer},
          {provide: SocketIOServer, use: socketIOServer},
          {provide: SocketIOService, use: socketIOService}
        ]);

        this.getWebsocketServicesStub.returns([{provider: "provider"}]);
        // WHEN
        await socketIOModule.$onServerReady();

        socketIOServer.attach.should.have.been.calledWithExactly(httpsServer, {
          config: "config"
        });

        this.getWebsocketServicesStub.should.have.been.calledWithExactly();
        socketIOService.addSocketProvider.should.have.been.calledWithExactly({provider: "provider"});
      }));

 after(() => {
   TestContext.reset();
   sandbox.restore();
 });

 after(() => {
   TestContext.reset();
   this.getWebsocketServicesStub.restore();
   this.printSocketEventsStub.restore();
 });

 after(() => {
   TestContext.reset();
   this.connectStub.restore();
 });

 inject([ServerSettingsService], (settings: ServerSettingsService) => {
   settings.set("typeorm", {});
   this.createConnectionStub.restore();
   TestContext.reset();
 })