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

test: Avoid unnecessary nesting.

Browse Source
This commit is contained in:
Ruben Verborgh 2020-12-22 00:08:02 +01:00
parent e4c4d2a781
commit 9a89766858
6 changed files with 434 additions and 445 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
test/.eslintrc.js
View File

@ -12,10 +12,11 @@ module.exports = {
'no-process-env': 'off', 'no-process-env': 'off',
// We are not using Mocha // We are not using Mocha
'mocha/no-nested-tests': 'off',
'mocha/no-exports': 'off', 'mocha/no-exports': 'off',
'mocha/no-nested-tests': 'off',
'mocha/no-skipped-tests': 'off', 'mocha/no-skipped-tests': 'off',
'mocha/no-synchronous-tests': 'off', 'mocha/no-synchronous-tests': 'off',
'mocha/no-top-level-hooks': 'off',
// Need these 2 to run tests for throwing non-Error objects // Need these 2 to run tests for throwing non-Error objects
'@typescript-eslint/no-throw-literal': 'off', '@typescript-eslint/no-throw-literal': 'off',

302
test/integration/AuthenticatedLdpHandler.test.ts
View File

@ -19,169 +19,163 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
) as HttpHandler; ) as HttpHandler;
}); });
describe('with simple handlers', (): void => { it('can add, read and delete data based on incoming requests.', async(): Promise<void> => {
it('can add, read and delete data based on incoming requests.', async(): Promise<void> => { // POST
// POST let requestUrl = new URL('http://test.com/');
let requestUrl = new URL('http://test.com/'); let response: MockResponse<any> = await call(
let response: MockResponse<any> = await call( handler,
handler, requestUrl,
requestUrl, 'POST',
'POST', { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
{ 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' }, [ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ],
[ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ], );
); expect(response.statusCode).toBe(201);
expect(response.statusCode).toBe(201); expect(response._getData()).toHaveLength(0);
expect(response._getData()).toHaveLength(0); const id = response._getHeaders().location;
const id = response._getHeaders().location; expect(id).toContain(url.format(requestUrl));
expect(id).toContain(url.format(requestUrl));
// GET // GET
requestUrl = new URL(id); requestUrl = new URL(id);
response = await call( response = await call(
handler, handler,
requestUrl, requestUrl,
'GET', 'GET',
{ accept: 'text/turtle' }, { accept: 'text/turtle' },
[], [],
); );
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response._getData()).toContain( expect(response._getData()).toContain(
'<http://test.com/s> <http://test.com/p> <http://test.com/o>.', '<http://test.com/s> <http://test.com/p> <http://test.com/o>.',
); );
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`); expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE // DELETE
response = await call(handler, requestUrl, 'DELETE', {}, []); response = await call(handler, requestUrl, 'DELETE', {}, []);
expect(response.statusCode).toBe(205); expect(response.statusCode).toBe(205);
expect(response._getData()).toHaveLength(0); expect(response._getData()).toHaveLength(0);
// GET // GET
response = await call( response = await call(
handler, handler,
requestUrl, requestUrl,
'GET', 'GET',
{ accept: 'text/turtle' }, { accept: 'text/turtle' },
[], [],
); );
expect(response.statusCode).toBe(404); expect(response.statusCode).toBe(404);
expect(response._getData()).toContain('NotFoundHttpError'); expect(response._getData()).toContain('NotFoundHttpError');
});
}); });
describe('with simple PATCH handlers', (): void => { it('can handle simple SPARQL updates.', async(): Promise<void> => {
it('can handle simple SPARQL updates.', async(): Promise<void> => { // POST
// POST let requestUrl = new URL('http://test.com/');
let requestUrl = new URL('http://test.com/'); let response: MockResponse<any> = await call(
let response: MockResponse<any> = await call( handler,
handler, requestUrl,
requestUrl, 'POST',
'POST', { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
{ 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' }, [ '<http://test.com/s1> <http://test.com/p1> <http://test.com/o1>.',
[ '<http://test.com/s1> <http://test.com/p1> <http://test.com/o1>.', '<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.' ],
'<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.' ], );
); expect(response.statusCode).toBe(201);
expect(response.statusCode).toBe(201); expect(response._getData()).toHaveLength(0);
expect(response._getData()).toHaveLength(0); const id = response._getHeaders().location;
const id = response._getHeaders().location; expect(id).toContain(url.format(requestUrl));
expect(id).toContain(url.format(requestUrl));
// PATCH // PATCH
requestUrl = new URL(id); requestUrl = new URL(id);
response = await call( response = await call(
handler, handler,
requestUrl, requestUrl,
'PATCH', 'PATCH',
{ 'content-type': 'application/sparql-update', 'transfer-encoding': 'chunked' }, { 'content-type': 'application/sparql-update', 'transfer-encoding': 'chunked' },
[ 'DELETE { <http://test.com/s1> <http://test.com/p1> <http://test.com/o1> }', [ 'DELETE { <http://test.com/s1> <http://test.com/p1> <http://test.com/o1> }',
'INSERT {<http://test.com/s3> <http://test.com/p3> <http://test.com/o3>}', 'INSERT {<http://test.com/s3> <http://test.com/p3> <http://test.com/o3>}',
'WHERE {}', 'WHERE {}',
], ],
); );
expect(response.statusCode).toBe(205); expect(response.statusCode).toBe(205);
expect(response._getData()).toHaveLength(0); expect(response._getData()).toHaveLength(0);
// GET // GET
requestUrl = new URL(id); requestUrl = new URL(id);
response = await call( response = await call(
handler, handler,
requestUrl, requestUrl,
'GET', 'GET',
{ accept: 'text/turtle' }, { accept: 'text/turtle' },
[], [],
); );
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain( expect(response._getBuffer().toString()).toContain(
'<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.',
);
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
const parser = new Parser();
const triples = parser.parse(response._getBuffer().toString());
expect(triples).toBeRdfIsomorphic([
quad(
namedNode('http://test.com/s2'),
namedNode('http://test.com/p2'),
namedNode('http://test.com/o2'),
),
quad(
namedNode('http://test.com/s3'),
namedNode('http://test.com/p3'),
namedNode('http://test.com/o3'),
),
]);
});
it('should overwrite the content on PUT request.', async(): Promise<void> => {
// POST
let requestUrl = new URL('http://test.com/');
let response: MockResponse<any> = await call(
handler,
requestUrl,
'POST',
{ 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
[
'<http://test.com/s1> <http://test.com/p1> <http://test.com/o1>.',
'<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.', '<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.',
); ],
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`); );
const parser = new Parser(); expect(response.statusCode).toBe(201);
const triples = parser.parse(response._getBuffer().toString()); expect(response._getData()).toHaveLength(0);
expect(triples).toBeRdfIsomorphic([ const id = response._getHeaders().location;
quad( expect(id).toContain(url.format(requestUrl));
namedNode('http://test.com/s2'),
namedNode('http://test.com/p2'),
namedNode('http://test.com/o2'),
),
quad(
namedNode('http://test.com/s3'),
namedNode('http://test.com/p3'),
namedNode('http://test.com/o3'),
),
]);
});
});
describe('with simple PUT handlers', (): void => { // PUT
it('should overwrite the content on PUT request.', async(): Promise<void> => { requestUrl = new URL(id);
// POST response = await call(
let requestUrl = new URL('http://test.com/'); handler,
let response: MockResponse<any> = await call( requestUrl,
handler, 'PUT',
requestUrl, { 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' },
'POST', [ '<http://test.com/s3> <http://test.com/p3> <http://test.com/o3>.' ],
{ 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' }, );
[ expect(response.statusCode).toBe(205);
'<http://test.com/s1> <http://test.com/p1> <http://test.com/o1>.', expect(response._getData()).toHaveLength(0);
'<http://test.com/s2> <http://test.com/p2> <http://test.com/o2>.',
],
);
expect(response.statusCode).toBe(201);
expect(response._getData()).toHaveLength(0);
const id = response._getHeaders().location;
expect(id).toContain(url.format(requestUrl));
// PUT // GET
requestUrl = new URL(id); requestUrl = new URL(id);
response = await call( response = await call(
handler, handler,
requestUrl, requestUrl,
'PUT', 'GET',
{ 'content-type': 'text/turtle', 'transfer-encoding': 'chunked' }, { accept: 'text/turtle' },
[ '<http://test.com/s3> <http://test.com/p3> <http://test.com/o3>.' ], [],
); );
expect(response.statusCode).toBe(205); expect(response.statusCode).toBe(200);
expect(response._getData()).toHaveLength(0); expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
const parser = new Parser();
// GET const triples = parser.parse(response._getData());
requestUrl = new URL(id); expect(triples).toBeRdfIsomorphic([
response = await call( quad(
handler, namedNode('http://test.com/s3'),
requestUrl, namedNode('http://test.com/p3'),
'GET', namedNode('http://test.com/o3'),
{ accept: 'text/turtle' }, ),
[], ]);
);
expect(response.statusCode).toBe(200);
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
const parser = new Parser();
const triples = parser.parse(response._getData());
expect(triples).toBeRdfIsomorphic([
quad(
namedNode('http://test.com/s3'),
namedNode('http://test.com/p3'),
namedNode('http://test.com/o3'),
),
]);
});
}); });
}); });

2
test/integration/Authorization.test.ts
View File

@ -61,7 +61,7 @@ describe('A server with authorization', (): void => {
expect(response.statusCode).toBe(205); expect(response.statusCode).toBe(205);
}); });
it('can not create new entries if not allowed.', async(): Promise<void> => { it('cannot create new entries if not allowed.', async(): Promise<void> => {
await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'authenticated'); await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'authenticated');
// POST // POST

178
test/integration/FullConfig.acl.test.ts
View File

@ -26,100 +26,98 @@ const stores: [string, any][] = [
}], }],
]; ];
describe.each(stores)('A server using %s', (name, { storeUrn, setup, teardown }): void => { describe.each(stores)('An LDP handler with auth using %s', (name, { storeUrn, setup, teardown }): void => {
describe('with acl', (): void => { let handler: HttpHandler;
let handler: HttpHandler; let aclHelper: AclTestHelper;
let aclHelper: AclTestHelper; let fileHelper: FileTestHelper;
let fileHelper: FileTestHelper;
beforeAll(async(): Promise<void> => { beforeAll(async(): Promise<void> => {
// Set up the internal store // Set up the internal store
await setup(); await setup();
const variables: Record<string, any> = { const variables: Record<string, any> = {
'urn:solid-server:default:variable:baseUrl': BASE, 'urn:solid-server:default:variable:baseUrl': BASE,
'urn:solid-server:default:variable:rootFilePath': rootFilePath, 'urn:solid-server:default:variable:rootFilePath': rootFilePath,
}; };
const internalStore = await instantiateFromConfig( const internalStore = await instantiateFromConfig(
storeUrn, storeUrn,
'auth-ldp-handler.json', 'auth-ldp-handler.json',
variables, variables,
) as ResourceStore; ) as ResourceStore;
variables['urn:solid-server:default:variable:store'] = internalStore; variables['urn:solid-server:default:variable:store'] = internalStore;
// Create and initialize the HTTP handler and related components // Create and initialize the HTTP handler and related components
let initializer: Initializer; let initializer: Initializer;
let store: ResourceStore; let store: ResourceStore;
const instances = await instantiateFromConfig( const instances = await instantiateFromConfig(
'urn:solid-server:test:Instances', 'urn:solid-server:test:Instances',
'auth-ldp-handler.json', 'auth-ldp-handler.json',
variables, variables,
) as Record<string, any>; ) as Record<string, any>;
({ handler, store, initializer } = instances); ({ handler, store, initializer } = instances);
await initializer.handleSafe(); await initializer.handleSafe();
// Create test helpers for manipulating the components // Create test helpers for manipulating the components
aclHelper = new AclTestHelper(store, BASE); aclHelper = new AclTestHelper(store, BASE);
fileHelper = new FileTestHelper(handler, new URL(BASE)); fileHelper = new FileTestHelper(handler, new URL(BASE));
// Write test resource // Write test resource
await store.setRepresentation({ path: `${BASE}/permanent.txt` }, { await store.setRepresentation({ path: `${BASE}/permanent.txt` }, {
binary: true, binary: true,
data: guardStream(createReadStream(join(__dirname, '../assets/permanent.txt'))), data: guardStream(createReadStream(join(__dirname, '../assets/permanent.txt'))),
metadata: new RepresentationMetadata({ [CONTENT_TYPE]: 'text/plain' }), metadata: new RepresentationMetadata({ [CONTENT_TYPE]: 'text/plain' }),
});
});
afterAll(async(): Promise<void> => {
await teardown();
});
it('can add a file to the store, read it and delete it if allowed.', async():
Promise<void> => {
// Set acl
await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'agent');
// Create file
let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain');
const id = response._getHeaders().location;
// Get file
response = await fileHelper.getFile(id);
expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('TESTFILE2');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE file
await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id);
});
it('can not add a file to the store if not allowed.', async():
Promise<void> => {
// Set acl
await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'authenticated');
// Try to create file
const response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true);
expect(response.statusCode).toBe(401);
});
it('can not add/delete, but only read files if allowed.', async():
Promise<void> => {
// Set acl
await aclHelper.setSimpleAcl({ read: true, write: false, append: false }, 'agent');
// Try to create file
let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true);
expect(response.statusCode).toBe(401);
// GET permanent file
response = await fileHelper.getFile('http://test.com/permanent.txt');
expect(response._getBuffer().toString()).toContain('TEST');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// Try to delete permanent file
response = await fileHelper.deleteResource('http://test.com/permanent.txt', true);
expect(response.statusCode).toBe(401);
}); });
}); });
afterAll(async(): Promise<void> => {
await teardown();
});
it('can add a file to the store, read it and delete it if allowed.', async():
Promise<void> => {
// Set acl
await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'agent');
// Create file
let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain');
const id = response._getHeaders().location;
// Get file
response = await fileHelper.getFile(id);
expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('TESTFILE2');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE file
await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id);
});
it('can not add a file to the store if not allowed.', async():
Promise<void> => {
// Set acl
await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'authenticated');
// Try to create file
const response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true);
expect(response.statusCode).toBe(401);
});
it('can not add/delete, but only read files if allowed.', async():
Promise<void> => {
// Set acl
await aclHelper.setSimpleAcl({ read: true, write: false, append: false }, 'agent');
// Try to create file
let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true);
expect(response.statusCode).toBe(401);
// GET permanent file
response = await fileHelper.getFile('http://test.com/permanent.txt');
expect(response._getBuffer().toString()).toContain('TEST');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// Try to delete permanent file
response = await fileHelper.deleteResource('http://test.com/permanent.txt', true);
expect(response.statusCode).toBe(401);
});
}); });

326
test/integration/FullConfig.noAuth.test.ts
View File

@ -23,204 +23,202 @@ const stores: [string, any][] = [
}], }],
]; ];
describe.each(stores)('A server using %s', (name, { storeUrn, setup, teardown }): void => { describe.each(stores)('An LDP handler without auth using %s', (name, { storeUrn, setup, teardown }): void => {
describe('without acl', (): void => { let handler: HttpHandler;
let handler: HttpHandler; let fileHelper: FileTestHelper;
let fileHelper: FileTestHelper;
beforeAll(async(): Promise<void> => { beforeAll(async(): Promise<void> => {
// Set up the internal store // Set up the internal store
await setup(); await setup();
const variables: Record<string, any> = { const variables: Record<string, any> = {
'urn:solid-server:default:variable:baseUrl': BASE, 'urn:solid-server:default:variable:baseUrl': BASE,
'urn:solid-server:default:variable:rootFilePath': rootFilePath, 'urn:solid-server:default:variable:rootFilePath': rootFilePath,
}; };
const internalStore = await instantiateFromConfig( const internalStore = await instantiateFromConfig(
storeUrn, storeUrn,
'auth-ldp-handler.json', 'auth-ldp-handler.json',
variables, variables,
) as ResourceStore; ) as ResourceStore;
variables['urn:solid-server:default:variable:store'] = internalStore; variables['urn:solid-server:default:variable:store'] = internalStore;
// Create and initialize the HTTP handler and related components // Create and initialize the HTTP handler and related components
let initializer: Initializer; let initializer: Initializer;
const instances = await instantiateFromConfig( const instances = await instantiateFromConfig(
'urn:solid-server:test:Instances', 'urn:solid-server:test:Instances',
'auth-ldp-handler.json', 'auth-ldp-handler.json',
variables, variables,
) as Record<string, any>; ) as Record<string, any>;
({ handler, initializer } = instances); ({ handler, initializer } = instances);
await initializer.handleSafe(); await initializer.handleSafe();
// Create test helpers for manipulating the components // Create test helpers for manipulating the components
fileHelper = new FileTestHelper(handler, new URL(BASE)); fileHelper = new FileTestHelper(handler, new URL(BASE));
}); });
afterAll(async(): Promise<void> => { afterAll(async(): Promise<void> => {
await teardown(); await teardown();
}); });
it('can add a file to the store, read it and delete it.', async(): it('can add a file to the store, read it and delete it.', async():
Promise<void> => { Promise<void> => {
// POST // POST
let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfile0.txt', 'text/plain'); let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfile0.txt', 'text/plain');
const id = response._getHeaders().location; const id = response._getHeaders().location;
// GET // GET
response = await fileHelper.getFile(id); response = await fileHelper.getFile(id);
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('TESTFILE0'); expect(response._getBuffer().toString()).toContain('TESTFILE0');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`); expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE // DELETE
await fileHelper.deleteResource(id); await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id); await fileHelper.shouldNotExist(id);
}); });
it('can add and overwrite a file.', async(): Promise<void> => { it('can add and overwrite a file.', async(): Promise<void> => {
let response = await fileHelper.createFile('../assets/testfile0.txt', 'file.txt', 'text/plain'); let response = await fileHelper.createFile('../assets/testfile0.txt', 'file.txt', 'text/plain');
const id = response._getHeaders().location; const id = response._getHeaders().location;
// GET // GET
response = await fileHelper.getFile(id); response = await fileHelper.getFile(id);
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('TESTFILE0'); expect(response._getBuffer().toString()).toContain('TESTFILE0');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`); expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// PUT // PUT
response = await fileHelper.overwriteFile('../assets/testfile1.txt', id, 'text/plain'); response = await fileHelper.overwriteFile('../assets/testfile1.txt', id, 'text/plain');
// GET // GET
response = await fileHelper.getFile(id); response = await fileHelper.getFile(id);
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('TESTFILE1'); expect(response._getBuffer().toString()).toContain('TESTFILE1');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`); expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE // DELETE
await fileHelper.deleteResource(id); await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id); await fileHelper.shouldNotExist(id);
}); });
it('can create a folder and delete it.', async(): Promise<void> => { it('can create a folder and delete it.', async(): Promise<void> => {
// POST // POST
let response = await fileHelper.createFolder('secondfolder/'); let response = await fileHelper.createFolder('secondfolder/');
const id = response._getHeaders().location; const id = response._getHeaders().location;
// GET // GET
response = await fileHelper.getFolder(id); response = await fileHelper.getFolder(id);
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response.getHeaders().link).toEqual( expect(response.getHeaders().link).toEqual(
[ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ], [ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ],
); );
// DELETE // DELETE
await fileHelper.deleteResource(id); await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id); await fileHelper.shouldNotExist(id);
}); });
it('can make a folder and put a file in it.', async(): Promise<void> => { it('can make a folder and put a file in it.', async(): Promise<void> => {
// Create folder // Create folder
await fileHelper.createFolder('testfolder0/'); await fileHelper.createFolder('testfolder0/');
// Create file // Create file
let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder0/testfile0.txt', 'text/plain'); let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder0/testfile0.txt', 'text/plain');
const id = response._getHeaders().location; const id = response._getHeaders().location;
// GET File // GET File
response = await fileHelper.getFile(id); response = await fileHelper.getFile(id);
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`); expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE // DELETE
await fileHelper.deleteResource(id); await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id); await fileHelper.shouldNotExist(id);
await fileHelper.deleteResource('http://test.com/testfolder0/'); await fileHelper.deleteResource('http://test.com/testfolder0/');
await fileHelper.shouldNotExist('http://test.com/testfolder0/'); await fileHelper.shouldNotExist('http://test.com/testfolder0/');
}); });
it('cannot remove a folder when the folder contains a file.', async(): Promise<void> => { it('cannot remove a folder when the folder contains a file.', async(): Promise<void> => {
// Create folder // Create folder
let response = await fileHelper.createFolder('testfolder1/'); let response = await fileHelper.createFolder('testfolder1/');
const folderId = response._getHeaders().location; const folderId = response._getHeaders().location;
// Create file // Create file
await fileHelper.createFile('../assets/testfile0.txt', 'testfolder1/testfile0.txt', 'text/plain'); await fileHelper.createFile('../assets/testfile0.txt', 'testfolder1/testfile0.txt', 'text/plain');
// Try DELETE folder // Try DELETE folder
response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {}); response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {});
expect(response.statusCode).toBe(409); expect(response.statusCode).toBe(409);
expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.'); expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.');
// DELETE // DELETE
await fileHelper.deleteResource('http://test.com/testfolder1/testfile0.txt'); await fileHelper.deleteResource('http://test.com/testfolder1/testfile0.txt');
await fileHelper.shouldNotExist('http://test.com/testfolder1/testfile0.txt'); await fileHelper.shouldNotExist('http://test.com/testfolder1/testfile0.txt');
await fileHelper.deleteResource(folderId); await fileHelper.deleteResource(folderId);
await fileHelper.shouldNotExist(folderId); await fileHelper.shouldNotExist(folderId);
}); });
it('cannot remove a folder when the folder contains a subfolder.', async(): Promise<void> => { it('cannot remove a folder when the folder contains a subfolder.', async(): Promise<void> => {
// Create folder // Create folder
let response = await fileHelper.createFolder('testfolder2/'); let response = await fileHelper.createFolder('testfolder2/');
const folderId = response._getHeaders().location; const folderId = response._getHeaders().location;
// Create subfolder // Create subfolder
response = await fileHelper.createFolder('testfolder2/subfolder0'); response = await fileHelper.createFolder('testfolder2/subfolder0');
const subFolderId = response._getHeaders().location; const subFolderId = response._getHeaders().location;
// Try DELETE folder // Try DELETE folder
response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {}); response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {});
expect(response.statusCode).toBe(409); expect(response.statusCode).toBe(409);
expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.'); expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.');
// DELETE // DELETE
await fileHelper.deleteResource(subFolderId); await fileHelper.deleteResource(subFolderId);
await fileHelper.shouldNotExist(subFolderId); await fileHelper.shouldNotExist(subFolderId);
await fileHelper.deleteResource(folderId); await fileHelper.deleteResource(folderId);
await fileHelper.shouldNotExist(folderId); await fileHelper.shouldNotExist(folderId);
}); });
it('can read the contents of a folder.', async(): Promise<void> => { it('can read the contents of a folder.', async(): Promise<void> => {
// Create folder // Create folder
let response = await fileHelper.createFolder('testfolder3/'); let response = await fileHelper.createFolder('testfolder3/');
const folderId = response._getHeaders().location; const folderId = response._getHeaders().location;
// Create subfolder // Create subfolder
response = await fileHelper.createFolder('testfolder3/subfolder0/'); response = await fileHelper.createFolder('testfolder3/subfolder0/');
const subFolderId = response._getHeaders().location; const subFolderId = response._getHeaders().location;
// Create file // Create file
response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder3/testfile0.txt', 'text/plain'); response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder3/testfile0.txt', 'text/plain');
const fileId = response._getHeaders().location; const fileId = response._getHeaders().location;
response = await fileHelper.getFolder(folderId); response = await fileHelper.getFolder(folderId);
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/subfolder0/> .'); expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/subfolder0/> .');
expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/testfile0.txt> .'); expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/testfile0.txt> .');
expect(response.getHeaders().link).toEqual( expect(response.getHeaders().link).toEqual(
[ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ], [ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ],
); );
// DELETE // DELETE
await fileHelper.deleteResource(fileId); await fileHelper.deleteResource(fileId);
await fileHelper.shouldNotExist(fileId); await fileHelper.shouldNotExist(fileId);
await fileHelper.deleteResource(subFolderId); await fileHelper.deleteResource(subFolderId);
await fileHelper.shouldNotExist(subFolderId); await fileHelper.shouldNotExist(subFolderId);
await fileHelper.deleteResource(folderId); await fileHelper.deleteResource(folderId);
await fileHelper.shouldNotExist(folderId); await fileHelper.shouldNotExist(folderId);
}); });
it('can upload and delete a image.', async(): Promise<void> => { it('can upload and delete a image.', async(): Promise<void> => {
let response = await fileHelper.createFile('../assets/testimage.png', 'image.png', 'image/png'); let response = await fileHelper.createFile('../assets/testimage.png', 'image.png', 'image/png');
const fileId = response._getHeaders().location; const fileId = response._getHeaders().location;
// GET // GET
response = await fileHelper.getFile(fileId); response = await fileHelper.getFile(fileId);
expect(response.statusCode).toBe(200); expect(response.statusCode).toBe(200);
expect(response._getHeaders()['content-type']).toBe('image/png'); expect(response._getHeaders()['content-type']).toBe('image/png');
// DELETE // DELETE
await fileHelper.deleteResource(fileId); await fileHelper.deleteResource(fileId);
await fileHelper.shouldNotExist(fileId); await fileHelper.shouldNotExist(fileId);
});
}); });
}); });

68
test/integration/SparqlStorage.test.ts
View File

@ -2,44 +2,42 @@ import type { HttpHandler, Initializer, ResourceStore } from '../../src/';
import { describeIf, FileTestHelper } from '../util/TestHelpers'; import { describeIf, FileTestHelper } from '../util/TestHelpers';
import { BASE, instantiateFromConfig } from './Config'; import { BASE, instantiateFromConfig } from './Config';
describeIf('docker', 'a server with a SPARQL endpoint as storage', (): void => { describeIf('docker', 'A server with a SPARQL endpoint as storage', (): void => {
describe('without acl', (): void => { let handler: HttpHandler;
let handler: HttpHandler; let fileHelper: FileTestHelper;
let fileHelper: FileTestHelper;
beforeAll(async(): Promise<void> => { beforeAll(async(): Promise<void> => {
// Set up the internal store // Set up the internal store
const variables: Record<string, any> = { const variables: Record<string, any> = {
'urn:solid-server:default:variable:baseUrl': BASE, 'urn:solid-server:default:variable:baseUrl': BASE,
'urn:solid-server:default:variable:sparqlEndpoint': 'http://localhost:4000/sparql', 'urn:solid-server:default:variable:sparqlEndpoint': 'http://localhost:4000/sparql',
}; };
const internalStore = await instantiateFromConfig( const internalStore = await instantiateFromConfig(
'urn:solid-server:default:SparqlResourceStore', 'urn:solid-server:default:SparqlResourceStore',
'auth-ldp-handler.json', 'auth-ldp-handler.json',
variables, variables,
) as ResourceStore; ) as ResourceStore;
variables['urn:solid-server:default:variable:store'] = internalStore; variables['urn:solid-server:default:variable:store'] = internalStore;
// Create and initialize the HTTP handler and related components // Create and initialize the HTTP handler and related components
let initializer: Initializer; let initializer: Initializer;
const instances = await instantiateFromConfig( const instances = await instantiateFromConfig(
'urn:solid-server:test:Instances', 'urn:solid-server:test:Instances',
'auth-ldp-handler.json', 'auth-ldp-handler.json',
variables, variables,
) as Record<string, any>; ) as Record<string, any>;
({ handler, initializer } = instances); ({ handler, initializer } = instances);
await initializer.handleSafe(); await initializer.handleSafe();
// Create test helpers for manipulating the components // Create test helpers for manipulating the components
fileHelper = new FileTestHelper(handler, new URL(BASE)); fileHelper = new FileTestHelper(handler, new URL(BASE));
}); });
it('can add a Turtle file to the store.', async(): it('can add a Turtle file to the store.', async():
Promise<void> => { Promise<void> => {
// POST // POST
const response = await fileHelper.createFile('../assets/person.ttl', 'person', 'text/turtle'); const response = await fileHelper.createFile('../assets/person.ttl', 'person', 'text/turtle');
const id = response._getHeaders().location; const id = response._getHeaders().location;
expect(id).toBeTruthy(); expect(id).toBeTruthy();
});
}); });
}); });