javascript-solid-server 0.0.7 → 0.0.8

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' });