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

refactor: Make URI constants consistent

Browse Source
This commit is contained in:
Joachim Van Herwegen
2020-09-11 17:25:30 +02:00
parent 8d3979372b
commit 85df2e5d7f
37 changed files with 320 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
test/integration/FileResourceStore.test.ts
View File

@@ -155,8 +155,8 @@ describe('A server using a FileResourceStore', (): void => {
response = await fileHelper.getFolder(folderId);
expect(response.statusCode).toBe(200);
expect(response._getHeaders().location).toBe(folderId);
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/subfolder0> .');
expect(response._getBuffer().toString()).toContain('<http://www.w3.org/ns/ldp#contains> <http://test.com/testfolder3/testfile0.txt> .');
// DELETE
await fileHelper.deleteFile(fileId);

6
test/integration/RepresentationConverter.test.ts
View File

@@ -4,7 +4,7 @@ import { RepresentationMetadata } from '../../src/ldp/representation/Representat
import { ChainedConverter } from '../../src/storage/conversion/ChainedConverter';
import { QuadToRdfConverter } from '../../src/storage/conversion/QuadToRdfConverter';
import { RdfToQuadConverter } from '../../src/storage/conversion/RdfToQuadConverter';
import { MA_CONTENT_TYPE } from '../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../src/util/UriConstants';
import { readableToString } from '../../src/util/Util';
describe('A ChainedConverter', (): void => {
@@ -15,7 +15,7 @@ describe('A ChainedConverter', (): void => {
const converter = new ChainedConverter(converters);
it('can convert from JSON-LD to turtle.', async(): Promise<void> => {
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'application/ld+json' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'application/ld+json' });
const representation: Representation = {
binary: true,
data: streamifyArray([ '{"@id": "http://test.com/s", "http://test.com/p": { "@id": "http://test.com/o" }}' ]),
@@ -33,7 +33,7 @@ describe('A ChainedConverter', (): void => {
});
it('can convert from turtle to JSON-LD.', async(): Promise<void> => {
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' });
const representation: Representation = {
binary: true,
data: streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ]),

4
test/unit/ldp/http/BasicResponseWriter.test.ts
View File

@@ -5,7 +5,7 @@ import { BasicResponseWriter } from '../../../../src/ldp/http/BasicResponseWrite
import { ResponseDescription } from '../../../../src/ldp/operations/ResponseDescription';
import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata';
import { UnsupportedHttpError } from '../../../../src/util/errors/UnsupportedHttpError';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../../../src/util/UriConstants';
describe('A BasicResponseWriter', (): void => {
const writer = new BasicResponseWriter();
@@ -48,7 +48,7 @@ describe('A BasicResponseWriter', (): void => {
});
it('responds with a content-type if the metadata has it.', async(done): Promise<void> => {
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' });
const body = {
binary: true,
data: streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ]),

6
test/unit/ldp/http/RawBodyParser.test.ts
View File

@@ -5,7 +5,7 @@ import { RepresentationMetadata } from '../../../../src/ldp/representation/Repre
import { HttpRequest } from '../../../../src/server/HttpRequest';
import { UnsupportedHttpError } from '../../../../src/util/errors/UnsupportedHttpError';
import 'jest-rdf';
import { HTTP_SLUG, RDF_TYPE } from '../../../../src/util/MetadataTypes';
import { HTTP, RDF } from '../../../../src/util/UriConstants';
describe('A RawBodyparser', (): void => {
const bodyParser = new RawBodyParser();
@@ -54,7 +54,7 @@ describe('A RawBodyparser', (): void => {
input.headers = { 'transfer-encoding': 'chunked', 'content-type': 'text/turtle', slug: 'slugText' };
const result = (await bodyParser.handle(input))!;
expect(result.metadata.contentType).toEqual('text/turtle');
expect(result.metadata.get(HTTP_SLUG)?.value).toEqual('slugText');
expect(result.metadata.get(HTTP.slug)?.value).toEqual('slugText');
});
it('errors if there are multiple slugs.', async(): Promise<void> => {
@@ -72,7 +72,7 @@ describe('A RawBodyparser', (): void => {
link: '<http://www.w3.org/ns/ldp#Container>; rel="type"' };
const result = (await bodyParser.handle(input))!;
expect(result.metadata.contentType).toEqual('text/turtle');
expect(result.metadata.get(RDF_TYPE)?.value).toEqual('http://www.w3.org/ns/ldp#Container');
expect(result.metadata.get(RDF.type)?.value).toEqual('http://www.w3.org/ns/ldp#Container');
});
it('ignores unknown link headers.', async(): Promise<void> => {

8
test/unit/ldp/representation/RepresentationMetadata.test.ts
View File

@@ -1,7 +1,7 @@
import { literal, namedNode, quad } from '@rdfjs/data-model';
import type { Literal, NamedNode, Quad } from 'rdf-js';
import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../../../src/util/UriConstants';
describe('A RepresentationMetadata', (): void => {
let metadata: RepresentationMetadata;
@@ -180,15 +180,15 @@ describe('A RepresentationMetadata', (): void => {
it('has a shorthand for content-type.', async(): Promise<void> => {
expect(metadata.contentType).toBeUndefined();
metadata.contentType = 'a/b';
expect(metadata.get(MA_CONTENT_TYPE)).toEqualRdfTerm(literal('a/b'));
expect(metadata.get(CONTENT_TYPE)).toEqualRdfTerm(literal('a/b'));
expect(metadata.contentType).toEqual('a/b');
metadata.contentType = undefined;
expect(metadata.contentType).toBeUndefined();
});
it('errors if a shorthand has multiple values.', async(): Promise<void> => {
metadata.add(MA_CONTENT_TYPE, 'a/b');
metadata.add(MA_CONTENT_TYPE, 'c/d');
metadata.add(CONTENT_TYPE, 'a/b');
metadata.add(CONTENT_TYPE, 'c/d');
expect((): any => metadata.contentType).toThrow();
});
});

88
test/unit/storage/FileResourceStore.test.ts
View File

@@ -15,10 +15,8 @@ import { MethodNotAllowedHttpError } from '../../../src/util/errors/MethodNotAll
import { NotFoundHttpError } from '../../../src/util/errors/NotFoundHttpError';
import { UnsupportedMediaTypeHttpError } from '../../../src/util/errors/UnsupportedMediaTypeHttpError';
import { InteractionController } from '../../../src/util/InteractionController';
import { LINK_TYPE_LDP_BC, LINK_TYPE_LDPR } from '../../../src/util/LinkTypes';
import { MetadataController } from '../../../src/util/MetadataController';
import { HTTP_BYTE_SIZE, HTTP_LAST_CHANGED, HTTP_SLUG, RDF_TYPE } from '../../../src/util/MetadataTypes';
import { LDP, RDF, STAT, TERMS, XML } from '../../../src/util/Prefixes';
import { DCTERMS, HTTP, LDP, POSIX, RDF, XSD } from '../../../src/util/UriConstants';
const { join: joinPath } = posix;
@@ -133,8 +131,8 @@ describe('A FileResourceStore', (): void => {
(fs.createReadStream as jest.Mock).mockImplementationOnce((): any => new Error('Metadata file does not exist.'));
// Write container (POST)
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(HTTP_SLUG, 'myContainer/');
representation.metadata.add(RDF.type, LDP.BasicContainer);
representation.metadata.add(HTTP.slug, 'myContainer/');
const identifier = await store.addResource({ path: base }, representation);
expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'myContainer/'), { recursive: true });
expect(identifier.path).toBe(`${base}myContainer/`);
@@ -146,7 +144,7 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(HTTP_LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(DCTERMS.modified)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).resolves.toBeDefined();
});
@@ -156,8 +154,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(HTTP_SLUG, 'myContainer/');
representation.metadata.add(RDF.type, LDP.BasicContainer);
representation.metadata.add(HTTP.slug, 'myContainer/');
await expect(store.addResource({ path: `${base}foo` }, representation)).rejects.toThrow(MethodNotAllowedHttpError);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo'));
});
@@ -173,19 +171,19 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(HTTP_SLUG, 'myContainer/');
representation.metadata.add(RDF.type, LDP.BasicContainer);
representation.metadata.add(HTTP.slug, 'myContainer/');
await expect(store.addResource({ path: `${base}doesnotexist` }, representation))
.rejects.toThrow(MethodNotAllowedHttpError);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'doesnotexist'));
representation.metadata.set(RDF_TYPE, LINK_TYPE_LDPR);
representation.metadata.set(HTTP_SLUG, 'file.txt');
representation.metadata.set(RDF.type, LDP.Resource);
representation.metadata.set(HTTP.slug, 'file.txt');
await expect(store.addResource({ path: `${base}doesnotexist` }, representation))
.rejects.toThrow(MethodNotAllowedHttpError);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'doesnotexist'));
representation.metadata.removeAll(RDF_TYPE);
representation.metadata.removeAll(RDF.type);
await expect(store.addResource({ path: `${base}existingresource` }, representation))
.rejects.toThrow(MethodNotAllowedHttpError);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'existingresource'));
@@ -217,8 +215,8 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(HTTP_LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(HTTP_BYTE_SIZE)?.value).toEqual(`${stats.size}`);
expect(result.metadata.get(DCTERMS.modified)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(POSIX.size)?.value).toEqual(`${stats.size}`);
expect(result.metadata.contentType).toEqual('text/plain');
await expect(arrayifyStream(result.data)).resolves.toEqual([ rawData ]);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'file.txt'));
@@ -254,8 +252,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDPR);
representation.metadata.add(HTTP_SLUG, 'file.txt');
representation.metadata.add(RDF.type, LDP.Resource);
representation.metadata.add(HTTP.slug, 'file.txt');
const identifier = await store.addResource({ path: `${base}doesnotexistyet/` }, representation);
expect(identifier.path).toBe(`${base}doesnotexistyet/file.txt`);
expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'doesnotexistyet/'),
@@ -280,7 +278,7 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDPR);
representation.metadata.add(RDF.type, LDP.Resource);
representation.data = readableMock;
await store.addResource({ path: `${base}foo/` }, representation);
expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo/'), { recursive: true });
@@ -350,17 +348,17 @@ describe('A FileResourceStore', (): void => {
const containerNode = namedNode(`${base}foo/`);
const fileNode = namedNode(`${base}foo/file.txt`);
const quads = [
quadRDF(containerNode, namedNode(`${RDF}type`), namedNode(`${LDP}Container`)),
quadRDF(containerNode, namedNode(`${RDF}type`), namedNode(`${LDP}BasicContainer`)),
quadRDF(containerNode, namedNode(`${RDF}type`), namedNode(`${LDP}Resource`)),
quadRDF(containerNode, namedNode(`${STAT}size`), DataFactory.literal(stats.size)),
quadRDF(containerNode, namedNode(`${TERMS}modified`), literal(stats.mtime.toUTCString(), `${XML}dateTime`)),
quadRDF(containerNode, namedNode(`${STAT}mtime`), DataFactory.literal(stats.mtime.getTime() / 100)),
quadRDF(containerNode, namedNode(`${LDP}contains`), fileNode),
quadRDF(fileNode, namedNode(`${RDF}type`), namedNode(`${LDP}Resource`)),
quadRDF(fileNode, namedNode(`${STAT}size`), DataFactory.literal(stats.size)),
quadRDF(fileNode, namedNode(`${TERMS}modified`), literal(stats.mtime.toUTCString(), `${XML}dateTime`)),
quadRDF(fileNode, namedNode(`${STAT}mtime`), DataFactory.literal(stats.mtime.getTime() / 100)),
quadRDF(containerNode, namedNode(RDF.type), namedNode(LDP.Container)),
quadRDF(containerNode, namedNode(RDF.type), namedNode(LDP.BasicContainer)),
quadRDF(containerNode, namedNode(RDF.type), namedNode(LDP.Resource)),
quadRDF(containerNode, namedNode(POSIX.size), DataFactory.literal(stats.size)),
quadRDF(containerNode, namedNode(DCTERMS.modified), literal(stats.mtime.toISOString(), namedNode(XSD.dateTime))),
quadRDF(containerNode, namedNode(POSIX.mtime), DataFactory.literal(Math.floor(stats.mtime.getTime() / 1000))),
quadRDF(containerNode, namedNode(LDP.contains), fileNode),
quadRDF(fileNode, namedNode(RDF.type), namedNode(LDP.Resource)),
quadRDF(fileNode, namedNode(POSIX.size), DataFactory.literal(stats.size)),
quadRDF(fileNode, namedNode(DCTERMS.modified), literal(stats.mtime.toISOString(), namedNode(XSD.dateTime))),
quadRDF(fileNode, namedNode(POSIX.mtime), DataFactory.literal(Math.floor(stats.mtime.getTime() / 1000))),
];
const result = await store.getRepresentation({ path: `${base}foo/` });
expect(result).toEqual({
@@ -368,9 +366,9 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(HTTP_LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(DCTERMS.modified)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).resolves.toEqualRdfQuadArray(quads);
await expect(arrayifyStream(result.data)).resolves.toBeRdfIsomorphic(quads);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo/'));
expect(fsPromises.readdir as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo/'));
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo', 'file.txt'));
@@ -387,7 +385,7 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDPR);
representation.metadata.add(RDF.type, LDP.Resource);
await store.setRepresentation({ path: `${base}alreadyexists.txt` }, representation);
expect(fs.createWriteStream as jest.Mock).toBeCalledTimes(2);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'alreadyexists.txt'));
@@ -403,7 +401,7 @@ describe('A FileResourceStore', (): void => {
await expect(store.setRepresentation({ path: `${base}alreadyexists` }, representation)).rejects
.toThrow(ConflictHttpError);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'alreadyexists'));
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(RDF.type, LDP.BasicContainer);
await expect(store.setRepresentation({ path: `${base}alreadyexists/` }, representation)).rejects
.toThrow(ConflictHttpError);
expect(fsPromises.access as jest.Mock).toBeCalledTimes(1);
@@ -417,7 +415,7 @@ describe('A FileResourceStore', (): void => {
(fsPromises.mkdir as jest.Mock).mockReturnValueOnce(true);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(RDF.type, LDP.BasicContainer);
await store.setRepresentation({ path: `${base}foo/` }, representation);
expect(fsPromises.mkdir as jest.Mock).toBeCalledTimes(1);
expect(fsPromises.access as jest.Mock).toBeCalledTimes(1);
@@ -435,8 +433,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.unlink as jest.Mock).mockReturnValueOnce(true);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDPR);
representation.metadata.add(HTTP_SLUG, 'file.txt');
representation.metadata.add(RDF.type, LDP.Resource);
representation.metadata.add(HTTP.slug, 'file.txt');
await expect(store.addResource({ path: base }, representation)).rejects.toThrow(Error);
expect(fs.createWriteStream as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'file.txt.metadata'));
expect(fs.createWriteStream as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'file.txt'));
@@ -452,8 +450,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.rmdir as jest.Mock).mockReturnValueOnce(true);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(HTTP_SLUG, 'foo/');
representation.metadata.add(RDF.type, LDP.BasicContainer);
representation.metadata.add(HTTP.slug, 'foo/');
await expect(store.addResource({ path: base }, representation)).rejects.toThrow(Error);
expect(fsPromises.rmdir as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo/'));
});
@@ -464,7 +462,7 @@ describe('A FileResourceStore', (): void => {
(fsPromises.mkdir as jest.Mock).mockReturnValueOnce(true);
// Tests
representation.metadata.add(HTTP_SLUG, 'myContainer/');
representation.metadata.add(HTTP.slug, 'myContainer/');
const identifier = await store.addResource({ path: base }, representation);
expect(identifier.path).toBe(`${base}myContainer/`);
expect(fsPromises.mkdir as jest.Mock).toBeCalledTimes(1);
@@ -485,8 +483,8 @@ describe('A FileResourceStore', (): void => {
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.contentType).toEqual('application/octet-stream');
expect(result.metadata.get(HTTP_LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(HTTP_BYTE_SIZE)?.value).toEqual(`${stats.size}`);
expect(result.metadata.get(DCTERMS.modified)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(POSIX.size)?.value).toEqual(`${stats.size}`);
});
it('errors when performing a PUT on the root path.', async(): Promise<void> => {
@@ -519,8 +517,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.mkdir as jest.Mock).mockReturnValue(true);
// Tests
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(HTTP_SLUG, 'bar');
representation.metadata.add(RDF.type, LDP.BasicContainer);
representation.metadata.add(HTTP.slug, 'bar');
const identifier = await store.addResource({ path: `${base}foo` }, representation);
expect(identifier.path).toBe(`${base}foo/bar/`);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo'));
@@ -552,8 +550,8 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(HTTP_LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(HTTP_BYTE_SIZE)?.value).toEqual(`${stats.size}`);
expect(result.metadata.get(DCTERMS.modified)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(POSIX.size)?.value).toEqual(`${stats.size}`);
await expect(arrayifyStream(result.data)).resolves.toEqual([ rawData ]);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, name));
expect(fs.createReadStream as jest.Mock).toBeCalledWith(joinPath(rootFilepath, name));

4
test/unit/storage/RepresentationConvertingStore.test.ts
View File

@@ -2,14 +2,14 @@ import { RepresentationMetadata } from '../../../src/ldp/representation/Represen
import { RepresentationConverter } from '../../../src/storage/conversion/RepresentationConverter';
import { RepresentationConvertingStore } from '../../../src/storage/RepresentationConvertingStore';
import { ResourceStore } from '../../../src/storage/ResourceStore';
import { MA_CONTENT_TYPE } from '../../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../../src/util/UriConstants';
describe('A RepresentationConvertingStore', (): void => {
let store: RepresentationConvertingStore;
let source: ResourceStore;
let handleSafeFn: jest.Mock<Promise<void>, []>;
let converter: RepresentationConverter;
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' });
beforeEach(async(): Promise<void> => {
source = {

6
test/unit/storage/conversion/ChainedConverter.test.ts
View File

@@ -5,7 +5,7 @@ import { ChainedConverter } from '../../../../src/storage/conversion/ChainedConv
import { checkRequest } from '../../../../src/storage/conversion/ConversionUtil';
import { RepresentationConverterArgs } from '../../../../src/storage/conversion/RepresentationConverter';
import { TypedRepresentationConverter } from '../../../../src/storage/conversion/TypedRepresentationConverter';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../../../src/util/UriConstants';
class DummyConverter extends TypedRepresentationConverter {
private readonly inTypes: { [contentType: string]: number };
@@ -31,7 +31,7 @@ class DummyConverter extends TypedRepresentationConverter {
public async handle(input: RepresentationConverterArgs): Promise<Representation> {
const metadata = new RepresentationMetadata(input.representation.metadata,
{ [MA_CONTENT_TYPE]: input.preferences.type![0].value });
{ [CONTENT_TYPE]: input.preferences.type![0].value });
return { ...input.representation, metadata };
}
}
@@ -51,7 +51,7 @@ describe('A ChainedConverter', (): void => {
];
converter = new ChainedConverter(converters);
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' });
representation = { metadata } as Representation;
preferences = { type: [{ value: 'internal/quads', weight: 1 }]};
args = { representation, preferences, identifier: { path: 'path' }};

4
test/unit/storage/conversion/QuadToRdfConverter.test.ts
View File

@@ -8,12 +8,12 @@ import { RepresentationPreferences } from '../../../../src/ldp/representation/Re
import { ResourceIdentifier } from '../../../../src/ldp/representation/ResourceIdentifier';
import { QuadToRdfConverter } from '../../../../src/storage/conversion/QuadToRdfConverter';
import { INTERNAL_QUADS } from '../../../../src/util/ContentTypes';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../../../src/util/UriConstants';
describe('A QuadToRdfConverter', (): void => {
const converter = new QuadToRdfConverter();
const identifier: ResourceIdentifier = { path: 'path' };
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: INTERNAL_QUADS });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: INTERNAL_QUADS });
it('supports parsing quads.', async(): Promise<void> => {
await expect(converter.getInputTypes()).resolves.toEqual({ [INTERNAL_QUADS]: 1 });

4
test/unit/storage/conversion/QuadToTurtleConverter.test.ts
View File

@@ -7,12 +7,12 @@ import { RepresentationPreferences } from '../../../../src/ldp/representation/Re
import { ResourceIdentifier } from '../../../../src/ldp/representation/ResourceIdentifier';
import { QuadToTurtleConverter } from '../../../../src/storage/conversion/QuadToTurtleConverter';
import { INTERNAL_QUADS } from '../../../../src/util/ContentTypes';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../../../src/util/UriConstants';
describe('A QuadToTurtleConverter', (): void => {
const converter = new QuadToTurtleConverter();
const identifier: ResourceIdentifier = { path: 'path' };
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: INTERNAL_QUADS });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: INTERNAL_QUADS });
it('can handle quad to turtle conversions.', async(): Promise<void> => {
const representation = { metadata } as Representation;

12
test/unit/storage/conversion/RdfToQuadConverter.test.ts
View File

@@ -10,7 +10,7 @@ import { ResourceIdentifier } from '../../../../src/ldp/representation/ResourceI
import { RdfToQuadConverter } from '../../../../src/storage/conversion/RdfToQuadConverter';
import { INTERNAL_QUADS } from '../../../../src/util/ContentTypes';
import { UnsupportedHttpError } from '../../../../src/util/errors/UnsupportedHttpError';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../../../src/util/UriConstants';
describe('A RdfToQuadConverter.test.ts', (): void => {
const converter = new RdfToQuadConverter();
@@ -25,21 +25,21 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
});
it('can handle turtle to quad conversions.', async(): Promise<void> => {
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' });
const representation = { metadata } as Representation;
const preferences: RepresentationPreferences = { type: [{ value: INTERNAL_QUADS, weight: 1 }]};
await expect(converter.canHandle({ identifier, representation, preferences })).resolves.toBeUndefined();
});
it('can handle JSON-LD to quad conversions.', async(): Promise<void> => {
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'application/ld+json' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'application/ld+json' });
const representation = { metadata } as Representation;
const preferences: RepresentationPreferences = { type: [{ value: INTERNAL_QUADS, weight: 1 }]};
await expect(converter.canHandle({ identifier, representation, preferences })).resolves.toBeUndefined();
});
it('converts turtle to quads.', async(): Promise<void> => {
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' });
const representation = {
data: streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ]),
metadata,
@@ -60,7 +60,7 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
});
it('converts JSON-LD to quads.', async(): Promise<void> => {
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'application/ld+json' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'application/ld+json' });
const representation = {
data: streamifyArray([ '{"@id": "http://test.com/s", "http://test.com/p": { "@id": "http://test.com/o" }}' ]),
metadata,
@@ -81,7 +81,7 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
});
it('throws an UnsupportedHttpError on invalid triple data.', async(): Promise<void> => {
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' });
const representation = {
data: streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.co' ]),
metadata,

4
test/unit/storage/conversion/TurtleToQuadConverter.test.ts
View File

@@ -9,12 +9,12 @@ import { ResourceIdentifier } from '../../../../src/ldp/representation/ResourceI
import { TurtleToQuadConverter } from '../../../../src/storage/conversion/TurtleToQuadConverter';
import { INTERNAL_QUADS } from '../../../../src/util/ContentTypes';
import { UnsupportedHttpError } from '../../../../src/util/errors/UnsupportedHttpError';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../../../src/util/UriConstants';
describe('A TurtleToQuadConverter', (): void => {
const converter = new TurtleToQuadConverter();
const identifier: ResourceIdentifier = { path: 'path' };
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const metadata = new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' });
it('can handle turtle to quad conversions.', async(): Promise<void> => {
const representation = { metadata } as Representation;

56
test/unit/util/UriUtil.test.ts Normal file
View File

@@ -0,0 +1,56 @@
import { literal, namedNode } from '@rdfjs/data-model';
import { CONTENT_TYPE, XSD } from '../../../src/util/UriConstants';
import { getNamedNode, getObjectTerm, getTypedLiteral, isTerm } from '../../../src/util/UriUtil';
describe('An UriUtil', (): void => {
describe('isTerm function', (): void => {
it('checks if any input is a Term.', async(): Promise<void> => {
expect(isTerm(namedNode('name'))).toBeTruthy();
expect(isTerm(literal('value'))).toBeTruthy();
expect(isTerm('notATerm')).toBeFalsy();
expect(isTerm({})).toBeFalsy();
expect(isTerm()).toBeFalsy();
});
});
describe('getNamedNode function', (): void => {
it('returns the input if it was a named node.', async(): Promise<void> => {
const term = namedNode('name');
expect(getNamedNode(term)).toBe(term);
});
it('returns a named node when a string is used.', async(): Promise<void> => {
expect(getNamedNode('name')).toEqualRdfTerm(namedNode('name'));
});
it('caches generated named nodes.', async(): Promise<void> => {
const result = getNamedNode('name');
expect(result).toEqualRdfTerm(namedNode('name'));
expect(getNamedNode('name')).toBe(result);
});
it('supports URI shorthands.', async(): Promise<void> => {
expect(getNamedNode('contentType')).toEqualRdfTerm(namedNode(CONTENT_TYPE));
});
});
describe('getObjectTerm function', (): void => {
it('returns the input if it was a term.', async(): Promise<void> => {
const nn = namedNode('name');
const lit = literal('lit');
expect(getObjectTerm(nn)).toBe(nn);
expect(getObjectTerm(lit)).toBe(lit);
});
it('returns a literal when a string is used.', async(): Promise<void> => {
expect(getObjectTerm('lit')).toEqualRdfTerm(literal('lit'));
});
});
describe('getTypedLiteral function', (): void => {
it('converts the input to a valid literal with the given type.', async(): Promise<void> => {
const expected = literal('5', namedNode(XSD.integer));
expect(getTypedLiteral(5, XSD.integer)).toEqualRdfTerm(expected);
});
});
});

7
test/util/TestHelpers.ts
View File

@@ -9,7 +9,7 @@ import { RepresentationMetadata, ResourceStore } from '../../index';
import { PermissionSet } from '../../src/ldp/permissions/PermissionSet';
import { HttpHandler } from '../../src/server/HttpHandler';
import { HttpRequest } from '../../src/server/HttpRequest';
import { MA_CONTENT_TYPE } from '../../src/util/MetadataTypes';
import { CONTENT_TYPE } from '../../src/util/UriConstants';
import { call } from './Util';
export class AclTestHelper {
@@ -50,7 +50,7 @@ export class AclTestHelper {
const representation = {
binary: true,
data: streamifyArray(acl),
metadata: new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' }),
metadata: new RepresentationMetadata({ [CONTENT_TYPE]: 'text/turtle' }),
};
return this.store.setRepresentation(
@@ -184,7 +184,8 @@ export class FileTestHelper {
public async getFolder(requestUrl: string): Promise<MockResponse<any>> {
const getUrl = new URL(requestUrl);
return await this.simpleCall(getUrl, 'GET', { accept: 'text/turtle' });
// `n-quads` allow for easy testing if a triple is present
return await this.simpleCall(getUrl, 'GET', { accept: 'application/n-quads' });
}
public async deleteFolder(requestUrl: string): Promise<MockResponse<any>> {