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

package/controllers/Auth.test.js

@@ -1,451 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-const userEmail = 'testing@test.com';
-const userPassword = 'SuperNiceSecret123$';
-
-const userEmail2 = 'testing2@test.com';
-
-describe('auth', () => {
-  describe('registration', () => {
-    it('code NOT able to create user with wrong email', async () => {
-      expect.assertions(1);
-      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 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 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(() => {});
-
-      expect(status).toBe(400);
-    });
-
-    it('can NOT create SAME user', async () => {
-      expect.assertions(1);
-
-      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 verified email', async () => {
-      expect.assertions(1);
-      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 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 verified email', async () => {
-      expect.assertions(2);
-
-      const user = await global.server.app
-        .getModel('User')
-        .findOne({ email: userEmail });
-      user.isVerified = true;
-      await user.save();
-
-      const response = await fetch(global.server.testingGetUrl('/auth/login'), {
-        method: 'POST',
-        headers: {
-          'Content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          email: userEmail,
-          password: userPassword,
-        }),
-      });
-
-      const responseBody = await response.json();
-
-      expect(response.status).toBe(200);
-      expect(responseBody.token).toBeDefined();
-    });
-  });
-
-  describe('isAuthWithVefificationFlow auth option', () => {
-    it('can verify user', async () => {
-      expect.assertions(2);
-      const user = await global.server.app.getModel('User').create({
-        email: 'Test@gmail.com',
-        password: 'userPassword',
-        name: {
-          nick: 'nickname',
-        },
-      });
-
-      user.verificationTokens.push({
-        token: 'testToken',
-      });
-
-      await user.save();
-
-      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',
-      });
-
-      expect(status).toBe(200);
-      expect(isVerified).toBeTruthy();
-    });
-
-    it('can not verify user with wrong token', async () => {
-      expect.assertions(2);
-      const user = await global.server.app.getModel('User').create({
-        email: 'Test423@gmail.com',
-        password: 'userPassword',
-        name: {
-          nick: 'nicknameee',
-        },
-      });
-
-      user.verificationTokens.push({
-        token: 'testToken',
-      });
-
-      await user.save();
-
-      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',
-      });
-
-      expect(status).toBe(400);
-      expect(isVerified).toBeFalsy();
-    });
-
-    it('can NOT send recovery to not exist email', async () => {
-      expect.assertions(1);
-      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 fetch(
-        global.server.testingGetUrl('/auth/send-recovery-email'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: userEmail,
-          }),
-        },
-      );
-
-      expect(status).toBe(200);
-    });
-
-    it('can recover password', async () => {
-      expect.assertions(1);
-
-      const user = await global.server.app.getModel('User').create({
-        email: 'Test1@gmail.com',
-        password: 'userPassword',
-        name: {
-          nick: 'nickname1',
-        },
-      });
-
-      user.passwordRecoveryTokens.push({
-        token: 'superPassword',
-      });
-
-      await user.save();
-
-      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);
-    });
-
-    it('can not recover password with wrong token', async () => {
-      expect.assertions(1);
-
-      const user = await global.server.app.getModel('User').create({
-        email: 'Test2@gmail.com',
-        password: 'userPassword',
-        name: {
-          nick: 'nickname2',
-        },
-      });
-
-      user.passwordRecoveryTokens.push({
-        token: 'superPassword',
-      });
-
-      await user.save();
-
-      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 if option isAuthWithVefificationFlow is set', async () => {
-      expect.assertions(4);
-
-      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 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(response3.status).toBe(200);
-      expect(responseBody3.token).toBeDefined();
-    });
-  });
-
-  it('can user send verification', async () => {
-    expect.assertions(1);
-
-    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 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('should receive 429 on rate limit exceeded', async () => {
-      expect.assertions(1);
-
-      const requests = Array.from({ length: 11 }, () =>
-        fetch(global.server.testingGetUrl('/auth/logout'), {
-          method: 'POST',
-        }),
-      );
-
-      const responses = await Promise.all(requests);
-      const statusCodes = responses.map((response) => response.status);
-
-      expect(statusCodes).toContain(429);
-    });
-  });
-});

package/controllers/Home.test.js

@@ -1,12 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('home', () => {
-  it('can open home have', async () => {
-    expect.assertions(1);
-    const { status } = await fetch(global.server.testingGetUrl('/')).catch(
-      () => {},
-    );
-
-    expect(status).toBe(200);
-  });
-});

package/models/Migration.test.js

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('migration model', () => {
-  it('migrationFile should be uniqe', async () => {
-    expect.assertions(1);
-    let errorCode;
-    const MigrationModel = global.server.app.getModel('Migration');
-    await MigrationModel.syncIndexes();
-    await MigrationModel.create({
-      migrationFile: 'a',
-    });
-    await MigrationModel.create({
-      migrationFile: 'a',
-    }).catch((e) => {
-      errorCode = e.code;
-    });
-
-    expect(errorCode).toBe(11000);
-  });
-});

package/models/Sequence.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('sequence model', () => {
-  it('should produce sequence', async () => {
-    expect.assertions(1);
-    const SequenceModel = global.server.app.getModel('Sequence');
-
-    const number1 = await SequenceModel.getSequence('typeOne');
-
-    expect(number1).toBe(1);
-  });
-
-  it('should produce sequence different for different types', async () => {
-    expect.assertions(3);
-    const SequenceModel = global.server.app.getModel('Sequence');
-
-    const number1 = await SequenceModel.getSequence('typeOneAgain');
-    const number2 = await SequenceModel.getSequence('typeTwo');
-    const number3 = await SequenceModel.getSequence('typeThree');
-
-    expect(number1).toBe(1);
-    expect(number2).toBe(1);
-    expect(number3).toBe(1);
-  });
-
-  it('should works on async env', async () => {
-    expect.assertions(1);
-    const SequenceModel = global.server.app.getModel('Sequence');
-
-    const promises = [];
-    const upTo = 100;
-    for (let i = 0; i < upTo; i += 1) {
-      promises.push(SequenceModel.getSequence('asyncTypeOne'));
-    }
-
-    const data = await Promise.all(promises);
-    const summ = ((1 + upTo) / 2) * upTo; // Arithmetic progression
-
-    const summ2 = data.reduce((a, b) => a + b, 0);
-
-    expect(summ2).toBe(summ);
-  });
-});

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