refactor: 💡 Server API tests minor refactoring

Author: kostysh

src/node/db/users.ts

@@ -43,6 +43,12 @@ export interface UsersDbOptions {
   prefix: string;
 }
 
+/**
+ * Class that implements an API to the users records storage
+ *
+ * @export
+ * @class UsersDb
+ */
 export class UsersDb {
   /** Storage instance for persisting the state of the API server */
   storage: Storage;
@@ -54,12 +60,12 @@ export class UsersDb {
    * Initializes an instance of UsersDb with given options.
    *
    * @param {UsersDbOptions} options
-   * @memberof NodeApiServer
+   * @memberof UsersDb
    */
   constructor(options: UsersDbOptions) {
     const { storage, prefix } = options;
 
-    // TODO Validate NodeApiServerOptions
+    // TODO Validate UsersDbOptions
 
     this.prefix = `${prefix}_api_users_`;
     this.storage = storage;
@@ -77,18 +83,6 @@ export class UsersDb {
     return await hash(password, 10);
   }
 
-  /**
-   * Generates a prefixed login key
-   *
-   * @private
-   * @param {string} login The login for which the key is generated
-   * @returns {string} The prefixed login key
-   * @memberof UsersDb
-   */
-  private loginKey(login: string): string {
-    return `${this.prefix}${login}`;
-  }
-
   /**
    * Retrieves the user with the given login from storage.
    *
@@ -98,7 +92,7 @@ export class UsersDb {
    * @memberof UsersDb
    */
   async get(login: string): Promise<User> {
-    const user = await this.storage.get<User>(this.loginKey(login));
+    const user = await this.storage.get<User>(`${this.prefix}${login}`);
 
     if (!user) {
       throw new Error(`User ${login} not found`);
@@ -118,15 +112,15 @@ export class UsersDb {
    * @memberof UsersDb
    */
   async add(login: string, password: string, isAdmin = false): Promise<void> {
-    const knownUser = await this.storage.get<User>(this.loginKey(login));
+    const knownUser = await this.storage.get<User>(`${this.prefix}${login}`);
 
     // Check if the user already exists
     if (knownUser) {
       throw new Error(`User ${login} already exists`);
     }
 
     // Save the user into the storage
-    await this.storage.set<User>(this.loginKey(login), {
+    await this.storage.set<User>(`${this.prefix}${login}`, {
       login,
       hashedPassword: await UsersDb.hashPassword(password),
       isAdmin,
@@ -141,7 +135,7 @@ export class UsersDb {
    * @memberof UsersDb
    */
   async set(user: User): Promise<void> {
-    await this.storage.set<User>(this.loginKey(user.login), user);
+    await this.storage.set<User>(`${this.prefix}${user.login}`, user);
   }
 
   /**
@@ -153,7 +147,7 @@ export class UsersDb {
    * @memberof UsersDb
    */
   async delete(login: string): Promise<void> {
-    const deleted = await this.storage.delete(this.loginKey(login));
+    const deleted = await this.storage.delete(`${this.prefix}${login}`);
 
     if (!deleted) {
       throw new Error(`Unable to delete user ${login}`);

test/node.api.nodeApiServer.spec.ts

@@ -45,7 +45,9 @@ describe('NodeApiServer', () => {
 
   beforeAll(async () => {
     options = {
-      storage: await createInitializer()(),
+      storage: await createInitializer({
+        scope: 'users',
+      })(),
       prefix: 'test',
       port: 3456,
       secret: 'secret',

test/node.db.users.spec.ts

@@ -0,0 +1,109 @@
+import { describe, beforeAll, it, expect } from './setup.js';
+import { createInitializer } from '../src/storage/memory.js';
+import {
+  UsersDb,
+  UsersDbOptions,
+  User,
+  comparePassword,
+} from '../src/node/db/users.js';
+
+describe('Node.API.Db', () => {
+  const password = 'password';
+  let userDb: UsersDb;
+  let testUser: User;
+
+  beforeAll(async () => {
+    const options: UsersDbOptions = {
+      storage: await createInitializer({
+        scope: 'users',
+      })(),
+      prefix: 'test',
+    };
+    userDb = new UsersDb(options);
+    testUser = {
+      login: 'testUser',
+      hashedPassword: await UsersDb.hashPassword('password'),
+    };
+  });
+
+  describe('#add', () => {
+    it('should add a new user', async () => {
+      await userDb.add(testUser.login, password);
+      const user = await userDb.get(testUser.login);
+      expect(user.login).to.be.eq(testUser.login);
+      expect(await comparePassword(password, user.hashedPassword)).to.be.true;
+    });
+
+    it('should throw an error when trying to add an existing user', async () => {
+      let error = null;
+      try {
+        await userDb.add(testUser.login, password);
+      } catch (err) {
+        error = err;
+      }
+      expect(error).to.be.an('Error');
+      expect((error as Error).message).to.be.eq(
+        `User ${testUser.login} already exists`,
+      );
+    });
+  });
+
+  describe('#get', () => {
+    it('should get a user', async () => {
+      const user = await userDb.get(testUser.login);
+      expect(user.login).to.be.eq(testUser.login);
+      expect(await comparePassword(password, user.hashedPassword)).to.be.true;
+    });
+
+    it('should throw an error when trying to get a non-existent user', async () => {
+      let error = null;
+      try {
+        await userDb.get('nonExistentUser');
+      } catch (err) {
+        error = err;
+      }
+      expect(error).to.be.an('Error');
+      expect((error as Error).message).to.be.eq(
+        'User nonExistentUser not found',
+      );
+    });
+  });
+
+  describe('#set', () => {
+    it('should update a user', async () => {
+      const updatedUser = { ...testUser, jwt: 'jwtToken' };
+      await userDb.set(updatedUser);
+      const user = await userDb.get(testUser.login);
+      expect(user).to.deep.equal(updatedUser);
+    });
+  });
+
+  describe('#delete', () => {
+    it('should delete a user', async () => {
+      await userDb.delete(testUser.login);
+      let error = null;
+      try {
+        await userDb.get(testUser.login);
+      } catch (err) {
+        error = err;
+      }
+      expect(error).to.be.an('Error');
+      expect((error as Error).message).to.be.eq(
+        `User ${testUser.login} not found`,
+      );
+    });
+
+    it('should throw an error when trying to delete a non-existent user', async () => {
+      let error = null;
+      try {
+        await userDb.delete('nonExistentUser');
+      } catch (err) {
+        error = err;
+      }
+      expect(error).to.be.an('Error');
+      expect((error as Error).message).to.be.eq(
+        'Unable to delete user nonExistentUser',
+      );
+    });
+  });
+});