@strapi/strapi 4.10.1 → 4.10.2

package/lib/services/entity-validator/__tests__/timestamp-validators.test.js

@@ -1,204 +0,0 @@
-'use strict';
-
-const strapiUtils = require('@strapi/utils');
-const {
-  errors: { YupValidationError },
-} = require('@strapi/utils');
-const validators = require('../validators');
-
-describe('Time validator', () => {
-  describe('unique', () => {
-    const fakeFindOne = jest.fn();
-
-    global.strapi = {
-      db: {
-        query: jest.fn(() => ({
-          findOne: fakeFindOne,
-        })),
-      },
-    };
-
-    afterEach(() => {
-      jest.clearAllMocks();
-      fakeFindOne.mockReset();
-    });
-
-    const fakeModel = {
-      kind: 'contentType',
-      modelName: 'test-model',
-      uid: 'test-uid',
-      privateAttributes: [],
-      options: {},
-      attributes: {
-        attrTimestampUnique: { type: 'timestamp', unique: true },
-      },
-    };
-
-    test('it does not validates the unique constraint if the attribute is not set as unique', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.timestamp(
-          {
-            attr: { type: 'timestamp' },
-            model: fakeModel,
-            updatedAttribute: {
-              name: 'attrTimestampUnique',
-              value: '1638140400',
-            },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      await validator('1638140400');
-
-      expect(fakeFindOne).not.toHaveBeenCalled();
-    });
-
-    test('it does not validates the unique constraint if the attribute value is `null`', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators
-          .timestamp(
-            {
-              attr: { type: 'timestamp', unique: true },
-              model: fakeModel,
-              updatedAttribute: {
-                name: 'attrTimestampUnique',
-                value: null,
-              },
-              entity: null,
-            },
-            { isDraft: false }
-          )
-          .nullable()
-      );
-
-      await validator(null);
-      expect(fakeFindOne).not.toHaveBeenCalled();
-    });
-
-    test('it validates the unique constraint if there is no other record in the database', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.timestamp(
-          {
-            attr: { type: 'timestamp', unique: true },
-            model: fakeModel,
-            updatedAttribute: {
-              name: 'attrTimestampUnique',
-              value: '1638140400',
-            },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      expect(await validator('1638140400')).toBe('1638140400');
-    });
-
-    test('it fails the validation of the unique constraint if the database contains a record with the same attribute value', async () => {
-      expect.assertions(1);
-      fakeFindOne.mockResolvedValueOnce({ attrTimestampUnique: '1638140400' });
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.timestamp(
-          {
-            attr: { type: 'timestamp', unique: true },
-            model: fakeModel,
-            updatedAttribute: {
-              name: 'attrTimestampUnique',
-              value: '1638140400',
-            },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      try {
-        await validator('1638140400');
-      } catch (err) {
-        expect(err).toBeInstanceOf(YupValidationError);
-      }
-    });
-
-    test('it validates the unique constraint if the attribute data has not changed even if there is a record in the database with the same attribute value', async () => {
-      fakeFindOne.mockResolvedValueOnce({ attrTimestampUnique: '1638140400' });
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.timestamp(
-          {
-            attr: { type: 'timestamp', unique: true },
-            model: fakeModel,
-            updatedAttribute: {
-              name: 'attrTimestampUnique',
-              value: '1638140400',
-            },
-            entity: { id: 1, attrTimestampUnique: '1638140400' },
-          },
-          { isDraft: false }
-        )
-      );
-
-      expect(await validator('1638140400')).toBe('1638140400');
-    });
-
-    test('it checks the database for records with the same value for the checked attribute', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.timestamp(
-          {
-            attr: { type: 'timestamp', unique: true },
-            model: fakeModel,
-            updatedAttribute: {
-              name: 'attrTimestampUnique',
-              value: '1638140400',
-            },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      await validator('1638140400');
-
-      expect(fakeFindOne).toHaveBeenCalledWith({
-        select: ['id'],
-        where: { attrTimestampUnique: '1638140400' },
-      });
-    });
-
-    test('it checks the database for records with the same value but not the same id for the checked attribute if an entity is passed', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.timestamp(
-          {
-            attr: { type: 'timestamp', unique: true },
-            model: fakeModel,
-            updatedAttribute: {
-              name: 'attrTimestampUnique',
-              value: '1638140400',
-            },
-            entity: { id: 1, attrTimestampUnique: '1000000000' },
-          },
-          { isDraft: false }
-        )
-      );
-
-      await validator('1638140400');
-
-      expect(fakeFindOne).toHaveBeenCalledWith({
-        select: ['id'],
-        where: { $and: [{ attrTimestampUnique: '1638140400' }, { $not: { id: 1 } }] },
-      });
-    });
-  });
-});

package/lib/services/entity-validator/__tests__/uid-validators.test.js

@@ -1,229 +0,0 @@
-'use strict';
-
-const strapiUtils = require('@strapi/utils');
-const {
-  errors: { YupValidationError },
-} = require('@strapi/utils');
-const validators = require('../validators');
-
-describe('UID validator', () => {
-  const fakeFindOne = jest.fn();
-
-  global.strapi = {
-    db: {
-      query: jest.fn(() => ({
-        findOne: fakeFindOne,
-      })),
-    },
-  };
-
-  afterEach(() => {
-    jest.clearAllMocks();
-    fakeFindOne.mockReset();
-  });
-
-  const fakeModel = {
-    kind: 'contentType',
-    modelName: 'test-model',
-    uid: 'test-uid',
-    privateAttributes: [],
-    options: {},
-    attributes: {
-      attrUidUnique: { type: 'uid' },
-    },
-  };
-
-  describe('unique', () => {
-    test('it validates the unique constraint if there is no other record in the database', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.uid(
-          {
-            attr: { type: 'uid', unique: true },
-            model: fakeModel,
-            updatedAttribute: { name: 'attrUidUnique', value: 'non-unique-uid' },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      expect(await validator('non-unique-uid')).toBe('non-unique-uid');
-    });
-
-    test('it does not validates the unique constraint if the attribute value is `null`', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators
-          .uid(
-            {
-              attr: { type: 'uid', unique: true },
-              model: fakeModel,
-              updatedAttribute: { name: 'attrUidUnique', value: null },
-              entity: null,
-            },
-            { isDraft: false }
-          )
-          .nullable()
-      );
-
-      await validator(null);
-
-      expect(fakeFindOne).not.toHaveBeenCalled();
-    });
-
-    test('it always validates the unique constraint even if the attribute is not set as unique', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.uid(
-          {
-            attr: { type: 'uid' },
-            model: fakeModel,
-            updatedAttribute: { name: 'attrUidUnique', value: 'non-unique-uid' },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      expect(await validator('non-unique-uid')).toBe('non-unique-uid');
-      expect(fakeFindOne).toHaveBeenCalledWith({
-        select: ['id'],
-        where: { attrUidUnique: 'non-unique-uid' },
-      });
-    });
-
-    test('it fails the validation of the unique constraint if the database contains a record with the same attribute value', async () => {
-      expect.assertions(1);
-      fakeFindOne.mockResolvedValueOnce({ attrUidUnique: 'unique-uid' });
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.uid(
-          {
-            attr: { type: 'uid', unique: true },
-            model: fakeModel,
-            updatedAttribute: { name: 'attrUidUnique', value: 'unique-uid' },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      try {
-        await validator('unique-uid');
-      } catch (err) {
-        expect(err).toBeInstanceOf(YupValidationError);
-      }
-    });
-
-    test('it validates the unique constraint if the attribute data has not changed even if there is a record in the database with the same attribute value', async () => {
-      fakeFindOne.mockResolvedValueOnce({ attrUidUnique: 'unchanged-unique-uid' });
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.uid(
-          {
-            attr: { type: 'uid', unique: true },
-            model: fakeModel,
-            updatedAttribute: { name: 'attrUidUnique', value: 'unchanged-unique-uid' },
-            entity: { id: 1, attrUidUnique: 'unchanged-unique-uid' },
-          },
-          { isDraft: false }
-        )
-      );
-
-      expect(await validator('unchanged-unique-uid')).toBe('unchanged-unique-uid');
-    });
-
-    test('it checks the database for records with the same value for the checked attribute', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.uid(
-          {
-            attr: { type: 'uid', unique: true },
-            model: fakeModel,
-            updatedAttribute: { name: 'attrUidUnique', value: 'unique-uid' },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      await validator('unique-uid');
-
-      expect(fakeFindOne).toHaveBeenCalledWith({
-        select: ['id'],
-        where: { attrUidUnique: 'unique-uid' },
-      });
-    });
-
-    test('it checks the database for records with the same value but not the same id for the checked attribute if an entity is passed', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.uid(
-          {
-            attr: { type: 'uid', unique: true },
-            model: fakeModel,
-            updatedAttribute: { name: 'attrUidUnique', value: 'unique-uid' },
-            entity: { id: 1, attrUidUnique: 'other-uid' },
-          },
-          { isDraft: false }
-        )
-      );
-
-      await validator('unique-uid');
-
-      expect(fakeFindOne).toHaveBeenCalledWith({
-        select: ['id'],
-        where: { $and: [{ attrUidUnique: 'unique-uid' }, { $not: { id: 1 } }] },
-      });
-    });
-  });
-
-  describe('regExp', () => {
-    test('it fails to validate the uid if it does not fit the requried format', async () => {
-      expect.assertions(1);
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.uid(
-          {
-            attr: { type: 'uid', unique: true },
-            model: fakeModel,
-            updatedAttribute: { name: 'attrUidUnique', value: 'non-unique-uid' },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      try {
-        await validator('wrongly\\formated||UID');
-      } catch (err) {
-        expect(err).toBeInstanceOf(YupValidationError);
-      }
-    });
-
-    test('it validate the uid if it fit the required format', async () => {
-      fakeFindOne.mockResolvedValueOnce(null);
-
-      const validator = strapiUtils.validateYupSchema(
-        validators.uid(
-          {
-            attr: { type: 'uid', unique: true },
-            model: fakeModel,
-            updatedAttribute: { name: 'attrUidUnique', value: 'non-unique-uid' },
-            entity: null,
-          },
-          { isDraft: false }
-        )
-      );
-
-      expect(await validator('properly.formated-uid')).toBe('properly.formated-uid');
-    });
-  });
-});

package/lib/services/metrics/__tests__/admin-user-hash.test.js

@@ -1,41 +0,0 @@
-'use strict';
-
-const crypto = require('crypto');
-const { generateAdminUserHash } = require('../admin-user-hash');
-const createContext = require('../../../../../../../test/helpers/create-context');
-
-describe('user email hash', () => {
-  test('should create a hash from admin user email', () => {
-    const state = {
-      user: {
-        email: 'testemail@strapi.io',
-      },
-    };
-
-    const ctx = createContext({}, { state });
-
-    const strapi = {
-      requestContext: {
-        get: jest.fn(() => ctx),
-      },
-    };
-
-    const hash = crypto.createHash('sha256').update('testemail@strapi.io').digest('hex');
-
-    const userId = generateAdminUserHash(strapi);
-    expect(userId).toBe(hash);
-  });
-
-  test('should return empty string if user is not available on ctx', () => {
-    const ctx = createContext({}, {});
-
-    const strapi = {
-      requestContext: {
-        get: jest.fn(() => ctx),
-      },
-    };
-
-    const userId = generateAdminUserHash(strapi);
-    expect(userId).toBe('');
-  });
-});

package/lib/services/metrics/__tests__/index.test.js

@@ -1,157 +0,0 @@
-'use strict';
-
-jest.mock('node-fetch', () => jest.fn(() => Promise.resolve()));
-
-const { get } = require('lodash/fp');
-const metrics = require('../index');
-
-const fetch = jest.fn(() => Promise.resolve());
-
-describe('metrics', () => {
-  beforeEach(() => {
-    fetch.mockClear();
-  });
-  test('Initializes a middleware', () => {
-    const use = jest.fn();
-
-    const metricsInstance = metrics({
-      config: {
-        get(path) {
-          return get(path, this);
-        },
-        uuid: 'test',
-        environment: 'dev',
-        info: {
-          strapi: '0.0.0',
-        },
-      },
-      server: {
-        use,
-      },
-      dirs: {
-        app: {
-          root: process.cwd(),
-        },
-      },
-      requestContext: {
-        get: jest.fn(() => ({})),
-      },
-      fetch,
-    });
-
-    metricsInstance.register();
-
-    expect(use).toHaveBeenCalled();
-
-    metricsInstance.destroy();
-  });
-
-  test('Does not init middleware if disabled', () => {
-    const use = jest.fn();
-
-    const metricsInstance = metrics({
-      config: {
-        get(path) {
-          return get(path, this);
-        },
-        uuid: false,
-        environment: 'dev',
-        info: {
-          strapi: '0.0.0',
-        },
-      },
-      server: {
-        use,
-      },
-      dirs: {
-        app: {
-          root: process.cwd(),
-        },
-      },
-      requestContext: {
-        get: jest.fn(() => ({})),
-      },
-      fetch,
-    });
-
-    metricsInstance.register();
-
-    expect(use).not.toHaveBeenCalled();
-
-    metricsInstance.destroy();
-  });
-
-  test('Send payload with meta', () => {
-    const { send } = metrics({
-      config: {
-        get(path) {
-          return get(path, this);
-        },
-        uuid: 'test',
-        environment: 'dev',
-        info: {
-          strapi: '0.0.0',
-        },
-      },
-      server: {
-        use() {},
-      },
-      dirs: {
-        app: {
-          root: process.cwd(),
-        },
-      },
-      requestContext: {
-        get: jest.fn(() => ({})),
-      },
-      fetch,
-    });
-
-    send('someEvent');
-
-    expect(fetch).toHaveBeenCalled();
-    expect(fetch.mock.calls[0][0]).toBe('https://analytics.strapi.io/api/v2/track');
-    expect(fetch.mock.calls[0][1].method).toBe('POST');
-    expect(JSON.parse(fetch.mock.calls[0][1].body)).toMatchObject({
-      event: 'someEvent',
-      groupProperties: {
-        projectType: 'Community',
-        projectId: 'test',
-      },
-    });
-
-    fetch.mockClear();
-  });
-
-  test('Does not send payload when disabled', () => {
-    const { send } = metrics({
-      config: {
-        get(path) {
-          return get(path, this);
-        },
-        uuid: false,
-        packageJsonStrapi: {},
-        environment: 'dev',
-        info: {
-          strapi: '0.0.0',
-        },
-      },
-      server: {
-        use() {},
-      },
-      dirs: {
-        app: {
-          root: process.cwd(),
-        },
-      },
-      requestContext: {
-        get: jest.fn(() => ({})),
-      },
-      fetch,
-    });
-
-    send('someEvent');
-
-    expect(fetch).not.toHaveBeenCalled();
-  });
-});

package/lib/services/metrics/__tests__/is-truthy.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const isTruthyEnvVar = require('../is-truthy');
-
-describe('isTruthyEnvVar', () => {
-  test('Handles boolean strings', () => {
-    expect(isTruthyEnvVar('true')).toBe(true);
-
-    expect(isTruthyEnvVar('false')).toBe(false);
-  });
-
-  test('Handle numbers', () => {
-    expect(isTruthyEnvVar(1)).toBe(true);
-
-    expect(isTruthyEnvVar(-1)).toBe(false);
-    expect(isTruthyEnvVar(0)).toBe(false);
-    expect(isTruthyEnvVar(2)).toBe(false);
-  });
-
-  test('Handles default booleans', () => {
-    expect(isTruthyEnvVar(true)).toBe(true);
-    expect(isTruthyEnvVar(false)).toBe(false);
-  });
-
-  test('Handles all the other values', () => {
-    expect(isTruthyEnvVar(null)).toBe(false);
-    expect(isTruthyEnvVar(undefined)).toBe(false);
-    expect(isTruthyEnvVar({})).toBe(false);
-    expect(isTruthyEnvVar([])).toBe(false);
-    expect(isTruthyEnvVar(new Date())).toBe(false);
-    expect(isTruthyEnvVar('some text')).toBe(false);
-  });
-});