@strapi/strapi 4.10.0 → 4.10.1

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

@@ -0,0 +1,220 @@
+'use strict';
+
+const strapiUtils = require('@strapi/utils');
+const {
+  errors: { YupValidationError },
+} = require('@strapi/utils');
+const validators = require('../validators');
+
+describe('BigInteger 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: {
+        attrBigIntegerUnique: { type: 'biginteger', unique: true },
+      },
+    };
+
+    test('it does not validate the unique constraint if the attribute is not set as unique', async () => {
+      fakeFindOne.mockResolvedValueOnce(null);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.biginteger(
+          {
+            attr: { type: 'biginteger' },
+            model: fakeModel,
+            updatedAttribute: {
+              name: 'attrBigIntegerUnique',
+              value: 1,
+            },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator(1);
+
+      expect(fakeFindOne).not.toHaveBeenCalled();
+    });
+
+    test('it does not validate the unique constraint if the attribute value is `null`', async () => {
+      fakeFindOne.mockResolvedValueOnce(null);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators
+          .biginteger(
+            {
+              attr: { type: 'biginteger', unique: true },
+              model: fakeModel,
+              updatedAttribute: {
+                name: 'attrBigIntegerUnique',
+                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.biginteger(
+          {
+            attr: { type: 'biginteger', unique: true },
+            model: fakeModel,
+            updatedAttribute: {
+              name: 'attrBigIntegerUnique',
+              value: 1,
+            },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator(1)).toBe(1);
+    });
+
+    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({ attrBigIntegerUnique: 2 });
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.biginteger(
+          {
+            attr: { type: 'biginteger', unique: true },
+            model: fakeModel,
+            updatedAttribute: {
+              name: 'attrBigIntegerUnique',
+              value: 2,
+            },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      try {
+        await validator(2);
+      } 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({ attrBigIntegerUnique: 3 });
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.biginteger(
+          {
+            attr: { type: 'biginteger', unique: true },
+            model: fakeModel,
+            updatedAttribute: {
+              name: 'attrBigIntegerUnique',
+              value: 3,
+            },
+            entity: { id: 1, attrBigIntegerUnique: 3 },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator(3)).toBe(3);
+    });
+
+    test('it checks the database for records with the same value for the checked attribute', async () => {
+      fakeFindOne.mockResolvedValueOnce(null);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.biginteger(
+          {
+            attr: { type: 'biginteger', unique: true },
+            model: fakeModel,
+            updatedAttribute: {
+              name: 'attrBigIntegerUnique',
+              value: 4,
+            },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator(4);
+
+      expect(fakeFindOne).toHaveBeenCalledWith({
+        select: ['id'],
+        where: { attrBigIntegerUnique: 4 },
+      });
+    });
+
+    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.biginteger(
+          {
+            attr: { type: 'biginteger', unique: true },
+            model: fakeModel,
+            updatedAttribute: {
+              name: 'attrBigIntegerUnique',
+              value: 5,
+            },
+            entity: { id: 1, attrBigIntegerUnique: 42 },
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator(5);
+
+      expect(fakeFindOne).toHaveBeenCalledWith({
+        select: ['id'],
+        where: { $and: [{ attrBigIntegerUnique: 5 }, { $not: { id: 1 } }] },
+      });
+    });
+  });
+
+  describe('min', () => {
+    test('it does not validate the min constraint if the attribute min is not a number', async () => {
+      const validator = strapiUtils.validateYupSchema(
+        validators.biginteger(
+          {
+            attr: { type: 'biginteger', minLength: '123' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator(1)).toBe(1);
+    });
+  });
+});

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

@@ -0,0 +1,183 @@
+'use strict';
+
+const strapiUtils = require('@strapi/utils');
+const {
+  errors: { YupValidationError },
+} = require('@strapi/utils');
+const validators = require('../validators');
+
+describe('Date 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: {
+        attrDateUnique: { type: 'date', 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.date(
+          {
+            attr: { type: 'date' },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateUnique', value: '2021-11-29' },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator('2021-11-29');
+
+      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
+          .date(
+            {
+              attr: { type: 'date', unique: true },
+              model: fakeModel,
+              updatedAttribute: { name: 'attrDateUnique', 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.date(
+          {
+            attr: { type: 'date', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateUnique', value: '2021-11-29' },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator('2021-11-29')).toBe('2021-11-29');
+    });
+
+    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({ attrDateUnique: '2021-11-29' });
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.date(
+          {
+            attr: { type: 'date', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateUnique', value: '2021-11-29' },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      try {
+        await validator('2021-11-29');
+      } 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({ attrDateUnique: '2021-11-29' });
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.date(
+          {
+            attr: { type: 'date', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateUnique', value: '2021-11-29' },
+            entity: { id: 1, attrDateUnique: '2021-11-29' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator('2021-11-29')).toBe('2021-11-29');
+    });
+
+    test('it checks the database for records with the same value for the checked attribute', async () => {
+      fakeFindOne.mockResolvedValueOnce(null);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.date(
+          {
+            attr: { type: 'date', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateUnique', value: '2021-11-29' },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator('2021-11-29');
+
+      expect(fakeFindOne).toHaveBeenCalledWith({
+        select: ['id'],
+        where: { attrDateUnique: '2021-11-29' },
+      });
+    });
+
+    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.date(
+          {
+            attr: { type: 'date', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateUnique', value: '2021-11-29' },
+            entity: { id: 1, attrDateUnique: '2021-12-15' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator('2021-11-29');
+
+      expect(fakeFindOne).toHaveBeenCalledWith({
+        select: ['id'],
+        where: { $and: [{ attrDateUnique: '2021-11-29' }, { $not: { id: 1 } }] },
+      });
+    });
+  });
+});

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

@@ -0,0 +1,183 @@
+'use strict';
+
+const strapiUtils = require('@strapi/utils');
+const {
+  errors: { YupValidationError },
+} = require('@strapi/utils');
+const validators = require('../validators');
+
+describe('Datetime 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: {
+        attrDateTimeUnique: { type: 'datetime', 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.datetime(
+          {
+            attr: { type: 'datetime' },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateTimeUnique', value: '2021-11-29T00:00:00.000Z' },
+            entity: { id: 1, attrDateTimeUnique: '2021-11-29T00:00:00.000Z' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator('2021-11-29T00:00:00.000Z');
+
+      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
+          .datetime(
+            {
+              attr: { type: 'datetime', unique: true },
+              model: fakeModel,
+              updatedAttribute: { name: 'attrDateTimeUnique', 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.datetime(
+          {
+            attr: { type: 'datetime', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateTimeUnique', value: '2021-11-29T00:00:00.000Z' },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator('2021-11-29T00:00:00.000Z')).toBe('2021-11-29T00:00:00.000Z');
+    });
+
+    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({ attrDateTimeUnique: '2021-11-29T00:00:00.000Z' });
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.datetime(
+          {
+            attr: { type: 'datetime', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateTimeUnique', value: '2021-11-29T00:00:00.000Z' },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      try {
+        await validator('2021-11-29T00:00:00.000Z');
+      } 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({ attrDateTimeUnique: '2021-11-29T00:00:00.000Z' });
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.datetime(
+          {
+            attr: { type: 'datetime', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateTimeUnique', value: '2021-11-29T00:00:00.000Z' },
+            entity: { id: 1, attrDateTimeUnique: '2021-11-29T00:00:00.000Z' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator('2021-11-29T00:00:00.000Z')).toBe('2021-11-29T00:00:00.000Z');
+    });
+
+    test('it checks the database for records with the same value for the checked attribute', async () => {
+      fakeFindOne.mockResolvedValueOnce(null);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.datetime(
+          {
+            attr: { type: 'datetime', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateTimeUnique', value: '2021-11-29T00:00:00.000Z' },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator('2021-11-29T00:00:00.000Z');
+
+      expect(fakeFindOne).toHaveBeenCalledWith({
+        select: ['id'],
+        where: { attrDateTimeUnique: '2021-11-29T00:00:00.000Z' },
+      });
+    });
+
+    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.datetime(
+          {
+            attr: { type: 'datetime', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrDateTimeUnique', value: '2021-11-29T00:00:00.000Z' },
+            entity: { id: 1, attrDateTimeUnique: '2021-12-25T00:00:00.000Z' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator('2021-11-29T00:00:00.000Z');
+
+      expect(fakeFindOne).toHaveBeenCalledWith({
+        select: ['id'],
+        where: { $and: [{ attrDateTimeUnique: '2021-11-29T00:00:00.000Z' }, { $not: { id: 1 } }] },
+      });
+    });
+  });
+});

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

@@ -0,0 +1,56 @@
+'use strict';
+
+const strapiUtils = require('@strapi/utils');
+const {
+  errors: { YupValidationError },
+} = require('@strapi/utils');
+const validators = require('../validators');
+
+describe('Email validator', () => {
+  describe('email', () => {
+    test('it fails the validation if the string is not a valid email', async () => {
+      expect.assertions(1);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.email(
+          {
+            attr: { type: 'email' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      try {
+        await validator('invalid-email');
+      } catch (err) {
+        expect(err).toBeInstanceOf(YupValidationError);
+      }
+    });
+
+    test('it validates the email if it is valid', async () => {
+      const validator = strapiUtils.validateYupSchema(
+        validators.email(
+          {
+            attr: { type: 'email' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator('valid@email.com')).toBe('valid@email.com');
+    });
+
+    test('it validates non-empty email required field', async () => {
+      const validator = strapiUtils.validateYupSchema(
+        validators.email({ attr: { type: 'email' } }, { isDraft: false })
+      );
+
+      try {
+        await validator('');
+      } catch (err) {
+        expect(err).toBeInstanceOf(YupValidationError);
+        expect(err.message).toBe('this cannot be empty');
+      }
+    });
+  });
+});

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

@@ -0,0 +1,43 @@
+'use strict';
+
+const strapiUtils = require('@strapi/utils');
+const {
+  errors: { YupValidationError },
+} = require('@strapi/utils');
+const validators = require('../validators');
+
+describe('Enumeration validator', () => {
+  describe('oneOf', () => {
+    test('it fails the validation if the value is not part of the allowed values', async () => {
+      expect.assertions(1);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.enumeration(
+          {
+            attr: { type: 'enum', enum: ['strapi', 'headless'] },
+          },
+          { isDraft: false }
+        )
+      );
+
+      try {
+        await validator('invalid-vlue');
+      } catch (err) {
+        expect(err).toBeInstanceOf(YupValidationError);
+      }
+    });
+
+    test('it validates the value if it is part of the allowed values', async () => {
+      const validator = strapiUtils.validateYupSchema(
+        validators.enumeration(
+          {
+            attr: { type: 'enumeration', enum: ['strapi', 'headless'] },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator('strapi')).toBe('strapi');
+    });
+  });
+});