Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

22.9 KB
Raw Blame
import {
  getLeadingExtent,
  getRotatedExtent,
  mapIsExtentValid,
  getMapParameterSetup,
  promiseImageryForTime,
  promiseImageryForTour,
} from './util';

jest.mock('ol/extent', () => ({
  getForViewAndSize: jest.fn(() => [10, 20, 30, 40]),
}));

jest.mock('ol/layer/Image', () => {
  const MockImageLayer = jest.fn().mockImplementation(() => ({}));
  return MockImageLayer;
});

jest.mock('ol/Map', () => {
  return jest.fn().mockImplementation(() => {
    const layersArray = [];
    const listeners = {};
    const instance = {
      getView: jest.fn(),
      setView: jest.fn(),
      addLayer: jest.fn((layer) => layersArray.push(layer)),
      removeLayer: jest.fn((layer) => {
        const idx = layersArray.indexOf(layer);
        if (idx !== -1) layersArray.splice(idx, 1);
      }),
      getLayers: jest.fn(() => ({ getArray: jest.fn(() => layersArray) })),
      on: jest.fn((event, cb) => { listeners[event] = cb; }),
      un: jest.fn((event) => { delete listeners[event]; }),
      fire: (event) => { if (listeners[event]) listeners[event](); },
      layersArray,
    };
    return instance;
  });
});

jest.mock('../link/util', () => ({
  encode: jest.fn((val) => `encoded:${val}`),
}));

jest.mock('../layers/selectors', () => ({
  getActiveVisibleLayersAtDate: jest.fn(),
}));

jest.mock('../date/util', () => ({
  tryCatchDate: jest.fn((dateString) => new Date(dateString)),
}));

import * as olExtent from 'ol/extent';
import OlMap from 'ol/Map';
import { encode } from '../link/util';
import { getActiveVisibleLayersAtDate } from '../layers/selectors';
import { tryCatchDate } from '../date/util';

function makeMockMap(view) {
  return {
    getView: jest.fn(() => view || {}),
    getSize: jest.fn(() => [800, 600]),
  };
}

function makeBaseState(uiOverrides = {}) {
  const mockChanged = jest.fn();
  const mockView = { changed: mockChanged };
  const mockSelected = { getView: jest.fn(() => mockView) };
  const mockCache = { getItem: jest.fn(() => null) };
  const mockLayerKey = jest.fn(() => 'key');
  const mockCreateLayer = jest.fn();

  const state = {
    map: {
      ui: {
        proj: 'geographic',
        cache: mockCache,
        selected: mockSelected,
        createLayer: mockCreateLayer,
        layerKey: mockLayerKey,
        ...uiOverrides,
      },
    },
  };

  return { state, mockChanged, mockCache, mockSelected, mockCreateLayer, mockLayerKey };
}

function makeTileLayer() {
  return {
    isVector: false,
    setVisible: jest.fn(),
  };
}

function makeLayerGroup(layers, proj = 'arctic') {
  return {
    wv: { proj },
    getLayersArray: jest.fn(() => layers),
  };
}

describe('getLeadingExtent', () => {
  const minLat = -46.546875;
  const maxLat = 53.015625;

  function makeUTCDate(hour) {
    return new Date(Date.UTC(2020, 0, 1, hour, 0, 0));
  }

  test('hour 0 forces curHour to 23', () => {
    const result = getLeadingExtent(makeUTCDate(0));
    const expectedMinLon = 20.6015625 + 23 * (-200.53125 / 23.0);
    const expectedMaxLon = expectedMinLon + 159.328125;
    expect(result).toEqual([expectedMinLon, minLat, expectedMaxLon, maxLat]);
  });

  test('hour 1 forces curHour to 23', () => {
    const result = getLeadingExtent(makeUTCDate(1));
    const expectedMinLon = 20.6015625 + 23 * (-200.53125 / 23.0);
    const expectedMaxLon = expectedMinLon + 159.328125;
    expect(result).toEqual([expectedMinLon, minLat, expectedMaxLon, maxLat]);
  });

  test('hour 2 forces curHour to 23', () => {
    const result = getLeadingExtent(makeUTCDate(2));
    const expectedMinLon = 20.6015625 + 23 * (-200.53125 / 23.0);
    const expectedMaxLon = expectedMinLon + 159.328125;
    expect(result).toEqual([expectedMinLon, minLat, expectedMaxLon, maxLat]);
  });

  test('hour 3 forces curHour to 0', () => {
    const result = getLeadingExtent(makeUTCDate(3));
    const expectedMinLon = 20.6015625 + 0 * (-200.53125 / 23.0);
    const expectedMaxLon = expectedMinLon + 159.328125;
    expect(result).toEqual([expectedMinLon, minLat, expectedMaxLon, maxLat]);
  });

  test('hour 8 forces curHour to 0', () => {
    const result = getLeadingExtent(makeUTCDate(8));
    const expectedMinLon = 20.6015625 + 0 * (-200.53125 / 23.0);
    const expectedMaxLon = expectedMinLon + 159.328125;
    expect(result).toEqual([expectedMinLon, minLat, expectedMaxLon, maxLat]);
  });

  test('hour 9 uses actual hour', () => {
    const result = getLeadingExtent(makeUTCDate(9));
    const expectedMinLon = 20.6015625 + 9 * (-200.53125 / 23.0);
    const expectedMaxLon = expectedMinLon + 159.328125;
    expect(result).toEqual([expectedMinLon, minLat, expectedMaxLon, maxLat]);
  });

  test('hour 23 uses actual hour', () => {
    const result = getLeadingExtent(makeUTCDate(23));
    const expectedMinLon = 20.6015625 + 23 * (-200.53125 / 23.0);
    const expectedMaxLon = expectedMinLon + 159.328125;
    expect(result).toEqual([expectedMinLon, minLat, expectedMaxLon, maxLat]);
  });

  test('always returns a 4-element array with correct lat bounds', () => {
    const result = getLeadingExtent(makeUTCDate(12));
    expect(result).toHaveLength(4);
    expect(result[1]).toBe(minLat);
    expect(result[3]).toBe(maxLat);
  });
});

describe('getRotatedExtent', () => {
  test('calls getForViewAndSize with correct args and returns result', () => {
    const mockCenter = [0, 0];
    const mockResolution = 2000;
    const mockSize = [800, 600];
    const mockView = {
      getCenter: jest.fn(() => mockCenter),
      getResolution: jest.fn(() => mockResolution),
    };
    const mockMap = {
      getView: jest.fn(() => mockView),
      getSize: jest.fn(() => mockSize),
    };

    const result = getRotatedExtent(mockMap);

    expect(mockMap.getView).toHaveBeenCalled();
    expect(olExtent.getForViewAndSize)
      .toHaveBeenCalledWith(mockCenter, mockResolution, 0, mockSize);
    expect(result).toEqual([10, 20, 30, 40]);
  });
});

describe('mapIsExtentValid', () => {
  test('returns false for undefined input', () => {
    expect(mapIsExtentValid(undefined)).toBe(false);
  });

  test('returns true for valid array extent', () => {
    expect(mapIsExtentValid([10, 20, 30, 40])).toBe(true);
  });

  test('returns false when any value is NaN', () => {
    expect(mapIsExtentValid([10, NaN, 30, 40])).toBe(false);
  });

  test('returns false when all values are NaN', () => {
    expect(mapIsExtentValid([NaN, NaN, NaN, NaN])).toBe(false);
  });

  test('returns true for object with toArray returning valid values', () => {
    const extentObj = { toArray: () => [1, 2, 3, 4] };
    expect(mapIsExtentValid(extentObj)).toBe(true);
  });

  test('returns false for object with toArray returning NaN values', () => {
    const extentObj = { toArray: () => [1, NaN, 3, 4] };
    expect(mapIsExtentValid(extentObj)).toBe(false);
  });

  test('returns true for valid negative values', () => {
    expect(mapIsExtentValid([-180, -90, 180, 90])).toBe(true);
  });

  test('returns true for zero values', () => {
    expect(mapIsExtentValid([0, 0, 0, 0])).toBe(true);
  });
});

describe('getMapParameterSetup', () => {
  let config;
  let models;
  let errors;
  let parameters;
  let legacyState;

  beforeEach(() => {
    config = { pageLoadTime: new Date(Date.UTC(2020, 0, 1, 12, 0, 0)) };
    models = { map: { load: jest.fn() } };
    errors = [];
    parameters = {};
    legacyState = {};
    encode.mockReturnValue('encodedExtent');
  });

  test('calls models.map.load with legacyState and errors', () => {
    getMapParameterSetup(parameters, config, models, legacyState, errors);
    expect(models.map.load).toHaveBeenCalledWith(legacyState, errors);
  });

  test('returns object with v and r keys', () => {
    const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
    expect(result).toHaveProperty('v');
    expect(result).toHaveProperty('r');
  });

  test('v.stateKey is map.extent', () => {
    const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
    expect(result.v.stateKey).toBe('map.extent');
  });

  test('v.initialState is the leading extent', () => {
    const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
    expect(result.v.initialState).toEqual(getLeadingExtent(config.pageLoadTime));
  });

  test('r.stateKey is map.rotation', () => {
    const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
    expect(result.r.stateKey).toBe('map.rotation');
  });

  test('r.initialState is 0', () => {
    const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
    expect(result.r.initialState).toBe(0);
  });

  describe('v.options.parse', () => {
    test('parses valid extent string and returns float array', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      expect(result.v.options.parse('10,20,30,40')).toEqual([10, 20, 30, 40]);
    });

    test('returns leadingExtent and pushes error for invalid extent', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      const parsed = result.v.options.parse('foo,bar,baz,qux');
      expect(parsed).toEqual(getLeadingExtent(config.pageLoadTime));
      expect(errors).toHaveLength(1);
      expect(errors[0].message).toContain('Invalid extent');
    });
  });

  describe('v.options.serialize', () => {
    test('returns encoded extent when valid and not equal to leading extent', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      const currentState = { map: { rotation: 0, leadingExtent: [0, 0, 0, 0] } };
      const serialized = result.v.options.serialize([1, 2, 3, 4], currentState);
      expect(encode).toHaveBeenCalledWith([1, 2, 3, 4]);
      expect(serialized).toBe('encodedExtent');
    });

    test('returns undefined when extent equals leading extent', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      const leadingExtent = getLeadingExtent(config.pageLoadTime);
      const currentState = { map: { rotation: 0, leadingExtent } };
      expect(result.v.options.serialize(leadingExtent, currentState)).toBeUndefined();
    });

    test('uses getRotatedExtent when rotation is truthy', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      const mockView = {
        getCenter: jest.fn(() => [0, 0]),
        getResolution: jest.fn(() => 100),
      };
      const mockMap = {
        getView: jest.fn(() => mockView),
        getSize: jest.fn(() => [800, 600]),
      };
      const currentState = {
        map: {
          rotation: 1.0,
          leadingExtent: [0, 0, 0, 0],
          ui: { selected: mockMap },
        },
      };
      result.v.options.serialize([1, 2, 3, 4], currentState);
      expect(olExtent.getForViewAndSize).toHaveBeenCalled();
    });

    test('returns undefined when currentItemState is invalid and leadingExtent matches', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      const leadingExtent = getLeadingExtent(config.pageLoadTime);
      const currentState = { map: { rotation: 0, leadingExtent } };
      expect(result.v.options.serialize([NaN, NaN, NaN, NaN], currentState)).toBeUndefined();
    });
  });

  describe('r.options.parse', () => {
    test('returns 0 for a numeric string', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      expect(result.r.options.parse('45')).toBe(0);
    });

    test('returns 0 for another numeric string', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      expect(result.r.options.parse('180')).toBe(0);
    });

    test('returns NaN when passed NaN directly', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      expect(result.r.options.parse(NaN)).toBeNaN();
    });
  });

  describe('r.options.serialize', () => {
    test('returns degrees string when rotation is set and proj is not geographic', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      const currentState = { proj: { selected: { id: 'arctic' } } };
      expect(result.r.options.serialize(Math.PI, currentState)).toBe((180.0).toPrecision(6));
    });

    test('returns undefined when proj is geographic', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      const currentState = { proj: { selected: { id: 'geographic' } } };
      expect(result.r.options.serialize(Math.PI, currentState)).toBeUndefined();
    });

    test('returns undefined when currentItemState is falsy', () => {
      const result = getMapParameterSetup(parameters, config, models, legacyState, errors);
      const currentState = { proj: { selected: { id: 'arctic' } } };
      expect(result.r.options.serialize(0, currentState)).toBeUndefined();
    });
  });
});

describe('promiseImageryForTime', () => {
  beforeEach(() => {
    OlMap.mockClear();
    document.body.innerHTML = '';
  });

  test('returns undefined when map.ui.proj is falsy', async () => {
    const { state } = makeBaseState({ proj: null });
    const result = await promiseImageryForTime(state, new Date(), 'active');
    expect(result).toBeUndefined();
  });

  test('returns date when layers list is empty', async () => {
    const { state, mockChanged } = makeBaseState();
    getActiveVisibleLayersAtDate.mockReturnValue([]);
    const date = new Date('2020-01-01');
    const result = await promiseImageryForTime(state, date, 'active');
    expect(result).toBe(date);
    expect(mockChanged).toHaveBeenCalled();
  });

  test('skips granule layers', async () => {
    const { state, mockCreateLayer } = makeBaseState();
    getActiveVisibleLayersAtDate.mockReturnValue([{ type: 'granule' }]);
    await promiseImageryForTime(state, new Date(), 'active');
    expect(mockCreateLayer).not.toHaveBeenCalled();
  });

  test('skips titiler layers', async () => {
    const { state, mockCreateLayer } = makeBaseState();
    getActiveVisibleLayersAtDate.mockReturnValue([{ type: 'titiler' }]);
    await promiseImageryForTime(state, new Date(), 'active');
    expect(mockCreateLayer).not.toHaveBeenCalled();
  });

  test('uses cached item when available and does not call createLayer', async () => {
    const cachedLayerGroup = { wv: { proj: null } };
    const { state, mockCreateLayer, mockChanged } = makeBaseState();
    state.map.ui.cache.getItem.mockReturnValue(cachedLayerGroup);
    getActiveVisibleLayersAtDate.mockReturnValue([{ type: 'wms' }]);
    await promiseImageryForTime(state, new Date(), 'active');
    expect(mockCreateLayer).not.toHaveBeenCalled();
    expect(mockChanged).toHaveBeenCalled();
  });

  test('calls createLayer when layer is not cached', async () => {
    const layerGroup = { wv: { proj: null } };
    const { state, mockCreateLayer, mockChanged } = makeBaseState();
    mockCreateLayer.mockResolvedValue(layerGroup);
    getActiveVisibleLayersAtDate.mockReturnValue([{ type: 'wms' }]);
    await promiseImageryForTime(state, new Date(), 'active');
    expect(mockCreateLayer).toHaveBeenCalled();
    expect(mockChanged).toHaveBeenCalled();
  });
});

describe('promiseImageryForTour', () => {
  beforeEach(() => {
    OlMap.mockClear();
    document.body.innerHTML = '';
    tryCatchDate.mockImplementation((dateString) => new Date(dateString));
  });

  test('returns early when map.ui.proj is falsy', async () => {
    const { state, mockChanged } = makeBaseState({ proj: null });
    await promiseImageryForTour(state, [], '2020-01-01', 'active');
    expect(mockChanged).not.toHaveBeenCalled();
  });

  test('processes empty layer list and calls changed', async () => {
    const { state, mockChanged } = makeBaseState();
    await promiseImageryForTour(state, [], '2020-01-01', 'active');
    expect(mockChanged).toHaveBeenCalled();
  });

  test('skips granule layers', async () => {
    const { state, mockCreateLayer } = makeBaseState();
    await promiseImageryForTour(state, [{ type: 'granule' }], '2020-01-01', 'active');
    expect(mockCreateLayer).not.toHaveBeenCalled();
  });

  test('skips titiler layers', async () => {
    const { state, mockCreateLayer } = makeBaseState();
    await promiseImageryForTour(state, [{ type: 'titiler' }], '2020-01-01', 'active');
    expect(mockCreateLayer).not.toHaveBeenCalled();
  });

  test('defaults group to active when activeString is undefined', async () => {
    const { state, mockCreateLayer, mockLayerKey } = makeBaseState();
    const layerGroup = { wv: { proj: null } };
    mockCreateLayer.mockResolvedValue(layerGroup);
    await promiseImageryForTour(state, [{ type: 'wms' }], '2020-01-01', undefined);
    expect(mockLayerKey).toHaveBeenCalledWith(
      expect.anything(),
      expect.objectContaining({ group: 'active' }),
      state,
    );
  });

  test('builds style from layer.custom', async () => {
    const { state, mockCreateLayer, mockLayerKey } = makeBaseState();
    const layerGroup = { wv: { proj: null } };
    mockCreateLayer.mockResolvedValue(layerGroup);
    const layer = { type: 'wms', custom: 'myPalette' };
    await promiseImageryForTour(state, [layer], '2020-01-01', 'active');
    expect(mockLayerKey).toHaveBeenCalledWith(
      layer,
      expect.objectContaining({ style: 'palette=myPalette' }),
      state,
    );
  });

  test('builds style from layer.min', async () => {
    const { state, mockCreateLayer, mockLayerKey } = makeBaseState();
    const layerGroup = { wv: { proj: null } };
    mockCreateLayer.mockResolvedValue(layerGroup);
    const layer = { type: 'wms', min: 0.1 };
    await promiseImageryForTour(state, [layer], '2020-01-01', 'active');
    expect(mockLayerKey).toHaveBeenCalledWith(
      layer,
      expect.objectContaining({ style: 'min=0.1' }),
      state,
    );
  });

  test('builds style from layer.max', async () => {
    const { state, mockCreateLayer, mockLayerKey } = makeBaseState();
    const layerGroup = { wv: { proj: null } };
    mockCreateLayer.mockResolvedValue(layerGroup);
    const layer = { type: 'wms', max: 0.9 };
    await promiseImageryForTour(state, [layer], '2020-01-01', 'active');
    expect(mockLayerKey).toHaveBeenCalledWith(
      layer,
      expect.objectContaining({ style: 'max=0.9' }),
      state,
    );
  });

  test('builds style with squash', async () => {
    const { state, mockCreateLayer, mockLayerKey } = makeBaseState();
    const layerGroup = { wv: { proj: null } };
    mockCreateLayer.mockResolvedValue(layerGroup);
    const layer = { type: 'wms', squash: true };
    await promiseImageryForTour(state, [layer], '2020-01-01', 'active');
    expect(mockLayerKey).toHaveBeenCalledWith(
      layer,
      expect.objectContaining({ style: 'squash' }),
      state,
    );
  });

  test('builds style with noclip', async () => {
    const { state, mockCreateLayer, mockLayerKey } = makeBaseState();
    const layerGroup = { wv: { proj: null } };
    mockCreateLayer.mockResolvedValue(layerGroup);
    const layer = { type: 'wms', noclip: true };
    await promiseImageryForTour(state, [layer], '2020-01-01', 'active');
    expect(mockLayerKey).toHaveBeenCalledWith(
      layer,
      expect.objectContaining({ style: 'noclip' }),
      state,
    );
  });

  test('builds combined style string from all options', async () => {
    const { state, mockCreateLayer, mockLayerKey } = makeBaseState();
    const layerGroup = { wv: { proj: null } };
    mockCreateLayer.mockResolvedValue(layerGroup);
    const layer = { type: 'wms', custom: 'pal', min: 0.1, max: 0.9, squash: true, noclip: true };
    await promiseImageryForTour(state, [layer], '2020-01-01', 'active');
    expect(mockLayerKey).toHaveBeenCalledWith(
      layer,
      expect.objectContaining({ style: 'palette=pal,min=0.1,max=0.9,squash,noclip' }),
      state,
    );
  });

  test('does not set style when no style keys are present', async () => {
    const { state, mockCreateLayer, mockLayerKey } = makeBaseState();
    const layerGroup = { wv: { proj: null } };
    mockCreateLayer.mockResolvedValue(layerGroup);
    const layer = { type: 'wms' };
    await promiseImageryForTour(state, [layer], '2020-01-01', 'active');
    const callArgs = mockLayerKey.mock.calls[0][1];
    expect(callArgs).not.toHaveProperty('style');
  });

  test('uses cached item and does not call createLayer', async () => {
    const { state, mockCreateLayer, mockChanged } = makeBaseState();
    const cachedLayerGroup = { wv: { proj: null } };
    state.map.ui.cache.getItem.mockReturnValue(cachedLayerGroup);
    await promiseImageryForTour(state, [{ type: 'wms' }], '2020-01-01', 'active');
    expect(mockCreateLayer).not.toHaveBeenCalled();
    expect(mockChanged).toHaveBeenCalled();
  });
});

describe('promiseTileLayer (via promiseImageryForTime)', () => {
  beforeEach(() => {
    OlMap.mockClear();
    document.body.innerHTML = '';
  });

  test('resolves immediately when wv-map container is absent from DOM', async () => {
    const mockMap = makeMockMap();
    const tileLayer = makeTileLayer();
    const layerGroup = makeLayerGroup([tileLayer], 'arctic');
    const { state, mockChanged } = makeBaseState({
      createLayer: jest.fn().mockResolvedValue(layerGroup),
      proj: { arctic: mockMap },
    });

    getActiveVisibleLayersAtDate.mockReturnValue([{ type: 'wms' }]);

    await promiseImageryForTime(state, new Date(), 'active');
    expect(mockChanged).toHaveBeenCalled();
  });

  test('creates preloadMap and resolves after loadend fires', async () => {
    const mapContainer = document.createElement('div');
    mapContainer.setAttribute('id', 'wv-map');
    document.body.appendChild(mapContainer);

    const mockView = {};
    const mockMap = makeMockMap(mockView);
    const tileLayer = makeTileLayer();
    const layerGroup = makeLayerGroup([tileLayer], 'arctic');
    const { state, mockChanged } = makeBaseState({
      createLayer: jest.fn().mockResolvedValue(layerGroup),
      proj: { arctic: mockMap },
    });

    getActiveVisibleLayersAtDate.mockReturnValue([{ type: 'wms' }]);

    const promise = promiseImageryForTime(state, new Date(), 'active');

    await Promise.resolve();
    await Promise.resolve();

    const instance = OlMap.mock.results[0]?.value;
    if (instance?.fire) instance.fire('loadend');

    await promise;

    expect(OlMap).toHaveBeenCalled();
    expect(mockChanged).toHaveBeenCalled();
  });

  test('skips promiseTileLayer for vector layers', async () => {
    const mapContainer = document.createElement('div');
    mapContainer.setAttribute('id', 'wv-map');
    document.body.appendChild(mapContainer);

    const mockMap = makeMockMap();
    const vectorLayer = { isVector: true, setVisible: jest.fn() };
    const layerGroup = makeLayerGroup([vectorLayer], 'arctic');
    const { state, mockChanged } = makeBaseState({
      createLayer: jest.fn().mockResolvedValue(layerGroup),
      proj: { arctic: mockMap },
    });

    getActiveVisibleLayersAtDate.mockReturnValue([{ type: 'wms' }]);

    await promiseImageryForTime(state, new Date(), 'active');

    expect(vectorLayer.setVisible).not.toHaveBeenCalled();
    expect(mockChanged).toHaveBeenCalled();
  });
});