@adaptivestone/framework 4.3.1 → 4.5.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+### 4.5.0
+
+[NEW] Now getSuper() available as a method on monsgoose models
+[UPDATE] Update rate-limiter-flexible to v3
+[UPDATE] Update test runner to suport ESM. In case problem with test please copy babel.config.js from framework to your project directory
+
+### 4.4.0
+
+[NEW] New method to grab url of server it testing enviroument global.server.testingGetUrl("/some/endpoint")
+
 ### 4.3.1
 
 [UPDATE] Yup file validator update. As formidable now return all fields as an array

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: [['@babel/preset-env', { targets: { node: 'current' } }]],
+};

package/controllers/Auth.test.js

@@ -1,5 +1,3 @@
-const request = require('supertest');
-
 const userEmail = 'testing@test.com';
 const userPassword = 'SuperNiceSecret123$';
 
@@ -9,85 +7,136 @@ describe('auth', () => {
   describe('registration', () => {
     it('code NOT able to create user with wrong email', async () => {
       expect.assertions(1);
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/register')
-        .send({
-          email: 'bad email',
-          password: userPassword,
-          nickName: 'test',
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/register'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: 'bad email',
+            password: userPassword,
+            nickName: 'test',
+          }),
+        },
+      ).catch(() => {});
+
       expect(status).toBe(400);
     });
 
     it('can create user', async () => {
       expect.assertions(1);
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/register')
-        .send({
-          email: userEmail,
-          password: userPassword,
-          nickName: 'test',
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/register'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: userEmail,
+            password: userPassword,
+            nickName: 'test',
+          }),
+        },
+      );
       expect(status).toBe(201);
     });
 
     it('can  not create user with the same nickname', async () => {
       expect.assertions(1);
-      await request(global.server.app.httpServer.express)
-        .post('/auth/register')
-        .send({
+      await fetch(global.server.testingGetUrl('/auth/register'), {
+        method: 'POST',
+        headers: {
+          'Content-type': 'application/json',
+        },
+        body: JSON.stringify({
           email: userEmail,
           password: userPassword,
           nickName: 'test',
-        });
+        }),
+      });
+
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/register'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: userEmail2,
+            password: '123',
+            nickName: 'test',
+          }),
+        },
+      ).catch(() => {});
 
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/register')
-        .send({
-          email: userEmail2,
-          password: '123',
-          nickName: 'test',
-        });
       expect(status).toBe(400);
     });
 
     it('can NOT create SAME user', async () => {
       expect.assertions(1);
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/register')
-        .send({
-          email: userEmail,
-          password: userPassword,
-          nickName: 'test',
-        });
+
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/register'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: userEmail,
+            password: userPassword,
+            nickName: 'test',
+          }),
+        },
+      );
+
       expect(status).toBe(400);
     });
   });
 
   describe('login', () => {
-    it('can NOT login with normal creds and not Verifyed email', async () => {
+    it('can NOT login with normal creds and not verified email', async () => {
       expect.assertions(1);
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/login')
-        .send({
-          email: userEmail,
-          password: userPassword,
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/login'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: userEmail,
+            password: userPassword,
+          }),
+        },
+      ).catch(() => {});
+
       expect(status).toBe(400);
     });
 
     it('can NOT login with WRONG creds', async () => {
       expect.assertions(1);
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/login')
-        .send({
-          email: 'test@test.by',
-          password: 'noPassword$',
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/login'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: 'test@test.by',
+            password: 'noPassword$',
+          }),
+        },
+      ).catch(() => {});
       expect(status).toBe(400);
     });
 
-    it('can login with normal creds and verifyed email', async () => {
+    it('can login with normal creds and verified email', async () => {
       expect.assertions(2);
 
       const user = await global.server.app
@@ -96,16 +145,21 @@ describe('auth', () => {
       user.isVerified = true;
       await user.save();
 
-      const { status, body } = await request(
-        global.server.app.httpServer.express,
-      )
-        .post('/auth/login')
-        .send({
+      const response = await fetch(global.server.testingGetUrl('/auth/login'), {
+        method: 'POST',
+        headers: {
+          'Content-type': 'application/json',
+        },
+        body: JSON.stringify({
           email: userEmail,
           password: userPassword,
-        });
-      expect(status).toBe(200);
-      expect(body.token).toBeDefined();
+        }),
+      });
+
+      const responseBody = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(responseBody.token).toBeDefined();
     });
   });
 
@@ -126,9 +180,14 @@ describe('auth', () => {
 
       await user.save();
 
-      const { status } = await request(
-        global.server.app.httpServer.express,
-      ).post(`/auth/verify?verification_token=testToken`);
+      const { status } = await fetch(
+        `${global.server.testingGetUrl(
+          '/auth/verify',
+        )}?verification_token=testToken`,
+        {
+          method: 'POST',
+        },
+      );
 
       const { isVerified } = await global.server.app.getModel('User').findOne({
         email: 'Test@gmail.com',
@@ -154,9 +213,14 @@ describe('auth', () => {
 
       await user.save();
 
-      const { status } = await request(
-        global.server.app.httpServer.express,
-      ).post(`/auth/verify?verification_token=testToken123wrong`);
+      const { status } = await fetch(
+        `${global.server.testingGetUrl(
+          '/auth/verify',
+        )}?verification_token=testToken123wrong`,
+        {
+          method: 'POST',
+        },
+      );
 
       const { isVerified } = await global.server.app.getModel('User').findOne({
         email: 'Test423@gmail.com',
@@ -168,21 +232,37 @@ describe('auth', () => {
 
     it('can NOT send recovery to not exist email', async () => {
       expect.assertions(1);
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/send-recovery-email')
-        .send({
-          email: 'notExists@gmail.com',
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/send-recovery-email'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: 'notExists@gmail.com',
+          }),
+        },
+      );
+
       expect(status).toBe(400);
     });
 
     it('can send recovery to exist email', async () => {
       expect.assertions(1);
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/send-recovery-email')
-        .send({
-          email: userEmail,
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/send-recovery-email'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: userEmail,
+          }),
+        },
+      );
+
       expect(status).toBe(200);
     });
 
@@ -203,12 +283,19 @@ describe('auth', () => {
 
       await user.save();
 
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/recover-password')
-        .send({
-          password: 'newPass',
-          passwordRecoveryToken: 'superPassword',
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/recover-password'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            password: 'newPass',
+            passwordRecoveryToken: 'superPassword',
+          }),
+        },
+      );
 
       expect(status).toBe(200);
     });
@@ -230,94 +317,133 @@ describe('auth', () => {
 
       await user.save();
 
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/recover-password')
-        .send({
-          password: 'newPass',
-          passwordRecoveryToken: '13123',
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/recover-password'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            password: 'newPass',
+            passwordRecoveryToken: '13123',
+          }),
+        },
+      );
 
       expect(status).toBe(400);
     });
 
-    it('can login with normal creds and  NOT verifyed email is option isAuthWithVefificationFlow is set', async () => {
+    it('can login with normal creds and NOT verifyed email if option isAuthWithVefificationFlow is set', async () => {
       expect.assertions(4);
 
-      const { status } = await request(global.server.app.httpServer.express)
-        .post('/auth/register')
-        .send({
-          email: userEmail2,
-          password: userPassword,
-        });
-
-      const { status: status2 } = await request(
-        global.server.app.httpServer.express,
-      )
-        .post('/auth/login')
-        .send({
-          email: userEmail2,
-          password: userPassword,
-        });
+      const { status } = await fetch(
+        global.server.testingGetUrl('/auth/register'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: userEmail2,
+            password: userPassword,
+          }),
+        },
+      );
+
+      const { status: status2 } = await fetch(
+        global.server.testingGetUrl('/auth/login'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: userEmail2,
+            password: userPassword,
+          }),
+        },
+      );
 
       global.server.app.updateConfig('auth', {
         isAuthWithVefificationFlow: false,
       });
 
-      const { status: status3, body } = await request(
-        global.server.app.httpServer.express,
-      )
-        .post('/auth/login')
-        .send({
-          email: userEmail2,
-          password: userPassword,
-        });
+      const response3 = await fetch(
+        global.server.testingGetUrl('/auth/login'),
+        {
+          method: 'POST',
+          headers: {
+            'Content-type': 'application/json',
+          },
+          body: JSON.stringify({
+            email: userEmail2,
+            password: userPassword,
+          }),
+        },
+      );
+
+      const responseBody3 = await response3.json();
 
       expect(status).toBe(201);
       expect(status2).toBe(400);
-      expect(status3).toBe(200);
-      expect(body.token).toBeDefined();
+      expect(response3.status).toBe(200);
+      expect(responseBody3.token).toBeDefined();
     });
   });
 
   it('can user send verification', async () => {
     expect.assertions(1);
 
-    const { status } = await request(global.server.app.httpServer.express)
-      .post('/auth/send-verification')
-      .send({
-        email: userEmail2,
-      });
+    const { status } = await fetch(
+      global.server.testingGetUrl('/auth/send-verification'),
+      {
+        method: 'POST',
+        headers: {
+          'Content-type': 'application/json',
+        },
+        body: JSON.stringify({
+          email: userEmail2,
+        }),
+      },
+    );
+
     expect(status).toBe(200);
   });
 
   it('can not user send verification to wrong email', async () => {
     expect.assertions(1);
 
-    const { status } = await request(global.server.app.httpServer.express)
-      .post('/auth/send-verification')
-      .send({
-        email: 'wrong@gmail.com',
-      });
+    const { status } = await fetch(
+      global.server.testingGetUrl('/auth/send-verification'),
+      {
+        method: 'POST',
+        headers: {
+          'Content-type': 'application/json',
+        },
+        body: JSON.stringify({
+          email: 'wrong@gmail.com',
+        }),
+      },
+    );
+
     expect(status).toBe(400);
   });
 
   describe('rate limiter', () => {
-    it('we  should receive 429 on rate limit exceeded', async () => {
+    it('should receive 429 on rate limit exceeded', async () => {
       expect.assertions(1);
-      const resultsPromise = [];
 
-      for (let i = 0; i < 11; i += 1) {
-        resultsPromise.push(
-          request(global.server.app.httpServer.express)
-            .post('/auth/logout')
-            .send({}),
-        );
-      }
+      const requests = Array.from({ length: 11 }, () =>
+        fetch(global.server.testingGetUrl('/auth/logout'), {
+          method: 'POST',
+        }),
+      );
 
-      const results = await Promise.all(resultsPromise);
-      const statuses = results.map((res) => res.status);
+      const responses = await Promise.all(requests);
+      const statusCodes = responses.map((response) => response.status);
 
-      expect(statuses.indexOf(429)).not.toBe(-1);
+      expect(statusCodes).toContain(429);
     });
   });
 });

package/controllers/Home.test.js

@@ -1,11 +1,10 @@
-const request = require('supertest');
-
 describe('home', () => {
   it('can open home have', async () => {
     expect.assertions(1);
-    const { status } = await request(global.server.app.httpServer.express).get(
-      '/',
+    const { status } = await fetch(global.server.testingGetUrl('/')).catch(
+      () => {},
     );
+
     expect(status).toBe(200);
   });
 });

package/controllers/index.js

@@ -28,26 +28,29 @@ class ControllerManager extends Base {
       }
       return 0;
     });
-    // const controllers = [];
+    const controllers = [];
     for (const controller of controllersToLoad) {
       // TODO wait until https://github.com/nodejs/node/issues/35889
-      // controllers.push(
-      // import(controller.path).then(({ default: ControllerModule }) => {
-      // eslint-disable-next-line import/no-dynamic-require, global-require
-      const ControllerModule = require(controller.path);
-      const contollerName = ControllerModule.name.toLowerCase();
-      let prefix = path.dirname(controller.file);
-      if (prefix === '.') {
-        prefix = '';
-      }
-      const controllePath = prefix
-        ? `${prefix}/${contollerName}`
-        : contollerName;
-      this.controllers[controllePath] = new ControllerModule(this.app, prefix);
-      // }),
-      // );
+      controllers.push(
+        import(controller.path).then(({ default: ControllerModule }) => {
+          // eslint-disable-next-line import/no-dynamic-require, global-require
+          // const ControllerModule = require(controller.path);
+          const contollerName = ControllerModule.name.toLowerCase();
+          let prefix = path.dirname(controller.file);
+          if (prefix === '.') {
+            prefix = '';
+          }
+          const controllePath = prefix
+            ? `${prefix}/${contollerName}`
+            : contollerName;
+          this.controllers[controllePath] = new ControllerModule(
+            this.app,
+            prefix,
+          );
+        }),
+      );
     }
-    // await Promise.all(controllers);
+    await Promise.all(controllers);
   }
 
   static get loggerGroup() {

package/models/User.js

@@ -88,8 +88,8 @@ class User extends AbstractModel {
     const scryptAsync = promisify(scrypt);
     const data = await scryptAsync(
       this.email + Date.now(),
-      this.constructor.getSuper().saltSecret,
-      this.constructor.getSuper().hashRounds,
+      this.getSuper().saltSecret,
+      this.getSuper().hashRounds,
     );
     const token = data.toString('base64url');
     this.sessionTokens.push({ token, valid: timestamp });
@@ -138,8 +138,8 @@ class User extends AbstractModel {
     const scryptAsync = promisify(scrypt);
     const data = await scryptAsync(
       userMongoose.email + Date.now(),
-      userMongoose.constructor.getSuper().saltSecret,
-      userMongoose.constructor.getSuper().hashRounds,
+      userMongoose.getSuper().saltSecret,
+      userMongoose.getSuper().hashRounds,
     );
     const token = data.toString('base64url');
     //       if (err) {
@@ -177,7 +177,7 @@ class User extends AbstractModel {
     const passwordRecoveryToken =
       await User.generateUserPasswordRecoveryToken(this);
     const mail = new Mailer(
-      this.constructor.getSuper().app,
+      this.getSuper().app,
       'recovery',
       {
         link: `${i18n.language}/auth/recovery?password_recovery_token=${passwordRecoveryToken.token}`,
@@ -194,8 +194,8 @@ class User extends AbstractModel {
     const scryptAsync = promisify(scrypt);
     const data = await scryptAsync(
       userMongoose.email + Date.now(),
-      userMongoose.constructor.getSuper().saltSecret,
-      userMongoose.constructor.getSuper().hashRounds,
+      userMongoose.getSuper().saltSecret,
+      userMongoose.getSuper().hashRounds,
     );
     const token = data.toString('base64url');
     // if (err) {
@@ -243,7 +243,7 @@ class User extends AbstractModel {
   async sendVerificationEmail(i18n) {
     const verificationToken = await User.generateUserVerificationToken(this);
     const mail = new Mailer(
-      this.constructor.getSuper().app,
+      this.getSuper().app,
       'verification',
       {
         link: `${i18n.language}/auth/login?verification_token=${verificationToken.token}`,

package/modules/AbstractModel.js

@@ -14,6 +14,7 @@ class AbstractModel extends Base {
     this.mongooseSchema.set('minimize', false);
     this.mongooseSchema.loadClass(this.constructor);
     this.mongooseSchema.statics.getSuper = () => this;
+    this.mongooseSchema.methods.getSuper = () => this;
     this.initHooks();
     this.mongooseModel = mongoose.model(
       this.constructor.name,

package/modules/BaseCli.js

@@ -48,10 +48,10 @@ class Cli extends Base {
       return false;
     }
     // TODO wait until https://github.com/nodejs/node/issues/35889
-    // const { default: Command } = await import(this.commands[command]);
+    const { default: Command } = await import(this.commands[command]);
 
     // eslint-disable-next-line import/no-dynamic-require, global-require
-    const Command = require(this.commands[command]);
+    // const Command = require(this.commands[command]);
 
     const c = new Command(this.app, this.commands, args);
     let result = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptivestone/framework",
-  "version": "4.3.1",
+  "version": "4.5.0",
   "description": "Adaptive stone node js framework",
   "main": "index.js",
   "engines": {
@@ -22,7 +22,8 @@
     "prepare": "husky install",
     "cli": "node cliCommand",
     "benchmark": "h2load -n 10000 -c 50 -p 'http/1.1' http://localhost:3300/",
-    "benchmark2": "h2load -n 10000 -c 50  https://localhost:3300/"
+    "benchmark2": "h2load -n 10000 -c 50  https://localhost:3300/",
+    "redis:docker": "docker run --rm  -p 6379:6379 redis"
   },
   "jest": {
     "setupFilesAfterEnv": [
@@ -55,13 +56,14 @@
     "nodemailer-sendmail-transport": "^1.0.2",
     "nodemailer-stub-transport": "^1.1.0",
     "pug": "^3.0.2",
-    "rate-limiter-flexible": "^2.2.4",
+    "rate-limiter-flexible": "^3.0.0",
     "redis": "^4.3.1",
     "winston": "^3.3.3",
     "winston-transport-sentry-node": "^2.0.0",
     "yup": "^1.0.0"
   },
   "devDependencies": {
+    "@babel/preset-env": "^7.22.15",
     "eslint": "^8.0.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^9.0.0",
@@ -71,8 +73,7 @@
     "lint-staged": "^14.0.0",
     "mongodb-memory-server": "^8.0.2",
     "nodemon": "^3.0.1",
-    "prettier": "^3.0.0",
-    "supertest": "^6.1.4"
+    "prettier": "^3.0.0"
   },
   "lint-staged": {
     "**/*.{js,jsx,ts,tsx,json,css,scss,md}": [

package/server.js

@@ -52,17 +52,17 @@ class Server {
    */
   async startServer(callbackBefore404 = async () => Promise.resolve()) {
     // eslint-disable-next-line global-require
-    const HttpServer = require('./services/http/HttpServer');
+    // const HttpServer = require('./services/http/HttpServer');
     // eslint-disable-next-line global-require
-    const ControllerManager = require('./controllers/index');
+    // const ControllerManager = require('./controllers/index');
     // TODO wait until https://github.com/nodejs/node/issues/35889
-    // const [{ default: HttpServer }, { default: ControllerManager }] =
-    //   await Promise.all([
-    //     // eslint-disable-next-line import/extensions
-    //     import('./services/http/HttpServer.js'), // Speed optimisation
-    //     // eslint-disable-next-line import/extensions
-    //     import('./controllers/index.js'), // Speed optimisation
-    //   ]);
+    const [{ default: HttpServer }, { default: ControllerManager }] =
+      await Promise.all([
+        // eslint-disable-next-line import/extensions
+        import('./services/http/HttpServer.js'), // Speed optimisation
+        // eslint-disable-next-line import/extensions
+        import('./controllers/index.js'), // Speed optimisation
+      ]);
 
     this.addErrorHandling();
 

package/services/http/middleware/RateLimiter.js

@@ -16,10 +16,9 @@ class RateLimiter extends AbstractMiddleware {
 
   constructor(app, params) {
     super(app, params);
-    const routeParams = params;
     const limiterOptions = this.app.getConfig('rateLimiter');
 
-    this.finalOptions = merge(limiterOptions, routeParams);
+    this.finalOptions = merge(limiterOptions, params);
     this.limiter = null;
 
     switch (this.finalOptions.driver) {
@@ -32,7 +31,7 @@ class RateLimiter extends AbstractMiddleware {
         break;
 
       case 'mongo':
-        this.limiter = RateLimiterMongo({
+        this.limiter = new RateLimiterMongo({
           storeClient: mongoose.connection,
           ...this.finalOptions.limiterOptions,
         });
@@ -50,7 +49,6 @@ class RateLimiter extends AbstractMiddleware {
     const redisConfig = this.app.getConfig('redis');
     const redisClient = redis.createClient({
       url: redisConfig.url,
-      legacyMode: true,
     });
 
     // TODO: change it
@@ -71,6 +69,7 @@ class RateLimiter extends AbstractMiddleware {
 
     return new RateLimiterRedis({
       storeClient: redisClient,
+      useRedisPackage: true,
       ...this.finalOptions.limiterOptions,
     });
   }
@@ -91,7 +90,7 @@ class RateLimiter extends AbstractMiddleware {
 
     if (request && request.length) {
       request.forEach((val) => {
-        if (req.body[val]) {
+        if (req.body && req.body[val]) {
           key.push(req.body[val]);
         }
         // if (req.appInfo.request && req.appInfo.request[val]) {
@@ -108,6 +107,7 @@ class RateLimiter extends AbstractMiddleware {
       this.logger.info(
         `RateLimmiter not inited correclty! Please check init logs `,
       );
+      return res.status(500).send('');
     }
 
     const { namespace } = this.app.getConfig('redis');
@@ -119,7 +119,6 @@ class RateLimiter extends AbstractMiddleware {
       .catch(() => {
         this.logger.warn(`Too many requests. Consume key: ${consumeKey}`);
       });
-
     if (consumeResult) {
       return next();
     }

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

@@ -1,6 +1,22 @@
+const { setTimeout } = require('node:timers/promises');
 const RateLimiter = require('./RateLimiter');
 
+let mongoRateLimiter;
+
 describe('rate limiter methods', () => {
+  beforeAll(() => {
+    mongoRateLimiter = new RateLimiter(global.server.app, {
+      driver: 'mongo',
+      limiterOptions: {
+        keyPrefix: `mongo_${Date.now()}`,
+      },
+    });
+  });
+
+  afterAll(async () => {
+    // we need to wait because redis mongo ask mongo to create indexes
+    await setTimeout(200);
+  });
   it('have description fields', async () => {
     expect.assertions(1);
     const middleware = new RateLimiter(global.server.app, {
@@ -47,4 +63,167 @@ describe('rate limiter methods', () => {
 
     expect(res).toBe('192.168.0.0__someId');
   });
+
+  it('generateConsumeKey with request works correctly', async () => {
+    expect.assertions(1);
+
+    const redisRateLimiter = new RateLimiter(global.server.app, {
+      driver: 'redis',
+      consumeKeyComponents: {
+        request: ['email'],
+      },
+    });
+
+    const res = await redisRateLimiter.gerenateConsumeKey({
+      ip: '192.168.0.0',
+      body: {
+        email: 'foo@example.com',
+      },
+    });
+
+    expect(res).toBe('192.168.0.0__foo@example.com');
+  });
+
+  it('middleware without driver should fail', async () => {
+    expect.assertions(2);
+    const rateLimiter = new RateLimiter(global.server.app, {
+      driver: 'unknown',
+    });
+    const nextFunction = jest.fn(() => {});
+    const req = {
+      appInfo: {},
+    };
+    let status;
+    let isSend;
+    await rateLimiter.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        send() {
+          isSend = true;
+        },
+      },
+      nextFunction,
+    );
+    expect(status).toBe(500);
+    expect(isSend).toBe(true);
+  });
+
+  const makeOneRequest = async ({ rateLimiter, driver, request }) => {
+    let realRateLimiter = rateLimiter;
+    if (!realRateLimiter) {
+      realRateLimiter = new RateLimiter(global.server.app, {
+        driver,
+      });
+    }
+    const req = {
+      appInfo: {},
+      ...request,
+    };
+    let status;
+    let isSend = false;
+    let isNextCalled = false;
+    await realRateLimiter.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        send() {
+          isSend = true;
+        },
+      },
+      () => {
+        isNextCalled = true;
+      },
+    );
+    return { status, isSend, isNextCalled };
+  };
+
+  it('middleware should works with a mongo drivers', async () => {
+    expect.assertions(1);
+    const { isNextCalled } = await makeOneRequest({
+      rateLimiter: mongoRateLimiter,
+      request: { ip: '10.10.0.1' },
+    });
+    expect(isNextCalled).toBe(true);
+  });
+
+  it('middleware should works with a memory drivers', async () => {
+    expect.assertions(1);
+    const { isNextCalled } = await makeOneRequest({
+      driver: 'memory',
+      request: { ip: '10.10.0.1' },
+    });
+    expect(isNextCalled).toBe(true);
+  });
+
+  it('middleware should works with a redis drivers', async () => {
+    expect.assertions(1);
+    const { isNextCalled } = await makeOneRequest({
+      driver: 'redis',
+      request: { ip: '10.10.0.1' },
+    });
+    expect(isNextCalled).toBe(true);
+  });
+
+  it('middleware should rate limits for us. mongo driver', async () => {
+    expect.assertions(2);
+
+    const middlewares = Array.from({ length: 20 }, () =>
+      makeOneRequest({ rateLimiter: mongoRateLimiter }),
+    );
+
+    const data = await Promise.all(middlewares);
+
+    const status = data.find((obj) => obj.status === 429);
+    const isSend = data.find((obj) => obj.isSend);
+
+    expect(status.status).toBe(429);
+    expect(isSend.isSend).toBe(true);
+  });
+
+  it('middleware should rate limits for us. memory driver', async () => {
+    expect.assertions(2);
+
+    const rateLimiter = new RateLimiter(global.server.app, {
+      driver: 'memory',
+    });
+
+    const middlewares = Array.from({ length: 20 }, () =>
+      makeOneRequest({ rateLimiter }),
+    );
+
+    const data = await Promise.all(middlewares);
+
+    const status = data.find((obj) => obj.status === 429);
+    const isSend = data.find((obj) => obj.isSend);
+
+    expect(status.status).toBe(429);
+    expect(isSend.isSend).toBe(true);
+  });
+
+  it('middleware should rate limits for us. redis driver', async () => {
+    expect.assertions(2);
+
+    const rateLimiter = new RateLimiter(global.server.app, {
+      driver: 'redis',
+    });
+
+    const middlewares = Array.from({ length: 20 }, () =>
+      makeOneRequest({ rateLimiter }),
+    );
+
+    const data = await Promise.all(middlewares);
+
+    const status = data.find((obj) => obj.status === 429);
+    const isSend = data.find((obj) => obj.isSend);
+
+    expect(status.status).toBe(429);
+    expect(isSend.isSend).toBe(true);
+  });
 });

package/tests/setup.js

@@ -14,7 +14,7 @@ jest.setTimeout(1000000);
 beforeAll(async () => {
   mongoMemoryServerInstance = await MongoMemoryReplSet.create({
     // binary: { version: '4.4.6' },
-    replSet: { storageEngine: 'wiredTiger' },
+    replSet: { count: 1, storageEngine: 'wiredTiger' },
   });
   await mongoMemoryServerInstance.waitUntilRunning();
   process.env.LOGGER_CONSOLE_LEVEL = 'error';
@@ -46,6 +46,8 @@ beforeAll(async () => {
   if (!global.testSetup) {
     global.testSetup = {};
   }
+  global.server.testingGetUrl = (urlPart) =>
+    `http://127.0.0.1:${global.server.getConfig('http').port}${urlPart}`;
   if (!global.testSetup.disableUserCreate) {
     const User = global.server.app.getModel('User');
     global.user = await User.create({