@pie-element/explicit-constructed-response 9.3.2-next.2 → 9.3.2-tip-tap.0

package/configure/lib/__tests__/alternateSection.test.js

@@ -0,0 +1,289 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _alternateSection = require("../alternateSection");
+
+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) { (0, _defineProperty2["default"])(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; }
+
+var choices = [{
+  label: 'cow',
+  value: '0'
+}, {
+  label: 'cattle',
+  value: '1'
+}, {
+  label: 'calf',
+  value: '2'
+}];
+describe('Choice', function () {
+  var onChange = jest.fn();
+  var onDelete = jest.fn();
+
+  var wrapper = function wrapper() {
+    var defaults = {
+      classes: {},
+      key: '0',
+      markup: 'cow',
+      onChange: onChange,
+      onDelete: onDelete
+    };
+
+    var props = _objectSpread({}, defaults);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_alternateSection.Choice, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      expect(wrapper()).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    it('calls onChange', function () {
+      var w = wrapper();
+      w.instance().onChange({
+        target: {
+          value: 'TEST'
+        }
+      });
+      setTimeout(function () {
+        expect(onChange).toHaveBeenCalledWith('TEST');
+      }, 400);
+    });
+  });
+});
+describe('AlternateSection', function () {
+  var onSelect = jest.fn();
+  var choiceChanged = jest.fn();
+  var choiceRemoved = jest.fn();
+  var lengthChanged = jest.fn();
+
+  var wrapper = function wrapper() {
+    var extras = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    var defaults = _objectSpread({
+      classes: {},
+      key: '0',
+      value: 'cow',
+      onSelect: onSelect,
+      choiceChanged: choiceChanged,
+      choiceRemoved: choiceRemoved,
+      lengthChanged: lengthChanged,
+      selectChoices: [{
+        label: 'moon',
+        value: '2'
+      }],
+      choices: choices,
+      maxLength: 10
+    }, extras);
+
+    var props = _objectSpread({}, defaults);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_alternateSection.AlternateSection, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      expect(wrapper()).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    var w;
+    beforeEach(function () {
+      w = wrapper();
+    });
+    describe('updateChoicesIfNeeded', function () {
+      it('does not set state', function () {
+        w.instance().updateChoicesIfNeeded({
+          choices: choices
+        });
+        expect(w.instance().state).toEqual(expect.objectContaining({
+          choices: choices
+        }));
+      });
+      it('sets state, updates edited choice', function () {
+        var newChoices = [{
+          label: 'cow',
+          value: '0'
+        }, {
+          label: 'cattle',
+          value: '1'
+        }, {
+          label: 'little calf',
+          value: '2'
+        }];
+        w.instance().updateChoicesIfNeeded({
+          choices: newChoices
+        });
+        expect(w.instance().state).toEqual(expect.objectContaining({
+          choices: newChoices
+        }));
+      });
+      it('sets state, updates adding new choice', function () {
+        var newChoices = [{
+          label: 'cow',
+          value: '0'
+        }, {
+          label: 'cattle',
+          value: '1'
+        }, {
+          label: 'little calf',
+          value: '2'
+        }];
+        w.instance().updateChoicesIfNeeded({
+          choices: newChoices
+        });
+        expect(w.instance().state).toEqual(expect.objectContaining({
+          choices: newChoices
+        }));
+      });
+      it('sets state, updates removing choice', function () {
+        var newChoices = [{
+          label: 'cow',
+          value: '0'
+        }, {
+          label: 'cattle',
+          value: '1'
+        }];
+        w.instance().updateChoicesIfNeeded({
+          choices: newChoices
+        });
+        expect(w.instance().state).toEqual(expect.objectContaining({
+          choices: newChoices
+        }));
+      });
+    });
+    describe('handleSelect', function () {
+      it('calls onSelect', function () {
+        w.instance().handleSelect({
+          target: {
+            value: '2'
+          }
+        });
+        expect(onSelect).toBeCalledWith({
+          label: 'moon',
+          value: '2'
+        });
+      });
+    });
+    describe('onAddChoice', function () {
+      it('adds choice', function () {
+        var state = w.instance().state;
+        w.instance().onAddChoice();
+        expect(w.instance().state.choices).toEqual([].concat((0, _toConsumableArray2["default"])(state.choices), [{
+          value: '3',
+          label: ''
+        }]));
+      });
+      it('does not add choice if previously added choice is empty', function () {
+        var state = w.instance().state;
+        w.instance().onAddChoice();
+        state.choices.push({
+          value: '3',
+          label: ''
+        });
+        expect(w.instance().state.choices).toEqual(state.choices);
+        w.instance().onAddChoice();
+        expect(w.instance().state.choices).toEqual(state.choices);
+      });
+    });
+    describe('onChoiceChanged', function () {
+      beforeEach(function () {
+        choiceChanged.mockClear();
+        lengthChanged.mockClear();
+      });
+      it('calls choiceChanged', function () {
+        w.instance().onChoiceChanged({
+          value: '0',
+          label: 'cow'
+        }, 'New value');
+        expect(choiceChanged).toBeCalledWith({
+          value: '0',
+          label: 'New value'
+        });
+      });
+      it('calls lengthChanged when new max length is greater than current maxLength', function () {
+        // ['cow', 'cattle', 'calf'] - max length is 6 (cattle)
+        // maxLength prop is 10, so we need something longer than 10
+        var longChoice = 'Very long choice text'; // 21 characters
+
+        w.instance().onChoiceChanged({
+          value: '0',
+          label: 'cow'
+        }, longChoice, 0); // 21 + 5 = 26
+
+        expect(lengthChanged).toHaveBeenCalledWith(26);
+      });
+      it('calls lengthChanged when new max length is significantly smaller', function () {
+        var wrapperWithHighMaxLength = wrapper({
+          maxLength: 30
+        }); // ['cow', 'cattle', 'calf'] - max length is 6
+
+        wrapperWithHighMaxLength.instance().onChoiceChanged({
+          value: '1',
+          label: 'cattle'
+        }, 'a', 1); // max length will be 4 (max of 'cow', 'a', 'calf')
+        // Since 4 + 10 = 14 <= 30, this should trigger lengthChanged
+
+        expect(lengthChanged).toHaveBeenCalledWith(7); // getAdjustedLength(4) = 4 + 3 = 7
+      });
+      it('does not call lengthChanged when new max length is within threshold', function () {
+        // ['cow', 'cattle', 'calf'] - max length is 6
+        // maxLength is 10, change to something that keeps max around the same
+        w.instance().onChoiceChanged({
+          value: '0',
+          label: 'cow'
+        }, 'bull', 0); // max length will still be 6 (cattle), which is not > 10 and not <= 0 (10-10)
+
+        expect(lengthChanged).not.toHaveBeenCalled();
+      });
+      it('calculates max length across all choices correctly', function () {
+        var shortChoices = [{
+          label: 'a',
+          value: '0'
+        }, {
+          label: 'bb',
+          value: '1'
+        }, {
+          label: 'ccc',
+          value: '2'
+        }];
+        var wrapperWithShortChoices = wrapper({
+          choices: shortChoices,
+          maxLength: 5
+        });
+        wrapperWithShortChoices.instance().onChoiceChanged({
+          value: '2',
+          label: 'ccc'
+        }, 'This is much longer', 2);
+        expect(lengthChanged).toHaveBeenCalledWith(24);
+      });
+      it('handles mixed special characters correctly', function () {
+        lengthChanged.mockClear();
+        var mixedSpecialChoice = 'Test with & < > " \' symbols'; // 27 chars when decoded
+
+        var wrapperWithLowMax = wrapper({
+          maxLength: 5
+        });
+        wrapperWithLowMax.instance().onChoiceChanged({
+          value: '0',
+          label: 'cow'
+        }, mixedSpecialChoice, 0); // 27 normal characters + 5 buffer = 32
+
+        expect(lengthChanged).toHaveBeenCalledWith(32);
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/alternateSection.test.jsx"],"names":["choices","label","value","describe","onChange","jest","fn","onDelete","wrapper","defaults","classes","key","markup","props","it","expect","toMatchSnapshot","w","instance","target","setTimeout","toHaveBeenCalledWith","onSelect","choiceChanged","choiceRemoved","lengthChanged","extras","selectChoices","maxLength","beforeEach","updateChoicesIfNeeded","state","toEqual","objectContaining","newChoices","handleSelect","toBeCalledWith","onAddChoice","push","mockClear","onChoiceChanged","longChoice","wrapperWithHighMaxLength","not","toHaveBeenCalled","shortChoices","wrapperWithShortChoices","mixedSpecialChoice","wrapperWithLowMax"],"mappings":"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","sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\n\nimport { AlternateSection, Choice } from '../alternateSection';\n\nconst choices = [\n  { label: 'cow', value: '0' },\n  { label: 'cattle', value: '1' },\n  { label: 'calf', value: '2' },\n];\n\ndescribe('Choice', () => {\n  let onChange = jest.fn();\n  let onDelete = jest.fn();\n\n  const wrapper = () => {\n    const defaults = {\n      classes: {},\n      key: '0',\n      markup: 'cow',\n      onChange,\n      onDelete,\n    };\n    const props = { ...defaults };\n\n    return shallow(<Choice {...props} />);\n  };\n\n  describe('snapshot', () => {\n    it('renders', () => {\n      expect(wrapper()).toMatchSnapshot();\n    });\n  });\n\n  describe('logic', () => {\n    it('calls onChange', () => {\n      const w = wrapper();\n\n      w.instance().onChange({ target: { value: 'TEST' } });\n\n      setTimeout(() => {\n        expect(onChange).toHaveBeenCalledWith('TEST');\n      }, 400);\n    });\n  });\n});\n\ndescribe('AlternateSection', () => {\n  let onSelect = jest.fn();\n  let choiceChanged = jest.fn();\n  let choiceRemoved = jest.fn();\n  let lengthChanged = jest.fn();\n\n  const wrapper = (extras = {}) => {\n    const defaults = {\n      classes: {},\n      key: '0',\n      value: 'cow',\n      onSelect,\n      choiceChanged,\n      choiceRemoved,\n      lengthChanged,\n      selectChoices: [{ label: 'moon', value: '2' }],\n      choices,\n      maxLength: 10,\n      ...extras\n    };\n    const props = { ...defaults };\n\n    return shallow(<AlternateSection {...props} />);\n  };\n\n  describe('snapshot', () => {\n    it('renders', () => {\n      expect(wrapper()).toMatchSnapshot();\n    });\n  });\n\n  describe('logic', () => {\n    let w;\n\n    beforeEach(() => {\n      w = wrapper();\n    });\n\n    describe('updateChoicesIfNeeded', () => {\n      it('does not set state', () => {\n        w.instance().updateChoicesIfNeeded({ choices });\n\n        expect(w.instance().state).toEqual(expect.objectContaining({ choices }));\n      });\n\n      it('sets state, updates edited choice', () => {\n        const newChoices = [\n          { label: 'cow', value: '0' },\n          { label: 'cattle', value: '1' },\n          { label: 'little calf', value: '2' },\n        ];\n\n        w.instance().updateChoicesIfNeeded({ choices: newChoices });\n\n        expect(w.instance().state).toEqual(\n          expect.objectContaining({\n            choices: newChoices,\n          }),\n        );\n      });\n\n      it('sets state, updates adding new choice', () => {\n        const newChoices = [\n          { label: 'cow', value: '0' },\n          { label: 'cattle', value: '1' },\n          { label: 'little calf', value: '2' },\n        ];\n\n        w.instance().updateChoicesIfNeeded({ choices: newChoices });\n\n        expect(w.instance().state).toEqual(\n          expect.objectContaining({\n            choices: newChoices,\n          }),\n        );\n      });\n\n      it('sets state, updates removing choice', () => {\n        const newChoices = [\n          { label: 'cow', value: '0' },\n          { label: 'cattle', value: '1' },\n        ];\n\n        w.instance().updateChoicesIfNeeded({ choices: newChoices });\n\n        expect(w.instance().state).toEqual(\n          expect.objectContaining({\n            choices: newChoices,\n          }),\n        );\n      });\n    });\n\n    describe('handleSelect', () => {\n      it('calls onSelect', () => {\n        w.instance().handleSelect({ target: { value: '2' } });\n\n        expect(onSelect).toBeCalledWith({ label: 'moon', value: '2' });\n      });\n    });\n\n    describe('onAddChoice', () => {\n      it('adds choice', () => {\n        const state = w.instance().state;\n\n        w.instance().onAddChoice();\n\n        expect(w.instance().state.choices).toEqual([...state.choices, { value: '3', label: '' }]);\n      });\n\n      it('does not add choice if previously added choice is empty', () => {\n        const state = w.instance().state;\n\n        w.instance().onAddChoice();\n\n        state.choices.push({ value: '3', label: '' });\n\n        expect(w.instance().state.choices).toEqual(state.choices);\n\n        w.instance().onAddChoice();\n\n        expect(w.instance().state.choices).toEqual(state.choices);\n      });\n    });\n\n    describe('onChoiceChanged', () => {\n      beforeEach(() => {\n        choiceChanged.mockClear();\n        lengthChanged.mockClear();\n      });\n\n      it('calls choiceChanged', () => {\n        w.instance().onChoiceChanged({ value: '0', label: 'cow' }, 'New value');\n\n        expect(choiceChanged).toBeCalledWith({ value: '0', label: 'New value' });\n      });\n\n      it('calls lengthChanged when new max length is greater than current maxLength', () => {\n        // ['cow', 'cattle', 'calf'] - max length is 6 (cattle)\n        // maxLength prop is 10, so we need something longer than 10\n        const longChoice = 'Very long choice text'; // 21 characters\n\n        w.instance().onChoiceChanged({ value: '0', label: 'cow' }, longChoice, 0);\n\n        // 21 + 5 = 26\n        expect(lengthChanged).toHaveBeenCalledWith(26);\n      });\n\n      it('calls lengthChanged when new max length is significantly smaller', () => {\n        const wrapperWithHighMaxLength = wrapper({ maxLength: 30 });\n\n        // ['cow', 'cattle', 'calf'] - max length is 6\n        wrapperWithHighMaxLength.instance().onChoiceChanged({ value: '1', label: 'cattle' }, 'a', 1);\n\n        // max length will be 4 (max of 'cow', 'a', 'calf')\n        // Since 4 + 10 = 14 <= 30, this should trigger lengthChanged\n        expect(lengthChanged).toHaveBeenCalledWith(7); // getAdjustedLength(4) = 4 + 3 = 7\n      });\n\n      it('does not call lengthChanged when new max length is within threshold', () => {\n        // ['cow', 'cattle', 'calf'] - max length is 6\n        // maxLength is 10, change to something that keeps max around the same\n        w.instance().onChoiceChanged({ value: '0', label: 'cow' }, 'bull', 0);\n\n        // max length will still be 6 (cattle), which is not > 10 and not <= 0 (10-10)\n        expect(lengthChanged).not.toHaveBeenCalled();\n      });\n\n      it('calculates max length across all choices correctly', () => {\n        const shortChoices = [\n          { label: 'a', value: '0' },\n          { label: 'bb', value: '1' },\n          { label: 'ccc', value: '2' },\n        ];\n\n        const wrapperWithShortChoices = wrapper({\n          choices: shortChoices,\n          maxLength: 5\n        });\n\n        wrapperWithShortChoices.instance().onChoiceChanged(\n          { value: '2', label: 'ccc' },\n          'This is much longer',\n          2\n        );\n        expect(lengthChanged).toHaveBeenCalledWith(24);\n      });\n\n      it('handles mixed special characters correctly', () => {\n        lengthChanged.mockClear();\n        const mixedSpecialChoice = 'Test with & < > \" \\' symbols'; // 27 chars when decoded\n\n        const wrapperWithLowMax = wrapper({ maxLength: 5 });\n\n        wrapperWithLowMax.instance().onChoiceChanged({ value: '0', label: 'cow' }, mixedSpecialChoice, 0);\n\n        // 27 normal characters + 5 buffer = 32\n        expect(lengthChanged).toHaveBeenCalledWith(32);\n      });\n    });\n  });\n});\n"]}

package/configure/lib/__tests__/ecr-toolbar.test.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _ecrToolbar = require("../ecr-toolbar");
+
+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) { (0, _defineProperty2["default"])(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; }
+
+describe('ECRToolbar', function () {
+  var onChangeResponse = jest.fn();
+  var onToolbarDone = jest.fn();
+
+  var wrapper = function wrapper() {
+    var defaults = {
+      onChangeResponse: onChangeResponse,
+      onToolbarDone: onToolbarDone,
+      classes: {},
+      node: {
+        key: 1,
+        data: {
+          get: function get(prop) {
+            if (prop === 'index') {
+              return '2';
+            }
+
+            return 'moon';
+          },
+          toJSON: jest.fn()
+        }
+      },
+      value: {
+        change: jest.fn().mockReturnValue({
+          setNodeByKey: jest.fn().mockReturnValue({
+            moveFocusTo: jest.fn().mockReturnValue({
+              moveAnchorTo: jest.fn()
+            })
+          })
+        }),
+        document: {
+          getNextText: jest.fn().mockReturnValue({
+            key: 1
+          })
+        }
+      },
+      correctChoice: {
+        value: '0',
+        label: 'moon'
+      }
+    };
+
+    var props = _objectSpread({}, defaults);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_ecrToolbar.ECRToolbar, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      expect(wrapper()).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    it('onDone: calls onToolbarDone and onChangeResponse', function () {
+      var w = wrapper();
+      w.instance().onDone();
+      expect(onToolbarDone).toBeCalled();
+      expect(onChangeResponse).toBeCalled();
+    });
+    it('onChange', function () {
+      var w = wrapper();
+      w.instance().onRespAreaChange('test');
+      expect(w.instance().state).toEqual({
+        markup: '',
+        respAreaMarkup: 'test',
+        toolbarStyle: {}
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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