fix: save synapse token in memory instead of mongoDB

src/__tests__/acceptance/logbook.controller.acceptance.ts

@@ -1,4 +1,4 @@
-import { Client } from "@loopback/testlab";
+import { Client, expect } from "@loopback/testlab";
 import { ScichatLoopbackApplication } from "../../application";
 import { setupApplication } from "./test-helper";
 
@@ -16,25 +16,31 @@ describe("LogbookController (acceptance)", () => {
 
   context("find", () => {
     it("should resolve in a 401 code with unauthenticated user", async () => {
-      await client.get("/scichatapi/Logbooks").expect(401);
-    });
-  });
-
-  context("create", () => {
-    it("should resolve in a 401 code with unauthenticated user", async () => {
-      await client.post("/scichatapi/Logbooks").expect(401);
+      try {
+        await client.get("/scichatapi/Logbooks");
+      } catch (error) {
+        expect(error.statusCode).equal(401);
+      }
     });
   });
 
   context("findByName", () => {
     it("should resolve in a 401 code with unauthenticated user", async () => {
-      await client.get("/scichatapi/Logbooks/123456").expect(401);
+      try {
+        await client.get("/scichatapi/Logbooks/123456");
+      } catch (error) {
+        expect(error.statusCode).equal(401);
+      }
     });
   });
 
   context("sendMessage", () => {
     it("should resolve in a 401 code with unauthenticated user", async () => {
-      await client.post("/scichatapi/Logbooks/123456/message").expect(401);
+      try {
+        await client.post("/scichatapi/Logbooks/123456/message");
+      } catch (error) {
+        expect(error.statusCode).equal(401);
+      }
     });
   });
 });

src/__tests__/acceptance/test-helper.ts

@@ -4,7 +4,6 @@ import {
   givenHttpServerConfig,
 } from "@loopback/testlab";
 import { ScichatLoopbackApplication } from "../..";
-import { testdbConfig } from "../fixtures/datasources/testdb.datasource";
 
 export async function setupApplication(): Promise<AppWithClient> {
   const restConfig = givenHttpServerConfig({
@@ -21,8 +20,6 @@ export async function setupApplication(): Promise<AppWithClient> {
 
   await app.boot();
 
-  app.bind("datasources.config.mongodb").to(testdbConfig);
-
   await app.start();
 
   const client = createRestAppClient(app);

src/__tests__/acceptance/user.controller.acceptance.ts

@@ -1,10 +1,5 @@
-import { Client, expect } from "@loopback/testlab";
+import { Client } from "@loopback/testlab";
 import { ScichatLoopbackApplication } from "../../application";
-import {
-  givenCredentials,
-  givenEmptyDatabase,
-  givenUserAccount,
-} from "../helpers";
 import { setupApplication } from "./test-helper";
 
 describe("UserController (acceptance)", () => {
@@ -15,9 +10,6 @@ describe("UserController (acceptance)", () => {
     ({ app, client } = await setupApplication());
   });
 
-  before(givenEmptyDatabase);
-  before(givenUserAccount);
-
   after(() => app.stop());
 
   context("login", () => {
@@ -28,15 +20,5 @@ describe("UserController (acceptance)", () => {
         .send(credentials)
         .expect(401);
     });
-
-    it("should resolve in a jwt token when logging in with the correct credentials", async () => {
-      const credentials = givenCredentials();
-      const res = await client
-        .post("/scichatapi/Users/login")
-        .send(credentials)
-        .expect(200);
-
-      expect(res.body).to.have.property("token");
-    });
   });
 });

src/__tests__/helpers.ts

@@ -1,55 +1,5 @@
-import { genSalt, hash } from "bcryptjs";
-import { MongodbDataSource } from "../datasources";
-import { Logbook, SynapseToken, User, UserCredentials } from "../models";
-import { UserCredentialsRepository, UserRepository } from "../repositories";
+import { Logbook, SynapseToken } from "../models";
 import { SynapseSyncResponse } from "../services";
-import { testdbConfig } from "./fixtures/datasources/testdb.datasource";
-
-const testdb = new MongodbDataSource(testdbConfig);
-const userRepository = new UserRepository(
-  testdb,
-  async () => userCredentialsRepository,
-);
-const userCredentialsRepository = new UserCredentialsRepository(testdb);
-
-export async function givenEmptyDatabase() {
-  await userRepository.deleteAll();
-  await userCredentialsRepository.deleteAll();
-}
-
-export function givenUserData(data?: Partial<User>) {
-  return Object.assign(
-    {
-      username: "testUser",
-      email: "[email protected]",
-    },
-    data,
-  );
-}
-
-export async function givenUser(data?: Partial<User>) {
-  return userRepository.create(givenUserData(data));
-}
-
-export async function givenUserCredentialsData(
-  data?: Partial<UserCredentials>,
-) {
-  return Object.assign(
-    {
-      password: await hash("password", await genSalt()),
-    },
-    data,
-  );
-}
-
-export async function givenUserCredentials(data?: Partial<UserCredentials>) {
-  return userCredentialsRepository.create(await givenUserCredentialsData(data));
-}
-
-export async function givenUserAccount() {
-  const user = await givenUser();
-  return givenUserCredentials({ userId: user.id });
-}
 
 export function givenCredentials() {
   return { username: "testUser", password: "password" };

src/__tests__/unit/logbook.controller.unit.ts

@@ -1,16 +1,12 @@
-import {
-  createStubInstance,
-  expect,
-  StubbedInstanceWithSinonAccessor,
-} from "@loopback/testlab";
+import { Context } from "@loopback/context";
+import { expect } from "@loopback/testlab";
 import sinon from "sinon";
 import { LogbookController } from "../../controllers";
-import { SynapseTokenRepository } from "../../repositories";
 import { SynapseService } from "../../services";
+import { TokenServiceManager } from "../../services/token.service";
 import { Utils } from "../../utils";
 import {
   givenAllRoomsSyncResponse,
-  givenCreateRoomResponse,
   givenFetchRoomIdByNameResponse,
   givenFetchRoomMessagesResponse,
   givenGetMessagesWithDisplayNameResponse,
@@ -22,21 +18,19 @@ import {
 describe("LogbookController (unit)", () => {
   let controller: LogbookController;
 
-  let synapseTokenRepositry: StubbedInstanceWithSinonAccessor<SynapseTokenRepository>;
   let synapseService: SynapseService;
+  let tokenServiceManager: TokenServiceManager;
   let utils: Utils;
-  let createRoom: sinon.SinonStub;
   let fetchAllRoomsMessages: sinon.SinonStub;
   let fetchRoomIdByName: sinon.SinonStub;
   let fetchRoomMessages: sinon.SinonStub;
   let getMessagesWithDisplayName: sinon.SinonStub;
   let sendMessage: sinon.SinonStub;
 
-  beforeEach(givenMockSynapseServiceAndRepository);
+  beforeEach(givenMockSynapseServiceAndTokenManager);
 
   context("find", () => {
     it("resolves a list of Logbooks", async () => {
-      synapseTokenRepositry.stubs.findOne.resolves(givenSynapseLoginResponse());
       fetchAllRoomsMessages.resolves(givenAllRoomsSyncResponse());
 
       const expected = givenLogbooks();
@@ -45,22 +39,8 @@ describe("LogbookController (unit)", () => {
     });
   });
 
-  context("create", () => {
-    it("resolves in an object containing the room_alias and room_id", async () => {
-      const details = { name: "098765" };
-      synapseTokenRepositry.stubs.findOne.resolves(givenSynapseLoginResponse());
-      createRoom.resolves(givenCreateRoomResponse(details));
-
-      const expected = givenCreateRoomResponse(details);
-      const actual = await controller.create(details);
-
-      expect(actual).to.eql(expected);
-    });
-  });
-
   context("findByName", () => {
     it("resolves in a Logbook instance matching the input name", async () => {
-      synapseTokenRepositry.stubs.findOne.resolves(givenSynapseLoginResponse());
       fetchRoomIdByName.resolves(givenFetchRoomIdByNameResponse());
       fetchRoomMessages.resolves(givenFetchRoomMessagesResponse());
       getMessagesWithDisplayName.resolves(
@@ -75,7 +55,6 @@ describe("LogbookController (unit)", () => {
   context("sendMessage", () => {
     it("resolves in an object containing the event_id of the sent message", async () => {
       const expected = { event_id: "$ABCDabcd1234" };
-      synapseTokenRepositry.stubs.findOne.resolves(givenSynapseLoginResponse());
       fetchRoomIdByName.resolves(givenFetchRoomIdByNameResponse());
       sendMessage.resolves(expected);
 
@@ -86,29 +65,31 @@ describe("LogbookController (unit)", () => {
     });
   });
 
-  function givenMockSynapseServiceAndRepository() {
+  function givenMockSynapseServiceAndTokenManager() {
     synapseService = {
       login: sinon.stub(),
-      createRoom: sinon.stub(),
       fetchAllRoomsMessages: sinon.stub(),
       fetchRoomIdByName: sinon.stub(),
       fetchRoomMessages: sinon.stub(),
       sendMessage: sinon.stub(),
       queryUser: sinon.stub(),
-      createUser: sinon.stub(),
     };
 
-    createRoom = synapseService.createRoom as sinon.SinonStub;
+    tokenServiceManager = new TokenServiceManager(new Context());
+
     fetchAllRoomsMessages =
       synapseService.fetchAllRoomsMessages as sinon.SinonStub;
     fetchRoomIdByName = synapseService.fetchRoomIdByName as sinon.SinonStub;
     fetchRoomMessages = synapseService.fetchRoomMessages as sinon.SinonStub;
     sendMessage = synapseService.sendMessage as sinon.SinonStub;
 
-    synapseTokenRepositry = createStubInstance(SynapseTokenRepository);
-    utils = new Utils(synapseTokenRepositry, synapseService);
+    tokenServiceManager.getToken = sinon
+      .stub()
+      .returns(givenSynapseLoginResponse().access_token);
+
+    utils = new Utils(tokenServiceManager, synapseService);
     controller = new LogbookController(
-      synapseTokenRepositry,
+      tokenServiceManager,
       synapseService,
       utils,
     );

src/application.ts

@@ -1,6 +1,6 @@
 import { AuthenticationComponent } from "@loopback/authentication";
 import { BootMixin } from "@loopback/boot";
-import { ApplicationConfig } from "@loopback/core";
+import { ApplicationConfig, BindingScope } from "@loopback/core";
 import { RepositoryMixin } from "@loopback/repository";
 import { RestApplication } from "@loopback/rest";
 import {
@@ -9,10 +9,9 @@ import {
 } from "@loopback/rest-explorer";
 import { ServiceMixin } from "@loopback/service-proxy";
 import path from "path";
-import { MongodbDataSource } from "./datasources";
-import { JWTAuthenticationComponent } from "./jwt-authentication-component";
-import { UserServiceBindings, UtilsBindings } from "./keys";
+import { TokenServiceBindings, UtilsBindings } from "./keys";
 import { MySequence } from "./sequence";
+import { TokenServiceManager } from "./services/token.service";
 import { Utils } from "./utils";
 
 export { ApplicationConfig };
@@ -48,11 +47,16 @@ export class ScichatLoopbackApplication extends BootMixin(
 
     // Mount authentication system
     this.component(AuthenticationComponent);
-    // Mount jwt component
-    this.component(JWTAuthenticationComponent);
-    // Bind datasource
-    this.dataSource(MongodbDataSource, UserServiceBindings.DATASOURCE_NAME);
 
     this.bind(UtilsBindings.UTILS).toClass(Utils);
+
+    this.bind(TokenServiceBindings.TOKEN_MANAGER)
+      .toClass(TokenServiceManager)
+      //
+      .inScope(BindingScope.SINGLETON);
+
+    this.bind(TokenServiceBindings.TOKEN_KEY)
+      .to("")
+      .inScope(BindingScope.SINGLETON);
   }
 }