@pie-lib/editable-html-tip-tap 1.0.0

package/lib/__tests__/editor.test.js

@@ -0,0 +1,470 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _index = require("../index");
+
+var _editor = require("../editor");
+
+var _enzyme = require("enzyme");
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _utils = require("./utils");
+
+var log = (0, _debug["default"])('@pie-lib:editable-html:test');
+var value = (0, _index.htmlToValue)('hi');
+
+var resizeWindow = function resizeWindow(width, height) {
+  window.innerWidth = width;
+  window.innerHeight = height;
+  window.dispatchEvent(new Event('resize'));
+};
+
+jest.mock('@pie-lib/math-toolbar', function () {
+  return {};
+});
+jest.mock('@pie-lib/math-input', function () {
+  HorizontalKeypad: (function () {
+    return /*#__PURE__*/_react["default"].createElement("div", null, "HorizontalKeypad");
+  });
+});
+expect.extend({
+  toEqualHtml: function toEqualHtml(value, html) {
+    var v = (0, _index.valueToHtml)(value);
+    var pass = v === html;
+    return {
+      pass: pass,
+      message: function message() {
+        return "expected ".concat(html, " to match ").concat(v);
+      }
+    };
+  }
+});
+describe('logic', function () {
+  test('onFocus/onBlur saves the value', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var wrapper, v;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+              editorRef: jest.fn(),
+              value: value,
+              classes: {},
+              onChange: jest.fn(),
+              onRef: jest.fn()
+            }));
+            _context.next = 3;
+            return wrapper.instance().onFocus();
+
+          case 3:
+            v = (0, _index.htmlToValue)('hi');
+            expect(wrapper.state('stashedValue')).toEqualHtml('<div>hi</div>');
+            wrapper.instance().onChange({
+              value: (0, _index.htmlToValue)('new value')
+            });
+            expect(wrapper.state('value')).toEqualHtml('<div>new value</div>');
+            return _context.abrupt("return", wrapper.instance().onBlur({}).then(function () {
+              expect(wrapper.state('value')).toEqualHtml('<div>new value</div>');
+            }));
+
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+});
+test('onFocus does not change focus if related target is a button from language keypad', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+  var wrapper, event, change;
+  return _regenerator["default"].wrap(function _callee2$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+            editorRef: jest.fn(),
+            value: value,
+            classes: {},
+            onChange: jest.fn(),
+            onRef: jest.fn()
+          }));
+          event = {
+            relatedTarget: {
+              tagName: 'button'
+            }
+          };
+          change = {
+            focus: jest.fn()
+          };
+          wrapper.instance().keypadInteractionDetected = true;
+          _context2.next = 6;
+          return wrapper.instance().onFocus(event, change);
+
+        case 6:
+          expect(change.focus).not.toHaveBeenCalled();
+
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }
+  }, _callee2);
+})));
+test('onFocus changes focus if related target is not a button from language keypad', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+  var wrapper, event, change;
+  return _regenerator["default"].wrap(function _callee3$(_context3) {
+    while (1) {
+      switch (_context3.prev = _context3.next) {
+        case 0:
+          wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+            editorRef: jest.fn(),
+            value: value,
+            classes: {},
+            onChange: jest.fn(),
+            onRef: jest.fn()
+          }));
+          event = {
+            relatedTarget: {
+              tagName: 'div'
+            }
+          };
+          change = {
+            focus: jest.fn()
+          };
+          _context3.next = 5;
+          return wrapper.instance().onFocus(event, change);
+
+        case 5:
+          expect(change.focus).toHaveBeenCalled();
+
+        case 6:
+        case "end":
+          return _context3.stop();
+      }
+    }
+  }, _callee3);
+})));
+test('onFocus stashes the value', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+  var wrapper;
+  return _regenerator["default"].wrap(function _callee4$(_context4) {
+    while (1) {
+      switch (_context4.prev = _context4.next) {
+        case 0:
+          wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+            editorRef: jest.fn(),
+            value: value,
+            classes: {},
+            onChange: jest.fn(),
+            onRef: jest.fn()
+          }));
+          _context4.next = 3;
+          return wrapper.instance().onFocus();
+
+        case 3:
+          expect(wrapper.state('stashedValue')).toEqualHtml('<div>hi</div>');
+
+        case 4:
+        case "end":
+          return _context4.stop();
+      }
+    }
+  }, _callee4);
+})));
+test('onBlur does not set focusToolbar if related target is RawDoneButton', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+  var wrapper, toolbarElement, relatedTarget, event;
+  return _regenerator["default"].wrap(function _callee5$(_context5) {
+    while (1) {
+      switch (_context5.prev = _context5.next) {
+        case 0:
+          wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+            editorRef: jest.fn(),
+            value: value,
+            classes: {},
+            onChange: jest.fn(),
+            onRef: jest.fn()
+          }));
+          toolbarElement = document.createElement('div');
+          relatedTarget = document.createElement('button');
+          relatedTarget.className = 'RawDoneButton';
+          toolbarElement.className = 'toolbar';
+          toolbarElement.appendChild(relatedTarget);
+          wrapper.instance().toolbarRef = toolbarElement;
+          wrapper.instance().doneButtonRef.current = relatedTarget;
+          event = {
+            relatedTarget: relatedTarget
+          };
+          _context5.next = 11;
+          return wrapper.instance().onBlur(event);
+
+        case 11:
+          expect(wrapper.state('focusToolbar')).toBe(false);
+
+        case 12:
+        case "end":
+          return _context5.stop();
+      }
+    }
+  }, _callee5);
+})));
+test('handleToolbarFocus sets focusToolbar to true', function () {
+  var wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+    editorRef: jest.fn(),
+    value: value,
+    classes: {},
+    onChange: jest.fn(),
+    onRef: jest.fn()
+  }));
+  wrapper.instance().handleToolbarFocus();
+  expect(wrapper.state('focusToolbar')).toBe(true);
+});
+test('handleToolbarBlur sets focusToolbar to false if toolbar does not contain focus', function (done) {
+  var wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+    editorRef: jest.fn(),
+    value: value,
+    classes: {},
+    onChange: jest.fn(),
+    onRef: jest.fn()
+  }));
+  wrapper.instance().toolbarContainsFocus = jest.fn().mockReturnValue(false);
+  wrapper.instance().handleToolbarBlur();
+  setTimeout(function () {
+    expect(wrapper.state('focusToolbar')).toBe(false);
+    done();
+  }, 20);
+});
+test('handleToolbarBlur does not set focusToolbar to false if toolbar contains focus', function (done) {
+  var wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+    editorRef: jest.fn(),
+    value: value,
+    classes: {},
+    onChange: jest.fn(),
+    onRef: jest.fn()
+  }));
+  wrapper.instance().toolbarContainsFocus = jest.fn().mockReturnValue(true);
+  wrapper.setState({
+    focusToolbar: true
+  });
+  wrapper.instance().handleToolbarBlur();
+  setTimeout(function () {
+    expect(wrapper.state('focusToolbar')).toBe(true);
+    done();
+  }, 20);
+});
+test('toolbarContainsFocus correctly detects focus within toolbar', function () {
+  var wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+    editorRef: jest.fn(),
+    value: value,
+    classes: {},
+    onChange: jest.fn(),
+    onRef: jest.fn()
+  }));
+  var toolbarElement = document.createElement('div');
+  var activeElement = document.createElement('button');
+  toolbarElement.appendChild(activeElement);
+  Object.defineProperty(document, 'activeElement', {
+    value: activeElement,
+    configurable: true
+  });
+  wrapper.instance().toolbarRef = toolbarElement;
+  expect(wrapper.instance().toolbarContainsFocus()).toBe(true);
+  Object.defineProperty(document, 'activeElement', {
+    value: document.createElement('div'),
+    configurable: true
+  });
+  expect(wrapper.instance().toolbarContainsFocus()).toBe(false);
+});
+test('onBlur sets focusToolbar to true if related target is within toolbar', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+  var wrapper, toolbarElement, relatedTarget, event;
+  return _regenerator["default"].wrap(function _callee6$(_context6) {
+    while (1) {
+      switch (_context6.prev = _context6.next) {
+        case 0:
+          wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+            editorRef: jest.fn(),
+            value: value,
+            classes: {},
+            onChange: jest.fn(),
+            onRef: jest.fn()
+          }));
+          toolbarElement = document.createElement('div');
+          relatedTarget = document.createElement('button');
+          toolbarElement.className = 'toolbar';
+          toolbarElement.appendChild(relatedTarget);
+          wrapper.instance().toolbarRef = toolbarElement;
+          event = {
+            relatedTarget: relatedTarget
+          };
+          _context6.next = 9;
+          return wrapper.instance().onBlur(event);
+
+        case 9:
+          expect(wrapper.state('focusToolbar')).toBe(true);
+
+        case 10:
+        case "end":
+          return _context6.stop();
+      }
+    }
+  }, _callee6);
+})));
+describe('buildSizeStyle', function () {
+  var wrapper = function wrapper(extras) {
+    var props = Object.assign({}, extras);
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, (0, _extends2["default"])({
+      editorRef: jest.fn(),
+      value: value,
+      classes: {},
+      onChange: jest.fn(),
+      onRef: jest.fn()
+    }, props)));
+  };
+
+  it('builds width with px', function () {
+    var w = wrapper({
+      width: 100
+    });
+    expect(w.instance().buildSizeStyle()).toEqual({
+      width: '100px',
+      height: undefined,
+      minHeight: undefined,
+      maxHeight: undefined
+    });
+  });
+  it('returns undefined for % ', function () {
+    var w = wrapper({
+      height: '100%',
+      width: '100%'
+    });
+    expect(w.instance().buildSizeStyle()).toEqual({
+      width: undefined,
+      height: undefined,
+      minHeight: undefined,
+      maxHeight: undefined
+    });
+  });
+  it('builds height', function () {
+    var w = wrapper({
+      height: 100
+    });
+    expect(w.instance().buildSizeStyle()).toEqual({
+      width: undefined,
+      height: '100px',
+      minHeight: undefined,
+      maxHeight: undefined
+    });
+  });
+  it('builds minHeight', function () {
+    var w = wrapper({
+      minHeight: 100
+    });
+    expect(w.instance().buildSizeStyle()).toEqual({
+      width: undefined,
+      height: undefined,
+      minHeight: '100px',
+      maxHeight: undefined
+    });
+  });
+  it('builds maxHeight', function () {
+    var w = wrapper({
+      maxHeight: 100
+    });
+    expect(w.instance().buildSizeStyle()).toEqual({
+      width: undefined,
+      height: undefined,
+      minHeight: undefined,
+      maxHeight: '100px'
+    });
+  });
+  it('builds width with calc()', function () {
+    var w = wrapper({
+      width: 'calc(10em + 42px)'
+    });
+    expect(w.instance().buildSizeStyle()).toEqual({
+      width: 'calc(10em + 42px)',
+      height: undefined,
+      minHeight: undefined,
+      maxHeight: undefined
+    });
+  });
+  it('builds width with ch', function () {
+    var w = wrapper({
+      width: '9ch'
+    });
+    expect(w.instance().buildSizeStyle()).toEqual({
+      width: '9ch',
+      height: undefined,
+      minHeight: undefined,
+      maxHeight: undefined
+    });
+  });
+  it('builds', function () {
+    var w = wrapper({});
+    expect(w.instance().buildSizeStyle()).toEqual({
+      width: undefined,
+      height: undefined,
+      minHeight: undefined,
+      maxHeight: undefined
+    });
+  });
+});
+describe('onResize', function () {
+  it('should display html of current state on Resize', function () {
+    var wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+      editorRef: jest.fn(),
+      value: value,
+      classes: {},
+      onChange: jest.fn(),
+      onRef: jest.fn()
+    }));
+    resizeWindow(500, 300);
+    expect(wrapper.state('value')).toEqualHtml('<div>hi</div>');
+    wrapper.instance().onChange({
+      value: (0, _index.htmlToValue)('new value')
+    });
+    resizeWindow(1024, 768);
+    expect(wrapper.state('value')).toEqualHtml('<div>new value</div>');
+    resizeWindow(500, 300);
+    expect(wrapper.state('value')).toEqualHtml('<div>new value</div>');
+  });
+});
+describe('MathMl', function () {
+  beforeEach(function () {});
+  it('should not call runSerializationOnMarkup if mathMl props are not there', function () {
+    var runSerializationOnMarkup = jest.fn();
+    var wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+      editorRef: jest.fn(),
+      value: value,
+      classes: {},
+      onChange: jest.fn(),
+      onRef: jest.fn(),
+      runSerializationOnMarkup: runSerializationOnMarkup
+    }));
+    expect(runSerializationOnMarkup).not.toHaveBeenCalled();
+  });
+  it('should call runSerializationOnMarkup if mmlEditing or mmlOutput are true', function () {
+    var runSerializationOnMarkup = jest.fn();
+    var wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_editor.Editor, {
+      editorRef: jest.fn(),
+      value: value,
+      classes: {},
+      onChange: jest.fn(),
+      onRef: jest.fn(),
+      runSerializationOnMarkup: runSerializationOnMarkup,
+      mathMlOptions: {
+        mmlOutput: true
+      }
+    }));
+    expect(runSerializationOnMarkup).toHaveBeenCalled();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/editor.test.jsx"],"names":["log","value","resizeWindow","width","height","window","innerWidth","innerHeight","dispatchEvent","Event","jest","mock","HorizontalKeypad","expect","extend","toEqualHtml","html","v","pass","message","describe","test","wrapper","fn","instance","onFocus","state","onChange","onBlur","then","event","relatedTarget","tagName","change","focus","keypadInteractionDetected","not","toHaveBeenCalled","toolbarElement","document","createElement","className","appendChild","toolbarRef","doneButtonRef","current","toBe","handleToolbarFocus","done","toolbarContainsFocus","mockReturnValue","handleToolbarBlur","setTimeout","setState","focusToolbar","activeElement","Object","defineProperty","configurable","extras","props","assign","it","w","buildSizeStyle","toEqual","undefined","minHeight","maxHeight","beforeEach","runSerializationOnMarkup","mmlOutput"],"mappings":"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","sourcesContent":["import React from 'react';\nimport { htmlToValue, valueToHtml } from '../index';\nimport { Editor } from '../editor';\nimport { shallow, configure } from 'enzyme';\nimport debug from 'debug';\n\nimport { mockComponents } from './utils';\n\nconst log = debug('@pie-lib:editable-html:test');\n\nconst value = htmlToValue('hi');\n\nconst resizeWindow = (width, height) => {\n  window.innerWidth = width;\n  window.innerHeight = height;\n  window.dispatchEvent(new Event('resize'));\n};\njest.mock('@pie-lib/math-toolbar', () => ({}));\njest.mock('@pie-lib/math-input', () => {\n  HorizontalKeypad: () => <div>HorizontalKeypad</div>;\n});\n\nexpect.extend({\n  toEqualHtml(value, html) {\n    const v = valueToHtml(value);\n    const pass = v === html;\n\n    return {\n      pass,\n      message: () => `expected ${html} to match ${v}`,\n    };\n  },\n});\n\ndescribe('logic', () => {\n  test('onFocus/onBlur saves the value', async () => {\n    const wrapper = shallow(\n      <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n    );\n\n    await wrapper.instance().onFocus();\n\n    const v = htmlToValue('hi');\n\n    expect(wrapper.state('stashedValue')).toEqualHtml('<div>hi</div>');\n\n    wrapper.instance().onChange({ value: htmlToValue('new value') });\n\n    expect(wrapper.state('value')).toEqualHtml('<div>new value</div>');\n\n    return wrapper\n      .instance()\n      .onBlur({})\n      .then(() => {\n        expect(wrapper.state('value')).toEqualHtml('<div>new value</div>');\n      });\n  });\n});\n\ntest('onFocus does not change focus if related target is a button from language keypad', async () => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  const event = {\n    relatedTarget: {\n      tagName: 'button',\n    },\n  };\n\n  const change = {\n    focus: jest.fn(),\n  };\n\n  wrapper.instance().keypadInteractionDetected = true;\n\n  await wrapper.instance().onFocus(event, change);\n\n  expect(change.focus).not.toHaveBeenCalled();\n});\n\ntest('onFocus changes focus if related target is not a button from language keypad', async () => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  const event = {\n    relatedTarget: {\n      tagName: 'div',\n    },\n  };\n\n  const change = {\n    focus: jest.fn(),\n  };\n\n  await wrapper.instance().onFocus(event, change);\n\n  expect(change.focus).toHaveBeenCalled();\n});\n\ntest('onFocus stashes the value', async () => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  await wrapper.instance().onFocus();\n\n  expect(wrapper.state('stashedValue')).toEqualHtml('<div>hi</div>');\n});\n\ntest('onBlur does not set focusToolbar if related target is RawDoneButton', async () => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  const toolbarElement = document.createElement('div');\n  const relatedTarget = document.createElement('button');\n  relatedTarget.className = 'RawDoneButton';\n  toolbarElement.className = 'toolbar';\n  toolbarElement.appendChild(relatedTarget);\n\n  wrapper.instance().toolbarRef = toolbarElement;\n  wrapper.instance().doneButtonRef.current = relatedTarget;\n\n  const event = { relatedTarget };\n\n  await wrapper.instance().onBlur(event);\n\n  expect(wrapper.state('focusToolbar')).toBe(false);\n});\n\ntest('handleToolbarFocus sets focusToolbar to true', () => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  wrapper.instance().handleToolbarFocus();\n  expect(wrapper.state('focusToolbar')).toBe(true);\n});\n\ntest('handleToolbarBlur sets focusToolbar to false if toolbar does not contain focus', (done) => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  wrapper.instance().toolbarContainsFocus = jest.fn().mockReturnValue(false);\n\n  wrapper.instance().handleToolbarBlur();\n\n  setTimeout(() => {\n    expect(wrapper.state('focusToolbar')).toBe(false);\n    done();\n  }, 20);\n});\n\ntest('handleToolbarBlur does not set focusToolbar to false if toolbar contains focus', (done) => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  wrapper.instance().toolbarContainsFocus = jest.fn().mockReturnValue(true);\n\n  wrapper.setState({ focusToolbar: true });\n\n  wrapper.instance().handleToolbarBlur();\n\n  setTimeout(() => {\n    expect(wrapper.state('focusToolbar')).toBe(true);\n    done();\n  }, 20);\n});\n\ntest('toolbarContainsFocus correctly detects focus within toolbar', () => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  const toolbarElement = document.createElement('div');\n  const activeElement = document.createElement('button');\n  toolbarElement.appendChild(activeElement);\n\n  Object.defineProperty(document, 'activeElement', {\n    value: activeElement,\n    configurable: true,\n  });\n\n  wrapper.instance().toolbarRef = toolbarElement;\n\n  expect(wrapper.instance().toolbarContainsFocus()).toBe(true);\n\n  Object.defineProperty(document, 'activeElement', {\n    value: document.createElement('div'),\n    configurable: true,\n  });\n\n  expect(wrapper.instance().toolbarContainsFocus()).toBe(false);\n});\n\ntest('onBlur sets focusToolbar to true if related target is within toolbar', async () => {\n  const wrapper = shallow(\n    <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n  );\n\n  const toolbarElement = document.createElement('div');\n  const relatedTarget = document.createElement('button');\n  toolbarElement.className = 'toolbar';\n  toolbarElement.appendChild(relatedTarget);\n\n  wrapper.instance().toolbarRef = toolbarElement;\n\n  const event = { relatedTarget };\n\n  await wrapper.instance().onBlur(event);\n\n  expect(wrapper.state('focusToolbar')).toBe(true);\n});\n\ndescribe('buildSizeStyle', () => {\n  const wrapper = (extras) => {\n    const props = Object.assign({}, extras);\n    return shallow(\n      <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} {...props} />,\n    );\n  };\n\n  it('builds width with px', () => {\n    const w = wrapper({ width: 100 });\n    expect(w.instance().buildSizeStyle()).toEqual({\n      width: '100px',\n      height: undefined,\n      minHeight: undefined,\n      maxHeight: undefined,\n    });\n  });\n\n  it('returns undefined for % ', () => {\n    const w = wrapper({ height: '100%', width: '100%' });\n    expect(w.instance().buildSizeStyle()).toEqual({\n      width: undefined,\n      height: undefined,\n      minHeight: undefined,\n      maxHeight: undefined,\n    });\n  });\n\n  it('builds height', () => {\n    const w = wrapper({ height: 100 });\n    expect(w.instance().buildSizeStyle()).toEqual({\n      width: undefined,\n      height: '100px',\n      minHeight: undefined,\n      maxHeight: undefined,\n    });\n  });\n\n  it('builds minHeight', () => {\n    const w = wrapper({ minHeight: 100 });\n    expect(w.instance().buildSizeStyle()).toEqual({\n      width: undefined,\n      height: undefined,\n      minHeight: '100px',\n      maxHeight: undefined,\n    });\n  });\n\n  it('builds maxHeight', () => {\n    const w = wrapper({ maxHeight: 100 });\n    expect(w.instance().buildSizeStyle()).toEqual({\n      width: undefined,\n      height: undefined,\n      minHeight: undefined,\n      maxHeight: '100px',\n    });\n  });\n\n  it('builds width with calc()', () => {\n    const w = wrapper({ width: 'calc(10em + 42px)' });\n    expect(w.instance().buildSizeStyle()).toEqual({\n      width: 'calc(10em + 42px)',\n      height: undefined,\n      minHeight: undefined,\n      maxHeight: undefined,\n    });\n  });\n\n  it('builds width with ch', () => {\n    const w = wrapper({ width: '9ch' });\n    expect(w.instance().buildSizeStyle()).toEqual({\n      width: '9ch',\n      height: undefined,\n      minHeight: undefined,\n      maxHeight: undefined,\n    });\n  });\n\n  it('builds', () => {\n    const w = wrapper({});\n    expect(w.instance().buildSizeStyle()).toEqual({\n      width: undefined,\n      height: undefined,\n      minHeight: undefined,\n      maxHeight: undefined,\n    });\n  });\n});\n\ndescribe('onResize', () => {\n  it('should display html of current state on Resize', () => {\n    const wrapper = shallow(\n      <Editor editorRef={jest.fn()} value={value} classes={{}} onChange={jest.fn()} onRef={jest.fn()} />,\n    );\n\n    resizeWindow(500, 300);\n    expect(wrapper.state('value')).toEqualHtml('<div>hi</div>');\n\n    wrapper.instance().onChange({ value: htmlToValue('new value') });\n    resizeWindow(1024, 768);\n    expect(wrapper.state('value')).toEqualHtml('<div>new value</div>');\n\n    resizeWindow(500, 300);\n    expect(wrapper.state('value')).toEqualHtml('<div>new value</div>');\n  });\n});\n\ndescribe('MathMl', () => {\n  beforeEach(() => {});\n\n  it('should not call runSerializationOnMarkup if mathMl props are not there', () => {\n    const runSerializationOnMarkup = jest.fn();\n\n    const wrapper = shallow(\n      <Editor\n        editorRef={jest.fn()}\n        value={value}\n        classes={{}}\n        onChange={jest.fn()}\n        onRef={jest.fn()}\n        runSerializationOnMarkup={runSerializationOnMarkup}\n      />,\n    );\n\n    expect(runSerializationOnMarkup).not.toHaveBeenCalled();\n  });\n\n  it('should call runSerializationOnMarkup if mmlEditing or mmlOutput are true', () => {\n    const runSerializationOnMarkup = jest.fn();\n\n    const wrapper = shallow(\n      <Editor\n        editorRef={jest.fn()}\n        value={value}\n        classes={{}}\n        onChange={jest.fn()}\n        onRef={jest.fn()}\n        runSerializationOnMarkup={runSerializationOnMarkup}\n        mathMlOptions={{ mmlOutput: true }}\n      />,\n    );\n\n    expect(runSerializationOnMarkup).toHaveBeenCalled();\n  });\n});\n"]}