javascript-solid-server 0.0.7 → 0.0.9

package/test/conneg.test.js

@@ -0,0 +1,289 @@
+/**
+ * Content Negotiation Tests
+ *
+ * Tests Turtle <-> JSON-LD conversion with conneg enabled.
+ * Note: Content negotiation is OFF by default (JSON-LD native server).
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import {
+  startTestServer,
+  stopTestServer,
+  request,
+  createTestPod,
+  assertStatus,
+  assertHeader,
+  assertHeaderContains
+} from './helpers.js';
+
+describe('Content Negotiation (conneg enabled)', () => {
+  before(async () => {
+    // Start server with conneg ENABLED
+    await startTestServer({ conneg: true });
+    await createTestPod('connegtest');
+  });
+
+  after(async () => {
+    await stopTestServer();
+  });
+
+  describe('GET with Accept header', () => {
+    it('should return JSON-LD when Accept: application/ld+json', async () => {
+      // Create a JSON-LD resource
+      const data = {
+        '@context': { 'foaf': 'http://xmlns.com/foaf/0.1/' },
+        '@id': '#me',
+        'foaf:name': 'Alice'
+      };
+
+      await request('/connegtest/public/alice.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify(data),
+        auth: 'connegtest'
+      });
+
+      const res = await request('/connegtest/public/alice.json', {
+        headers: { 'Accept': 'application/ld+json' }
+      });
+
+      assertStatus(res, 200);
+      assertHeaderContains(res, 'Content-Type', 'application/ld+json');
+
+      const body = await res.json();
+      assert.strictEqual(body['foaf:name'], 'Alice');
+    });
+
+    it('should return Turtle when Accept: text/turtle', async () => {
+      // Create a JSON-LD resource
+      const data = {
+        '@context': { 'foaf': 'http://xmlns.com/foaf/0.1/' },
+        '@id': '#me',
+        'foaf:name': 'Bob'
+      };
+
+      await request('/connegtest/public/bob.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify(data),
+        auth: 'connegtest'
+      });
+
+      const res = await request('/connegtest/public/bob.json', {
+        headers: { 'Accept': 'text/turtle' }
+      });
+
+      assertStatus(res, 200);
+      assertHeaderContains(res, 'Content-Type', 'text/turtle');
+
+      const turtle = await res.text();
+      // Should contain foaf prefix and name
+      assert.ok(turtle.includes('foaf:') || turtle.includes('http://xmlns.com/foaf/0.1/'),
+        'Turtle should contain foaf prefix or URI');
+      assert.ok(turtle.includes('Bob'), 'Turtle should contain the name');
+    });
+
+    it('should default to JSON-LD for */* Accept', async () => {
+      const res = await request('/connegtest/public/alice.json', {
+        headers: { 'Accept': '*/*' }
+      });
+
+      assertStatus(res, 200);
+      assertHeaderContains(res, 'Content-Type', 'application/ld+json');
+    });
+
+    it('should include Vary header with Accept', async () => {
+      const res = await request('/connegtest/public/alice.json');
+      const vary = res.headers.get('Vary');
+      assert.ok(vary && vary.includes('Accept'), 'Should have Vary: Accept');
+    });
+  });
+
+  describe('PUT with Content-Type', () => {
+    it('should accept Turtle input and store as JSON-LD', async () => {
+      const turtle = `
+        @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+        <#me> foaf:name "Charlie".
+      `;
+
+      const res = await request('/connegtest/public/charlie.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/turtle' },
+        body: turtle,
+        auth: 'connegtest'
+      });
+
+      assertStatus(res, 201);
+
+      // Verify it's stored as JSON-LD
+      const getRes = await request('/connegtest/public/charlie.json', {
+        headers: { 'Accept': 'application/ld+json' }
+      });
+
+      assertStatus(getRes, 200);
+      const data = await getRes.json();
+      assert.ok(data['@context'], 'Should have @context');
+    });
+
+    it('should accept N3 input', async () => {
+      const n3 = `
+        @prefix schema: <http://schema.org/>.
+        <#item> schema:name "Widget".
+      `;
+
+      const res = await request('/connegtest/public/widget.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/n3' },
+        body: n3,
+        auth: 'connegtest'
+      });
+
+      assertStatus(res, 201);
+    });
+
+    it('should return 400 for invalid Turtle', async () => {
+      const invalidTurtle = 'this is not valid turtle {{{';
+
+      const res = await request('/connegtest/public/invalid.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/turtle' },
+        body: invalidTurtle,
+        auth: 'connegtest'
+      });
+
+      assertStatus(res, 400);
+    });
+  });
+
+  describe('POST with Content-Type', () => {
+    it('should accept Turtle input in POST', async () => {
+      const turtle = `
+        @prefix dc: <http://purl.org/dc/terms/>.
+        <#doc> dc:title "My Document".
+      `;
+
+      const res = await request('/connegtest/public/', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'text/turtle',
+          'Slug': 'turtle-doc.json'
+        },
+        body: turtle,
+        auth: 'connegtest'
+      });
+
+      assertStatus(res, 201);
+      const location = res.headers.get('Location');
+      assert.ok(location, 'Should have Location header');
+    });
+  });
+
+  describe('Accept-* Headers', () => {
+    it('should advertise Turtle support in Accept-Put', async () => {
+      const res = await request('/connegtest/public/alice.json');
+      const acceptPut = res.headers.get('Accept-Put');
+      assert.ok(acceptPut && acceptPut.includes('text/turtle'),
+        'Accept-Put should include text/turtle');
+    });
+
+    it('should advertise Turtle support in Accept-Post for containers', async () => {
+      const res = await request('/connegtest/public/');
+      const acceptPost = res.headers.get('Accept-Post');
+      assert.ok(acceptPost && acceptPost.includes('text/turtle'),
+        'Accept-Post should include text/turtle');
+    });
+  });
+});
+
+describe('Content Negotiation (conneg disabled - default)', () => {
+  before(async () => {
+    // Start server with conneg DISABLED (default)
+    await startTestServer({ conneg: false });
+    await createTestPod('noconneg');
+  });
+
+  after(async () => {
+    await stopTestServer();
+  });
+
+  describe('Default JSON-LD behavior', () => {
+    it('should always return JSON-LD regardless of Accept header', async () => {
+      // Create resource
+      const data = {
+        '@context': { 'foaf': 'http://xmlns.com/foaf/0.1/' },
+        '@id': '#me',
+        'foaf:name': 'DefaultUser'
+      };
+
+      await request('/noconneg/public/user.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify(data),
+        auth: 'noconneg'
+      });
+
+      // Request Turtle
+      const res = await request('/noconneg/public/user.json', {
+        headers: { 'Accept': 'text/turtle' }
+      });
+
+      assertStatus(res, 200);
+      // Should still return JSON-LD when conneg disabled
+      const body = await res.json();
+      assert.strictEqual(body['foaf:name'], 'DefaultUser');
+    });
+
+    it('should accept JSON-LD input', async () => {
+      const data = { '@id': '#test', 'http://example.org/p': 'value' };
+
+      const res = await request('/noconneg/public/test.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify(data),
+        auth: 'noconneg'
+      });
+
+      assertStatus(res, 201);
+    });
+
+    it('should accept plain JSON input', async () => {
+      const data = { foo: 'bar' };
+
+      const res = await request('/noconneg/public/plain.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(data),
+        auth: 'noconneg'
+      });
+
+      assertStatus(res, 201);
+    });
+
+    it('should accept non-RDF content types', async () => {
+      const res = await request('/noconneg/public/readme.txt', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'text/plain' },
+        body: 'Hello World',
+        auth: 'noconneg'
+      });
+
+      assertStatus(res, 201);
+
+      const getRes = await request('/noconneg/public/readme.txt');
+      assertStatus(getRes, 200);
+      const text = await getRes.text();
+      assert.strictEqual(text, 'Hello World');
+    });
+
+    it('should not advertise Turtle in Accept-Put when conneg disabled', async () => {
+      const res = await request('/noconneg/public/');
+      const acceptPut = res.headers.get('Accept-Put');
+      // Should only advertise JSON-LD, not Turtle
+      assert.ok(acceptPut && acceptPut.includes('application/ld+json'),
+        'Accept-Put should include application/ld+json');
+      assert.ok(!acceptPut || !acceptPut.includes('text/turtle'),
+        'Accept-Put should NOT include text/turtle when conneg disabled');
+    });
+  });
+});

package/test/helpers.js

@@ -16,13 +16,15 @@ const podTokens = new Map();
 
 /**
  * Start a test server on a random available port
+ * @param {object} options - Server options
+ * @param {boolean} options.conneg - Enable content negotiation (default false)
  * @returns {Promise<{server: object, baseUrl: string}>}
  */
-export async function startTestServer() {
+export async function startTestServer(options = {}) {
   // Clean up any existing test data
   await fs.emptyDir(TEST_DATA_DIR);
 
-  server = createServer({ logger: false });
+  server = createServer({ logger: false, ...options });
   // Use port 0 to let OS assign available port
   await server.listen({ port: 0, host: '127.0.0.1' });
 

package/test/notifications.test.js

@@ -0,0 +1,348 @@
+/**
+ * WebSocket Notifications Tests
+ *
+ * Tests the solid-0.1 WebSocket notification protocol.
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import { WebSocket } from 'ws';
+import {
+  startTestServer,
+  stopTestServer,
+  request,
+  createTestPod,
+  getBaseUrl,
+  assertStatus,
+  assertHeader,
+  assertHeaderContains
+} from './helpers.js';
+
+describe('WebSocket Notifications (notifications enabled)', () => {
+  let wsUrl;
+
+  before(async () => {
+    // Start server with notifications ENABLED
+    await startTestServer({ notifications: true });
+    await createTestPod('notifytest');
+
+    // Get WebSocket URL from Updates-Via header
+    const res = await request('/notifytest/', { method: 'OPTIONS' });
+    wsUrl = res.headers.get('Updates-Via');
+  });
+
+  after(async () => {
+    await stopTestServer();
+  });
+
+  describe('Discovery', () => {
+    it('should return Updates-Via header in OPTIONS response', async () => {
+      const res = await request('/notifytest/public/', { method: 'OPTIONS' });
+      assertStatus(res, 204);
+      const updatesVia = res.headers.get('Updates-Via');
+      assert.ok(updatesVia, 'Should have Updates-Via header');
+      assert.ok(updatesVia.startsWith('ws://') || updatesVia.startsWith('wss://'),
+        'Updates-Via should be a WebSocket URL');
+    });
+
+    it('should return Updates-Via header in GET response', async () => {
+      const res = await request('/notifytest/');
+      assertStatus(res, 200);
+      const updatesVia = res.headers.get('Updates-Via');
+      assert.ok(updatesVia, 'GET response should have Updates-Via header');
+    });
+
+    it('should expose Updates-Via in CORS headers', async () => {
+      const res = await request('/notifytest/', {
+        headers: { 'Origin': 'http://example.org' }
+      });
+      const expose = res.headers.get('Access-Control-Expose-Headers');
+      assert.ok(expose && expose.includes('Updates-Via'),
+        'Updates-Via should be in exposed headers');
+    });
+  });
+
+  describe('WebSocket Protocol', () => {
+    it('should connect and receive protocol greeting', async () => {
+      const ws = new WebSocket(wsUrl);
+
+      const message = await new Promise((resolve, reject) => {
+        ws.on('open', () => {});
+        ws.on('message', (data) => resolve(data.toString()));
+        ws.on('error', reject);
+        setTimeout(() => reject(new Error('Timeout')), 5000);
+      });
+
+      assert.strictEqual(message, 'protocol solid-0.1');
+      ws.close();
+    });
+
+    it('should acknowledge subscription', async () => {
+      const ws = new WebSocket(wsUrl);
+      const baseUrl = getBaseUrl();
+      const resourceUrl = `${baseUrl}/notifytest/public/test.json`;
+
+      const messages = [];
+
+      await new Promise((resolve, reject) => {
+        ws.on('open', () => {
+          ws.send(`sub ${resourceUrl}`);
+        });
+        ws.on('message', (data) => {
+          messages.push(data.toString());
+          if (messages.length >= 2) resolve();
+        });
+        ws.on('error', reject);
+        setTimeout(() => resolve(), 2000);
+      });
+
+      assert.ok(messages.includes('protocol solid-0.1'), 'Should receive protocol greeting');
+      assert.ok(messages.some(m => m.startsWith('ack ')), 'Should receive ack');
+      ws.close();
+    });
+  });
+
+  describe('Notifications', () => {
+    it('should receive pub notification on PUT', async () => {
+      const ws = new WebSocket(wsUrl);
+      const baseUrl = getBaseUrl();
+      const resourceUrl = `${baseUrl}/notifytest/public/notify-put.json`;
+
+      const notifications = [];
+
+      await new Promise((resolve) => {
+        ws.on('open', () => {
+          ws.send(`sub ${resourceUrl}`);
+        });
+        ws.on('message', (data) => {
+          const msg = data.toString();
+          if (msg.startsWith('pub ')) {
+            notifications.push(msg);
+            resolve();
+          }
+        });
+
+        // Wait for subscription to be established
+        setTimeout(async () => {
+          // Create the resource
+          await request('/notifytest/public/notify-put.json', {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/ld+json' },
+            body: JSON.stringify({ '@id': '#test', 'http://example.org/p': 'value' }),
+            auth: 'notifytest'
+          });
+        }, 500);
+
+        setTimeout(() => resolve(), 3000);
+      });
+
+      assert.ok(notifications.length > 0, 'Should receive pub notification');
+      assert.ok(notifications[0].includes(resourceUrl), 'Notification should include resource URL');
+      ws.close();
+    });
+
+    it('should receive pub notification on PATCH', async () => {
+      const baseUrl = getBaseUrl();
+      const resourceUrl = `${baseUrl}/notifytest/public/notify-patch2.json`;
+
+      // First create the resource
+      await request('/notifytest/public/notify-patch2.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify({ '@id': '#test', 'http://example.org/name': 'Original' }),
+        auth: 'notifytest'
+      });
+
+      // Create WebSocket AFTER the initial PUT to avoid race condition
+      const ws = new WebSocket(wsUrl);
+      const notifications = [];
+
+      await new Promise((resolve) => {
+        ws.on('open', () => {
+          ws.send(`sub ${resourceUrl}`);
+        });
+        ws.on('message', (data) => {
+          const msg = data.toString();
+          if (msg.startsWith('pub ')) {
+            notifications.push(msg);
+            resolve();
+          }
+        });
+
+        // Wait for subscription to be established, then patch
+        setTimeout(async () => {
+          const patch = `
+            @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+            _:patch a solid:InsertDeletePatch;
+              solid:inserts { <#test> <http://example.org/name> "Updated" }.
+          `;
+          await request('/notifytest/public/notify-patch2.json', {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'text/n3' },
+            body: patch,
+            auth: 'notifytest'
+          });
+        }, 500);
+
+        setTimeout(() => resolve(), 3000);
+      });
+
+      assert.ok(notifications.length > 0, 'Should receive pub notification for PATCH');
+      ws.close();
+    });
+
+    it('should receive pub notification on DELETE', async () => {
+      const baseUrl = getBaseUrl();
+      const resourceUrl = `${baseUrl}/notifytest/public/notify-delete2.json`;
+
+      // First create the resource
+      await request('/notifytest/public/notify-delete2.json', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify({ '@id': '#test' }),
+        auth: 'notifytest'
+      });
+
+      // Create WebSocket AFTER the initial PUT to avoid race condition
+      const ws = new WebSocket(wsUrl);
+      const notifications = [];
+
+      await new Promise((resolve) => {
+        ws.on('open', () => {
+          ws.send(`sub ${resourceUrl}`);
+        });
+        ws.on('message', (data) => {
+          const msg = data.toString();
+          if (msg.startsWith('pub ')) {
+            notifications.push(msg);
+            resolve();
+          }
+        });
+
+        // Wait for subscription, then delete
+        setTimeout(async () => {
+          await request('/notifytest/public/notify-delete2.json', {
+            method: 'DELETE',
+            auth: 'notifytest'
+          });
+        }, 500);
+
+        setTimeout(() => resolve(), 3000);
+      });
+
+      assert.ok(notifications.length > 0, 'Should receive pub notification for DELETE');
+      ws.close();
+    });
+
+    it('should receive container notification when child changes', async () => {
+      const ws = new WebSocket(wsUrl);
+      const baseUrl = getBaseUrl();
+      const containerUrl = `${baseUrl}/notifytest/public/`;
+
+      const notifications = [];
+
+      await new Promise((resolve) => {
+        ws.on('open', () => {
+          // Subscribe to container
+          ws.send(`sub ${containerUrl}`);
+        });
+        ws.on('message', (data) => {
+          const msg = data.toString();
+          if (msg.startsWith('pub ')) {
+            notifications.push(msg);
+            resolve();
+          }
+        });
+
+        // Wait for subscription, then create a child resource
+        setTimeout(async () => {
+          await request('/notifytest/public/child-resource.json', {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/ld+json' },
+            body: JSON.stringify({ '@id': '#child' }),
+            auth: 'notifytest'
+          });
+        }, 500);
+
+        setTimeout(() => resolve(), 3000);
+      });
+
+      assert.ok(notifications.length > 0, 'Container should receive notification for child changes');
+      ws.close();
+    });
+  });
+
+  describe('Multiple Subscribers', () => {
+    it('should notify all subscribers', async () => {
+      const ws1 = new WebSocket(wsUrl);
+      const ws2 = new WebSocket(wsUrl);
+      const baseUrl = getBaseUrl();
+      const resourceUrl = `${baseUrl}/notifytest/public/multi-sub.json`;
+
+      const notifications1 = [];
+      const notifications2 = [];
+
+      await new Promise((resolve) => {
+        let ready = 0;
+
+        const setupWs = (ws, notifications) => {
+          ws.on('open', () => {
+            ws.send(`sub ${resourceUrl}`);
+          });
+          ws.on('message', (data) => {
+            const msg = data.toString();
+            if (msg.startsWith('ack ')) {
+              ready++;
+              if (ready === 2) {
+                // Both subscribed, trigger change
+                setTimeout(async () => {
+                  await request('/notifytest/public/multi-sub.json', {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ test: true }),
+                    auth: 'notifytest'
+                  });
+                }, 100);
+              }
+            }
+            if (msg.startsWith('pub ')) {
+              notifications.push(msg);
+              if (notifications1.length > 0 && notifications2.length > 0) {
+                resolve();
+              }
+            }
+          });
+        };
+
+        setupWs(ws1, notifications1);
+        setupWs(ws2, notifications2);
+
+        setTimeout(() => resolve(), 4000);
+      });
+
+      assert.ok(notifications1.length > 0, 'First subscriber should receive notification');
+      assert.ok(notifications2.length > 0, 'Second subscriber should receive notification');
+      ws1.close();
+      ws2.close();
+    });
+  });
+});
+
+describe('WebSocket Notifications (notifications disabled - default)', () => {
+  before(async () => {
+    // Start server with notifications DISABLED (default)
+    await startTestServer({ notifications: false });
+    await createTestPod('nonotify');
+  });
+
+  after(async () => {
+    await stopTestServer();
+  });
+
+  it('should NOT return Updates-Via header when notifications disabled', async () => {
+    const res = await request('/nonotify/', { method: 'OPTIONS' });
+    assertStatus(res, 204);
+    const updatesVia = res.headers.get('Updates-Via');
+    assert.strictEqual(updatesVia, null, 'Should NOT have Updates-Via header when disabled');
+  });
+});