Written test for delete-account-request

Author: megoth

lib/requests/delete-account-request.js

@@ -49,12 +49,10 @@ class DeleteAccountRequest extends AuthRequest {
    * Renders the Delete form
    */
   renderForm (error) {
-    const params = {
+    this.response.render('account/delete', {
       error,
       multiuser: this.accountManager.multiuser
-    }
-
-    this.response.render('account/delete', params)
+    })
   }
 
   /**
@@ -102,6 +100,18 @@ class DeleteAccountRequest extends AuthRequest {
 
     debug(`User '${request.username}' requested to be sent a delete account email`)
 
+    return DeleteAccountRequest.handlePost(request)
+  }
+
+  /**
+   * Performs a 'send me a password reset email' request operation, after the
+   * user has entered an email into the reset form.
+   *
+   * @param request {DeleteAccountRequest}
+   *
+   * @return {Promise}
+   */
+  static handlePost (request) {
     return Promise.resolve()
       .then(() => request.validate())
       .then(() => request.loadUser())
@@ -111,11 +121,9 @@ class DeleteAccountRequest extends AuthRequest {
   }
 
   static get (req, res) {
-    let request = DeleteAccountRequest.fromParams(req, res)
+    const request = DeleteAccountRequest.fromParams(req, res)
 
-    return Promise.resolve()
-      .then(() => request.renderForm())
-      .catch(error => request.error(error))
+    request.renderForm()
   }
 
   static fromParams (req, res) {

lib/requests/password-reset-email-request.js

@@ -85,7 +85,7 @@ class PasswordResetEmailRequest extends AuthRequest {
    * Performs a 'send me a password reset email' request operation, after the
    * user has entered an email into the reset form.
    *
-   * @param request {IncomingRequest}
+   * @param request {PasswordResetEmailRequest}
    *
    * @return {Promise}
    */

test/unit/delete-account-request-test.js

@@ -0,0 +1,181 @@
+'use strict'
+
+const chai = require('chai')
+const sinon = require('sinon')
+const expect = chai.expect
+const dirtyChai = require('dirty-chai')
+chai.use(dirtyChai)
+const sinonChai = require('sinon-chai')
+chai.use(sinonChai)
+chai.should()
+
+const HttpMocks = require('node-mocks-http')
+
+const DeleteAccountRequest = require('../../lib/requests/delete-account-request')
+const AccountManager = require('../../lib/models/account-manager')
+const SolidHost = require('../../lib/models/solid-host')
+
+describe('DeleteAccountRequest', () => {
+  describe('constructor()', () => {
+    it('should initialize a request instance from options', () => {
+      let res = HttpMocks.createResponse()
+
+      let options = {
+        response: res,
+        username: 'alice'
+      }
+
+      let 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', () => {
+      let username = 'alice'
+      let accountManager = {}
+
+      let req = {
+        app: { locals: { accountManager } },
+        body: { username }
+      }
+      let res = HttpMocks.createResponse()
+
+      let 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', () => {
+      let username = 'alice'
+      let accountManager = { multiuser: true }
+
+      let req = {
+        app: { locals: { accountManager } },
+        body: { username }
+      }
+      let 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')
+
+      let username = 'alice'
+      let host = SolidHost.from({ serverUri: 'https://example.com' })
+      let store = {
+        suffixAcl: '.acl'
+      }
+      let 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()
+
+      let req = {
+        app: { locals: { accountManager } },
+        body: { username }
+      }
+      let 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', () => {
+      let host = SolidHost.from({ serverUri: 'https://example.com' })
+      let accountManager = AccountManager.from({ host, multiuser: true })
+
+      let 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', () => {
+      let host = SolidHost.from({ serverUri: 'https://example.com' })
+      let accountManager = AccountManager.from({ host, multiuser: false })
+
+      let request = new DeleteAccountRequest({ accountManager })
+
+      expect(() => request.validate()).to.not.throw()
+    })
+  })
+
+  describe('handlePost()', () => {
+    it('should handle the post request', () => {
+      let host = SolidHost.from({ serverUri: 'https://example.com' })
+      let store = { suffixAcl: '.acl' }
+      let 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)
+
+      let username = 'alice'
+      let response = HttpMocks.createResponse()
+      response.render = sinon.stub()
+
+      let options = { accountManager, username, response }
+      let 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', () => {
+      let host = SolidHost.from({ serverUri: 'https://example.com' })
+      let store = { suffixAcl: '.acl' }
+      let accountManager = AccountManager.from({ host, multiuser: true, store })
+      accountManager.accountExists = sinon.stub().resolves(true)
+      let username = 'alice'
+
+      let options = { accountManager, username }
+      let 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 => {
+      let host = SolidHost.from({ serverUri: 'https://example.com' })
+      let store = { suffixAcl: '.acl' }
+      let accountManager = AccountManager.from({ host, multiuser: true, store })
+      accountManager.accountExists = sinon.stub().resolves(false)
+      let username = 'alice'
+
+      let options = { accountManager, username }
+      let request = new DeleteAccountRequest(options)
+
+      request.loadUser()
+        .catch(error => {
+          expect(error.message).to.equal('Account not found for that username')
+          done()
+        })
+    })
+  })
+})