@adaptivestone/framework 5.0.0-alpha.10 → 5.0.0-alpha.12

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

@@ -1,143 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import IpDetector from './IpDetector.js';
-
-const testVectors = [
-  // IPv4 CIDR blocks
-  {
-    cidr: '192.168.0.0/16',
-    tests: [
-      { ip: '192.168.1.1', matches: true },
-      { ip: '192.169.1.1', matches: false },
-    ],
-  },
-  {
-    cidr: '10.0.0.0/8',
-    tests: [
-      { ip: '10.0.0.1', matches: true },
-      { ip: '11.0.0.1', matches: false },
-    ],
-  },
-  {
-    cidr: '172.16.0.0/12',
-    tests: [
-      { ip: '172.16.0.1', matches: true },
-      { ip: '172.32.0.1', matches: false },
-    ],
-  },
-
-  // // IPv6 CIDR blocks
-  {
-    cidr: '2001:db8::/32',
-    tests: [
-      { ip: '2001:db8::1', matches: true },
-      { ip: '2001:db9::1', matches: false },
-    ],
-  },
-  {
-    cidr: 'fe80::/10',
-    tests: [
-      { ip: 'fe80::1', matches: true },
-      { ip: 'fec0::1', matches: false },
-    ],
-  },
-  {
-    cidr: '::ffff:0:0/96',
-    tests: [
-      { ip: '::ffff:192.0.2.1', matches: true },
-      { ip: '2001:db8::1', matches: false },
-    ],
-  },
-
-  // // Specific IPv4 addresses
-  {
-    cidr: '203.0.113.1/32',
-    tests: [
-      { ip: '203.0.113.1', matches: true },
-      { ip: '203.0.113.2', matches: false },
-    ],
-  },
-
-  // // Specific IPv6 addresses
-  {
-    cidr: '2001:db8:85a3::8a2e:370:7334/128',
-    tests: [
-      { ip: '2001:db8:85a3::8a2e:370:7334', matches: true },
-      { ip: '2001:db8:85a3::8a2e:370:7335', matches: false },
-    ],
-  },
-
-  // // Mixed scenarios
-  {
-    cidr: '::ffff:192.0.2.0/120',
-    tests: [
-      { ip: '::ffff:192.0.2.1', matches: true },
-      { ip: '192.0.2.1', matches: true }, // IPv4-mapped addresses should match their IPv4 equivalents
-      { ip: '::ffff:192.0.3.1', matches: false },
-    ],
-  },
-
-  // // Edge cases
-  {
-    cidr: '0.0.0.0/0',
-    tests: [
-      { ip: '0.0.0.0', matches: true },
-      { ip: '255.255.255.255', matches: true },
-      { ip: '2001:db8::1', matches: false }, // Matches any IPv4 but not IPv6
-    ],
-  },
-  {
-    cidr: '::/0',
-    tests: [
-      { ip: '::1', matches: true },
-      { ip: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', matches: true },
-      { ip: '192.168.1.1', matches: true },
-    ],
-  },
-  {
-    cidr: '8.8.8.8-8.8.8.10', // our feature range
-    tests: [
-      { ip: '8.8.8.7', matches: false },
-      { ip: '8.8.8.8', matches: true },
-      { ip: '8.8.8.9', matches: true },
-      { ip: '8.8.8.10', matches: true },
-      { ip: '8.8.8.11', matches: false },
-    ],
-  },
-  {
-    cidr: '1.1.1.1', // one ip
-    tests: [
-      { ip: '8.8.8.7', matches: false },
-      { ip: '1.1.1.1', matches: true },
-    ],
-  },
-];
-
-describe('ipDetector methods', () => {
-  it('have description fields', async () => {
-    expect.assertions(1);
-    const middleware = new IpDetector(global.server.app);
-    expect(middleware.constructor.description).toBeDefined();
-  });
-
-  it('middleware that works', async () => {
-    expect.hasAssertions();
-    const nextFunction = () => {};
-    for (const vector of testVectors) {
-      global.server.app.updateConfig('ipDetector', {
-        trustedProxy: [vector.cidr],
-      });
-      const middleware = new IpDetector(global.server.app);
-      for (const test of vector.tests) {
-        const req = {
-          appInfo: {},
-          headers: { 'x-forwarded-for': 'notAnIP' },
-          socket: { remoteAddress: test.ip },
-        };
-        // eslint-disable-next-line no-await-in-loop
-        await middleware.middleware(req, {}, nextFunction);
-        const result = req.appInfo.ip === 'notAnIP';
-        expect(result).toBe(test.matches);
-      }
-    }
-  });
-});

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

@@ -1,26 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import PrepareAppInfo from './PrepareAppInfo.js';
-
-describe('prepareAppInfo methods', () => {
-  it('have description fields', async () => {
-    expect.assertions(1);
-    const middleware = new PrepareAppInfo(global.server.app);
-    expect(middleware.constructor.description).toBeDefined();
-  });
-
-  it('middleware that works', async () => {
-    expect.assertions(3);
-    const middleware = new PrepareAppInfo(global.server.app);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {};
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-    expect(req.appInfo).toBeDefined();
-    req.appInfo.test = 5;
-    await middleware.middleware(req, {}, nextFunction);
-    expect(req.appInfo.test).toBe(5);
-  });
-});

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

@@ -1,235 +0,0 @@
-import { setTimeout } from 'node:timers/promises';
-import crypto from 'node:crypto';
-import { beforeAll, afterAll, describe, it, expect } from 'vitest';
-
-import RateLimiter from './RateLimiter.js';
-
-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, {
-      driver: 'redis',
-    });
-    expect(middleware.constructor.description).toBeDefined();
-  });
-
-  it('can create redis rateLimiter', async () => {
-    expect.assertions(1);
-
-    const redisRateLimiter = new RateLimiter(global.server.app, {
-      driver: 'redis',
-    });
-
-    expect(redisRateLimiter.limiter).toBeDefined();
-  });
-
-  it('can not create rateLimiter with unknown driver', async () => {
-    expect.assertions(1);
-
-    const rateLimiter = new RateLimiter(global.server.app, {
-      driver: 'unknown',
-    });
-
-    expect(rateLimiter.limiter).toBeNull();
-  });
-
-  it('generateConsumeKey works correctly', async () => {
-    expect.assertions(1);
-
-    const redisRateLimiter = new RateLimiter(global.server.app, {
-      driver: 'redis',
-    });
-
-    const res = await redisRateLimiter.gerenateConsumeKey({
-      appInfo: {
-        ip: '192.168.0.0',
-        user: {
-          id: 'someId',
-        },
-      },
-    });
-
-    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({
-      appInfo: {
-        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;
-        },
-        json() {
-          isSend = true;
-        },
-      },
-      () => {},
-    );
-    expect(status).toBe(500);
-    expect(isSend).toBeTruthy();
-  });
-
-  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;
-        },
-        json() {
-          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).toBeTruthy();
-  });
-
-  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).toBeTruthy();
-  });
-
-  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).toBeTruthy();
-  });
-
-  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).toBeTruthy();
-  });
-
-  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).toBeTruthy();
-  });
-
-  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).toBeTruthy();
-  });
-});

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

@@ -1,121 +0,0 @@
-import { createServer } from 'node:http';
-import { describe, it, expect } from 'vitest';
-import { PersistentFile } from 'formidable';
-
-import RequestParser from './RequestParser.js';
-
-describe('reqest parser limiter methods', () => {
-  it('have description fields', async () => {
-    expect.assertions(1);
-    const middleware = new RequestParser(global.server.app);
-    expect(middleware.constructor.description).toBeDefined();
-  });
-  it('middleware that works', async () => {
-    expect.assertions(4);
-
-    await new Promise((done) => {
-      // from https://github.com/node-formidable/formidable/blob/master/test-node/standalone/promise.test.js
-
-      const server = createServer(async (req, res) => {
-        req.appInfo = {};
-        const middleware = new RequestParser(global.server.app);
-        middleware.middleware(req, {}, (err) => {
-          expect(err).toBeUndefined();
-          expect(req.body.title).toBeDefined();
-          expect(req.body.multipleFiles).toBeDefined();
-          expect(
-            req.body.multipleFiles[0] instanceof PersistentFile,
-          ).toBeTruthy();
-
-          res.writeHead(200);
-          res.end('ok');
-        });
-      });
-      server.listen(null, async () => {
-        const chosenPort = server.address().port;
-        const body = `----13068458571765726332503797717\r
-Content-Disposition: form-data; name="title"\r
-\r
-a\r
-----13068458571765726332503797717\r
-Content-Disposition: form-data; name="multipleFiles"; filename="x.txt"\r
-Content-Type: application/x-javascript\r
-\r
-\r
-\r
-a\r
-b\r
-c\r
-d\r
-\r
-----13068458571765726332503797717--\r
-`;
-        await fetch(String(new URL(`http:localhost:${chosenPort}/`)), {
-          method: 'POST',
-
-          headers: {
-            'Content-Length': body.length,
-            Host: `localhost:${chosenPort}`,
-            'Content-Type':
-              'multipart/form-data; boundary=--13068458571765726332503797717',
-          },
-          body,
-        }).catch((err) => {
-          console.error(err);
-          done(err);
-        });
-        server.close(() => {
-          done();
-        });
-      });
-    });
-  });
-  it('middleware with a problem', async () => {
-    expect.assertions(1);
-
-    await new Promise((done) => {
-      // from https://github.com/node-formidable/formidable/blob/master/test-node/standalone/promise.test.js
-
-      const server = createServer(async (req, res) => {
-        req.appInfo = {};
-        const middleware = new RequestParser(global.server.app);
-        let status;
-
-        const resp = {
-          status: (code) => {
-            status = code;
-            return resp;
-          },
-          json: () => resp,
-        };
-        await middleware.middleware(req, resp, () => {});
-        expect(status).toBe(400);
-        // expect(err).toBeDefined();
-
-        res.writeHead(200);
-        res.end('ok');
-      });
-      server.listen(null, async () => {
-        const chosenPort = server.address().port;
-        const body = 'someBadBody';
-
-        await fetch(String(new URL(`http:localhost:${chosenPort}/`)), {
-          method: 'POST',
-
-          headers: {
-            'Content-Length': body.length,
-            Host: `localhost:${chosenPort}`,
-            'Content-Type': 'badContentType',
-          },
-          body,
-        }).catch((err) => {
-          console.error(err);
-          done(err);
-        });
-        server.close(() => {
-          done();
-        });
-      });
-    });
-  });
-});

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

@@ -1,93 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Role from './Role.js';
-
-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;
-        },
-        json() {
-          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();
-  });
-});