refactor: Restructure source code folder

This way the location of certain classes should make more sense

test/unit/http/ldp/DeleteOperationHandler.test.ts

@@ -0,0 +1,31 @@
+import { DeleteOperationHandler } from '../../../../src/http/ldp/DeleteOperationHandler';
+import type { Operation } from '../../../../src/http/Operation';
+import { BasicConditions } from '../../../../src/storage/BasicConditions';
+import type { ResourceStore } from '../../../../src/storage/ResourceStore';
+import { NotImplementedHttpError } from '../../../../src/util/errors/NotImplementedHttpError';
+
+describe('A DeleteOperationHandler', (): void => {
+  let operation: Operation;
+  const conditions = new BasicConditions({});
+  const store = {} as unknown as ResourceStore;
+  const handler = new DeleteOperationHandler(store);
+  beforeEach(async(): Promise<void> => {
+    operation = { method: 'DELETE', target: { path: 'http://test.com/foo' }, preferences: {}, conditions };
+    store.deleteResource = jest.fn(async(): Promise<any> => undefined);
+  });
+
+  it('only supports DELETE operations.', async(): Promise<void> => {
+    await expect(handler.canHandle({ operation })).resolves.toBeUndefined();
+    operation.method = 'GET';
+    await expect(handler.canHandle({ operation })).rejects.toThrow(NotImplementedHttpError);
+  });
+
+  it('deletes the resource from the store and returns the correct response.', async(): Promise<void> => {
+    const result = await handler.handle({ operation });
+    expect(store.deleteResource).toHaveBeenCalledTimes(1);
+    expect(store.deleteResource).toHaveBeenLastCalledWith(operation.target, conditions);
+    expect(result.statusCode).toBe(205);
+    expect(result.metadata).toBeUndefined();
+    expect(result.data).toBeUndefined();
+  });
+});

test/unit/http/ldp/GetOperationHandler.test.ts

@@ -0,0 +1,39 @@
+import { GetOperationHandler } from '../../../../src/http/ldp/GetOperationHandler';
+import type { Operation } from '../../../../src/http/Operation';
+import type { Representation } from '../../../../src/http/representation/Representation';
+import { BasicConditions } from '../../../../src/storage/BasicConditions';
+import type { ResourceStore } from '../../../../src/storage/ResourceStore';
+import { NotImplementedHttpError } from '../../../../src/util/errors/NotImplementedHttpError';
+
+describe('A GetOperationHandler', (): void => {
+  let operation: Operation;
+  const conditions = new BasicConditions({});
+  const preferences = {};
+  let store: ResourceStore;
+  let handler: GetOperationHandler;
+
+  beforeEach(async(): Promise<void> => {
+    operation = { method: 'GET', target: { path: 'http://test.com/foo' }, preferences, conditions };
+    store = {
+      getRepresentation: jest.fn(async(): Promise<Representation> =>
+        ({ binary: false, data: 'data', metadata: 'metadata' } as any)),
+    } as unknown as ResourceStore;
+
+    handler = new GetOperationHandler(store);
+  });
+
+  it('only supports GET operations.', async(): Promise<void> => {
+    await expect(handler.canHandle({ operation })).resolves.toBeUndefined();
+    operation.method = 'POST';
+    await expect(handler.canHandle({ operation })).rejects.toThrow(NotImplementedHttpError);
+  });
+
+  it('returns the representation from the store with the correct response.', async(): Promise<void> => {
+    const result = await handler.handle({ operation });
+    expect(result.statusCode).toBe(200);
+    expect(result.metadata).toBe('metadata');
+    expect(result.data).toBe('data');
+    expect(store.getRepresentation).toHaveBeenCalledTimes(1);
+    expect(store.getRepresentation).toHaveBeenLastCalledWith(operation.target, preferences, conditions);
+  });
+});

test/unit/http/ldp/HeadOperationHandler.test.ts

@@ -0,0 +1,45 @@
+import type { Readable } from 'stream';
+import { HeadOperationHandler } from '../../../../src/http/ldp/HeadOperationHandler';
+import type { Operation } from '../../../../src/http/Operation';
+import type { Representation } from '../../../../src/http/representation/Representation';
+import { BasicConditions } from '../../../../src/storage/BasicConditions';
+import type { ResourceStore } from '../../../../src/storage/ResourceStore';
+import { NotImplementedHttpError } from '../../../../src/util/errors/NotImplementedHttpError';
+
+describe('A HeadOperationHandler', (): void => {
+  let operation: Operation;
+  const conditions = new BasicConditions({});
+  const preferences = {};
+  let store: ResourceStore;
+  let handler: HeadOperationHandler;
+  let data: Readable;
+
+  beforeEach(async(): Promise<void> => {
+    operation = { method: 'HEAD', target: { path: 'http://test.com/foo' }, preferences, conditions };
+    data = { destroy: jest.fn() } as any;
+    store = {
+      getRepresentation: jest.fn(async(): Promise<Representation> =>
+        ({ binary: false, data, metadata: 'metadata' } as any)),
+    } as any;
+
+    handler = new HeadOperationHandler(store);
+  });
+
+  it('only supports HEAD operations.', async(): Promise<void> => {
+    await expect(handler.canHandle({ operation })).resolves.toBeUndefined();
+    operation.method = 'GET';
+    await expect(handler.canHandle({ operation })).rejects.toThrow(NotImplementedHttpError);
+    operation.method = 'POST';
+    await expect(handler.canHandle({ operation })).rejects.toThrow(NotImplementedHttpError);
+  });
+
+  it('returns the representation from the store with the correct response.', async(): Promise<void> => {
+    const result = await handler.handle({ operation });
+    expect(result.statusCode).toBe(200);
+    expect(result.metadata).toBe('metadata');
+    expect(result.data).toBeUndefined();
+    expect(data.destroy).toHaveBeenCalledTimes(1);
+    expect(store.getRepresentation).toHaveBeenCalledTimes(1);
+    expect(store.getRepresentation).toHaveBeenLastCalledWith(operation.target, preferences, conditions);
+  });
+});

test/unit/http/ldp/PatchOperationHandler.test.ts

@@ -0,0 +1,43 @@
+import { PatchOperationHandler } from '../../../../src/http/ldp/PatchOperationHandler';
+import type { Operation } from '../../../../src/http/Operation';
+import { BasicRepresentation } from '../../../../src/http/representation/BasicRepresentation';
+import type { Representation } from '../../../../src/http/representation/Representation';
+import { BasicConditions } from '../../../../src/storage/BasicConditions';
+import type { ResourceStore } from '../../../../src/storage/ResourceStore';
+import { BadRequestHttpError } from '../../../../src/util/errors/BadRequestHttpError';
+import { NotImplementedHttpError } from '../../../../src/util/errors/NotImplementedHttpError';
+
+describe('A PatchOperationHandler', (): void => {
+  let operation: Operation;
+  let body: Representation;
+  const conditions = new BasicConditions({});
+  const store = {} as unknown as ResourceStore;
+  const handler = new PatchOperationHandler(store);
+  beforeEach(async(): Promise<void> => {
+    body = new BasicRepresentation('', 'text/turtle');
+    operation = { method: 'PATCH', target: { path: 'http://test.com/foo' }, body, conditions, preferences: {}};
+    store.modifyResource = jest.fn(async(): Promise<any> => undefined);
+  });
+
+  it('only supports PATCH operations.', async(): Promise<void> => {
+    await expect(handler.canHandle({ operation })).resolves.toBeUndefined();
+    operation.method = 'GET';
+    await expect(handler.canHandle({ operation })).rejects.toThrow(NotImplementedHttpError);
+  });
+
+  it('errors if there is no body or content-type.', async(): Promise<void> => {
+    operation.body!.metadata.contentType = undefined;
+    await expect(handler.handle({ operation })).rejects.toThrow(BadRequestHttpError);
+    delete operation.body;
+    await expect(handler.handle({ operation })).rejects.toThrow(BadRequestHttpError);
+  });
+
+  it('deletes the resource from the store and returns the correct response.', async(): Promise<void> => {
+    const result = await handler.handle({ operation });
+    expect(store.modifyResource).toHaveBeenCalledTimes(1);
+    expect(store.modifyResource).toHaveBeenLastCalledWith(operation.target, body, conditions);
+    expect(result.statusCode).toBe(205);
+    expect(result.metadata).toBeUndefined();
+    expect(result.data).toBeUndefined();
+  });
+});

test/unit/http/ldp/PostOperationHandler.test.ts

@@ -0,0 +1,51 @@
+import { PostOperationHandler } from '../../../../src/http/ldp/PostOperationHandler';
+import type { Operation } from '../../../../src/http/Operation';
+import { BasicRepresentation } from '../../../../src/http/representation/BasicRepresentation';
+import type { Representation } from '../../../../src/http/representation/Representation';
+import { RepresentationMetadata } from '../../../../src/http/representation/RepresentationMetadata';
+import type { ResourceIdentifier } from '../../../../src/http/representation/ResourceIdentifier';
+import { BasicConditions } from '../../../../src/storage/BasicConditions';
+import type { ResourceStore } from '../../../../src/storage/ResourceStore';
+import { BadRequestHttpError } from '../../../../src/util/errors/BadRequestHttpError';
+import { NotImplementedHttpError } from '../../../../src/util/errors/NotImplementedHttpError';
+import { SOLID_HTTP } from '../../../../src/util/Vocabularies';
+
+describe('A PostOperationHandler', (): void => {
+  let operation: Operation;
+  let body: Representation;
+  const conditions = new BasicConditions({});
+  let store: ResourceStore;
+  let handler: PostOperationHandler;
+
+  beforeEach(async(): Promise<void> => {
+    body = new BasicRepresentation('', 'text/turtle');
+    operation = { method: 'POST', target: { path: 'http://test.com/foo' }, body, conditions, preferences: {}};
+    store = {
+      addResource: jest.fn(async(): Promise<ResourceIdentifier> => ({ path: 'newPath' } as ResourceIdentifier)),
+    } as unknown as ResourceStore;
+    handler = new PostOperationHandler(store);
+  });
+
+  it('only supports POST operations.', async(): Promise<void> => {
+    await expect(handler.canHandle({ operation })).resolves.toBeUndefined();
+    operation.method = 'GET';
+    await expect(handler.canHandle({ operation })).rejects.toThrow(NotImplementedHttpError);
+  });
+
+  it('errors if there is no body or content-type.', async(): Promise<void> => {
+    operation.body!.metadata.contentType = undefined;
+    await expect(handler.handle({ operation })).rejects.toThrow(BadRequestHttpError);
+    delete operation.body;
+    await expect(handler.handle({ operation })).rejects.toThrow(BadRequestHttpError);
+  });
+
+  it('adds the given representation to the store and returns the correct response.', async(): Promise<void> => {
+    const result = await handler.handle({ operation });
+    expect(result.statusCode).toBe(201);
+    expect(result.metadata).toBeInstanceOf(RepresentationMetadata);
+    expect(result.metadata?.get(SOLID_HTTP.location)?.value).toBe('newPath');
+    expect(result.data).toBeUndefined();
+    expect(store.addResource).toHaveBeenCalledTimes(1);
+    expect(store.addResource).toHaveBeenLastCalledWith(operation.target, body, conditions);
+  });
+});

test/unit/http/ldp/PutOperationHandler.test.ts

@@ -0,0 +1,44 @@
+import { PutOperationHandler } from '../../../../src/http/ldp/PutOperationHandler';
+import type { Operation } from '../../../../src/http/Operation';
+import { BasicRepresentation } from '../../../../src/http/representation/BasicRepresentation';
+import type { Representation } from '../../../../src/http/representation/Representation';
+import { BasicConditions } from '../../../../src/storage/BasicConditions';
+import type { ResourceStore } from '../../../../src/storage/ResourceStore';
+import { BadRequestHttpError } from '../../../../src/util/errors/BadRequestHttpError';
+import { NotImplementedHttpError } from '../../../../src/util/errors/NotImplementedHttpError';
+
+describe('A PutOperationHandler', (): void => {
+  let operation: Operation;
+  let body: Representation;
+  const conditions = new BasicConditions({});
+  const store = {} as unknown as ResourceStore;
+  const handler = new PutOperationHandler(store);
+  beforeEach(async(): Promise<void> => {
+    body = new BasicRepresentation('', 'text/turtle');
+    operation = { method: 'PUT', target: { path: 'http://test.com/foo' }, body, conditions, preferences: {}};
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    store.setRepresentation = jest.fn(async(): Promise<any> => {});
+  });
+
+  it('only supports PUT operations.', async(): Promise<void> => {
+    await expect(handler.canHandle({ operation })).resolves.toBeUndefined();
+    operation.method = 'GET';
+    await expect(handler.canHandle({ operation })).rejects.toThrow(NotImplementedHttpError);
+  });
+
+  it('errors if there is no body or content-type.', async(): Promise<void> => {
+    operation.body!.metadata.contentType = undefined;
+    await expect(handler.handle({ operation })).rejects.toThrow(BadRequestHttpError);
+    delete operation.body;
+    await expect(handler.handle({ operation })).rejects.toThrow(BadRequestHttpError);
+  });
+
+  it('sets the representation in the store and returns the correct response.', async(): Promise<void> => {
+    const result = await handler.handle({ operation });
+    expect(store.setRepresentation).toHaveBeenCalledTimes(1);
+    expect(store.setRepresentation).toHaveBeenLastCalledWith(operation.target, body, conditions);
+    expect(result.statusCode).toBe(205);
+    expect(result.metadata).toBeUndefined();
+    expect(result.data).toBeUndefined();
+  });
+});

test/unit/http/ldp/metadata/WebAclMetadataCollector.test.ts

@@ -0,0 +1,61 @@
+import 'jest-rdf';
+import { CredentialGroup } from '../../../../../src/authentication/Credentials';
+import type { AclPermission } from '../../../../../src/authorization/permissions/AclPermission';
+import { WebAclMetadataCollector } from '../../../../../src/http/ldp/metadata/WebAclMetadataCollector';
+import type { Operation } from '../../../../../src/http/Operation';
+import { RepresentationMetadata } from '../../../../../src/http/representation/RepresentationMetadata';
+import { ACL, AUTH } from '../../../../../src/util/Vocabularies';
+
+describe('A WebAclMetadataCollector', (): void => {
+  let operation: Operation;
+  let metadata: RepresentationMetadata;
+  const writer = new WebAclMetadataCollector();
+
+  beforeEach(async(): Promise<void> => {
+    operation = {
+      method: 'GET',
+      target: { path: 'http://test.com/foo' },
+      preferences: {},
+    };
+
+    metadata = new RepresentationMetadata();
+  });
+
+  it('adds no metadata if there are no permissions.', async(): Promise<void> => {
+    await expect(writer.handle({ metadata, operation })).resolves.toBeUndefined();
+    expect(metadata.quads()).toHaveLength(0);
+
+    operation.permissionSet = {};
+    await expect(writer.handle({ metadata, operation })).resolves.toBeUndefined();
+    expect(metadata.quads()).toHaveLength(0);
+  });
+
+  it('adds no metadata if the method is wrong.', async(): Promise<void> => {
+    operation.permissionSet = { [CredentialGroup.public]: { read: true, write: false }};
+    operation.method = 'DELETE';
+    await expect(writer.handle({ metadata, operation })).resolves.toBeUndefined();
+    expect(metadata.quads()).toHaveLength(0);
+  });
+
+  it('adds corresponding metadata for all permissions present.', async(): Promise<void> => {
+    operation.permissionSet = {
+      [CredentialGroup.agent]: { read: true, write: true, control: false } as AclPermission,
+      [CredentialGroup.public]: { read: true, write: false },
+    };
+    await expect(writer.handle({ metadata, operation })).resolves.toBeUndefined();
+    expect(metadata.quads()).toHaveLength(3);
+    expect(metadata.getAll(AUTH.terms.userMode)).toEqualRdfTermArray([ ACL.terms.Read, ACL.terms.Write ]);
+    expect(metadata.get(AUTH.terms.publicMode)).toEqualRdfTerm(ACL.terms.Read);
+  });
+
+  it('ignores unknown modes.', async(): Promise<void> => {
+    operation.permissionSet = {
+      [CredentialGroup.agent]: { read: true, create: true },
+      [CredentialGroup.public]: { read: true },
+    };
+    await expect(writer.handle({ metadata, operation })).resolves.toBeUndefined();
+    expect(metadata.quads()).toHaveLength(2);
+    expect(metadata.getAll(AUTH.terms.userMode)).toEqualRdfTermArray([ ACL.terms.Read ]);
+    expect(metadata.get(AUTH.terms.publicMode)).toEqualRdfTerm(ACL.terms.Read);
+  });
+});