solid-server 5.8.7 → 5.8.8-8d509db1

package/test/unit/delete-account-request-test.mjs

@@ -0,0 +1,180 @@
+import chai from 'chai'
+import sinon from 'sinon'
+import dirtyChai from 'dirty-chai'
+import sinonChai from 'sinon-chai'
+
+import HttpMocks from 'node-mocks-http'
+
+import DeleteAccountRequest from '../../lib/requests/delete-account-request.mjs'
+import AccountManager from '../../lib/models/account-manager.mjs'
+import SolidHost from '../../lib/models/solid-host.mjs'
+
+const { expect } = chai
+chai.use(dirtyChai)
+chai.use(sinonChai)
+chai.should()
+
+describe('DeleteAccountRequest', () => {
+  describe('constructor()', () => {
+    it('should initialize a request instance from options', () => {
+      const res = HttpMocks.createResponse()
+
+      const options = {
+        response: res,
+        username: 'alice'
+      }
+
+      const request = new DeleteAccountRequest(options)
+
+      expect(request.response).to.equal(res)
+      expect(request.username).to.equal(options.username)
+    })
+  })
+
+  describe('fromParams()', () => {
+    it('should return a request instance from options', () => {
+      const username = 'alice'
+      const accountManager = {}
+
+      const req = {
+        app: { locals: { accountManager } },
+        body: { username }
+      }
+      const res = HttpMocks.createResponse()
+
+      const request = DeleteAccountRequest.fromParams(req, res)
+
+      expect(request.accountManager).to.equal(accountManager)
+      expect(request.username).to.equal(username)
+      expect(request.response).to.equal(res)
+    })
+  })
+
+  describe('get()', () => {
+    it('should create an instance and render a delete account form', () => {
+      const username = 'alice'
+      const accountManager = { multiuser: true }
+
+      const req = {
+        app: { locals: { accountManager } },
+        body: { username }
+      }
+      const res = HttpMocks.createResponse()
+      res.render = sinon.stub()
+
+      DeleteAccountRequest.get(req, res)
+
+      expect(res.render).to.have.been.calledWith('account/delete',
+        { error: undefined, multiuser: true })
+    })
+  })
+
+  describe('post()', () => {
+    it('creates a request instance and invokes handlePost()', () => {
+      sinon.spy(DeleteAccountRequest, 'handlePost')
+
+      const username = 'alice'
+      const host = SolidHost.from({ serverUri: 'https://example.com' })
+      const store = {
+        suffixAcl: '.acl'
+      }
+      const accountManager = AccountManager.from({ host, multiuser: true, store })
+      accountManager.accountExists = sinon.stub().resolves(true)
+      accountManager.loadAccountRecoveryEmail = sinon.stub().resolves('alice@example.com')
+      accountManager.sendDeleteLink = sinon.stub().resolves()
+
+      const req = {
+        app: { locals: { accountManager } },
+        body: { username }
+      }
+      const res = HttpMocks.createResponse()
+
+      DeleteAccountRequest.post(req, res)
+        .then(() => {
+          expect(DeleteAccountRequest.handlePost).to.have.been.called()
+        })
+    })
+  })
+
+  describe('validate()', () => {
+    it('should throw an error if username is missing in multi-user mode', () => {
+      const host = SolidHost.from({ serverUri: 'https://example.com' })
+      const accountManager = AccountManager.from({ host, multiuser: true })
+
+      const request = new DeleteAccountRequest({ accountManager })
+
+      expect(() => request.validate()).to.throw(/Username required/)
+    })
+
+    it('should not throw an error if username is missing in single user mode', () => {
+      const host = SolidHost.from({ serverUri: 'https://example.com' })
+      const accountManager = AccountManager.from({ host, multiuser: false })
+
+      const request = new DeleteAccountRequest({ accountManager })
+
+      expect(() => request.validate()).to.not.throw()
+    })
+  })
+
+  describe('handlePost()', () => {
+    it('should handle the post request', () => {
+      const host = SolidHost.from({ serverUri: 'https://example.com' })
+      const store = { suffixAcl: '.acl' }
+      const accountManager = AccountManager.from({ host, multiuser: true, store })
+      accountManager.loadAccountRecoveryEmail = sinon.stub().resolves('alice@example.com')
+      accountManager.sendDeleteAccountEmail = sinon.stub().resolves()
+      accountManager.accountExists = sinon.stub().resolves(true)
+
+      const username = 'alice'
+      const response = HttpMocks.createResponse()
+      response.render = sinon.stub()
+
+      const options = { accountManager, username, response }
+      const request = new DeleteAccountRequest(options)
+
+      sinon.spy(request, 'error')
+
+      return DeleteAccountRequest.handlePost(request)
+        .then(() => {
+          expect(accountManager.loadAccountRecoveryEmail).to.have.been.called()
+          expect(response.render).to.have.been.calledWith('account/delete-link-sent')
+          expect(request.error).to.not.have.been.called()
+        })
+    })
+  })
+
+  describe('loadUser()', () => {
+    it('should return a UserAccount instance based on username', () => {
+      const host = SolidHost.from({ serverUri: 'https://example.com' })
+      const store = { suffixAcl: '.acl' }
+      const accountManager = AccountManager.from({ host, multiuser: true, store })
+      accountManager.accountExists = sinon.stub().resolves(true)
+      const username = 'alice'
+
+      const options = { accountManager, username }
+      const request = new DeleteAccountRequest(options)
+
+      return request.loadUser()
+        .then(account => {
+          expect(account.webId).to.equal('https://alice.example.com/profile/card#me')
+        })
+    })
+
+    it('should throw an error if the user does not exist', done => {
+      const host = SolidHost.from({ serverUri: 'https://example.com' })
+      const store = { suffixAcl: '.acl' }
+      const accountManager = AccountManager.from({ host, multiuser: true, store })
+      accountManager.accountExists = sinon.stub().resolves(false)
+      const username = 'alice'
+
+      const options = { accountManager, username }
+      const request = new DeleteAccountRequest(options)
+
+      request.loadUser()
+        .catch(error => {
+          expect(error.message).to.equal('Account not found for that username')
+          done()
+        })
+    })
+  })
+})

package/test/unit/email-service-test.mjs

@@ -0,0 +1,166 @@
+/* eslint-disable no-unused-expressions */
+import sinon from 'sinon'
+import chai from 'chai'
+import sinonChai from 'sinon-chai'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+import EmailService from '../../lib/services/email-service.mjs'
+
+const { expect } = chai
+chai.use(sinonChai)
+chai.should()
+
+// const require = createRequire(import.meta.url)
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+const templatePath = join(__dirname, '../../default-templates/emails')
+
+describe('Email Service', function () {
+  describe('EmailService constructor', () => {
+    it('should set up a nodemailer instance', () => {
+      const templatePath = '../../config/email-templates'
+      const config = {
+        host: 'smtp.gmail.com',
+        auth: {
+          user: 'alice@gmail.com',
+          pass: '12345'
+        }
+      }
+
+      const emailService = new EmailService(templatePath, config)
+      expect(emailService.mailer.options.host).to.equal('smtp.gmail.com')
+      expect(emailService.mailer).to.respondTo('sendMail')
+
+      expect(emailService.templatePath).to.equal(templatePath)
+    })
+
+    it('should init a sender address if explicitly passed in', () => {
+      const sender = 'Solid Server <solid@databox.me>'
+      const config = { host: 'smtp.gmail.com', auth: {}, sender }
+
+      const emailService = new EmailService(templatePath, config)
+      expect(emailService.sender).to.equal(sender)
+    })
+
+    it('should construct a default sender if not passed in', () => {
+      const config = { host: 'databox.me', auth: {} }
+
+      const emailService = new EmailService(templatePath, config)
+
+      expect(emailService.sender).to.equal('no-reply@databox.me')
+    })
+  })
+
+  describe('sendMail()', () => {
+    it('passes through the sendMail call to the initialized mailer', () => {
+      const sendMail = sinon.stub().returns(Promise.resolve())
+      const config = { host: 'databox.me', auth: {} }
+      const emailService = new EmailService(templatePath, config)
+
+      emailService.mailer.sendMail = sendMail
+
+      const email = { subject: 'Test' }
+
+      return emailService.sendMail(email)
+        .then(() => {
+          expect(sendMail).to.have.been.calledWith(email)
+        })
+    })
+
+    it('uses the provided from:, if present', () => {
+      const config = { host: 'databox.me', auth: {} }
+      const emailService = new EmailService(templatePath, config)
+      const email = { subject: 'Test', from: 'alice@example.com' }
+
+      emailService.mailer.sendMail = (email) => { return Promise.resolve(email) }
+
+      return emailService.sendMail(email)
+        .then(email => {
+          expect(email.from).to.equal('alice@example.com')
+        })
+    })
+
+    it('uses the default sender if a from: is not provided', () => {
+      const config = { host: 'databox.me', auth: {}, sender: 'solid@example.com' }
+      const emailService = new EmailService(templatePath, config)
+      const email = { subject: 'Test', from: null }
+
+      emailService.mailer.sendMail = (email) => { return Promise.resolve(email) }
+
+      return emailService.sendMail(email)
+        .then(email => {
+          expect(email.from).to.equal(config.sender)
+        })
+    })
+  })
+
+  describe('templatePathFor()', () => {
+    it('should compose filename based on base path and template name', () => {
+      const config = { host: 'databox.me', auth: {} }
+      const templatePath = '../../config/email-templates'
+      const emailService = new EmailService(templatePath, config)
+
+      const templateFile = emailService.templatePathFor('welcome')
+
+      expect(templateFile.endsWith('email-templates/welcome'))
+    })
+  })
+
+  describe('readTemplate()', () => {
+    it('should read a template if it exists', async () => {
+      const config = { host: 'databox.me', auth: {} }
+      const emailService = new EmailService(templatePath, config)
+
+      const template = await emailService.readTemplate('welcome.js') // support legacy name
+
+      expect(template).to.respondTo('render')
+    })
+
+    it('should throw an error if a template does not exist', async () => {
+      const config = { host: 'databox.me', auth: {} }
+      const emailService = new EmailService(templatePath, config)
+
+      try {
+        await emailService.readTemplate('invalid-template')
+        throw new Error('Expected readTemplate to throw')
+      } catch (err) {
+        expect(err.message).to.match(/Cannot find email template/)
+      }
+    })
+  })
+
+  describe('sendWithTemplate()', () => {
+    it('should reject with error if template does not exist', done => {
+      const config = { host: 'databox.me', auth: {} }
+      const emailService = new EmailService(templatePath, config)
+
+      const data = {}
+
+      emailService.sendWithTemplate('invalid-template', data)
+        .catch(error => {
+          expect(error.message.startsWith('Cannot find email template'))
+            .to.be.true
+          done()
+        })
+    })
+
+    it('should render an email from template and send it', () => {
+      const config = { host: 'databox.me', auth: {} }
+      const emailService = new EmailService(templatePath, config)
+
+      emailService.sendMail = (email) => { return Promise.resolve(email) }
+      emailService.sendMail = sinon.spy(emailService, 'sendMail')
+
+      const data = { webid: 'https://alice.example.com#me' }
+
+      return emailService.sendWithTemplate('welcome.js', data)
+        .then(renderedEmail => {
+          expect(emailService.sendMail).to.be.called
+
+          expect(renderedEmail.subject).to.exist
+          expect(renderedEmail.text.endsWith('Your Web Id: https://alice.example.com#me'))
+            .to.be.true
+        })
+    })
+  })
+})

package/test/unit/email-welcome-test.mjs

@@ -0,0 +1,81 @@
+/* eslint-disable no-unused-expressions */
+import { fileURLToPath } from 'url'
+import path from 'path'
+import chai from 'chai'
+import sinon from 'sinon'
+import sinonChai from 'sinon-chai'
+
+import SolidHost from '../../lib/models/solid-host.mjs'
+import AccountManager from '../../lib/models/account-manager.mjs'
+import EmailService from '../../lib/services/email-service.mjs'
+
+const { expect } = chai
+chai.use(sinonChai)
+chai.should()
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const templatePath = path.join(__dirname, '../../default-templates/emails')
+
+let host, accountManager, emailService
+
+beforeEach(() => {
+  host = SolidHost.from({ serverUri: 'https://example.com' })
+
+  const emailConfig = { auth: {}, sender: 'solid@example.com' }
+  emailService = new EmailService(templatePath, emailConfig)
+
+  const mgrConfig = {
+    host,
+    emailService,
+    authMethod: 'oidc',
+    multiuser: true
+  }
+  accountManager = AccountManager.from(mgrConfig)
+})
+
+describe('Account Creation Welcome Email', () => {
+  describe('accountManager.sendWelcomeEmail() (unit tests)', () => {
+    it('should resolve to null if email service not set up', () => {
+      accountManager.emailService = null
+
+      const userData = { name: 'Alice', username: 'alice', email: 'alice@alice.com' }
+      const newUser = accountManager.userAccountFrom(userData)
+
+      return accountManager.sendWelcomeEmail(newUser)
+        .then(result => {
+          expect(result).to.be.null
+        })
+    })
+
+    it('should resolve to null if a new user has no email', () => {
+      const userData = { name: 'Alice', username: 'alice' }
+      const newUser = accountManager.userAccountFrom(userData)
+
+      return accountManager.sendWelcomeEmail(newUser)
+        .then(result => {
+          expect(result).to.be.null
+        })
+    })
+
+    it('should send an email using the welcome template', () => {
+      const sendWithTemplate = sinon
+        .stub(accountManager.emailService, 'sendWithTemplate')
+        .returns(Promise.resolve())
+
+      const userData = { name: 'Alice', username: 'alice', email: 'alice@alice.com' }
+      const newUser = accountManager.userAccountFrom(userData)
+
+      const expectedEmailData = {
+        webid: 'https://alice.example.com/profile/card#me',
+        to: 'alice@alice.com',
+        name: 'Alice'
+      }
+
+      return accountManager.sendWelcomeEmail(newUser)
+        .then(result => {
+          expect(sendWithTemplate).to.be.calledWith('welcome', expectedEmailData)
+        })
+    })
+  })
+})

package/test/unit/error-pages-test.mjs

@@ -0,0 +1,100 @@
+import { describe, it } from 'mocha'
+import chai from 'chai'
+import sinon from 'sinon'
+import sinonChai from 'sinon-chai'
+import dirtyChai from 'dirty-chai'
+import * as errorPages from '../../lib/handlers/error-pages.mjs'
+
+const { expect } = chai
+chai.use(sinonChai)
+chai.use(dirtyChai)
+chai.should()
+
+describe('handlers/error-pages', () => {
+  describe('handler()', () => {
+    it('should use the custom error handler if available', () => {
+      const ldp = { errorHandler: sinon.stub() }
+      const req = { app: { locals: { ldp } } }
+      const res = { status: sinon.stub(), send: sinon.stub() }
+      const err = {}
+      const next = {}
+
+      errorPages.handler(err, req, res, next)
+
+      expect(ldp.errorHandler).to.have.been.calledWith(err, req, res, next)
+
+      expect(res.status).to.not.have.been.called()
+      expect(res.send).to.not.have.been.called()
+    })
+
+    it('defaults to status code 500 if none is specified in the error', () => {
+      const ldp = { noErrorPages: true }
+      const req = { app: { locals: { ldp } } }
+      const res = { status: sinon.stub(), send: sinon.stub(), header: sinon.stub() }
+      const err = { message: 'Unspecified error' }
+      const next = {}
+
+      errorPages.handler(err, req, res, next)
+
+      expect(res.status).to.have.been.calledWith(500)
+      expect(res.header).to.have.been.calledWith('Content-Type', 'text/plain;charset=utf-8')
+      expect(res.send).to.have.been.calledWith('Unspecified error\n')
+    })
+  })
+
+  describe('sendErrorResponse()', () => {
+    it('should send http status code and error message', () => {
+      const statusCode = 404
+      const error = {
+        message: 'Error description'
+      }
+      const res = {
+        status: sinon.stub(),
+        header: sinon.stub(),
+        send: sinon.stub()
+      }
+
+      errorPages.sendErrorResponse(statusCode, res, error)
+
+      expect(res.status).to.have.been.calledWith(404)
+      expect(res.header).to.have.been.calledWith('Content-Type', 'text/plain;charset=utf-8')
+      expect(res.send).to.have.been.calledWith('Error description\n')
+    })
+  })
+
+  describe('setAuthenticateHeader()', () => {
+    it('should do nothing for a non-implemented auth method', () => {
+      const err = {}
+      const req = {
+        app: { locals: { authMethod: null } }
+      }
+      const res = {
+        set: sinon.stub()
+      }
+
+      errorPages.setAuthenticateHeader(req, res, err)
+
+      expect(res.set).to.not.have.been.called()
+    })
+  })
+
+  describe('sendErrorPage()', () => {
+    it('falls back the default sendErrorResponse if no page is found', () => {
+      const statusCode = 400
+      const res = {
+        status: sinon.stub(),
+        header: sinon.stub(),
+        send: sinon.stub()
+      }
+      const err = { message: 'Error description' }
+      const ldp = { errorPages: './' }
+
+      return errorPages.sendErrorPage(statusCode, res, err, ldp)
+        .then(() => {
+          expect(res.status).to.have.been.calledWith(400)
+          expect(res.header).to.have.been.calledWith('Content-Type', 'text/plain;charset=utf-8')
+          expect(res.send).to.have.been.calledWith('Error description\n')
+        })
+    })
+  })
+})

package/test/unit/esm-imports.test.mjs

@@ -0,0 +1,149 @@
+/* eslint-disable no-unused-expressions */
+import { describe, it } from 'mocha'
+import { expect } from 'chai'
+import { testESMImport, PerformanceTimer } from '../test-helpers.mjs'
+
+describe('ESM Module Import Tests', function () {
+  this.timeout(10000)
+
+  describe('Core Utility Modules', () => {
+    it('should import debug.mjs with named exports', async () => {
+      const result = await testESMImport('../lib/debug.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.namedExports).to.include('handlers')
+      expect(result.namedExports).to.include('ACL')
+      expect(result.namedExports).to.include('fs')
+      expect(result.namedExports).to.include('metadata')
+    })
+
+    it('should import http-error.mjs with default export', async () => {
+      const result = await testESMImport('../lib/http-error.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.hasDefault).to.be.true
+
+      const { default: HTTPError } = result.module
+      expect(typeof HTTPError).to.equal('function')
+
+      const error = HTTPError(404, 'Not Found')
+      expect(error.status).to.equal(404)
+      expect(error.message).to.equal('Not Found')
+    })
+
+    it('should import utils.mjs with named exports', async () => {
+      const result = await testESMImport('../lib/utils.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.namedExports).to.include('getContentType')
+      expect(result.namedExports).to.include('pathBasename')
+      expect(result.namedExports).to.include('translate')
+      expect(result.namedExports).to.include('routeResolvedFile')
+    })
+  })
+
+  describe('Handler Modules', () => {
+    it('should import all handler modules successfully', async () => {
+      const handlers = [
+        '../lib/handlers/get.mjs',
+        '../lib/handlers/post.mjs',
+        '../lib/handlers/put.mjs',
+        '../lib/handlers/delete.mjs',
+        '../lib/handlers/copy.mjs',
+        '../lib/handlers/patch.mjs'
+      ]
+
+      for (const handler of handlers) {
+        const result = await testESMImport(handler)
+        expect(result.success).to.be.true
+        expect(result.hasDefault).to.be.true
+        expect(typeof result.module.default).to.equal('function')
+      }
+    })
+
+    it('should import allow.mjs and validate permission function', async () => {
+      const result = await testESMImport('../lib/handlers/allow.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.hasDefault).to.be.true
+
+      const { default: allow } = result.module
+      expect(typeof allow).to.equal('function')
+
+      const readHandler = allow('Read')
+      expect(typeof readHandler).to.equal('function')
+    })
+  })
+
+  describe('Infrastructure Modules', () => {
+    it('should import metadata.mjs with Metadata constructor', async () => {
+      const result = await testESMImport('../lib/metadata.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.namedExports).to.include('Metadata')
+
+      const { Metadata } = result.module
+      const metadata = new Metadata()
+      expect(metadata.isResource).to.be.false
+      expect(metadata.isContainer).to.be.false
+    })
+
+    it('should import acl-checker.mjs with ACLChecker class', async () => {
+      const result = await testESMImport('../lib/acl-checker.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.hasDefault).to.be.true
+      expect(result.namedExports).to.include('DEFAULT_ACL_SUFFIX')
+      expect(result.namedExports).to.include('clearAclCache')
+
+      const { default: ACLChecker, DEFAULT_ACL_SUFFIX } = result.module
+      expect(typeof ACLChecker).to.equal('function')
+      expect(DEFAULT_ACL_SUFFIX).to.equal('.acl')
+    })
+
+    it('should import lock.mjs with withLock function', async () => {
+      const result = await testESMImport('../lib/lock.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.hasDefault).to.be.true
+
+      const { default: withLock } = result.module
+      expect(typeof withLock).to.equal('function')
+    })
+  })
+
+  describe('Application Modules', () => {
+    it('should import ldp-middleware.mjs with router function', async () => {
+      const result = await testESMImport('../lib/ldp-middleware.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.hasDefault).to.be.true
+
+      const { default: LdpMiddleware } = result.module
+      expect(typeof LdpMiddleware).to.equal('function')
+    })
+
+    it('should import main entry point index.mjs', async () => {
+      const result = await testESMImport('../index.mjs')
+
+      expect(result.success).to.be.true
+      expect(result.hasDefault).to.be.true
+      expect(result.namedExports).to.include('createServer')
+      expect(result.namedExports).to.include('startCli')
+    })
+  })
+
+  describe('Import Performance', () => {
+    it('should measure ESM import performance', async () => {
+      const timer = new PerformanceTimer()
+
+      timer.start()
+      const result = await testESMImport('../index.mjs')
+      const duration = timer.end()
+
+      expect(result.success).to.be.true
+      expect(duration).to.be.lessThan(1000) // Should import in less than 1 second
+      console.log(`ESM import took ${duration.toFixed(2)}ms`)
+    })
+  })
+})