mirror of
https://github.com/strapi/strapi.git
synced 2025-08-07 00:09:23 +00:00

* 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>
412 lines
12 KiB
JavaScript
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);
|
|
});
|
|
});
|
|
});
|
|
});
|