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: Streamline RepresentationMetadata interface

Browse Source
This commit is contained in:
Joachim Van Herwegen
2020-09-08 09:43:30 +02:00
parent 76319ba360
commit 8d3979372b
36 changed files with 416 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
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 { CONTENT_TYPE } from '../../src/util/MetadataTypes';
import { MA_CONTENT_TYPE } from '../../src/util/MetadataTypes';
import { readableToString } from '../../src/util/Util';
describe('A ChainedConverter', (): void => {
@@ -15,8 +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();
metadata.set(CONTENT_TYPE, 'application/ld+json');
const metadata = new RepresentationMetadata({ [MA_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" }}' ]),
@@ -30,12 +29,11 @@ describe('A ChainedConverter', (): void => {
});
await expect(readableToString(result.data)).resolves.toEqual('<http://test.com/s> <http://test.com/p> <http://test.com/o>.\n');
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.contentType).toEqual('text/turtle');
});
it('can convert from turtle to JSON-LD.', async(): Promise<void> => {
const metadata = new RepresentationMetadata();
metadata.set(CONTENT_TYPE, 'text/turtle');
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const representation: Representation = {
binary: true,
data: streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ]),
@@ -51,6 +49,6 @@ describe('A ChainedConverter', (): void => {
expect(JSON.parse(await readableToString(result.data))).toEqual(
[{ '@id': 'http://test.com/s', 'http://test.com/p': [{ '@id': 'http://test.com/o' }]}],
);
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('application/ld+json');
expect(result.metadata.contentType).toEqual('application/ld+json');
});
});

3
test/integration/RequestParser.test.ts
View File

@@ -7,7 +7,6 @@ import { BasicTargetExtractor } from '../../src/ldp/http/BasicTargetExtractor';
import { RawBodyParser } from '../../src/ldp/http/RawBodyParser';
import { RepresentationMetadata } from '../../src/ldp/representation/RepresentationMetadata';
import { HttpRequest } from '../../src/server/HttpRequest';
import { CONTENT_TYPE } from '../../src/util/MetadataTypes';
describe('A BasicRequestParser with simple input parsers', (): void => {
const targetExtractor = new BasicTargetExtractor();
@@ -41,7 +40,7 @@ describe('A BasicRequestParser with simple input parsers', (): void => {
metadata: expect.any(RepresentationMetadata),
},
});
expect(result.body?.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.body?.metadata.contentType).toEqual('text/turtle');
await expect(arrayifyStream(result.body!.data)).resolves.toEqual(
[ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ],

5
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 { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A BasicResponseWriter', (): void => {
const writer = new BasicResponseWriter();
@@ -48,8 +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();
metadata.add(CONTENT_TYPE, 'text/turtle');
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const body = {
binary: true,
data: streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ]),

14
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 { CONTENT_TYPE, SLUG, TYPE } from '../../../../src/util/MetadataTypes';
import { HTTP_SLUG, RDF_TYPE } from '../../../../src/util/MetadataTypes';
describe('A RawBodyparser', (): void => {
const bodyParser = new RawBodyParser();
@@ -43,7 +43,7 @@ describe('A RawBodyparser', (): void => {
data: input,
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.contentType).toEqual('text/turtle');
await expect(arrayifyStream(result.data)).resolves.toEqual(
[ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ],
);
@@ -53,8 +53,8 @@ describe('A RawBodyparser', (): void => {
const input = {} as HttpRequest;
input.headers = { 'transfer-encoding': 'chunked', 'content-type': 'text/turtle', slug: 'slugText' };
const result = (await bodyParser.handle(input))!;
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.get(SLUG)?.value).toEqual('slugText');
expect(result.metadata.contentType).toEqual('text/turtle');
expect(result.metadata.get(HTTP_SLUG)?.value).toEqual('slugText');
});
it('errors if there are multiple slugs.', async(): Promise<void> => {
@@ -71,8 +71,8 @@ describe('A RawBodyparser', (): void => {
'content-type': 'text/turtle',
link: '<http://www.w3.org/ns/ldp#Container>; rel="type"' };
const result = (await bodyParser.handle(input))!;
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.get(TYPE)?.value).toEqual('http://www.w3.org/ns/ldp#Container');
expect(result.metadata.contentType).toEqual('text/turtle');
expect(result.metadata.get(RDF_TYPE)?.value).toEqual('http://www.w3.org/ns/ldp#Container');
});
it('ignores unknown link headers.', async(): Promise<void> => {
@@ -82,6 +82,6 @@ describe('A RawBodyparser', (): void => {
link: [ '<unrelatedLink>', 'badLink' ]};
const result = (await bodyParser.handle(input))!;
expect(result.metadata.quads()).toHaveLength(1);
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.contentType).toEqual('text/turtle');
});
});

3
test/unit/ldp/http/SparqlUpdateBodyParser.test.ts
View File

@@ -6,7 +6,6 @@ import { SparqlUpdateBodyParser } from '../../../../src/ldp/http/SparqlUpdateBod
import { HttpRequest } from '../../../../src/server/HttpRequest';
import { UnsupportedHttpError } from '../../../../src/util/errors/UnsupportedHttpError';
import { UnsupportedMediaTypeHttpError } from '../../../../src/util/errors/UnsupportedMediaTypeHttpError';
import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A SparqlUpdateBodyParser', (): void => {
const bodyParser = new SparqlUpdateBodyParser();
@@ -35,7 +34,7 @@ describe('A SparqlUpdateBodyParser', (): void => {
namedNode('http://test.com/o'),
) ]);
expect(result.binary).toBe(true);
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('application/sparql-update');
expect(result.metadata.contentType).toEqual('application/sparql-update');
// Workaround for Node 10 not exposing objectMode
expect((await arrayifyStream(result.data)).join('')).toEqual(

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

@@ -1,6 +1,7 @@
import { literal, namedNode, quad } from '@rdfjs/data-model';
import { Literal, NamedNode, Quad } from 'rdf-js';
import type { Literal, NamedNode, Quad } from 'rdf-js';
import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A RepresentationMetadata', (): void => {
let metadata: RepresentationMetadata;
@@ -30,15 +31,47 @@ describe('A RepresentationMetadata', (): void => {
expect(metadata.identifier).toEqualRdfTerm(namedNode('identifier'));
});
it('stores input quads.', async(): Promise<void> => {
metadata = new RepresentationMetadata(identifier, inputQuads);
expect(metadata.quads()).toBeRdfIsomorphic(inputQuads);
it('copies an other metadata object.', async(): Promise<void> => {
const other = new RepresentationMetadata('otherId', { 'test:pred': 'objVal' });
metadata = new RepresentationMetadata(other);
expect(metadata.identifier).toEqualRdfTerm(namedNode('otherId'));
expect(metadata.quads()).toBeRdfIsomorphic([
quad(namedNode('otherId'), namedNode('test:pred'), literal('objVal')) ]);
});
it('takes overrides for specific predicates.', async(): Promise<void> => {
metadata = new RepresentationMetadata({ predVal: 'objVal' });
expect(metadata.get('predVal')).toEqualRdfTerm(literal('objVal'));
metadata = new RepresentationMetadata({ predVal: literal('objVal') });
expect(metadata.get('predVal')).toEqualRdfTerm(literal('objVal'));
metadata = new RepresentationMetadata({ predVal: [ 'objVal1', literal('objVal2') ], predVal2: 'objVal3' });
expect(metadata.getAll('predVal')).toEqualRdfTermArray([ literal('objVal1'), literal('objVal2') ]);
expect(metadata.get('predVal2')).toEqualRdfTerm(literal('objVal3'));
});
it('can combine overrides with an identifier.', async(): Promise<void> => {
metadata = new RepresentationMetadata(identifier, { predVal: 'objVal' });
expect(metadata.quads()).toBeRdfIsomorphic([
quad(identifier, namedNode('predVal'), literal('objVal')) ]);
});
it('can combine overrides with other metadata.', async(): Promise<void> => {
const other = new RepresentationMetadata('otherId', { 'test:pred': 'objVal' });
metadata = new RepresentationMetadata(other, { 'test:pred': 'objVal2' });
expect(metadata.quads()).toBeRdfIsomorphic([
quad(namedNode('otherId'), namedNode('test:pred'), literal('objVal2')) ]);
});
});
describe('instantiated', (): void => {
beforeEach(async(): Promise<void> => {
metadata = new RepresentationMetadata(identifier, inputQuads);
metadata = new RepresentationMetadata(identifier).addQuads(inputQuads);
});
it('can get all quads.', async(): Promise<void> => {
expect(metadata.quads()).toBeRdfIsomorphic(inputQuads);
});
it('can change the stored identifier.', async(): Promise<void> => {
@@ -57,6 +90,28 @@ describe('A RepresentationMetadata', (): void => {
expect(metadata.quads()).toBeRdfIsomorphic(newQuads);
});
it('can copy metadata.', async(): Promise<void> => {
const other = new RepresentationMetadata(identifier, { 'test:pred': 'objVal' });
metadata.setMetadata(other);
expect(metadata.identifier).toEqual(other.identifier);
expect(metadata.quads()).toBeRdfIsomorphic(inputQuads.concat([
quad(identifier, namedNode('test:pred'), literal('objVal')) ]));
});
it('updates its identifier when copying metadata.', async(): Promise<void> => {
const other = new RepresentationMetadata('otherId', { 'test:pred': 'objVal' });
metadata.setMetadata(other);
// `setMetadata` should have the same result as the following
const expectedMetadata = new RepresentationMetadata(identifier).addQuads(inputQuads);
expectedMetadata.identifier = namedNode('otherId');
expectedMetadata.add('test:pred', 'objVal');
expect(metadata.identifier).toEqual(other.identifier);
expect(metadata.quads()).toBeRdfIsomorphic(expectedMetadata.quads());
});
it('can add quads.', async(): Promise<void> => {
const newQuads: Quad[] = [
quad(namedNode('random'), namedNode('new'), namedNode('triple')),
@@ -100,6 +155,10 @@ describe('A RepresentationMetadata', (): void => {
expect(metadata.quads()).toBeRdfIsomorphic(updatedNodes);
});
it('can get all values for a predicate.', async(): Promise<void> => {
expect(metadata.getAll(namedNode('has'))).toEqualRdfTermArray([ literal('data'), literal('moreData') ]);
});
it('can get the single value for a predicate.', async(): Promise<void> => {
expect(metadata.get(namedNode('hasOne'))).toEqualRdfTerm(literal('otherData'));
});
@@ -110,11 +169,27 @@ describe('A RepresentationMetadata', (): void => {
it('errors if there are multiple values when getting a value.', async(): Promise<void> => {
expect((): any => metadata.get(namedNode('has'))).toThrow(Error);
expect((): any => metadata.get('has')).toThrow(Error);
});
it('can set the value of predicate.', async(): Promise<void> => {
it('can set the value of a predicate.', async(): Promise<void> => {
metadata.set(namedNode('has'), literal('singleValue'));
expect(metadata.get(namedNode('has'))).toEqualRdfTerm(literal('singleValue'));
});
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.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');
expect((): any => metadata.contentType).toThrow();
});
});
});

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

@@ -17,7 +17,7 @@ import { UnsupportedMediaTypeHttpError } from '../../../src/util/errors/Unsuppor
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 { BYTE_SIZE, CONTENT_TYPE, LAST_CHANGED, SLUG, TYPE } from '../../../src/util/MetadataTypes';
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';
const { join: joinPath } = posix;
@@ -133,8 +133,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(TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(SLUG, 'myContainer/');
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
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,8 +146,8 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(INTERNAL_QUADS);
expect(result.metadata.get(HTTP_LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).resolves.toBeDefined();
});
@@ -156,8 +156,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(SLUG, 'myContainer/');
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
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 +173,19 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(SLUG, 'myContainer/');
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
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(TYPE, LINK_TYPE_LDPR);
representation.metadata.set(SLUG, 'file.txt');
representation.metadata.set(RDF_TYPE, LINK_TYPE_LDPR);
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(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,9 +217,9 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(BYTE_SIZE)?.value).toEqual(`${stats.size}`);
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/plain');
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.contentType).toEqual('text/plain');
await expect(arrayifyStream(result.data)).resolves.toEqual([ rawData ]);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'file.txt'));
expect(fs.createReadStream as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'file.txt'));
@@ -254,8 +254,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDPR);
representation.metadata.add(SLUG, 'file.txt');
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDPR);
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 +280,7 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDPR);
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDPR);
representation.data = readableMock;
await store.addResource({ path: `${base}foo/` }, representation);
expect(fsPromises.mkdir as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo/'), { recursive: true });
@@ -368,8 +368,8 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(INTERNAL_QUADS);
expect(result.metadata.get(HTTP_LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).resolves.toEqualRdfQuadArray(quads);
expect(fsPromises.lstat as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo/'));
expect(fsPromises.readdir as jest.Mock).toBeCalledWith(joinPath(rootFilepath, 'foo/'));
@@ -387,7 +387,7 @@ describe('A FileResourceStore', (): void => {
(fsPromises.lstat as jest.Mock).mockReturnValueOnce(stats);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDPR);
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDPR);
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 +403,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(TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
await expect(store.setRepresentation({ path: `${base}alreadyexists/` }, representation)).rejects
.toThrow(ConflictHttpError);
expect(fsPromises.access as jest.Mock).toBeCalledTimes(1);
@@ -417,7 +417,7 @@ describe('A FileResourceStore', (): void => {
(fsPromises.mkdir as jest.Mock).mockReturnValueOnce(true);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
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 +435,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.unlink as jest.Mock).mockReturnValueOnce(true);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDPR);
representation.metadata.add(SLUG, 'file.txt');
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDPR);
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 +452,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.rmdir as jest.Mock).mockReturnValueOnce(true);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(SLUG, 'foo/');
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
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 +464,7 @@ describe('A FileResourceStore', (): void => {
(fsPromises.mkdir as jest.Mock).mockReturnValueOnce(true);
// Tests
representation.metadata.add(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);
@@ -484,9 +484,9 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('application/octet-stream');
expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(BYTE_SIZE)?.value).toEqual(`${stats.size}`);
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}`);
});
it('errors when performing a PUT on the root path.', async(): Promise<void> => {
@@ -519,8 +519,8 @@ describe('A FileResourceStore', (): void => {
(fsPromises.mkdir as jest.Mock).mockReturnValue(true);
// Tests
representation.metadata.add(TYPE, LINK_TYPE_LDP_BC);
representation.metadata.add(SLUG, 'bar');
representation.metadata.add(RDF_TYPE, LINK_TYPE_LDP_BC);
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 +552,8 @@ describe('A FileResourceStore', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(BYTE_SIZE)?.value).toEqual(`${stats.size}`);
expect(result.metadata.get(HTTP_LAST_CHANGED)?.value).toEqual(stats.mtime.toISOString());
expect(result.metadata.get(HTTP_BYTE_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));

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

@@ -2,15 +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 { CONTENT_TYPE } from '../../../src/util/MetadataTypes';
import { MA_CONTENT_TYPE } from '../../../src/util/MetadataTypes';
describe('A RepresentationConvertingStore', (): void => {
let store: RepresentationConvertingStore;
let source: ResourceStore;
let handleSafeFn: jest.Mock<Promise<void>, []>;
let converter: RepresentationConverter;
const metadata = new RepresentationMetadata();
metadata.add(CONTENT_TYPE, 'text/turtle');
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
beforeEach(async(): Promise<void> => {
source = {
@@ -31,7 +30,7 @@ describe('A RepresentationConvertingStore', (): void => {
data: 'data',
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.contentType).toEqual('text/turtle');
expect(source.getRepresentation).toHaveBeenCalledTimes(1);
expect(source.getRepresentation).toHaveBeenLastCalledWith(
{ path: 'path' }, { type: [{ value: 'text/*', weight: 0 }, { value: 'text/turtle', weight: 1 }]}, undefined,
@@ -45,7 +44,7 @@ describe('A RepresentationConvertingStore', (): void => {
data: 'data',
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.contentType).toEqual('text/turtle');
expect(source.getRepresentation).toHaveBeenCalledTimes(1);
expect(source.getRepresentation).toHaveBeenLastCalledWith(
{ path: 'path' }, {}, undefined,

14
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 { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
class DummyConverter extends TypedRepresentationConverter {
private readonly inTypes: { [contentType: string]: number };
@@ -30,9 +30,8 @@ class DummyConverter extends TypedRepresentationConverter {
}
public async handle(input: RepresentationConverterArgs): Promise<Representation> {
const oldMeta = input.representation.metadata;
const metadata = new RepresentationMetadata(oldMeta.identifier, oldMeta.quads());
metadata.set(CONTENT_TYPE, input.preferences.type![0].value);
const metadata = new RepresentationMetadata(input.representation.metadata,
{ [MA_CONTENT_TYPE]: input.preferences.type![0].value });
return { ...input.representation, metadata };
}
}
@@ -52,8 +51,7 @@ describe('A ChainedConverter', (): void => {
];
converter = new ChainedConverter(converters);
const metadata = new RepresentationMetadata();
metadata.set(CONTENT_TYPE, 'text/turtle');
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
representation = { metadata } as Representation;
preferences = { type: [{ value: 'internal/quads', weight: 1 }]};
args = { representation, preferences, identifier: { path: 'path' }};
@@ -79,7 +77,7 @@ describe('A ChainedConverter', (): void => {
});
it('errors if the start of the chain does not support the representation type.', async(): Promise<void> => {
representation.metadata.set(CONTENT_TYPE, 'bad/type');
representation.metadata.contentType = 'bad/type';
await expect(converter.canHandle(args)).rejects.toThrow();
});
@@ -94,7 +92,7 @@ describe('A ChainedConverter', (): void => {
jest.spyOn(converters[2], 'handle');
const result = await converter.handle(args);
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('internal/quads');
expect(result.metadata.contentType).toEqual('internal/quads');
expect((converters[0] as any).handle).toHaveBeenCalledTimes(1);
expect((converters[1] as any).handle).toHaveBeenCalledTimes(1);
expect((converters[2] as any).handle).toHaveBeenCalledTimes(1);

7
test/unit/storage/conversion/ConversionUtil.test.ts
View File

@@ -3,7 +3,6 @@ import { RepresentationMetadata } from '../../../../src/ldp/representation/Repre
import { RepresentationPreferences } from '../../../../src/ldp/representation/RepresentationPreferences';
import { ResourceIdentifier } from '../../../../src/ldp/representation/ResourceIdentifier';
import { checkRequest, matchingTypes } from '../../../../src/storage/conversion/ConversionUtil';
import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A ConversionUtil', (): void => {
const identifier: ResourceIdentifier = { path: 'path' };
@@ -23,21 +22,21 @@ describe('A ConversionUtil', (): void => {
});
it('requires a matching input type.', async(): Promise<void> => {
metadata.add(CONTENT_TYPE, 'a/x');
metadata.contentType = 'a/x';
const preferences: RepresentationPreferences = { type: [{ value: 'b/x', weight: 1 }]};
expect((): any => checkRequest({ identifier, representation, preferences }, [ 'c/x' ], [ '*/*' ]))
.toThrow('Can only convert from c/x to */*.');
});
it('requires a matching output type.', async(): Promise<void> => {
metadata.add(CONTENT_TYPE, 'a/x');
metadata.contentType = 'a/x';
const preferences: RepresentationPreferences = { type: [{ value: 'b/x', weight: 1 }]};
expect((): any => checkRequest({ identifier, representation, preferences }, [ '*/*' ], [ 'c/x' ]))
.toThrow('Can only convert from */* to c/x.');
});
it('succeeds with a valid input and output type.', async(): Promise<void> => {
metadata.add(CONTENT_TYPE, 'a/x');
metadata.contentType = 'a/x';
const preferences: RepresentationPreferences = { type: [{ value: 'b/x', weight: 1 }]};
expect(checkRequest({ identifier, representation, preferences }, [ '*/*' ], [ '*/*' ]))
.toBeUndefined();

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

@@ -8,13 +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 { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A QuadToRdfConverter', (): void => {
const converter = new QuadToRdfConverter();
const identifier: ResourceIdentifier = { path: 'path' };
const metadata = new RepresentationMetadata();
metadata.set(CONTENT_TYPE, INTERNAL_QUADS);
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: INTERNAL_QUADS });
it('supports parsing quads.', async(): Promise<void> => {
await expect(converter.getInputTypes()).resolves.toEqual({ [INTERNAL_QUADS]: 1 });
@@ -51,7 +50,7 @@ describe('A QuadToRdfConverter', (): void => {
binary: true,
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.contentType).toEqual('text/turtle');
await expect(stringifyStream(result.data)).resolves.toEqual(
`<http://test.com/s> <http://test.com/p> <http://test.com/o>.
`,
@@ -59,7 +58,7 @@ describe('A QuadToRdfConverter', (): void => {
});
it('converts quads to JSON-LD.', async(): Promise<void> => {
metadata.set(CONTENT_TYPE, INTERNAL_QUADS);
metadata.contentType = INTERNAL_QUADS;
const representation = {
data: streamifyArray([ triple(
namedNode('http://test.com/s'),
@@ -74,7 +73,7 @@ describe('A QuadToRdfConverter', (): void => {
binary: true,
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('application/ld+json');
expect(result.metadata.contentType).toEqual('application/ld+json');
await expect(stringifyStream(result.data)).resolves.toEqual(
`[
{

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

@@ -7,13 +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 { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A QuadToTurtleConverter', (): void => {
const converter = new QuadToTurtleConverter();
const identifier: ResourceIdentifier = { path: 'path' };
const metadata = new RepresentationMetadata();
metadata.add(CONTENT_TYPE, INTERNAL_QUADS);
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: INTERNAL_QUADS });
it('can handle quad to turtle conversions.', async(): Promise<void> => {
const representation = { metadata } as Representation;
@@ -36,7 +35,7 @@ describe('A QuadToTurtleConverter', (): void => {
binary: true,
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual('text/turtle');
expect(result.metadata.contentType).toEqual('text/turtle');
await expect(arrayifyStream(result.data)).resolves.toContain(
'<http://test.com/s> <http://test.com/p> <http://test.com/o>',
);

23
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 { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A RdfToQuadConverter.test.ts', (): void => {
const converter = new RdfToQuadConverter();
@@ -25,24 +25,21 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
});
it('can handle turtle to quad conversions.', async(): Promise<void> => {
const metadata = new RepresentationMetadata();
metadata.set(CONTENT_TYPE, 'text/turtle');
const metadata = new RepresentationMetadata({ [MA_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();
metadata.set(CONTENT_TYPE, 'application/ld+json');
const metadata = new RepresentationMetadata({ [MA_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();
metadata.set(CONTENT_TYPE, 'text/turtle');
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const representation = {
data: streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.com/o>.' ]),
metadata,
@@ -54,7 +51,7 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(INTERNAL_QUADS);
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).resolves.toEqualRdfQuadArray([ triple(
namedNode('http://test.com/s'),
namedNode('http://test.com/p'),
@@ -63,8 +60,7 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
});
it('converts JSON-LD to quads.', async(): Promise<void> => {
const metadata = new RepresentationMetadata();
metadata.set(CONTENT_TYPE, 'application/ld+json');
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'application/ld+json' });
const representation = {
data: streamifyArray([ '{"@id": "http://test.com/s", "http://test.com/p": { "@id": "http://test.com/o" }}' ]),
metadata,
@@ -76,7 +72,7 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(INTERNAL_QUADS);
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).resolves.toEqualRdfQuadArray([ triple(
namedNode('http://test.com/s'),
namedNode('http://test.com/p'),
@@ -85,8 +81,7 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
});
it('throws an UnsupportedHttpError on invalid triple data.', async(): Promise<void> => {
const metadata = new RepresentationMetadata();
metadata.set(CONTENT_TYPE, 'text/turtle');
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
const representation = {
data: streamifyArray([ '<http://test.com/s> <http://test.com/p> <http://test.co' ]),
metadata,
@@ -98,7 +93,7 @@ describe('A RdfToQuadConverter.test.ts', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(INTERNAL_QUADS);
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).rejects.toThrow(UnsupportedHttpError);
});
});

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

@@ -9,13 +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 { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
import { MA_CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A TurtleToQuadConverter', (): void => {
const converter = new TurtleToQuadConverter();
const identifier: ResourceIdentifier = { path: 'path' };
const metadata = new RepresentationMetadata();
metadata.add(CONTENT_TYPE, 'text/turtle');
const metadata = new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' });
it('can handle turtle to quad conversions.', async(): Promise<void> => {
const representation = { metadata } as Representation;
@@ -35,7 +34,7 @@ describe('A TurtleToQuadConverter', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(INTERNAL_QUADS);
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).resolves.toEqualRdfQuadArray([ triple(
namedNode('http://test.com/s'),
namedNode('http://test.com/p'),
@@ -55,7 +54,7 @@ describe('A TurtleToQuadConverter', (): void => {
data: expect.any(Readable),
metadata: expect.any(RepresentationMetadata),
});
expect(result.metadata.get(CONTENT_TYPE)?.value).toEqual(INTERNAL_QUADS);
expect(result.metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(result.data)).rejects.toThrow(UnsupportedHttpError);
});
});

3
test/unit/storage/patch/SparqlUpdatePatchHandler.test.ts
View File

@@ -11,7 +11,6 @@ import { ResourceLocker } from '../../../../src/storage/ResourceLocker';
import { ResourceStore } from '../../../../src/storage/ResourceStore';
import { INTERNAL_QUADS } from '../../../../src/util/ContentTypes';
import { UnsupportedHttpError } from '../../../../src/util/errors/UnsupportedHttpError';
import { CONTENT_TYPE } from '../../../../src/util/MetadataTypes';
describe('A SparqlUpdatePatchHandler', (): void => {
let handler: SparqlUpdatePatchHandler;
@@ -77,7 +76,7 @@ describe('A SparqlUpdatePatchHandler', (): void => {
binary: false,
metadata: expect.any(RepresentationMetadata),
}));
expect(setParams[1].metadata.get(CONTENT_TYPE)?.value).toEqual(INTERNAL_QUADS);
expect(setParams[1].metadata.contentType).toEqual(INTERNAL_QUADS);
await expect(arrayifyStream(setParams[1].data)).resolves.toBeRdfIsomorphic(quads);
};

9
test/util/TestHelpers.ts
View File

@@ -5,10 +5,11 @@ import { join } from 'path';
import * as url from 'url';
import { createResponse, MockResponse } from 'node-mocks-http';
import streamifyArray from 'streamify-array';
import { ResourceStore } from '../../index';
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 { call } from './Util';
export class AclTestHelper {
@@ -49,11 +50,7 @@ export class AclTestHelper {
const representation = {
binary: true,
data: streamifyArray(acl),
metadata: {
raw: [],
profiles: [],
contentType: 'text/turtle',
},
metadata: new RepresentationMetadata({ [MA_CONTENT_TYPE]: 'text/turtle' }),
};
return this.store.setRepresentation(