@ukhomeoffice/cop-react-form-renderer 5.0.0-alpha → 5.0.1

package/dist/components/FormRenderer/onPageAction.test.js

@@ -0,0 +1,678 @@
+"use strict";
+
+var _models = require("../../models");
+var _utils = _interopRequireDefault(require("../../utils"));
+var _handlers = _interopRequireDefault(require("./handlers"));
+var _helpers = _interopRequireDefault(require("./helpers"));
+var _onPageAction = _interopRequireDefault(require("./onPageAction"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+jest.mock('./handlers', function () {
+  return {
+    navigateCalls: 0,
+    navigate: function navigate() {
+      this.navigateCalls += 1;
+    },
+    submissionErrorCalls: 0,
+    submissionErrorArgs: [],
+    submissionError: function submissionError(errors, addErrors) {
+      this.submissionErrorCalls += 1;
+      this.submissionErrorArgs.push(errors);
+      if (typeof addErrors === 'function') {
+        addErrors(errors);
+      }
+    },
+    reset: function reset() {
+      this.navigateCalls = 0;
+      this.submissionErrorCalls = 0;
+      this.submissionErrorArgs = [];
+    }
+  };
+});
+jest.mock('./helpers', function () {
+  return {
+    canActionProceedCalls: 0,
+    canActionProceedResult: true,
+    canActionProceed: function canActionProceed(action, page, validator) {
+      this.canActionProceedCalls += 1;
+      if (typeof validator === 'function') {
+        validator();
+      }
+      return this.canActionProceedResult;
+    },
+    cleanHiddenNestedDataCalls: 0,
+    cleanHiddenNestedData: function cleanHiddenNestedData(patch) {
+      this.cleanHiddenNestedDataCalls += 1;
+      return patch;
+    },
+    getNextPageIdCalls: 0,
+    getNextPageId: function getNextPageId() {
+      this.getNextPageIdCalls += 1;
+      return 'page2';
+    },
+    getSubmissionStatusCalls: 0,
+    getSubmissionStatus: function getSubmissionStatus() {
+      this.getSubmissionStatusCalls += 1;
+      return 'Good to go!';
+    },
+    reset: function reset() {
+      this.canActionProceedCalls = 0;
+      this.canActionProceedResult = true;
+      this.canCYASubmitResult = true;
+      this.cleanHiddenNestedDataCalls = 0;
+      this.getFormStateCalls = 0;
+      this.getSubmissionStatusCalls = 0;
+    }
+  };
+});
+jest.mock('../../utils', function () {
+  var originalModule = jest.requireActual('../../utils');
+  return _objectSpread(_objectSpread({}, originalModule.default), {}, {
+    Format: {
+      formCalls: 0,
+      form: function form(_form, data) {
+        this.formCalls += 1;
+        return data;
+      }
+    },
+    CollectionPage: {
+      duplicateActiveEntryCalls: 0,
+      duplicateActiveEntryResult: true,
+      duplicateActiveEntry: function duplicateActiveEntry() {
+        this.duplicateActiveEntryCalls += 1;
+        return this.duplicateActiveEntryResult;
+      }
+    },
+    reset: function reset() {
+      this.Format.formCalls = 0;
+      this.CollectionPage.duplicateActiveEntryCalls = 0;
+      this.duplicateActiveEntryResult = true;
+    }
+  });
+});
+describe('components.FormRenderer.onPageAction', function () {
+  var MOCK_HOOKS = {
+    onSubmitCalls: 0,
+    onSubmitArgs: [],
+    onSubmit: function onSubmit(type, payload, onSuccess, onError, changedFieldName, changedFieldValue) {
+      this.onSubmitCalls += 1;
+      this.onSubmitArgs.push({
+        type: type,
+        payload: payload,
+        changedFieldName: changedFieldName,
+        changedFieldValue: changedFieldValue
+      });
+      if (typeof onSuccess === 'function') {
+        onSuccess();
+      }
+      // onError would not normally be called alongside
+      // onSuccess, we're just doing it here to make sure
+      // the expected function chain is called.
+      if (typeof onError === 'function') {
+        onError(['an example error']);
+      }
+    },
+    onFormCompleteCalls: 0,
+    onFormComplete: function onFormComplete() {
+      this.onFormCompleteCalls += 1;
+    },
+    onCancelCalls: 0,
+    onCancel: function onCancel() {
+      this.onCancelCalls += 1;
+    },
+    reset: function reset() {
+      this.onSubmitCalls = 0;
+      this.onSubmitArgs = [];
+      this.onFormCompleteCalls = 0;
+      this.onCancelCalls = 0;
+      this.onActionCalls = 0;
+    },
+    onActionCalls: 0,
+    onAction: function onAction(formData, patch) {
+      this.onActionCalls += 1;
+      return {
+        formData: formData,
+        patch: patch
+      };
+    }
+  };
+  var MOCK_VALIDATE = {
+    pageCalls: 0,
+    page: function page() {
+      MOCK_VALIDATE.pageCalls += 1;
+    },
+    reset: function reset() {
+      this.pageCalls = 0;
+    }
+  };
+  var setPagePointCalls = 0;
+  var setPagePointArgs = [];
+  var mockSetPagePoint = function mockSetPagePoint(point) {
+    setPagePointCalls += 1;
+    setPagePointArgs.push(point);
+  };
+  var setDataCalls = 0;
+  var setDataArgs = [];
+  var mockSetData = function mockSetData(data) {
+    setDataCalls += 1;
+    setDataArgs.push(data);
+  };
+  var onPageChangeCalls = 0;
+  var onPageChangeArgs = [];
+  var mockOnPageChange = function mockOnPageChange(pageId) {
+    onPageChangeCalls += 1;
+    onPageChangeArgs.push(pageId);
+  };
+  var addErrorsArgs = [];
+  var mockAddErrors = function mockAddErrors(errors) {
+    addErrorsArgs.push(errors);
+  };
+  var setSubmittedArgs = [];
+  var mockSetSubmitted = function mockSetSubmitted(newSubmitted) {
+    setSubmittedArgs.push(newSubmitted);
+  };
+  var COMPONENTS = [{
+    id: 'alpha',
+    fieldId: 'alpha'
+  }, {
+    id: 'bravo',
+    fieldId: 'bravo'
+  }, {
+    id: 'charlie',
+    fieldId: 'charlie'
+  }, {
+    id: 'delta',
+    fieldId: 'delta'
+  }];
+  var PAGES = [{
+    id: 'page1',
+    components: [_objectSpread({}, COMPONENTS[0]), _objectSpread({}, COMPONENTS[1])]
+  }, {
+    id: 'page2',
+    components: [_objectSpread({}, COMPONENTS[2]), _objectSpread({}, COMPONENTS[3])]
+  }];
+  var CURRENT_TASK = {
+    name: 'testTask',
+    fullPages: PAGES
+  };
+  var ARGS = {
+    action: {
+      type: _models.PageAction.TYPES.NAVIGATE
+    },
+    patch: null,
+    patchLabel: {},
+    hooks: MOCK_HOOKS,
+    data: {},
+    formState: {
+      page: {
+        formData: {}
+      }
+    },
+    validate: MOCK_VALIDATE,
+    onPageChange: mockOnPageChange,
+    type: _models.FormTypes.FORM_WITH_TASK,
+    pages: PAGES,
+    components: COMPONENTS,
+    pageId: 'alpha',
+    setPagePoint: mockSetPagePoint,
+    currentTask: CURRENT_TASK,
+    setData: mockSetData,
+    hubDetails: {},
+    setSubmitted: mockSetSubmitted,
+    addErrors: mockAddErrors
+  };
+  beforeEach(function () {
+    _handlers.default.reset();
+    _helpers.default.reset();
+    _utils.default.reset();
+    MOCK_HOOKS.reset();
+    MOCK_VALIDATE.reset();
+    setPagePointCalls = 0;
+    setPagePointArgs = [];
+    setDataCalls = 0;
+    setDataArgs = [];
+    onPageChangeCalls = 0;
+    onPageChangeArgs = [];
+    addErrorsArgs = [];
+    setSubmittedArgs = [];
+  });
+  var preActionChecks = function preActionChecks() {
+    expect(_helpers.default.canActionProceedCalls).toEqual(1);
+    expect(MOCK_VALIDATE.pageCalls).toEqual(1);
+    expect(_helpers.default.cleanHiddenNestedDataCalls).toEqual(1);
+  };
+  var postActionChecks = function postActionChecks(argsUsed) {
+    expect(_utils.default.Format.formCalls).toEqual(1);
+    expect(_helpers.default.getSubmissionStatusCalls).toEqual(1);
+    // setData is always called once in the error callback 
+    // for the onSubmit hook. It's called an extra time prior
+    // to this if patch is valid.
+    if (argsUsed.patch) {
+      expect(setDataCalls).toEqual(2);
+      var dataUsed = _objectSpread(_objectSpread(_objectSpread({}, argsUsed.data), argsUsed.patch), argsUsed.formState.page.formData);
+      var submissionData = _utils.default.Format.form(null, dataUsed, null);
+      submissionData.formStatus = _helpers.default.getSubmissionStatus();
+      expect(setDataArgs[0]).toEqual(submissionData);
+    } else {
+      expect(setDataCalls).toEqual(1);
+    }
+    expect(MOCK_HOOKS.onSubmitCalls).toEqual(1);
+    if (argsUsed.type === _models.FormTypes.HUB && Object.keys(argsUsed.patchLabel).length > 0) {
+      var firstKey = Object.keys(argsUsed.patchLabel)[0];
+      expect(MOCK_HOOKS.onSubmitArgs[0]).toMatchObject({
+        changedFieldName: firstKey,
+        changedFieldValue: argsUsed.patchLabel[firstKey]
+      });
+    }
+    expect(MOCK_HOOKS.onActionCalls).toEqual(1);
+
+    // Both the success and error paths of the onSubmit hook are tested
+    // together to make sure the correct function chains are called for
+    // each.
+
+    // The success path is tested per-action as it can differ slightly.
+
+    // Testing the error path.
+    expect(_handlers.default.submissionErrorCalls).toEqual(1);
+    expect(setDataArgs[setDataCalls - 1]).toEqual(argsUsed.data); // Data is reset in the case of an error.
+  };
+
+  it("should handle the ".concat(_models.PageAction.TYPES.CANCEL, " Page Action type"), function () {
+    var ACTION = {
+      type: _models.PageAction.TYPES.CANCEL
+    };
+    var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+      action: ACTION
+    });
+    _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+    expect(MOCK_HOOKS.onCancelCalls).toEqual(1);
+    // Shouldn't get to the point of validation if
+    // action is a cancel action.
+    expect(_helpers.default.canActionProceedCalls).toEqual(0);
+    expect(MOCK_VALIDATE.pageCalls).toEqual(0);
+  });
+  it("should handle the ".concat(_models.PageAction.TYPES.NAVIGATE, " Page Action type"), function () {
+    var ACTION = {
+      type: _models.PageAction.TYPES.NAVIGATE
+    };
+    var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+      action: ACTION
+    });
+    _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+    preActionChecks();
+    expect(_handlers.default.navigateCalls).toEqual(1);
+    expect(MOCK_HOOKS.onSubmitCalls).toEqual(0);
+    // Not doing the usual post-action checks here
+    // as a navigate action should stop at calling
+    // hooks.navigate.
+  });
+
+  it("should handle the ".concat(_models.PageAction.TYPES.SUBMIT, " Page Action type"), function () {
+    var ACTION = {
+      type: _models.PageAction.TYPES.SUBMIT
+    };
+    var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+      action: ACTION
+    });
+    _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+    preActionChecks();
+    expect(setPagePointCalls).toEqual(1);
+    expect(setPagePointArgs[0]).toEqual('submit');
+    postActionChecks(CUSTOM_ARGS);
+  });
+  it("should handle the ".concat(_models.PageAction.TYPES.SAVE_AND_NAVIGATE, " Page Action type"), function () {
+    var ACTION = {
+      type: _models.PageAction.TYPES.SAVE_AND_NAVIGATE
+    };
+    var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+      action: ACTION
+    });
+    _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+    preActionChecks();
+    // All the actions does in this case is set a function
+    // to be called in the onSuccess callback for the onSubmit hook.
+    postActionChecks(CUSTOM_ARGS);
+    expect(_handlers.default.navigateCalls).toEqual(1);
+  });
+  it("should handle the ".concat(_models.PageAction.TYPES.COLLECTION_ADD, " Page Action type"), function () {
+    var FORM_STATE = {
+      page: {
+        formData: {
+          'testCollection': []
+        }
+      }
+    };
+    var ACTION = {
+      type: _models.PageAction.TYPES.COLLECTION_ADD,
+      collection: 'testCollection'
+    };
+    var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+      action: ACTION,
+      formState: FORM_STATE
+    });
+    _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+    preActionChecks();
+    expect(FORM_STATE.page.formData["".concat(ACTION.collection, "ActiveId")]).toBeDefined();
+    postActionChecks(CUSTOM_ARGS);
+
+    // This action type also sets up a call to handlers.navigate
+    // that's called as part of the onSubmit hook's onSuccess callback.
+    expect(_handlers.default.navigateCalls).toEqual(1);
+  });
+  describe("should handle the ".concat(_models.PageAction.TYPES.COLLECTION_DUPLICATE, " Page Action type"), function () {
+    it("calling handlers.navigate if the duplication was successful", function () {
+      var FORM_STATE = {
+        page: {
+          formData: {
+            'testCollection': []
+          }
+        }
+      };
+      var ACTION = {
+        type: _models.PageAction.TYPES.COLLECTION_DUPLICATE,
+        collection: 'testCollection'
+      };
+      var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+        action: ACTION,
+        formState: FORM_STATE
+      });
+      _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+      preActionChecks();
+      expect(_utils.default.CollectionPage.duplicateActiveEntryCalls).toEqual(1);
+      postActionChecks(CUSTOM_ARGS);
+
+      // This action type also sets up a call to handlers.navigate
+      // that's called as part of the onSubmit hook's onSuccess callback.
+      expect(_handlers.default.navigateCalls).toEqual(1);
+    });
+    it("calling onPageChange if the duplication was unsuccessful", function () {
+      var FORM_STATE = {
+        page: {
+          formData: {
+            'testCollection': []
+          }
+        }
+      };
+      var ACTION = {
+        type: _models.PageAction.TYPES.COLLECTION_DUPLICATE,
+        collection: 'testCollection'
+      };
+      var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+        action: ACTION,
+        formState: FORM_STATE
+      });
+      _utils.default.CollectionPage.duplicateActiveEntryResult = false;
+      _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+      preActionChecks();
+      expect(_utils.default.CollectionPage.duplicateActiveEntryCalls).toEqual(1);
+      postActionChecks(CUSTOM_ARGS);
+
+      // The handlers.navigate callback shouldn't be set when
+      // duplication fails.
+      expect(_handlers.default.navigateCalls).toEqual(0);
+      // Instead we should be using the default onPageChange setup.
+      expect(onPageChangeCalls).toEqual(1);
+    });
+  });
+  describe("should handle the ".concat(_models.PageAction.TYPES.COLLECTION_REMOVE, " Page Action type"), function () {
+    it("should store a reference to the removed item if action.recordRemoval is true", function () {
+      var FORM_STATE = {
+        page: {
+          formData: {
+            testCollectionActiveId: 'removeMe',
+            testCollection: [{
+              id: 'removeMe'
+            }, {
+              id: 'leaveMeAlone'
+            }]
+          }
+        }
+      };
+      var ACTION = {
+        type: _models.PageAction.TYPES.COLLECTION_REMOVE,
+        collection: 'testCollection',
+        recordRemoval: true
+      };
+      var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+        action: ACTION,
+        formState: FORM_STATE
+      });
+      _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+      preActionChecks();
+      expect(FORM_STATE.page.formData.testCollection).toEqual([{
+        id: 'leaveMeAlone'
+      }]);
+      expect(FORM_STATE.page.formData.testCollectionLastRemoved).toEqual({
+        id: 'removeMe'
+      });
+      postActionChecks(CUSTOM_ARGS);
+
+      // This action type uses the default onPageChange.
+      expect(onPageChangeCalls).toEqual(1);
+    });
+    it("should not store a reference to the removed item if action.recordRemoval is false", function () {
+      var FORM_STATE = {
+        page: {
+          formData: {
+            testCollectionActiveId: 'removeMe',
+            testCollection: [{
+              id: 'removeMe'
+            }, {
+              id: 'leaveMeAlone'
+            }]
+          }
+        }
+      };
+      var ACTION = {
+        type: _models.PageAction.TYPES.COLLECTION_REMOVE,
+        collection: 'testCollection',
+        recordRemoval: false
+      };
+      var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+        action: ACTION,
+        formState: FORM_STATE
+      });
+      _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+      preActionChecks();
+      expect(FORM_STATE.page.formData.testCollection).toEqual([{
+        id: 'leaveMeAlone'
+      }]);
+      expect(FORM_STATE.page.formData.testCollectionLastRemoved).toBeUndefined();
+      postActionChecks(CUSTOM_ARGS);
+
+      // This action type uses the default onPageChange.
+      expect(onPageChangeCalls).toEqual(1);
+    });
+    it("should not store a reference to the removed item if action.recordRemoval is not defined", function () {
+      var FORM_STATE = {
+        page: {
+          formData: {
+            testCollectionActiveId: 'removeMe',
+            testCollection: [{
+              id: 'removeMe'
+            }, {
+              id: 'leaveMeAlone'
+            }]
+          }
+        }
+      };
+      var ACTION = {
+        type: _models.PageAction.TYPES.COLLECTION_REMOVE,
+        collection: 'testCollection'
+      };
+      var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+        action: ACTION,
+        formState: FORM_STATE
+      });
+      _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+      preActionChecks();
+      expect(FORM_STATE.page.formData.testCollection).toEqual([{
+        id: 'leaveMeAlone'
+      }]);
+      expect(FORM_STATE.page.formData.testCollectionLastRemoved).toBeUndefined();
+      postActionChecks(CUSTOM_ARGS);
+
+      // This action type uses the default onPageChange.
+      expect(onPageChangeCalls).toEqual(1);
+    });
+  });
+  describe('if validation fails', function () {
+    var VALID_ACTIONS = Object.values(_models.PageAction.TYPES).filter(function (a) {
+      return a !== _models.PageAction.TYPES.CANCEL;
+    });
+    VALID_ACTIONS.forEach(function (actionType) {
+      it("should not continue for the ".concat(actionType, " action type"), function () {
+        var ACTION = {
+          type: actionType
+        };
+        var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+          action: ACTION
+        });
+        _helpers.default.canActionProceedResult = false;
+        _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+        expect(_helpers.default.canActionProceedCalls).toEqual(1);
+        expect(MOCK_VALIDATE.pageCalls).toEqual(1);
+        // Validation fails so we expect to never reach
+        // the point of submission.
+        expect(MOCK_HOOKS.onSubmitCalls).toEqual(0);
+      });
+    });
+  });
+  describe('adding a field to formData if specified on the action', function () {
+    var VALID_ACTIONS = Object.values(_models.PageAction.TYPES).filter(function (a) {
+      return a !== _models.PageAction.TYPES.CANCEL && a !== _models.PageAction.TYPES.NAVIGATE;
+    });
+    VALID_ACTIONS.forEach(function (actionType) {
+      it("should work for the ".concat(actionType, " action type"), function () {
+        var FORM_STATE = {
+          page: {
+            formData: {
+              testCollection: []
+            }
+          }
+        };
+        var ACTION = {
+          type: actionType,
+          collection: 'testCollection',
+          addToFormData: {
+            field: 'alpha',
+            value: '123'
+          }
+        };
+        var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+          formState: FORM_STATE,
+          action: ACTION
+        });
+        _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+        preActionChecks();
+        postActionChecks(CUSTOM_ARGS);
+        expect(FORM_STATE.page.formData).toMatchObject({
+          alpha: '123'
+        });
+      });
+    });
+    it("should work for the ".concat(_models.PageAction.TYPES.NAVIGATE, " action type"), function () {
+      var FORM_STATE = {
+        page: {
+          formData: {
+            testCollection: []
+          }
+        }
+      };
+      var ACTION = {
+        type: _models.PageAction.TYPES.NAVIGATE,
+        collection: 'testCollection',
+        addToFormData: {
+          field: 'alpha',
+          value: '123'
+        }
+      };
+      var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+        formState: FORM_STATE,
+        action: ACTION
+      });
+      _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+      preActionChecks();
+      // Not doing the usual post-action checks here
+      // as a navigate action should stop at calling
+      // hooks.navigate.
+      expect(FORM_STATE.page.formData).toMatchObject({
+        alpha: '123'
+      });
+    });
+    it('should work for an array of formData', function () {
+      var FORM_STATE = {
+        page: {
+          formData: {
+            testCollection: []
+          }
+        }
+      };
+      var ACTION = {
+        type: _models.PageAction.TYPES.NAVIGATE,
+        collection: 'testCollection',
+        addToFormData: [{
+          field: 'alpha',
+          value: '123'
+        }, {
+          field: 'beta.gamma',
+          value: '456'
+        }]
+      };
+      var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+        formState: FORM_STATE,
+        action: ACTION
+      });
+      _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+      preActionChecks();
+      // Not doing the usual post-action checks here
+      // as a navigate action should stop at calling
+      // hooks.navigate.
+      expect(FORM_STATE.page.formData).toMatchObject({
+        alpha: '123',
+        beta: {
+          gamma: '456'
+        }
+      });
+    });
+  });
+  describe('recording patchLabel fields correctly when it is defined', function () {
+    var VALID_ACTIONS = Object.values(_models.PageAction.TYPES).filter(function (a) {
+      return a !== _models.PageAction.TYPES.CANCEL && a !== _models.PageAction.TYPES.NAVIGATE;
+    });
+    VALID_ACTIONS.forEach(function (actionType) {
+      it("should work for the ".concat(actionType, " action type"), function () {
+        var FORM_STATE = {
+          page: {
+            formData: {
+              testCollection: []
+            }
+          }
+        };
+        var KEY = 'testField';
+        var VALUE = 'testValue';
+        var PATCH_LABEL = _defineProperty({}, KEY, VALUE);
+        var PATCH = _defineProperty({}, KEY, VALUE);
+        var ACTION = {
+          type: actionType,
+          collection: 'testCollection'
+        };
+        var CUSTOM_ARGS = _objectSpread(_objectSpread({}, ARGS), {}, {
+          action: ACTION,
+          formState: FORM_STATE,
+          patch: PATCH,
+          patchLabel: PATCH_LABEL,
+          type: _models.FormTypes.HUB
+        });
+        _onPageAction.default.apply(void 0, Object.values(CUSTOM_ARGS));
+        preActionChecks();
+        postActionChecks(CUSTOM_ARGS); // Specific check for patchLabel done in here.
+      });
+    });
+  });
+});