@strapi/strapi 4.10.0 → 4.10.1

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

@@ -0,0 +1,159 @@
+'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 Dynamic Zone level.
+ */
+describe('Entity validator | Relations | Dynamic Zone', () => {
+  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',
+        {
+          DZ: [
+            {
+              __component: 'basic.dev-compo',
+              categories: {
+                disconnect: [],
+                connect: existentIDs.slice(-3).map((id) => ({
+                  id,
+                })),
+              },
+            },
+          ],
+        },
+      ],
+      [
+        'Set',
+        {
+          DZ: [
+            {
+              __component: 'basic.dev-compo',
+              categories: {
+                set: existentIDs.slice(-3).map((id) => ({
+                  id,
+                })),
+              },
+            },
+          ],
+        },
+      ],
+      [
+        'Number',
+        {
+          DZ: [
+            {
+              __component: 'basic.dev-compo',
+              categories: existentIDs[0],
+            },
+          ],
+        },
+      ],
+      [
+        'Array',
+        {
+          DZ: [
+            {
+              __component: 'basic.dev-compo',
+              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(
+      `2 relation(s) of type api::category.category associated with this entity do not exist`
+    );
+    const testData = [
+      [
+        'Connect',
+        {
+          DZ: [
+            {
+              __component: 'basic.dev-compo',
+              categories: {
+                disconnect: [],
+                connect: [existentIDs[0], ...nonExistentIds.slice(-2)].map((id) => ({
+                  id,
+                })),
+              },
+            },
+          ],
+        },
+      ],
+      [
+        'Set',
+        {
+          DZ: [
+            {
+              __component: 'basic.dev-compo',
+              categories: {
+                set: [existentIDs[0], ...nonExistentIds.slice(-2)].map((id) => ({
+                  id,
+                })),
+              },
+            },
+          ],
+        },
+      ],
+      [
+        'Array',
+        {
+          DZ: [
+            {
+              __component: 'basic.dev-compo',
+              categories: [existentIDs[0], ...nonExistentIds.slice(-2)].map((id) => ({
+                id,
+              })),
+            },
+          ],
+        },
+      ],
+    ];
+
+    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);
+    });
+  });
+});

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

@@ -0,0 +1,74 @@
+'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 Media level.
+ */
+describe('Entity validator | Relations | Media', () => {
+  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),
+  };
+
+  it('Success', async () => {
+    global.strapi = strapi;
+    const input = {
+      media: [
+        {
+          id: existentIDs[0],
+          name: 'img.jpeg',
+        },
+      ],
+    };
+
+    const res = entityValidator.validateEntityCreation(models.get('api::dev.dev'), input, {
+      isDraft: true,
+    });
+    await expect(res).resolves.not.toThrowError();
+  });
+
+  it('Error', async () => {
+    global.strapi = strapi;
+    const expectedError = new ValidationError(
+      `1 relation(s) of type plugin::upload.file associated with this entity do not exist`
+    );
+    const input = {
+      media: [
+        {
+          id: nonExistentIds[0],
+          name: 'img.jpeg',
+        },
+        {
+          id: existentIDs[0],
+          name: 'img.jpeg',
+        },
+      ],
+    };
+
+    const res = entityValidator.validateEntityCreation(models.get('api::dev.dev'), input, {
+      isDraft: true,
+    });
+    await expect(res).rejects.toThrowError(expectedError);
+  });
+});

package/lib/services/entity-validator/__tests__/relations/utils/relations.testdata.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const models = new Map();
+models.set('api::dev.dev', {
+  kind: 'collectionType',
+  collectionName: 'devs',
+  modelType: 'contentType',
+  modelName: 'dev',
+  connection: 'default',
+  uid: 'api::dev.dev',
+  apiName: 'dev',
+  globalId: 'Dev',
+  info: {
+    singularName: 'dev',
+    pluralName: 'devs',
+    displayName: 'Dev',
+    description: '',
+  },
+  attributes: {
+    categories: {
+      type: 'relation',
+      relation: 'manyToMany',
+      target: 'api::category.category',
+      inversedBy: 'devs',
+    },
+    sCom: {
+      type: 'component',
+      repeatable: false,
+      component: 'basic.dev-compo',
+    },
+    rCom: {
+      type: 'component',
+      repeatable: true,
+      component: 'basic.dev-compo',
+    },
+    DZ: {
+      type: 'dynamiczone',
+      components: ['basic.dev-compo'],
+    },
+    media: {
+      allowedTypes: ['images', 'files', 'videos', 'audios'],
+      type: 'media',
+      multiple: true,
+    },
+    createdAt: {
+      type: 'datetime',
+    },
+    updatedAt: {
+      type: 'datetime',
+    },
+    publishedAt: {
+      type: 'datetime',
+      configurable: false,
+      writable: true,
+      visible: false,
+    },
+    createdBy: {
+      type: 'relation',
+      relation: 'oneToOne',
+      target: 'admin::user',
+      configurable: false,
+      writable: false,
+      visible: false,
+      useJoinTable: false,
+      private: true,
+    },
+    updatedBy: {
+      type: 'relation',
+      relation: 'oneToOne',
+      target: 'admin::user',
+      configurable: false,
+      writable: false,
+      visible: false,
+      useJoinTable: false,
+      private: true,
+    },
+  },
+});
+models.set('api::category.category', {
+  kind: 'collectionType',
+  collectionName: 'categories',
+  modelType: 'contentType',
+  modelName: 'category',
+  connection: 'default',
+  uid: 'api::category.category',
+  apiName: 'category',
+  globalId: 'Category',
+  info: {
+    displayName: 'Category',
+    singularName: 'category',
+    pluralName: 'categories',
+    description: '',
+    name: 'Category',
+  },
+  attributes: {
+    name: {
+      type: 'string',
+      pluginOptions: {
+        i18n: {
+          localized: true,
+        },
+      },
+    },
+  },
+});
+models.set('basic.dev-compo', {
+  collectionName: 'components_basic_dev_compos',
+  uid: 'basic.dev-compo',
+  category: 'basic',
+  modelType: 'component',
+  modelName: 'dev-compo',
+  globalId: 'ComponentBasicDevCompo',
+  info: {
+    displayName: 'DevCompo',
+    icon: 'allergies',
+  },
+  attributes: {
+    categories: {
+      type: 'relation',
+      relation: 'oneToMany',
+      target: 'api::category.category',
+    },
+  },
+});
+models.set('plugin::upload.file', {
+  collectionName: 'files',
+  info: {
+    singularName: 'file',
+    pluralName: 'files',
+    displayName: 'File',
+    description: '',
+  },
+  attributes: {
+    name: {
+      type: 'string',
+      configurable: false,
+      required: true,
+    },
+  },
+  kind: 'collectionType',
+  modelType: 'contentType',
+  modelName: 'file',
+  connection: 'default',
+  uid: 'plugin::upload.file',
+  plugin: 'upload',
+  globalId: 'UploadFile',
+});
+
+module.exports = {
+  models,
+  existentIDs: [1, 2, 3, 4, 5, 6],
+  nonExistentIds: [10, 11, 12, 13, 14, 15, 16],
+};