solid-server 5.8.6 → 5.8.8-8d509db1

package/test/integration/payment-pointer-test.mjs

@@ -0,0 +1,155 @@
+import { fileURLToPath } from 'url'
+import path from 'path'
+import supertest from 'supertest'
+import chai from 'chai'
+
+// Import utility functions from the ESM utils
+import { cleanDir } from '../utils.mjs'
+import * as Solid from '../../index.mjs'
+
+const { expect } = chai
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+describe('API', () => {
+  const configPath = path.join(__dirname, '../resources/config')
+
+  const serverConfig = {
+    sslKey: path.join(__dirname, '../keys/key.pem'),
+    sslCert: path.join(__dirname, '../keys/cert.pem'),
+    auth: 'oidc',
+    dataBrowser: false,
+    webid: true,
+    multiuser: false,
+    configPath
+  }
+
+  function startServer (pod, port) {
+    return new Promise((resolve) => {
+      pod.listen(port, () => { resolve() })
+    })
+  }
+
+  describe('Payment Pointer Alice', () => {
+    let alice
+    const aliceServerUri = 'https://localhost:5000'
+    const aliceDbPath = path.join(__dirname,
+      '../resources/accounts-scenario/alice/db')
+    const aliceRootPath = path.join(__dirname, '../resources/accounts-scenario/alice')
+
+    const alicePod = Solid.createServer(
+      Object.assign({
+        root: aliceRootPath,
+        serverUri: aliceServerUri,
+        dbPath: aliceDbPath
+      }, serverConfig)
+    )
+
+    before(() => {
+      return Promise.all([
+        startServer(alicePod, 5000)
+      ]).then(() => {
+        alice = supertest(aliceServerUri)
+      })
+    })
+
+    after(() => {
+      alicePod.close()
+      cleanDir(aliceRootPath)
+    })
+
+    describe('GET Payment Pointer document', () => {
+      it('should show instructions to add a triple', (done) => {
+        alice.get('/.well-known/pay')
+          .expect(200)
+          .expect('content-type', /application\/json/)
+          .end(function (err, req) {
+            if (err) {
+              done(err)
+            } else {
+              expect(req.body).deep.equal({
+                fail: 'Add triple',
+                subject: '<https://localhost:5000/profile/card#me>',
+                predicate: '<http://paymentpointers.org/ns#PaymentPointer>',
+                object: '$alice.example'
+              })
+              done()
+            }
+          })
+      })
+    })
+  })
+
+  describe('Payment Pointer Bob', () => {
+    let bob
+    const bobServerUri = 'https://localhost:5001'
+    const bobDbPath = path.join(__dirname,
+      '../resources/accounts-scenario/bob/db')
+    const bobRootPath = path.join(__dirname, '../resources/accounts-scenario/bob')
+    const bobPod = Solid.createServer(
+      Object.assign({
+        root: bobRootPath,
+        serverUri: bobServerUri,
+        dbPath: bobDbPath
+      }, serverConfig)
+    )
+
+    before(() => {
+      return Promise.all([
+        startServer(bobPod, 5001)
+      ]).then(() => {
+        bob = supertest(bobServerUri)
+      })
+    })
+
+    after(() => {
+      bobPod.close()
+      cleanDir(bobRootPath)
+    })
+
+    describe('GET Payment Pointer document', () => {
+      it.skip('should redirect to example.com', (done) => {
+        bob.get('/.well-known/pay')
+          .expect('location', 'https://bob.com/.well-known/pay')
+          .expect(302, done)
+      })
+    })
+  })
+
+  describe('Payment Pointer Charlie', () => {
+    let charlie
+    const charlieServerUri = 'https://localhost:5002'
+    const charlieDbPath = path.join(__dirname,
+      '../resources/accounts-scenario/charlie/db')
+    const charlieRootPath = path.join(__dirname, '../resources/accounts-scenario/charlie')
+    const charliePod = Solid.createServer(
+      Object.assign({
+        root: charlieRootPath,
+        serverUri: charlieServerUri,
+        dbPath: charlieDbPath
+      }, serverConfig)
+    )
+
+    before(() => {
+      return Promise.all([
+        startServer(charliePod, 5002)
+      ]).then(() => {
+        charlie = supertest(charlieServerUri)
+      })
+    })
+
+    after(() => {
+      charliePod.close()
+      cleanDir(charlieRootPath)
+    })
+
+    describe('GET Payment Pointer document', () => {
+      it('should redirect to example.com/charlie', (done) => {
+        charlie.get('/.well-known/pay')
+          .expect('location', 'https://service.com/charlie')
+          .expect(302, done)
+      })
+    })
+  })
+})

package/test/integration/prep-test.mjs

@@ -0,0 +1,314 @@
+import { fileURLToPath } from 'url'
+import fs from 'fs'
+import path from 'path'
+import { validate as uuidValidate } from 'uuid'
+import { expect } from 'chai'
+import { parseDictionary } from 'structured-headers'
+import prepFetch from 'prep-fetch'
+import { createServer } from '../utils.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const dateTimeRegex = /^-?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?(?:Z|(?:\+|-)\d{2}:\d{2})$/
+
+const samplePath = path.join(__dirname, '../resources', 'sampleContainer')
+const sampleFile = fs.readFileSync(path.join(samplePath, 'example1.ttl'))
+
+describe('Per Resource Events Protocol', function () {
+  let server
+
+  before((done) => {
+    server = createServer({
+      live: true,
+      dataBrowserPath: 'default',
+      root: path.join(__dirname, '../resources'),
+      auth: 'oidc',
+      webid: false,
+      prep: true
+    })
+    server.listen(8445, done)
+  })
+
+  after(() => {
+    if (fs.existsSync(path.join(samplePath, 'example-post'))) {
+      fs.rmSync(path.join(samplePath, 'example-post'), { recursive: true, force: true })
+    }
+    server.close()
+  })
+
+  it('should set `Accept-Events` header on a GET response with "prep"',
+    async function () {
+      const response = await fetch('http://localhost:8445/sampleContainer/example1.ttl')
+      expect(response.headers.get('Accept-Events')).to.match(/^"prep"/)
+      expect(response.status).to.equal(200)
+    }
+  )
+
+  it('should send an ordinary response, if `Accept-Events` header is not specified',
+    async function () {
+      const response = await fetch('http://localhost:8445/sampleContainer/example1.ttl')
+      expect(response.headers.get('Content-Type')).to.match(/text\/turtle/)
+      expect(response.headers.has('Events')).to.equal(false)
+      expect(response.status).to.equal(200)
+    })
+
+  describe('with prep response on container', async function () {
+    let response
+    let prepResponse
+    const controller = new AbortController()
+    const { signal } = controller
+
+    it('should set headers correctly', async function () {
+      response = await fetch('http://localhost:8445/sampleContainer/', {
+        headers: {
+          'Accept-Events': '"prep";accept=application/ld+json',
+          Accept: 'text/turtle'
+        },
+        signal
+      })
+      expect(response.status).to.equal(200)
+      expect(response.headers.get('Vary')).to.match(/Accept-Events/)
+      const eventsHeader = parseDictionary(response.headers.get('Events'))
+      expect(eventsHeader.get('protocol')?.[0]).to.equal('prep')
+      expect(eventsHeader.get('status')?.[0]).to.equal(200)
+      expect(eventsHeader.get('expires')?.[0]).to.be.a('string')
+      expect(response.headers.get('Content-Type')).to.match(/^multipart\/mixed/)
+    })
+
+    it('should send a representation as the first part, matching the content size on disk',
+      async function () {
+        prepResponse = prepFetch(response)
+        const representation = await prepResponse.getRepresentation()
+        expect(representation.headers.get('Content-Type')).to.match(/text\/turtle/)
+        await representation.text()
+      })
+
+    describe('should send notifications in the second part', async function () {
+      let notifications
+      let notificationsIterator
+
+      it('when a contained resource is created', async function () {
+        notifications = await prepResponse.getNotifications()
+        notificationsIterator = notifications.notifications()
+        await fetch('http://localhost:8445/sampleContainer/example-prep.ttl', {
+          method: 'PUT',
+          headers: {
+            'Content-Type': 'text/turtle'
+          },
+          body: sampleFile
+        })
+        const { value } = await notificationsIterator.next()
+        expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+        const notification = await value.json()
+        expect(notification.published).to.match(dateTimeRegex)
+        expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+        expect(notification.type).to.equal('Add')
+        expect(notification.target).to.match(/sampleContainer\/$/)
+        expect(notification.object).to.match(/sampleContainer\/example-prep\.ttl$/)
+        expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+        expect(notification.state).to.match(/\w{6}/)
+      })
+
+      it('when contained resource is modified', async function () {
+        await fetch('http://localhost:8445/sampleContainer/example-prep.ttl', {
+          method: 'PATCH',
+          headers: {
+            'Content-Type': 'text/n3'
+          },
+          body: `@prefix solid: <http://www.w3.org/ns/solid/terms#>.
+<> a solid:InsertDeletePatch;
+solid:inserts { <u> <v> <z>. }.`
+        })
+        const { value } = await notificationsIterator.next()
+        expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+        const notification = await value.json()
+        expect(notification.published).to.match(dateTimeRegex)
+        expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+        expect(notification.type).to.equal('Update')
+        expect(notification.object).to.match(/sampleContainer\/$/)
+        expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+        expect(notification.state).to.match(/\w{6}/)
+      })
+
+      it('when contained resource is deleted',
+        async function () {
+          await fetch('http://localhost:8445/sampleContainer/example-prep.ttl', {
+            method: 'DELETE'
+          })
+          const { value } = await notificationsIterator.next()
+          expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+          const notification = await value.json()
+          expect(notification.published).to.match(dateTimeRegex)
+          expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+          expect(notification.type).to.equal('Remove')
+          expect(notification.origin).to.match(/sampleContainer\/$/)
+          expect(notification.object).to.match(/sampleContainer\/.*example-prep.ttl$/)
+          expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+          expect(notification.state).to.match(/\w{6}/)
+        })
+
+      it('when a contained container is created', async function () {
+        await fetch('http://localhost:8445/sampleContainer/example-prep/', {
+          method: 'PUT',
+          headers: {
+            'Content-Type': 'text/turtle'
+          }
+        })
+        const { value } = await notificationsIterator.next()
+        expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+        const notification = await value.json()
+        expect(notification.published).to.match(dateTimeRegex)
+        expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+        expect(notification.type).to.equal('Add')
+        expect(notification.target).to.match(/sampleContainer\/$/)
+        expect(notification.object).to.match(/sampleContainer\/example-prep\/$/)
+        expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+        expect(notification.state).to.match(/\w{6}/)
+      })
+
+      it('when a contained container is deleted', async function () {
+        await fetch('http://localhost:8445/sampleContainer/example-prep/', {
+          method: 'DELETE'
+        })
+        const { value } = await notificationsIterator.next()
+        expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+        const notification = await value.json()
+        expect(notification.published).to.match(dateTimeRegex)
+        expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+        expect(notification.type).to.equal('Remove')
+        expect(notification.origin).to.match(/sampleContainer\/$/)
+        expect(notification.object).to.match(/sampleContainer\/example-prep\/$/)
+        expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+        expect(notification.state).to.match(/\w{6}/)
+      })
+
+      it('when a container is created by POST',
+        async function () {
+          await fetch('http://localhost:8445/sampleContainer/', {
+            method: 'POST',
+            headers: {
+              slug: 'example-post',
+              link: '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"',
+              'content-type': 'text/turtle'
+            }
+          })
+          const { value } = await notificationsIterator.next()
+          expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+          const notification = await value.json()
+          expect(notification.published).to.match(dateTimeRegex)
+          expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+          expect(notification.type).to.equal('Add')
+          expect(notification.target).to.match(/sampleContainer\/$/)
+          expect(notification.object).to.match(/sampleContainer\/.*example-post\/$/)
+          expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+          expect(notification.state).to.match(/\w{6}/)
+        })
+
+      it('when resource is created by POST',
+        async function () {
+          await fetch('http://localhost:8445/sampleContainer/', {
+            method: 'POST',
+            headers: {
+              slug: 'example-prep.ttl',
+              'content-type': 'text/turtle'
+            },
+            body: sampleFile
+          })
+          const { value } = await notificationsIterator.next()
+          expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+          const notification = await value.json()
+          expect(notification.published).to.match(dateTimeRegex)
+          expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+          expect(notification.type).to.equal('Add')
+          expect(notification.target).to.match(/sampleContainer\/$/)
+          expect(notification.object).to.match(/sampleContainer\/.*example-prep.ttl$/)
+          expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+          expect(notification.state).to.match(/\w{6}/)
+          controller.abort()
+        })
+    })
+  })
+
+  describe('with prep response on RDF resource', async function () {
+    let response
+    let prepResponse
+
+    it('should set headers correctly', async function () {
+      response = await fetch('http://localhost:8445/sampleContainer/example-prep.ttl', {
+        headers: {
+          'Accept-Events': '"prep";accept=application/ld+json',
+          Accept: 'text/n3'
+        }
+      })
+      expect(response.status).to.equal(200)
+      expect(response.headers.get('Vary')).to.match(/Accept-Events/)
+      const eventsHeader = parseDictionary(response.headers.get('Events'))
+      expect(eventsHeader.get('protocol')?.[0]).to.equal('prep')
+      expect(eventsHeader.get('status')?.[0]).to.equal(200)
+      expect(eventsHeader.get('expires')?.[0]).to.be.a('string')
+      expect(response.headers.get('Content-Type')).to.match(/^multipart\/mixed/)
+    })
+
+    it('should send a representation as the first part, matching the content size on disk',
+      async function () {
+        prepResponse = prepFetch(response)
+        const representation = await prepResponse.getRepresentation()
+        expect(representation.headers.get('Content-Type')).to.match(/text\/n3/)
+        const blob = await representation.blob()
+        expect(function (done) {
+          const size = fs.statSync(path.join(__dirname,
+            '../resources/sampleContainer/example-prep.ttl')).size
+          if (blob.size !== size) {
+            return done(new Error('files are not of the same size'))
+          }
+        })
+      })
+
+    describe('should send notifications in the second part', async function () {
+      let notifications
+      let notificationsIterator
+
+      it('when modified with PATCH', async function () {
+        notifications = await prepResponse.getNotifications()
+        notificationsIterator = notifications.notifications()
+        await fetch('http://localhost:8445/sampleContainer/example-prep.ttl', {
+          method: 'PATCH',
+          headers: {
+            'content-type': 'text/n3'
+          },
+          body: `@prefix solid: <http://www.w3.org/ns/solid/terms#>.
+<> a solid:InsertDeletePatch;
+solid:inserts { <u> <v> <z>. }.`
+        })
+        const { value } = await notificationsIterator.next()
+        expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+        const notification = await value.json()
+        expect(notification.published).to.match(dateTimeRegex)
+        expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+        expect(notification.type).to.equal('Update')
+        expect(notification.object).to.match(/sampleContainer\/example-prep\.ttl$/)
+        expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+        expect(notification.state).to.match(/\w{6}/)
+      })
+
+      it('when removed with DELETE, it should also close the connection',
+        async function () {
+          await fetch('http://localhost:8445/sampleContainer/example-prep.ttl', {
+            method: 'DELETE'
+          })
+          const { value } = await notificationsIterator.next()
+          expect(value.headers.get('content-type')).to.match(/application\/ld\+json/)
+          const notification = await value.json()
+          expect(notification.published).to.match(dateTimeRegex)
+          expect(isNaN((new Date(notification.published)).valueOf())).to.equal(false)
+          expect(notification.type).to.equal('Delete')
+          expect(notification.object).to.match(/sampleContainer\/example-prep\.ttl$/)
+          expect(uuidValidate(notification.id.substring(9))).to.equal(true)
+          expect(notification.state).to.match(/\w{6}/)
+          const { done } = await notificationsIterator.next()
+          expect(done).to.equal(true)
+        })
+    })
+  })
+})

package/test/integration/quota-test.mjs

@@ -0,0 +1,51 @@
+/* eslint-disable no-unused-expressions */
+import path from 'path'
+import chai from 'chai'
+
+// Import utility functions from the ESM utils
+import { read } from '../utils.mjs'
+import { getQuota, overQuota } from '../../lib/utils.mjs'
+
+const { expect } = chai
+
+const root = 'accounts-acl/config/templates/new-account/'
+
+describe('Get Quota', function () {
+  const prefs = read(path.join(root, 'settings/serverSide.ttl'))
+  it('from file to check that it is readable and has predicate', function () {
+    expect(prefs).to.be.a('string')
+    expect(prefs).to.match(/storageQuota/)
+  })
+  it('and check it', async function () {
+    const quota = await getQuota(path.join('test/resources/', root), 'https://localhost')
+    console.log('Quota is', quota)
+    expect(quota).to.equal(2000)
+  })
+  it('with wrong size', async function () {
+    const quota = await getQuota(path.join('test/resources/', root), 'https://localhost')
+    expect(quota).to.not.equal(3000)
+  })
+  it('with non-existant file', async function () {
+    const quota = await getQuota(path.join('nowhere/', root), 'https://localhost')
+    expect(quota).to.equal(Infinity)
+  })
+  it('when the predicate is not present', async function () {
+    const quota = await getQuota('test/resources/accounts-acl/quota', 'https://localhost')
+    expect(quota).to.equal(Infinity)
+  })
+})
+
+describe('Check if over Quota', function () {
+  it('when it is above', async function () {
+    const quota = await overQuota(path.join('test/resources/', root), 'https://localhost')
+    expect(quota).to.be.true
+  })
+  it('with non-existant file', async function () {
+    const quota = await overQuota(path.join('nowhere/', root), 'https://localhost')
+    expect(quota).to.be.false
+  })
+  it('when the predicate is not present', async function () {
+    const quota = await overQuota('test/resources/accounts-acl/quota', 'https://localhost')
+    expect(quota).to.be.false
+  })
+})

package/test/integration/special-root-acl-handling-test.mjs

@@ -0,0 +1,68 @@
+import { fileURLToPath } from 'url'
+import path from 'path'
+import { assert } from 'chai'
+import { httpRequest as request, checkDnsSettings, cleanDir } from '../utils.mjs'
+import ldnode from '../../index.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const port = 7777
+const serverUri = `https://localhost:${port}`
+const root = path.join(__dirname, '../resources/accounts-acl')
+const dbPath = path.join(root, 'db')
+const configPath = path.join(root, 'config')
+
+function createOptions (path = '') {
+  return {
+    url: `https://nicola.localhost:${port}${path}`
+  }
+}
+
+describe('Special handling: Root ACL does not give READ access to root', () => {
+  let ldp, ldpHttpsServer
+
+  before(checkDnsSettings)
+
+  before(done => {
+    ldp = ldnode.createServer({
+      root,
+      serverUri,
+      dbPath,
+      port,
+      configPath,
+      sslKey: path.join(__dirname, '../keys/key.pem'),
+      sslCert: path.join(__dirname, '../keys/cert.pem'),
+      webid: true,
+      multiuser: true,
+      auth: 'oidc',
+      strictOrigin: true,
+      host: { serverUri }
+    })
+    ldpHttpsServer = ldp.listen(port, done)
+  })
+
+  after(() => {
+    if (ldpHttpsServer) ldpHttpsServer.close()
+    cleanDir(root)
+  })
+
+  describe('should still grant READ access to everyone because of index.html.acl', () => {
+    it('for root with /', function (done) {
+      const options = createOptions('/')
+      request.get(options, function (error, response, body) {
+        assert.equal(error, null)
+        assert.equal(response.statusCode, 200)
+        done()
+      })
+    })
+    it('for root without /', function (done) {
+      const options = createOptions()
+      request.get(options, function (error, response, body) {
+        assert.equal(error, null)
+        assert.equal(response.statusCode, 200)
+        done()
+      })
+    })
+  })
+})

package/test/integration/validate-tts-test.mjs

@@ -0,0 +1,57 @@
+import { fileURLToPath } from 'url'
+import path from 'path'
+import fs from 'fs'
+
+// Import utility functions from the ESM utils
+import { setupSupertestServer } from '../utils.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const server = setupSupertestServer({
+  live: true,
+  dataBrowserPath: 'default',
+  root: path.join(__dirname, '../resources'),
+  auth: 'oidc',
+  webid: false
+})
+
+const invalidTurtleBody = fs.readFileSync(path.join(__dirname, '../resources/invalid1.ttl'), {
+  encoding: 'utf8'
+})
+
+describe('HTTP requests with invalid Turtle syntax', () => {
+  describe('PUT API', () => {
+    it('is allowed with invalid TTL files in general', (done) => {
+      server.put('/invalid1.ttl')
+        .send(invalidTurtleBody)
+        .set('content-type', 'text/turtle')
+        .expect(204, done)
+    })
+
+    it('is not allowed with invalid ACL files', (done) => {
+      server.put('/invalid1.ttl.acl')
+        .send(invalidTurtleBody)
+        .set('content-type', 'text/turtle')
+        .expect(400, done)
+    })
+  })
+
+  describe('PATCH API', () => {
+    it('does not support patching of TTL files', (done) => {
+      server.patch('/patch-1-initial.ttl')
+        .send(invalidTurtleBody)
+        .set('content-type', 'text/turtle')
+        .expect(415, done)
+    })
+  })
+
+  describe('POST API (multipart)', () => {
+    it('does not validate files that are posted', (done) => {
+      server.post('/')
+        .attach('invalid1', path.join(__dirname, '../resources/invalid1.ttl'))
+        .attach('invalid2', path.join(__dirname, '../resources/invalid2.ttl'))
+        .expect(200, done)
+    })
+  })
+})