@pie-element/drawing-response 10.0.1 → 10.2.0-mui-update.0

package/lib/drawing-response/__tests__/drawing-main.test.js

@@ -0,0 +1,684 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _enzyme = require("enzyme");
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+var _drawableFreePath = _interopRequireDefault(require("../drawable-free-path"));
+var _drawableLine = _interopRequireDefault(require("../drawable-line"));
+var _drawableRectangle = _interopRequireDefault(require("../drawable-rectangle"));
+var _drawableCircle = _interopRequireDefault(require("../drawable-circle"));
+var _drawableEraser = _interopRequireDefault(require("../drawable-eraser"));
+var _drawableText = _interopRequireDefault(require("../drawable-text"));
+var _drawableMain = require("../drawable-main");
+const drawableClasses = {
+  FreePathDrawable: _drawableFreePath.default,
+  LineDrawable: _drawableLine.default,
+  RectangleDrawable: _drawableRectangle.default,
+  CircleDrawable: _drawableCircle.default,
+  EraserDrawable: _drawableEraser.default,
+  DrawableText: _drawableText.default
+};
+describe('DrawingResponse', () => {
+  let element;
+  let wrapper;
+  const mkWrapper = (type, props, WrapperEl) => {
+    element = new drawableClasses[type](props);
+    let content = element.render(props);
+    if (WrapperEl) {
+      content = /*#__PURE__*/_react.default.createElement(WrapperEl, null, content);
+    }
+    return (0, _enzyme.shallow)(content);
+  };
+  describe('DrawableMain', () => {
+    let onSessionChange = jest.fn();
+    const TextEntry = new _drawableText.default();
+    const wrapperMain = (extras, renderOpts) => {
+      const defaults = {
+        classes: {},
+        disabled: false,
+        className: 'className',
+        onSessionChange,
+        imageDimensions: {},
+        imageUrl: 'url',
+        drawableDimensions: {
+          height: 350,
+          width: 353
+        },
+        fillColor: 'white',
+        outlineColor: 'black',
+        paintColor: 'red',
+        session: {},
+        toolActive: {
+          type: 'Select',
+          label: 'Select',
+          icon: 'mdiCursorDefault'
+        },
+        TextEntry
+      };
+      const props = {
+        ...defaults,
+        ...extras
+      };
+      return (0, _enzyme.shallow)(/*#__PURE__*/_react.default.createElement(_drawableMain.DrawableMain, props), {
+        ...renderOpts
+      });
+    };
+    describe('snapshot', () => {
+      it('renders', () => {
+        const w = wrapperMain();
+        expect(w).toMatchSnapshot();
+      });
+      it('renders disabled', () => {
+        const w = wrapperMain({
+          disabled: true
+        });
+        expect(w).toMatchSnapshot();
+      });
+    });
+    describe('logic', () => {
+      const handleSessionChange = jest.fn();
+      const forceUpdate = jest.fn();
+      const props = {
+        handleSessionChange,
+        forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        x: 300,
+        y: 300,
+        createdAt: new Date()
+      };
+      it('handleUndo', () => {
+        const w = wrapperMain();
+        w.setState({
+          drawables: [new _drawableRectangle.default(props), new _drawableRectangle.default(props)]
+        });
+        w.instance().handleUndo();
+        expect(w.state('drawables').length).toEqual(1);
+        w.instance().handleUndo();
+        expect(w.state('drawables')).toEqual([]);
+      });
+      it('handleClearAll', () => {
+        const w = wrapperMain();
+        w.setState({
+          drawables: [new _drawableRectangle.default(props), new _drawableRectangle.default(props)]
+        });
+        w.instance().handleClearAll();
+        expect(w.state('drawables')).toEqual([]);
+      });
+    });
+  });
+  describe('CircleDrawable', () => {
+    let handleSessionChange = jest.fn();
+    let forceUpdate = jest.fn();
+    let props;
+    beforeEach(() => {
+      props = {
+        handleSessionChange,
+        forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        x: 300,
+        y: 200,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('CircleDrawable', props);
+    });
+    describe('snapshot', () => {
+      it('renders', () => {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', () => {
+      it('calls forceUpdate', () => {
+        wrapper.simulate('click');
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      it('changes x and y', () => {
+        element.registerMovement(400, 400);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(400);
+      });
+      it('changes session when needed', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes startx and starty', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.startx).toEqual(300);
+        expect(element.starty).toEqual(300);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(300);
+      });
+    });
+  });
+  describe('EraserDrawable', () => {
+    let handleSessionChange = jest.fn();
+    let forceUpdate = jest.fn();
+    let props;
+    beforeEach(() => {
+      props = {
+        handleSessionChange,
+        forceUpdate,
+        points: [200, 200, 300, 300],
+        posX: 200,
+        posY: 200,
+        startx: 200,
+        starty: 200,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('EraserDrawable', props);
+    });
+    describe('snapshot', () => {
+      it('renders', () => {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', () => {
+      it('changes points', () => {
+        element.registerMovement(400, 400);
+        expect(element.points).toEqual([200, 200, 300, 300, 400, 400]);
+      });
+      it('changes session when needed', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes posX and posY', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.posX).toEqual(300);
+        expect(element.posY).toEqual(300);
+      });
+    });
+  });
+  describe('FreePathDrawable', () => {
+    let handleSessionChange = jest.fn();
+    let forceUpdate = jest.fn();
+    let props;
+    beforeEach(() => {
+      props = {
+        handleSessionChange,
+        forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        points: [200, 200, 300, 300],
+        posX: 200,
+        posY: 200,
+        startx: 200,
+        starty: 200,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('FreePathDrawable', props);
+    });
+    describe('snapshot', () => {
+      it('renders', () => {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', () => {
+      it('calls forceUpdate', () => {
+        wrapper.simulate('click');
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      it('changes points', () => {
+        element.registerMovement(400, 400);
+        expect(element.points).toEqual([200, 200, 300, 300, 400, 400]);
+      });
+      it('changes session when needed', () => {
+        const spy = jest.spyOn(element, 'handleDragEnd');
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes posX and posY', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.posX).toEqual(300);
+        expect(element.posY).toEqual(300);
+      });
+    });
+  });
+  describe('LineDrawable', () => {
+    let handleSessionChange = jest.fn();
+    let forceUpdate = jest.fn();
+    let props;
+    beforeEach(() => {
+      props = {
+        handleSessionChange,
+        forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        posX: 200,
+        posY: 200,
+        x: 300,
+        y: 200,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('LineDrawable', props);
+    });
+    describe('snapshot', () => {
+      it('renders', () => {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', () => {
+      it('calls forceUpdate', () => {
+        wrapper.simulate('click');
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      it('changes x and y', () => {
+        element.registerMovement(400, 400);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(400);
+      });
+      it('changes session when needed', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes posX and posY', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.posX).toEqual(300);
+        expect(element.posY).toEqual(300);
+      });
+    });
+  });
+  describe('RectangleDrawable', () => {
+    let handleSessionChange = jest.fn();
+    let forceUpdate = jest.fn();
+    let props;
+    beforeEach(() => {
+      props = {
+        handleSessionChange,
+        forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        x: 300,
+        y: 300,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('RectangleDrawable', props);
+    });
+    describe('snapshot', () => {
+      it('renders', () => {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', () => {
+      it('calls forceUpdate', () => {
+        wrapper.simulate('click');
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      it('changes x and y', () => {
+        element.registerMovement(400, 400);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(400);
+      });
+      it('changes session when needed', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes posX and posY', () => {
+        const event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.startx).toEqual(300);
+        expect(element.starty).toEqual(300);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(400);
+      });
+    });
+  });
+  describe('DrawableText', () => {
+    const all = [{
+      id: 'gcifqhhimf8k2d6g8hs',
+      isDefault: true,
+      label: 'Double click to edit this text. Press Enter to submit.',
+      value: 'This is what the user entered',
+      width: 200,
+      x: 2 * 5 + 50,
+      y: 2 * 5 + 50,
+      textVisible: true,
+      transformerVisible: true,
+      textareaVisible: false,
+      createdAt: new Date(),
+      type: 'text-entry'
+    }];
+    let handleSessionChange = jest.fn();
+    let forceUpdate = jest.fn();
+    let toggleTextSelected = jest.fn();
+    let props;
+    let stage;
+    beforeEach(() => {
+      stage = {
+        on: jest.fn(),
+        off: jest.fn()
+      };
+      props = {
+        all,
+        handleSessionChange,
+        forceUpdate,
+        stage,
+        toggleTextSelected,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        x: 300,
+        y: 300,
+        scale: 1
+      };
+      wrapper = mkWrapper('DrawableText', props, 'div');
+    });
+    describe('snapshot', () => {
+      it('renders', () => {
+        expect(wrapper).toMatchSnapshot();
+      });
+      it('renders textAreas', () => {
+        element = new drawableClasses['DrawableText'](props);
+        wrapper = (0, _enzyme.shallow)(/*#__PURE__*/_react.default.createElement("div", null, element.renderTextareas()));
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('snapshot when there is no value', () => {
+      beforeEach(() => {
+        props.all.forEach(a => {
+          delete a.value;
+        });
+        wrapper = mkWrapper('DrawableText', props, 'div');
+      });
+      it('renders', () => {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', () => {
+      it('shoud change the all property and call forceUpdate', () => {
+        element.setAll([]);
+        expect(element.all).toEqual([]);
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      describe('addNewTextEntry', () => {
+        it('shoud add a new element and call the appropriate functions', () => {
+          element.addNewTextEntry();
+          expect(element.all.length).toEqual(2);
+          expect(element.all).toEqual(expect.arrayContaining([expect.objectContaining({
+            isDefault: true,
+            label: 'Double click to edit this text. Press Enter to submit.',
+            width: 200,
+            textVisible: true,
+            transformerVisible: true,
+            textareaVisible: false,
+            type: 'text-entry'
+          })]));
+          expect(stage.on).toHaveBeenCalled();
+          expect(handleSessionChange).toHaveBeenCalled();
+        });
+      });
+      describe('showOnlyTextNodes', () => {
+        it('should change properties for the "all" array', () => {
+          element.showOnlyTextNodes();
+          expect(element.all).toEqual(expect.arrayContaining([expect.objectContaining({
+            textVisible: true,
+            transformerVisible: false,
+            textareaVisible: false
+          })]));
+        });
+      });
+      describe('showOnltoggleTextareayTextNodes', () => {
+        it('should change the item with the right id in the "all" array and call forceUpdate', () => {
+          element.toggleTextarea('gcifqhhimf8k2d6g8hs', true);
+          expect(element.all[0]).toEqual(expect.objectContaining({
+            textVisible: false,
+            transformerVisible: false,
+            textareaVisible: true
+          }));
+          expect(forceUpdate).toHaveBeenCalled();
+          element.toggleTextarea('gcifqhhimf8k2d6g8hs', false);
+          expect(element.all[0]).toEqual(expect.objectContaining({
+            textVisible: true,
+            transformerVisible: true,
+            textareaVisible: false
+          }));
+          expect(forceUpdate).toHaveBeenCalled();
+        });
+      });
+      describe('initializeDefault', () => {
+        it('should make the item with the right id default', () => {
+          element.initializeDefault('gcifqhhimf8k2d6g8hs', true);
+          expect(element.all[0]).toEqual(expect.objectContaining({
+            isDefault: false
+          }));
+        });
+      });
+      describe('saveValue', () => {
+        it('should make the item with the right id default and call handleSessionChange', () => {
+          const textNode = {
+            text: jest.fn()
+          };
+          const textareaNode = {
+            value: 'Foo bar'
+          };
+          element.saveValue('gcifqhhimf8k2d6g8hs', textNode, textareaNode);
+          expect(textNode.text).toHaveBeenCalledWith('Foo bar');
+          expect(handleSessionChange).toHaveBeenCalled();
+          textareaNode.value = '';
+          element.saveValue('gcifqhhimf8k2d6g8hs', textNode, textareaNode);
+          expect(element.all).toEqual(expect.not.arrayContaining([expect.objectContaining({
+            id: 'gcifqhhimf8k2d6g8hs'
+          })]));
+          expect(forceUpdate).toHaveBeenCalled();
+          expect(handleSessionChange).toHaveBeenCalled();
+        });
+      });
+      describe('handleMouseEvents', () => {
+        it('should call the right functions on mouse down and up', () => {
+          element.handleMouseDown();
+          expect(toggleTextSelected).toHaveBeenCalledWith(true);
+          element.handleMouseUp();
+          expect(toggleTextSelected).toHaveBeenCalledWith(false);
+        });
+        it('should call the right functions onClick', () => {
+          element.handleClick(null, 'gcifqhhimf8k2d6g8hs');
+          expect(element.all).toEqual(expect.arrayContaining([expect.objectContaining({
+            transformerVisible: true
+          })]));
+          expect(forceUpdate).toHaveBeenCalled();
+        });
+        it('should call the right functions onDblClick', () => {
+          const text = {
+            id: 'gcifqhhimf8k2d6g8hs',
+            isDefault: false
+          };
+          const textNode = element[`text_${text.id}`] = {
+            _lastPos: {
+              x: 200,
+              y: 200
+            },
+            align: jest.fn().mockReturnValue('center'),
+            fill: jest.fn().mockReturnValue('green'),
+            fontFamily: jest.fn().mockReturnValue('FooBarFamily'),
+            fontSize: jest.fn().mockReturnValue('16'),
+            height: jest.fn().mockReturnValue(40),
+            lineHeight: jest.fn().mockReturnValue('40px'),
+            padding: jest.fn().mockReturnValue(0),
+            rotation: jest.fn().mockReturnValue(0),
+            text: jest.fn().mockReturnValue('foo bar'),
+            width: jest.fn().mockReturnValue(200)
+          };
+          const textareaNode = element[`textarea_${text.id}`] = {
+            focus: jest.fn(),
+            addEventListener: jest.fn(),
+            style: {},
+            scrollHeight: 205
+          };
+          const initSpy = jest.spyOn(element, 'initializeDefault');
+          const saveValueSpy = jest.spyOn(element, 'saveValue');
+          const toggleSpy = jest.spyOn(element, 'toggleTextarea');
+          element.handleDblClick(null, text);
+          expect(toggleSpy).toHaveBeenCalledWith(text.id, true);
+          expect(textareaNode.value).toEqual('foo bar');
+          expect(textareaNode.style).toEqual({
+            background: 'none',
+            border: 'none',
+            color: 'green',
+            fontFamily: 'FooBarFamily',
+            fontSize: '16px',
+            height: '208px',
+            left: '200px',
+            lineHeight: '40px',
+            margin: '0px',
+            outline: 'none',
+            overflow: 'hidden',
+            padding: '0px',
+            position: 'absolute',
+            resize: 'none',
+            top: '200px',
+            transformOrigin: 'left top',
+            textAlign: 'center',
+            transform: 'translateY(-0px)',
+            width: '200px'
+          });
+          expect(textareaNode.focus).toHaveBeenCalled();
+          expect(stage.on).toHaveBeenCalled();
+          expect(initSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);
+          expect(forceUpdate).toHaveBeenCalled();
+          expect(textareaNode.addEventListener.mock.calls[0][0]).toEqual('keydown');
+          expect(textareaNode.addEventListener.mock.calls[1][0]).toEqual('blur');
+          const event = {
+            keyCode: 13,
+            shiftKey: true
+          };
+          textareaNode.addEventListener.mock.calls[0][1](event);
+
+          // Make sure it's not called the second time
+          expect(toggleSpy).toHaveBeenCalledTimes(1);
+          expect(saveValueSpy).not.toHaveBeenCalled();
+          event.shiftKey = false;
+          textareaNode.addEventListener.mock.calls[0][1](event);
+          expect(toggleSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);
+          expect(saveValueSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', textNode, textareaNode);
+          event.keyCode = 27;
+          textareaNode.addEventListener.mock.calls[0][1](event);
+          expect(toggleSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);
+          const showTextSpy = jest.spyOn(element, 'showOnlyTextNodes');
+          event.target = stage;
+          stage.on.mock.calls[0][1](event);
+          expect(showTextSpy).toHaveBeenCalled();
+          expect(saveValueSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', textNode, textareaNode);
+        });
+      });
+      describe('handleTransform', () => {
+        it('should change attrs when called', () => {
+          const textNode = element[`text_gcifqhhimf8k2d6g8hs`] = {
+            setAttrs: jest.fn(),
+            width: jest.fn().mockReturnValue(100),
+            scaleX: jest.fn().mockReturnValue(1)
+          };
+          element.handleTransform(null, 'text_gcifqhhimf8k2d6g8hs');
+          expect(textNode.setAttrs).toHaveBeenCalledWith({
+            width: 100,
+            scaleX: 1
+          });
+        });
+      });
+      describe('setInitialProps', () => {
+        it('should set the props if not set already', () => {
+          element.props = undefined;
+          element.setInitialProps(props);
+          expect(element.props).toEqual(props);
+        });
+      });
+      describe('render', () => {
+        it('should set the stage listener only once', () => {
+          const separateStage = {
+            on: jest.fn(),
+            off: jest.fn()
+          };
+          const newProps = {
+            ...(0, _cloneDeep.default)(props),
+            stage: separateStage
+          };
+          const newElement = new drawableClasses['DrawableText'](newProps);
+          expect(newElement.stage).toEqual(undefined);
+          newElement.render(newProps);
+          expect(newElement.stage).toEqual(separateStage);
+          newElement.render(newProps);
+          expect(separateStage.on.mock.calls.length).toEqual(1);
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_enzyme","_cloneDeep","_drawableFreePath","_drawableLine","_drawableRectangle","_drawableCircle","_drawableEraser","_drawableText","_drawableMain","drawableClasses","FreePathDrawable","LineDrawable","RectangleDrawable","CircleDrawable","EraserDrawable","DrawableText","describe","element","wrapper","mkWrapper","type","props","WrapperEl","content","render","default","createElement","shallow","onSessionChange","jest","fn","TextEntry","wrapperMain","extras","renderOpts","defaults","classes","disabled","className","imageDimensions","imageUrl","drawableDimensions","height","width","fillColor","outlineColor","paintColor","session","toolActive","label","icon","DrawableMain","it","w","expect","toMatchSnapshot","handleSessionChange","forceUpdate","paint","startx","starty","x","y","createdAt","Date","setState","drawables","instance","handleUndo","state","length","toEqual","handleClearAll","beforeEach","simulate","toHaveBeenCalled","registerMovement","event","target","getX","mockReturnValue","getY","handleDragEnd","points","posX","posY","spy","spyOn","all","id","isDefault","value","textVisible","transformerVisible","textareaVisible","toggleTextSelected","stage","on","off","scale","renderTextareas","forEach","a","setAll","addNewTextEntry","arrayContaining","objectContaining","showOnlyTextNodes","toggleTextarea","initializeDefault","textNode","text","textareaNode","saveValue","toHaveBeenCalledWith","not","handleMouseDown","handleMouseUp","handleClick","_lastPos","align","fill","fontFamily","fontSize","lineHeight","padding","rotation","focus","addEventListener","style","scrollHeight","initSpy","saveValueSpy","toggleSpy","handleDblClick","background","border","color","left","margin","outline","overflow","position","resize","top","transformOrigin","textAlign","transform","mock","calls","keyCode","shiftKey","toHaveBeenCalledTimes","showTextSpy","setAttrs","scaleX","handleTransform","undefined","setInitialProps","separateStage","newProps","cloneDeep","newElement"],"sources":["../../../src/drawing-response/__tests__/drawing-main.test.jsx"],"sourcesContent":["import React from 'react';\nimport { shallow } from 'enzyme';\nimport cloneDeep from 'lodash/cloneDeep';\nimport FreePathDrawable from '../drawable-free-path';\nimport LineDrawable from '../drawable-line';\nimport RectangleDrawable from '../drawable-rectangle';\nimport CircleDrawable from '../drawable-circle';\nimport EraserDrawable from '../drawable-eraser';\nimport DrawableText from '../drawable-text';\nimport { DrawableMain } from '../drawable-main';\n\nconst drawableClasses = {\n  FreePathDrawable,\n  LineDrawable,\n  RectangleDrawable,\n  CircleDrawable,\n  EraserDrawable,\n  DrawableText,\n};\n\ndescribe('DrawingResponse', () => {\n  let element;\n  let wrapper;\n\n  const mkWrapper = (type, props, WrapperEl) => {\n    element = new drawableClasses[type](props);\n\n    let content = element.render(props);\n\n    if (WrapperEl) {\n      content = <WrapperEl>{content}</WrapperEl>;\n    }\n\n    return shallow(content);\n  };\n\n  describe('DrawableMain', () => {\n    let onSessionChange = jest.fn();\n    const TextEntry = new DrawableText();\n\n    const wrapperMain = (extras, renderOpts) => {\n      const defaults = {\n        classes: {},\n        disabled: false,\n        className: 'className',\n        onSessionChange,\n        imageDimensions: {},\n        imageUrl: 'url',\n        drawableDimensions: { height: 350, width: 353 },\n        fillColor: 'white',\n        outlineColor: 'black',\n        paintColor: 'red',\n        session: {},\n        toolActive: { type: 'Select', label: 'Select', icon: 'mdiCursorDefault' },\n        TextEntry,\n      };\n      const props = { ...defaults, ...extras };\n      return shallow(<DrawableMain {...props} />, {\n        ...renderOpts,\n      });\n    };\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        const w = wrapperMain();\n        expect(w).toMatchSnapshot();\n      });\n\n      it('renders disabled', () => {\n        const w = wrapperMain({ disabled: true });\n        expect(w).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      const handleSessionChange = jest.fn();\n      const forceUpdate = jest.fn();\n      const props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        x: 300,\n        y: 300,\n        createdAt: new Date(),\n      };\n\n      it('handleUndo', () => {\n        const w = wrapperMain();\n\n        w.setState({ drawables: [new RectangleDrawable(props), new RectangleDrawable(props)] });\n        w.instance().handleUndo();\n\n        expect(w.state('drawables').length).toEqual(1);\n\n        w.instance().handleUndo();\n\n        expect(w.state('drawables')).toEqual([]);\n      });\n\n      it('handleClearAll', () => {\n        const w = wrapperMain();\n\n        w.setState({ drawables: [new RectangleDrawable(props), new RectangleDrawable(props)] });\n        w.instance().handleClearAll();\n\n        expect(w.state('drawables')).toEqual([]);\n      });\n    });\n  });\n\n  describe('CircleDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        x: 300,\n        y: 200,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('CircleDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('calls forceUpdate', () => {\n        wrapper.simulate('click');\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      it('changes x and y', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(400);\n      });\n\n      it('changes session when needed', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes startx and starty', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.startx).toEqual(300);\n        expect(element.starty).toEqual(300);\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(300);\n      });\n    });\n  });\n\n  describe('EraserDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        points: [200, 200, 300, 300],\n        posX: 200,\n        posY: 200,\n        startx: 200,\n        starty: 200,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('EraserDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('changes points', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.points).toEqual([200, 200, 300, 300, 400, 400]);\n      });\n\n      it('changes session when needed', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes posX and posY', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.posX).toEqual(300);\n        expect(element.posY).toEqual(300);\n      });\n    });\n  });\n\n  describe('FreePathDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        points: [200, 200, 300, 300],\n        posX: 200,\n        posY: 200,\n        startx: 200,\n        starty: 200,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('FreePathDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('calls forceUpdate', () => {\n        wrapper.simulate('click');\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      it('changes points', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.points).toEqual([200, 200, 300, 300, 400, 400]);\n      });\n\n      it('changes session when needed', () => {\n        const spy = jest.spyOn(element, 'handleDragEnd');\n\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes posX and posY', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.posX).toEqual(300);\n        expect(element.posY).toEqual(300);\n      });\n    });\n  });\n\n  describe('LineDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        posX: 200,\n        posY: 200,\n        x: 300,\n        y: 200,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('LineDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('calls forceUpdate', () => {\n        wrapper.simulate('click');\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      it('changes x and y', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(400);\n      });\n\n      it('changes session when needed', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes posX and posY', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.posX).toEqual(300);\n        expect(element.posY).toEqual(300);\n      });\n    });\n  });\n\n  describe('RectangleDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        x: 300,\n        y: 300,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('RectangleDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('calls forceUpdate', () => {\n        wrapper.simulate('click');\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      it('changes x and y', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(400);\n      });\n\n      it('changes session when needed', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes posX and posY', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300),\n          },\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.startx).toEqual(300);\n        expect(element.starty).toEqual(300);\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(400);\n      });\n    });\n  });\n\n  describe('DrawableText', () => {\n    const all = [\n      {\n        id: 'gcifqhhimf8k2d6g8hs',\n        isDefault: true,\n        label: 'Double click to edit this text. Press Enter to submit.',\n        value: 'This is what the user entered',\n        width: 200,\n        x: 2 * 5 + 50,\n        y: 2 * 5 + 50,\n        textVisible: true,\n        transformerVisible: true,\n        textareaVisible: false,\n        createdAt: new Date(),\n        type: 'text-entry',\n      },\n    ];\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let toggleTextSelected = jest.fn();\n    let props;\n    let stage;\n\n    beforeEach(() => {\n      stage = {\n        on: jest.fn(),\n        off: jest.fn(),\n      };\n\n      props = {\n        all,\n        handleSessionChange,\n        forceUpdate,\n        stage,\n        toggleTextSelected,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        x: 300,\n        y: 300,\n        scale: 1,\n      };\n      wrapper = mkWrapper('DrawableText', props, 'div');\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n\n      it('renders textAreas', () => {\n        element = new drawableClasses['DrawableText'](props);\n\n        wrapper = shallow(<div>{element.renderTextareas()}</div>);\n\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('snapshot when there is no value', () => {\n      beforeEach(() => {\n        props.all.forEach((a) => {\n          delete a.value;\n        });\n        wrapper = mkWrapper('DrawableText', props, 'div');\n      });\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('shoud change the all property and call forceUpdate', () => {\n        element.setAll([]);\n\n        expect(element.all).toEqual([]);\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      describe('addNewTextEntry', () => {\n        it('shoud add a new element and call the appropriate functions', () => {\n          element.addNewTextEntry();\n\n          expect(element.all.length).toEqual(2);\n          expect(element.all).toEqual(\n            expect.arrayContaining([\n              expect.objectContaining({\n                isDefault: true,\n                label: 'Double click to edit this text. Press Enter to submit.',\n                width: 200,\n                textVisible: true,\n                transformerVisible: true,\n                textareaVisible: false,\n                type: 'text-entry',\n              }),\n            ]),\n          );\n\n          expect(stage.on).toHaveBeenCalled();\n          expect(handleSessionChange).toHaveBeenCalled();\n        });\n      });\n\n      describe('showOnlyTextNodes', () => {\n        it('should change properties for the \"all\" array', () => {\n          element.showOnlyTextNodes();\n\n          expect(element.all).toEqual(\n            expect.arrayContaining([\n              expect.objectContaining({\n                textVisible: true,\n                transformerVisible: false,\n                textareaVisible: false,\n              }),\n            ]),\n          );\n        });\n      });\n\n      describe('showOnltoggleTextareayTextNodes', () => {\n        it('should change the item with the right id in the \"all\" array and call forceUpdate', () => {\n          element.toggleTextarea('gcifqhhimf8k2d6g8hs', true);\n\n          expect(element.all[0]).toEqual(\n            expect.objectContaining({\n              textVisible: false,\n              transformerVisible: false,\n              textareaVisible: true,\n            }),\n          );\n\n          expect(forceUpdate).toHaveBeenCalled();\n\n          element.toggleTextarea('gcifqhhimf8k2d6g8hs', false);\n\n          expect(element.all[0]).toEqual(\n            expect.objectContaining({\n              textVisible: true,\n              transformerVisible: true,\n              textareaVisible: false,\n            }),\n          );\n\n          expect(forceUpdate).toHaveBeenCalled();\n        });\n      });\n\n      describe('initializeDefault', () => {\n        it('should make the item with the right id default', () => {\n          element.initializeDefault('gcifqhhimf8k2d6g8hs', true);\n\n          expect(element.all[0]).toEqual(\n            expect.objectContaining({\n              isDefault: false,\n            }),\n          );\n        });\n      });\n\n      describe('saveValue', () => {\n        it('should make the item with the right id default and call handleSessionChange', () => {\n          const textNode = {\n            text: jest.fn(),\n          };\n          const textareaNode = {\n            value: 'Foo bar',\n          };\n\n          element.saveValue('gcifqhhimf8k2d6g8hs', textNode, textareaNode);\n\n          expect(textNode.text).toHaveBeenCalledWith('Foo bar');\n          expect(handleSessionChange).toHaveBeenCalled();\n\n          textareaNode.value = '';\n\n          element.saveValue('gcifqhhimf8k2d6g8hs', textNode, textareaNode);\n\n          expect(element.all).toEqual(\n            expect.not.arrayContaining([\n              expect.objectContaining({\n                id: 'gcifqhhimf8k2d6g8hs',\n              }),\n            ]),\n          );\n          expect(forceUpdate).toHaveBeenCalled();\n          expect(handleSessionChange).toHaveBeenCalled();\n        });\n      });\n\n      describe('handleMouseEvents', () => {\n        it('should call the right functions on mouse down and up', () => {\n          element.handleMouseDown();\n          expect(toggleTextSelected).toHaveBeenCalledWith(true);\n\n          element.handleMouseUp();\n          expect(toggleTextSelected).toHaveBeenCalledWith(false);\n        });\n\n        it('should call the right functions onClick', () => {\n          element.handleClick(null, 'gcifqhhimf8k2d6g8hs');\n\n          expect(element.all).toEqual(\n            expect.arrayContaining([\n              expect.objectContaining({\n                transformerVisible: true,\n              }),\n            ]),\n          );\n\n          expect(forceUpdate).toHaveBeenCalled();\n        });\n\n        it('should call the right functions onDblClick', () => {\n          const text = {\n            id: 'gcifqhhimf8k2d6g8hs',\n            isDefault: false,\n          };\n\n          const textNode = (element[`text_${text.id}`] = {\n            _lastPos: {\n              x: 200,\n              y: 200,\n            },\n            align: jest.fn().mockReturnValue('center'),\n            fill: jest.fn().mockReturnValue('green'),\n            fontFamily: jest.fn().mockReturnValue('FooBarFamily'),\n            fontSize: jest.fn().mockReturnValue('16'),\n            height: jest.fn().mockReturnValue(40),\n            lineHeight: jest.fn().mockReturnValue('40px'),\n            padding: jest.fn().mockReturnValue(0),\n            rotation: jest.fn().mockReturnValue(0),\n            text: jest.fn().mockReturnValue('foo bar'),\n            width: jest.fn().mockReturnValue(200),\n          });\n          const textareaNode = (element[`textarea_${text.id}`] = {\n            focus: jest.fn(),\n            addEventListener: jest.fn(),\n            style: {},\n            scrollHeight: 205,\n          });\n\n          const initSpy = jest.spyOn(element, 'initializeDefault');\n          const saveValueSpy = jest.spyOn(element, 'saveValue');\n          const toggleSpy = jest.spyOn(element, 'toggleTextarea');\n\n          element.handleDblClick(null, text);\n\n          expect(toggleSpy).toHaveBeenCalledWith(text.id, true);\n\n          expect(textareaNode.value).toEqual('foo bar');\n          expect(textareaNode.style).toEqual({\n            background: 'none',\n            border: 'none',\n            color: 'green',\n            fontFamily: 'FooBarFamily',\n            fontSize: '16px',\n            height: '208px',\n            left: '200px',\n            lineHeight: '40px',\n            margin: '0px',\n            outline: 'none',\n            overflow: 'hidden',\n            padding: '0px',\n            position: 'absolute',\n            resize: 'none',\n            top: '200px',\n            transformOrigin: 'left top',\n            textAlign: 'center',\n            transform: 'translateY(-0px)',\n            width: '200px',\n          });\n\n          expect(textareaNode.focus).toHaveBeenCalled();\n          expect(stage.on).toHaveBeenCalled();\n          expect(initSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);\n          expect(forceUpdate).toHaveBeenCalled();\n          expect(textareaNode.addEventListener.mock.calls[0][0]).toEqual('keydown');\n          expect(textareaNode.addEventListener.mock.calls[1][0]).toEqual('blur');\n\n          const event = {\n            keyCode: 13,\n            shiftKey: true,\n          };\n\n          textareaNode.addEventListener.mock.calls[0][1](event);\n\n          // Make sure it's not called the second time\n          expect(toggleSpy).toHaveBeenCalledTimes(1);\n          expect(saveValueSpy).not.toHaveBeenCalled();\n\n          event.shiftKey = false;\n\n          textareaNode.addEventListener.mock.calls[0][1](event);\n\n          expect(toggleSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);\n          expect(saveValueSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', textNode, textareaNode);\n\n          event.keyCode = 27;\n\n          textareaNode.addEventListener.mock.calls[0][1](event);\n\n          expect(toggleSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);\n\n          const showTextSpy = jest.spyOn(element, 'showOnlyTextNodes');\n\n          event.target = stage;\n\n          stage.on.mock.calls[0][1](event);\n\n          expect(showTextSpy).toHaveBeenCalled();\n          expect(saveValueSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', textNode, textareaNode);\n        });\n      });\n\n      describe('handleTransform', () => {\n        it('should change attrs when called', () => {\n          const textNode = (element[`text_gcifqhhimf8k2d6g8hs`] = {\n            setAttrs: jest.fn(),\n            width: jest.fn().mockReturnValue(100),\n            scaleX: jest.fn().mockReturnValue(1),\n          });\n\n          element.handleTransform(null, 'text_gcifqhhimf8k2d6g8hs');\n\n          expect(textNode.setAttrs).toHaveBeenCalledWith({\n            width: 100,\n            scaleX: 1,\n          });\n        });\n      });\n\n      describe('setInitialProps', () => {\n        it('should set the props if not set already', () => {\n          element.props = undefined;\n\n          element.setInitialProps(props);\n\n          expect(element.props).toEqual(props);\n        });\n      });\n\n      describe('render', () => {\n        it('should set the stage listener only once', () => {\n          const separateStage = {\n            on: jest.fn(),\n            off: jest.fn(),\n          };\n          const newProps = {\n            ...cloneDeep(props),\n            stage: separateStage,\n          };\n          const newElement = new drawableClasses['DrawableText'](newProps);\n\n          expect(newElement.stage).toEqual(undefined);\n\n          newElement.render(newProps);\n          expect(newElement.stage).toEqual(separateStage);\n\n          newElement.render(newProps);\n\n          expect(separateStage.on.mock.calls.length).toEqual(1);\n        });\n      });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}