@strapi/admin 4.16.1 → 4.17.0

package/server/services/__tests__/auth.test.js

@@ -1,319 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { ApplicationError } = require('@strapi/utils').errors;
-
-const {
-  validatePassword,
-  hashPassword,
-  checkCredentials,
-  forgotPassword,
-  resetPassword,
-} = require('../auth');
-
-describe('Auth', () => {
-  describe('checkCredentials', () => {
-    test('Fails on not found user, without leaking not found info', async () => {
-      const findOne = jest.fn(() => Promise.resolve());
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-      };
-
-      const input = { email: 'test@strapi.io', password: 'pcw123' };
-      const res = await checkCredentials(input);
-
-      expect(findOne).toHaveBeenCalledWith({ where: { email: input.email } });
-      expect(res).toEqual([null, false, { message: 'Invalid credentials' }]);
-    });
-
-    test('Fails when password is invalid, without leaking specific info', async () => {
-      const user = {
-        id: 1,
-        firstname: '',
-        lastname: '',
-        email: 'test@strapi.io',
-        password: await hashPassword('test-password'),
-      };
-
-      const findOne = jest.fn(() => Promise.resolve(user));
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-      };
-
-      const input = { email: 'test@strapi.io', password: 'wrong-password' };
-      const res = await checkCredentials(input);
-
-      expect(findOne).toHaveBeenCalledWith({ where: { email: input.email } });
-      expect(res).toEqual([null, false, { message: 'Invalid credentials' }]);
-    });
-
-    test.each([false, null, 1, 0])('Fails when user is not active (%s)', async (isActive) => {
-      const user = {
-        id: 1,
-        firstname: '',
-        lastname: '',
-        email: 'test@strapi.io',
-        isActive,
-        password: await hashPassword('test-password'),
-      };
-
-      const findOne = jest.fn(() => Promise.resolve(user));
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-      };
-
-      const input = { email: 'test@strapi.io', password: 'test-password' };
-      const res = await checkCredentials(input);
-
-      expect(findOne).toHaveBeenCalledWith({ where: { email: input.email } });
-      expect(res).toEqual([null, false, { message: 'User not active' }]);
-    });
-
-    test('Returns user when all checks pass', async () => {
-      const user = {
-        id: 1,
-        firstname: '',
-        lastname: '',
-        email: 'test@strapi.io',
-        isActive: true,
-        password: await hashPassword('test-password'),
-      };
-
-      const findOne = jest.fn(() => Promise.resolve(user));
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-      };
-
-      const input = { email: 'test@strapi.io', password: 'test-password' };
-      const res = await checkCredentials(input);
-
-      expect(findOne).toHaveBeenCalledWith({ where: { email: input.email } });
-      expect(res).toEqual([null, user]);
-    });
-  });
-
-  describe('validatePassword', () => {
-    test('Compares password with hash (matching passwords)', async () => {
-      const password = 'pcw123';
-      const hash = await hashPassword(password);
-
-      const isValid = await validatePassword(password, hash);
-      expect(isValid).toBe(true);
-    });
-
-    test('Compares password with hash (not matching passwords)', async () => {
-      const password = 'pcw123';
-      const password2 = 'pcs1234';
-      const hash = await hashPassword(password2);
-
-      const isValid = await validatePassword(password, hash);
-      expect(isValid).toBe(false);
-    });
-  });
-
-  describe('forgotPassword', () => {
-    test('Only run the process for active users', async () => {
-      const findOne = jest.fn(() => Promise.resolve());
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-      };
-
-      const input = { email: 'test@strapi.io' };
-      await forgotPassword(input);
-
-      expect(findOne).toHaveBeenCalledWith({ where: { email: input.email, isActive: true } });
-    });
-
-    test('Will return silently in case the user is not found', async () => {
-      const findOne = jest.fn(() => Promise.resolve());
-      const send = jest.fn(() => Promise.resolve());
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-        plugins: {
-          email: {
-            services: {
-              email: { send },
-            },
-          },
-        },
-      };
-
-      const input = { email: 'test@strapi.io' };
-      await forgotPassword(input);
-
-      expect(findOne).toHaveBeenCalled();
-      expect(send).not.toHaveBeenCalled();
-    });
-
-    test('Will assign a new reset token', async () => {
-      const user = {
-        id: 1,
-        email: 'test@strapi.io',
-      };
-      const resetPasswordToken = '123';
-
-      const findOne = jest.fn(() => Promise.resolve(user));
-      const send = jest.fn(() => Promise.resolve());
-      const updateById = jest.fn(() => Promise.resolve());
-      const createToken = jest.fn(() => resetPasswordToken);
-
-      const config = {
-        server: {
-          host: '0.0.0.0',
-        },
-        admin: { url: '/admin' },
-      };
-
-      global.strapi = {
-        config: {
-          ...config,
-          get(path, def) {
-            return _.get(path, def);
-          },
-        },
-        query() {
-          return { findOne };
-        },
-        admin: { services: { user: { updateById }, token: { createToken } } },
-        plugins: { email: { services: { email: { send, sendTemplatedEmail: send } } } },
-      };
-
-      const input = { email: user.email };
-      await forgotPassword(input);
-
-      expect(findOne).toHaveBeenCalled();
-      expect(createToken).toHaveBeenCalled();
-      expect(updateById).toHaveBeenCalledWith(user.id, { resetPasswordToken });
-    });
-
-    test('Will call the send service', async () => {
-      const user = {
-        id: 1,
-        email: 'test@strapi.io',
-      };
-      const resetPasswordToken = '123';
-
-      const findOne = jest.fn(() => Promise.resolve(user));
-      const send = jest.fn(() => Promise.resolve());
-      const sendTemplatedEmail = jest.fn(() => Promise.resolve());
-      const updateById = jest.fn(() => Promise.resolve());
-      const createToken = jest.fn(() => resetPasswordToken);
-
-      const config = {
-        server: {
-          host: '0.0.0.0',
-          admin: { url: '/admin', forgotPassword: { emailTemplate: {} } },
-        },
-      };
-
-      global.strapi = {
-        config: {
-          ...config,
-          get(path, def) {
-            return _.get(path, def);
-          },
-        },
-        query() {
-          return { findOne };
-        },
-        admin: {
-          services: {
-            user: { updateById },
-            token: { createToken },
-          },
-        },
-        plugins: { email: { services: { email: { send, sendTemplatedEmail } } } },
-      };
-
-      const input = { email: user.email };
-      await forgotPassword(input);
-
-      expect(findOne).toHaveBeenCalled();
-      expect(createToken).toHaveBeenCalled();
-      expect(sendTemplatedEmail).toHaveBeenCalled();
-    });
-  });
-
-  describe('resetPassword', () => {
-    test('Check user is active', async () => {
-      const resetPasswordToken = '123';
-      const findOne = jest.fn(() => Promise.resolve());
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-      };
-
-      expect.assertions(2);
-
-      try {
-        await resetPassword({ resetPasswordToken, password: 'Test1234' });
-      } catch (e) {
-        expect(e instanceof ApplicationError).toBe(true);
-      }
-
-      expect(findOne).toHaveBeenCalledWith({ where: { resetPasswordToken, isActive: true } });
-    });
-
-    test('Fails if user is not found', async () => {
-      const resetPasswordToken = '123';
-      const findOne = jest.fn(() => Promise.resolve());
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-      };
-
-      expect.assertions(1);
-
-      try {
-        await resetPassword({ resetPasswordToken, password: 'Test1234' });
-      } catch (e) {
-        expect(e instanceof ApplicationError).toBe(true);
-      }
-    });
-
-    test('Changes password and clear reset token', async () => {
-      const resetPasswordToken = '123';
-      const user = { id: 1 };
-
-      const findOne = jest.fn(() => Promise.resolve(user));
-      const updateById = jest.fn(() => Promise.resolve());
-
-      global.strapi = {
-        query() {
-          return { findOne };
-        },
-        admin: { services: { user: { updateById } } },
-      };
-
-      const input = { resetPasswordToken, password: 'Test1234' };
-      await resetPassword(input);
-
-      expect(updateById).toHaveBeenCalledWith(user.id, {
-        password: input.password,
-        resetPasswordToken: null,
-      });
-    });
-  });
-});

package/server/services/__tests__/content-type.test.js

@@ -1,405 +0,0 @@
-'use strict';
-
-const { merge } = require('lodash/fp');
-const { toPermission } = require('../../domain/permission');
-const contentTypeService = require('../content-type');
-
-describe('Content-Type', () => {
-  const contentTypes = {
-    user: {
-      uid: 'user',
-      attributes: {
-        firstname: { type: 'text', required: true },
-        restaurant: { type: 'component', component: 'restaurant' },
-        car: { type: 'component', component: 'car', required: true },
-      },
-    },
-    country: {
-      uid: 'country',
-      attributes: {
-        name: { type: 'text' },
-        code: { type: 'text' },
-      },
-    },
-  };
-  const components = {
-    restaurant: {
-      uid: 'restaurant',
-      attributes: {
-        name: { type: 'text' },
-        description: { type: 'text' },
-        address: { type: 'component', component: 'address' },
-      },
-    },
-    car: {
-      uid: 'car',
-      attributes: {
-        model: { type: 'text' },
-      },
-    },
-    address: {
-      uid: 'address',
-      attributes: {
-        city: { type: 'text' },
-        country: { type: 'text', required: true },
-        gpsCoordinates: { type: 'component', component: 'gpsCoordinates' },
-      },
-    },
-    gpsCoordinates: {
-      uid: 'gpsCoordinates',
-      attributes: {
-        lat: { type: 'text' },
-        long: { type: 'text' },
-      },
-    },
-  };
-
-  global.strapi = {
-    components,
-    contentTypes,
-    admin: { services: { condition: { isValidCondition: () => true } } },
-  };
-
-  describe('getNestedFields', () => {
-    const testsA = [
-      [1, ['firstname', 'restaurant', 'car']],
-      [
-        2,
-        [
-          'firstname',
-          'restaurant.name',
-          'restaurant.description',
-          'restaurant.address',
-          'car.model',
-        ],
-      ],
-      [
-        3,
-        [
-          'firstname',
-          'restaurant.name',
-          'restaurant.description',
-          'restaurant.address.city',
-          'restaurant.address.country',
-          'restaurant.address.gpsCoordinates',
-          'car.model',
-        ],
-      ],
-      [
-        4,
-        [
-          'firstname',
-          'restaurant.name',
-          'restaurant.description',
-          'restaurant.address.city',
-          'restaurant.address.country',
-          'restaurant.address.gpsCoordinates.lat',
-          'restaurant.address.gpsCoordinates.long',
-          'car.model',
-        ],
-      ],
-      [
-        5,
-        [
-          'firstname',
-          'restaurant.name',
-          'restaurant.description',
-          'restaurant.address.city',
-          'restaurant.address.country',
-          'restaurant.address.gpsCoordinates.lat',
-          'restaurant.address.gpsCoordinates.long',
-          'car.model',
-        ],
-      ],
-    ];
-
-    test.each(testsA)('%p level(s)', async (nestingLevel, expectedResult) => {
-      const res = contentTypeService.getNestedFields(contentTypes.user, {
-        nestingLevel,
-        components: strapi.components,
-      });
-      expect(res).toEqual(expectedResult);
-    });
-
-    const testsB = [
-      [undefined, ['firstname', 'car']],
-      [null, ['firstname', 'car']],
-      [
-        ['firstname', 'car'],
-        ['firstname', 'car'],
-      ],
-      [['restaurant.description'], ['firstname', 'car']],
-      [['restaurant.address'], ['firstname', 'restaurant.address.country', 'car']],
-      [['restaurant.address.city'], ['firstname', 'restaurant.address.country', 'car']],
-      [
-        ['firstname', 'restaurant.address.country', 'car'],
-        ['firstname', 'restaurant.address.country', 'car'],
-      ],
-    ];
-
-    test.each(testsB)('requiredOnly : %p -> %p', (existingFields, expectedResult) => {
-      const res = contentTypeService.getNestedFields(contentTypes.user, {
-        components: strapi.components,
-        requiredOnly: true,
-        existingFields,
-      });
-      expect(res).toEqual(expectedResult);
-    });
-  });
-
-  describe('getNestedFieldsWithIntermediate', () => {
-    const tests = [
-      [1, ['firstname', 'restaurant', 'car']],
-      [
-        2,
-        [
-          'firstname',
-          'restaurant',
-          'restaurant.name',
-          'restaurant.description',
-          'restaurant.address',
-          'car',
-          'car.model',
-        ],
-      ],
-      [
-        3,
-        [
-          'firstname',
-          'restaurant',
-          'restaurant.name',
-          'restaurant.description',
-          'restaurant.address',
-          'restaurant.address.city',
-          'restaurant.address.country',
-          'restaurant.address.gpsCoordinates',
-          'car',
-          'car.model',
-        ],
-      ],
-      [
-        4,
-        [
-          'firstname',
-          'restaurant',
-          'restaurant.name',
-          'restaurant.description',
-          'restaurant.address',
-          'restaurant.address.city',
-          'restaurant.address.country',
-          'restaurant.address.gpsCoordinates',
-          'restaurant.address.gpsCoordinates.lat',
-          'restaurant.address.gpsCoordinates.long',
-          'car',
-          'car.model',
-        ],
-      ],
-      [
-        5,
-        [
-          'firstname',
-          'restaurant',
-          'restaurant.name',
-          'restaurant.description',
-          'restaurant.address',
-          'restaurant.address.city',
-          'restaurant.address.country',
-          'restaurant.address.gpsCoordinates',
-          'restaurant.address.gpsCoordinates.lat',
-          'restaurant.address.gpsCoordinates.long',
-          'car',
-          'car.model',
-        ],
-      ],
-    ];
-
-    test.each(tests)('%p level(s) - withIntermediate', async (nestingLevel, expectedResult) => {
-      const res = contentTypeService.getNestedFieldsWithIntermediate(contentTypes.user, {
-        nestingLevel,
-        components: strapi.components,
-        withIntermediate: true,
-      });
-      expect(res).toEqual(expectedResult);
-    });
-  });
-
-  describe('getPermissionsWithNestedFields', () => {
-    test('1 action (no nesting)', async () => {
-      const resultLevel1 = contentTypeService.getPermissionsWithNestedFields([
-        { actionId: 'action-1', subjects: ['country'], options: { applyToProperties: ['fields'] } },
-      ]);
-
-      expect(resultLevel1).toEqual([
-        {
-          action: 'action-1',
-          actionParameters: {},
-          subject: 'country',
-          properties: { fields: ['name', 'code'] },
-          conditions: [],
-        },
-      ]);
-    });
-
-    test('2 actions (with nesting level 1)', async () => {
-      const resultLevel1 = contentTypeService.getPermissionsWithNestedFields(
-        [
-          {
-            actionId: 'action-1',
-            subjects: ['country', 'user'],
-            options: { applyToProperties: ['fields'] },
-          },
-        ],
-        { nestingLevel: 1 }
-      );
-      expect(resultLevel1).toEqual([
-        {
-          action: 'action-1',
-          actionParameters: {},
-          subject: 'country',
-          properties: { fields: ['name', 'code'] },
-          conditions: [],
-        },
-        {
-          action: 'action-1',
-          actionParameters: {},
-          subject: 'user',
-          properties: { fields: ['firstname', 'restaurant', 'car'] },
-          conditions: [],
-        },
-      ]);
-    });
-
-    test('2 actions (with nesting level 2)', async () => {
-      const resultLevel1 = contentTypeService.getPermissionsWithNestedFields(
-        [
-          {
-            actionId: 'action-1',
-            subjects: ['country', 'user'],
-            options: { applyToProperties: ['fields'] },
-          },
-        ],
-        { nestingLevel: 2 }
-      );
-      expect(resultLevel1).toEqual([
-        {
-          action: 'action-1',
-          actionParameters: {},
-          subject: 'country',
-          properties: { fields: ['name', 'code'] },
-          conditions: [],
-        },
-        {
-          action: 'action-1',
-          actionParameters: {},
-          subject: 'user',
-          properties: {
-            fields: [
-              'firstname',
-              'restaurant.name',
-              'restaurant.description',
-              'restaurant.address',
-              'car.model',
-            ],
-          },
-          conditions: [],
-        },
-      ]);
-    });
-
-    test('2 actions (with nesting level 100)', async () => {
-      const resultLevel1 = contentTypeService.getPermissionsWithNestedFields([
-        {
-          actionId: 'action-1',
-          subjects: ['country', 'user'],
-          options: { applyToProperties: ['fields'] },
-        },
-      ]);
-      expect(resultLevel1).toEqual([
-        {
-          action: 'action-1',
-          actionParameters: {},
-          subject: 'country',
-          properties: { fields: ['name', 'code'] },
-          conditions: [],
-        },
-        {
-          action: 'action-1',
-          actionParameters: {},
-          subject: 'user',
-          properties: {
-            fields: [
-              'firstname',
-              'restaurant.name',
-              'restaurant.description',
-              'restaurant.address.city',
-              'restaurant.address.country',
-              'restaurant.address.gpsCoordinates.lat',
-              'restaurant.address.gpsCoordinates.long',
-              'car.model',
-            ],
-          },
-          conditions: [],
-        },
-      ]);
-    });
-  });
-
-  describe('cleanPermissionFields', () => {
-    beforeAll(() => {
-      global.strapi = merge(global.strapi, {
-        admin: {
-          services: {
-            permission: {
-              actionProvider: {
-                get: () => ({ options: { applyToProperties: ['fields'] } }),
-              },
-            },
-          },
-        },
-      });
-    });
-
-    const tests = [
-      [undefined, ['firstname', 'car']],
-      [null, ['firstname', 'car']],
-      [
-        ['firstname', 'car'],
-        ['firstname', 'car'],
-      ],
-      [['restaurant.description'], ['restaurant.description', 'firstname', 'car']],
-      [['restaurant.address'], ['firstname', 'restaurant.address.country', 'car']],
-      [
-        ['restaurant.address.city'],
-        ['restaurant.address.city', 'firstname', 'restaurant.address.country', 'car'],
-      ],
-      [
-        ['firstname', 'restaurant.address.country', 'car'],
-        ['firstname', 'restaurant.address.country', 'car'],
-      ],
-    ];
-
-    test.each(tests)('requiredOnly : %p -> %p', (fields, expectedFields) => {
-      const res = contentTypeService.cleanPermissionFields(
-        toPermission([
-          {
-            action: 'foo',
-            subject: 'user',
-            properties: { fields },
-          },
-        ]),
-        {
-          requiredOnly: true,
-        }
-      );
-      expect(res).toEqual([
-        {
-          action: 'foo',
-          actionParameters: {},
-          subject: 'user',
-          properties: { fields: expectedFields },
-          conditions: [],
-        },
-      ]);
-    });
-  });
-});