refactor: Separate middleware from Express.

test/configs/middleware.json

@@ -0,0 +1,13 @@
+{
+  "@context": "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^1.0.0/components/context.jsonld",
+  "import": [
+    "files-scs:config/presets/http.json",
+    "files-scs:config/presets/middleware.json"
+  ],
+  "@graph": [
+    {
+      "@id": "urn:solid-server:default:LdpHandler",
+      "@type": "Variable"
+    }
+  ]
+}

test/configs/websockets.json

@@ -9,6 +9,7 @@
     "files-scs:config/presets/ldp/response-writer.json",
     "files-scs:config/presets/ldp/request-parser.json",
     "files-scs:config/presets/ldp/websockets.json",
+    "files-scs:config/presets/middleware.json",
     "files-scs:config/presets/representation-conversion.json",
     "files-scs:config/presets/storage/backend/storage-memory.json",
     "files-scs:config/presets/storage/routing/no-routing.json",
@@ -17,7 +18,7 @@
   ],
   "@graph": [
     {
-      "@id": "urn:solid-server:default:HttpHandler",
+      "@id": "urn:solid-server:default:LdpHandler",
       "@type": "AuthenticatedLdpHandler",
       "AuthenticatedLdpHandler:_args_requestParser": {
         "@id": "urn:solid-server:default:RequestParser"

test/integration/Middleware.test.ts

@@ -0,0 +1,69 @@
+import type { Server } from 'http';
+import request from 'supertest';
+import type { ExpressHttpServerFactory } from '../../src/server/ExpressHttpServerFactory';
+import { HttpHandler } from '../../src/server/HttpHandler';
+import type { HttpRequest } from '../../src/server/HttpRequest';
+import type { HttpResponse } from '../../src/server/HttpResponse';
+import { instantiateFromConfig } from '../configs/Util';
+
+const port = 6002;
+
+class SimpleHttpHandler extends HttpHandler {
+  public async handle(input: { request: HttpRequest; response: HttpResponse }): Promise<void> {
+    input.response.writeHead(200);
+    input.response.end('Hello World');
+  }
+}
+
+describe('An Express server with middleware', (): void => {
+  let server: Server;
+
+  beforeAll(async(): Promise<void> => {
+    const factory = await instantiateFromConfig(
+      'urn:solid-server:default:ExpressHttpServerFactory', 'middleware.json', {
+        'urn:solid-server:default:LdpHandler': new SimpleHttpHandler(),
+      },
+    ) as ExpressHttpServerFactory;
+    server = factory.startServer(port);
+  });
+
+  afterEach(async(): Promise<void> => {
+    server.close();
+  });
+
+  it('sends server identification in the X-Powered-By header.', async(): Promise<void> => {
+    const res = await request(server).get('/');
+    expect(res.header).toEqual(expect.objectContaining({
+      'x-powered-by': 'Community Solid Server',
+    }));
+  });
+
+  it('returns CORS headers for an OPTIONS request.', async(): Promise<void> => {
+    const res = await request(server)
+      .options('/')
+      .set('Access-Control-Request-Headers', 'content-type')
+      .set('Access-Control-Request-Method', 'POST')
+      .set('Host', 'test.com')
+      .expect(204);
+    expect(res.header).toEqual(expect.objectContaining({
+      'access-control-allow-origin': '*',
+      'access-control-allow-headers': 'content-type',
+    }));
+    const corsMethods = res.header['access-control-allow-methods'].split(',')
+      .map((method: string): string => method.trim());
+    const allowedMethods = [ 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT', 'PATCH', 'DELETE' ];
+    expect(corsMethods).toEqual(expect.arrayContaining(allowedMethods));
+    expect(corsMethods).toHaveLength(allowedMethods.length);
+  });
+
+  it('specifies CORS origin header if an origin was supplied.', async(): Promise<void> => {
+    const res = await request(server).get('/').set('origin', 'test.com').expect(200);
+    expect(res.header).toEqual(expect.objectContaining({ 'access-control-allow-origin': 'test.com' }));
+  });
+
+  it('sends incoming requests to the handler.', async(): Promise<void> => {
+    const response = request(server).get('/').set('Host', 'test.com');
+    expect(response).toBeDefined();
+    await response.expect(200).expect('Hello World');
+  });
+});

test/unit/server/ExpressHttpServerFactory.test.ts

@@ -42,7 +42,6 @@ describe('ExpressHttpServerFactory', (): void => {
   });
 
   afterEach(async(): Promise<void> => {
-    // Close server
     server.close();
   });
 
@@ -50,36 +49,6 @@ describe('ExpressHttpServerFactory', (): void => {
     mock.mockReset();
   });
 
-  it('sends server identification in the X-Powered-By header.', async(): Promise<void> => {
-    const res = await request(server).get('/');
-    expect(res.header).toEqual(expect.objectContaining({
-      'x-powered-by': 'Community Solid Server',
-    }));
-  });
-
-  it('returns CORS headers for an OPTIONS request.', async(): Promise<void> => {
-    const res = await request(server)
-      .options('/')
-      .set('Access-Control-Request-Headers', 'content-type')
-      .set('Access-Control-Request-Method', 'POST')
-      .set('Host', 'test.com')
-      .expect(204);
-    expect(res.header).toEqual(expect.objectContaining({
-      'access-control-allow-origin': '*',
-      'access-control-allow-headers': 'content-type',
-    }));
-    const corsMethods = res.header['access-control-allow-methods'].split(',')
-      .map((method: string): string => method.trim());
-    const allowedMethods = [ 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT', 'PATCH', 'DELETE' ];
-    expect(corsMethods).toEqual(expect.arrayContaining(allowedMethods));
-    expect(corsMethods).toHaveLength(allowedMethods.length);
-  });
-
-  it('specifies CORS origin header if an origin was supplied.', async(): Promise<void> => {
-    const res = await request(server).get('/').set('origin', 'test.com').expect(200);
-    expect(res.header).toEqual(expect.objectContaining({ 'access-control-allow-origin': 'test.com' }));
-  });
-
   it('sends incoming requests to the handler.', async(): Promise<void> => {
     await request(server).get('/').set('Host', 'test.com').expect(200);
     expect(canHandleJest).toHaveBeenCalledTimes(1);

test/unit/server/middleware/CorsHandler.test.ts

@@ -0,0 +1,33 @@
+import { createRequest, createResponse } from 'node-mocks-http';
+import { CorsHandler } from '../../../../src/server/middleware/CorsHandler';
+import { guardStream } from '../../../../src/util/GuardedStream';
+
+describe('a CorsHandler', (): void => {
+  let handler: CorsHandler;
+
+  beforeAll(async(): Promise<void> => {
+    handler = new CorsHandler();
+  });
+
+  it('returns CORS headers.', async(): Promise<void> => {
+    const request = guardStream(createRequest());
+    const response = createResponse();
+    await handler.handleSafe({ request, response });
+    expect(response.getHeaders()).toEqual(expect.objectContaining({
+      'access-control-allow-origin': '*',
+    }));
+  });
+
+  it('echoes the origin when specified.', async(): Promise<void> => {
+    const request = guardStream(createRequest({
+      headers: {
+        origin: 'example.org',
+      },
+    }));
+    const response = createResponse();
+    await handler.handleSafe({ request, response });
+    expect(response.getHeaders()).toEqual(expect.objectContaining({
+      'access-control-allow-origin': 'example.org',
+    }));
+  });
+});

test/unit/server/middleware/HeaderHandler.test.ts

@@ -0,0 +1,20 @@
+import { createRequest, createResponse } from 'node-mocks-http';
+import { HeaderHandler } from '../../../../src/server/middleware/HeaderHandler';
+import { guardStream } from '../../../../src/util/GuardedStream';
+
+describe('a HeaderHandler', (): void => {
+  let handler: HeaderHandler;
+
+  beforeAll(async(): Promise<void> => {
+    handler = new HeaderHandler();
+  });
+
+  it('returns an X-Powered-By header.', async(): Promise<void> => {
+    const request = guardStream(createRequest());
+    const response = createResponse();
+    await handler.handleSafe({ request, response });
+    expect(response.getHeaders()).toEqual(expect.objectContaining({
+      'x-powered-by': 'Community Solid Server',
+    }));
+  });
+});