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

package/lib/core/registries/__tests__/custom-fields.test.js

@@ -1,152 +0,0 @@
-'use strict';
-
-const customFieldsRegistry = require('../custom-fields');
-
-const strapi = {
-  plugins: { plugintest: 'foo' },
-  plugin: jest.fn((plugin) => strapi.plugins[plugin]),
-};
-
-describe('Custom fields registry', () => {
-  describe('add', () => {
-    it('adds a custom field registered in a plugin', () => {
-      const mockCF = {
-        name: 'test',
-        plugin: 'plugintest',
-        type: 'text',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-      customFields.add(mockCF);
-
-      const expected = {
-        'plugin::plugintest.test': mockCF,
-      };
-      expect(customFields.getAll()).toEqual(expected);
-    });
-
-    it('adds a custom field not registered in a plugin', () => {
-      const mockCF = {
-        name: 'test',
-        type: 'text',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-      customFields.add(mockCF);
-
-      const expected = {
-        'global::test': mockCF,
-      };
-      expect(customFields.getAll()).toEqual(expected);
-    });
-
-    it('requires a name key on the custom field', () => {
-      const mockCF = {
-        type: 'test',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-
-      expect(() => customFields.add(mockCF)).toThrowError(
-        `Custom fields require a 'name' and 'type' key`
-      );
-    });
-
-    it('requires a type key on the custom field', () => {
-      const mockCF = {
-        name: 'test',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-
-      expect(() => customFields.add(mockCF)).toThrowError(
-        `Custom fields require a 'name' and 'type' key`
-      );
-    });
-
-    it('validates the name can be used as an object key', () => {
-      const mockCF = {
-        name: 'test.boom',
-        type: 'text',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-
-      expect(() => customFields.add(mockCF)).toThrowError(
-        `Custom field name: 'test.boom' is not a valid object key`
-      );
-    });
-
-    it('validates the type is a Strapi type', () => {
-      const mockCF = {
-        name: 'test',
-        type: 'geojson',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-
-      expect(() => customFields.add(mockCF)).toThrowError(
-        `Custom field type: 'geojson' is not a valid Strapi type`
-      );
-    });
-
-    it('validates inputSize', () => {
-      const mockCF = {
-        name: 'test',
-        type: 'text',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-
-      expect(() => customFields.add({ ...mockCF, inputSize: 'small' })).toThrowError(
-        `inputSize should be an object with 'default' and 'isResizable' keys`
-      );
-      expect(() => customFields.add({ ...mockCF, inputSize: ['array'] })).toThrowError(
-        `inputSize should be an object with 'default' and 'isResizable' keys`
-      );
-      expect(() =>
-        customFields.add({ ...mockCF, inputSize: { default: 99, isResizable: true } })
-      ).toThrowError('Custom fields require a valid default input size');
-      expect(() =>
-        customFields.add({ ...mockCF, inputSize: { default: 12, isResizable: 'true' } })
-      ).toThrowError('Custom fields should specify if their input is resizable');
-    });
-
-    it('confirms the custom field does not already exist', () => {
-      const mockCF = {
-        name: 'test',
-        plugin: 'plugintest',
-        type: 'text',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-
-      customFields.add(mockCF);
-      expect(() => customFields.add(mockCF)).toThrowError(
-        `Custom field: 'plugin::plugintest.test' has already been registered`
-      );
-    });
-  });
-  describe('get', () => {
-    it('gets a registered custom field', () => {
-      const mockCF = {
-        name: 'test',
-        plugin: 'plugintest',
-        type: 'text',
-      };
-
-      const customFields = customFieldsRegistry(strapi);
-      customFields.add(mockCF);
-
-      expect(customFields.get('plugin::plugintest.test')).toEqual(mockCF);
-    });
-
-    it('throws when a custom field is not registered', () => {
-      const customFields = customFieldsRegistry(strapi);
-
-      expect(() => customFields.get('plugin::plugintest.test')).toThrowError(
-        `Could not find Custom Field: plugin::plugintest.test`
-      );
-    });
-  });
-});

package/lib/core-api/__tests__/controller.test.js

@@ -1,39 +0,0 @@
-'use strict';
-
-const { createController } = require('../controller');
-
-describe('Default Controller', () => {
-  test('Creates Collection Type default actions', () => {
-    const service = {};
-    const contentType = {
-      modelName: 'testModel',
-      kind: 'collectionType',
-    };
-
-    const controller = createController({ service, contentType });
-
-    expect(controller).toEqual({
-      find: expect.any(Function),
-      findOne: expect.any(Function),
-      create: expect.any(Function),
-      update: expect.any(Function),
-      delete: expect.any(Function),
-    });
-  });
-
-  test('Creates Single Type default actions', () => {
-    const service = {};
-    const contentType = {
-      modelName: 'testModel',
-      kind: 'singleType',
-    };
-
-    const controller = createController({ service, contentType });
-
-    expect(controller).toEqual({
-      find: expect.any(Function),
-      update: expect.any(Function),
-      delete: expect.any(Function),
-    });
-  });
-});

package/lib/core-api/controller/__tests__/transform.test.js

@@ -1,226 +0,0 @@
-'use strict';
-
-const transforms = require('../transform');
-
-describe('Transforms', () => {
-  test('Leaves nil values untouched', () => {
-    expect(transforms.transformResponse()).toBeUndefined();
-    expect(transforms.transformResponse(null)).toBe(null);
-  });
-
-  test('Throws if entry is not and object or an array of object', () => {
-    expect(() => transforms.transformResponse(0)).toThrow();
-    expect(() => transforms.transformResponse(new Date())).toThrow();
-    expect(() => transforms.transformResponse('azaz')).toThrow();
-  });
-
-  test('Handles arrays of entries', () => {
-    expect(transforms.transformResponse([{ id: 1, title: 'Hello' }])).toStrictEqual({
-      data: [{ id: 1, attributes: { title: 'Hello' } }],
-      meta: {},
-    });
-  });
-
-  test('Handles single entry', () => {
-    expect(transforms.transformResponse({ id: 1, title: 'Hello' })).toStrictEqual({
-      data: { id: 1, attributes: { title: 'Hello' } },
-      meta: {},
-    });
-  });
-
-  test('Accepts any meta', () => {
-    const someMeta = { foo: 'bar' };
-    expect(transforms.transformResponse({ id: 1, title: 'Hello' }, someMeta)).toStrictEqual({
-      data: { id: 1, attributes: { title: 'Hello' } },
-      meta: someMeta,
-    });
-  });
-
-  test('Handles relations single value', () => {
-    const contentType = {
-      attributes: {
-        relation: {
-          type: 'relation',
-          target: 'xxx',
-        },
-      },
-    };
-
-    global.strapi = {
-      contentType() {
-        return undefined;
-      },
-    };
-
-    expect(
-      transforms.transformResponse(
-        { id: 1, title: 'Hello', relation: { id: 1, value: 'test' } },
-        undefined,
-        { contentType }
-      )
-    ).toStrictEqual({
-      data: {
-        id: 1,
-        attributes: {
-          title: 'Hello',
-          relation: {
-            data: {
-              id: 1,
-              attributes: {
-                value: 'test',
-              },
-            },
-          },
-        },
-      },
-      meta: {},
-    });
-  });
-
-  test('Handles relations array value', () => {
-    const contentType = {
-      attributes: {
-        relation: {
-          type: 'relation',
-          target: 'xxx',
-        },
-      },
-    };
-
-    global.strapi = {
-      contentType() {
-        return undefined;
-      },
-    };
-
-    expect(
-      transforms.transformResponse(
-        { id: 1, title: 'Hello', relation: [{ id: 1, value: 'test' }] },
-        undefined,
-        { contentType }
-      )
-    ).toStrictEqual({
-      data: {
-        id: 1,
-        attributes: {
-          title: 'Hello',
-          relation: {
-            data: [
-              {
-                id: 1,
-                attributes: {
-                  value: 'test',
-                },
-              },
-            ],
-          },
-        },
-      },
-      meta: {},
-    });
-  });
-
-  test('Handles relations recursively', () => {
-    const contentType = {
-      attributes: {
-        relation: {
-          type: 'relation',
-          target: 'xxx',
-        },
-      },
-    };
-
-    global.strapi = {
-      contentType() {
-        return {
-          attributes: {
-            nestedRelation: {
-              type: 'relation',
-              target: 'xxxx',
-            },
-          },
-        };
-      },
-    };
-
-    expect(
-      transforms.transformResponse(
-        {
-          id: 1,
-          title: 'Hello',
-          relation: [{ id: 1, value: 'test', nestedRelation: { id: 2, foo: 'bar' } }],
-        },
-        undefined,
-        { contentType }
-      )
-    ).toStrictEqual({
-      data: {
-        id: 1,
-        attributes: {
-          title: 'Hello',
-          relation: {
-            data: [
-              {
-                id: 1,
-                attributes: {
-                  value: 'test',
-                  nestedRelation: {
-                    data: {
-                      id: 2,
-                      attributes: {
-                        foo: 'bar',
-                      },
-                    },
-                  },
-                },
-              },
-            ],
-          },
-        },
-      },
-      meta: {},
-    });
-  });
-
-  test('Handles media like relations', () => {
-    const contentType = {
-      attributes: {
-        media: {
-          type: 'media',
-        },
-      },
-    };
-
-    global.strapi = {
-      contentType() {
-        return undefined;
-      },
-    };
-
-    expect(
-      transforms.transformResponse(
-        { id: 1, title: 'Hello', media: [{ id: 1, value: 'test' }] },
-        undefined,
-        { contentType }
-      )
-    ).toStrictEqual({
-      data: {
-        id: 1,
-        attributes: {
-          title: 'Hello',
-          media: {
-            data: [
-              {
-                id: 1,
-                attributes: {
-                  value: 'test',
-                },
-              },
-            ],
-          },
-        },
-      },
-      meta: {},
-    });
-  });
-});

package/lib/core-api/service/__tests__/index.test.js

@@ -1,127 +0,0 @@
-'use strict';
-
-const { createService } = require('../index');
-
-describe('Default Service', () => {
-  describe('Collection Type', () => {
-    test('Creates default actions', () => {
-      const contentType = {
-        modelName: 'testModel',
-        kind: 'collectionType',
-      };
-
-      const service = createService({ contentType });
-
-      expect(service).toEqual({
-        find: expect.any(Function),
-        findOne: expect.any(Function),
-        create: expect.any(Function),
-        update: expect.any(Function),
-        delete: expect.any(Function),
-      });
-    });
-  });
-
-  describe('Single Type', () => {
-    test('Creates default actions', () => {
-      const contentType = {
-        modelName: 'testModel',
-        kind: 'singleType',
-      };
-
-      const service = createService({ contentType });
-
-      expect(service).toEqual({
-        find: expect.any(Function),
-        createOrUpdate: expect.any(Function),
-        delete: expect.any(Function),
-      });
-    });
-
-    describe('Passes the logic down to the entityService', () => {
-      test('Creates data when no entity is found', async () => {
-        global.strapi = {
-          entityService: {
-            findMany: jest.fn(() => Promise.resolve(null)),
-            create: jest.fn(() => Promise.resolve({ id: 1 })),
-          },
-          query() {
-            return { count() {} };
-          },
-        };
-
-        const contentType = {
-          uid: 'testModel',
-          kind: 'singleType',
-        };
-
-        const service = createService({ contentType });
-
-        const input = {};
-        await service.createOrUpdate({ data: input });
-
-        expect(strapi.entityService.findMany).toHaveBeenCalledWith('testModel', {
-          publicationState: 'preview',
-        });
-
-        expect(strapi.entityService.create).toHaveBeenCalledWith('testModel', { data: input });
-      });
-
-      test('Updates data when entity is found', async () => {
-        global.strapi = {
-          entityService: {
-            findMany: jest.fn(() => Promise.resolve({ id: 1 })),
-            update: jest.fn(() => Promise.resolve({ id: 1 })),
-          },
-          query() {
-            return { count() {} };
-          },
-        };
-
-        const contentType = {
-          uid: 'testModel',
-          kind: 'singleType',
-        };
-
-        const service = createService({ contentType });
-
-        const input = {};
-        await service.createOrUpdate({ data: input });
-
-        expect(strapi.entityService.findMany).toHaveBeenCalledWith('testModel', {
-          populate: undefined,
-          publicationState: 'preview',
-        });
-
-        expect(strapi.entityService.update).toHaveBeenCalledWith('testModel', 1, {
-          data: input,
-        });
-      });
-
-      test('Delete data when entity is found', async () => {
-        global.strapi = {
-          entityService: {
-            findMany: jest.fn(() => Promise.resolve({ id: 1 })),
-            delete: jest.fn(() => Promise.resolve({ id: 1 })),
-          },
-        };
-
-        const contentType = {
-          uid: 'testModel',
-          kind: 'singleType',
-        };
-
-        const service = createService({ contentType });
-
-        await service.delete();
-
-        expect(strapi.entityService.findMany).toHaveBeenCalledWith('testModel', {
-          populate: undefined,
-          publicationState: 'live',
-        });
-
-        expect(strapi.entityService.delete).toHaveBeenCalledWith('testModel', 1);
-      });
-    });
-  });
-});