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: Make helper terminology consistent.

Browse Source
This commit is contained in:
Ruben Verborgh
2020-12-22 01:02:19 +01:00
parent 9dcb4fb603
commit af8524e0d6
7 changed files with 129 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
test/integration/LdpHandlerWithAuth.test.ts
View File

@@ -4,7 +4,7 @@ import type { HttpHandler, Initializer, ResourceStore } from '../../src/';
import { RepresentationMetadata } from '../../src/ldp/representation/RepresentationMetadata';
import { guardStream } from '../../src/util/GuardedStream';
import { CONTENT_TYPE, LDP } from '../../src/util/UriConstants';
import { AclTestHelper, FileTestHelper } from '../util/TestHelpers';
import { AclHelper, ResourceHelper } from '../util/TestHelpers';
import { BASE, getTestFolder, createFolder, removeFolder, instantiateFromConfig } from './Config';
const rootFilePath = getTestFolder('full-config-acl');
@@ -23,8 +23,8 @@ const stores: [string, any][] = [
describe.each(stores)('An LDP handler with auth using %s', (name, { storeUrn, setup, teardown }): void => {
let handler: HttpHandler;
let aclHelper: AclTestHelper;
let fileHelper: FileTestHelper;
let aclHelper: AclHelper;
let resourceHelper: ResourceHelper;
beforeAll(async(): Promise<void> => {
// Set up the internal store
@@ -52,8 +52,8 @@ describe.each(stores)('An LDP handler with auth using %s', (name, { storeUrn, se
await initializer.handleSafe();
// Create test helpers for manipulating the components
aclHelper = new AclTestHelper(store, BASE);
fileHelper = new FileTestHelper(handler, new URL(BASE));
aclHelper = new AclHelper(store, BASE);
resourceHelper = new ResourceHelper(handler, BASE);
// Write test resource
await store.setRepresentation({ path: `${BASE}/permanent.txt` }, {
@@ -73,18 +73,20 @@ describe.each(stores)('An LDP handler with auth using %s', (name, { storeUrn, se
await aclHelper.setSimpleAcl({ read: true, write: true, append: true }, 'agent');
// Create file
let response = await fileHelper.createFile('../assets/testfile2.txt', 'testfile2.txt', 'text/plain');
let response = await resourceHelper.createResource(
'../assets/testfile2.txt', 'testfile2.txt', 'text/plain',
);
const id = response._getHeaders().location;
// Get file
response = await fileHelper.getFile(id);
response = await resourceHelper.getResource(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);
await resourceHelper.deleteResource(id);
await resourceHelper.shouldNotExist(id);
});
it('can not add a file to the store if not allowed.', async():
@@ -93,7 +95,9 @@ describe.each(stores)('An LDP handler with auth using %s', (name, { storeUrn, se
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);
const response = await resourceHelper.createResource(
'../assets/testfile2.txt', 'testfile2.txt', 'text/plain', true,
);
expect(response.statusCode).toBe(401);
});
@@ -103,16 +107,18 @@ describe.each(stores)('An LDP handler with auth using %s', (name, { storeUrn, se
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);
let response = await resourceHelper.createResource(
'../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');
response = await resourceHelper.getResource('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);
response = await resourceHelper.deleteResource('http://test.com/permanent.txt', true);
expect(response.statusCode).toBe(401);
});
});

118
test/integration/LdpHandlerWithoutAuth.test.ts
View File

@@ -1,6 +1,6 @@
import type { HttpHandler, Initializer, ResourceStore } from '../../src/';
import { LDP } from '../../src/util/UriConstants';
import { FileTestHelper } from '../util/TestHelpers';
import { ResourceHelper } from '../util/TestHelpers';
import { BASE, getTestFolder, createFolder, removeFolder, instantiateFromConfig } from './Config';
const rootFilePath = getTestFolder('full-config-no-auth');
@@ -19,7 +19,7 @@ const stores: [string, any][] = [
describe.each(stores)('An LDP handler without auth using %s', (name, { storeUrn, setup, teardown }): void => {
let handler: HttpHandler;
let fileHelper: FileTestHelper;
let resourceHelper: ResourceHelper;
beforeAll(async(): Promise<void> => {
// Set up the internal store
@@ -46,7 +46,7 @@ describe.each(stores)('An LDP handler without auth using %s', (name, { storeUrn,
await initializer.handleSafe();
// Create test helpers for manipulating the components
fileHelper = new FileTestHelper(handler, new URL(BASE));
resourceHelper = new ResourceHelper(handler, BASE);
});
afterAll(async(): Promise<void> => {
@@ -56,136 +56,148 @@ describe.each(stores)('An LDP handler without auth using %s', (name, { storeUrn,
it('can add a file to the store, read it and delete it.', async():
Promise<void> => {
// POST
let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfile0.txt', 'text/plain');
let response = await resourceHelper.createResource(
'../assets/testfile0.txt', 'testfile0.txt', 'text/plain',
);
const id = response._getHeaders().location;
// GET
response = await fileHelper.getFile(id);
response = await resourceHelper.getResource(id);
expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('TESTFILE0');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE
await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id);
await resourceHelper.deleteResource(id);
await resourceHelper.shouldNotExist(id);
});
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 resourceHelper.createResource(
'../assets/testfile0.txt', 'file.txt', 'text/plain',
);
const id = response._getHeaders().location;
// GET
response = await fileHelper.getFile(id);
response = await resourceHelper.getResource(id);
expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('TESTFILE0');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// PUT
response = await fileHelper.overwriteFile('../assets/testfile1.txt', id, 'text/plain');
response = await resourceHelper.replaceResource(
'../assets/testfile1.txt', id, 'text/plain',
);
// GET
response = await fileHelper.getFile(id);
response = await resourceHelper.getResource(id);
expect(response.statusCode).toBe(200);
expect(response._getBuffer().toString()).toContain('TESTFILE1');
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE
await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id);
await resourceHelper.deleteResource(id);
await resourceHelper.shouldNotExist(id);
});
it('can create a folder and delete it.', async(): Promise<void> => {
// POST
let response = await fileHelper.createFolder('secondfolder/');
let response = await resourceHelper.createContainer('secondfolder/');
const id = response._getHeaders().location;
// GET
response = await fileHelper.getFolder(id);
response = await resourceHelper.getContainer(id);
expect(response.statusCode).toBe(200);
expect(response.getHeaders().link).toEqual(
[ `<${LDP.Container}>; rel="type"`, `<${LDP.BasicContainer}>; rel="type"`, `<${LDP.Resource}>; rel="type"` ],
);
// DELETE
await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id);
await resourceHelper.deleteResource(id);
await resourceHelper.shouldNotExist(id);
});
it('can make a folder and put a file in it.', async(): Promise<void> => {
// Create folder
await fileHelper.createFolder('testfolder0/');
await resourceHelper.createContainer('testfolder0/');
// Create file
let response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder0/testfile0.txt', 'text/plain');
let response = await resourceHelper.createResource(
'../assets/testfile0.txt', 'testfolder0/testfile0.txt', 'text/plain',
);
const id = response._getHeaders().location;
// GET File
response = await fileHelper.getFile(id);
response = await resourceHelper.getResource(id);
expect(response.statusCode).toBe(200);
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE
await fileHelper.deleteResource(id);
await fileHelper.shouldNotExist(id);
await fileHelper.deleteResource('http://test.com/testfolder0/');
await fileHelper.shouldNotExist('http://test.com/testfolder0/');
await resourceHelper.deleteResource(id);
await resourceHelper.shouldNotExist(id);
await resourceHelper.deleteResource('http://test.com/testfolder0/');
await resourceHelper.shouldNotExist('http://test.com/testfolder0/');
});
it('cannot remove a folder when the folder contains a file.', async(): Promise<void> => {
// Create folder
let response = await fileHelper.createFolder('testfolder1/');
let response = await resourceHelper.createContainer('testfolder1/');
const folderId = response._getHeaders().location;
// Create file
await fileHelper.createFile('../assets/testfile0.txt', 'testfolder1/testfile0.txt', 'text/plain');
await resourceHelper.createResource(
'../assets/testfile0.txt', 'testfolder1/testfile0.txt', 'text/plain',
);
// Try DELETE folder
response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {});
response = await resourceHelper.performRequest(new URL(folderId), 'DELETE', {});
expect(response.statusCode).toBe(409);
expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.');
// DELETE
await fileHelper.deleteResource('http://test.com/testfolder1/testfile0.txt');
await fileHelper.shouldNotExist('http://test.com/testfolder1/testfile0.txt');
await fileHelper.deleteResource(folderId);
await fileHelper.shouldNotExist(folderId);
await resourceHelper.deleteResource('http://test.com/testfolder1/testfile0.txt');
await resourceHelper.shouldNotExist('http://test.com/testfolder1/testfile0.txt');
await resourceHelper.deleteResource(folderId);
await resourceHelper.shouldNotExist(folderId);
});
it('cannot remove a folder when the folder contains a subfolder.', async(): Promise<void> => {
// Create folder
let response = await fileHelper.createFolder('testfolder2/');
let response = await resourceHelper.createContainer('testfolder2/');
const folderId = response._getHeaders().location;
// Create subfolder
response = await fileHelper.createFolder('testfolder2/subfolder0');
response = await resourceHelper.createContainer('testfolder2/subfolder0');
const subFolderId = response._getHeaders().location;
// Try DELETE folder
response = await fileHelper.simpleCall(new URL(folderId), 'DELETE', {});
response = await resourceHelper.performRequest(new URL(folderId), 'DELETE', {});
expect(response.statusCode).toBe(409);
expect(response._getData()).toContain('ConflictHttpError: Can only delete empty containers.');
// DELETE
await fileHelper.deleteResource(subFolderId);
await fileHelper.shouldNotExist(subFolderId);
await fileHelper.deleteResource(folderId);
await fileHelper.shouldNotExist(folderId);
await resourceHelper.deleteResource(subFolderId);
await resourceHelper.shouldNotExist(subFolderId);
await resourceHelper.deleteResource(folderId);
await resourceHelper.shouldNotExist(folderId);
});
it('can read the contents of a folder.', async(): Promise<void> => {
// Create folder
let response = await fileHelper.createFolder('testfolder3/');
let response = await resourceHelper.createContainer('testfolder3/');
const folderId = response._getHeaders().location;
// Create subfolder
response = await fileHelper.createFolder('testfolder3/subfolder0/');
response = await resourceHelper.createContainer('testfolder3/subfolder0/');
const subFolderId = response._getHeaders().location;
// Create file
response = await fileHelper.createFile('../assets/testfile0.txt', 'testfolder3/testfile0.txt', 'text/plain');
response = await resourceHelper.createResource(
'../assets/testfile0.txt', 'testfolder3/testfile0.txt', 'text/plain',
);
const fileId = response._getHeaders().location;
response = await fileHelper.getFolder(folderId);
response = await resourceHelper.getContainer(folderId);
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/testfile0.txt> .');
@@ -194,25 +206,27 @@ describe.each(stores)('An LDP handler without auth using %s', (name, { storeUrn,
);
// DELETE
await fileHelper.deleteResource(fileId);
await fileHelper.shouldNotExist(fileId);
await fileHelper.deleteResource(subFolderId);
await fileHelper.shouldNotExist(subFolderId);
await fileHelper.deleteResource(folderId);
await fileHelper.shouldNotExist(folderId);
await resourceHelper.deleteResource(fileId);
await resourceHelper.shouldNotExist(fileId);
await resourceHelper.deleteResource(subFolderId);
await resourceHelper.shouldNotExist(subFolderId);
await resourceHelper.deleteResource(folderId);
await resourceHelper.shouldNotExist(folderId);
});
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 resourceHelper.createResource(
'../assets/testimage.png', 'image.png', 'image/png',
);
const fileId = response._getHeaders().location;
// GET
response = await fileHelper.getFile(fileId);
response = await resourceHelper.getResource(fileId);
expect(response.statusCode).toBe(200);
expect(response._getHeaders()['content-type']).toBe('image/png');
// DELETE
await fileHelper.deleteResource(fileId);
await fileHelper.shouldNotExist(fileId);
await resourceHelper.deleteResource(fileId);
await resourceHelper.shouldNotExist(fileId);
});
});

22
test/integration/LpdHandlerOperations.test.ts
View File

@@ -5,7 +5,7 @@ import { Parser } from 'n3';
import type { MockResponse } from 'node-mocks-http';
import type { HttpHandler } from '../../src/server/HttpHandler';
import { LDP } from '../../src/util/UriConstants';
import { call } from '../util/Util';
import { performRequest } from '../util/Util';
import { BASE, instantiateFromConfig } from './Config';
describe('An integrated AuthenticatedLdpHandler', (): void => {
@@ -22,7 +22,7 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
it('can add, read and delete data based on incoming requests.', async(): Promise<void> => {
// POST
let requestUrl = new URL('http://test.com/');
let response: MockResponse<any> = await call(
let response: MockResponse<any> = await performRequest(
handler,
requestUrl,
'POST',
@@ -36,7 +36,7 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
// GET
requestUrl = new URL(id);
response = await call(
response = await performRequest(
handler,
requestUrl,
'GET',
@@ -50,12 +50,12 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
expect(response.getHeaders().link).toBe(`<${LDP.Resource}>; rel="type"`);
// DELETE
response = await call(handler, requestUrl, 'DELETE', {}, []);
response = await performRequest(handler, requestUrl, 'DELETE', {}, []);
expect(response.statusCode).toBe(205);
expect(response._getData()).toHaveLength(0);
// GET
response = await call(
response = await performRequest(
handler,
requestUrl,
'GET',
@@ -69,7 +69,7 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
it('can handle simple SPARQL updates.', async(): Promise<void> => {
// POST
let requestUrl = new URL('http://test.com/');
let response: MockResponse<any> = await call(
let response: MockResponse<any> = await performRequest(
handler,
requestUrl,
'POST',
@@ -84,7 +84,7 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
// PATCH
requestUrl = new URL(id);
response = await call(
response = await performRequest(
handler,
requestUrl,
'PATCH',
@@ -99,7 +99,7 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
// GET
requestUrl = new URL(id);
response = await call(
response = await performRequest(
handler,
requestUrl,
'GET',
@@ -130,7 +130,7 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
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(
let response: MockResponse<any> = await performRequest(
handler,
requestUrl,
'POST',
@@ -147,7 +147,7 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
// PUT
requestUrl = new URL(id);
response = await call(
response = await performRequest(
handler,
requestUrl,
'PUT',
@@ -159,7 +159,7 @@ describe('An integrated AuthenticatedLdpHandler', (): void => {
// GET
requestUrl = new URL(id);
response = await call(
response = await performRequest(
handler,
requestUrl,
'GET',

16
test/integration/ServerWithAuth.test.ts
View File

@@ -1,12 +1,12 @@
import type { MockResponse } from 'node-mocks-http';
import type { HttpHandler, Initializer, ResourceStore } from '../../src/';
import { AclTestHelper } from '../util/TestHelpers';
import { call } from '../util/Util';
import { AclHelper } from '../util/TestHelpers';
import { performRequest } from '../util/Util';
import { BASE, instantiateFromConfig } from './Config';
describe('A server with authorization', (): void => {
let handler: HttpHandler;
let aclHelper: AclTestHelper;
let aclHelper: AclHelper;
beforeAll(async(): Promise<void> => {
// Set up the internal store
@@ -32,7 +32,7 @@ describe('A server with authorization', (): void => {
await initializer.handleSafe();
// Create test helpers for manipulating the components
aclHelper = new AclTestHelper(store, BASE);
aclHelper = new AclHelper(store, BASE);
});
it('can create new entries.', async(): Promise<void> => {
@@ -40,7 +40,7 @@ describe('A server with authorization', (): void => {
// POST
let requestUrl = new URL('http://test.com/');
let response: MockResponse<any> = await call(
let response: MockResponse<any> = await performRequest(
handler,
requestUrl,
'POST',
@@ -51,7 +51,7 @@ describe('A server with authorization', (): void => {
// PUT
requestUrl = new URL('http://test.com/foo/bar');
response = await call(
response = await performRequest(
handler,
requestUrl,
'PUT',
@@ -66,7 +66,7 @@ describe('A server with authorization', (): void => {
// POST
let requestUrl = new URL('http://test.com/');
let response: MockResponse<any> = await call(
let response: MockResponse<any> = await performRequest(
handler,
requestUrl,
'POST',
@@ -77,7 +77,7 @@ describe('A server with authorization', (): void => {
// PUT
requestUrl = new URL('http://test.com/foo/bar');
response = await call(
response = await performRequest(
handler,
requestUrl,
'PUT',

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

@@ -1,10 +1,10 @@
import type { HttpHandler, Initializer, ResourceStore } from '../../src/';
import { describeIf, FileTestHelper } from '../util/TestHelpers';
import { describeIf, ResourceHelper } from '../util/TestHelpers';
import { BASE, instantiateFromConfig } from './Config';
describeIf('docker', 'A server with a SPARQL endpoint as storage', (): void => {
let handler: HttpHandler;
let fileHelper: FileTestHelper;
let resourceHelper: ResourceHelper;
beforeAll(async(): Promise<void> => {
// Set up the internal store
@@ -30,13 +30,13 @@ describeIf('docker', 'A server with a SPARQL endpoint as storage', (): void => {
await initializer.handleSafe();
// Create test helpers for manipulating the components
fileHelper = new FileTestHelper(handler, new URL(BASE));
resourceHelper = new ResourceHelper(handler, BASE);
});
it('can add a Turtle file to the store.', async():
Promise<void> => {
// POST
const response = await fileHelper.createFile('../assets/person.ttl', 'person', 'text/turtle');
const response = await resourceHelper.createResource('../assets/person.ttl', 'person', 'text/turtle');
const id = response._getHeaders().location;
expect(id).toBeTruthy();
});

40
test/util/TestHelpers.ts
View File

@@ -9,10 +9,10 @@ import { createResponse } from 'node-mocks-http';
import type { ResourceStore, PermissionSet, HttpHandler, HttpRequest } from '../../src/';
import { guardedStreamFrom, RepresentationMetadata, ensureTrailingSlash } from '../../src/';
import { CONTENT_TYPE } from '../../src/util/UriConstants';
import { call } from './Util';
import { performRequest } from './Util';
/* eslint-disable jest/no-standalone-expect */
export class AclTestHelper {
export class AclHelper {
public readonly store: ResourceStore;
public id: string;
@@ -60,24 +60,24 @@ export class AclTestHelper {
}
}
export class FileTestHelper {
export class ResourceHelper {
public readonly handler: HttpHandler;
public readonly baseUrl: URL;
public constructor(handler: HttpHandler, baseUrl: URL) {
public constructor(handler: HttpHandler, baseUrl: string) {
this.handler = handler;
this.baseUrl = baseUrl;
this.baseUrl = new URL(baseUrl);
}
public async simpleCall(
public async performRequest(
requestUrl: URL,
method: string,
headers: IncomingHttpHeaders,
): Promise<MockResponse<any>> {
return call(this.handler, requestUrl, method, headers, []);
return performRequest(this.handler, requestUrl, method, headers, []);
}
public async callWithFile(
public async performRequestWithBody(
requestUrl: URL,
method: string,
headers: IncomingHttpHeaders,
@@ -106,13 +106,13 @@ export class FileTestHelper {
return response;
}
public async createFile(fileLocation: string, slug: string, contentType: string, mayFail = false):
public async createResource(fileLocation: string, slug: string, contentType: string, mayFail = false):
Promise<MockResponse<any>> {
const fileData = await fs.readFile(
join(__dirname, fileLocation),
);
const response: MockResponse<any> = await this.callWithFile(
const response: MockResponse<any> = await this.performRequestWithBody(
this.baseUrl,
'POST',
{ 'content-type': contentType,
@@ -128,7 +128,7 @@ export class FileTestHelper {
return response;
}
public async overwriteFile(fileLocation: string, requestUrl: string, contentType: string):
public async replaceResource(fileLocation: string, requestUrl: string, contentType: string):
Promise<MockResponse<any>> {
const fileData = await fs.readFile(
join(__dirname, fileLocation),
@@ -136,7 +136,7 @@ export class FileTestHelper {
const putUrl = new URL(requestUrl);
const response: MockResponse<any> = await this.callWithFile(
const response: MockResponse<any> = await this.performRequestWithBody(
putUrl,
'PUT',
{ 'content-type': contentType, 'transfer-encoding': 'chunked' },
@@ -147,10 +147,10 @@ export class FileTestHelper {
return response;
}
public async getFile(requestUrl: string): Promise<MockResponse<any>> {
public async getResource(requestUrl: string): Promise<MockResponse<any>> {
const getUrl = new URL(requestUrl);
const response = await this.simpleCall(getUrl, 'GET', { accept: '*/*' });
const response = await this.performRequest(getUrl, 'GET', { accept: '*/*' });
expect(response.statusCode).toBe(200);
return response;
}
@@ -158,7 +158,7 @@ export class FileTestHelper {
public async deleteResource(requestUrl: string, mayFail = false): Promise<MockResponse<any>> {
const deleteUrl = new URL(requestUrl);
const response = await this.simpleCall(deleteUrl, 'DELETE', {});
const response = await this.performRequest(deleteUrl, 'DELETE', {});
if (!mayFail) {
expect(response.statusCode).toBe(205);
expect(response._getData()).toHaveLength(0);
@@ -166,8 +166,8 @@ export class FileTestHelper {
return response;
}
public async createFolder(slug: string): Promise<MockResponse<any>> {
const response: MockResponse<any> = await this.simpleCall(
public async createContainer(slug: string): Promise<MockResponse<any>> {
const response: MockResponse<any> = await this.performRequest(
this.baseUrl,
'POST',
{
@@ -183,17 +183,17 @@ export class FileTestHelper {
return response;
}
public async getFolder(requestUrl: string): Promise<MockResponse<any>> {
public async getContainer(requestUrl: string): Promise<MockResponse<any>> {
const getUrl = new URL(requestUrl);
// `n-quads` allow for easy testing if a triple is present
return await this.simpleCall(getUrl, 'GET', { accept: 'application/n-quads' });
return await this.performRequest(getUrl, 'GET', { accept: 'application/n-quads' });
}
public async shouldNotExist(requestUrl: string): Promise<MockResponse<any>> {
const getUrl = new URL(requestUrl);
const response = await this.simpleCall(getUrl, 'GET', { accept: '*/*' });
const response = await this.performRequest(getUrl, 'GET', { accept: '*/*' });
expect(response.statusCode).toBe(404);
expect(response._getData()).toContain('NotFoundHttpError');
return response;

2
test/util/Util.ts
View File

@@ -9,7 +9,7 @@ import type { HttpHandler } from '../../src/server/HttpHandler';
import type { HttpRequest } from '../../src/server/HttpRequest';
import type { SystemError } from '../../src/util/errors/SystemError';
export const call = async(
export const performRequest = async(
handler: HttpHandler,
requestUrl: URL,
method: string,