@pie-element/explicit-constructed-response 9.3.2-tip-tap.11 → 9.3.2-tip-tap.12

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

@@ -0,0 +1,320 @@
+"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 _main = require("../main");
+
+var _defaults = _interopRequireDefault(require("../defaults"));
+
+var _markupUtils = require("../markupUtils");
+
+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; }
+
+jest.mock('@pie-lib/config-ui', function () {
+  return {
+    choiceUtils: {
+      firstAvailableIndex: jest.fn()
+    },
+    settings: {
+      Panel: function Panel(props) {
+        return /*#__PURE__*/_react["default"].createElement("div", props);
+      },
+      toggle: jest.fn(),
+      radio: jest.fn(),
+      dropdown: jest.fn()
+    },
+    layout: {
+      ConfigLayout: function ConfigLayout(props) {
+        return /*#__PURE__*/_react["default"].createElement("div", null, props.children);
+      }
+    },
+    InputContainer: function InputContainer(props) {
+      return /*#__PURE__*/_react["default"].createElement("div", null, props.children);
+    }
+  };
+});
+var model = {
+  markup: '<p>The {{0}} jumped {{1}} the {{2}}</p>',
+  disabled: false,
+  choices: {
+    0: [{
+      label: 'cow',
+      value: '0'
+    }, {
+      label: 'cattle',
+      value: '1'
+    }, {
+      label: 'calf',
+      value: '2'
+    }],
+    1: [{
+      label: 'over',
+      value: '0'
+    }, {
+      label: 'past',
+      value: '1'
+    }, {
+      label: 'beyond',
+      value: '2'
+    }],
+    2: [{
+      label: 'moon',
+      value: '0'
+    }]
+  },
+  maxLengthPerChoice: [6, 6, 4],
+  prompt: 'Complete the sentence'
+};
+
+var prepareModel = function prepareModel() {
+  var model = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  var joinedObj = _objectSpread(_objectSpread({}, _defaults["default"].model), model);
+
+  var slateMarkup = joinedObj.slateMarkup || (0, _markupUtils.createSlateMarkup)(joinedObj.markup, joinedObj.choices);
+  var processedMarkup = (0, _markupUtils.processMarkup)(slateMarkup);
+  return _objectSpread(_objectSpread({}, joinedObj), {}, {
+    slateMarkup: slateMarkup,
+    markup: processedMarkup
+  });
+};
+
+describe('Main', function () {
+  var onModelChanged = jest.fn();
+  var onConfigurationChanged = jest.fn();
+
+  var wrapper = function wrapper(extras) {
+    var defaults = {
+      onModelChanged: onModelChanged,
+      onConfigurationChanged: onConfigurationChanged,
+      classes: {},
+      model: prepareModel(_objectSpread(_objectSpread({}, model), extras)),
+      configuration: _defaults["default"].configuration
+    };
+
+    var props = _objectSpread({}, defaults);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_main.Main, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders with teacher instructions, prompt and rationale even if not set', function () {
+      expect(wrapper()).toMatchSnapshot();
+    });
+    it('renders without teacher instructions, prompt and rationale', function () {
+      expect(wrapper({
+        promptEnabled: false,
+        teacherInstructionsEnabled: false,
+        rationaleEnabled: false
+      })).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    var w;
+    beforeEach(function () {
+      w = wrapper();
+    });
+    describe('onModelChange', function () {
+      it('changes the model', function () {
+        w.instance().onModelChange({
+          promptEnabled: false
+        });
+        expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+          promptEnabled: false
+        }));
+      });
+    });
+    describe('onPromptChanged', function () {
+      it('changes the prompt value', function () {
+        w.instance().onPromptChanged('This is the new prompt');
+        expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+          prompt: 'This is the new prompt'
+        }));
+      });
+    });
+    describe('onRationaleChanged', function () {
+      it('changes the rationale value', function () {
+        w.instance().onRationaleChanged('New Rationale');
+        expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+          rationale: 'New Rationale'
+        }));
+      });
+    });
+    describe('onTeacherInstructionsChanged', function () {
+      it('changes the teacher instructions value', function () {
+        w.instance().onTeacherInstructionsChanged('New Teacher Instructions');
+        expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+          teacherInstructions: 'New Teacher Instructions'
+        }));
+      });
+    });
+    describe('onMarkupChanged', function () {
+      it('changes slate markup value', function () {
+        var slateMarkup = '<p>The <span data-type=\\"explicit_constructed_response\\" data-index=\\"0\\" data-value=\\"cow\\"></span> jumped</p>';
+        w.instance().onMarkupChanged(slateMarkup);
+        expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+          slateMarkup: slateMarkup
+        }));
+      });
+    });
+    describe('onResponsesChanged', function () {
+      it('changes choices and slateMarkup as well', function () {
+        var newChoices = {
+          0: [{
+            label: 'cow',
+            value: '0'
+          }, {
+            label: 'cattle',
+            value: '1'
+          }, {
+            label: 'calf',
+            value: '2'
+          }],
+          1: [{
+            label: 'over',
+            value: '0'
+          }, {
+            label: 'past',
+            value: '1'
+          }, {
+            label: 'beyond',
+            value: '2'
+          }],
+          2: [{
+            label: 'sun',
+            value: '0'
+          }]
+        };
+        w.instance().onResponsesChanged(newChoices);
+        expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+          choices: newChoices
+        }));
+      });
+    });
+    describe('onChangeResponse', function () {
+      it('with new area', function () {
+        var wr = wrapper();
+        wr.instance().onChangeResponse(3);
+        expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+          choices: _objectSpread(_objectSpread({}, model.choices), {}, {
+            3: [{
+              label: '',
+              value: '0'
+            }]
+          })
+        }));
+      });
+      it('with existing area', function () {
+        var wr = wrapper();
+        wr.instance().onChangeResponse(1, 'under');
+        expect(onModelChanged).toBeCalledWith(expect.objectContaining({
+          choices: expect.objectContaining({
+            1: [{
+              label: 'under',
+              value: '0'
+            }, {
+              label: 'past',
+              value: '1'
+            }, {
+              label: 'beyond',
+              value: '2'
+            }]
+          })
+        }));
+      });
+    });
+    describe('onChange', function () {
+      var wr;
+      beforeEach(function () {
+        wr = wrapper({
+          choices: {
+            0: [{
+              label: 'cow',
+              value: '0'
+            }, {
+              label: 'cattle',
+              value: '1'
+            }, {
+              label: 'calf',
+              value: '2'
+            }],
+            1: [{
+              label: 'over',
+              value: '0'
+            }, {
+              label: 'past',
+              value: '1'
+            }, {
+              label: 'beyond',
+              value: '2'
+            }],
+            2: [{
+              label: 'moon',
+              value: '0'
+            }]
+          }
+        });
+      });
+      it('slateMarkup and choices are updated', function () {
+        var newMarkup = "<p>The <span data-type=\"explicit_constructed_response\" data-index=\"0\" data-value=\"cow\"></span> jumped <span data-type=\"explicit_constructed_response\" data-index=\"1\" data-value=\"over\"></span> the <span data-type=\"explicit_constructed_response\" data-index=\"2\" data-value=\"moon\"></span>and <span data-type=\"explicit_constructed_response\" data-index=\"3\"></span></p>";
+        wr.instance().onChange(newMarkup);
+        setTimeout(function () {
+          return expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+            slateMarkup: newMarkup,
+            choices: expect.objectContaining({
+              3: [{
+                label: '',
+                value: '0'
+              }]
+            })
+          }));
+        }, 10);
+      });
+      it('slateMarkup and choices are updated', function () {
+        var newMarkup = "<p>The <span data-type=\"explicit_constructed_response\" data-index=\"0\" data-value=\"cow\"></span> jumped <span data-type=\"explicit_constructed_response\" data-index=\"1\" data-value=\"over\"></span> the <span data-type=\"explicit_constructed_response\" data-index=\"2\" data-value=\"moon\"></span>and <span data-type=\"explicit_constructed_response\" data-index=\"3\" data-value=\"test\"></span></p>";
+        wr.instance().onChange(newMarkup);
+        setTimeout(function () {
+          return expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+            slateMarkup: newMarkup,
+            choices: expect.objectContaining({
+              3: [{
+                label: 'test',
+                value: '0'
+              }]
+            })
+          }));
+        }, 10);
+      });
+      it('slateMarkup and choices are updated', function () {
+        var newMarkup = "<p>The <span data-type=\"explicit_constructed_response\" data-index=\"0\" data-value=\"rabbit\"></span> jumped <span data-type=\"explicit_constructed_response\" data-index=\"1\" data-value=\"over\"></span> the <span data-type=\"explicit_constructed_response\" data-index=\"2\" data-value=\"moon\"></span>and <span data-type=\"explicit_constructed_response\" data-index=\"3\" data-value=\"test\"></span></p>";
+        wr.instance().onChange(newMarkup);
+        setTimeout(function () {
+          return expect(onModelChanged).toBeCalledWith(_objectSpread(_objectSpread({}, prepareModel(model)), {}, {
+            slateMarkup: newMarkup,
+            choices: expect.objectContaining({
+              0: [{
+                label: 'rabbit',
+                value: '0'
+              }, {
+                label: 'cattle',
+                value: '1'
+              }, {
+                label: 'calf',
+                value: '2'
+              }]
+            })
+          }));
+        }, 10);
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/main.test.jsx"],"names":["jest","mock","choiceUtils","firstAvailableIndex","fn","settings","Panel","props","toggle","radio","dropdown","layout","ConfigLayout","children","InputContainer","model","markup","disabled","choices","label","value","maxLengthPerChoice","prompt","prepareModel","joinedObj","sensibleDefaults","slateMarkup","processedMarkup","describe","onModelChanged","onConfigurationChanged","wrapper","extras","defaults","classes","configuration","it","expect","toMatchSnapshot","promptEnabled","teacherInstructionsEnabled","rationaleEnabled","w","beforeEach","instance","onModelChange","toBeCalledWith","onPromptChanged","onRationaleChanged","rationale","onTeacherInstructionsChanged","teacherInstructions","onMarkupChanged","newChoices","onResponsesChanged","wr","onChangeResponse","objectContaining","newMarkup","onChange","setTimeout"],"mappings":"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","sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\n\nimport { Main } from '../main';\nimport sensibleDefaults from '../defaults';\nimport { createSlateMarkup, processMarkup } from '../markupUtils';\n\njest.mock('@pie-lib/config-ui', () => ({\n  choiceUtils: {\n    firstAvailableIndex: jest.fn(),\n  },\n  settings: {\n    Panel: (props) => <div {...props} />,\n    toggle: jest.fn(),\n    radio: jest.fn(),\n    dropdown: jest.fn(),\n  },\n  layout: {\n    ConfigLayout: (props) => <div>{props.children}</div>,\n  },\n  InputContainer: (props) => <div>{props.children}</div>,\n}));\n\nconst model = {\n  markup: '<p>The {{0}} jumped {{1}} the {{2}}</p>',\n  disabled: false,\n  choices: {\n    0: [\n      { label: 'cow', value: '0' },\n      { label: 'cattle', value: '1' },\n      { label: 'calf', value: '2' },\n    ],\n    1: [\n      { label: 'over', value: '0' },\n      { label: 'past', value: '1' },\n      { label: 'beyond', value: '2' },\n    ],\n    2: [{ label: 'moon', value: '0' }],\n  },\n  maxLengthPerChoice: [6, 6, 4],\n  prompt: 'Complete the sentence',\n};\n\nconst prepareModel = (model = {}) => {\n  const joinedObj = {\n    ...sensibleDefaults.model,\n    ...model,\n  };\n  const slateMarkup = joinedObj.slateMarkup || createSlateMarkup(joinedObj.markup, joinedObj.choices);\n  const processedMarkup = processMarkup(slateMarkup);\n\n  return {\n    ...joinedObj,\n    slateMarkup,\n    markup: processedMarkup,\n  };\n};\n\ndescribe('Main', () => {\n  let onModelChanged = jest.fn();\n  let onConfigurationChanged = jest.fn();\n\n  const wrapper = (extras) => {\n    const defaults = {\n      onModelChanged,\n      onConfigurationChanged,\n      classes: {},\n      model: prepareModel({\n        ...model,\n        ...extras,\n      }),\n      configuration: sensibleDefaults.configuration,\n    };\n    const props = { ...defaults };\n\n    return shallow(<Main {...props} />);\n  };\n\n  describe('snapshot', () => {\n    it('renders with teacher instructions, prompt and rationale even if not set', () => {\n      expect(wrapper()).toMatchSnapshot();\n    });\n\n    it('renders without teacher instructions, prompt and rationale', () => {\n      expect(\n        wrapper({\n          promptEnabled: false,\n          teacherInstructionsEnabled: false,\n          rationaleEnabled: false,\n        }),\n      ).toMatchSnapshot();\n    });\n  });\n\n  describe('logic', () => {\n    let w;\n\n    beforeEach(() => {\n      w = wrapper();\n    });\n\n    describe('onModelChange', () => {\n      it('changes the model', () => {\n        w.instance().onModelChange({ promptEnabled: false });\n\n        expect(onModelChanged).toBeCalledWith({\n          ...prepareModel(model),\n          promptEnabled: false,\n        });\n      });\n    });\n\n    describe('onPromptChanged', () => {\n      it('changes the prompt value', () => {\n        w.instance().onPromptChanged('This is the new prompt');\n\n        expect(onModelChanged).toBeCalledWith({\n          ...prepareModel(model),\n          prompt: 'This is the new prompt',\n        });\n      });\n    });\n\n    describe('onRationaleChanged', () => {\n      it('changes the rationale value', () => {\n        w.instance().onRationaleChanged('New Rationale');\n\n        expect(onModelChanged).toBeCalledWith({\n          ...prepareModel(model),\n          rationale: 'New Rationale',\n        });\n      });\n    });\n\n    describe('onTeacherInstructionsChanged', () => {\n      it('changes the teacher instructions value', () => {\n        w.instance().onTeacherInstructionsChanged('New Teacher Instructions');\n\n        expect(onModelChanged).toBeCalledWith({\n          ...prepareModel(model),\n          teacherInstructions: 'New Teacher Instructions',\n        });\n      });\n    });\n\n    describe('onMarkupChanged', () => {\n      it('changes slate markup value', () => {\n        const slateMarkup =\n          '<p>The <span data-type=\\\\\"explicit_constructed_response\\\\\" data-index=\\\\\"0\\\\\" data-value=\\\\\"cow\\\\\"></span> jumped</p>';\n\n        w.instance().onMarkupChanged(slateMarkup);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...prepareModel(model),\n          slateMarkup,\n        });\n      });\n    });\n\n    describe('onResponsesChanged', () => {\n      it('changes choices and slateMarkup as well', () => {\n        const newChoices = {\n          0: [\n            { label: 'cow', value: '0' },\n            { label: 'cattle', value: '1' },\n            { label: 'calf', value: '2' },\n          ],\n          1: [\n            { label: 'over', value: '0' },\n            { label: 'past', value: '1' },\n            { label: 'beyond', value: '2' },\n          ],\n          2: [{ label: 'sun', value: '0' }],\n        };\n\n        w.instance().onResponsesChanged(newChoices);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...prepareModel(model),\n          choices: newChoices,\n        });\n      });\n    });\n\n    describe('onChangeResponse', () => {\n      it('with new area', () => {\n        const wr = wrapper();\n\n        wr.instance().onChangeResponse(3);\n\n        expect(onModelChanged).toBeCalledWith({\n          ...prepareModel(model),\n          choices: {\n            ...model.choices,\n            3: [{ label: '', value: '0' }],\n          },\n        });\n      });\n\n      it('with existing area', () => {\n        const wr = wrapper();\n\n        wr.instance().onChangeResponse(1, 'under');\n\n        expect(onModelChanged).toBeCalledWith(\n          expect.objectContaining({\n            choices: expect.objectContaining({\n              1: [\n                { label: 'under', value: '0' },\n                { label: 'past', value: '1' },\n                { label: 'beyond', value: '2' },\n              ],\n            }),\n          }),\n        );\n      });\n    });\n\n    describe('onChange', () => {\n      let wr;\n\n      beforeEach(() => {\n        wr = wrapper({\n          choices: {\n            0: [\n              { label: 'cow', value: '0' },\n              { label: 'cattle', value: '1' },\n              { label: 'calf', value: '2' },\n            ],\n            1: [\n              { label: 'over', value: '0' },\n              { label: 'past', value: '1' },\n              { label: 'beyond', value: '2' },\n            ],\n            2: [{ label: 'moon', value: '0' }],\n          },\n        });\n      });\n\n      it('slateMarkup and choices are updated', () => {\n        const newMarkup = `<p>The <span data-type=\"explicit_constructed_response\" data-index=\"0\" data-value=\"cow\"></span> jumped <span data-type=\"explicit_constructed_response\" data-index=\"1\" data-value=\"over\"></span> the <span data-type=\"explicit_constructed_response\" data-index=\"2\" data-value=\"moon\"></span>and <span data-type=\"explicit_constructed_response\" data-index=\"3\"></span></p>`;\n\n        wr.instance().onChange(newMarkup);\n\n        setTimeout(\n          () =>\n            expect(onModelChanged).toBeCalledWith({\n              ...prepareModel(model),\n              slateMarkup: newMarkup,\n              choices: expect.objectContaining({\n                3: [{ label: '', value: '0' }],\n              }),\n            }),\n          10,\n        );\n      });\n\n      it('slateMarkup and choices are updated', () => {\n        const newMarkup = `<p>The <span data-type=\"explicit_constructed_response\" data-index=\"0\" data-value=\"cow\"></span> jumped <span data-type=\"explicit_constructed_response\" data-index=\"1\" data-value=\"over\"></span> the <span data-type=\"explicit_constructed_response\" data-index=\"2\" data-value=\"moon\"></span>and <span data-type=\"explicit_constructed_response\" data-index=\"3\" data-value=\"test\"></span></p>`;\n        wr.instance().onChange(newMarkup);\n\n        setTimeout(\n          () =>\n            expect(onModelChanged).toBeCalledWith({\n              ...prepareModel(model),\n              slateMarkup: newMarkup,\n              choices: expect.objectContaining({\n                3: [{ label: 'test', value: '0' }],\n              }),\n            }),\n          10,\n        );\n      });\n\n      it('slateMarkup and choices are updated', () => {\n        const newMarkup = `<p>The <span data-type=\"explicit_constructed_response\" data-index=\"0\" data-value=\"rabbit\"></span> jumped <span data-type=\"explicit_constructed_response\" data-index=\"1\" data-value=\"over\"></span> the <span data-type=\"explicit_constructed_response\" data-index=\"2\" data-value=\"moon\"></span>and <span data-type=\"explicit_constructed_response\" data-index=\"3\" data-value=\"test\"></span></p>`;\n\n        wr.instance().onChange(newMarkup);\n\n        setTimeout(\n          () =>\n            expect(onModelChanged).toBeCalledWith({\n              ...prepareModel(model),\n              slateMarkup: newMarkup,\n              choices: expect.objectContaining({\n                0: [\n                  { label: 'rabbit', value: '0' },\n                  { label: 'cattle', value: '1' },\n                  { label: 'calf', value: '2' },\n                ],\n              }),\n            }),\n          10,\n        );\n      });\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,56 @@
+"use strict";
+
+var _markupUtils = require("../markupUtils");
+
+describe('markupUtils', function () {
+  describe('removeUnwantedCharacters', function () {
+    it('should remove \\t and \\n characters', function () {
+      expect((0, _markupUtils.removeUnwantedCharacters)('<div>foo\t\nbar</div>')).toEqual('<div>foobar</div>');
+    });
+    it('should remove \\t and \\n characters', function () {
+      expect((0, _markupUtils.removeUnwantedCharacters)('<div>foo\\t\\nbar</div>')).toEqual('<div>foobar</div>');
+    });
+    it('should replace \\" with "', function () {
+      expect((0, _markupUtils.removeUnwantedCharacters)('<div>"foo bar"</div>')).toEqual('<div>"foo bar"</div>');
+    });
+    it('should replace \\/ with /', function () {
+      expect((0, _markupUtils.removeUnwantedCharacters)('<div>foo/bar</div>')).toEqual('<div>foo/bar</div>');
+    });
+    it('should not remove \\t character which has latex like \\times', function () {
+      expect((0, _markupUtils.removeUnwantedCharacters)('<div><span data-latex="" data-raw="3\\times3\\div2">3\\times3\\div2</span></div>')).toEqual('<div><span data-latex="" data-raw="3\\times3\\div2">3\\times3\\div2</span></div>');
+    });
+  });
+  describe('processMarkup', function () {
+    it('should process slate markup and replace {{number}} with a ecr element dom', function () {
+      var markup = ['<div>', '<span data-type="explicit_constructed_response"></span>', '<span data-type="explicit_constructed_response"></span>', '</div>'].join('');
+      var processed = (0, _markupUtils.processMarkup)(markup);
+      expect(processed).toEqual(['<div>', '{{0}}', '{{1}}', '</div>'].join(''));
+    });
+  });
+  describe('createSlateMarkup', function () {
+    it('should handle the case when markup is empty', function () {
+      expect((0, _markupUtils.createSlateMarkup)('', {})).toEqual('');
+    });
+    it('should replace {{number}} with the appropriate element', function () {
+      var markup = ['<div>', '{{0}}', '</div>'].join('');
+      var choices = {
+        0: [{
+          label: 'foobar'
+        }]
+      };
+      var slateMarkup = (0, _markupUtils.createSlateMarkup)(markup, choices);
+      expect(slateMarkup).toEqual(['<div>', '<span data-type="explicit_constructed_response" data-index="0" data-value="foobar"></span>', '</div>'].join(''));
+    });
+    it('should replace {{number}} with the appropriate element having the value escaped', function () {
+      var markup = ['<div>', '{{0}}', '</div>'].join('');
+      var choices = {
+        0: [{
+          label: 'foo&bar'
+        }]
+      };
+      var slateMarkup = (0, _markupUtils.createSlateMarkup)(markup, choices);
+      expect(slateMarkup).toEqual(['<div>', '<span data-type="explicit_constructed_response" data-index="0" data-value="foo&amp;bar"></span>', '</div>'].join(''));
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,66 @@
+"use strict";
+
+var _markupUtils = require("../markupUtils");
+
+describe('processMarkup', function () {
+  var assertProcessMarkup = function assertProcessMarkup(markup, expected, should) {
+    it(should || "returns processed markup: ".concat(expected), function () {
+      expect((0, _markupUtils.processMarkup)(markup)).toEqual(expected);
+    });
+  };
+
+  assertProcessMarkup('<p>The <span data-type="explicit_constructed_response" data-index="0" data-value="cow"></span> jumped <span data-type="explicit_constructed_response" data-index="1" data-value="over"></span> the <span data-type="explicit_constructed_response" data-index="2" data-value="moon"></span></p>', '<p>The {{0}} jumped {{1}} the {{2}}</p>');
+  assertProcessMarkup('<p>This is a <span data-type="explicit_constructed_response" data-index="0" data-value="test"></span>.</p>', '<p>This is a {{0}}.</p>');
+  assertProcessMarkup('<p>This is another test.</p>', '<p>This is another test.</p>');
+  assertProcessMarkup('', '');
+  assertProcessMarkup(undefined, '');
+  assertProcessMarkup(null, '');
+  assertProcessMarkup('<div> \\tfoo\\nbar </div>', '<div> foobar </div>', 'should remove \t, \n from the string');
+  assertProcessMarkup('<div> "foobar" </div>', '<div> "foobar" </div>', 'should replace " with " in the string');
+  assertProcessMarkup('<div> /foobar </div>', '<div> /foobar </div>', 'should replace / with / in the string');
+});
+describe('createSlateMarkup', function () {
+  var choices = {
+    0: [{
+      label: 'cow',
+      value: '0'
+    }, {
+      label: 'cattle',
+      value: '1'
+    }, {
+      label: 'calf',
+      value: '2'
+    }],
+    1: [{
+      label: 'over',
+      value: '0'
+    }, {
+      label: 'past',
+      value: '1'
+    }, {
+      label: 'beyond',
+      value: '2'
+    }],
+    2: [{
+      label: 'moon',
+      value: '0'
+    }]
+  };
+
+  var assertCreateSlateMarkup = function assertCreateSlateMarkup(markup, expected, should) {
+    it(should || "returns slate markup: ".concat(expected), function () {
+      expect((0, _markupUtils.createSlateMarkup)(markup, choices)).toEqual(expected);
+    });
+  };
+
+  assertCreateSlateMarkup('<p>The {{0}} jumped {{1}} the {{2}}</p>', '<p>The <span data-type="explicit_constructed_response" data-index="0" data-value="cow"></span> jumped <span data-type="explicit_constructed_response" data-index="1" data-value="over"></span> the <span data-type="explicit_constructed_response" data-index="2" data-value="moon"></span></p>');
+  assertCreateSlateMarkup('<p>This is a {{0}}.</p>', '<p>This is a <span data-type="explicit_constructed_response" data-index="0" data-value="cow"></span>.</p>');
+  assertCreateSlateMarkup('<p>This is another test.</p>', '<p>This is another test.</p>');
+  assertCreateSlateMarkup('', '');
+  assertCreateSlateMarkup(undefined, '');
+  assertCreateSlateMarkup(null, '');
+  assertCreateSlateMarkup('<div> \\tfoo\\nbar </div>', '<div> foobar </div>', 'should remove \t, \n from the string');
+  assertCreateSlateMarkup('<div> "foobar" </div>', '<div> "foobar" </div>', 'should replace " with " in the string');
+  assertCreateSlateMarkup('<div> /foobar </div>', '<div> /foobar </div>', 'should replace / with / in the string');
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/configure/package.json

@@ -8,8 +8,8 @@
     "@material-ui/core": "^3.9.2",
     "@material-ui/icons": "^3.0.1",
     "@pie-framework/pie-configure-events": "^1.3.0",
-    "@pie-lib/config-ui": "11.30.2-beta-12",
-    "@pie-lib/editable-html-tip-tap": "^1.0.18",
+    "@pie-lib/config-ui": "11.30.2-beta-13",
+    "@pie-lib/editable-html-tip-tap": "^1.0.19",
     "@pie-lib/math-toolbar": "1.31.2-beta.3",
     "classnames": "^2.2.6",
     "debug": "^3.1.0",

package/controller/lib/__tests__/index.spec.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _index = require("../index");
+
+var choice = function choice(l, v) {
+  return {
+    label: l,
+    value: v
+  };
+};
+
+var d = {
+  prompt: '',
+  teacherInstructions: true,
+  studentInstructions: false,
+  choices: {
+    0: [choice('A', '0'), choice('B', '1')]
+  },
+  markup: '<p>\n  <strong>Esta cuadrícula de coordenadas representa el diseño del salón de matemáticas de Valerie. Cada unidad en la cuadricula representa 1 pie cuadrado.&nbsp;</strong>\n</p>\n<p>\n  <strong>* El escritorio de Valeria se encuentra en (-3,-4)</strong>\n</p>\n<p>\n  <strong>* El escritorio de la maestra se encuentra en (5,-4)</strong>\n</p>\n<p>\n  <strong>* El cuarto de materiales se encuentra&nbsp; en (-3,-7)</strong>\n</p>\n<p>\n  <strong><img src="https://storage.googleapis.com/pie-staging-221718-assets/image/180d28b2-0376-428e-b415-de96e158b7e7" alt=""></strong>\n</p>\n<p>\n  &nbsp;\n</p>\n<p>\n  <strong>Anota la distancia, en pies, desde el escritorio de Valerie al cuarto de materiales.</strong>\n</p>\n<p>\n  {{0}} <strong>pies</strong>\n</p>',
+  id: '2422330',
+  rubric: '',
+  element: 'explicit-constructed-response-element',
+  autoScoring: 'partial',
+  rationale: ''
+};
+describe('edge cases', function () {
+  it('does not throw an error if the session has no value', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var result;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            result = (0, _index.model)(d, {}, {
+              mode: 'evaluate'
+            });
+            expect(result).toBeDefined();
+
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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