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

fix: Remove unneeded pod files

Browse Source
This commit is contained in:
Joachim Van Herwegen
2021-05-28 16:39:28 +02:00
parent 4d7d939dc4
commit 130a91fdfb
11 changed files with 4 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
test/integration/PodCreation.test.ts
View File

@@ -1,75 +0,0 @@
import type { Server } from 'http';
import fetch from 'cross-fetch';
import type { Initializer } from '../../src/init/Initializer';
import type { HttpServerFactory } from '../../src/server/HttpServerFactory';
import { joinFilePath } from '../../src/util/PathUtil';
import { readableToString } from '../../src/util/StreamUtil';
import { getPort } from '../util/Util';
import { getTestConfigPath, instantiateFromConfig } from './Config';
const port = getPort('PodCreation');
const baseUrl = `http://localhost:${port}/`;
describe('A server with a pod handler', (): void => {
let initializer: Initializer;
let factory: HttpServerFactory;
let server: Server;
const settings = { login: 'alice', webId: 'http://test.com/#alice', name: 'Alice Bob' };
beforeAll(async(): Promise<void> => {
const instances = await instantiateFromConfig(
'urn:solid-server:test:Instances',
getTestConfigPath('server-without-auth.json'),
{
'urn:solid-server:default:variable:port': port,
'urn:solid-server:default:variable:baseUrl': baseUrl,
'urn:solid-server:default:variable:podTemplateFolder': joinFilePath(__dirname, '../assets/templates'),
},
) as Record<string, any>;
({ factory, initializer } = instances);
await initializer.handleSafe();
server = factory.startServer(port);
});
afterAll(async(): Promise<void> => {
await new Promise<void>((resolve, reject): void => {
server.close((error): void => error ? reject(error) : resolve());
});
});
it('creates a pod when posting PodSettings to /pods.', async(): Promise<void> => {
const pod = `${baseUrl}${settings.login}/`;
// Pod should not exist yet
let res = await fetch(pod);
expect(res.status).toBe(404);
// Create pod call should return the address of the new pod
res = await fetch(`${baseUrl}pods`, {
method: 'POST',
headers: {
'content-type': 'application/json',
},
body: JSON.stringify(settings),
});
expect(res.status).toBe(201);
expect(res.headers.get('location')).toBe(`${baseUrl}${settings.login}/`);
// Check if all resources are created
res = await fetch(`${pod}.acl`);
expect(res.status).toBe(200);
let body = await readableToString(res.body as any);
expect(body).toContain(`acl:agent <${settings.webId}>`);
res = await fetch(`${pod}profile/card`);
expect(res.status).toBe(200);
expect(res.headers.get('content-type')).toBe('text/turtle');
body = await readableToString(res.body as any);
expect(body).toBe(`@prefix foaf: <http://xmlns.com/foaf/0.1/>.
<${settings.webId}>
a foaf:Person ;
foaf:name "${settings.name}".
`);
});
});

80
test/unit/pods/PodManagerHttpHandler.test.ts
View File

@@ -1,80 +0,0 @@
import type { RequestParser } from '../../../src/ldp/http/RequestParser';
import { CreatedResponseDescription } from '../../../src/ldp/http/response/CreatedResponseDescription';
import type { ResponseWriter } from '../../../src/ldp/http/ResponseWriter';
import type { ResourceIdentifier } from '../../../src/ldp/representation/ResourceIdentifier';
import type { PodManager } from '../../../src/pods/PodManager';
import { PodManagerHttpHandler } from '../../../src/pods/PodManagerHttpHandler';
import type { PodSettingsParser } from '../../../src/pods/settings/PodSettingsParser';
import type { HttpRequest } from '../../../src/server/HttpRequest';
import type { HttpResponse } from '../../../src/server/HttpResponse';
import { BadRequestHttpError } from '../../../src/util/errors/BadRequestHttpError';
import { InternalServerError } from '../../../src/util/errors/InternalServerError';
import { NotImplementedHttpError } from '../../../src/util/errors/NotImplementedHttpError';
import { StaticAsyncHandler } from '../../util/StaticAsyncHandler';
describe('A PodManagerHttpHandler', (): void => {
const requestPath = '/pods';
let requestParser: RequestParser;
let podSettingsParser: PodSettingsParser;
let manager: PodManager;
let responseWriter: ResponseWriter;
let handler: PodManagerHttpHandler;
beforeEach(async(): Promise<void> => {
requestParser = { handleSafe: jest.fn((): any => 'requestParser') } as any;
podSettingsParser = new StaticAsyncHandler(true, 'podSettingsParser' as any);
manager = {
createPod: jest.fn(),
};
responseWriter = { handleSafe: jest.fn((): any => 'response') } as any;
handler = new PodManagerHttpHandler({ requestPath, requestParser, podSettingsParser, manager, responseWriter });
});
it('only supports requests to /pods.', async(): Promise<void> => {
const call = handler.canHandle({ request: { url: '/notPods' } as HttpRequest });
await expect(call).rejects.toThrow('Only requests to /pods are accepted');
await expect(call).rejects.toThrow(NotImplementedHttpError);
await expect(handler.canHandle({ request: { url: '/pods' } as HttpRequest })).resolves.toBeUndefined();
});
it('writes an error if the request was no POST.', async(): Promise<void> => {
const response = {} as HttpResponse;
await expect(handler.handle({ request: { method: 'GET' } as HttpRequest, response })).resolves.toBeUndefined();
expect(responseWriter.handleSafe).toHaveBeenCalledTimes(1);
const mockCall = (responseWriter.handleSafe as jest.Mock).mock.calls[0][0];
expect(mockCall).toEqual({ response, result: expect.any(NotImplementedHttpError) });
expect(mockCall.result.message).toBe('Only POST requests are supported');
});
it('writes an error if there is no input body.', async(): Promise<void> => {
const response = {} as HttpResponse;
await expect(handler.handle({ request: { method: 'POST' } as HttpRequest, response })).resolves.toBeUndefined();
expect(responseWriter.handleSafe).toHaveBeenCalledTimes(1);
const mockCall = (responseWriter.handleSafe as jest.Mock).mock.calls[0][0];
expect(mockCall).toEqual({ response, result: expect.any(BadRequestHttpError) });
expect(mockCall.result.message).toBe('A body is required to create a pod');
});
it('writes an internal error if a non-error was thrown.', async(): Promise<void> => {
const response = {} as HttpResponse;
(requestParser.handleSafe as jest.Mock).mockImplementationOnce((): any => {
throw 'apple';
});
await expect(handler.handle({ request: { method: 'POST' } as HttpRequest, response })).resolves.toBeUndefined();
expect(responseWriter.handleSafe).toHaveBeenCalledTimes(1);
const mockCall = (responseWriter.handleSafe as jest.Mock).mock.calls[0][0];
expect(mockCall).toEqual({ response, result: expect.any(InternalServerError) });
expect(mockCall.result.message).toBe('Unexpected error');
});
it('returns the id of the created pod on success.', async(): Promise<void> => {
const response = {} as HttpResponse;
(manager.createPod as jest.Mock).mockImplementationOnce((): ResourceIdentifier => ({ path: '/pad/to/pod/' }));
(requestParser.handleSafe as jest.Mock).mockImplementationOnce((): any => ({ body: 'data' }));
await expect(handler.handle({ request: { method: 'POST' } as HttpRequest, response })).resolves.toBeUndefined();
expect(responseWriter.handleSafe).toHaveBeenCalledTimes(1);
expect(responseWriter.handleSafe).toHaveBeenLastCalledWith(
{ response, result: new CreatedResponseDescription({ path: '/pad/to/pod/' }) },
);
});
});

50
test/unit/pods/settings/PodSettingsJsonParser.test.ts
View File

@@ -1,50 +0,0 @@
import { BasicRepresentation } from '../../../../src/ldp/representation/BasicRepresentation';
import type { Representation } from '../../../../src/ldp/representation/Representation';
import { RepresentationMetadata } from '../../../../src/ldp/representation/RepresentationMetadata';
import { PodSettingsJsonParser } from '../../../../src/pods/settings/PodSettingsJsonParser';
import { BadRequestHttpError } from '../../../../src/util/errors/BadRequestHttpError';
import { NotImplementedHttpError } from '../../../../src/util/errors/NotImplementedHttpError';
import { guardedStreamFrom } from '../../../../src/util/StreamUtil';
describe('An PodSettingsJsonParser', (): void => {
let metadata: RepresentationMetadata;
let representation: Representation;
const parser = new PodSettingsJsonParser();
beforeEach(async(): Promise<void> => {
metadata = new RepresentationMetadata('application/json');
representation = new BasicRepresentation([], metadata);
});
it('only supports JSON data.', async(): Promise<void> => {
metadata.contentType = undefined;
const result = parser.canHandle(representation);
await expect(result).rejects.toThrow(NotImplementedHttpError);
await expect(result).rejects.toThrow('Only JSON data is supported');
metadata.contentType = 'application/json';
await expect(parser.canHandle(representation)).resolves.toBeUndefined();
metadata.contentType = 'application/ld+json';
await expect(parser.canHandle(representation)).resolves.toBeUndefined();
});
it('errors if required keys are missing.', async(): Promise<void> => {
representation.data = guardedStreamFrom([ JSON.stringify({ login: 'login' }) ]);
const result = parser.handle(representation);
await expect(result).rejects.toThrow(BadRequestHttpError);
await expect(result).rejects.toThrow('Input data is missing key webId');
});
it('generates a User object.', async(): Promise<void> => {
representation.data = guardedStreamFrom([ JSON.stringify({
login: 'login',
webId: 'webId',
name: 'name',
}) ]);
await expect(parser.handle(representation)).resolves
.toEqual({
login: 'login',
webId: 'webId',
name: 'name',
});
});
});