hmpo-form-wizard 15.0.6 → 17.0.0

package/.github/workflows/ci.yaml

@@ -13,7 +13,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [20.x, 22.x]
+        node-version: [24.x]
 
     steps:
       - uses: actions/checkout@v4

package/.nvmrc

@@ -0,0 +1 @@
+v24.14.0

package/README.md

@@ -177,11 +177,14 @@ Any of these options can also be provided as a third argument to the wizard to c
 * `resetJourney` - Reset the journey `journeyModel` when this step is accessed.
 * `skip` - A template is not rendered on a GET request. The `post()` lifecycle is called instead. Defaults to `false`.
 * `noPost` - Don't allow posting to this step. The post method is set to null and the step is completed if there is a next step
+* `hub` - Mark this step as a hub: it is recorded in journey history on GET without storing a `next` pointer. This allows other steps to declare `prereqs` referencing this step without the hub influencing skip-ahead navigation. Use with `nonLinearJourney: true` on the wizard. Defaults to `false`.
+* `setValuesOnSave` - Array of `{ key, value }` pairs to unconditionally set on the session when this step is submitted (in `saveValues`). Useful for recording completion state flags. e.g. `setValuesOnSave: [{ key: 'sectionComplete', value: 'completed' }]`
 * `forwardQuery` - forward the query params when internally redirecting. Defaults to `false`.
 * `editable` - This step is editable. This allows accessing this step with the `editSuffix` and sets the back link and next step to the `editBackStep`. Defaults to `false`.
 * `editSuffix` - Suffix to use for editing steps. Defaults to `/edit`.
 * `editBackStep` - Location to return to after editing a step. Defaults to `confirm`
 * `continueOnEdit` - While editing, if the step marked with this is evaluated to be the next step, continue to editing it instead of returning to `editBackStep`. Defaults to `false`.
+* `nonLinearJourney` - Enable support for branching journeys. When `true`, edit mode allows access to previously-completed steps even when not reachable by normal chain-walking. Defaults to `false`. Set as a wizard-level option.
 * `fields` - specifies which of the fields from the field definition list are applied to this step. Form inputs which are not named on this list will not be processed. Default: `[]`
 * `template` - Specifies the template to render for GET requests to this step. Defaults to the route (without trailing slash)
 * `templatePath` - provides the location within `app.get('views')` that templates are stored.
@@ -360,6 +363,89 @@ These controllers can be overridden in a custom controller to provide additional
 > #### - `errorHandler(err, req, res, next)`
 > Additional error handling can be performed by overriding the `errorHandler`.
 
+## Non-linear journeys
+
+By default, the wizard validates step access by walking a linear chain of `next` pointers in journey history. This works well for sequential journeys but breaks when a journey branches into multiple independent sections from a central step.
+
+To support this pattern, two opt-in options are provided:
+
+### `hub: true` (step option)
+
+Marks a step as a hub. On each GET request, the step is recorded in journey history with only `path` and `wizard` — no `next`. This allows other steps to declare `prereqs: ['hub-step']` to validate that the hub has been visited, without the hub interfering with skip-ahead navigation.
+
+```js
+'/dashboard': {
+  noPost: true,
+  checkJourney: false,
+  hub: true
+}
+```
+
+The `checkJourney: false` is typically set alongside `hub: true` since hub steps are dispatch points, not part of a linear sequence.
+
+### `nonLinearJourney: true` (wizard option)
+
+Enables two fallbacks for edit mode that the standard chain walk cannot handle:
+
+1. **Progress check**: When editing, a step that was previously completed (present in history with a `next` and not invalid) is allowed even if the chain walk cannot reach it.
+2. **Next step**: When editing, `editBackStep` is returned if the current step was previously visited, bypassing the normal reachability check.
+
+Set at the wizard level so it applies to all steps:
+
+```js
+app.use(wizard(steps, fields, {
+  name: 'my-wizard',
+  editBackStep: 'summary',
+  nonLinearJourney: true
+}));
+```
+
+### Full example
+
+```js
+// steps.js
+module.exports = {
+  '/dashboard': {
+    noPost: true,
+    checkJourney: false,
+    hub: true
+  },
+  '/section-a': {
+    prereqs: ['dashboard'],
+    editable: true,
+    next: 'section-a-details'
+  },
+  '/section-a-details': {
+    editable: true,
+    next: 'dashboard',
+    setValuesOnSave: [{ key: 'sectionAComplete', value: 'completed' }]
+  },
+  '/section-b': {
+    prereqs: ['dashboard'],
+    editable: true,
+    next: 'section-b-details'
+  },
+  '/section-b-details': {
+    editable: true,
+    next: 'dashboard',
+    setValuesOnSave: [{ key: 'sectionBComplete', value: 'completed' }]
+  },
+  '/summary': {
+    checkJourney: false,
+    prereqs: ['dashboard']
+  }
+}
+
+// index.js
+app.use(wizard(steps, fields, {
+  name: 'my-wizard',
+  editBackStep: 'summary',
+  nonLinearJourney: true
+}));
+```
+
+In this pattern, a user visits `/dashboard`, enters any section, completes it (which sets a flag via `setValuesOnSave`), and returns to `/dashboard`. They can later edit any previously-completed section step from `/summary` and be returned to `/summary` afterwards.
+
 ## Example app
 
 An example application can be found in [the ./example directory](./example). To run this, follow the instructions in the [README](./example/README.md).

package/lib/controller/index.js

@@ -94,11 +94,8 @@ class BaseController {
     rejectUnsupportedMethods(req, res, next) {
         const method = req.method.toLowerCase();
 
-        const postBlocked = method === 'post'
-            && (req.form.options.skip || req.form.options.noPost === true);
-        const unsupported = typeof this[method] !== 'function' || postBlocked;
-
-        if (unsupported) {
+        if ((typeof this[method] !== 'function') ||
+            (req.form.options.skip && method === 'post')) {
             return this.methodNotSupported(req, res, next);
         }
 
@@ -237,20 +234,28 @@ class BaseController {
 
     _checkStatus(req, res, next) {
         debug('%s #_checkStatus', req.originalUrl);
-
-        const noPost = req.form.options.noPost === true || typeof this.post !== 'function';
         if (req.form.options.skip) {
-            if (noPost) {
-                return this.successHandler(req, res, next);
+            if (typeof this.post === 'function') {
+                return this.post(req, res, next);
             }
-            return this.post(req, res, next);
+            return this.successHandler(req, res, next);
         }
 
         const pathname = url(req).pathname;
-        if (noPost && res.locals.nextPage !== pathname && req.form.options.checkJourney) {
+        if (typeof this.post !== 'function' && res.locals.nextPage !== pathname && req.form.options.checkJourney) {
             this.setStepComplete(req, res);
         }
 
+        if (req.form.options.hub) {
+            let journeyHistory = req.journeyModel.get('history') || [];
+            if (!_.find(journeyHistory, { path: req.form.options.fullPath })) {
+                this.addJourneyHistoryStep(req, res, {
+                    path: req.form.options.fullPath,
+                    wizard: req.form.options.name
+                });
+            }
+        }
+
         next();
     }
 
@@ -354,6 +359,11 @@ class BaseController {
 
     saveValues(req, res, next) {
         debug('%s #saveValues', req.originalUrl);
+        if (req.form.options?.setValuesOnSave) {
+            for (const { key, value } of req.form.options.setValuesOnSave) {
+                req.form.values[key] = value;
+            }
+        }
         req.sessionModel.set(req.form.values);
         req.sessionModel.unset('errorValues');
         next();

package/lib/controller/mixins/check-progress.js

@@ -36,6 +36,14 @@ module.exports = Controller => class extends Controller {
             return next();
         }
 
+        if (req.isEditing && req.form.options.nonLinearJourney) {
+            let visited = this.visitedJourneyStep(req, res, path);
+            if (visited && visited.next && !visited.invalid) {
+                debug('Step is allowed by edit history', path);
+                return next();
+            }
+        }
+
         debug('Step missing prereq', path);
 
         let err = new Error('Missing prereq for this step');
@@ -92,6 +100,12 @@ module.exports = Controller => class extends Controller {
         return this.walkJourneyHistory(req, res, step => step.path === path);
     }
 
+    // return step from history by direct lookup (no chain walking)
+    visitedJourneyStep(req, res, path) {
+        let journeyHistory = req.journeyModel.get('history') || [];
+        return _.find(journeyHistory, step => step.path === path);
+    }
+
     // return step that allows a given path
     allowedJourneyStep(req, res, path) {
         return this.walkJourneyHistory(req, res, step => step.next === path);

package/lib/controller/mixins/edit-step.js

@@ -89,6 +89,15 @@ module.exports = Controller => class extends Controller {
             return editBackStep;
         }
 
+        // if the current step has been previously visited: return to edit back step
+        if (req.form.options.nonLinearJourney) {
+            let visitedStep = this.visitedJourneyStep(req, res, req.form.options.fullPath);
+            if (visitedStep && !visitedStep.invalid) {
+                debug('edit journey returning to edit back step via visited step', editBackStep);
+                return editBackStep;
+            }
+        }
+
         // go to the last step in history in edit mode to allow returning to edit-back-step
         let lastAllowedStep = this.lastAllowedStep(req, res);
         if (lastAllowedStep) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hmpo-form-wizard",
-  "version": "15.0.6",
+  "version": "17.0.0",
   "description": "Routing and request handling for a multi-step form processes",
   "main": "index.js",
   "scripts": {
@@ -17,7 +17,7 @@
   "author": "HMPO",
   "license": "MIT",
   "engines": {
-    "node": "20.x || 22.x"
+    "node": "24.x"
   },
   "bugs": {
     "url": "https://github.com/HMPO/hmpo-form-wizard/issues"
@@ -28,7 +28,7 @@
     "csrf": "^3.1.0",
     "debug": "4.3.7",
     "deep-clone-merge": "^1.5.5",
-    "hmpo-model": "^6.0.2",
+    "hmpo-model": "^7.0.1",
     "moment": "^2.30.1",
     "underscore": "^1.13.7"
   },
@@ -40,15 +40,15 @@
     "chai": "^4.5.0",
     "eslint": "^9.12.0",
     "express": "^4.21.2",
+    "globals": "^15.11.0",
+    "hmpo-reqres": "^3.0.0",
+    "husky": "^9.1.6",
     "json5": "^2.2.3",
     "mocha": "^10.7.3",
     "nyc": "^17.1.0",
     "proxyquire": "^2.1.3",
-    "hmpo-reqres": "^2.0.0",
     "sinon": "^21.0.2",
-    "sinon-chai": "^3.7.0",
-    "husky": "^9.1.6",
-    "globals": "^15.11.0"
+    "sinon-chai": "^3.7.0"
   },
   "overrides": {
     "serialize-javascript": "7.0.4"

package/test/controller/mixins/spec.check-progress.js

@@ -182,6 +182,66 @@ describe('mixins/check-progress', () => {
             next.should.have.been.calledOnce;
             next.should.have.been.calledWithExactly();
         });
+
+        it('calls callback with no arguments if editing and step is visited in history with a next', () => {
+            req.isEditing = true;
+            controller.options.nonLinearJourney = true;
+            req.journeyModel.set('history', [
+                { path: '/base/hub', wizard: 'wizard' },
+                { path: '/base/teststep', next: '/base/nextstep', wizard: 'wizard' }
+            ]);
+            controller.checkJourneyProgress(req, res, next);
+            next.should.have.been.calledOnce;
+            next.should.have.been.calledWithExactly();
+        });
+
+        it('calls callback with MISSING_PREREQ if editing but step has no next in history', () => {
+            req.isEditing = true;
+            controller.options.nonLinearJourney = true;
+            req.journeyModel.set('history', [
+                { path: '/base/teststep', wizard: 'wizard' }
+            ]);
+            controller.checkJourneyProgress(req, res, next);
+            next.should.have.been.calledOnce;
+            next.args[0][0].should.be.an.instanceOf(Error);
+            next.args[0][0].code.should.equal('MISSING_PREREQ');
+        });
+
+        it('calls callback with MISSING_PREREQ if editing but step is invalid in history', () => {
+            req.isEditing = true;
+            controller.options.nonLinearJourney = true;
+            req.journeyModel.set('history', [
+                { path: '/base/teststep', next: '/base/nextstep', invalid: true }
+            ]);
+            controller.checkJourneyProgress(req, res, next);
+            next.should.have.been.calledOnce;
+            next.args[0][0].should.be.an.instanceOf(Error);
+            next.args[0][0].code.should.equal('MISSING_PREREQ');
+        });
+
+        it('does not use edit history fallback if not editing', () => {
+            controller.options.nonLinearJourney = true;
+            req.journeyModel.set('history', [
+                { path: '/base/hub', wizard: 'wizard' },
+                { path: '/base/teststep', next: '/base/nextstep', wizard: 'wizard' }
+            ]);
+            controller.checkJourneyProgress(req, res, next);
+            next.should.have.been.calledOnce;
+            next.args[0][0].should.be.an.instanceOf(Error);
+            next.args[0][0].code.should.equal('MISSING_PREREQ');
+        });
+
+        it('does not use edit history fallback if nonLinearJourney is not set', () => {
+            req.isEditing = true;
+            req.journeyModel.set('history', [
+                { path: '/base/hub', wizard: 'wizard' },
+                { path: '/base/teststep', next: '/base/nextstep', wizard: 'wizard' }
+            ]);
+            controller.checkJourneyProgress(req, res, next);
+            next.should.have.been.calledOnce;
+            next.args[0][0].should.be.an.instanceOf(Error);
+            next.args[0][0].code.should.equal('MISSING_PREREQ');
+        });
     });
 
     describe('checkProceedToNextStep', () => {
@@ -480,6 +540,38 @@ describe('mixins/check-progress', () => {
 
     });
 
+    describe('visitedJourneyStep', () => {
+        it('returns the step if it exists in history', () => {
+            req.journeyModel.set('history', [
+                { path: '/base/hub', wizard: 'wizard' },
+                { path: '/base/teststep', next: '/base/nextstep', wizard: 'wizard' }
+            ]);
+            let result = controller.visitedJourneyStep(req, res, '/base/teststep');
+            result.should.deep.equal({ path: '/base/teststep', next: '/base/nextstep', wizard: 'wizard' });
+        });
+
+        it('returns the step even if it has no next', () => {
+            req.journeyModel.set('history', [
+                { path: '/base/hub', wizard: 'wizard' }
+            ]);
+            let result = controller.visitedJourneyStep(req, res, '/base/hub');
+            result.should.deep.equal({ path: '/base/hub', wizard: 'wizard' });
+        });
+
+        it('returns undefined if step is not in history', () => {
+            req.journeyModel.set('history', [
+                { path: '/base/other', next: '/base/nextstep' }
+            ]);
+            let result = controller.visitedJourneyStep(req, res, '/base/teststep');
+            expect(result).to.be.undefined;
+        });
+
+        it('returns undefined if history is empty', () => {
+            let result = controller.visitedJourneyStep(req, res, '/base/teststep');
+            expect(result).to.be.undefined;
+        });
+    });
+
     describe('addJourneyHistoryStep', () => {
         it('creates a step history and adds step if there is no existing step history', () => {
             controller.addJourneyHistoryStep(req, res,

package/test/controller/mixins/spec.edit-step.js

@@ -221,6 +221,41 @@ describe('mixins/edit-step', () => {
             controller.getNextStep(req, res).should.equal('/base/url/backstep');
         });
 
+        it('returns editBackStep if the current step has been previously visited', () => {
+            req.journeyModel.set('history', [
+                { path: '/base/url/hub' },
+                { path: '/base/url/path', next: '/base/url/nextstep' }
+            ]);
+            req.isEditing = true;
+            options.nonLinearJourney = true;
+            options.fullPath = '/base/url/path';
+            controller.getNextStepObject.returns({ url: 'nextstep', condition: {} });
+            controller.getNextStep(req, res).should.equal('/base/url/backstep');
+        });
+
+        it('does not return editBackStep via visited step if step is invalid', () => {
+            req.journeyModel.set('history', [
+                { path: '/base/url/hub' },
+                { path: '/base/url/path', next: '/base/url/nextstep', invalid: true }
+            ]);
+            req.isEditing = true;
+            options.nonLinearJourney = true;
+            options.fullPath = '/base/url/path';
+            controller.getNextStepObject.returns({ url: 'nextstep', condition: {} });
+            controller.getNextStep(req, res).should.not.equal('/base/url/backstep');
+        });
+
+        it('does not use visited step fallback if nonLinearJourney is not set', () => {
+            req.journeyModel.set('history', [
+                { path: '/base/url/hub' },
+                { path: '/base/url/path', next: '/base/url/nextstep' }
+            ]);
+            req.isEditing = true;
+            options.fullPath = '/base/url/path';
+            controller.getNextStepObject.returns({ url: 'nextstep', condition: {} });
+            controller.getNextStep(req, res).should.not.equal('/base/url/backstep');
+        });
+
         it('returns last valid next in history in edit mode with next arg if backstep is not valid', () => {
             req.journeyModel.set('history', [
                 { path: '/base/url/a', next: '/base/url/b' },

package/test/controller/spec.index.js

@@ -4,6 +4,7 @@ const Controller = require('../../lib/controller');
 const ErrorClass = require('../../lib/error');
 const formatting = require('../../lib/formatting');
 const validation = require('../../lib/validation');
+// const _ = require('underscore');
 
 const proxyquire = require('proxyquire');
 const express = require('express');
@@ -16,8 +17,6 @@ describe('Form Controller', () => {
         options = {
             route: '/route',
             checkJourney: true,
-            skip: false,
-            noPost: false,
             next: 'nextstep',
             template: 'template',
             fields: {
@@ -95,19 +94,12 @@ describe('Form Controller', () => {
         });
 
         it('should remove post method if noPost option is set', () =>{
-            options.noPost = true;
+            options.noPost  = true;
             let controller = new Controller(options);
             expect(controller.post).to.be.null;
         });
 
-        it('should leave post method if noPost option is not set', () => {
-            delete options.noPost;
-            let controller = new Controller(options);
-            controller.post.should.be.a('function');
-        });
-
-        it('should leave post method if noPost option is set to false', () =>{
-            options.noPost = false;
+        it('should leave post method if noPost option is not set', () =>{
             let controller = new Controller(options);
             controller.post.should.be.a('function');
         });
@@ -332,14 +324,6 @@ describe('Form Controller', () => {
             next.should.not.have.been.called;
         });
 
-        it('calls methodNotSupported for POSTing when noPost is set dynamically', () =>  {
-            req.form.options.noPost = true;
-            req.method = 'POST';
-            controller.rejectUnsupportedMethods(req, res, next);
-            controller.methodNotSupported.should.have.been.calledWithExactly(req, res, next);
-            next.should.not.have.been.called;
-        });
-
         it('does not call methodNotSupported for supported methods', () =>  {
             req.method = 'POST';
             controller.rejectUnsupportedMethods(req, res, next);
@@ -502,6 +486,7 @@ describe('Form Controller', () => {
         });
     });
 
+
     describe('_getErrors', () => {
         let controller;
 
@@ -745,9 +730,8 @@ describe('Form Controller', () => {
             sinon.stub(controller, 'successHandler');
         });
 
-        it('should call post if skip is true and noPost is false', () => {
+        it('should call post if skip is true', () => {
             options.skip = true;
-            options.noPost = false;
             controller._checkStatus(req, res, next);
             next.should.not.have.been.called;
             controller.post.should.have.been.calledWithExactly(req, res, next);
@@ -759,27 +743,17 @@ describe('Form Controller', () => {
             next.should.have.been.calledWithExactly();
         });
 
-        it('should call the successHandler if skip is set and noPost is true', () => {
+        it('should call the successHandler if skip is set but there is no post method', () => {
             options.skip = true;
-            options.noPost = true;
-            controller._checkStatus(req, res, next);
-            next.should.not.have.been.called;
-            controller.successHandler.should.have.been.calledWithExactly(req, res, next);
-        });
-
-        it('should call successHandler if skip is true and post is not a function', () => {
-            options.skip = true;
-            options.noPost = false;
             controller.post = null;
             controller._checkStatus(req, res, next);
             next.should.not.have.been.called;
             controller.successHandler.should.have.been.calledWithExactly(req, res, next);
         });
 
-        it('should call setStepComplete if the step has a next page, noPost is true and checkJourney is true', () => {
+        it('should call setStepComplete if the step has a next page and no post method', () => {
             res.locals.nextPage = '/next/page';
-            options.noPost = true;
-            options.checkJourney = true;
+            controller.post = null;
             controller._checkStatus(req, res, next);
             controller.setStepComplete.should.have.been.calledOnce;
             controller.setStepComplete.should.have.been.calledWithExactly(req, res);
@@ -788,19 +762,40 @@ describe('Form Controller', () => {
 
         it('should not call setStepComplete if the next page is the same as the current url', () => {
             res.locals.nextPage = '/base/route';
+            controller.post = null;
             controller._checkStatus(req, res, next);
             controller.setStepComplete.should.not.have.been.called;
             next.should.have.been.calledWithExactly();
         });
 
-        it('should call setStepComplete if post is not a function and checkJourney is true', () => {
-            res.locals.nextPage = '/next/page';
-            options.noPost = false;
-            options.checkJourney = true;
-            controller.post = null;
+        it('should add hub step to history on first visit when hub option is true', () => {
+            sinon.stub(controller, 'addJourneyHistoryStep');
+            options.hub = true;
+            options.fullPath = '/base/route';
+            options.name = 'test-wizard';
             controller._checkStatus(req, res, next);
-            controller.setStepComplete.should.have.been.calledOnce;
-            controller.setStepComplete.should.have.been.calledWithExactly(req, res);
+            controller.addJourneyHistoryStep.should.have.been.calledOnce;
+            controller.addJourneyHistoryStep.should.have.been.calledWithExactly(req, res, {
+                path: '/base/route',
+                wizard: 'test-wizard'
+            });
+            next.should.have.been.calledWithExactly();
+        });
+
+        it('should not add hub step to history if already present', () => {
+            sinon.stub(controller, 'addJourneyHistoryStep');
+            options.hub = true;
+            options.fullPath = '/base/route';
+            req.journeyModel.set('history', [{ path: '/base/route' }]);
+            controller._checkStatus(req, res, next);
+            controller.addJourneyHistoryStep.should.not.have.been.called;
+            next.should.have.been.calledWithExactly();
+        });
+
+        it('should not add hub step to history when hub option is not set', () => {
+            sinon.stub(controller, 'addJourneyHistoryStep');
+            controller._checkStatus(req, res, next);
+            controller.addJourneyHistoryStep.should.not.have.been.called;
             next.should.have.been.calledWithExactly();
         });
     });
@@ -1199,6 +1194,28 @@ describe('Form Controller', () => {
             controller.saveValues(req, res, next);
             next.should.have.been.calledWithExactly();
         });
+
+        it('sets setValuesOnSave values in form values before saving', () => {
+            req.form.options = { setValuesOnSave: [{ key: 'sectionComplete', value: true }] };
+            controller.saveValues(req, res, next);
+            req.sessionModel.get('sectionComplete').should.equal(true);
+        });
+
+        it('sets multiple setValuesOnSave values', () => {
+            req.form.options = { setValuesOnSave: [
+                { key: 'sectionComplete', value: true },
+                { key: 'sectionStatus', value: 'done' }
+            ] };
+            controller.saveValues(req, res, next);
+            req.sessionModel.get('sectionComplete').should.equal(true);
+            req.sessionModel.get('sectionStatus').should.equal('done');
+        });
+
+        it('does not set values when setValuesOnSave is not configured', () => {
+            req.form.options = {};
+            controller.saveValues(req, res, next);
+            expect(req.sessionModel.get('sectionComplete')).to.be.undefined;
+        });
     });
 
     describe('successHandler', () => {

package/test/controller/spec.lifecycle.js

@@ -10,8 +10,6 @@ describe('Controller Lifecycle', () => {
         options = {
             route: '/route',
             checkJourney: true,
-            skip: false,
-            noPost: false,
             next: 'nextstep',
             template: 'template',
             fields: {
@@ -305,31 +303,8 @@ describe('Controller Lifecycle', () => {
             handler(req, res, next);
         });
 
-        it('runs the successHandler if the skip option is set and noPost option is set', done => {
+        it('runs the successHandler if the skip options is set and there is no post handler', done => {
             controller.options.skip = true;
-            controller.options.noPost = true;
-
-            assert = () => {
-                controller.successHandler.should.have.been
-                    .calledOnce
-                    .calledAfter(controller._checkStatus)
-                    .and.calledOn(controller)
-                    .and.calledWithExactly(req, res, sinon.match.func);
-                controller.setStepComplete.should.have.been
-                    .calledOnce
-                    .calledAfter(controller.successHandler)
-                    .and.calledOn(controller)
-                    .and.calledWithExactly(req, res);
-                controller.render.should.not.have.been.called;
-                done();
-            };
-
-            handler(req, res, next);
-        });
-
-        it('runs the successHandler if skip is set and post is not a function', done => {
-            controller.options.skip = true;
-            controller.options.noPost = false;
             controller.post = null;
 
             assert = () => {
@@ -350,8 +325,8 @@ describe('Controller Lifecycle', () => {
             handler(req, res, next);
         });
 
-        it('sets the step as complete if noPost option is set', done => {
-            controller.options.noPost = true;
+        it('sets the step as complete if there is no post handler', done => {
+            controller.post = null;
 
             assert = () => {
                 controller.setStepComplete.should.have.been