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

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

@@ -1,275 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { getPaginationInfo } = require('../pagination');
-
-const maxLimit = 50;
-const defaultLimit = 20;
-
-describe('Pagination service', () => {
-  describe('With maxLimit set globally', () => {
-    beforeAll(() => {
-      global.strapi = {
-        config: {
-          get(path, defaultValue) {
-            return _.get(this, path, defaultValue);
-          },
-          api: {
-            rest: {
-              defaultLimit,
-              maxLimit,
-            },
-          },
-        },
-      };
-    });
-
-    test('Uses default limit', () => {
-      const pagination = {};
-      const paginationInfo = getPaginationInfo({ pagination });
-
-      expect(paginationInfo).toEqual({
-        page: 1,
-        pageSize: defaultLimit,
-      });
-    });
-
-    describe('Paged pagination', () => {
-      test('Uses specified pageSize', () => {
-        const pagination = { pageSize: 5 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: pagination.pageSize,
-        });
-      });
-
-      test('Uses maxLimit as pageSize', () => {
-        const pagination = { pageSize: 999 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: maxLimit,
-        });
-      });
-
-      test('Uses 1 as pageSize', () => {
-        const pagination = { pageSize: 0 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: 1,
-        });
-      });
-
-      test('Uses 1 as pageSize', () => {
-        const pagination = { pageSize: -1 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: 1,
-        });
-      });
-
-      test('Uses 1 as pageSize', () => {
-        const pagination = { pageSize: -2 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: 1,
-        });
-      });
-    });
-
-    describe('Offset pagination', () => {
-      test('Uses specified limit', () => {
-        const pagination = { limit: 5 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: pagination.limit,
-        });
-      });
-
-      test('Uses maxLimit as limit', () => {
-        const pagination = { limit: 999 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: maxLimit,
-        });
-      });
-
-      test('Uses 1 as limit', () => {
-        const pagination = { limit: 0 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: 1,
-        });
-      });
-
-      test('Uses maxLimit as limit', () => {
-        const pagination = { limit: -1 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: maxLimit,
-        });
-      });
-
-      test('Uses 1 as limit', () => {
-        const pagination = { limit: -2 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: 1,
-        });
-      });
-    });
-  });
-
-  // Setting global strapi api conf
-
-  describe('With maxLimit undefined', () => {
-    beforeAll(() => {
-      global.strapi = {
-        config: {
-          get(path, defaultValue) {
-            return _.get(this, path, defaultValue);
-          },
-          api: {
-            rest: {
-              defaultLimit,
-              maxLimit: undefined,
-            },
-          },
-        },
-      };
-    });
-
-    test('Uses default limit', () => {
-      const pagination = {};
-      const paginationInfo = getPaginationInfo({ pagination });
-
-      expect(paginationInfo).toEqual({
-        page: 1,
-        pageSize: defaultLimit,
-      });
-    });
-
-    describe('Paged pagination', () => {
-      test('Uses specified pageSize', () => {
-        const pagination = { pageSize: 5 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: pagination.pageSize,
-        });
-      });
-
-      test('Uses specified pageSize', () => {
-        const pagination = { pageSize: 999 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: pagination.pageSize,
-        });
-      });
-
-      test('Uses 1 as pageSize', () => {
-        const pagination = { pageSize: 0 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: 1,
-        });
-      });
-
-      test('Uses 1 as pageSize', () => {
-        const pagination = { pageSize: -1 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: 1,
-        });
-      });
-
-      test('Uses 1 as pageSize', () => {
-        const pagination = { pageSize: -2 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          page: 1,
-          pageSize: 1,
-        });
-      });
-    });
-
-    describe('Offset pagination', () => {
-      test('Uses specified limit', () => {
-        const pagination = { limit: 5 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: pagination.limit,
-        });
-      });
-
-      test('Uses specified limit', () => {
-        const pagination = { limit: 999 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: pagination.limit,
-        });
-      });
-
-      test('Uses 1 as limit', () => {
-        const pagination = { limit: 0 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: 1,
-        });
-      });
-
-      test('Uses -1 as limit', () => {
-        const pagination = { limit: -1 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: -1,
-        });
-      });
-
-      test('Uses 1 as limit', () => {
-        const pagination = { limit: -2 };
-        const paginationInfo = getPaginationInfo({ pagination });
-
-        expect(paginationInfo).toEqual({
-          start: 0,
-          limit: 1,
-        });
-      });
-    });
-  });
-});

package/lib/load/__tests__/filepath-to-prop-path.test.js

@@ -1,30 +0,0 @@
-'use strict';
-
-const filePathToPropPath = require('../filepath-to-prop-path');
-
-const commonCases = [
-  ['./config/test.js', ['config', 'test']],
-  ['./config/test.json', ['config', 'test']],
-  ['./config/test.settings.js', ['config', 'test']],
-  ['./config/test.settings.json', ['config', 'test']],
-  ['config/test.settings.json', ['config', 'test']],
-];
-
-describe('filePathToPropPath', () => {
-  test.each(commonCases)('File %s becomes %p', (input, expected) => {
-    expect(filePathToPropPath(input)).toEqual(expected);
-  });
-
-  // uses dots to create path
-  test('Uses dots for key separation', () => {
-    expect(filePathToPropPath('./config/file.key.js')).toEqual(['config', 'file', 'key']);
-
-    expect(filePathToPropPath('./config/file.key.json')).toEqual(['config', 'file', 'key']);
-  });
-
-  // removes the last prop of the path
-  test('Disable file name key', () => {
-    expect(filePathToPropPath('./config/test.js', false)).toEqual(['config']);
-    expect(filePathToPropPath('./config/test.key.js', false)).toEqual(['config', 'test']);
-  });
-});

package/lib/middlewares/__tests__/errors.test.js

@@ -1,21 +0,0 @@
-'use strict';
-
-const Koa = require('koa');
-const request = require('supertest');
-
-describe('Errors middleware', () => {
-  test('_explicitStatus still exists', async () => {
-    // Since we are using an internal variable of koa in our code,
-    // we check that it doesn't change in newer updates
-    const app = new Koa();
-
-    app.use(async (ctx) => {
-      ctx.body = 'hello';
-      expect(ctx.response._explicitStatus).toBe(true);
-    });
-
-    expect.assertions(1);
-
-    await request(app.callback()).get('/');
-  });
-});

package/lib/services/__tests__/content-api-permissions.test.js

@@ -1,291 +0,0 @@
-'use strict';
-
-const createContentAPI = require('../content-api');
-
-describe('Content API - Permissions', () => {
-  const bindToContentAPI = (action) => {
-    Object.assign(action, { [Symbol.for('__type__')]: ['content-api'] });
-    return action;
-  };
-
-  describe('Get Actions Map', () => {
-    test('When no API are defined, it should return an empty object', () => {
-      global.strapi = {};
-
-      const contentAPI = createContentAPI(global.strapi);
-      const actionsMap = contentAPI.permissions.getActionsMap();
-
-      expect(actionsMap).toEqual({});
-    });
-
-    test('When no controller are defined for an API, it should ignore the API', () => {
-      global.strapi = {
-        api: {
-          foo: {},
-          bar: {},
-        },
-      };
-
-      const contentAPI = createContentAPI(global.strapi);
-      const actionsMap = contentAPI.permissions.getActionsMap();
-
-      expect(actionsMap).toEqual({});
-    });
-
-    test(`Do not register controller if they're not bound to the content API`, () => {
-      const actionC = () => {};
-      Object.assign(actionC, { [Symbol.for('__type__')]: ['admin-api'] });
-
-      global.strapi = {
-        api: {
-          foo: {
-            controllers: {
-              controllerA: {
-                actionA: bindToContentAPI(() => {}),
-                actionB() {},
-                actionC,
-              },
-            },
-          },
-        },
-      };
-
-      const contentAPI = createContentAPI(global.strapi);
-      const actionsMap = contentAPI.permissions.getActionsMap();
-
-      expect(actionsMap).toEqual({
-        'api::foo': { controllers: { controllerA: ['actionA'] } },
-      });
-    });
-
-    test('Creates and populate a map of actions from APIs and plugins', () => {
-      global.strapi = {
-        api: {
-          foo: {
-            controllers: {
-              controllerA: {
-                actionA: bindToContentAPI(() => {}),
-                actionB: bindToContentAPI(() => {}),
-              },
-            },
-          },
-          bar: {
-            controllers: {
-              controllerA: {
-                actionA: bindToContentAPI(() => {}),
-                actionB: bindToContentAPI(() => {}),
-              },
-            },
-          },
-          foobar: {
-            controllers: {
-              controllerA: {
-                actionA: bindToContentAPI(() => {}),
-                actionB: bindToContentAPI(() => {}),
-              },
-              controllerB: {
-                actionC: bindToContentAPI(() => {}),
-                actionD: bindToContentAPI(() => {}),
-              },
-            },
-          },
-        },
-        plugins: {
-          foo: {
-            controllers: {
-              controllerA: {
-                actionA: bindToContentAPI(() => {}),
-                actionB: bindToContentAPI(() => {}),
-              },
-            },
-          },
-          bar: {
-            controllers: {
-              controllerA: {
-                actionA: bindToContentAPI(() => {}),
-                actionB: bindToContentAPI(() => {}),
-              },
-            },
-          },
-        },
-      };
-
-      const contentAPI = createContentAPI(global.strapi);
-      const actionsMap = contentAPI.permissions.getActionsMap();
-
-      expect(actionsMap).toEqual({
-        'api::foo': { controllers: { controllerA: ['actionA', 'actionB'] } },
-        'api::bar': { controllers: { controllerA: ['actionA', 'actionB'] } },
-        'api::foobar': {
-          controllers: {
-            controllerA: ['actionA', 'actionB'],
-            controllerB: ['actionC', 'actionD'],
-          },
-        },
-        'plugin::foo': { controllers: { controllerA: ['actionA', 'actionB'] } },
-        'plugin::bar': { controllers: { controllerA: ['actionA', 'actionB'] } },
-      });
-    });
-  });
-
-  describe('Register Actions', () => {
-    beforeEach(() => {
-      global.strapi = {
-        api: {
-          foo: {
-            controllers: {
-              controllerA: {
-                actionA: bindToContentAPI(() => {}),
-                actionB: bindToContentAPI(() => {}),
-              },
-              controllerB: {
-                actionC: bindToContentAPI(() => {}),
-                actionD: bindToContentAPI(() => {}),
-              },
-            },
-          },
-        },
-        plugins: {
-          foo: {
-            controllers: {
-              controllerA: {
-                actionA: bindToContentAPI(() => {}),
-              },
-            },
-          },
-        },
-      };
-    });
-
-    test('The action provider should holds every action from APIs and plugins', async () => {
-      const contentAPI = createContentAPI(global.strapi);
-
-      await contentAPI.permissions.registerActions();
-
-      const values = contentAPI.permissions.providers.action.values();
-
-      expect(values).toEqual([
-        {
-          uid: 'api::foo.controllerA.actionA',
-          api: 'api::foo',
-          controller: 'controllerA',
-          action: 'actionA',
-        },
-        {
-          uid: 'api::foo.controllerA.actionB',
-          api: 'api::foo',
-          controller: 'controllerA',
-          action: 'actionB',
-        },
-        {
-          uid: 'api::foo.controllerB.actionC',
-          api: 'api::foo',
-          controller: 'controllerB',
-          action: 'actionC',
-        },
-        {
-          uid: 'api::foo.controllerB.actionD',
-          api: 'api::foo',
-          controller: 'controllerB',
-          action: 'actionD',
-        },
-        {
-          uid: 'plugin::foo.controllerA.actionA',
-          api: 'plugin::foo',
-          controller: 'controllerA',
-          action: 'actionA',
-        },
-      ]);
-    });
-
-    test('Call registerActions twice should throw a duplicate error', async () => {
-      const contentAPI = createContentAPI(global.strapi);
-
-      await contentAPI.permissions.registerActions();
-
-      expect(() => contentAPI.permissions.registerActions()).rejects.toThrowError(
-        'Duplicated item key: api::foo.controllerA.actionA'
-      );
-    });
-  });
-
-  describe('Providers', () => {
-    test('You should not be able to register action once strapi is loaded', () => {
-      global.strapi.isLoaded = true;
-
-      const contentAPI = createContentAPI(global.strapi);
-
-      // Actions
-      expect(() =>
-        contentAPI.permissions.providers.action.register('foo', {})
-      ).rejects.toThrowError(`You can't register new actions outside the bootstrap function.`);
-
-      // Conditions
-      expect(() =>
-        contentAPI.permissions.providers.condition.register({ name: 'myCondition' })
-      ).rejects.toThrowError(`You can't register new conditions outside the bootstrap function.`);
-
-      // Register Actions
-      expect(() => contentAPI.permissions.registerActions()).rejects.toThrowError(
-        `You can't register new actions outside the bootstrap function.`
-      );
-    });
-  });
-
-  describe('Engine', () => {
-    test('Engine warns when registering an unknown action', async () => {
-      global.strapi = {
-        log: {
-          debug: jest.fn(),
-        },
-      };
-
-      const contentAPI = createContentAPI();
-
-      const ability = await contentAPI.permissions.engine.generateAbility([{ action: 'foo' }]);
-
-      expect(ability.rules).toHaveLength(0);
-      expect(global.strapi.log.debug).toHaveBeenCalledWith(
-        `Unknown action "foo" supplied when registering a new permission`
-      );
-    });
-
-    test('Engine filter out invalid action when generating an ability', async () => {
-      global.strapi = {
-        log: {
-          debug: jest.fn(),
-        },
-
-        api: {
-          foo: {
-            controllers: {
-              bar: { foobar: bindToContentAPI(() => {}) },
-            },
-          },
-        },
-      };
-
-      const contentAPI = createContentAPI(global.strapi);
-
-      await contentAPI.permissions.registerActions();
-
-      const ability = await contentAPI.permissions.engine.generateAbility([
-        { action: 'foo' },
-        { action: 'api::foo.bar.foobar' },
-      ]);
-
-      expect(ability.rules).toHaveLength(1);
-      expect(ability.rules).toEqual([
-        {
-          action: 'api::foo.bar.foobar',
-          subject: 'all',
-        },
-      ]);
-
-      expect(global.strapi.log.debug).toHaveBeenCalledTimes(1);
-      expect(global.strapi.log.debug).toHaveBeenCalledWith(
-        `Unknown action "foo" supplied when registering a new permission`
-      );
-    });
-  });
-});