@strapi/strapi 4.10.1-experimental.0 → 4.10.2-alpha.0

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

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

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

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