@strapi/strapi 4.10.0 → 4.10.1-experimental.0

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

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

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

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

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