@strapi/strapi 4.10.0 → 4.10.1

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

@@ -0,0 +1,204 @@
+'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

@@ -0,0 +1,229 @@
+'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

@@ -0,0 +1,41 @@
+'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

@@ -0,0 +1,157 @@
+'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

@@ -0,0 +1,33 @@
+'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);
+  });
+});