feat: Implement --baseUrl flag.

Closes https://github.com/solid/community-server/issues/372

test/integration/Middleware.test.ts

@@ -23,6 +23,7 @@ describe('An Express server with middleware', (): void => {
       'urn:solid-server:default:ExpressHttpServerFactory', 'middleware.json', {
         'urn:solid-server:default:LdpHandler': new SimpleHttpHandler(),
         'urn:solid-server:default:variable:port': port,
+        'urn:solid-server:default:variable:baseUrl': 'https://example.pod/',
       },
     ) as ExpressHttpServerFactory;
     server = factory.startServer(port);

test/integration/WebSocketsProtocol.test.ts

@@ -5,7 +5,7 @@ import type { HttpServerFactory } from '../../src/server/HttpServerFactory';
 import { instantiateFromConfig } from '../configs/Util';
 
 const port = 6001;
-const baseUrl = `http://localhost:${port}/`;
+const serverUrl = `http://localhost:${port}/`;
 
 describe('A server with the Solid WebSockets API', (): void => {
   let server: Server;
@@ -14,7 +14,7 @@ describe('A server with the Solid WebSockets API', (): void => {
     const factory = await instantiateFromConfig(
       'urn:solid-server:default:ServerFactory', 'websockets.json', {
         'urn:solid-server:default:variable:port': port,
-        'urn:solid-server:default:variable:base': baseUrl,
+        'urn:solid-server:default:variable:baseUrl': 'http://example.pod/',
       },
     ) as HttpServerFactory;
     server = factory.startServer(port);
@@ -27,17 +27,17 @@ describe('A server with the Solid WebSockets API', (): void => {
   });
 
   it('returns a 200.', async(): Promise<void> => {
-    const response = await fetch(baseUrl);
+    const response = await fetch(serverUrl, { headers: { host: 'example.pod' }});
     expect(response.status).toBe(200);
   });
 
   it('sets the Updates-Via header.', async(): Promise<void> => {
-    const response = await fetch(baseUrl);
-    expect(response.headers.get('Updates-Via')).toBe(`ws://localhost:${port}/`);
+    const response = await fetch(serverUrl, { headers: { host: 'example.pod' }});
+    expect(response.headers.get('Updates-Via')).toBe('ws://example.pod/');
   });
 
   it('exposes the Updates-Via header via CORS.', async(): Promise<void> => {
-    const response = await fetch(baseUrl);
+    const response = await fetch(serverUrl, { headers: { host: 'example.pod' }});
     expect(response.headers.get('Access-Control-Expose-Headers')!.split(','))
       .toContain('Updates-Via');
   });
@@ -47,7 +47,7 @@ describe('A server with the Solid WebSockets API', (): void => {
     const messages = new Array<string>();
 
     beforeAll(async(): Promise<void> => {
-      client = new WebSocket(`ws://localhost:${port}`, [ 'solid/0.1.0-alpha' ]);
+      client = new WebSocket(`ws://localhost:${port}`, [ 'solid/0.1.0-alpha' ], { headers: { host: 'example.pod' }});
       client.on('message', (message: string): any => messages.push(message));
       await new Promise((resolve): any => client.on('open', resolve));
     });
@@ -69,21 +69,24 @@ describe('A server with the Solid WebSockets API', (): void => {
 
     describe('when the client subscribes to a resource', (): void => {
       beforeAll(async(): Promise<void> => {
-        client.send(`sub ${baseUrl}my-resource`);
+        client.send(`sub http://example.pod/my-resource`);
         await new Promise((resolve): any => client.once('message', resolve));
       });
 
       it('acknowledges the subscription.', async(): Promise<void> => {
-        expect(messages).toEqual([ `ack ${baseUrl}my-resource` ]);
+        expect(messages).toEqual([ `ack http://example.pod/my-resource` ]);
       });
 
       it('notifies the client of resource updates.', async(): Promise<void> => {
-        await fetch(`${baseUrl}my-resource`, {
+        await fetch(`${serverUrl}my-resource`, {
           method: 'PUT',
-          headers: { 'content-type': 'application/json' },
+          headers: {
+            host: 'example.pod',
+            'content-type': 'application/json',
+          },
           body: '{}',
         });
-        expect(messages).toEqual([ `pub ${baseUrl}my-resource` ]);
+        expect(messages).toEqual([ `pub http://example.pod/my-resource` ]);
       });
     });
   });

test/unit/init/CliRunner.test.ts

@@ -5,13 +5,13 @@ import type { Setup } from '../../../src/init/Setup';
 
 const mainModulePath = path.join(__dirname, '../../../');
 
-const mockSetup = {
+const mockSetup: jest.Mocked<Setup> = {
   setup: jest.fn(async(): Promise<any> => null),
-} as unknown as jest.Mocked<Setup>;
-const loader = {
+} as any;
+const loader: jest.Mocked<Loader> = {
   instantiateFromUrl: jest.fn(async(): Promise<any> => mockSetup),
   registerAvailableModuleResources: jest.fn(async(): Promise<any> => mockSetup),
-} as unknown as jest.Mocked<Loader>;
+} as any;
 
 // Mock the Loader class.
 jest.mock('componentsjs', (): any => ({
@@ -40,7 +40,7 @@ describe('CliRunner', (): void => {
       {
         variables: {
           'urn:solid-server:default:variable:port': 3000,
-          'urn:solid-server:default:variable:base': `http://localhost:3000/`,
+          'urn:solid-server:default:variable:baseUrl': 'http://localhost:3000/',
           'urn:solid-server:default:variable:rootFilePath': process.cwd(),
           'urn:solid-server:default:variable:sparqlEndpoint': undefined,
           'urn:solid-server:default:variable:loggingLevel': 'info',
@@ -58,6 +58,7 @@ describe('CliRunner', (): void => {
       argv: [
         'node', 'script',
         '-p', '4000',
+        '-b', 'http://pod.example/',
         '-c', 'myconfig.json',
         '-f', '/root',
         '-s', 'http://localhost:5000/sparql',
@@ -73,7 +74,7 @@ describe('CliRunner', (): void => {
       {
         variables: {
           'urn:solid-server:default:variable:port': 4000,
-          'urn:solid-server:default:variable:base': `http://localhost:4000/`,
+          'urn:solid-server:default:variable:baseUrl': 'http://pod.example/',
           'urn:solid-server:default:variable:rootFilePath': '/root',
           'urn:solid-server:default:variable:sparqlEndpoint': 'http://localhost:5000/sparql',
           'urn:solid-server:default:variable:loggingLevel': 'debug',
@@ -87,6 +88,7 @@ describe('CliRunner', (): void => {
       argv: [
         'node', 'script',
         '--port', '4000',
+        '--baseUrl', 'http://pod.example/',
         '--config', 'myconfig.json',
         '--rootFilePath', '/root',
         '--sparqlEndpoint', 'http://localhost:5000/sparql',
@@ -102,7 +104,7 @@ describe('CliRunner', (): void => {
       {
         variables: {
           'urn:solid-server:default:variable:port': 4000,
-          'urn:solid-server:default:variable:base': `http://localhost:4000/`,
+          'urn:solid-server:default:variable:baseUrl': 'http://pod.example/',
           'urn:solid-server:default:variable:rootFilePath': '/root',
           'urn:solid-server:default:variable:sparqlEndpoint': 'http://localhost:5000/sparql',
           'urn:solid-server:default:variable:loggingLevel': 'debug',

test/unit/server/middleware/WebSocketAdvertiser.test.ts

@@ -2,36 +2,31 @@ import { createResponse } from 'node-mocks-http';
 import { WebSocketAdvertiser } from '../../../../src/server/middleware/WebSocketAdvertiser';
 
 describe('A WebSocketAdvertiser', (): void => {
-  it('writes a default HTTP WebSocket.', async(): Promise<void> => {
-    const writer = new WebSocketAdvertiser();
-    const response = createResponse();
-    await writer.handle({ response } as any);
-    expect(response.getHeaders()).toEqual({ 'updates-via': 'ws://localhost/' });
-  });
-
-  it('writes an HTTP WebSocket with port 80.', async(): Promise<void> => {
-    const writer = new WebSocketAdvertiser({ hostname: 'test.example', port: 80, protocol: 'http' });
+  it('writes a ws: socket when given an http: URL.', async(): Promise<void> => {
+    const writer = new WebSocketAdvertiser('http://test.example/');
     const response = createResponse();
     await writer.handle({ response } as any);
     expect(response.getHeaders()).toEqual({ 'updates-via': 'ws://test.example/' });
   });
 
-  it('writes an HTTP WebSocket with port 3000.', async(): Promise<void> => {
-    const writer = new WebSocketAdvertiser({ hostname: 'test.example', port: 3000, protocol: 'http' });
+  it('writes a ws: socket when given a ws: URL.', async(): Promise<void> => {
+    const writer = new WebSocketAdvertiser('ws://test.example/');
     const response = createResponse();
     await writer.handle({ response } as any);
-    expect(response.getHeaders()).toEqual({ 'updates-via': 'ws://test.example:3000/' });
+    expect(response.getHeaders()).toEqual({ 'updates-via': 'ws://test.example/' });
   });
 
-  it('writes an HTTPS WebSocket with port 443.', async(): Promise<void> => {
-    const writer = new WebSocketAdvertiser({ hostname: 'test.example', port: 443, protocol: 'https' });
+  it('writes a wss: socket when given an https: URL.', async(): Promise<void> => {
+    const writer = new WebSocketAdvertiser('https://test.example/');
     const response = createResponse();
     await writer.handle({ response } as any);
     expect(response.getHeaders()).toEqual({ 'updates-via': 'wss://test.example/' });
   });
 
-  it('rejects an invalid hostname.', (): void => {
-    expect((): any => new WebSocketAdvertiser({ hostname: 'test.example/invalid' }))
-      .toThrow('Invalid hostname: test.example/invalid');
+  it('writes a wss: socket when given a wss: URL.', async(): Promise<void> => {
+    const writer = new WebSocketAdvertiser('wss://test.example/');
+    const response = createResponse();
+    await writer.handle({ response } as any);
+    expect(response.getHeaders()).toEqual({ 'updates-via': 'wss://test.example/' });
   });
 });