@adaptivestone/framework 4.4.0 → 4.6.0

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

@@ -1,6 +1,27 @@
-const RateLimiter = require('./RateLimiter');
+import { setTimeout } from 'node:timers/promises';
+import crypto from 'node:crypto';
+import { beforeAll, afterAll, describe, it, expect } from 'vitest';
+
+import RateLimiter from './RateLimiter';
+
+let mongoRateLimiter;
 
 describe('rate limiter methods', () => {
+  beforeAll(async () => {
+    await setTimeout(20);
+
+    mongoRateLimiter = new RateLimiter(global.server.app, {
+      driver: 'mongo',
+      limiterOptions: {
+        keyPrefix: `mongo_${Date.now()}_${crypto.randomUUID()}}`,
+      },
+    });
+  });
+
+  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 +68,166 @@ 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 req = {
+      appInfo: {},
+    };
+    let status;
+    let isSend;
+    await rateLimiter.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        send() {
+          isSend = true;
+        },
+      },
+      () => {},
+    );
+    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/services/http/middleware/RequestParser.test.js

@@ -1,7 +1,10 @@
-const { createServer } = require('node:http');
-const formidable = require('formidable');
+import { createServer } from 'node:http';
+import { describe, it, expect } from 'vitest';
+
+import RequestParser from './RequestParser';
 
-const RequestParser = require('./RequestParser');
+// TODO change on ESM
+const formidable = require('formidable');
 
 describe('reqest parser limiter methods', () => {
   it('have description fields', async () => {
@@ -24,7 +27,7 @@ describe('reqest parser limiter methods', () => {
           expect(req.body.multipleFiles).toBeDefined();
           expect(
             req.body.multipleFiles[0] instanceof formidable.PersistentFile,
-          ).toBe(true);
+          ).toBeTruthy();
 
           res.writeHead(200);
           res.end('ok');

package/services/validate/ValidateService.test.js

@@ -1,3 +1,5 @@
+import { describe, it, expect } from 'vitest';
+
 const yup = require('yup');
 const ValidateService = require('./ValidateService');
 const YupValidator = require('./drivers/YupValidator');

package/tests/setup.js

@@ -1,5 +1,5 @@
+/* eslint-disable no-undef */
 const path = require('node:path');
-/* eslint-disable jest/require-top-level-describe */
 const { MongoMemoryReplSet } = require('mongodb-memory-server');
 const mongoose = require('mongoose');
 
@@ -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';

package/tests/setupVitest.js

@@ -0,0 +1,119 @@
+import path from 'node:path';
+import { beforeAll, beforeEach, afterEach, afterAll } from 'vitest';
+
+const { MongoMemoryReplSet } = require('mongodb-memory-server');
+
+const mongoose = require('mongoose');
+
+let mongoMemoryServerInstance;
+
+const redis = require('redis');
+const Server = require('../server');
+
+const clearRedisNamespace = require('../helpers/redis/clearNamespace');
+
+// eslint-disable-next-line vitest/no-hooks, vitest/require-top-level-describe
+beforeAll(async () => {
+  mongoMemoryServerInstance = await MongoMemoryReplSet.create({
+    // binary: { version: '4.4.6' },
+    replSet: { count: 1, storageEngine: 'wiredTiger' },
+  });
+  await mongoMemoryServerInstance.waitUntilRunning();
+  process.env.LOGGER_CONSOLE_LEVEL = 'error';
+  const connectionStringMongo = await mongoMemoryServerInstance.getUri();
+  // console.info('MONGO_URI: ', connectionStringMongo);
+  global.server = new Server({
+    folders: {
+      config: process.env.TEST_FOLDER_CONFIG || path.resolve('./config'),
+      controllers:
+        process.env.TEST_FOLDER_CONTROLLERS || path.resolve('./controllers'),
+      views: process.env.TEST_FOLDER_VIEWS || path.resolve('./views'),
+      public: process.env.TEST_FOLDER_PUBLIC || path.resolve('./public'),
+      models: process.env.TEST_FOLDER_MODELS || path.resolve('./models'),
+      emails:
+        process.env.TEST_FOLDER_EMAIL ||
+        process.env.TEST_FOLDER_EMAILS ||
+        path.resolve('./services/messaging/email/templates'),
+      locales: process.env.TEST_FOLDER_LOCALES || path.resolve('./locales'),
+      commands: process.env.TEST_FOLDER_COMMANDS || path.resolve('./commands'),
+      migrations:
+        process.env.TEST_FOLDER_MIGRATIONS || path.resolve('./migrations'),
+    },
+  });
+  global.server.updateConfig('mongo', {
+    connectionString: connectionStringMongo,
+  });
+  global.server.updateConfig('http', { port: 0 }); // allow to use random
+  global.server.updateConfig('mail', { transport: 'stub' });
+  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({
+      email: 'test@test.com',
+      password: 'testPassword',
+      isVerified: true,
+      name: {
+        nick: 'testUserNickName',
+      },
+    }).catch((e) => {
+      // eslint-disable-next-line no-console
+      console.error(e);
+      // eslint-disable-next-line no-console
+      console.info(
+        'That error can happens in case you have custom user model. Please use global.testSetup.disableUserCreate flag to skip user creating',
+      );
+    });
+    global.authToken = await global.user.generateToken();
+  }
+  if (typeof global.testSetup.beforeAll === 'function') {
+    await global.testSetup.beforeAll();
+  }
+  await global.server.startServer();
+});
+
+// eslint-disable-next-line vitest/no-hooks, vitest/require-top-level-describe
+beforeEach(() => {
+  if (global.server) {
+    const key = `test-${Math.random().toString(36).substring(7)}`;
+    global.server.app.updateConfig('redis', {
+      namespace: key,
+    });
+  }
+});
+
+// eslint-disable-next-line vitest/no-hooks, vitest/require-top-level-describe
+afterEach(async () => {
+  if (global.server) {
+    const { url, namespace } = global.server.getConfig('redis');
+    const redisClient = redis.createClient({ url });
+
+    try {
+      await redisClient.connect();
+      await clearRedisNamespace(redisClient, namespace);
+      await redisClient.disconnect();
+    } catch (err) {
+      // that ok. No redis connection
+    }
+  }
+});
+
+// eslint-disable-next-line vitest/no-hooks, vitest/require-top-level-describe
+afterAll(async () => {
+  if (global.server) {
+    global.server.app.httpServer.shutdown();
+    global.server.app.events.emit('shutdown');
+  }
+  // setTimeout(async () => {
+  if (typeof global.testSetup.afterAll === 'function') {
+    await global.testSetup.afterAll();
+  }
+
+  await mongoose.disconnect();
+  await mongoMemoryServerInstance.stop();
+
+  // }, 2000);
+});

package/vitest.config.js

@@ -0,0 +1,9 @@
+// eslint-disable-next-line import/no-unresolved
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    setupFiles: './tests/setupVitest.js',
+    testTimeout: 10000,
+  },
+});