@strapi/admin 4.16.2 → 4.18.0

package/server/services/__tests__/permissions-manager.test.js

@@ -1,318 +0,0 @@
-'use strict';
-
-const { AbilityBuilder, Ability } = require('@casl/ability');
-const { pick } = require('lodash/fp');
-const sift = require('sift');
-const { buildStrapiQuery } = require('../permission/permissions-manager/query-builders');
-const createPermissionsManager = require('../permission/permissions-manager');
-
-const allowedOperations = [
-  '$or',
-  '$and',
-  '$eq',
-  '$ne',
-  '$in',
-  '$nin',
-  '$lt',
-  '$lte',
-  '$gt',
-  '$gte',
-  '$exists',
-  '$elemMatch',
-];
-
-const operations = pick(allowedOperations, sift);
-
-const conditionsMatcher = (conditions) => {
-  return sift.createQueryTester(conditions, { operations });
-};
-
-const defineAbility = (register) => {
-  const { can, build } = new AbilityBuilder(Ability);
-
-  register(can);
-
-  return build({ conditionsMatcher });
-};
-
-describe('Permissions Manager', () => {
-  beforeEach(() => {
-    global.strapi = {
-      getModel() {
-        return {};
-      },
-    };
-  });
-
-  describe('get Query', () => {
-    test('It should returns an empty query when no conditions are defined', async () => {
-      const ability = defineAbility((can) => can('read', 'foo'));
-      const pm = createPermissionsManager({
-        ability,
-        action: 'read',
-        model: 'foo',
-      });
-
-      expect(pm.getQuery()).toStrictEqual({});
-    });
-
-    test('It should returns a valid query from the ability', () => {
-      const ability = defineAbility((can) => can('read', 'foo', ['bar'], { kai: 'doe' }));
-      const pm = createPermissionsManager({
-        ability,
-        action: 'read',
-        model: 'foo',
-      });
-
-      const expected = { $or: [{ kai: 'doe' }] };
-
-      expect(pm.getQuery()).toStrictEqual(expected);
-    });
-
-    test('It should throw if no action is defined', () => {
-      const ability = defineAbility((can) => can('read', 'foo', ['bar'], { kai: 'doe' }));
-      const pm = createPermissionsManager({
-        ability,
-        model: 'foo',
-      });
-
-      expect(() => pm.getQuery()).toThrowError();
-    });
-  });
-
-  describe('get isAllowed', () => {
-    const ability = defineAbility((can) => can('read', 'foo'));
-
-    test('It should grants access', () => {
-      const pm = createPermissionsManager({
-        ability,
-        action: 'read',
-        model: 'foo',
-      });
-
-      expect(pm.isAllowed).toBeTruthy();
-    });
-
-    test('It should deny access', () => {
-      const pm = createPermissionsManager({
-        ability,
-        action: 'read',
-        model: 'bar',
-      });
-
-      expect(pm.isAllowed).toBeFalsy();
-    });
-  });
-
-  describe('toSubject', () => {
-    global.strapi = {
-      getModel() {
-        return {};
-      },
-    };
-
-    const attr = '__caslSubjectType__';
-    const ability = defineAbility((can) => can('read', 'foo'));
-    const pm = createPermissionsManager({
-      ability,
-      action: 'read',
-      model: 'foo',
-    });
-
-    test('It should transform an object to a subject using default model', () => {
-      const input = { foo: 'bar' };
-      const sub = pm.toSubject(input);
-
-      expect(sub[attr]).toBeDefined();
-      expect(sub[attr]).toEqual('foo');
-      expect(sub).toStrictEqual(input);
-    });
-
-    test('It should transform an object to a subject using the given model', () => {
-      const input = { foo: 'bar' };
-      const newSubjectName = 'another_subject';
-      const sub = pm.toSubject(input, newSubjectName);
-
-      expect(sub[attr]).toBeDefined();
-      expect(sub[attr]).toEqual(newSubjectName);
-      expect(sub).toStrictEqual(input);
-    });
-  });
-
-  describe('pickPermittedFieldsOf', () => {
-    global.strapi = {
-      getModel() {
-        return {
-          attributes: {
-            title: {
-              type: 'text',
-              private: false,
-            },
-          },
-          primaryKey: 'id',
-          options: {},
-        };
-      },
-      config: {
-        get: jest.fn,
-      },
-    };
-
-    const ability = defineAbility((can) => {
-      can('read', 'article', ['title'], { title: 'foo' });
-      can('edit', 'article', ['title'], { title: { $in: ['kai', 'doe'] } });
-    });
-
-    const pm = createPermissionsManager({
-      ability,
-      action: 'read',
-      model: 'article',
-    });
-
-    test('Pick all fields (output) using default model', async () => {
-      const input = { title: 'foo' };
-      const res = await pm.pickPermittedFieldsOf(input);
-
-      expect(res).toStrictEqual(input);
-    });
-
-    test(`Pick 0 fields (output) using custom model`, async () => {
-      const input = { title: 'foo' };
-      const res = await pm.pickPermittedFieldsOf(input, { action: 'edit' });
-
-      expect(res).toStrictEqual({});
-    });
-
-    test('Sanitize an array of objects', async () => {
-      const input = [{ title: 'foo' }, { title: 'kai' }];
-      const expected = [{ title: 'foo' }, {}];
-
-      const res = await pm.pickPermittedFieldsOf(input);
-
-      expect(res).toStrictEqual(expected);
-    });
-  });
-
-  describe('addPermissionsQueryTo', () => {
-    const ability = defineAbility((can) =>
-      can('read', 'article', ['title'], { $and: [{ title: 'foo' }] })
-    );
-    const pm = createPermissionsManager({
-      ability,
-      action: 'read',
-      model: 'article',
-    });
-
-    const pmQuery = { $or: [{ $and: [{ title: 'foo' }] }] };
-
-    test('Create query from simple object', () => {
-      const query = { limit: 100 };
-      const expected = { limit: 100, filters: pmQuery };
-
-      const res = pm.addPermissionsQueryTo(query);
-
-      expect(res).toStrictEqual(expected);
-    });
-
-    test('Create query from complex object', () => {
-      const query = { limit: 100, filters: { $and: [{ a: 'b' }, { c: 'd' }] } };
-      const expected = {
-        limit: 100,
-        filters: {
-          $and: [query.filters, pmQuery],
-        },
-      };
-
-      const res = pm.addPermissionsQueryTo(query);
-
-      expect(res).toStrictEqual(expected);
-    });
-  });
-
-  describe('buildStrapiQuery', () => {
-    const tests = [
-      ['No transform', { foo: 'bar' }, { foo: 'bar' }],
-      ['Simple op', { foo: { $eq: 'bar' } }, { foo: { $eq: 'bar' } }],
-      ['Nested property', { 'foo.nested': 'bar' }, { foo: { nested: 'bar' } }],
-      [
-        'Nested property + $eq',
-        { 'foo.nested': { $eq: 'bar' } },
-        { foo: { nested: { $eq: 'bar' } } },
-      ],
-      [
-        'Nested property + $elementMatch',
-        { 'foo.nested': { $elemMatch: 'bar' } },
-        { foo: { nested: 'bar' } },
-      ],
-      [
-        'Deeply nested property',
-        { 'foo.nested.again': 'bar' },
-        { foo: { nested: { again: 'bar' } } },
-      ],
-      ['Op with array', { foo: { $in: ['bar', 'rab'] } }, { foo: { $in: ['bar', 'rab'] } }],
-      ['Removable op', { foo: { $elemMatch: { a: 'b' } } }, { foo: { a: 'b' } }],
-      [
-        'Combination of removable and basic ops',
-        { foo: { $elemMatch: { a: { $in: [1, 2, 3] } } } },
-        { foo: { a: { $in: [1, 2, 3] } } },
-      ],
-      [
-        'Decoupling of nested properties with/without op',
-        { foo: { $elemMatch: { a: { $in: [1, 2, 3] }, b: 'c' } } },
-        { foo: { a: { $in: [1, 2, 3] }, b: 'c' } },
-      ],
-      [
-        'OR op and properties decoupling',
-        { $or: [{ foo: { a: 2 } }, { foo: { b: 3 } }] },
-        { $or: [{ foo: { a: 2 } }, { foo: { b: 3 } }] },
-      ],
-      [
-        'OR op with nested properties & ops',
-        { $or: [{ foo: { a: 2 } }, { foo: { b: { $in: [1, 2, 3] } } }] },
-        { $or: [{ foo: { a: 2 } }, { foo: { b: { $in: [1, 2, 3] } } }] },
-      ],
-      [
-        'Nested OR op',
-        { $or: [{ $or: [{ a: 2 }, { a: 3 }] }] },
-        { $or: [{ $or: [{ a: 2 }, { a: 3 }] }] },
-      ],
-      [
-        'OR op with nested AND op',
-        { $or: [{ a: 2 }, [{ a: 3 }, { $or: [{ b: 1 }, { b: 4 }] }]] },
-        { $or: [{ a: 2 }, [{ a: 3 }, { $or: [{ b: 1 }, { b: 4 }] }]] },
-      ],
-      [
-        'OR op with nested AND op and nested properties',
-        { $or: [{ a: 2 }, [{ a: 3 }, { b: { c: 'foo' } }]] },
-        { $or: [{ a: 2 }, [{ a: 3 }, { b: { c: 'foo' } }]] },
-      ],
-      [
-        'Literal nested property with removable op',
-        {
-          created_by: {
-            roles: {
-              $elemMatch: {
-                id: {
-                  $in: [1, 2, 3],
-                },
-              },
-            },
-          },
-        },
-        {
-          created_by: {
-            roles: {
-              id: {
-                $in: [1, 2, 3],
-              },
-            },
-          },
-        },
-      ],
-    ];
-
-    test.each(tests)(`Test n°%#: %s`, (name, input, expected) => {
-      expect(buildStrapiQuery(input)).toStrictEqual(expected);
-    });
-  });
-});

package/server/services/__tests__/permissions.section-builder.section.test.js

@@ -1,136 +0,0 @@
-'use strict';
-
-const createSection = require('../permission/sections-builder/section');
-
-describe('Section', () => {
-  test('Creates a new section with the correct properties', () => {
-    const section = createSection();
-
-    expect(section.hooks).toMatchObject({
-      handlers: expect.any(Object),
-      matchers: expect.any(Object),
-    });
-
-    expect(section).toHaveProperty('appliesToAction', expect.any(Function));
-    expect(section).toHaveProperty('build', expect.any(Function));
-  });
-
-  test(`It's possible to register handlers for hooks on section init`, async () => {
-    const handler = jest.fn();
-    const matcher = jest.fn();
-
-    const section = createSection({ handlers: [handler], matchers: [matcher] });
-
-    await section.hooks.matchers.call();
-    await section.hooks.handlers.call();
-
-    expect(handler).toHaveBeenCalled();
-    expect(matcher).toHaveBeenCalled();
-  });
-
-  test(`It's possible to register handlers for hooks after section init`, async () => {
-    const handler = jest.fn();
-    const matcher = jest.fn();
-
-    const section = createSection();
-
-    section.hooks.handlers.register(handler);
-    section.hooks.matchers.register(matcher);
-
-    await section.hooks.matchers.call();
-    await section.hooks.handlers.call();
-
-    expect(handler).toHaveBeenCalled();
-    expect(matcher).toHaveBeenCalled();
-  });
-
-  describe('appliesToAction', () => {
-    test(`If there is no matcher registered, it should return false everytime`, async () => {
-      const section = createSection();
-      const action = {};
-
-      const applies = await section.appliesToAction(action);
-
-      expect(applies).toBe(false);
-    });
-
-    test(`If there is at least one matcher returning true, it should return true`, async () => {
-      const action = { foo: 'bar' };
-      const matchers = [jest.fn((a) => a.foo === 'bar'), jest.fn((a) => a.bar === 'foo')];
-      const section = createSection({ matchers });
-
-      const applies = await section.appliesToAction(action);
-
-      matchers.forEach((matcher) => expect(matcher).toHaveBeenCalledWith(action));
-      expect(applies).toBe(true);
-    });
-
-    test('If every matcher returns other results than true, it should return false', async () => {
-      const action = { foo: 'bar' };
-      const matchers = [jest.fn((a) => a.foo === 'foo'), jest.fn((a) => a.bar === 'foo')];
-      const section = createSection({ matchers });
-
-      const applies = await section.appliesToAction(action);
-
-      matchers.forEach((matcher) => expect(matcher).toHaveBeenCalledWith(action));
-      expect(applies).toBe(false);
-    });
-  });
-
-  describe('build', () => {
-    test('Trying to build the section without any action should return the section initial state', async () => {
-      const initialStateFactory = jest.fn(() => ({ foo: 'bar' }));
-      const section = createSection({ initialStateFactory });
-
-      const result = await section.build();
-
-      expect(initialStateFactory).toHaveBeenCalled();
-      expect(result).toStrictEqual({ foo: 'bar' });
-    });
-
-    test('Trying to build the section without any registered matcher should return the section initial state', async () => {
-      const initialStateFactory = jest.fn(() => ({ foo: 'bar' }));
-      const actions = [{ foo: 'bar' }, { bar: 'foo' }];
-      const section = createSection({ initialStateFactory });
-
-      const result = await section.build(actions);
-
-      expect(initialStateFactory).toHaveBeenCalled();
-      expect(result).toStrictEqual({ foo: 'bar' });
-    });
-
-    test('Trying to build the section without any registered handler should return the section initial state', async () => {
-      const initialStateFactory = jest.fn(() => ({ foo: 'bar' }));
-      const matchers = [jest.fn(() => true)];
-      const actions = [{ foo: 'bar' }, { bar: 'foo' }];
-      const section = createSection({ initialStateFactory, matchers });
-
-      const result = await section.build(actions);
-
-      expect(initialStateFactory).toHaveBeenCalled();
-      expect(matchers[0]).toHaveBeenCalledTimes(actions.length);
-      expect(result).toStrictEqual({ foo: 'bar' });
-    });
-
-    test('Building the section with different handlers', async () => {
-      const initialStateFactory = jest.fn(() => ({ foo: 'bar' }));
-      const matchers = [jest.fn(() => true)];
-      const handlers = [
-        jest.fn(({ section }) => {
-          section.foobar = 1;
-        }),
-        jest.fn(({ section }) => {
-          section.barfoo = 2;
-        }),
-      ];
-      const actions = [{ foo: 'bar' }, { bar: 'foo' }];
-      const section = createSection({ initialStateFactory, matchers, handlers });
-
-      const result = await section.build(actions);
-
-      expect(initialStateFactory).toHaveBeenCalled();
-      expect(matchers[0]).toHaveBeenCalledTimes(actions.length);
-      expect(result).toStrictEqual({ foo: 'bar', foobar: 1, barfoo: 2 });
-    });
-  });
-});