Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

19.7 KB
Raw Blame
import { createElement } from 'react';
import { render, act } from '@testing-library/react';

jest.mock('react-redux', () => ({
  connect: (mapStateToProps, mapDispatchToProps) => {
    globalThis.measureConnectArgs = { mapStateToProps, mapDispatchToProps };
    return (Component) => Component;
  },
}));

jest.mock('../measure-tool/util', () => ({
  transformLineStringArc: jest.fn((g) => g),
  transformPolygonArc: jest.fn((g) => g),
  downloadGeoJSON: jest.fn(),
}));

let mockTooltipProps = null;
jest.mock('../measure-tool/measure-tooltip', () => (props) => {
  mockTooltipProps = props;
  return null;
});

jest.mock('../../modules/location-search/util', () => ({
  areCoordinatesWithinExtent: jest.fn(() => true),
}));

jest.mock('ol/Observable', () => ({ unByKey: jest.fn() }));
jest.mock('ol/proj', () => ({ transform: jest.fn((coord) => coord) }));

jest.mock('ol/Overlay', () => jest.fn());

let mockDrawCallbacks = {};
jest.mock('ol/interaction', () => ({
  Draw: jest.fn().mockImplementation(() => ({
    on: jest.fn((evt, cb) => { mockDrawCallbacks[evt] = cb; }),
    off: jest.fn(),
  })),
}));

jest.mock('ol/layer', () => ({
  Vector: jest.fn().mockImplementation(() => ({ setMap: jest.fn() })),
}));

jest.mock('ol/source', () => ({
  Vector: jest.fn().mockImplementation(() => ({ removeFeature: jest.fn(), wrapX: false })),
}));

jest.mock('ol/style', () => ({
  Circle: jest.fn(),
  Fill: jest.fn(),
  Stroke: jest.fn(),
  Style: jest.fn(),
}));

jest.mock('ol/geom', () => ({
  LineString: jest.fn(),
  Polygon: jest.fn(),
}));

jest.mock('../../modules/measure/actions', () => ({
  toggleMeasureActive: jest.fn((v) => ({ type: 'TOGGLE_MEASURE', payload: v })),
  updateMeasurements: jest.fn((m) => ({ type: 'UPDATE_MEASUREMENTS', payload: m })),
}));

import OlMeasureTool from './ol-measure-tool';
import util from '../../util/util';
import {
  transformLineStringArc,
  transformPolygonArc,
  downloadGeoJSON,
} from '../measure-tool/util';
import { areCoordinatesWithinExtent } from '../../modules/location-search/util';
import { unByKey as OlObservableUnByKey } from 'ol/Observable';
import { LineString as OlLineString, Polygon as OlPolygon } from 'ol/geom';
import { Draw as OlDraw } from 'ol/interaction';
import { Vector as OlVectorLayer } from 'ol/layer';
import OlOverlay from 'ol/Overlay';
import {
  MEASURE_DISTANCE,
  MEASURE_AREA,
  MEASURE_CLEAR,
  MEASURE_DOWNLOAD_GEOJSON,
  MAP_DISABLE_CLICK_ZOOM,
  MAP_ENABLE_CLICK_ZOOM,
} from '../../util/constants';
import { CRS } from '../../modules/map/constants';

const { events } = util;

let overlayCount = 0;
let featureCount = 0;
let capturedMeasurements = null;

const makeOlMap = () => ({
  addInteraction: jest.fn(),
  removeInteraction: jest.fn(),
  addOverlay: jest.fn(),
  removeOverlay: jest.fn(),
  on: jest.fn(() => ({ key: 'listener' })),
  un: jest.fn(),
  getCoordinateFromPixel: jest.fn(() => [0, 0]),
});

const makeMap = (olMap) => ({
  rendered: true,
  ui: {
    proj: {
      geographic: olMap,
      arctic: olMap,
      antarctic: olMap,
    },
  },
});

const defaultProjections = [CRS.GEOGRAPHIC, CRS.ARCTIC, CRS.ANTARCTIC];

const buildProps = (overrides = {}) => {
  const olMap = overrides.olMap !== undefined ? overrides.olMap : makeOlMap();
  const userUpdate = overrides.updateMeasurements || jest.fn();
  return {
    olMap,
    map: overrides.map !== undefined ? overrides.map : makeMap(olMap),
    crs: CRS.GEOGRAPHIC,
    unitOfMeasure: 'km',
    toggleMeasureActive: jest.fn(),
    projections: defaultProjections,
    proj: { selected: { crs: CRS.GEOGRAPHIC } },
    ...overrides,
    updateMeasurements: (measurements) => {
      capturedMeasurements = measurements;
      userUpdate(measurements);
    },
  };
};

const renderTool = (overrides = {}) => {
  const props = buildProps(overrides);
  let result;
  act(() => {
    result = render(createElement(OlMeasureTool, props));
  });
  return { ...result, props, olMap: props.olMap };
};

const rerenderTool = (rerender, props) => {
  act(() => { rerender(createElement(OlMeasureTool, props)); });
};

const trigger = (eventName, ...args) => {
  act(() => { events.trigger(eventName, ...args); });
};

const makeLineGeometry = (lastCoord = [10, 20]) => {
  const geom = Object.create(OlLineString.prototype);
  geom.on = jest.fn();
  geom.getLastCoordinate = jest.fn(() => lastCoord);
  geom.changed = jest.fn();
  return geom;
};

const makePolygonGeometry = (interiorCoord = [5, 5]) => {
  const geom = Object.create(OlPolygon.prototype);
  geom.on = jest.fn();
  geom.getInteriorPoint = jest.fn(() => ({ getCoordinates: () => interiorCoord }));
  geom.changed = jest.fn();
  return geom;
};

const makeFeature = (geometry) => {
  featureCount += 1;
  return { getGeometry: jest.fn(() => geometry), ol_uid: `feat-${featureCount}` };
};

const originalConsoleError = console.error;
beforeAll(() => {
  jest.spyOn(console, 'error').mockImplementation((...args) => {
    const msg = typeof args[0] === 'string' ? args[0] : '';
    if (msg.includes('already been passed to createRoot')) return;
    originalConsoleError(...args);
  });
});

afterAll(() => {
  console.error.mockRestore();
});

beforeEach(() => {
  jest.clearAllMocks();
  mockDrawCallbacks = {};
  mockTooltipProps = null;

  OlOverlay.mockImplementation(() => {
    overlayCount += 1;
    const element = document.createElement('div');
    return {
      ol_uid: `overlay-${overlayCount}`,
      element,
      setOffset: jest.fn(),
      setPosition: jest.fn(),
      getElement: () => element,
    };
  });
});

afterEach(() => {
  if (capturedMeasurements) {
    Object.keys(capturedMeasurements).forEach((key) => {
      capturedMeasurements[key] = {};
    });
  }
});

describe('OlMeasureTool', () => {
  describe('rendering', () => {
    it('renders null (no DOM output)', () => {
      const { container } = renderTool();
      expect(container.firstChild).toBeNull();
    });

    it('does not throw when map and olMap are null', () => {
      expect(() => renderTool({ map: null, olMap: null })).not.toThrow();
    });

    it('does not throw with an empty projections list', () => {
      expect(() => renderTool({ projections: [] })).not.toThrow();
    });
  });

  describe('event registration', () => {
    it('registers all four measure event handlers when the map is rendered', () => {
      const onSpy = jest.spyOn(events, 'on');
      renderTool();
      const registered = onSpy.mock.calls.map(([evt]) => evt);
      expect(registered).toEqual(expect.arrayContaining([
        MEASURE_DISTANCE, MEASURE_AREA, MEASURE_CLEAR, MEASURE_DOWNLOAD_GEOJSON,
      ]));
      onSpy.mockRestore();
    });

    it('does not register handlers when map.rendered is false', () => {
      const olMap = makeOlMap();
      const onSpy = jest.spyOn(events, 'on');
      renderTool({
        olMap,
        map: {
          rendered: false,
          ui: { proj: { geographic: olMap, arctic: olMap, antarctic: olMap } },
        },
      });
      const registered = onSpy.mock.calls.map(([evt]) => evt);
      expect(registered).not.toContain(MEASURE_DISTANCE);
      onSpy.mockRestore();
    });

    it('deregisters the measure event handlers on unmount', () => {
      const offSpy = jest.spyOn(events, 'off');
      const { unmount } = renderTool();
      act(() => { unmount(); });
      const deregistered = offSpy.mock.calls.map(([evt]) => evt);
      expect(deregistered).toEqual(expect.arrayContaining([
        MEASURE_DISTANCE, MEASURE_AREA, MEASURE_CLEAR, MEASURE_DOWNLOAD_GEOJSON,
      ]));
      offSpy.mockRestore();
    });
  });

  describe('distance measurement', () => {
    it('adds a Draw interaction of type LineString', () => {
      const { olMap } = renderTool();
      trigger(MEASURE_DISTANCE);
      expect(olMap.addInteraction).toHaveBeenCalled();
      expect(OlDraw.mock.calls.at(-1)[0].type).toBe('LineString');
    });

    it('activates measure mode and adds the tooltip overlay', () => {
      const toggleMeasureActive = jest.fn();
      const { olMap } = renderTool({ toggleMeasureActive });
      trigger(MEASURE_DISTANCE);
      expect(toggleMeasureActive).toHaveBeenCalledWith(true);
      expect(olMap.addOverlay).toHaveBeenCalled();
    });

    it('registers a contextmenu listener on the map', () => {
      const { olMap } = renderTool();
      trigger(MEASURE_DISTANCE);
      expect(olMap.on).toHaveBeenCalledWith('contextmenu', expect.any(Function));
    });

    it('removes the previous Draw interaction when restarted', () => {
      const { olMap } = renderTool();
      trigger(MEASURE_DISTANCE);
      olMap.removeInteraction.mockClear();
      trigger(MEASURE_DISTANCE);
      expect(olMap.removeInteraction).toHaveBeenCalled();
    });
  });

  describe('area measurement', () => {
    it('adds a Draw interaction of type Polygon', () => {
      const { olMap } = renderTool();
      trigger(MEASURE_AREA);
      expect(olMap.addInteraction).toHaveBeenCalled();
      expect(OlDraw.mock.calls.at(-1)[0].type).toBe('Polygon');
    });

    it('activates measure mode', () => {
      const toggleMeasureActive = jest.fn();
      renderTool({ toggleMeasureActive });
      trigger(MEASURE_AREA);
      expect(toggleMeasureActive).toHaveBeenCalledWith(true);
    });
  });

  describe('Draw condition function', () => {
    it('checks coordinates against the projection extent', () => {
      const { olMap } = renderTool();
      trigger(MEASURE_DISTANCE);
      const { condition } = OlDraw.mock.calls.at(-1)[0];
      const result = condition({ originalEvent: { x: 100, y: 200 } });
      expect(olMap.getCoordinateFromPixel).toHaveBeenCalledWith([100, 200]);
      expect(areCoordinatesWithinExtent).toHaveBeenCalled();
      expect(result).toBe(true);
    });
  });

  describe('drawstart callback', () => {
    it('disables click-zoom and listens for geometry changes', () => {
      const triggerSpy = jest.spyOn(events, 'trigger');
      renderTool();
      trigger(MEASURE_DISTANCE);

      const geom = makeLineGeometry();
      act(() => { mockDrawCallbacks.drawstart({ feature: makeFeature(geom) }); });

      expect(triggerSpy).toHaveBeenCalledWith(MAP_DISABLE_CLICK_ZOOM);
      expect(geom.on).toHaveBeenCalledWith('change', expect.any(Function));
      triggerSpy.mockRestore();
    });

    it('positions the tooltip at the LineString last coordinate on change', () => {
      const { rerender, props } = renderTool();
      trigger(MEASURE_DISTANCE);
      rerenderTool(rerender, props);

      const overlay = OlOverlay.mock.results.at(-1).value;
      const lastCoord = [99, 88];
      const geom = makeLineGeometry(lastCoord);
      act(() => { mockDrawCallbacks.drawstart({ feature: makeFeature(geom) }); });

      const changeHandler = geom.on.mock.calls.find(([evt]) => evt === 'change')[1];
      act(() => { changeHandler({ target: geom }); });

      expect(overlay.setPosition).toHaveBeenCalledWith(lastCoord);
    });

    it('positions the tooltip at the Polygon interior point on change', () => {
      const { rerender, props } = renderTool();
      trigger(MEASURE_AREA);
      rerenderTool(rerender, props);

      const overlay = OlOverlay.mock.results.at(-1).value;
      const interior = [3, 4];
      const geom = makePolygonGeometry(interior);
      act(() => { mockDrawCallbacks.drawstart({ feature: makeFeature(geom) }); });

      const changeHandler = geom.on.mock.calls.find(([evt]) => evt === 'change')[1];
      act(() => { changeHandler({ target: geom }); });

      expect(overlay.setPosition).toHaveBeenCalledWith(interior);
    });
  });

  describe('drawend callback', () => {
    const startAndEnd = () => {
      const userUpdate = jest.fn();
      const toggleMeasureActive = jest.fn();
      const {
        rerender, props,
      } = renderTool({ updateMeasurements: userUpdate, toggleMeasureActive });
      trigger(MEASURE_DISTANCE);
      rerenderTool(rerender, props);

      const overlay = OlOverlay.mock.results.at(-1).value;
      const triggerSpy = jest.spyOn(events, 'trigger');
      act(() => { mockDrawCallbacks.drawend({ feature: makeFeature(makeLineGeometry()) }); });
      return {
        overlay, userUpdate, toggleMeasureActive, triggerSpy,
      };
    };

    it('offsets the overlay and stores the measurement', () => {
      const { overlay, userUpdate } = startAndEnd();
      expect(overlay.setOffset).toHaveBeenCalledWith([0, -7]);
      expect(userUpdate).toHaveBeenCalled();
    });

    it('terminates the draw (deactivates and re-enables click zoom)', () => {
      const { toggleMeasureActive, triggerSpy } = startAndEnd();
      expect(toggleMeasureActive).toHaveBeenCalledWith(false);
      expect(triggerSpy).toHaveBeenCalledWith(MAP_ENABLE_CLICK_ZOOM);
      triggerSpy.mockRestore();
    });
  });

  describe('contextmenu (right-click) handling', () => {
    it('terminates the draw and removes the overlay on right-click', () => {
      const toggleMeasureActive = jest.fn();
      const { olMap } = renderTool({ toggleMeasureActive });
      trigger(MEASURE_DISTANCE);

      const contextHandler = olMap.on.mock.calls.find(([evt]) => evt === 'contextmenu')[1];
      const preventDefault = jest.fn();
      const triggerSpy = jest.spyOn(events, 'trigger');
      olMap.removeOverlay.mockClear();
      toggleMeasureActive.mockClear();

      act(() => { contextHandler({ preventDefault }); });

      expect(preventDefault).toHaveBeenCalled();
      expect(toggleMeasureActive).toHaveBeenCalledWith(false);
      expect(olMap.removeOverlay).toHaveBeenCalled();
      expect(OlObservableUnByKey).toHaveBeenCalled();
      expect(triggerSpy).toHaveBeenCalledWith(MAP_ENABLE_CLICK_ZOOM);
      triggerSpy.mockRestore();
    });
  });

  describe('clear measurements', () => {
    it('clears stored measurements and deactivates measure mode', () => {
      const userUpdate = jest.fn();
      const toggleMeasureActive = jest.fn();
      const { olMap } = renderTool({ updateMeasurements: userUpdate, toggleMeasureActive });
      trigger(MEASURE_DISTANCE);
      userUpdate.mockClear();
      toggleMeasureActive.mockClear();
      olMap.removeOverlay.mockClear();

      trigger(MEASURE_CLEAR);

      expect(userUpdate).toHaveBeenCalled();
      expect(toggleMeasureActive).toHaveBeenCalledWith(false);
      expect(olMap.removeOverlay).toHaveBeenCalled();
    });

    it('tears down the vector layer when one exists', () => {
      renderTool();
      trigger(MEASURE_DISTANCE);
      const layerInstance = OlVectorLayer.mock.results.at(-1).value;
      trigger(MEASURE_CLEAR);
      expect(layerInstance.setMap).toHaveBeenCalledWith(null);
    });
  });

  describe('download GeoJSON', () => {
    it('calls downloadGeoJSON for the current projection', () => {
      renderTool();
      trigger(MEASURE_DOWNLOAD_GEOJSON);
      expect(downloadGeoJSON).toHaveBeenCalledWith(expect.anything(), CRS.GEOGRAPHIC);
    });
  });

  describe('styleGeometryFn', () => {
    const getStyleGeometryFn = () => {
      const { Style } = require('ol/style');
      const call = Style.mock.calls.find((args) => args[0] && args[0].geometry);
      return call[0].geometry;
    };

    it('applies a great-circle arc to LineString geometry', () => {
      renderTool();
      const fn = getStyleGeometryFn();
      const geom = Object.create(OlLineString.prototype);
      fn({ getGeometry: () => geom });
      expect(transformLineStringArc).toHaveBeenCalledWith(geom, CRS.GEOGRAPHIC);
    });

    it('applies a great-circle arc to Polygon geometry', () => {
      renderTool();
      const fn = getStyleGeometryFn();
      const geom = Object.create(OlPolygon.prototype);
      fn({ getGeometry: () => geom });
      expect(transformPolygonArc).toHaveBeenCalledWith(geom, CRS.GEOGRAPHIC);
    });

    it('passes other geometry types through unchanged', () => {
      renderTool();
      const fn = getStyleGeometryFn();
      const geom = { type: 'Point' };
      expect(fn({ getGeometry: () => geom })).toBe(geom);
    });
  });

  describe('projection change', () => {
    it('terminates the in-progress draw when the crs changes', () => {
      const olMap = makeOlMap();
      const { rerender, props } = renderTool({ olMap });
      trigger(MEASURE_DISTANCE);
      olMap.removeInteraction.mockClear();

      rerenderTool(rerender, {
        ...props,
        crs: CRS.ARCTIC,
        proj: { selected: { crs: CRS.ARCTIC } },
      });

      expect(olMap.removeInteraction).toHaveBeenCalled();
    });
  });

  describe('recalculateAllMeasurements', () => {
    it('re-renders stored measurements when the unit of measure changes', () => {
      const { rerender, props } = renderTool({ unitOfMeasure: 'km' });
      trigger(MEASURE_DISTANCE);
      rerenderTool(rerender, props);

      const geom = makeLineGeometry();
      act(() => { mockDrawCallbacks.drawend({ feature: makeFeature(geom) }); });

      expect(() => {
        rerenderTool(rerender, { ...props, unitOfMeasure: 'mi' });
      }).not.toThrow();
      expect(geom.changed).toHaveBeenCalled();
    });
  });

  describe('removing an individual measurement', () => {
    it('removes the feature and overlay via the tooltip onRemove callback', () => {
      const userUpdate = jest.fn();
      const { rerender, props } = renderTool({ updateMeasurements: userUpdate });
      trigger(MEASURE_DISTANCE);
      rerenderTool(rerender, props);

      const { olMap } = props;
      act(() => { mockDrawCallbacks.drawend({ feature: makeFeature(makeLineGeometry()) }); });

      expect(mockTooltipProps).not.toBeNull();
      olMap.removeOverlay.mockClear();
      userUpdate.mockClear();
      act(() => { mockTooltipProps.onRemove(); });

      expect(olMap.removeOverlay).toHaveBeenCalled();
      expect(userUpdate).toHaveBeenCalled();
    });
  });

  describe('clearing stored measurements', () => {
    it('removes the overlay for each stored measurement', () => {
      const { rerender, props } = renderTool();
      trigger(MEASURE_DISTANCE);
      rerenderTool(rerender, props);

      const overlay = OlOverlay.mock.results.at(-1).value;
      act(() => { mockDrawCallbacks.drawend({ feature: makeFeature(makeLineGeometry()) }); });

      const { olMap } = props;
      olMap.removeOverlay.mockClear();
      trigger(MEASURE_CLEAR);

      expect(olMap.removeOverlay).toHaveBeenCalledWith(overlay);
    });
  });

  describe('projection change with an active tooltip', () => {
    it('removes the tooltip overlay when a tooltip-active element exists', () => {
      const olMap = makeOlMap();
      const { rerender, props } = renderTool({ olMap });
      trigger(MEASURE_DISTANCE);

      const activeEl = document.createElement('div');
      activeEl.className = 'tooltip-active';
      document.body.appendChild(activeEl);
      olMap.removeOverlay.mockClear();

      rerenderTool(rerender, {
        ...props,
        crs: CRS.ARCTIC,
        proj: { selected: { crs: CRS.ARCTIC } },
      });

      expect(olMap.removeOverlay).toHaveBeenCalled();
      document.body.removeChild(activeEl);
    });
  });

  describe('redux bindings', () => {
    it('mapStateToProps selects the expected slice of state', () => {
      const state = {
        map: { ui: { selected: { id: 'olMap' } }, rendered: true },
        proj: { selected: { crs: CRS.ARCTIC } },
        measure: { unitOfMeasure: 'mi' },
        config: {
          projections: {
            geographic: { crs: CRS.GEOGRAPHIC },
            arctic: { crs: CRS.ARCTIC },
          },
        },
      };
      const result = globalThis.measureConnectArgs.mapStateToProps(state);
      expect(result.crs).toBe(CRS.ARCTIC);
      expect(result.unitOfMeasure).toBe('mi');
      expect(result.olMap).toBe(state.map.ui.selected);
      expect(result.projections).toEqual([CRS.GEOGRAPHIC, CRS.ARCTIC]);
    });

    it('mapDispatchToProps dispatches the measure actions', () => {
      const dispatch = jest.fn();
      const bound = globalThis.measureConnectArgs.mapDispatchToProps(dispatch);
      bound.toggleMeasureActive(true);
      bound.updateMeasurements({ foo: 'bar' });
      expect(dispatch).toHaveBeenCalledTimes(2);
    });
  });
});