strapi/packages/strapi-utils/lib/__tests__/provider-factory.test.js
Jean-Sébastien Herbaux 1e5b1c99f6
I18n/ permissions rework (#9535)
* Add a domain layer for the permission, rework the engine handling of the permissions

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Add permissions-fields-to-properties migration for the admin

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Removes useless console.log

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Remove debug logLevel from provider-login.test.e2e.js

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Adds the new layout for the GET permissions, allow to subscribe to actionRegistered events, adds i18n handlers

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Fix typo

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Update permissions validators

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Update unit tests

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Update integrations test + fix some validation issues

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Change plugins & settings section format for the permissions layout

* only return locales property to localized subjects for the permission's layout

* Do not send the locales property to the permission's layout when there is no locales created

* Add the 'locales' property to publish & delete routes

* Fix unwanted mutation of the sections builder states on multiple builds

* Fix units tests with (new engine)

* Fix admin-role e2e test - Add locales property to the update payload

* fix e2e testsé

* Update e2e snapshots

* Fix unit test for i18n bootstrap

* Add mocks for i18n/bootstrap test

* Fix has-locale condition & updatePermission validator

* Avoid mutation in migration, always authorize super admin for has-locales condition

* Rework rbac domain objects, add a hook module and a provider factory

* Remove old providers

* Update the admin services & tests for the new rbac domain & providers

* Fix tests, bootstrap functions & services following rbac domain rework

* Update migration runner

* PR comments

Signed-off-by: Convly <jean-sebastien.herbaux@epitech.eu>

* Remove useless console.log

* Fix sanitizeCondition bug

* Section builder rework

* Add test for the section-builder section & add jsdoc for the permission domain

* pr comments (without the migrations)

* fix fields-to-properties migration

* Add jsdoc for the sections-builder

* Moves createBoundAbstractDomain from permission domain to the engine service

* Remove debug logLevel for admin role test (e2e)

* Fix core-store

* Fix hooks & move business logic from i18n bootstrap to dedicated services

* add route get-non-localized-fields

* use write and read permission

* refacto

* add input validator

* add route doc

* handle ST

Co-authored-by: Pierre Noël <petersg83@gmail.com>
Co-authored-by: Alexandre BODIN <alexandrebodin@users.noreply.github.com>
2021-03-25 14:59:44 +01:00

412 lines
12 KiB
JavaScript

'use strict';
const providerFactory = require('../provider-factory');
const providerMethods = [
'register',
'delete',
'get',
'getWhere',
'values',
'keys',
'has',
'size',
'clear',
];
describe('Provider Factory', () => {
describe('Core', () => {
test('Can create a default provider', () => {
const provider = providerFactory();
expect(provider).toHaveProperty('hooks', expect.any(Object));
providerMethods.forEach(methodName =>
expect(provider).toHaveProperty(methodName, expect.any(Function))
);
});
});
describe('Hooks', () => {
test.each(['willRegister'])(
'AsyncSeries: %s hook can be triggered and mutate the given context',
async hookName => {
const provider = providerFactory();
const ctx = { bar: 'foo' };
const handler = jest.fn(context => (context.foo = 'bar'));
provider.hooks[hookName].register(handler);
await provider.hooks[hookName].call(ctx);
expect(handler).toHaveBeenCalled();
expect(ctx).toEqual({ bar: 'foo', foo: 'bar' });
}
);
test.each(['didRegister', 'willDelete', 'didDelete'])(
'AsyncParallel: %s hook can be triggered, but cannot mutate the given context',
async hookName => {
const provider = providerFactory();
const ctx = { bar: 'foo' };
const handler = jest.fn(context => {
context.foo = 'bar';
return context;
});
provider.hooks[hookName].register(handler);
const results = await provider.hooks[hookName].call(ctx);
expect(handler).toHaveBeenCalled();
expect(results).toEqual([{ foo: 'bar', bar: 'foo' }]);
expect(ctx).toEqual({ bar: 'foo' });
}
);
});
describe('Methods', () => {
describe('Register', () => {
test('Can register a new item', async () => {
const provider = providerFactory();
const key = 'key';
const item = { foo: 'bar' };
await provider.register(key, item);
expect(provider.get(key)).toEqual(item);
});
test(`Can't register duplicated key by default`, async () => {
const provider = providerFactory();
const key = 'key';
const itemA = { foo: 'bar' };
const itemB = { bar: 'foo' };
await provider.register(key, itemA);
await expect(provider.register(key, itemB)).rejects.toThrowError(
'Duplicated item key: key'
);
});
test('Can register duplicated key when "throwOnDuplicates" is false', async () => {
const provider = providerFactory({ throwOnDuplicates: false });
const key = 'key';
const itemA = { foo: 'bar' };
const itemB = { bar: 'foo' };
await provider.register(key, itemA);
expect(provider.get(key)).toEqual(itemA);
await provider.register(key, itemB);
expect(provider.get(key)).toEqual(itemB);
});
test('Register hooks are triggered on item registration', async () => {
const willRegister = jest.fn(({ value }) => (value.bar = 'foo'));
const didRegister = jest.fn();
const key = 'key';
const item = { foo: 'bar' };
const provider = providerFactory();
provider.hooks.willRegister.register(willRegister);
provider.hooks.didRegister.register(didRegister);
await provider.register(key, item);
expect(willRegister).toHaveBeenCalledWith({ key, value: item });
expect(didRegister).toHaveBeenCalledWith({ key, value: item });
expect(item).toMatchObject({ foo: 'bar', bar: 'foo' });
});
});
describe('Delete', () => {
const key = 'key';
const item = { foo: 'bar' };
test('Can delete a registered item by its key', async () => {
const provider = providerFactory();
await provider.register(key, item);
expect(provider.get(key)).toBe(item);
await provider.delete(key, item);
expect(provider.get(key)).toBeUndefined();
});
test('Trying to delete an unregistered item does nothing', async () => {
const provider = providerFactory();
expect(provider.get(key)).toBeUndefined();
await provider.delete(key);
expect(provider.get(key)).toBeUndefined();
await provider.register(key, item);
expect(provider.get(key)).toBe(item);
await provider.delete(`${key}.${key}`);
expect(provider.get(key)).toBe(item);
});
test('Register hooks are triggered on item registration', async () => {
const willDelete = jest.fn();
const didDelete = jest.fn();
const provider = providerFactory();
provider.hooks.willDelete.register(willDelete);
provider.hooks.didDelete.register(didDelete);
await provider.register(key, item);
await provider.delete(key);
expect(willDelete).toHaveBeenCalledWith({ key, value: item });
expect(didDelete).toHaveBeenCalledWith({ key, value: item });
expect(item).toEqual({ foo: 'bar' });
});
});
describe('Get', () => {
test('calling get on an existing key returns the registered item', async () => {
const provider = providerFactory();
const key = 'key';
const item = { foo: 'bar' };
await provider.register(key, item);
const result = provider.get(key);
expect(result).toBe(item);
});
test('Calling get on a non-existing key returns undefined', () => {
const provider = providerFactory();
const result = provider.get('key');
expect(result).toBeUndefined();
});
});
describe('GetWhere', () => {
const items = [
{ key: 'keyA', value: { foo: 'barA', bar: 'foo1' } },
{ key: 'keyB', value: { foo: 'barB', bar: 'foo2' } },
{ key: 'keyC', value: { foo: 'barC', bar: 'foo1' } },
{ key: 'keyD', value: { foo: 'barD', bar: 'foo2' } },
];
const provider = providerFactory();
const sortItems = (a, b) => (a.key < b.key ? -1 : 1);
const pickItems = (...indexes) => indexes.map(index => items[index].value);
beforeAll(async () => {
for (const item of items) {
await provider.register(item.key, item.value);
}
});
test('Calling getWhere without filters returns every registered items', async () => {
const expected = items.map(i => i.value).sort(sortItems);
const results = provider.getWhere();
expect(results).toStrictEqual(expect.any(Array));
expect(results).toHaveLength(items.length);
expect(results.sort(sortItems)).toEqual(expected);
});
test.each([
[{ foo: 'barA' }, pickItems(0)],
[{ bar: 'foo1' }, pickItems(0, 2)],
[{ bar: 'foo2' }, pickItems(1, 3)],
[{ foo: 'barD', bar: 'foo2' }, pickItems(3)],
[{ foo: 'barC', bar: 'foo2' }, []],
[{ foobar: 'foobar' }, []],
[{}, pickItems(0, 1, 2, 3)],
])('Filters %s', (filters, expected) => {
const results = provider.getWhere(filters);
expect(results).toStrictEqual(expect.any(Array));
expect(results).toStrictEqual(expected);
});
});
describe('Values', () => {
test('Returns an empty array when there is no registered item', async () => {
const provider = providerFactory();
const values = provider.values();
expect(values).toStrictEqual(expect.any(Array));
expect(values).toHaveLength(0);
});
test('Returns every registered item (only the value, not the key)', async () => {
const provider = providerFactory();
const items = [
{ key: 'keyA', value: { foo: 'barA', bar: 'foo1' } },
{ key: 'keyB', value: { foo: 'barB', bar: 'foo2' } },
{ key: 'keyC', value: { foo: 'barC', bar: 'foo1' } },
{ key: 'keyD', value: { foo: 'barD', bar: 'foo2' } },
];
for (const item of items) {
await provider.register(item.key, item.value);
}
const values = provider.values();
expect(values).toStrictEqual(items.map(item => item.value));
});
});
describe('Keys', () => {
test('Returns an empty array when there is no registered item', async () => {
const provider = providerFactory();
const keys = provider.keys();
expect(keys).toStrictEqual(expect.any(Array));
expect(keys).toHaveLength(0);
});
test('Returns every registered item (only the key, not the value)', async () => {
const provider = providerFactory();
const items = [
{ key: 'keyA', value: { foo: 'barA', bar: 'foo1' } },
{ key: 'keyB', value: { foo: 'barB', bar: 'foo2' } },
{ key: 'keyC', value: { foo: 'barC', bar: 'foo1' } },
{ key: 'keyD', value: { foo: 'barD', bar: 'foo2' } },
];
for (const item of items) {
await provider.register(item.key, item.value);
}
const keys = provider.keys();
expect(keys).toStrictEqual(items.map(item => item.key));
});
});
describe('Has', () => {
const provider = providerFactory();
const key = 'key';
const item = { foo: 'bar' };
beforeAll(async () => {
await provider.register(key, item);
});
test.each([
[key, true],
['foo', false],
])('Has %s => %s', (key, expected) => {
const result = provider.has(key);
expect(result).toBe(expected);
});
});
describe('Size', () => {
test.each([
['No item', []],
['One item', [{ key: 'key', value: { foo: 'bar' } }]],
[
'Multiple items',
[
{ key: 'keyA', value: { foo: 'bar' } },
{ key: 'keyB', value: { foo: 'bar' } },
{ key: 'keyC', value: { foo: 'bar' } },
],
],
])('%s', async (name, items) => {
const provider = providerFactory();
for (const item of items) {
await provider.register(item.key, item.value);
}
const size = provider.size();
expect(size).toBe(items.length);
});
});
describe('Clear', () => {
test('Does nothing when there is no registered item', async () => {
const provider = providerFactory();
expect(provider.size()).toBe(0);
await provider.clear();
expect(provider.size()).toBe(0);
});
test('Delete every registered item', async () => {
const provider = providerFactory();
const items = [
{ key: 'keyA', value: { foo: 'barA' } },
{ key: 'keyB', value: { foo: 'barB' } },
{ key: 'keyC', value: { foo: 'barC' } },
];
for (const item of items) {
await provider.register(item.key, item.value);
}
expect(provider.size()).toBe(items.length);
await provider.clear();
expect(provider.size()).toBe(0);
});
test('Delete hooks are triggered for every item on clear', async () => {
const willDelete = jest.fn();
const didDelete = jest.fn();
const provider = providerFactory();
provider.hooks.willDelete.register(willDelete);
provider.hooks.didDelete.register(didDelete);
const items = [
{ key: 'keyA', value: { foo: 'barA' } },
{ key: 'keyB', value: { foo: 'barB' } },
{ key: 'keyC', value: { foo: 'barC' } },
];
for (const item of items) {
await provider.register(item.key, item.value);
}
expect(provider.size()).toBe(items.length);
await provider.clear();
expect(provider.size()).toBe(0);
expect(willDelete).toHaveBeenCalledTimes(items.length);
expect(didDelete).toHaveBeenCalledTimes(items.length);
});
});
});
});