@strapi/admin 4.16.1 → 4.17.0

package/server/controllers/__tests__/content-api.test.js

@@ -1,173 +0,0 @@
-'use strict';
-
-const createContext = require('../../../../../../test/helpers/create-context');
-const contentApiController = require('../content-api');
-
-describe('Content API permissions', () => {
-  const actionsMap = {
-    'api::address': {
-      controllers: {
-        address: ['find', 'findOne'],
-      },
-    },
-    'api::category': {
-      controllers: {
-        category: ['find', 'findOne', 'create', 'update', 'delete', 'createLocalization'],
-      },
-    },
-  };
-
-  test('return content api layout successfully', async () => {
-    const getActionsMap = jest.fn().mockResolvedValue(actionsMap);
-    const send = jest.fn();
-    const ctx = createContext({}, { send });
-
-    global.strapi = {
-      contentAPI: {
-        permissions: {
-          getActionsMap,
-        },
-      },
-    };
-
-    await contentApiController.getPermissions(ctx);
-
-    expect(getActionsMap).toHaveBeenCalled();
-    expect(send).toHaveBeenCalledWith({ data: actionsMap });
-  });
-
-  const routesMap = {
-    'api::address': [
-      {
-        method: 'GET',
-        path: '/api/addresses',
-        handler: 'api::address.address.find',
-        config: {
-          auth: false,
-        },
-        info: {
-          apiName: 'address',
-          type: 'content-api',
-        },
-      },
-      {
-        method: 'GET',
-        path: '/api/addresses/:id',
-        handler: 'api::address.address.findOne',
-        config: {
-          auth: {
-            scope: ['api::address.address.findOne'],
-          },
-        },
-        info: {
-          apiName: 'address',
-          type: 'content-api',
-        },
-      },
-    ],
-    'api::category': [
-      {
-        method: 'GET',
-        path: '/api/categories',
-        handler: 'api::category.category.find',
-        config: {
-          auth: {
-            scope: ['api::category.category.find'],
-          },
-        },
-        info: {
-          apiName: 'category',
-          type: 'content-api',
-        },
-      },
-      {
-        method: 'GET',
-        path: '/api/categories/:id',
-        handler: 'api::category.category.findOne',
-        config: {
-          auth: {
-            scope: ['api::category.category.findOne'],
-          },
-        },
-        info: {
-          apiName: 'category',
-          type: 'content-api',
-        },
-      },
-      {
-        method: 'POST',
-        path: '/api/categories',
-        handler: 'api::category.category.create',
-        config: {
-          auth: {
-            scope: ['api::category.category.create'],
-          },
-        },
-        info: {
-          apiName: 'category',
-          type: 'content-api',
-        },
-      },
-      {
-        method: 'PUT',
-        path: '/api/categories/:id',
-        handler: 'api::category.category.update',
-        config: {
-          auth: {
-            scope: ['api::category.category.update'],
-          },
-        },
-        info: {
-          apiName: 'category',
-          type: 'content-api',
-        },
-      },
-      {
-        method: 'DELETE',
-        path: '/api/categories/:id',
-        handler: 'api::category.category.delete',
-        config: {
-          auth: {
-            scope: ['api::category.category.delete'],
-          },
-        },
-        info: {
-          apiName: 'category',
-          type: 'content-api',
-        },
-      },
-      {
-        method: 'POST',
-        path: '/api/categories/:id/localizations',
-        handler: 'category.createLocalization',
-        config: {
-          policies: [],
-          auth: {
-            scope: ['api::category.category.createLocalization'],
-          },
-        },
-        info: {
-          apiName: 'category',
-          type: 'content-api',
-        },
-      },
-    ],
-  };
-
-  test('return content api routes successfully', async () => {
-    const getRoutesMap = jest.fn().mockResolvedValue(routesMap);
-    const send = jest.fn();
-    const ctx = createContext({}, { send });
-
-    global.strapi = {
-      contentAPI: {
-        getRoutesMap,
-      },
-    };
-
-    await contentApiController.getRoutes(ctx);
-
-    expect(getRoutesMap).toHaveBeenCalled();
-    expect(send).toHaveBeenCalledWith({ data: routesMap });
-  });
-});

package/server/controllers/__tests__/permission.test.js

@@ -1,200 +0,0 @@
-'use strict';
-
-const createContext = require('../../../../../../test/helpers/create-context');
-const permissionController = require('../permission');
-
-describe('Permission Controller', () => {
-  const localTestData = {
-    permissions: {
-      valid: [
-        { action: 'read', subject: 'article', field: 'title' },
-        { action: 'read', subject: 'article' },
-        { action: 'read' },
-      ],
-      invalid: [
-        { action: {}, subject: '', field: '' },
-        { subject: 'article', field: 'title' },
-        { action: 'read', subject: {}, field: 'title' },
-        { action: 'read', subject: 'article', field: {} },
-        { action: 'read', subject: 'article', field: 'title', foo: 'bar' },
-      ],
-    },
-    ability: {
-      can: jest.fn(() => true),
-    },
-    badRequest: jest.fn(),
-  };
-
-  global.strapi = {
-    admin: {
-      services: {
-        permission: {
-          engine: {
-            checkMany: jest.fn((ability) => (permissions) => {
-              return permissions.map(({ action, subject, field }) =>
-                ability.can(action, subject, field)
-              );
-            }),
-          },
-        },
-      },
-    },
-  };
-
-  afterEach(async () => {
-    jest.clearAllMocks();
-  });
-
-  describe('Check Many Permissions', () => {
-    test('Invalid Permission Shape (bad type for action)', async () => {
-      const ctx = createContext(
-        { body: { permissions: [localTestData.permissions.invalid[0]] } },
-        { state: { userAbility: localTestData.ability }, badRequest: localTestData.badRequest }
-      );
-
-      expect.assertions(1);
-
-      try {
-        await permissionController.check(ctx);
-      } catch (e) {
-        expect(e).toMatchObject({
-          name: 'ValidationError',
-          message: 'permissions[0].action must be a `string` type, but the final value was: `{}`.',
-          details: {
-            errors: [
-              {
-                path: ['permissions', '0', 'action'],
-                message:
-                  'permissions[0].action must be a `string` type, but the final value was: `{}`.',
-                name: 'ValidationError',
-              },
-            ],
-          },
-        });
-      }
-    });
-
-    test('Invalid Permission Shape (missing required action)', async () => {
-      const ctx = createContext(
-        { body: { permissions: [localTestData.permissions.invalid[1]] } },
-        { state: { userAbility: localTestData.ability }, badRequest: localTestData.badRequest }
-      );
-
-      expect.assertions(1);
-
-      try {
-        await permissionController.check(ctx);
-      } catch (e) {
-        expect(e).toMatchObject({
-          name: 'ValidationError',
-          message: 'permissions[0].action is a required field',
-          details: {
-            errors: [
-              {
-                path: ['permissions', '0', 'action'],
-                message: 'permissions[0].action is a required field',
-                name: 'ValidationError',
-              },
-            ],
-          },
-        });
-      }
-    });
-
-    test('Invalid Permission Shape (bad type for subject)', async () => {
-      const ctx = createContext(
-        { body: { permissions: [localTestData.permissions.invalid[2]] } },
-        { state: { userAbility: localTestData.ability }, badRequest: localTestData.badRequest }
-      );
-
-      expect.assertions(1);
-
-      try {
-        await permissionController.check(ctx);
-      } catch (e) {
-        expect(e).toMatchObject({
-          name: 'ValidationError',
-          message: 'permissions[0].subject must be a `string` type, but the final value was: `{}`.',
-          details: {
-            errors: [
-              {
-                path: ['permissions', '0', 'subject'],
-                message:
-                  'permissions[0].subject must be a `string` type, but the final value was: `{}`.',
-                name: 'ValidationError',
-              },
-            ],
-          },
-        });
-      }
-    });
-
-    test('Invalid Permission Shape (bad type for field)', async () => {
-      const ctx = createContext(
-        { body: { permissions: [localTestData.permissions.invalid[3]] } },
-        { state: { userAbility: localTestData.ability }, badRequest: localTestData.badRequest }
-      );
-
-      expect.assertions(1);
-
-      try {
-        await permissionController.check(ctx);
-      } catch (e) {
-        expect(e).toMatchObject({
-          name: 'ValidationError',
-          message: 'permissions[0].field must be a `string` type, but the final value was: `{}`.',
-          details: {
-            errors: [
-              {
-                path: ['permissions', '0', 'field'],
-                message:
-                  'permissions[0].field must be a `string` type, but the final value was: `{}`.',
-                name: 'ValidationError',
-              },
-            ],
-          },
-        });
-      }
-    });
-
-    test('Invalid Permission Shape (unrecognized foo param)', async () => {
-      const ctx = createContext(
-        { body: { permissions: [localTestData.permissions.invalid[4]] } },
-        { state: { userAbility: localTestData.ability }, badRequest: localTestData.badRequest }
-      );
-
-      expect.assertions(1);
-
-      try {
-        await permissionController.check(ctx);
-      } catch (e) {
-        expect(e).toMatchObject({
-          name: 'ValidationError',
-          message: 'permissions[0] field has unspecified keys: foo',
-          details: {
-            errors: [
-              {
-                path: ['permissions', '0'],
-                message: 'permissions[0] field has unspecified keys: foo',
-                name: 'ValidationError',
-              },
-            ],
-          },
-        });
-      }
-    });
-
-    test('Check Many Permissions', async () => {
-      const ctx = createContext(
-        { body: { permissions: localTestData.permissions.valid } },
-        { state: { userAbility: localTestData.ability } }
-      );
-
-      await permissionController.check(ctx);
-
-      expect(localTestData.ability.can).toHaveBeenCalled();
-      expect(strapi.admin.services.permission.engine.checkMany).toHaveBeenCalled();
-      expect(ctx.body.data).toHaveLength(localTestData.permissions.valid.length);
-    });
-  });
-});

package/server/controllers/__tests__/role.test.js

@@ -1,201 +0,0 @@
-'use strict';
-
-const { ApplicationError } = require('@strapi/utils').errors;
-const createContext = require('../../../../../../test/helpers/create-context');
-const roleController = require('../role');
-
-describe('Role controller', () => {
-  describe('getPermissions', () => {
-    test('Fails if role does not exist', async () => {
-      const findOne = jest.fn(() => Promise.resolve());
-      const notFound = jest.fn();
-
-      const ctx = createContext(
-        {
-          params: { id: 1 },
-        },
-        {
-          notFound,
-        }
-      );
-
-      global.strapi = {
-        admin: {
-          services: {
-            role: {
-              findOne,
-            },
-          },
-        },
-      };
-
-      await roleController.getPermissions(ctx);
-
-      expect(findOne).toHaveBeenCalledWith({ id: ctx.params.id });
-      expect(notFound).toHaveBeenCalled();
-    });
-
-    test('Finds permissions correctly', async () => {
-      const permissions = [
-        {
-          action: 'test1',
-        },
-        {
-          action: 'test2',
-          subject: 'model1',
-        },
-      ];
-
-      const findOneRole = jest.fn(() => Promise.resolve({ id: 1 }));
-      const findPermissions = jest.fn(() => Promise.resolve(permissions));
-      const sanitizePermission = jest.fn((perms) => perms);
-
-      const ctx = createContext({
-        params: { id: 1 },
-      });
-
-      global.strapi = {
-        admin: {
-          services: {
-            role: {
-              findOne: findOneRole,
-            },
-            permission: {
-              findMany: findPermissions,
-              sanitizePermission,
-            },
-          },
-        },
-      };
-
-      await roleController.getPermissions(ctx);
-
-      expect(findOneRole).toHaveBeenCalledWith({ id: ctx.params.id });
-      expect(findPermissions).toHaveBeenCalledWith({ where: { role: { id: ctx.params.id } } });
-      expect(ctx.body).toEqual({
-        data: permissions,
-      });
-    });
-  });
-
-  describe('updatePermissions', () => {
-    test('Fails on missing permissions input', async () => {
-      const findOne = jest.fn(() => Promise.resolve({ id: 1 }));
-
-      const ctx = createContext({
-        params: { id: 1 },
-        body: {},
-      });
-
-      global.strapi = {
-        admin: {
-          services: {
-            permission: {
-              sanitizePermission: jest.fn((p) => p),
-            },
-            role: {
-              findOne,
-            },
-          },
-        },
-      };
-
-      expect.assertions(2);
-
-      try {
-        await roleController.updatePermissions(ctx);
-      } catch (e) {
-        expect(e instanceof ApplicationError).toBe(true);
-        expect(e.message).toEqual('permissions is a required field');
-      }
-    });
-
-    test('Fails on missing action permission', async () => {
-      const findOne = jest.fn(() => Promise.resolve({ id: 1 }));
-
-      const ctx = createContext({
-        params: { id: 1 },
-        body: {
-          permissions: [{}],
-        },
-      });
-      global.strapi = {
-        admin: {
-          services: {
-            role: { findOne },
-            permission: {
-              sanitizePermission: jest.fn((p) => p),
-              actionProvider: { get: jest.fn() },
-              conditionProvider: { values: jest.fn(() => []) },
-            },
-          },
-        },
-      };
-
-      expect.assertions(2);
-
-      try {
-        await roleController.updatePermissions(ctx);
-      } catch (e) {
-        expect(e instanceof ApplicationError).toBe(true);
-        expect(e.message).toEqual('permissions[0].action is a required field');
-      }
-    });
-
-    test('Assign permissions if input is valid', async () => {
-      const roleID = 1;
-      const findOneRole = jest.fn(() => Promise.resolve({ id: roleID }));
-      const assignPermissions = jest.fn((roleID, permissions) => Promise.resolve(permissions));
-      const inputPermissions = [
-        {
-          action: 'test',
-          subject: 'model1',
-          properties: { fields: ['title'] },
-          conditions: ['admin::is-creator'],
-        },
-      ];
-
-      const ctx = createContext({
-        params: { id: roleID },
-        body: {
-          permissions: inputPermissions,
-        },
-      });
-
-      global.strapi = {
-        admin: {
-          services: {
-            role: {
-              assignPermissions,
-              findOne: findOneRole,
-              getSuperAdmin: jest.fn(() => undefined),
-            },
-            permission: {
-              sanitizePermission: jest.fn((permissions) => permissions),
-              conditionProvider: {
-                values: jest.fn(() => [{ id: 'admin::is-creator' }]),
-              },
-              actionProvider: {
-                values: jest.fn(() => [{ actionId: 'test', subjects: ['model1'] }]),
-                get: jest.fn(() => ({
-                  actionId: 'test',
-                  subjects: ['model1'],
-                  options: { applyToProperties: ['fields'] },
-                })),
-              },
-            },
-          },
-        },
-      };
-
-      await roleController.updatePermissions(ctx);
-
-      expect(findOneRole).toHaveBeenCalledWith({ id: roleID });
-      expect(assignPermissions).toHaveBeenCalledWith(roleID, inputPermissions);
-
-      expect(ctx.body).toEqual({
-        data: inputPermissions,
-      });
-    });
-  });
-});