@pie-lib/graphing-solution-set 2.16.0-beta.0

package/src/tools/shared/line/__tests__/__snapshots__/line-path.test.jsx.snap

@@ -0,0 +1,57 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`LinePath snapshot renders 1`] = `
+<RawLinePath
+  className="className"
+  classes={
+    Object {
+      "correct": "RawLinePath-correct-5",
+      "disabled": "RawLinePath-disabled-4",
+      "dragging": "RawLinePath-dragging-3",
+      "drawLine": "RawLinePath-drawLine-1",
+      "incorrect": "RawLinePath-incorrect-6",
+      "line": "RawLinePath-line-2",
+      "missing": "RawLinePath-missing-7",
+    }
+  }
+  from={
+    Object {
+      "x": 0,
+      "y": 0,
+    }
+  }
+  graphProps={
+    Object {
+      "domain": Object {
+        "max": 1,
+        "min": 0,
+        "step": 1,
+      },
+      "range": Object {
+        "max": 1,
+        "min": 0,
+        "step": 1,
+      },
+      "scale": Object {
+        "x": [MockFunction],
+        "y": [MockFunction],
+      },
+      "size": Object {
+        "height": 400,
+        "width": 400,
+      },
+      "snap": Object {
+        "x": [MockFunction],
+        "y": [MockFunction],
+      },
+    }
+  }
+  onChange={[MockFunction]}
+  to={
+    Object {
+      "x": 1,
+      "y": 1,
+    }
+  }
+/>
+`;

package/src/tools/shared/line/__tests__/__snapshots__/with-root-edge.test.jsx.snap

@@ -0,0 +1,63 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`rootEdgeComponent snapshot renders 1`] = `
+<Component
+  graphProps={
+    Object {
+      "domain": Object {
+        "max": 1,
+        "min": 0,
+        "step": 1,
+      },
+      "range": Object {
+        "max": 1,
+        "min": 0,
+        "step": 1,
+      },
+      "scale": Object {
+        "x": [MockFunction],
+        "y": [MockFunction],
+      },
+      "size": Object {
+        "height": 400,
+        "width": 400,
+      },
+      "snap": Object {
+        "x": [MockFunction],
+        "y": [MockFunction],
+      },
+    }
+  }
+  mark={
+    Object {
+      "from": Object {
+        "x": 0,
+        "y": 0,
+      },
+      "to": Object {
+        "x": 1,
+        "y": 1,
+      },
+    }
+  }
+  onChange={[Function]}
+/>
+`;
+
+exports[`rootEdgeToToFromWRapper renders 1`] = `
+<Component
+  mark={
+    Object {
+      "from": Object {
+        "x": 1,
+        "y": 1,
+      },
+      "to": Object {
+        "x": 2,
+        "y": 2,
+      },
+    }
+  }
+  onChange={[Function]}
+/>
+`;

package/src/tools/shared/line/__tests__/index.test.jsx

@@ -0,0 +1,247 @@
+import { lineTool, lineToolComponent, lineBase } from '../index';
+import { utils } from '@pie-lib/plot';
+import { shallow } from 'enzyme';
+import React from 'react';
+import { graphProps as getGraphProps } from '../../../../__tests__/utils';
+
+const { xy } = utils;
+const xyLabel = (x, y, label) => ({ x, y, label });
+
+describe('lineTool', () => {
+  describe('addPoint', () => {
+    let toolbar;
+    beforeEach(() => {
+      toolbar = lineTool('lineType', () => <div />)();
+    });
+    it('returns a building mark', () => {
+      const result = toolbar.addPoint(xy(1, 1));
+      expect(result).toEqual({
+        type: 'lineType',
+        building: true,
+        from: xy(1, 1),
+      });
+    });
+
+    it('returns a complete mark', () => {
+      const result = toolbar.addPoint(xy(1, 1), { from: xy(0, 0) });
+      expect(result).toEqual({
+        building: false,
+        from: xy(0, 0),
+        to: xy(1, 1),
+      });
+    });
+  });
+});
+
+describe('lineToolComponent', () => {
+  let Comp;
+  let mark;
+  let onChange;
+  let w;
+  const wrapper = (extras) => {
+    const defaults = {
+      mark,
+      onChange: jest.fn(),
+      graphProps: getGraphProps(),
+    };
+    const props = { ...defaults, ...extras };
+
+    return shallow(<Comp {...props} />);
+  };
+
+  beforeEach(() => {
+    Comp = lineToolComponent(() => <text />);
+    mark = { from: xy(0, 0), to: xy(1, 1) };
+  });
+
+  describe('snapshot', () => {
+    it('renders', () => {
+      w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+  describe('logic', () => {
+    describe('startDrag', () => {
+      it('sets state', () => {
+        w = wrapper();
+        w.instance().startDrag();
+        expect(w.state('mark')).toEqual(mark);
+      });
+    });
+
+    describe('stopDrag/changeMark', () => {
+      let update = { from: xy(2, 2), to: xy(4, 4) };
+      beforeEach(() => {
+        w = wrapper();
+        w.instance().changeMark(update);
+        w.instance().stopDrag();
+      });
+      it('calls onChange', () => {
+        expect(w.instance().props.onChange).toHaveBeenCalledWith(mark, update);
+      });
+    });
+  });
+});
+
+describe('lineBase', () => {
+  let Comp;
+  let w;
+  let onChange = jest.fn();
+  let changeMarkProps = jest.fn();
+
+  beforeEach(() => {
+    Comp = lineBase(() => <text />);
+  });
+
+  const wrapper = (extras) => {
+    const defaults = {
+      onChange,
+      changeMarkProps,
+      graphProps: getGraphProps(),
+      from: xy(0, 0),
+      to: xy(1, 1),
+    };
+    const props = { ...defaults, ...extras };
+
+    return shallow(<Comp {...props} />);
+  };
+
+  // used to test items that have labels attached to points
+  const labelNode = document.createElement('foreignObject');
+  const wrapperWithLabels = (extras = {}) =>
+    wrapper({
+      ...extras,
+      labelNode: labelNode,
+      from: xyLabel(0, 0, 'A'),
+      to: xyLabel(1, 1, 'B'),
+    });
+
+  describe('render', () => {
+    it('renders', () => {
+      w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+
+    it('renders with labels', () => {
+      w = wrapperWithLabels();
+      expect(w).toMatchSnapshot();
+    });
+  });
+
+  describe('logic', () => {
+    const assertCallsOnChange = (fn, args, expected) => {
+      it('calls onChange', () => {
+        const w = wrapper();
+        w.instance()[fn](...args);
+        expect(w.instance().props.onChange).toBeCalledWith(expected);
+      });
+    };
+
+    const assertCallsOnChangeWithLabels = (fn, args, expected) => {
+      it('calls onChange with labels', () => {
+        const w = wrapperWithLabels();
+        w.instance()[fn](...args);
+        expect(w.instance().props.onChange).toBeCalledWith(expected);
+      });
+    };
+
+    describe('dragComp', () => {
+      const update = { from: xy(2, 2), to: xy(4, 4) };
+      assertCallsOnChange('dragComp', [update], update);
+    });
+
+    describe('dragComp keeps labels on both "from" and "to"', () => {
+      const update = { from: xy(2, 2), to: xy(4, 4) };
+      assertCallsOnChangeWithLabels('dragComp', [update], {
+        from: xyLabel(2, 2, 'A'),
+        to: xyLabel(4, 4, 'B'),
+      });
+    });
+
+    describe('dragFrom', () => {
+      assertCallsOnChange('dragFrom', [xy(2, 2)], { from: xy(2, 2), to: xy(1, 1) });
+    });
+
+    describe('dragFrom keeps labels on "from"', () => {
+      assertCallsOnChangeWithLabels('dragFrom', [xy(2, 2)], {
+        from: xyLabel(2, 2, 'A'),
+        to: xyLabel(1, 1, 'B'),
+      });
+    });
+
+    describe('dragTo', () => {
+      assertCallsOnChange('dragTo', [xy(2, 2)], { from: xy(0, 0), to: xy(2, 2) });
+    });
+
+    describe('dragTo keeps labels on "to"', () => {
+      assertCallsOnChangeWithLabels('dragTo', [xy(3, 3)], {
+        from: xyLabel(0, 0, 'A'),
+        to: xyLabel(3, 3, 'B'),
+      });
+    });
+
+    describe('labelChange', () => {
+      it('updates "label" property for point', () => {
+        w = wrapperWithLabels({ labelModeEnabled: true });
+
+        w.instance().labelChange(xyLabel(0, 0, 'Label A'), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'Label A'),
+        });
+
+        w.instance().labelChange(xyLabel(0, 0, 'Label B'), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          to: xyLabel(0, 0, 'Label B'),
+        });
+      });
+
+      it('removes "label" property if the field is empty', () => {
+        w = wrapperWithLabels();
+
+        w.instance().labelChange(xyLabel(0, 0, ''), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xy(0, 0),
+        });
+
+        w.instance().labelChange(xyLabel(0, 0, ''), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          to: xy(0, 0),
+        });
+      });
+    });
+
+    describe('clickPoint', () => {
+      it('adds "label" property to a point', () => {
+        w = wrapperWithLabels({ labelModeEnabled: true });
+
+        w.instance().clickPoint(xy(0, 0), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, ''),
+          to: xyLabel(1, 1, 'B'),
+        });
+
+        w.instance().clickPoint(xy(1, 1), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'A'),
+          to: xyLabel(1, 1, ''),
+        });
+      });
+
+      it('if point already has label, keeps that value', () => {
+        w = wrapperWithLabels({ labelModeEnabled: true });
+
+        w.instance().clickPoint(xyLabel(0, 0, 'Label A'), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'Label A'),
+          to: xyLabel(1, 1, 'B'),
+        });
+
+        w.instance().clickPoint(xyLabel(1, 1, 'Label B'), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'A'),
+          to: xyLabel(1, 1, 'Label B'),
+        });
+      });
+    });
+  });
+});

package/src/tools/shared/line/__tests__/line-path.test.jsx

@@ -0,0 +1,53 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import { graphProps as getGraphProps } from '../../../../__tests__/utils';
+import { gridDraggable, utils } from '@pie-lib/plot';
+const { xy } = utils;
+
+import * as lineUtils from '../../../../utils';
+
+const { bounds, pointsToArea } = lineUtils;
+jest.mock('../../../../utils', () => {
+  const a = jest.requireActual('../../../../utils');
+  return {
+    pointsToArea: jest.fn().mockReturnValue({}),
+    bounds: jest.fn().mockReturnValue({}),
+    point: a.point,
+  };
+});
+
+jest.mock('@pie-lib/plot', () => {
+  const a = jest.requireActual('@pie-lib/plot');
+  return {
+    gridDraggable: jest.fn((opts) => jest.fn()),
+    types: a.types,
+    utils: a.utils,
+  };
+});
+
+describe('LinePath', () => {
+  let LinePath;
+  let w;
+  let onChange = jest.fn();
+  beforeEach(() => {
+    LinePath = require('../line-path').LinePath;
+  });
+  const wrapper = (extras) => {
+    const defaults = {
+      classes: {},
+      className: 'className',
+      onChange,
+      graphProps: getGraphProps(),
+      from: xy(0, 0, 0),
+      to: xy(1, 1, 0),
+    };
+    const props = { ...defaults, ...extras };
+    return shallow(<LinePath {...props} />);
+  };
+  describe('snapshot', () => {
+    it('renders', () => {
+      const w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+});

package/src/tools/shared/line/__tests__/with-root-edge.test.jsx

@@ -0,0 +1,73 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import { rootEdgeComponent, withRootEdge, rootEdgeToFromToWrapper } from '../with-root-edge';
+import { graphProps as getGraphProps } from '../../../../__tests__/utils';
+import { utils } from '@pie-lib/plot';
+import { lineToolComponent, LineToolMockComponent } from '../index';
+const { xy } = utils;
+jest.mock('../index', () => {
+  const out = {
+    lineBase: jest.fn().mockReturnValue(() => <div />),
+    lineToolComponent: jest.fn().mockReturnValue(() => <div />),
+  };
+  return out;
+});
+
+describe('rootEdgeToToFromWRapper', () => {
+  let Comp;
+  let w;
+  let onChange = jest.fn();
+  beforeEach(() => {
+    Comp = rootEdgeToFromToWrapper(() => <div />);
+  });
+  const wrapper = (extras) => {
+    const defaults = {
+      mark: { root: xy(1, 1), edge: xy(2, 2) },
+      onChange,
+    };
+    const props = { ...defaults, ...extras };
+    return shallow(<Comp {...props} />);
+  };
+
+  it('renders', () => {
+    w = wrapper();
+    expect(w).toMatchSnapshot();
+  });
+
+  it('has from/to mark', () => {
+    w = wrapper();
+    expect(w.props().mark).toEqual({ from: xy(1, 1), to: xy(2, 2) });
+  });
+
+  it('calls onChange with root edge ', () => {
+    w = wrapper();
+    w.props().onChange({ from: xy(1, 1), to: xy(2, 2) }, { from: xy(3, 3), to: xy(4, 4) });
+    expect(onChange).toHaveBeenCalledWith({ root: xy(1, 1), edge: xy(2, 2) }, { root: xy(3, 3), edge: xy(4, 4) });
+  });
+});
+describe('rootEdgeComponent', () => {
+  let w;
+  let onChange = jest.fn();
+  let Comp;
+  let mark;
+  beforeEach(() => {
+    mark = { root: xy(0, 0), edge: xy(1, 1) };
+    Comp = rootEdgeComponent(() => <text />);
+  });
+  const wrapper = (extras, opts) => {
+    const defaults = {
+      mark,
+      graphProps: getGraphProps(),
+      onChange,
+    };
+
+    const props = { ...defaults, ...extras };
+    return shallow(<Comp {...props} />, opts);
+  };
+  describe('snapshot', () => {
+    it('renders', () => {
+      const w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+});