Mirroristas/CommunitySolidServer
2
0
Fork 0
mirror of https://github.com/CommunitySolidServer/CommunitySolidServer.git synced 2024-10-03 14:55:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: Update ModesExtractors to support new permission interface

Browse Source
This commit is contained in:
Joachim Van Herwegen
2022-06-29 10:56:17 +02:00
parent 23f0b37c28
commit 7085252b3f
8 changed files with 147 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
test/unit/authorization/permissions/SparqlUpdateModesExtractor.test.ts
View File

@@ -1,17 +1,40 @@
import { Factory } from 'sparqlalgebrajs';
import type { AccessMap } from '../../../../src/authorization/permissions/Permissions';
import { AccessMode } from '../../../../src/authorization/permissions/Permissions';
import { SparqlUpdateModesExtractor } from '../../../../src/authorization/permissions/SparqlUpdateModesExtractor';
import type { Operation } from '../../../../src/http/Operation';
import { BasicRepresentation } from '../../../../src/http/representation/BasicRepresentation';
import type { ResourceIdentifier } from '../../../../src/http/representation/ResourceIdentifier';
import type { SparqlUpdatePatch } from '../../../../src/http/representation/SparqlUpdatePatch';
import type { ResourceSet } from '../../../../src/storage/ResourceSet';
import { NotImplementedHttpError } from '../../../../src/util/errors/NotImplementedHttpError';
import { IdentifierSetMultiMap } from '../../../../src/util/map/IdentifierMap';
import { compareMaps } from '../../../util/Util';
describe('A SparqlUpdateModesExtractor', (): void => {
const target: ResourceIdentifier = { path: 'http://example.com/foo' };
let patch: SparqlUpdatePatch;
let operation: Operation;
let resourceSet: jest.Mocked<ResourceSet>;
let extractor: SparqlUpdateModesExtractor;
const factory = new Factory();
function getMap(modes: AccessMode[], identifier?: ResourceIdentifier): AccessMap {
return new IdentifierSetMultiMap(
modes.map((mode): [ResourceIdentifier, AccessMode] => [ identifier ?? target, mode ]),
);
}
beforeEach(async(): Promise<void> => {
patch = new BasicRepresentation() as SparqlUpdatePatch;
operation = {
method: 'PATCH',
body: patch,
preferences: {},
target,
};
resourceSet = {
hasResource: jest.fn().mockResolvedValue(true),
};
@@ -19,7 +42,7 @@ describe('A SparqlUpdateModesExtractor', (): void => {
});
it('can only handle (composite) SPARQL DELETE/INSERT operations.', async(): Promise<void> => {
const operation = { method: 'PATCH', body: { algebra: factory.createDeleteInsert() }} as unknown as Operation;
patch.algebra = factory.createDeleteInsert();
await expect(extractor.canHandle(operation)).resolves.toBeUndefined();
(operation.body as SparqlUpdatePatch).algebra = factory.createCompositeUpdate([ factory.createDeleteInsert() ]);
await expect(extractor.canHandle(operation)).resolves.toBeUndefined();
@@ -28,75 +51,59 @@ describe('A SparqlUpdateModesExtractor', (): void => {
await expect(result).rejects.toThrow(NotImplementedHttpError);
await expect(result).rejects.toThrow('Cannot determine permissions of non-SPARQL patches.');
result = extractor.canHandle({ ...operation,
body: { algebra: factory.createMove('DEFAULT', 'DEFAULT') } as unknown as SparqlUpdatePatch });
patch.algebra = factory.createMove('DEFAULT', 'DEFAULT');
result = extractor.canHandle(operation);
await expect(result).rejects.toThrow(NotImplementedHttpError);
await expect(result).rejects.toThrow('Can only determine permissions of a PATCH with DELETE/INSERT operations.');
});
it('requires nothing for NOP operations.', async(): Promise<void> => {
const operation = {
method: 'PATCH',
body: { algebra: factory.createNop() },
} as unknown as Operation;
await expect(extractor.handle(operation)).resolves.toEqual(new Set());
patch.algebra = factory.createNop();
compareMaps(await extractor.handle(operation), getMap([]));
});
it('requires append for INSERT operations.', async(): Promise<void> => {
const operation = {
method: 'PATCH',
body: { algebra: factory.createDeleteInsert(undefined, [
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
]) },
} as unknown as Operation;
await expect(extractor.handle(operation)).resolves.toEqual(new Set([ AccessMode.append ]));
patch.algebra = factory.createDeleteInsert(undefined, [
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
]);
compareMaps(await extractor.handle(operation), getMap([ AccessMode.append ]));
});
it('requires create for INSERT operations if the resource does not exist.', async(): Promise<void> => {
resourceSet.hasResource.mockResolvedValueOnce(false);
const operation = {
method: 'PATCH',
body: { algebra: factory.createDeleteInsert(undefined, [
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
]) },
} as unknown as Operation;
await expect(extractor.handle(operation)).resolves.toEqual(new Set([ AccessMode.append, AccessMode.create ]));
patch.algebra = factory.createDeleteInsert(undefined, [
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
]);
compareMaps(await extractor.handle(operation), getMap([ AccessMode.append, AccessMode.create ]));
});
it('requires read and write for DELETE operations.', async(): Promise<void> => {
const operation = {
method: 'PATCH',
body: { algebra: factory.createDeleteInsert([
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
]) },
} as unknown as Operation;
await expect(extractor.handle(operation))
.resolves.toEqual(new Set([ AccessMode.read, AccessMode.write ]));
patch.algebra = factory.createDeleteInsert([
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
]);
compareMaps(await extractor.handle(operation), getMap([ AccessMode.read, AccessMode.write ]));
});
it('requires read and append for composite operations with an insert and conditions.', async(): Promise<void> => {
const operation = {
method: 'PATCH',
body: { algebra: factory.createCompositeUpdate([ factory.createDeleteInsert(undefined, [
patch.algebra = factory.createCompositeUpdate([
factory.createDeleteInsert(undefined, [
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
], factory.createBgp([
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
])) ]) },
} as unknown as Operation;
await expect(extractor.handle(operation)).resolves.toEqual(new Set([ AccessMode.append, AccessMode.read ]));
])),
]);
compareMaps(await extractor.handle(operation), getMap([ AccessMode.append, AccessMode.read ]));
});
it('requires read, write and append for composite operations with a delete and insert.', async(): Promise<void> => {
const operation = {
method: 'PATCH',
body: { algebra: factory.createCompositeUpdate([ factory.createDeleteInsert(undefined, [
patch.algebra = factory.createCompositeUpdate([
factory.createDeleteInsert(undefined, [
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
]),
factory.createDeleteInsert([
factory.createPattern(factory.createTerm('<s>'), factory.createTerm('<p>'), factory.createTerm('<o>')),
]) ]) },
} as unknown as Operation;
await expect(extractor.handle(operation))
.resolves.toEqual(new Set([ AccessMode.append, AccessMode.read, AccessMode.write ]));
]),
]);
compareMaps(await extractor.handle(operation), getMap([ AccessMode.append, AccessMode.read, AccessMode.write ]));
});
});