@adaptivestone/framework 4.6.0 → 4.8.0

package/services/cache/Cache.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { setTimeout } from 'node:timers/promises';
+
+describe('cache', () => {
+  const time = Date.now();
+
+  it('can get set values', async () => {
+    expect.assertions(2);
+
+    const { cache } = global.server.app;
+
+    const res = await cache.getSetValue('TEST_TIME', () => time);
+    expect(res).toStrictEqual(time);
+
+    const res2 = await cache.getSetValue('TEST_TIME', () => '123');
+    expect(res2).toStrictEqual(time);
+  });
+
+  it('can delete values', async () => {
+    expect.assertions(1);
+    const { cache } = global.server.app;
+
+    await cache.removeKey('TEST_TIME');
+
+    const res2 = await cache.getSetValue('TEST_TIME', () => '123');
+    expect(res2).toBe('123');
+  });
+
+  it('can works with big int', async () => {
+    expect.assertions(2);
+    const { cache } = global.server.app;
+
+    const res = await cache.getSetValue('BIN_INT', () => 1n);
+    expect(res).toBe(1n);
+
+    const res2 = await cache.getSetValue('BIN_INT', () => '1111');
+    expect(res2).toBe(1n);
+  });
+
+  it('can execute only one request per time', async () => {
+    expect.assertions(3);
+    const { cache } = global.server.app;
+    let counter = 0;
+
+    const f = async () => {
+      await setTimeout(10);
+      counter += 1;
+      return 1;
+    };
+
+    const [res, res1] = await Promise.all([
+      cache.getSetValue('T', f),
+      cache.getSetValue('T', f),
+    ]);
+
+    expect(counter).toBe(1);
+
+    expect(res).toBe(1);
+    expect(res1).toBe(1);
+  });
+
+  it('can handle problems on onNotFound', async () => {
+    expect.assertions(1);
+    const getAsyncThrow = async () => {
+      throw new Error('err');
+    };
+    let err;
+
+    const { cache } = global.server.app;
+
+    try {
+      await Promise.all([
+        cache.getSetValue('THROW', getAsyncThrow),
+        cache.getSetValue('THROW', getAsyncThrow),
+      ]);
+    } catch (e) {
+      err = e;
+    }
+    expect(err.message).toBe('err');
+  });
+});

package/services/documentation/DocumentationGenerator.js

@@ -2,7 +2,8 @@ const Base = require('../../modules/Base');
 const ValidateService = require('../validate/ValidateService');
 
 class DocumentationGenerator extends Base {
-  static processingFields(fieldsByRoute) {
+  // eslint-disable-next-line class-methods-use-this
+  processingFields(fieldsByRoute) {
     const fields = [];
     if (!fieldsByRoute) {
       return fields;
@@ -36,7 +37,8 @@ class DocumentationGenerator extends Base {
     return fields;
   }
 
-  static selectUniqueFields(fields) {
+  // eslint-disable-next-line class-methods-use-this
+  selectUniqueFields(fields) {
     return Array.from(
       new Map(fields.map((item) => [item.name, item])).values(),
     ).reduce((uniqueArray, item) => {
@@ -52,7 +54,7 @@ class DocumentationGenerator extends Base {
     }, []);
   }
 
-  static groupFieldsFromSchemas(schemas) {
+  groupFieldsFromSchemas(schemas) {
     const result = [];
     schemas.forEach((schema) => {
       const convertedSchema = new ValidateService(this.app, schema).validator;
@@ -71,7 +73,7 @@ class DocumentationGenerator extends Base {
     return result;
   }
 
-  static convertDataToDocumentationElement(
+  convertDataToDocumentationElement(
     controllerName,
     routesInfo,
     middlewaresInfo,
@@ -80,23 +82,19 @@ class DocumentationGenerator extends Base {
     return {
       contollerName: controllerName,
       routesInfo: routesInfo.map((route) => {
-        const middlewareQueryParams = ValidateService.getMiddlewareParams(
-          middlewaresInfo,
-          routeMiddlewaresReg,
-          {
-            method: route.method.toLowerCase(),
-            path: route.fullPath,
-          },
-        ).query;
+        const middlewareQueryParams = new ValidateService(
+          this.app,
+        ).getMiddlewareParams(middlewaresInfo, routeMiddlewaresReg, {
+          method: route.method.toLowerCase(),
+          path: route.fullPath,
+        }).query;
 
-        const middlewareRequestParams = ValidateService.getMiddlewareParams(
-          middlewaresInfo,
-          routeMiddlewaresReg,
-          {
-            method: route.method.toLowerCase(),
-            path: route.fullPath,
-          },
-        ).request;
+        const middlewareRequestParams = new ValidateService(
+          this.app,
+        ).getMiddlewareParams(middlewaresInfo, routeMiddlewaresReg, {
+          method: route.method.toLowerCase(),
+          path: route.fullPath,
+        }).request;
 
         const queryParams = this.groupFieldsFromSchemas(middlewareQueryParams);
 

package/services/http/middleware/Auth.test.js

@@ -0,0 +1,57 @@
+import { beforeAll, describe, it, expect } from 'vitest';
+import Auth from './Auth';
+
+describe('atuh middleware methods', () => {
+  let middleware;
+  beforeAll(() => {
+    middleware = new Auth(global.server.app);
+  });
+  it('have description fields', async () => {
+    expect.assertions(1);
+    expect(middleware.constructor.description).toBeDefined();
+  });
+
+  it('middleware pass when user presented', async () => {
+    expect.assertions(1);
+    let isCalled = false;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {
+        user: true,
+      },
+    };
+    await middleware.middleware(req, {}, nextFunction);
+    expect(isCalled).toBeTruthy();
+  });
+
+  it('middleware NOT pass when user NOT presented', async () => {
+    expect.assertions(3);
+    let isCalled = false;
+    let status;
+    let isSend;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {}, // no user
+    };
+    await middleware.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        json() {
+          isSend = true;
+        },
+      },
+      nextFunction,
+    );
+    expect(isCalled).toBeFalsy();
+    expect(status).toBe(401);
+    expect(isSend).toBeTruthy();
+  });
+});

package/services/http/middleware/I18n.test.js

@@ -12,7 +12,7 @@ describe('i18n middleware methods', () => {
   });
 
   it('detectors should works correctly', async () => {
-    expect.assertions(5);
+    expect.assertions(6);
     const request = {
       get: () => 'en',
       query: {
@@ -42,10 +42,13 @@ describe('i18n middleware methods', () => {
     };
     lang = await middleware.detectLang(request);
     expect(lang).toBe('en');
+
+    lang = await middleware.detectLang(request, false);
+    expect(lang).toBe('en-GB');
   });
 
   it('middleware that works', async () => {
-    expect.assertions(4);
+    expect.assertions(6);
     let isCalled = false;
     const nextFunction = () => {
       isCalled = true;
@@ -55,10 +58,19 @@ describe('i18n middleware methods', () => {
       appInfo: {},
     };
     await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBe(true);
+    expect(isCalled).toBeTruthy();
     expect(req.appInfo.i18n).toBeDefined();
+    expect(req.appInfo.i18n.language).toBe('en');
     expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
     expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test
+
+    const req2 = {
+      get: () => 'fakeLang',
+      appInfo: {},
+    };
+
+    await middleware.middleware(req2, {}, nextFunction);
+    expect(req2.appInfo.i18n.language).toBe('en');
   });
 
   it('middleware disabled', async () => {

package/services/http/middleware/PrepareAppInfo.test.js

@@ -17,7 +17,7 @@ describe('prepareAppInfo methods', () => {
     };
     const req = {};
     await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBe(true);
+    expect(isCalled).toBeTruthy();
     expect(req.appInfo).toBeDefined();
     req.appInfo.test = 5;
     await middleware.middleware(req, {}, nextFunction);

package/services/http/middleware/Role.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import Role from './Role';
+
+describe('role middleware methods', () => {
+  it('have description fields', async () => {
+    expect.assertions(1);
+    const middleware = new Role(global.server.app);
+    expect(middleware.constructor.description).toBeDefined();
+  });
+
+  it('middleware pass when user presented with a right role', async () => {
+    expect.assertions(1);
+    let isCalled = false;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {
+        user: {
+          roles: ['role1', 'role2'],
+        },
+      },
+    };
+    const middleware = new Role(global.server.app, {
+      roles: ['admin', 'role1'],
+    });
+
+    await middleware.middleware(req, {}, nextFunction);
+    expect(isCalled).toBeTruthy();
+  });
+
+  it('middleware NOT pass when user NOT presented', async () => {
+    expect.assertions(3);
+    let isCalled = false;
+    let status;
+    let isSend;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {}, // no user
+    };
+    const middleware = new Role(global.server.app);
+    await middleware.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        send() {
+          isSend = true;
+        },
+      },
+      nextFunction,
+    );
+    expect(isCalled).toBeFalsy();
+    expect(status).toBe(401);
+    expect(isSend).toBeTruthy();
+  });
+
+  it('middleware NOT pass when user  have a wrong role', async () => {
+    expect.assertions(3);
+    let isCalled = false;
+    let status;
+    let isSend;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {
+        user: { roles: ['role1', 'role2'] },
+      },
+    };
+    const middleware = new Role(global.server.app, { roles: ['admin'] });
+    await middleware.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        json() {
+          isSend = true;
+        },
+      },
+      nextFunction,
+    );
+    expect(isCalled).toBeFalsy();
+    expect(status).toBe(403);
+    expect(isSend).toBeTruthy();
+  });
+});

package/services/validate/ValidateService.js

@@ -41,7 +41,7 @@ class ValidateService extends Base {
   /**
    * Filter middlewares by route path and select all parameters
    */
-  static filterRelatedParametersByRoute(middlewares, method, path) {
+  filterRelatedParametersByRoute(middlewares, method, path) {
     const middlewaresParams = middlewares
       .filter(
         (middleware) =>
@@ -63,11 +63,7 @@ class ValidateService extends Base {
   /**
    * Group all middleware(routes + controller) parameters
    */
-  static getMiddlewareParams(
-    controllerMiddlewares,
-    AllrouteMiddlewares,
-    options,
-  ) {
+  getMiddlewareParams(controllerMiddlewares, AllrouteMiddlewares, options) {
     const { method, path } = options;
     const routeMiddlewaresParams = this.filterRelatedParametersByRoute(
       AllrouteMiddlewares,
@@ -134,7 +130,7 @@ class ValidateService extends Base {
       this.validator,
       selectedReqData,
     );
-    const additionalMiddlewareSchemas = this.constructor.getMiddlewareParams(
+    const additionalMiddlewareSchemas = this.getMiddlewareParams(
       middlewaresInfo,
       routeMiddlewaresReg,
       routeOptions,

package/tests/setup.js

@@ -38,6 +38,7 @@ beforeAll(async () => {
         process.env.TEST_FOLDER_MIGRATIONS || path.resolve('./migrations'),
     },
   });
+  await global.server.init();
   global.server.updateConfig('mongo', {
     connectionString: connectionStringMongo,
   });

package/tests/setupVitest.js

@@ -40,6 +40,7 @@ beforeAll(async () => {
         process.env.TEST_FOLDER_MIGRATIONS || path.resolve('./migrations'),
     },
   });
+  await global.server.init();
   global.server.updateConfig('mongo', {
     connectionString: connectionStringMongo,
   });