@adaptivestone/framework 5.0.0-alpha.2 → 5.0.0-alpha.21

package/services/cache/Cache.test.js

@@ -1,81 +0,0 @@
-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/http/middleware/Auth.test.js

@@ -1,57 +0,0 @@
-import { beforeAll, describe, it, expect } from 'vitest';
-import Auth from './Auth.js';
-
-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/Cors.test.js

@@ -1,147 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import Cors from './Cors.js';
-
-describe('cors middleware methods', () => {
-  it('have description fields', async () => {
-    expect.assertions(1);
-    const middleware = new Cors(global.server.app, { origins: ['something'] });
-    expect(middleware.constructor.description).toBeDefined();
-  });
-
-  it('should throw without origns', async () => {
-    expect.assertions(1);
-    expect(() => new Cors(global.server.app)).toThrow();
-  });
-
-  it('should throw with empty options', async () => {
-    expect.assertions(1);
-    expect(() => new Cors(global.server.app, {})).toThrow();
-  });
-
-  it('should throw with empty origins', async () => {
-    expect.assertions(1);
-    expect(() => new Cors(global.server.app, { origins: [] })).toThrow();
-  });
-
-  it('should throw with empty origins not array', async () => {
-    expect.assertions(1);
-    expect(() => new Cors(global.server.app, { origins: 'origins' })).toThrow();
-  });
-
-  it('non options should be different', async () => {
-    expect.assertions(2);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const map = new Map();
-    const req = {
-      method: 'GET',
-
-      headers: { origin: 'https://localhost' },
-    };
-    const res = {
-      set: (key, val) => {
-        map.set(key, val);
-      },
-    };
-    const middleware = new Cors(global.server.app, {
-      origins: ['https://localhost'],
-    });
-
-    await middleware.middleware(req, res, nextFunction);
-    expect(isCalled).toBeTruthy();
-    expect(map.get('Vary')).toBe('Origin');
-  });
-
-  it('host the not match origin', async () => {
-    expect.assertions(1);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      method: 'OPTIONS',
-      headers: { origin: 'http://anotherDomain.com' },
-    };
-    const middleware = new Cors(global.server.app, {
-      origins: ['https://localhost'],
-    });
-
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-  });
-
-  it('string domain match', async () => {
-    expect.assertions(5);
-    let isEndCalled = false;
-    const map = new Map();
-    const req = {
-      method: 'OPTIONS',
-      headers: {
-        origin: 'https://localhost',
-        'access-control-request-headers': 'someAccessControlRequestHeaders',
-      },
-    };
-    const res = {
-      set: (key, val) => {
-        map.set(key, val);
-      },
-      status: () => {},
-      end: () => {
-        isEndCalled = true;
-      },
-    };
-    const middleware = new Cors(global.server.app, {
-      origins: ['https://localhost'],
-    });
-
-    await middleware.middleware(req, res);
-    expect(isEndCalled).toBeTruthy();
-    expect(map.get('Vary')).toBe('Origin, Access-Control-Request-Headers');
-    expect(map.get('Access-Control-Allow-Headers')).toBe(
-      'someAccessControlRequestHeaders',
-    );
-    expect(map.get('Access-Control-Allow-Origin')).toBe('https://localhost');
-    expect(map.get('Access-Control-Allow-Methods')).toBe(
-      'GET,HEAD,PUT,PATCH,POST,DELETE',
-    );
-  });
-
-  it('regexp domain match', async () => {
-    expect.assertions(5);
-    let isEndCalled = false;
-    const map = new Map();
-    const req = {
-      method: 'OPTIONS',
-      headers: {
-        origin: 'https://localhost',
-        'access-control-request-headers': 'someAccessControlRequestHeaders',
-      },
-    };
-    const res = {
-      set: (key, val) => {
-        map.set(key, val);
-      },
-      status: () => {},
-
-      end: () => {
-        isEndCalled = true;
-      },
-    };
-    const middleware = new Cors(global.server.app, {
-      origins: [/./],
-    });
-
-    await middleware.middleware(req, res);
-    expect(isEndCalled).toBeTruthy();
-    expect(map.get('Vary')).toBe('Origin, Access-Control-Request-Headers');
-    expect(map.get('Access-Control-Allow-Headers')).toBe(
-      'someAccessControlRequestHeaders',
-    );
-    expect(map.get('Access-Control-Allow-Origin')).toBe('https://localhost');
-    expect(map.get('Access-Control-Allow-Methods')).toBe(
-      'GET,HEAD,PUT,PATCH,POST,DELETE',
-    );
-  });
-});

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

@@ -1,108 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import GetUserByToken from './GetUserByToken.js';
-
-describe('getUserByToken middleware methods', () => {
-  it('have description fields', async () => {
-    expect.assertions(1);
-    const middleware = new GetUserByToken(global.server.app);
-    expect(middleware.constructor.description).toBeDefined();
-  });
-
-  it('have description usedAuthParameters', async () => {
-    expect.assertions(2);
-    const middleware = new GetUserByToken(global.server.app);
-    const params = middleware.usedAuthParameters;
-    expect(params).toHaveLength(1);
-    expect(params[0].name).toBe('Authorization');
-  });
-
-  it('should not called twice', async () => {
-    expect.assertions(1);
-    const middleware = new GetUserByToken(global.server.app);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      appInfo: {
-        user: {},
-      },
-    };
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-  });
-
-  it('should not getuser without token', async () => {
-    expect.assertions(1);
-    const middleware = new GetUserByToken(global.server.app);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      appInfo: {},
-      body: {},
-      get: () => {},
-    };
-
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-  });
-
-  it('should not getuser with a wrong token', async () => {
-    expect.assertions(2);
-    const middleware = new GetUserByToken(global.server.app);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      appInfo: {},
-      body: {
-        token: 'fake',
-      },
-      get: () => {},
-    };
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-    expect(req.appInfo.user).toBeUndefined();
-  });
-
-  it('should not getuser with a good token in body', async () => {
-    expect.assertions(2);
-    const middleware = new GetUserByToken(global.server.app);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      appInfo: {},
-      body: {
-        token: global.authToken.token,
-      },
-      get: () => {},
-    };
-
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-    expect(req.appInfo.user).toBeDefined();
-  });
-
-  it('should not getuser with a good token in header', async () => {
-    expect.assertions(2);
-    const middleware = new GetUserByToken(global.server.app);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      appInfo: {},
-      body: {},
-      get: () => global.authToken.token,
-    };
-
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-    expect(req.appInfo.user).toBeDefined();
-  });
-});

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

@@ -1,96 +0,0 @@
-import { beforeAll, describe, it, expect } from 'vitest';
-import I18n from './I18n.js';
-
-describe('i18n middleware methods', () => {
-  let middleware;
-  beforeAll(() => {
-    middleware = new I18n(global.server.app);
-  });
-  it('have description fields', async () => {
-    expect.assertions(1);
-    expect(middleware.constructor.description).toBeDefined();
-  });
-
-  it('detectors should works correctly', async () => {
-    expect.assertions(6);
-    const request = {
-      get: () => 'en',
-      query: {
-        [middleware.lookupQuerystring]: 'es',
-      },
-    };
-    let lang = await middleware.detectLang(request);
-    expect(lang).toBe('en');
-
-    request.appInfo = {
-      user: {
-        locale: 'be',
-      },
-    };
-    lang = await middleware.detectLang(request);
-    expect(lang).toBe('en');
-    request.get = () => null;
-    lang = await middleware.detectLang(request);
-    expect(lang).toBe('es');
-
-    delete request.query;
-    lang = await middleware.detectLang(request);
-    expect(lang).toBe('be');
-
-    request.query = {
-      [middleware.lookupQuerystring]: 'en-GB',
-    };
-    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(6);
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      get: () => 'en',
-      appInfo: {},
-    };
-    await middleware.middleware(req, {}, nextFunction);
-    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 () => {
-    expect.assertions(4);
-    global.server.app.updateConfig('i18n', { enabled: false });
-    middleware = new I18n(global.server.app);
-
-    let isCalled = false;
-    const nextFunction = () => {
-      isCalled = true;
-    };
-    const req = {
-      get: () => 'en',
-      appInfo: {},
-    };
-    await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBeTruthy();
-    expect(req.appInfo.i18n).toBeDefined();
-    expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
-    expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test
-    global.server.app.updateConfig('i18n', { enabled: true });
-  });
-});

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);
-  });
-});