@pie-lib/graphing-solution-set 4.0.4-next.30 → 4.0.4-next.34

package/src/__tests__/graph-with-controls.test.jsx

@@ -0,0 +1,184 @@
+import { render } from '@pie-lib/test-utils';
+import React from 'react';
+import {
+  filterByValidToolTypes,
+  filterByVisibleToolTypes,
+  getAvailableTool,
+  GraphWithControls,
+  setToolbarAvailability,
+  toolIsAvailable,
+} from '../graph-with-controls';
+import { allTools, line as lineTool, toolsArr } from '../tools';
+
+// Mock DragProvider to avoid @dnd-kit React version conflicts
+jest.mock('@pie-lib/drag', () => ({
+  DragProvider: ({ children }) => <div data-testid="drag-provider">{children}</div>,
+}));
+
+// Mock @dnd-kit/core hooks to avoid DndContext requirement
+jest.mock('@dnd-kit/core', () => ({
+  useDraggable: jest.fn(() => ({
+    attributes: {
+      role: 'button',
+      tabIndex: 0,
+    },
+    listeners: {
+      onPointerDown: jest.fn(),
+    },
+    setNodeRef: jest.fn(),
+    transform: null,
+    transition: null,
+    isDragging: false,
+  })),
+  useDroppable: jest.fn(() => ({
+    setNodeRef: jest.fn(),
+    isOver: false,
+    active: null,
+  })),
+}));
+
+// Mock @dnd-kit/utilities for CSS transform
+jest.mock('@dnd-kit/utilities', () => ({
+  CSS: {
+    Transform: {
+      toString: jest.fn((transform) => (transform ? 'translate3d(0, 0, 0)' : '')),
+    },
+  },
+}));
+
+// Mock @dnd-kit/sortable for arrayMove
+jest.mock('@dnd-kit/sortable', () => ({
+  arrayMove: jest.fn((array, from, to) => {
+    const newArray = [...array];
+    const [removed] = newArray.splice(from, 1);
+    newArray.splice(to, 0, removed);
+    return newArray;
+  }),
+}));
+
+const line = {
+  type: 'line',
+  from: { x: 0, y: 0 },
+  to: { x: 1, y: 1 },
+  label: 'Line',
+  building: true,
+};
+
+const polygon = {
+  type: 'polygon',
+  points: [
+    { x: 0, y: 0 },
+    { x: 1, y: 1 },
+    { x: 2, y: 2 },
+  ],
+};
+
+const marks = [line, polygon];
+
+// Pure function tests - keep as-is
+describe('setToolbarAvailability', () => {
+  it('sets `toolbar: true` if tool should be displayed in toolbar - all tools', () => {
+    const result = setToolbarAvailability(allTools);
+    const allTrue = new Array(toolsArr.length).fill(true);
+
+    expect(result.map((r) => r.toolbar)).toEqual(allTrue);
+  });
+
+  it('sets `toolbar: true` if tool should be displayed in toolbar - few tools', () => {
+    const result = setToolbarAvailability(['line', 'polygon']);
+    const allOthersFalse = new Array(toolsArr.length - 2).fill(false);
+
+    expect(result.filter((r) => r.type === 'line' || r.type === 'polygon').map((r) => r.toolbar)).toEqual([true, true]);
+    expect(result.filter((r) => r.type !== 'line' && r.type !== 'polygon').map((r) => r.toolbar)).toEqual(
+      allOthersFalse,
+    );
+  });
+});
+
+describe('toolIsAvailable', () => {
+  const tools = setToolbarAvailability(['line', 'polygon']);
+
+  it('returns true if tool is available', () => {
+    expect(toolIsAvailable(tools, lineTool())).toEqual(true);
+  });
+});
+
+describe('getAvailableTool', () => {
+  it('returns the first available tool in list if there is any', () => {
+    const tools = setToolbarAvailability(['line', 'polygon']);
+
+    expect(getAvailableTool(tools).toolbar).toEqual(true);
+  });
+
+  it('returns undefined list if there is no available tool', () => {
+    const tools = setToolbarAvailability([]);
+
+    expect(getAvailableTool(tools)).toEqual(undefined);
+  });
+});
+
+describe('filterByValidToolTypes', () => {
+  it('filters marks by valid types', () => {
+    const marks = [{ type: 'polygon' }, { type: 'a' }, { type: 'b' }, { type: 'line' }, { type: 'c' }];
+
+    expect(filterByValidToolTypes(marks)).toEqual([{ type: 'polygon' }, { type: 'line' }]);
+  });
+});
+
+describe('filterByVisibleToolTypes', () => {
+  it('filters marks by the types that should be visible', () => {
+    expect(
+      filterByVisibleToolTypes(['line', 'polygon'], [{ type: 'point' }, { type: 'line' }, { type: 'polygon' }]),
+    ).toEqual([{ type: 'line' }, { type: 'polygon' }]);
+
+    expect(filterByVisibleToolTypes(['line'], [{ type: 'point' }, { type: 'line' }, { type: 'circle' }])).toEqual([
+      { type: 'line' },
+    ]);
+
+    expect(filterByVisibleToolTypes(['segment'], [{ type: 'point' }, { type: 'line' }, { type: 'circle' }])).toEqual(
+      [],
+    );
+  });
+});
+
+describe('GraphWithControls', () => {
+  let onChangeMarks = jest.fn();
+
+  beforeEach(() => {
+    onChangeMarks.mockClear();
+  });
+
+  const defaultProps = () => ({
+    axesSettings: { includeArrows: true },
+    className: '',
+    coordinatesOnHover: false,
+    domain: { min: 0, max: 10, step: 1 },
+    labels: { top: 'a', left: 'b', right: 'c', bottom: 'd' },
+    labelModeEnabled: true,
+    marks,
+    onChangeMarks,
+    range: { min: 0, max: 10, step: 1 },
+    size: { width: 500, height: 500 },
+    title: 'Title',
+    toolbarTools: allTools,
+    language: 'en',
+  });
+  const initialProps = defaultProps();
+
+  const renderComponent = (extras) => {
+    const props = { ...initialProps, ...extras };
+    return render(<GraphWithControls {...props} />);
+  };
+
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      const { container } = renderComponent();
+      expect(container.firstChild).toBeInTheDocument();
+    });
+
+    it('renders Graph component', () => {
+      const { container } = renderComponent();
+      expect(container.querySelector('svg')).toBeInTheDocument();
+    });
+  });
+});

package/src/__tests__/graph.test.jsx

@@ -0,0 +1,93 @@
+import { render } from '@pie-lib/test-utils';
+import React from 'react';
+
+import Graph, { removeBuildingToolIfCurrentToolDiffers } from '../graph';
+import { toolsArr } from '../tools';
+
+// Pure function tests - keep as-is
+describe('removeBuildingToolIfCurrentToolDiffers', () => {
+  let marks = [
+    {
+      type: 'point',
+      x: 2,
+      y: 2,
+      label: 'Point',
+      showLabel: true,
+    },
+    {
+      type: 'line',
+      from: { x: 0, y: 0 },
+      label: 'Line',
+      building: true,
+    },
+  ];
+
+  it('keeps all marks if currentTool is the same', () => {
+    expect(removeBuildingToolIfCurrentToolDiffers({ marks, currentTool: { type: 'line' } })).toEqual(marks);
+  });
+
+  it('removes building marks if currentTool is different', () => {
+    expect(removeBuildingToolIfCurrentToolDiffers({ marks, currentTool: { type: 'different' } })).toEqual([marks[0]]);
+  });
+});
+
+// Note: Instance method tests have been removed. Component behavior should be tested
+// through user interactions and integration tests.
+describe('Graph', () => {
+  let onChangeMarks = jest.fn();
+
+  beforeEach(() => {
+    onChangeMarks.mockClear();
+  });
+
+  const complete = jest.fn();
+  const addPoint = jest.fn();
+  const currentTool = toolsArr[0];
+  currentTool.complete = complete;
+  currentTool.addPoint = addPoint;
+
+  const props = {
+    className: 'className',
+    onChangeMarks,
+    tools: toolsArr,
+    domain: { min: 0, max: 1, step: 1 },
+    range: { min: 0, max: 1, step: 1 },
+    size: { width: 400, height: 400 },
+    currentTool,
+  };
+
+  const renderComponent = (extras) => {
+    const properties = {
+      ...props,
+      marks: [
+        {
+          type: 'point',
+          x: 2,
+          y: 2,
+          label: 'Point',
+          showLabel: true,
+        },
+        {
+          type: 'line',
+          from: { x: 0, y: 0 },
+          label: 'Line',
+          building: true,
+        },
+      ],
+      ...extras,
+    };
+    return render(<Graph {...properties} />);
+  };
+
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      const { container } = renderComponent();
+      expect(container.firstChild).toBeInTheDocument();
+    });
+
+    it('renders SVG graph', () => {
+      const { container } = renderComponent();
+      expect(container.querySelector('svg')).toBeInTheDocument();
+    });
+  });
+});