Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

17.4 KB
Raw Blame
/* eslint-disable react/jsx-props-no-spreading */
/* eslint-disable react/prop-types */
import { render } from '@testing-library/react';
import '@testing-library/jest-dom';

jest.mock('react-redux', () => {
  const actual = jest.requireActual('react-redux');
  const capture = {};
  const mockConnect = (msp, mdp) => {
    capture.msp = msp;
    capture.mdp = mdp;
    return (Component) => Component;
  };
  mockConnect.connectCapture = capture;
  return { ...actual, connect: mockConnect };
});

jest.mock('./layer-list', () => function MockLayerList(props) {
  return (
    <div
      data-testid="layer-list"
      data-title={props.title}
      data-group-id={props.groupId}
      data-layer-count={props.layers ? props.layers.length : 0}
      data-layer-split={props.layerSplit}
      data-show-dropdown={String(props.showDropdownBtn)}
    />
  );
});

jest.mock('../../modules/layers/selectors', () => ({
  getAllActiveOverlaysBaselayers: jest.fn(() => ({ baselayers: [], overlays: [] })),
  getActiveOverlayGroups: jest.fn(() => []),
  getActiveLayersMap: jest.fn(() => ({})),
  getFilteredOverlayGroups: jest.fn(() => []),
}));

jest.mock('../../modules/charting/actions', () => ({
  updateActiveChartingLayerAction: jest.fn((id) => ({ type: 'UPDATE_ACTIVE_CHARTING_LAYER', id })),
}));

import ChartingLayerMenu from './charting';
import {
  getAllActiveOverlaysBaselayers,
  getActiveOverlayGroups,
  getActiveLayersMap,
  getFilteredOverlayGroups,
} from '../../modules/layers/selectors';
import { updateActiveChartingLayerAction } from '../../modules/charting/actions';

let capturedMapStateToProps;
let capturedMapDispatchToProps;

beforeAll(() => {
  const { connect } = jest.requireMock('react-redux');
  capturedMapStateToProps = connect.connectCapture.msp;
  capturedMapDispatchToProps = connect.connectCapture.mdp;
});

beforeEach(() => {
  jest.clearAllMocks();
  getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays: [] });
  getActiveOverlayGroups.mockReturnValue([]);
  getActiveLayersMap.mockReturnValue({});
  getFilteredOverlayGroups.mockReturnValue([]);
});

const defaultProps = {
  activeLayersWithPalettes: [],
  height: 500,
  isActive: true,
  isEmbedModeActive: false,
  updateActiveChartingLayer: jest.fn(),
  renderedPalettes: {},
  activeChartingLayer: null,
};

const renderComponent = (propOverrides = {}) => render(
  <ChartingLayerMenu {...defaultProps} {...propOverrides} />,
);

describe('ChartingLayerMenu rendering', () => {
  it('renders the scroll container when isActive is true', () => {
    const { container } = renderComponent();
    expect(container.querySelector('#layers-scroll-container')).toBeInTheDocument();
  });

  it('renders nothing when isActive is false', () => {
    const { container } = renderComponent({ isActive: false });
    expect(container.firstChild).toBeNull();
  });

  it('renders LayerList with correct props', () => {
    const layers = [{ id: 'layer1' }, { id: 'layer2' }];
    const { getByTestId } = renderComponent({ activeLayersWithPalettes: layers });
    const list = getByTestId('layer-list');
    expect(list).toHaveAttribute('data-title', 'Overlays');
    expect(list).toHaveAttribute('data-group-id', 'overlays');
    expect(list).toHaveAttribute('data-layer-count', '2');
    expect(list).toHaveAttribute('data-layer-split', '2');
    expect(list).toHaveAttribute('data-show-dropdown', 'false');
  });

  it('sets layerSplit to activeLayersWithPalettes.length', () => {
    const layers = [{ id: 'a' }, { id: 'b' }, { id: 'c' }];
    const { getByTestId } = renderComponent({ activeLayersWithPalettes: layers });
    expect(getByTestId('layer-list')).toHaveAttribute('data-layer-split', '3');
  });

  it('always passes showDropdownBtn=false to LayerList', () => {
    const { getByTestId } = renderComponent();
    expect(getByTestId('layer-list')).toHaveAttribute('data-show-dropdown', 'false');
  });
});

// ─── scrollContainerStyles ────────────────────────────────────────────────────

describe('ChartingLayerMenu scroll container styles', () => {
  it('applies height-based maxHeight when not in embed mode', () => {
    const { container } = renderComponent({ height: 400, isEmbedModeActive: false });
    const el = container.querySelector('#layers-scroll-container');
    expect(el.style.maxHeight).toBe('400px');
    expect(el.style.minHeight).toBe('100px');
  });

  it('applies 55vh maxHeight and 25px minHeight in embed mode', () => {
    const { container } = renderComponent({ isEmbedModeActive: true });
    const el = container.querySelector('#layers-scroll-container');
    expect(el.style.maxHeight).toBe('55vh');
    expect(el.style.minHeight).toBe('25px');
  });

  it('sets overflowY to auto', () => {
    const { container } = renderComponent();
    const el = container.querySelector('#layers-scroll-container');
    expect(el.style.overflowY).toBe('auto');
  });
});

// ─── useEffect ────────────────────────────────────────────────────────────────

describe('ChartingLayerMenu useEffect', () => {
  it('calls updateActiveChartingLayer with first non-hidden layer id when renderedPalettes is non-empty and activeChartingLayer is null', () => {
    const updateActiveChartingLayer = jest.fn();
    const activeLayersWithPalettes = [
      { id: 'layer-a', shouldHide: false },
      { id: 'layer-b', shouldHide: false },
    ];
    renderComponent({
      updateActiveChartingLayer,
      activeChartingLayer: null,
      renderedPalettes: { palette1: {} },
      activeLayersWithPalettes,
    });
    expect(updateActiveChartingLayer).toHaveBeenCalledWith('layer-a');
  });

  it('skips hidden layers and picks first visible one', () => {
    const updateActiveChartingLayer = jest.fn();
    const activeLayersWithPalettes = [
      { id: 'hidden-layer', shouldHide: true },
      { id: 'visible-layer', shouldHide: false },
    ];
    renderComponent({
      updateActiveChartingLayer,
      activeChartingLayer: null,
      renderedPalettes: { palette1: {} },
      activeLayersWithPalettes,
    });
    expect(updateActiveChartingLayer).toHaveBeenCalledWith('visible-layer');
  });

  it('does not call updateActiveChartingLayer when activeChartingLayer is already set', () => {
    const updateActiveChartingLayer = jest.fn();
    renderComponent({
      updateActiveChartingLayer,
      activeChartingLayer: 'existing-layer',
      renderedPalettes: { palette1: {} },
      activeLayersWithPalettes: [{ id: 'layer-a', shouldHide: false }],
    });
    expect(updateActiveChartingLayer).not.toHaveBeenCalled();
  });

  it('does not call updateActiveChartingLayer when renderedPalettes is empty', () => {
    const updateActiveChartingLayer = jest.fn();
    renderComponent({
      updateActiveChartingLayer,
      activeChartingLayer: null,
      renderedPalettes: {},
      activeLayersWithPalettes: [{ id: 'layer-a', shouldHide: false }],
    });
    expect(updateActiveChartingLayer).not.toHaveBeenCalled();
  });

  it('re-runs when renderedPalettes changes', () => {
    const updateActiveChartingLayer = jest.fn();
    const activeLayersWithPalettes = [{ id: 'layer-a', shouldHide: false }];
    const { rerender } = renderComponent({
      updateActiveChartingLayer,
      activeChartingLayer: null,
      renderedPalettes: {},
      activeLayersWithPalettes,
    });
    expect(updateActiveChartingLayer).not.toHaveBeenCalled();

    const newPalettes = { palette1: {} };
    rerender(
      <ChartingLayerMenu
        {...defaultProps}
        updateActiveChartingLayer={updateActiveChartingLayer}
        activeChartingLayer={null}
        renderedPalettes={newPalettes}
        activeLayersWithPalettes={activeLayersWithPalettes}
      />,
    );
    expect(updateActiveChartingLayer).toHaveBeenCalledWith('layer-a');
  });
});

describe('mapStateToProps', () => {
  const makeState = (overrides = {}) => ({
    compare: { active: false },
    charting: { active: true, activeLayer: null },
    embed: { isEmbedModeActive: false },
    layers: {
      active: { groupOverlays: false },
      activeB: { groupOverlays: true },
    },
    animation: { isPlaying: false },
    screenSize: { isMobileDevice: false },
    palettes: { rendered: {} },
    ...overrides,
  });

  beforeEach(() => {
    getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays: [] });
    getActiveLayersMap.mockReturnValue({});
    getActiveOverlayGroups.mockReturnValue([]);
    getFilteredOverlayGroups.mockReturnValue([]);
  });

  it('maps isAnimating from animation.isPlaying', () => {
    const state = makeState({ animation: { isPlaying: true } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.isAnimating).toBe(true);
  });

  it('maps isCompareActive from compare.active', () => {
    const state = makeState({ compare: { active: true } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.isCompareActive).toBe(true);
  });

  it('maps isChartingActive from charting.active', () => {
    const state = makeState({ charting: { active: true, activeLayer: null } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.isChartingActive).toBe(true);
  });

  it('maps activeChartingLayer from charting.activeLayer', () => {
    const state = makeState({ charting: { active: true, activeLayer: 'layer-x' } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.activeChartingLayer).toBe('layer-x');
  });

  it('maps isEmbedModeActive from embed state', () => {
    const state = makeState({ embed: { isEmbedModeActive: true } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.isEmbedModeActive).toBe(true);
  });

  it('maps isMobile from screenSize.isMobileDevice', () => {
    const state = makeState({ screenSize: { isMobileDevice: true } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.isMobile).toBe(true);
  });

  it('maps groupOverlays from layers[compareState]', () => {
    const state = makeState();
    expect(capturedMapStateToProps(state, { compareState: 'active' }).groupOverlays).toBe(false);
    expect(capturedMapStateToProps(state, { compareState: 'activeB' }).groupOverlays).toBe(true);
  });

  it('calls getActiveLayersMap with state', () => {
    const state = makeState();
    capturedMapStateToProps(state, { compareState: 'active' });
    expect(getActiveLayersMap).toHaveBeenCalledWith(state);
  });

  it('uses getActiveOverlayGroups when groupOverlays is true', () => {
    const state = makeState();
    capturedMapStateToProps(state, { compareState: 'activeB' });
    expect(getActiveOverlayGroups).toHaveBeenCalledWith(state);
  });

  it('returns empty overlayGroups when groupOverlays is false', () => {
    const state = makeState();
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.overlayGroups).toEqual([]);
    expect(getActiveOverlayGroups).not.toHaveBeenCalled();
  });

  it('maps renderedPalettes from palettes.rendered', () => {
    const rendered = { pal1: {} };
    const state = makeState({ palettes: { rendered } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.renderedPalettes).toBe(rendered);
  });

  it('filters hidden and Reference layers in embed mode', () => {
    const overlays = [
      { id: 'vis', visible: true, layergroup: 'Science', palette: { id: 'p1' }, layerPeriod: 'Daily', disableCharting: false },
      { id: 'hidden', visible: false, layergroup: 'Science', palette: { id: 'p2' }, layerPeriod: 'Daily', disableCharting: false },
      { id: 'ref', visible: true, layergroup: 'Reference', palette: { id: 'p3' }, layerPeriod: 'Daily', disableCharting: false },
    ];
    const baselayers = [
      { id: 'base-vis', visible: true },
      { id: 'base-hidden', visible: false },
    ];
    getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers, overlays });
    const state = makeState({ embed: { isEmbedModeActive: true }, palettes: { rendered: {} } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.overlays.map((l) => l.id)).toEqual(['vis']);
    expect(result.baselayers.map((l) => l.id)).toEqual(['base-vis']);
    expect(getFilteredOverlayGroups).toHaveBeenCalled();
  });

  it('does not filter layers when not in embed mode', () => {
    const overlays = [
      { id: 'vis', visible: true, layergroup: 'Science', palette: { id: 'p1' }, layerPeriod: 'Daily', disableCharting: false },
      { id: 'hidden', visible: false, layergroup: 'Science', palette: { id: 'p2' }, layerPeriod: 'Daily', disableCharting: false },
    ];
    getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays });
    const state = makeState({ palettes: { rendered: {} } });
    const result = capturedMapStateToProps(state, { compareState: 'active' });
    expect(result.overlays).toHaveLength(2);
    expect(getFilteredOverlayGroups).not.toHaveBeenCalled();
  });

  describe('activeLayersWithPalettes shouldHide logic', () => {
    it('shouldHide is false for a qualifying continuous daily layer with rendered palette', () => {
      const overlay = {
        id: 'good',
        visible: true,
        layergroup: 'Science',
        palette: { id: 'pal1' },
        layerPeriod: 'Daily',
        disableCharting: false,
      };
      getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays: [overlay] });
      const rendered = { pal1: { maps: [{ type: 'continuous' }] } };
      const state = makeState({ palettes: { rendered } });
      const result = capturedMapStateToProps(state, { compareState: 'active' });
      expect(result.activeLayersWithPalettes[0].shouldHide).toBe(false);
    });

    it('shouldHide is true when layer has no palette', () => {
      const overlay = {
        id: 'no-palette',
        visible: true,
        layergroup: 'Science',
        layerPeriod: 'Daily',
        disableCharting: false,
      };
      getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays: [overlay] });
      const state = makeState({ palettes: { rendered: {} } });
      const result = capturedMapStateToProps(state, { compareState: 'active' });
      expect(result.activeLayersWithPalettes[0].shouldHide).toBe(true);
    });

    it('shouldHide is true when palette is not rendered', () => {
      const overlay = {
        id: 'unrendered',
        visible: true,
        layergroup: 'Science',
        palette: { id: 'unrendered-pal' },
        layerPeriod: 'Daily',
        disableCharting: false,
      };
      getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays: [overlay] });
      const state = makeState({ palettes: { rendered: {} } });
      const result = capturedMapStateToProps(state, { compareState: 'active' });
      expect(result.activeLayersWithPalettes[0].shouldHide).toBe(true);
    });

    it('shouldHide is true when palette type is not continuous', () => {
      const overlay = {
        id: 'classification',
        visible: true,
        layergroup: 'Science',
        palette: { id: 'pal-cls' },
        layerPeriod: 'Daily',
        disableCharting: false,
      };
      getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays: [overlay] });
      const rendered = { 'pal-cls': { maps: [{ type: 'classification' }] } };
      const state = makeState({ palettes: { rendered } });
      const result = capturedMapStateToProps(state, { compareState: 'active' });
      expect(result.activeLayersWithPalettes[0].shouldHide).toBe(true);
    });

    it('shouldHide is true when layerPeriod is not Daily', () => {
      const overlay = {
        id: 'monthly',
        visible: true,
        layergroup: 'Science',
        palette: { id: 'pal-m' },
        layerPeriod: 'Monthly',
        disableCharting: false,
      };
      getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays: [overlay] });
      const rendered = { 'pal-m': { maps: [{ type: 'continuous' }] } };
      const state = makeState({ palettes: { rendered } });
      const result = capturedMapStateToProps(state, { compareState: 'active' });
      expect(result.activeLayersWithPalettes[0].shouldHide).toBe(true);
    });

    it('shouldHide is true when disableCharting is true', () => {
      const overlay = {
        id: 'disabled',
        visible: true,
        layergroup: 'Science',
        palette: { id: 'pal-d' },
        layerPeriod: 'Daily',
        disableCharting: true,
      };
      getAllActiveOverlaysBaselayers.mockReturnValue({ baselayers: [], overlays: [overlay] });
      const rendered = { 'pal-d': { maps: [{ type: 'continuous' }] } };
      const state = makeState({ palettes: { rendered } });
      const result = capturedMapStateToProps(state, { compareState: 'active' });
      expect(result.activeLayersWithPalettes[0].shouldHide).toBe(true);
    });
  });
});

describe('mapDispatchToProps', () => {
  it('updateActiveChartingLayer dispatches updateActiveChartingLayerAction', () => {
    const dispatch = jest.fn();
    const { updateActiveChartingLayer } = capturedMapDispatchToProps(dispatch);
    updateActiveChartingLayer('my-layer');
    expect(updateActiveChartingLayerAction).toHaveBeenCalledWith('my-layer');
    expect(dispatch).toHaveBeenCalledWith({ type: 'UPDATE_ACTIVE_CHARTING_LAYER', id: 'my-layer' });
  });
});