@strapi/strapi 4.10.0 → 4.10.1-experimental.0

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

@@ -0,0 +1,278 @@
+'use strict';
+
+const strapiUtils = require('@strapi/utils');
+const {
+  errors: { YupValidationError },
+} = require('@strapi/utils');
+const validators = require('../validators');
+
+describe('Integer validator', () => {
+  describe('unique', () => {
+    const fakeFindOne = jest.fn();
+
+    global.strapi = {
+      db: {
+        query: jest.fn(() => ({
+          findOne: fakeFindOne,
+        })),
+      },
+    };
+
+    afterEach(() => {
+      jest.clearAllMocks();
+      fakeFindOne.mockReset();
+    });
+
+    const fakeModel = {
+      kind: 'contentType',
+      uid: 'test-uid',
+      modelName: 'test-model',
+      privateAttributes: [],
+      options: {},
+      attributes: {
+        attrIntegerUnique: { type: 'integer', 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.integer(
+          {
+            attr: { type: 'integer' },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrIntegerUnique', value: 1 },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator(1);
+
+      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
+          .integer(
+            {
+              attr: { type: 'integer', unique: true },
+              model: fakeModel,
+              updatedAttribute: { name: 'attrIntegerUnique', 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.integer(
+          {
+            attr: { type: 'integer', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrIntegerUnique', value: 2 },
+            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({ attrIntegerUnique: 2 });
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.integer(
+          {
+            attr: { type: 'integer', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrIntegerUnique', 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({ attrIntegerUnique: 3 });
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.integer(
+          {
+            attr: { type: 'integer', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrIntegerUnique', value: 3 },
+            entity: { id: 1, attrIntegerUnique: 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.integer(
+          {
+            attr: { type: 'integer', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrIntegerUnique', value: 4 },
+            entity: null,
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator(4);
+
+      expect(fakeFindOne).toHaveBeenCalledWith({
+        select: ['id'],
+        where: { attrIntegerUnique: 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.integer(
+          {
+            attr: { type: 'integer', unique: true },
+            model: fakeModel,
+            updatedAttribute: { name: 'attrIntegerUnique', value: 5 },
+            entity: { id: 1, attrIntegerUnique: 42 },
+          },
+          { isDraft: false }
+        )
+      );
+
+      await validator(5);
+
+      expect(fakeFindOne).toHaveBeenCalledWith({
+        select: ['id'],
+        where: { $and: [{ attrIntegerUnique: 5 }, { $not: { id: 1 } }] },
+      });
+    });
+  });
+
+  describe('min', () => {
+    test('it does not validates the min constraint if the attribute min is not a number', async () => {
+      const validator = strapiUtils.validateYupSchema(
+        validators.integer(
+          {
+            attr: { type: 'integer', minLength: '123' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator(1)).toBe(1);
+    });
+
+    test('it fails the validation if the integer is lower than the define min', async () => {
+      expect.assertions(1);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.integer(
+          {
+            attr: { type: 'integer', min: 3 },
+          },
+          { isDraft: false }
+        )
+      );
+
+      try {
+        await validator(1);
+      } catch (err) {
+        expect(err).toBeInstanceOf(YupValidationError);
+      }
+    });
+
+    test('it validates the min constraint if the integer is higher than the define min', async () => {
+      const validator = strapiUtils.validateYupSchema(
+        validators.integer(
+          {
+            attr: { type: 'integer', min: 3 },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator(4)).toBe(4);
+    });
+  });
+
+  describe('max', () => {
+    test('it does not validates the max constraint if the attribute max is not an integer', async () => {
+      const validator = strapiUtils.validateYupSchema(
+        validators.integer(
+          {
+            attr: { type: 'integer', maxLength: '123' },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator(1)).toBe(1);
+    });
+
+    test('it fails the validation if the number is integer than the define max', async () => {
+      expect.assertions(1);
+
+      const validator = strapiUtils.validateYupSchema(
+        validators.integer(
+          {
+            attr: { type: 'integer', max: 3 },
+          },
+          { isDraft: false }
+        )
+      );
+
+      try {
+        await validator(4);
+      } catch (err) {
+        expect(err).toBeInstanceOf(YupValidationError);
+      }
+    });
+
+    test('it validates the max constraint if the integer is lower than the define max', async () => {
+      const validator = strapiUtils.validateYupSchema(
+        validators.integer(
+          {
+            attr: { type: 'integer', max: 3 },
+          },
+          { isDraft: false }
+        )
+      );
+
+      expect(await validator(2)).toBe(2);
+    });
+  });
+});

package/lib/services/entity-validator/__tests__/relations/attribute-level.test.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const { ValidationError } = require('@strapi/utils').errors;
+
+const entityValidator = require('../..');
+const { models, existentIDs, nonExistentIds } = require('./utils/relations.testdata');
+
+/**
+ * Test that relations can be successfully validated and non existent relations
+ * can be detected at the Attribute level.
+ */
+describe('Entity validator | Relations | Attribute', () => {
+  const strapi = {
+    components: {
+      'basic.dev-compo': {},
+    },
+    db: {
+      query() {
+        return {
+          count: ({
+            where: {
+              id: { $in },
+            },
+          }) => existentIDs.filter((value) => $in.includes(value)).length,
+        };
+      },
+    },
+    errors: {
+      badRequest: jest.fn(),
+    },
+    getModel: (uid) => models.get(uid),
+  };
+
+  describe('Success', () => {
+    const testData = [
+      [
+        'Connect',
+        {
+          categories: {
+            disconnect: [],
+            connect: [
+              {
+                id: existentIDs[0],
+              },
+            ],
+          },
+        },
+      ],
+      [
+        'Set',
+        {
+          categories: {
+            set: [
+              {
+                id: existentIDs[0],
+              },
+            ],
+          },
+        },
+      ],
+      [
+        'Number',
+        {
+          categories: existentIDs[0],
+        },
+      ],
+      [
+        'Array',
+        {
+          categories: existentIDs.slice(-Math.floor(existentIDs.length / 2)),
+        },
+      ],
+    ];
+    test.each(testData)('%s', async (__, input = {}) => {
+      global.strapi = strapi;
+      const res = entityValidator.validateEntityCreation(models.get('api::dev.dev'), input, {
+        isDraft: true,
+      });
+      await expect(res).resolves.not.toThrowError();
+    });
+  });
+
+  describe('Error', () => {
+    const expectError = new ValidationError(
+      `2 relation(s) of type api::category.category associated with this entity do not exist`
+    );
+    const testData = [
+      [
+        'Connect',
+        {
+          categories: {
+            disconnect: [],
+            connect: [existentIDs[0], ...nonExistentIds.slice(-2)].map((id) => ({
+              id,
+            })),
+          },
+        },
+      ],
+      [
+        'Set',
+        {
+          categories: {
+            set: [existentIDs[0], ...nonExistentIds.slice(-2)].map((id) => ({ id })),
+          },
+        },
+      ],
+      [
+        'Number',
+        {
+          categories: nonExistentIds.slice(-2),
+        },
+      ],
+    ];
+
+    test.each(testData)('%s', async (__, input = {}) => {
+      global.strapi = strapi;
+      const res = entityValidator.validateEntityCreation(models.get('api::dev.dev'), input, {
+        isDraft: true,
+      });
+      await expect(res).rejects.toThrowError(expectError);
+    });
+  });
+});

package/lib/services/entity-validator/__tests__/relations/component-level.test.js

@@ -0,0 +1,275 @@
+'use strict';
+
+const { ValidationError } = require('@strapi/utils').errors;
+
+const entityValidator = require('../..');
+const { models, nonExistentIds, existentIDs } = require('./utils/relations.testdata');
+
+/**
+ * Test that relations can be successfully validated and non existent relations
+ * can be detected at the Component level.
+ */
+describe('Entity validator | Relations | Component Level', () => {
+  const strapi = {
+    components: {
+      'basic.dev-compo': {},
+    },
+    db: {
+      query() {
+        return {
+          count: ({
+            where: {
+              id: { $in },
+            },
+          }) => existentIDs.filter((value) => $in.includes(value)).length,
+        };
+      },
+    },
+    errors: {
+      badRequest: jest.fn(),
+    },
+    getModel: (uid) => models.get(uid),
+  };
+
+  describe('Single Component', () => {
+    describe('Success', () => {
+      const testData = [
+        [
+          'Connect',
+          {
+            sCom: {
+              categories: {
+                disconnect: [],
+                connect: [
+                  {
+                    id: existentIDs[0],
+                  },
+                ],
+              },
+            },
+          },
+        ],
+        [
+          'Set',
+          {
+            sCom: {
+              categories: {
+                set: [
+                  {
+                    id: existentIDs[0],
+                  },
+                ],
+              },
+            },
+          },
+        ],
+        [
+          'Number',
+          {
+            sCom: {
+              categories: existentIDs[0],
+            },
+          },
+        ],
+        [
+          'Array',
+          {
+            sCom: {
+              categories: existentIDs.slice(-3),
+            },
+          },
+        ],
+      ];
+
+      test.each(testData)('%s', async (__, input = {}) => {
+        global.strapi = strapi;
+        const res = entityValidator.validateEntityCreation(models.get('api::dev.dev'), input, {
+          isDraft: true,
+        });
+        await expect(res).resolves.not.toThrowError();
+      });
+    });
+
+    describe('Error', () => {
+      const expectedError = new ValidationError(
+        `1 relation(s) of type api::category.category associated with this entity do not exist`
+      );
+      const testData = [
+        [
+          'Connect',
+          {
+            sCom: {
+              categories: {
+                disconnect: [],
+                connect: [
+                  {
+                    id: nonExistentIds[0],
+                  },
+                ],
+              },
+            },
+          },
+        ],
+        [
+          'Set',
+          {
+            sCom: {
+              categories: {
+                set: [
+                  {
+                    id: nonExistentIds[0],
+                  },
+                ],
+              },
+            },
+          },
+        ],
+        [
+          'Number',
+          {
+            sCom: {
+              categories: nonExistentIds[0],
+            },
+          },
+        ],
+        [
+          'Array',
+          {
+            sCom: {
+              categories: [nonExistentIds[0]],
+            },
+          },
+        ],
+      ];
+
+      test.each(testData)('%s', async (__, input = {}) => {
+        global.strapi = strapi;
+        const res = entityValidator.validateEntityCreation(models.get('api::dev.dev'), input, {
+          isDraft: true,
+        });
+        await expect(res).rejects.toThrowError(expectedError);
+      });
+    });
+  });
+
+  describe('Repeatable Component', () => {
+    describe('Success', () => {
+      const testData = [
+        [
+          'Connect',
+          {
+            rCom: [
+              {
+                categories: {
+                  disconnect: [],
+                  connect: [
+                    {
+                      id: existentIDs[0],
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        ],
+        [
+          'Set',
+          {
+            rCom: [
+              {
+                categories: {
+                  set: existentIDs.slice(-Math.floor(existentIDs.length / 2)).map((id) => ({
+                    id,
+                  })),
+                },
+              },
+            ],
+          },
+        ],
+        [
+          'Number',
+          {
+            rCom: [
+              {
+                categories: existentIDs[0],
+              },
+            ],
+          },
+        ],
+        [
+          'Array',
+          {
+            rCom: [
+              {
+                categories: existentIDs.slice(-Math.floor(existentIDs.length / 2)),
+              },
+            ],
+          },
+        ],
+      ];
+
+      test.each(testData)('%s', async (__, input = {}) => {
+        global.strapi = strapi;
+        const res = entityValidator.validateEntityCreation(models.get('api::dev.dev'), input, {
+          isDraft: true,
+        });
+        await expect(res).resolves.not.toThrowError();
+      });
+    });
+
+    describe('Error', () => {
+      const expectedError = new ValidationError(
+        `4 relation(s) of type api::category.category associated with this entity do not exist`
+      );
+      const testData = [
+        [
+          'Connect',
+          {
+            rCom: [
+              {
+                categories: {
+                  disconnect: [],
+                  connect: [existentIDs[0], ...nonExistentIds.slice(-4)].map((id) => ({
+                    id,
+                  })),
+                },
+              },
+            ],
+          },
+        ],
+        [
+          'Set',
+          {
+            rCom: [
+              {
+                categories: {
+                  set: [existentIDs[0], ...nonExistentIds.slice(-4)].map((id) => ({
+                    id,
+                  })),
+                },
+              },
+            ],
+          },
+        ],
+        [
+          'Array',
+          {
+            rCom: [
+              {
+                categories: nonExistentIds.slice(-4),
+              },
+            ],
+          },
+        ],
+      ];
+
+      test.each(testData)('%s', async (__, input = {}) => {
+        global.strapi = strapi;
+        const res = entityValidator.validateEntityCreation(models.get('api::dev.dev'), input, {
+          isDraft: true,
+        });
+        await expect(res).rejects.toThrowError(expectedError);
+      });
+    });
+  });
+});