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

package/models/User.test.js

@@ -1,143 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-const userEmail = 'testing@test.com';
-const userPassword = 'SuperNiceSecret123$';
-
-let globalUser;
-
-describe('user model', () => {
-  it('can create user', async () => {
-    expect.assertions(1);
-    globalUser = await global.server.app.getModel('User').create({
-      email: userEmail,
-      password: userPassword,
-      name: {
-        nick: 'nickname',
-      },
-    });
-    expect(globalUser.id).toBeDefined();
-  });
-
-  it('passwords should be hashed', async () => {
-    expect.assertions(1);
-
-    const user = await global.server.app.getModel('User').findOne({
-      email: userEmail,
-    });
-    expect(user.password).not.toBe(userPassword);
-  });
-
-  it('passwords should not be changed on other fields save', async () => {
-    expect.assertions(1);
-    const user = await global.server.app.getModel('User').findOne({
-      email: userEmail,
-    });
-    const psw = user.password;
-    user.email = 'rrrr';
-    await user.save();
-    user.email = userEmail;
-    await user.save();
-
-    expect(user.password).toBe(psw);
-  });
-
-  describe('getUserByEmailAndPassword', () => {
-    it('should WORK with valid creds', async () => {
-      expect.assertions(1);
-      const userModel = await global.server.app.getModel('User');
-      const user = await userModel.getUserByEmailAndPassword(
-        userEmail,
-        userPassword,
-      );
-      expect(user.id).toBe(globalUser.id);
-    });
-
-    it('should NOT with INvalid creds', async () => {
-      expect.assertions(1);
-      const userModel = await global.server.app.getModel('User');
-      const user = await userModel.getUserByEmailAndPassword(
-        userEmail,
-        'wrongPassword',
-      );
-      expect(user).toBeFalsy();
-    });
-
-    it('should NOT with wrong email', async () => {
-      expect.assertions(1);
-      const userModel = await global.server.app.getModel('User');
-      const user = await userModel.getUserByEmailAndPassword(
-        'not@exists.com',
-        userPassword,
-      );
-      expect(user).toBeFalsy();
-    });
-  });
-
-  describe('getUserByToken', () => {
-    it('should NOT work for non valid token', async () => {
-      expect.assertions(1);
-
-      const user = await global.server.app
-        .getModel('User')
-        .getUserByToken('fake one');
-      expect(user).toBeFalsy();
-    });
-
-    it('should  work for VALID token', async () => {
-      expect.assertions(1);
-      const token = await globalUser.generateToken();
-      const user = await global.server.app
-        .getModel('User')
-        .getUserByToken(token.token);
-      expect(user.id).toBe(globalUser.id);
-    });
-  });
-
-  describe('getUserByVerificationToken', () => {
-    it('should NOT work for non valid token', async () => {
-      expect.assertions(1);
-
-      await expect(
-        global.server.app
-          .getModel('User')
-          .getUserByVerificationToken('fake one'),
-      ).rejects.toStrictEqual(new Error('User not exists'));
-    });
-
-    it('should  work for VALID token', async () => {
-      expect.assertions(1);
-      const token = await global.server.app
-        .getModel('User')
-        .generateUserVerificationToken(globalUser);
-
-      const user = await global.server.app
-        .getModel('User')
-        .getUserByVerificationToken(token.token);
-      expect(user.id).toBe(globalUser.id);
-    });
-  });
-
-  describe('getUserByPasswordRecoveryToken', () => {
-    it('should NOT work for non valid token', async () => {
-      expect.assertions(1);
-
-      await expect(
-        global.server.app
-          .getModel('User')
-          .getUserByPasswordRecoveryToken('fake one'),
-      ).rejects.toStrictEqual(new Error('User not exists'));
-    });
-
-    it('should  work for VALID token', async () => {
-      expect.assertions(1);
-      const token = await global.server.app
-        .getModel('User')
-        .generateUserPasswordRecoveryToken(globalUser);
-
-      const user = await global.server.app
-        .getModel('User')
-        .getUserByPasswordRecoveryToken(token.token);
-      expect(user.id).toBe(globalUser.id);
-    });
-  });
-});

package/modules/Modules.test.js

@@ -1,18 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import SomeController from '../controllers/test/SomeController.js';
-import AbstractController from './AbstractController.js';
-
-describe('abstract controller methods', () => {
-  it('can get routes', async () => {
-    expect.assertions(2);
-
-    const controller = new AbstractController(global.server.app);
-    const childController = new SomeController(global.server.app);
-
-    const { routes } = controller;
-    const { routes: childRoutes } = childController;
-
-    expect(routes).toStrictEqual({});
-    expect(childRoutes).toBeDefined();
-  });
-});

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