javascript-solid-server 0.0.73 → 0.0.76

package/test/range.test.js

@@ -0,0 +1,145 @@
+/**
+ * Range Request Tests
+ *
+ * Tests HTTP Range header support for partial content delivery.
+ */
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert';
+import {
+  startTestServer,
+  stopTestServer,
+  request,
+  createTestPod,
+  assertStatus
+} from './helpers.js';
+
+describe('Range Requests', () => {
+  const testContent = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'; // 36 bytes
+
+  before(async () => {
+    await startTestServer();
+    await createTestPod('rangetest');
+
+    // Create a test file with known content
+    await request('/rangetest/public/test.txt', {
+      method: 'PUT',
+      headers: { 'Content-Type': 'text/plain' },
+      body: testContent,
+      auth: 'rangetest'
+    });
+  });
+
+  after(async () => {
+    await stopTestServer();
+  });
+
+  describe('Accept-Ranges header', () => {
+    it('should include Accept-Ranges: bytes for files', async () => {
+      const res = await request('/rangetest/public/test.txt');
+      assertStatus(res, 200);
+      assert.strictEqual(res.headers.get('Accept-Ranges'), 'bytes');
+    });
+
+    it('should include Accept-Ranges: none for containers', async () => {
+      const res = await request('/rangetest/public/');
+      assertStatus(res, 200);
+      assert.strictEqual(res.headers.get('Accept-Ranges'), 'none');
+    });
+  });
+
+  describe('Range header parsing', () => {
+    it('should return 206 for valid range bytes=0-9', async () => {
+      const res = await request('/rangetest/public/test.txt', {
+        headers: { 'Range': 'bytes=0-9' }
+      });
+      assertStatus(res, 206);
+
+      const body = await res.text();
+      assert.strictEqual(body, 'ABCDEFGHIJ');
+      assert.strictEqual(res.headers.get('Content-Range'), 'bytes 0-9/36');
+      assert.strictEqual(res.headers.get('Content-Length'), '10');
+    });
+
+    it('should return 206 for open-ended range bytes=30-', async () => {
+      const res = await request('/rangetest/public/test.txt', {
+        headers: { 'Range': 'bytes=30-' }
+      });
+      assertStatus(res, 206);
+
+      const body = await res.text();
+      assert.strictEqual(body, '456789');
+      assert.strictEqual(res.headers.get('Content-Range'), 'bytes 30-35/36');
+    });
+
+    it('should return 206 for suffix range bytes=-6', async () => {
+      const res = await request('/rangetest/public/test.txt', {
+        headers: { 'Range': 'bytes=-6' }
+      });
+      assertStatus(res, 206);
+
+      const body = await res.text();
+      assert.strictEqual(body, '456789');
+      assert.strictEqual(res.headers.get('Content-Range'), 'bytes 30-35/36');
+    });
+
+    it('should clamp end to file size for range exceeding file', async () => {
+      const res = await request('/rangetest/public/test.txt', {
+        headers: { 'Range': 'bytes=30-1000' }
+      });
+      assertStatus(res, 206);
+
+      const body = await res.text();
+      assert.strictEqual(body, '456789');
+      assert.strictEqual(res.headers.get('Content-Range'), 'bytes 30-35/36');
+    });
+  });
+
+  describe('Multi-range requests', () => {
+    it('should ignore multi-range and return 200 with full content', async () => {
+      const res = await request('/rangetest/public/test.txt', {
+        headers: { 'Range': 'bytes=0-5,10-15' }
+      });
+      // Multi-range is not supported, should fall back to 200
+      assertStatus(res, 200);
+
+      const body = await res.text();
+      assert.strictEqual(body, testContent);
+    });
+  });
+
+  describe('Invalid ranges', () => {
+    it('should return 200 for invalid range format', async () => {
+      const res = await request('/rangetest/public/test.txt', {
+        headers: { 'Range': 'invalid' }
+      });
+      // Invalid format, ignore Range header
+      assertStatus(res, 200);
+    });
+
+    it('should return 200 for non-bytes range unit', async () => {
+      const res = await request('/rangetest/public/test.txt', {
+        headers: { 'Range': 'chars=0-10' }
+      });
+      assertStatus(res, 200);
+    });
+  });
+
+  describe('RDF resources', () => {
+    it('should ignore Range header for RDF resources', async () => {
+      // Create an RDF resource
+      await request('/rangetest/public/data.jsonld', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify({ '@id': '#test', 'http://example.org/name': 'Test' }),
+        auth: 'rangetest'
+      });
+
+      const res = await request('/rangetest/public/data.jsonld', {
+        headers: { 'Range': 'bytes=0-10' }
+      });
+      // RDF resources don't support range requests
+      assertStatus(res, 200);
+    });
+  });
+});

package/test/webid-tls.test.js

@@ -0,0 +1,119 @@
+/**
+ * WebID-TLS Authentication tests
+ *
+ * Tests the WebID-TLS certificate parsing and verification logic.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import {
+  extractWebIdFromSAN,
+  verifyWebIdTls,
+  clearCache
+} from '../src/auth/webid-tls.js';
+
+describe('WebID-TLS', () => {
+  describe('extractWebIdFromSAN', () => {
+    it('should extract WebID from simple SAN', () => {
+      const san = 'URI:https://alice.example/card#me';
+      const webId = extractWebIdFromSAN(san);
+      assert.strictEqual(webId, 'https://alice.example/card#me');
+    });
+
+    it('should extract WebID from multi-value SAN', () => {
+      const san = 'URI:https://bob.example/profile/card#me, DNS:example.com, IP:192.168.1.1';
+      const webId = extractWebIdFromSAN(san);
+      assert.strictEqual(webId, 'https://bob.example/profile/card#me');
+    });
+
+    it('should return null for missing SAN', () => {
+      const webId = extractWebIdFromSAN(null);
+      assert.strictEqual(webId, null);
+    });
+
+    it('should return null for SAN without URI', () => {
+      const san = 'DNS:example.com, IP:192.168.1.1';
+      const webId = extractWebIdFromSAN(san);
+      assert.strictEqual(webId, null);
+    });
+
+    it('should handle URI without spaces', () => {
+      const san = 'URI:https://user.example/me,DNS:example.com';
+      const webId = extractWebIdFromSAN(san);
+      assert.strictEqual(webId, 'https://user.example/me');
+    });
+  });
+
+  describe('verifyWebIdTls', () => {
+    // Clear cache before each test
+    it('should reject certificate without modulus', async () => {
+      clearCache();
+      const cert = { exponent: '10001' }; // Missing modulus
+      try {
+        await verifyWebIdTls(cert, 'https://example.com/card#me');
+        assert.fail('Should have thrown an error');
+      } catch (err) {
+        assert.ok(err.message.includes('modulus'));
+      }
+    });
+
+    it('should reject certificate without exponent', async () => {
+      clearCache();
+      const cert = { modulus: 'abc123' }; // Missing exponent
+      try {
+        await verifyWebIdTls(cert, 'https://example.com/card#me');
+        assert.fail('Should have thrown an error');
+      } catch (err) {
+        assert.ok(err.message.includes('exponent'));
+      }
+    });
+  });
+
+  describe('Certificate key extraction', () => {
+    it('should extract keys from JSON-LD profile with cert:key', async () => {
+      // This tests the internal extractCertKeys function indirectly
+      // by checking that profiles are fetched and parsed correctly
+      clearCache();
+
+      // A minimal test - full integration would need a mock server
+      // For now we just ensure the functions are callable
+      const cert = {
+        modulus: 'abc123def456',
+        exponent: '10001' // 65537 in hex
+      };
+
+      try {
+        // This will fail because the profile URL doesn't exist
+        // but it tests that the function runs without syntax errors
+        const result = await verifyWebIdTls(cert, 'https://nonexistent.example/card#me');
+        assert.strictEqual(result, false);
+      } catch (err) {
+        // Expected to fail on network error
+        assert.ok(true);
+      }
+    });
+  });
+
+  describe('SAN format variations', () => {
+    it('should handle lowercase uri prefix', () => {
+      // Some certs might have lowercase
+      const san = 'uri:https://alice.example/card#me';
+      // Our regex is case-sensitive, which matches the standard
+      const webId = extractWebIdFromSAN(san);
+      assert.strictEqual(webId, null); // Should not match lowercase
+    });
+
+    it('should extract first URI when multiple are present', () => {
+      const san = 'URI:https://primary.example/me, URI:https://secondary.example/me';
+      const webId = extractWebIdFromSAN(san);
+      assert.strictEqual(webId, 'https://primary.example/me');
+    });
+
+    it('should handle spaces in SAN format', () => {
+      const san = 'URI: https://alice.example/card#me';
+      const webId = extractWebIdFromSAN(san);
+      // With space after colon, it captures from the space
+      assert.ok(webId === null || webId === ' https://alice.example/card#me');
+    });
+  });
+});