Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

Checking in first round of unit test files for containers/ directory

Jason Hurley28a102adfbf4
diff --git a/web/js/containers/animation-widget/animation-widget.test.js b/web/js/containers/animation-widget/animation-widget.test.js
index ca0c1d10f..b9161cfcb 100644
--- a/web/js/containers/animation-widget/animation-widget.test.js
+++ b/web/js/containers/animation-widget/animation-widget.test.js
@@ -1,3 +1,975 @@
-test('animation-widget container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, act } 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('../../util/util', () => ({
+ clearTimeUTC: jest.fn((date) => {
+ const d = new Date(date);
+ d.setUTCHours(0, 0, 0, 0);
+ return d;
+ }),
+}));
+
+jest.mock('../error-boundary', () => ({ children }) => <div data-testid="error-boundary">{children}</div>);
+
+jest.mock('../../components/animation-widget/play-queue', () => () => (
+ <div data-testid="play-queue" />
+));
+
+jest.mock('../../modules/map/util', () => ({
+ promiseImageryForTime: jest.fn(() => Promise.resolve()),
+}));
+
+jest.mock('../../modules/date/actions', () => ({
+ selectDate: jest.fn(() => ({ type: 'SELECT_DATE' })),
+ selectInterval: jest.fn(() => ({ type: 'SELECT_INTERVAL' })),
+ toggleCustomModal: jest.fn(() => ({ type: 'TOGGLE_CUSTOM_MODAL' })),
+}));
+
+jest.mock('../../modules/date/constants', () => ({
+ TIME_SCALE_FROM_NUMBER: {
+ 1: 'year',
+ 2: 'month',
+ 3: 'day',
+ 4: 'hour',
+ 5: 'minute',
+ },
+ customModalType: { ANIMATION: 'ANIMATION' },
+}));
+
+jest.mock('../../modules/animation/util', () => ({
+ snapToIntervalDelta: jest.fn((date) => date),
+ getNumberOfSteps: jest.fn(() => 10),
+}));
+
+jest.mock('../../modules/layers/selectors', () => ({
+ subdailyLayersActive: jest.fn(() => false),
+ getAllActiveLayers: jest.fn(() => []),
+ dateRange: jest.fn(() => null),
+}));
+
+jest.mock('../../modules/date/selectors', () => ({
+ getSelectedDate: jest.fn(() => new Date('2021-01-15')),
+}));
+
+jest.mock('../../modules/animation/actions', () => ({
+ play: jest.fn(() => ({ type: 'PLAY' })),
+ onClose: jest.fn(() => ({ type: 'CLOSE' })),
+ stop: jest.fn(() => ({ type: 'STOP' })),
+ toggleLooping: jest.fn(() => ({ type: 'TOGGLE_LOOPING' })),
+ changeFrameRate: jest.fn(() => ({ type: 'CHANGE_FRAME_RATE' })),
+ changeStartDate: jest.fn(() => ({ type: 'CHANGE_START_DATE' })),
+ changeEndDate: jest.fn(() => ({ type: 'CHANGE_END_DATE' })),
+ changeStartAndEndDate: jest.fn(() => ({ type: 'CHANGE_START_AND_END_DATE' })),
+ toggleAnimationCollapse: jest.fn(() => ({ type: 'TOGGLE_ANIMATION_COLLAPSE' })),
+}));
+
+jest.mock('../../util/customHooks', () => jest.fn(() => undefined));
+
+const desktopCapture = {};
+const mobileCapture = {};
+const collapsedCapture = {};
+
+jest.mock('./desktop-animation-widget', () => function MockDesktopWidget(props) {
+ Object.assign(desktopCapture, props);
+ return <div data-testid="desktop-animation-widget" />;
+});
+
+jest.mock('./mobile-animation-widget', () => function MockMobileWidget(props) {
+ Object.assign(mobileCapture, props);
+ return <div data-testid="mobile-animation-widget" />;
+});
+
+jest.mock('./collapsed-animation-widget', () => function MockCollapsedWidget(props) {
+ Object.assign(collapsedCapture, props);
+ return <div data-testid="collapsed-animation-widget" />;
+});
+
+jest.mock('../../components/kiosk/animation-tile-check/animation-tile-check', () => () => (
+ <div data-testid="animation-tile-check" />
+));
+
+import usePrevious from '../../util/customHooks';
+import util from '../../util/util';
+import AnimationWidget from './animation-widget';
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+const appNow = new Date('2021-06-01T00:00:00Z');
+const startDate = new Date('2021-01-01T00:00:00Z');
+const endDate = new Date('2021-03-01T00:00:00Z');
+
+const defaultProps = {
+ appNow,
+ animationCustomModalOpen: false,
+ autoplay: false,
+ breakpoints: {},
+ checkAnimationAvailability: false,
+ currentDate: new Date('2021-01-15'),
+ delta: 1,
+ endDate,
+ hasFutureLayers: false,
+ hasSubdailyLayers: false,
+ interval: 'day',
+ isActive: true,
+ isCollapsed: false,
+ isDistractionFreeModeActive: false,
+ isEmbedModeActive: false,
+ isKioskModeActive: false,
+ isLandscape: false,
+ isMobile: false,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ isPlaying: false,
+ isPortrait: true,
+ looping: false,
+ map: null,
+ maxDate: new Date('2021-06-01'),
+ minDate: new Date('2020-01-01'),
+ numberOfFrames: 10,
+ onClose: jest.fn(),
+ onPushLoop: jest.fn(),
+ onPushPause: jest.fn(),
+ onPushPlay: jest.fn(),
+ onSlide: jest.fn(),
+ onToggleAnimationCollapse: jest.fn(),
+ onUpdateEndDate: jest.fn(),
+ onUpdateStartDate: jest.fn(),
+ onUpdateStartAndEndDate: jest.fn(),
+ playDisabled: false,
+ promiseImageryForTime: jest.fn(),
+ screenHeight: 768,
+ screenWidth: 1024,
+ selectDate: jest.fn(),
+ sliderLabel: 'Frames Per Second',
+ speedRedux: 3,
+ snappedCurrentDate: new Date('2021-01-15'),
+ startDate,
+ subDailyMode: false,
+ autoSelected: false,
+ layers: [],
+};
+
+const renderWidget = (propOverrides = {}) => render(
+ <AnimationWidget {...defaultProps} {...propOverrides} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ usePrevious.mockReturnValue(undefined);
+ Object.keys(desktopCapture).forEach((k) => delete desktopCapture[k]);
+ Object.keys(mobileCapture).forEach((k) => delete mobileCapture[k]);
+ Object.keys(collapsedCapture).forEach((k) => delete collapsedCapture[k]);
+});
+
+describe('AnimationWidget rendering', () => {
+ it('returns null when isActive is false', () => {
+ const { container } = renderWidget({ isActive: false });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders the error boundary when active', () => {
+ const { getByTestId } = renderWidget();
+ expect(getByTestId('error-boundary')).toBeInTheDocument();
+ });
+
+ it('renders DesktopAnimationWidget when not mobile and not collapsed', () => {
+ const { getByTestId } = renderWidget({ isMobile: false, isCollapsed: false });
+ expect(getByTestId('desktop-animation-widget')).toBeInTheDocument();
+ });
+
+ it('renders MobileAnimationWidget when isMobile is true and not collapsed', () => {
+ const { getByTestId } = renderWidget({ isMobile: true, isCollapsed: false });
+ expect(getByTestId('mobile-animation-widget')).toBeInTheDocument();
+ });
+
+ it('does not render DesktopAnimationWidget when isMobile is true', () => {
+ const { queryByTestId } = renderWidget({ isMobile: true, isCollapsed: false });
+ expect(queryByTestId('desktop-animation-widget')).not.toBeInTheDocument();
+ });
+
+ it('renders CollapsedAnimationWidget when isCollapsed is true', () => {
+ const { getByTestId } = renderWidget({ isCollapsed: true });
+ expect(getByTestId('collapsed-animation-widget')).toBeInTheDocument();
+ });
+
+ it('does not render DesktopAnimationWidget when isCollapsed', () => {
+ const { queryByTestId } = renderWidget({ isCollapsed: true });
+ expect(queryByTestId('desktop-animation-widget')).not.toBeInTheDocument();
+ });
+
+ it('renders PlayQueue when isPlaying and checkAnimationAvailability is false', () => {
+ const { getByTestId } = renderWidget({ isPlaying: true, checkAnimationAvailability: false });
+ expect(getByTestId('play-queue')).toBeInTheDocument();
+ });
+
+ it('does not render PlayQueue when not isPlaying', () => {
+ const { queryByTestId } = renderWidget({ isPlaying: false });
+ expect(queryByTestId('play-queue')).not.toBeInTheDocument();
+ });
+
+ it('renders AnimationTileCheck when checkAnimationAvailability is true', () => {
+ const { getByTestId } = renderWidget({ checkAnimationAvailability: true });
+ expect(getByTestId('animation-tile-check')).toBeInTheDocument();
+ });
+
+ it('does not render PlayQueue when checkAnimationAvailability is true (even if playing)', () => {
+ const { queryByTestId } = renderWidget({
+ isPlaying: true,
+ checkAnimationAvailability: true,
+ });
+ expect(queryByTestId('play-queue')).not.toBeInTheDocument();
+ });
+});
+
+describe('AnimationWidget mount effect', () => {
+ it('calls onPushPlay when autoplay is true and not playing', () => {
+ const onPushPlay = jest.fn();
+ renderWidget({ autoplay: true, isPlaying: false, onPushPlay });
+ expect(onPushPlay).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call onPushPlay when autoplay is true but already playing', () => {
+ const onPushPlay = jest.fn();
+ renderWidget({ autoplay: true, isPlaying: true, onPushPlay });
+ expect(onPushPlay).not.toHaveBeenCalled();
+ });
+
+ it('does not call onPushPlay when autoplay is false', () => {
+ const onPushPlay = jest.fn();
+ renderWidget({ autoplay: false, isPlaying: false, onPushPlay });
+ expect(onPushPlay).not.toHaveBeenCalled();
+ });
+
+ it('calls onToggleAnimationCollapse when isEmbedModeActive is true', () => {
+ const onToggleAnimationCollapse = jest.fn();
+ renderWidget({ isEmbedModeActive: true, onToggleAnimationCollapse });
+ expect(onToggleAnimationCollapse).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call onToggleAnimationCollapse when isEmbedModeActive is false', () => {
+ const onToggleAnimationCollapse = jest.fn();
+ renderWidget({ isEmbedModeActive: false, onToggleAnimationCollapse });
+ expect(onToggleAnimationCollapse).not.toHaveBeenCalled();
+ });
+});
+
+describe('AnimationWidget update effect', () => {
+ it('calls onUpdateEndDate with appNow when hasFutureLayers changes from true to false', () => {
+ const onUpdateEndDate = jest.fn();
+ // First call to usePrevious (prevSubDailyMode) returns undefined
+ // Second call to usePrevious (prevHasFutureLayers) returns true
+ usePrevious
+ .mockReturnValueOnce(undefined)
+ .mockReturnValueOnce(true);
+ renderWidget({ hasFutureLayers: false, onUpdateEndDate });
+ expect(onUpdateEndDate).toHaveBeenCalledWith(appNow);
+ });
+
+ it('does not call onUpdateEndDate when hasFutureLayers stays false', () => {
+ const onUpdateEndDate = jest.fn();
+ usePrevious
+ .mockReturnValueOnce(undefined)
+ .mockReturnValueOnce(false);
+ renderWidget({ hasFutureLayers: false, onUpdateEndDate });
+ expect(onUpdateEndDate).not.toHaveBeenCalled();
+ });
+
+ it('does not call onUpdateEndDate when hasFutureLayers stays true', () => {
+ const onUpdateEndDate = jest.fn();
+ usePrevious
+ .mockReturnValueOnce(undefined)
+ .mockReturnValueOnce(true);
+ renderWidget({ hasFutureLayers: true, onUpdateEndDate });
+ expect(onUpdateEndDate).not.toHaveBeenCalled();
+ });
+
+ it('does not update widget position on subDailyMode change when widget was manually moved', () => {
+ usePrevious
+ .mockReturnValueOnce(false)
+ .mockReturnValueOnce(false);
+ renderWidget({ subDailyMode: true });
+ act(() => {
+ desktopCapture.onExpandedDrag({}, { x: 50, y: 50 });
+ });
+ expect(desktopCapture.widgetPosition).toEqual({ x: 50, y: 50 });
+ });
+});
+
+describe('handleDragStart', () => {
+ const makeEvent = (className) => ({
+ target: {
+ classList: {
+ contains: (c) => c === className,
+ },
+ },
+ });
+
+ beforeEach(() => {
+ renderWidget();
+ });
+
+ it('returns true when target has class wv-animation-widget', () => {
+ expect(desktopCapture.handleDragStart(makeEvent('wv-animation-widget'), {})).toBe(true);
+ });
+
+ it('returns true when target has class wv-animation-widget-header', () => {
+ expect(desktopCapture.handleDragStart(makeEvent('wv-animation-widget-header'), {})).toBe(true);
+ });
+
+ it('returns true when target has class wv-anim-dates-case', () => {
+ expect(desktopCapture.handleDragStart(makeEvent('wv-anim-dates-case'), {})).toBe(true);
+ });
+
+ it('returns true when target has class thru-label', () => {
+ expect(desktopCapture.handleDragStart(makeEvent('thru-label'), {})).toBe(true);
+ });
+
+ it('returns false when target has an unrecognized class', () => {
+ expect(desktopCapture.handleDragStart(makeEvent('some-other-class'), {})).toBe(false);
+ });
+
+ it('handleDragStart is also passed to CollapsedAnimationWidget', () => {
+ renderWidget({ isCollapsed: true });
+ expect(typeof collapsedCapture.handleDragStart).toBe('function');
+ expect(collapsedCapture.handleDragStart(makeEvent('wv-animation-widget'), {})).toBe(true);
+ });
+});
+
+describe('drag handlers', () => {
+ it('onExpandedDrag updates widgetPosition and marks widget as moved', () => {
+ renderWidget();
+ act(() => {
+ desktopCapture.onExpandedDrag({}, { x: 200, y: 100 });
+ });
+ expect(desktopCapture.widgetPosition).toEqual({ x: 200, y: 100 });
+ });
+
+ it('onCollapsedDrag updates collapsedWidgetPosition', () => {
+ renderWidget({ isCollapsed: true });
+ act(() => {
+ collapsedCapture.onCollapsedDrag({}, { x: 50, y: 75 });
+ });
+ expect(collapsedCapture.collapsedWidgetPosition).toEqual({ x: 50, y: 75 });
+ });
+});
+
+describe('onLoop', () => {
+ it('calls onPushLoop when onLoop is triggered', () => {
+ const onPushLoop = jest.fn();
+ renderWidget({ onPushLoop, looping: false });
+ act(() => {
+ desktopCapture.onLoop();
+ });
+ expect(onPushLoop).toHaveBeenCalledWith(false);
+ });
+
+ it('passes current looping value to onPushLoop', () => {
+ const onPushLoop = jest.fn();
+ renderWidget({ onPushLoop, looping: true });
+ act(() => {
+ desktopCapture.onLoop();
+ });
+ expect(onPushLoop).toHaveBeenCalledWith(true);
+ });
+});
+
+describe('onDateChange', () => {
+ it('calls onUpdateStartDate when start date changes', () => {
+ const onUpdateStartDate = jest.fn();
+ const onUpdateEndDate = jest.fn();
+ renderWidget({ onUpdateStartDate, onUpdateEndDate });
+ const newStart = new Date('2021-02-01');
+ act(() => {
+ desktopCapture.onDateChange([newStart, endDate]);
+ });
+ expect(onUpdateStartDate).toHaveBeenCalledWith(newStart);
+ expect(onUpdateEndDate).not.toHaveBeenCalled();
+ });
+
+ it('calls onUpdateEndDate when end date changes', () => {
+ const onUpdateStartDate = jest.fn();
+ const onUpdateEndDate = jest.fn();
+ renderWidget({ onUpdateStartDate, onUpdateEndDate });
+ const newEnd = new Date('2021-04-01');
+ act(() => {
+ desktopCapture.onDateChange([startDate, newEnd]);
+ });
+ expect(onUpdateEndDate).toHaveBeenCalledWith(newEnd);
+ expect(onUpdateStartDate).not.toHaveBeenCalled();
+ });
+
+ it('calls both update functions when both dates change', () => {
+ const onUpdateStartDate = jest.fn();
+ const onUpdateEndDate = jest.fn();
+ renderWidget({ onUpdateStartDate, onUpdateEndDate });
+ const newStart = new Date('2021-02-01');
+ const newEnd = new Date('2021-04-01');
+ act(() => {
+ desktopCapture.onDateChange([newStart, newEnd]);
+ });
+ expect(onUpdateStartDate).toHaveBeenCalledWith(newStart);
+ expect(onUpdateEndDate).toHaveBeenCalledWith(newEnd);
+ });
+
+ it('calls neither update function when dates are unchanged', () => {
+ const onUpdateStartDate = jest.fn();
+ const onUpdateEndDate = jest.fn();
+ renderWidget({ onUpdateStartDate, onUpdateEndDate });
+ act(() => {
+ desktopCapture.onDateChange([startDate, endDate]);
+ });
+ expect(onUpdateStartDate).not.toHaveBeenCalled();
+ expect(onUpdateEndDate).not.toHaveBeenCalled();
+ });
+});
+
+describe('zeroDates', () => {
+ it('calls clearTimeUTC for non-subdaily mode', () => {
+ renderWidget({ subDailyMode: false });
+ desktopCapture.zeroDates();
+ expect(util.clearTimeUTC).toHaveBeenCalledWith(startDate);
+ expect(util.clearTimeUTC).toHaveBeenCalledWith(endDate);
+ });
+
+ it('returns objects with startDate and endDate for non-subdaily mode', () => {
+ renderWidget({ subDailyMode: false });
+ const result = desktopCapture.zeroDates();
+ expect(result).toHaveProperty('startDate');
+ expect(result).toHaveProperty('endDate');
+ expect(result.startDate.getUTCHours()).toBe(0);
+ expect(result.startDate.getUTCSeconds()).toBe(0);
+ expect(result.startDate.getUTCMilliseconds()).toBe(0);
+ });
+
+ it('zeroes seconds and milliseconds in subdaily mode', () => {
+ const subdailyStart = new Date('2021-01-01T10:35:45.500Z');
+ const subdailyEnd = new Date('2021-03-01T14:55:30.200Z');
+ renderWidget({
+ subDailyMode: true,
+ startDate: subdailyStart,
+ endDate: subdailyEnd,
+ autoSelected: false,
+ });
+ const result = desktopCapture.zeroDates();
+ expect(result.startDate.getUTCSeconds()).toBe(0);
+ expect(result.startDate.getUTCMilliseconds()).toBe(0);
+ expect(result.endDate.getUTCSeconds()).toBe(0);
+ expect(result.endDate.getUTCMilliseconds()).toBe(0);
+ });
+
+ it('floors minutes to nearest 10 in subdaily mode when not autoSelected', () => {
+ const subdailyStart = new Date('2021-01-01T10:35:00.000Z');
+ const subdailyEnd = new Date('2021-03-01T14:55:00.000Z');
+ renderWidget({
+ subDailyMode: true,
+ startDate: subdailyStart,
+ endDate: subdailyEnd,
+ autoSelected: false,
+ });
+ const result = desktopCapture.zeroDates();
+ expect(result.startDate.getUTCMinutes()).toBe(30);
+ expect(result.endDate.getUTCMinutes()).toBe(50);
+ });
+
+ it('does not floor minutes in subdaily mode when autoSelected', () => {
+ const subdailyStart = new Date('2021-01-01T10:35:00.000Z');
+ renderWidget({
+ subDailyMode: true,
+ startDate: subdailyStart,
+ endDate: new Date('2021-03-01T14:55:00.000Z'),
+ autoSelected: true,
+ });
+ const result = desktopCapture.zeroDates();
+ expect(result.startDate.getUTCMinutes()).toBe(35);
+ });
+
+ it('does not call clearTimeUTC in subdaily mode', () => {
+ renderWidget({ subDailyMode: true });
+ desktopCapture.zeroDates();
+ expect(util.clearTimeUTC).not.toHaveBeenCalled();
+ });
+});
+
+describe('onPushPlayFunc', () => {
+ it('calls onUpdateStartAndEndDate with zeroed dates then calls onPushPlay', () => {
+ const onUpdateStartAndEndDate = jest.fn();
+ const onPushPlay = jest.fn();
+ renderWidget({ onUpdateStartAndEndDate, onPushPlay, subDailyMode: false });
+ act(() => {
+ desktopCapture.onPushPlay();
+ });
+ expect(onUpdateStartAndEndDate).toHaveBeenCalledTimes(1);
+ expect(onPushPlay).toHaveBeenCalledTimes(1);
+ const [calledStart, calledEnd] = onUpdateStartAndEndDate.mock.calls[0];
+ expect(calledStart.getUTCHours()).toBe(0);
+ expect(calledEnd.getUTCHours()).toBe(0);
+ });
+
+ it('onPushPlay in CollapsedAnimationWidget also calls onUpdateStartAndEndDate', () => {
+ const onUpdateStartAndEndDate = jest.fn();
+ const onPushPlay = jest.fn();
+ renderWidget({ isCollapsed: true, onUpdateStartAndEndDate, onPushPlay });
+ act(() => {
+ collapsedCapture.onPushPlay();
+ });
+ expect(onUpdateStartAndEndDate).toHaveBeenCalledTimes(1);
+ expect(onPushPlay).toHaveBeenCalledTimes(1);
+ });
+});
+
+describe('widget initial position', () => {
+ it('sets initial widget x position centered based on screenWidth', () => {
+ renderWidget({ screenWidth: 1000, subDailyMode: false });
+ // widgetWidth = 334, halfWidgetWidth = 167, x = 500 - 167 = 333
+ expect(desktopCapture.widgetPosition.x).toBe(500 - 167);
+ });
+
+ it('uses subdailyWidgetWidth when subDailyMode is true', () => {
+ renderWidget({ screenWidth: 1000, subDailyMode: true });
+ // subdailyWidgetWidth = 460, halfWidgetWidth = 230, x = 500 - 230 = 270
+ expect(desktopCapture.widgetPosition.x).toBe(500 - 230);
+ });
+
+ it('sets embed mode widget position to x:10, y:0', () => {
+ renderWidget({ isEmbedModeActive: true, isCollapsed: false });
+ expect(desktopCapture.widgetPosition).toEqual({ x: 10, y: 0 });
+ });
+});
+
+describe('props forwarded to child widgets', () => {
+ it('passes expected props to DesktopAnimationWidget', () => {
+ renderWidget();
+ expect(desktopCapture).toMatchObject({
+ endDate,
+ hasSubdailyLayers: false,
+ interval: 'day',
+ isPlaying: false,
+ looping: false,
+ minDate: defaultProps.minDate,
+ maxDate: defaultProps.maxDate,
+ numberOfFrames: 10,
+ playDisabled: false,
+ sliderLabel: 'Frames Per Second',
+ startDate,
+ subDailyMode: false,
+ });
+ });
+
+ it('passes expected props to MobileAnimationWidget', () => {
+ renderWidget({ isMobile: true });
+ expect(mobileCapture).toMatchObject({
+ endDate,
+ hasSubdailyLayers: false,
+ isPlaying: false,
+ looping: false,
+ playDisabled: false,
+ startDate,
+ subDailyMode: false,
+ });
+ });
+
+ it('passes expected props to CollapsedAnimationWidget', () => {
+ renderWidget({ isCollapsed: true });
+ expect(collapsedCapture).toMatchObject({
+ isPlaying: false,
+ playDisabled: false,
+ isMobile: false,
+ });
+ });
+});
+
+describe('mapStateToProps', () => {
+ const buildMockState = (overrides = {}) => ({
+ compare: { active: false, ...(overrides.compare || {}) },
+ animation: {
+ startDate: new Date('2021-01-01'),
+ endDate: new Date('2021-03-01'),
+ speed: 3,
+ loop: false,
+ isPlaying: false,
+ isActive: true,
+ isCollapsed: false,
+ autoplay: false,
+ ...(overrides.animation || {}),
+ },
+ date: {
+ customSelected: false,
+ autoSelected: false,
+ delta: 1,
+ customDelta: null,
+ appNow: new Date('2021-06-01'),
+ animationCustomModalOpen: false,
+ interval: 1,
+ customInterval: 3,
+ ...(overrides.date || {}),
+ },
+ embed: { isEmbedModeActive: false, ...(overrides.embed || {}) },
+ sidebar: { activeTab: 'layers', ...(overrides.sidebar || {}) },
+ modal: { isOpen: false, id: '', ...(overrides.modal || {}) },
+ config: { startDate: '2020-01-01', ...(overrides.config || {}) },
+ map: { ui: { selected: { frameState_: true } }, ...(overrides.map || {}) },
+ screenSize: {
+ isMobileDevice: false,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ breakpoints: {},
+ screenWidth: 1024,
+ screenHeight: 768,
+ orientation: 'landscape',
+ ...(overrides.screenSize || {}),
+ },
+ ui: {
+ isDistractionFreeModeActive: false,
+ isKioskModeActive: false,
+ animationAvailabilityChecked: false,
+ eic: null,
+ ...(overrides.ui || {}),
+ },
+ proj: {},
+ layers: {
+ active: { layers: [] },
+ ...(overrides.layers || {}),
+ },
+ });
+
+ const callMSP = (stateOverrides = {}) => capturedMapStateToProps(buildMockState(stateOverrides));
+
+ beforeEach(() => {
+ const { subdailyLayersActive, getAllActiveLayers, dateRange } = require('../../modules/layers/selectors');
+ const { getNumberOfSteps, snapToIntervalDelta } = require('../../modules/animation/util');
+ const { getSelectedDate } = require('../../modules/date/selectors');
+ subdailyLayersActive.mockReturnValue(false);
+ getAllActiveLayers.mockReturnValue([]);
+ dateRange.mockReturnValue(null);
+ getNumberOfSteps.mockReturnValue(10);
+ getSelectedDate.mockReturnValue(new Date('2021-01-15'));
+ snapToIntervalDelta.mockReturnValue(new Date('2021-01-15'));
+ });
+
+ it('returns isActive true when all conditions met', () => {
+ expect(callMSP().isActive).toBe(true);
+ });
+
+ it('returns isActive false when compare is active', () => {
+ expect(callMSP({ compare: { active: true } }).isActive).toBe(false);
+ });
+
+ it('returns isActive false when sidebar tab is download', () => {
+ expect(callMSP({ sidebar: { activeTab: 'download' } }).isActive).toBe(false);
+ });
+
+ it('returns isActive false when TOOLBAR_SNAPSHOT modal is open', () => {
+ expect(callMSP({ modal: { isOpen: true, id: 'TOOLBAR_SNAPSHOT' } }).isActive).toBe(false);
+ });
+
+ it('returns isActive false when map frameState_ is falsy', () => {
+ expect(callMSP({ map: { ui: { selected: {} } } }).isActive).toBeFalsy();
+ });
+
+ it('returns isActive false when animation.isActive is false', () => {
+ expect(callMSP({ animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: false, isActive: false, isCollapsed: false, autoplay: false } }).isActive).toBe(false);
+ });
+
+ it('maps startDate, endDate, speedRedux, looping, isPlaying from animation state', () => {
+ const result = callMSP();
+ expect(result.startDate).toEqual(new Date('2021-01-01'));
+ expect(result.endDate).toEqual(new Date('2021-03-01'));
+ expect(result.speedRedux).toBe(3);
+ expect(result.looping).toBe(false);
+ expect(result.isPlaying).toBe(false);
+ });
+
+ it('maps appNow, animationCustomModalOpen, autoplay from date state', () => {
+ const result = callMSP();
+ expect(result.appNow).toEqual(new Date('2021-06-01'));
+ expect(result.animationCustomModalOpen).toBe(false);
+ expect(result.autoplay).toBe(false);
+ });
+
+ it('checkAnimationAvailability is true when eic=sa, kiosk, not checked, playing', () => {
+ const result = callMSP({
+ ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, animationAvailabilityChecked: false, eic: 'sa' },
+ animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: true, isActive: true, isCollapsed: false, autoplay: false },
+ });
+ expect(result.checkAnimationAvailability).toBe(true);
+ });
+
+ it('checkAnimationAvailability is true when eic=da', () => {
+ const result = callMSP({
+ ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, animationAvailabilityChecked: false, eic: 'da' },
+ animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: true, isActive: true, isCollapsed: false, autoplay: false },
+ });
+ expect(result.checkAnimationAvailability).toBe(true);
+ });
+
+ it('checkAnimationAvailability is false when already checked', () => {
+ const result = callMSP({
+ ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, animationAvailabilityChecked: true, eic: 'sa' },
+ animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: true, isActive: true, isCollapsed: false, autoplay: false },
+ });
+ expect(result.checkAnimationAvailability).toBe(false);
+ });
+
+ it('checkAnimationAvailability is false when not playing', () => {
+ const result = callMSP({
+ ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, animationAvailabilityChecked: false, eic: 'sa' },
+ });
+ expect(result.checkAnimationAvailability).toBe(false);
+ });
+
+ it('caps interval to day when no subdaily layers and interval > 3', () => {
+ // interval 4 capped to 3, TIME_SCALE_FROM_NUMBER[3] = 'day'
+ const result = callMSP({ date: { customSelected: false, autoSelected: false, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 4, customInterval: 3 } });
+ expect(result.interval).toBe('day');
+ });
+
+ it('does not cap interval when subdaily layers are active', () => {
+ const { subdailyLayersActive } = require('../../modules/layers/selectors');
+ subdailyLayersActive.mockReturnValue(true);
+ const result = callMSP({ date: { customSelected: false, autoSelected: false, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 4, customInterval: 4 } });
+ expect(result.interval).toBe('hour');
+ expect(result.subDailyMode).toBe(true);
+ });
+
+ it('uses customDelta when customSelected is true and customDelta is set', () => {
+ const result = callMSP({ date: { customSelected: true, autoSelected: false, delta: 1, customDelta: 5, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 1, customInterval: 4 } });
+ expect(result.delta).toBe(5);
+ });
+
+ it('falls back to delta when customSelected but customDelta is null', () => {
+ const result = callMSP({ date: { customSelected: true, autoSelected: false, delta: 2, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 1, customInterval: 3 } });
+ expect(result.delta).toBe(2);
+ });
+
+ it('sets maxDate to layerDateRange.end when it exceeds appNow', () => {
+ const { dateRange } = require('../../modules/layers/selectors');
+ const futureEnd = new Date('2030-01-01');
+ dateRange.mockReturnValue({ end: futureEnd });
+ expect(callMSP().maxDate).toBe(futureEnd);
+ });
+
+ it('sets maxDate to appNow when no layer date range', () => {
+ expect(callMSP().maxDate).toEqual(new Date('2021-06-01'));
+ });
+
+ it('hasFutureLayers is true when a layer has futureTime', () => {
+ const { getAllActiveLayers } = require('../../modules/layers/selectors');
+ getAllActiveLayers.mockReturnValue([{ futureTime: '2030-01-01' }]);
+ expect(callMSP().hasFutureLayers).toBe(true);
+ });
+
+ it('hasFutureLayers is false when no layer has futureTime', () => {
+ expect(callMSP().hasFutureLayers).toBe(false);
+ });
+
+ it('playDisabled is true when numberOfFrames >= 300 on desktop', () => {
+ const { getNumberOfSteps } = require('../../modules/animation/util');
+ getNumberOfSteps.mockReturnValue(300);
+ expect(callMSP().playDisabled).toBe(true);
+ });
+
+ it('playDisabled is true when numberOfFrames >= 50 on mobile', () => {
+ const { getNumberOfSteps } = require('../../modules/animation/util');
+ getNumberOfSteps.mockReturnValue(50);
+ const result = callMSP({ screenSize: { isMobileDevice: true, isMobilePhone: true, isMobileTablet: false, breakpoints: {}, screenWidth: 375, screenHeight: 667, orientation: 'portrait' } });
+ expect(result.playDisabled).toBe(true);
+ });
+
+ it('playDisabled is true when numberOfFrames === 1', () => {
+ const { getNumberOfSteps } = require('../../modules/animation/util');
+ getNumberOfSteps.mockReturnValue(1);
+ expect(callMSP().playDisabled).toBe(true);
+ });
+
+ it('playDisabled is false for valid frame count', () => {
+ expect(callMSP().playDisabled).toBe(false);
+ });
+
+ it('subDailyMode is true when interval > 3 and hasSubdailyLayers', () => {
+ const { subdailyLayersActive } = require('../../modules/layers/selectors');
+ subdailyLayersActive.mockReturnValue(true);
+ const result = callMSP({ date: { customSelected: false, autoSelected: false, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 4, customInterval: 4 } });
+ expect(result.subDailyMode).toBe(true);
+ });
+
+ it('subDailyMode is false when interval <= 3', () => {
+ expect(callMSP().subDailyMode).toBe(false);
+ });
+
+ it('snappedCurrentDate is currentDate when numberOfFrames >= frameLimit', () => {
+ const { getNumberOfSteps, snapToIntervalDelta } = require('../../modules/animation/util');
+ const { getSelectedDate } = require('../../modules/date/selectors');
+ const currentDate = new Date('2021-01-15');
+ getNumberOfSteps.mockReturnValue(300);
+ getSelectedDate.mockReturnValue(currentDate);
+ const result = callMSP();
+ expect(result.snappedCurrentDate).toBe(currentDate);
+ expect(snapToIntervalDelta).not.toHaveBeenCalled();
+ });
+
+ it('snappedCurrentDate uses snapToIntervalDelta when numberOfFrames < frameLimit', () => {
+ const { snapToIntervalDelta } = require('../../modules/animation/util');
+ const snapped = new Date('2021-01-10');
+ snapToIntervalDelta.mockReturnValue(snapped);
+ const result = callMSP();
+ expect(result.snappedCurrentDate).toBe(snapped);
+ expect(snapToIntervalDelta).toHaveBeenCalled();
+ });
+
+ it('maps screenSize fields correctly', () => {
+ const result = callMSP();
+ expect(result.isMobile).toBe(false);
+ expect(result.screenWidth).toBe(1024);
+ expect(result.screenHeight).toBe(768);
+ expect(result.isLandscape).toBe(true);
+ expect(result.isPortrait).toBe(false);
+ });
+
+ it('maps portrait mobile screenSize correctly', () => {
+ const result = callMSP({ screenSize: { isMobileDevice: true, isMobilePhone: true, isMobileTablet: false, breakpoints: {}, screenWidth: 812, screenHeight: 375, orientation: 'portrait' } });
+ expect(result.isMobile).toBe(true);
+ expect(result.isPortrait).toBe(true);
+ expect(result.isLandscape).toBe(false);
+ });
+
+ it('promiseImageryForTime calls the util function when invoked', () => {
+ const result = callMSP();
+ expect(typeof result.promiseImageryForTime).toBe('function');
+ result.promiseImageryForTime(new Date('2021-01-01'));
+ const { promiseImageryForTime: promiseUtil } = require('../../modules/map/util');
+ expect(promiseUtil).toHaveBeenCalled();
+ });
+
+ it('maps isEmbedModeActive from embed state', () => {
+ expect(callMSP({ embed: { isEmbedModeActive: true } }).isEmbedModeActive).toBe(true);
+ });
+
+ it('maps autoSelected from date state', () => {
+ const result = callMSP({ date: { customSelected: false, autoSelected: true, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 1, customInterval: 3 } });
+ expect(result.autoSelected).toBe(true);
+ });
+
+ it('customInterval defaults to 3 when null', () => {
+ const result = callMSP({ date: { customSelected: false, autoSelected: false, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 1, customInterval: null } });
+ expect(result.customInterval).toBe(3);
+ });
+
+ it('customDelta defaults to 1 when null', () => {
+ expect(callMSP().customDelta).toBe(1);
+ });
+
+ it('maps isCollapsed, isKioskModeActive, isDistractionFreeModeActive', () => {
+ const result = callMSP({
+ animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: false, isActive: true, isCollapsed: true, autoplay: false },
+ ui: {
+ isDistractionFreeModeActive: true,
+ isKioskModeActive: true,
+ animationAvailabilityChecked: false,
+ eic: null,
+ },
+ });
+ expect(result.isCollapsed).toBe(true);
+ expect(result.isKioskModeActive).toBe(true);
+ expect(result.isDistractionFreeModeActive).toBe(true);
+ });
+
+ it('maps sliderLabel as Frames Per Second', () => {
+ expect(callMSP().sliderLabel).toBe('Frames Per Second');
+ });
+
+ it('maps layers from layers.active.layers', () => {
+ const myLayers = [{ id: 'layer1' }];
+ expect(callMSP({ layers: { active: { layers: myLayers } } }).layers).toBe(myLayers);
+ });
+});
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ });
+
+ const callMDP = () => capturedMapDispatchToProps(dispatch);
+
+ it('selectDate dispatches selectDateAction', () => {
+ callMDP().selectDate(new Date('2021-01-01'));
+ expect(dispatch).toHaveBeenCalledWith({ type: 'SELECT_DATE' });
+ });
+
+ it('onClose dispatches onCloseAction', () => {
+ callMDP().onClose();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'CLOSE' });
+ });
+
+ it('onPushPlay dispatches play action', () => {
+ callMDP().onPushPlay();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'PLAY' });
+ });
+
+ it('onPushPause dispatches stop action', () => {
+ callMDP().onPushPause();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'STOP' });
+ });
+
+ it('onPushLoop dispatches toggleLooping action', () => {
+ callMDP().onPushLoop();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_LOOPING' });
+ });
+
+ it('toggleCustomModal dispatches toggleCustomModal action', () => {
+ callMDP().toggleCustomModal(true, 'INTERVAL');
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_CUSTOM_MODAL' });
+ });
+
+ it('onSlide dispatches changeFrameRate action', () => {
+ callMDP().onSlide(5);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_FRAME_RATE' });
+ });
+
+ it('onIntervalSelect dispatches selectInterval action', () => {
+ callMDP().onIntervalSelect(1, 'day', false);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'SELECT_INTERVAL' });
+ });
+
+ it('onUpdateStartDate dispatches changeStartDate action', () => {
+ callMDP().onUpdateStartDate(new Date('2021-01-01'));
+ expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_START_DATE' });
+ });
+
+ it('onUpdateEndDate dispatches changeEndDate action', () => {
+ callMDP().onUpdateEndDate(new Date('2021-03-01'));
+ expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_END_DATE' });
+ });
+
+ it('onUpdateStartAndEndDate dispatches changeStartAndEndDate action', () => {
+ callMDP().onUpdateStartAndEndDate(new Date('2021-01-01'), new Date('2021-03-01'));
+ expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_START_AND_END_DATE' });
+ });
+
+ it('onToggleAnimationCollapse dispatches toggleAnimationCollapse action', () => {
+ callMDP().onToggleAnimationCollapse();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_ANIMATION_COLLAPSE' });
+ });
});
diff --git a/web/js/containers/animation-widget/collapsed-animation-widget.test.js b/web/js/containers/animation-widget/collapsed-animation-widget.test.js
index f5f99b0a7..8908f7f81 100644
--- a/web/js/containers/animation-widget/collapsed-animation-widget.test.js
+++ b/web/js/containers/animation-widget/collapsed-animation-widget.test.js
@@ -1,3 +1,359 @@
-test('collapse-animation-widget container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('react-draggable', () => {
+ const capture = {};
+ const MockDraggable = ({ children, ...props }) => {
+ Object.assign(capture, props);
+ return children;
+ };
+ MockDraggable.draggableCapture = capture;
+ return { __esModule: true, default: MockDraggable };
+});
+
+jest.mock('../../components/animation-widget/play-button', () => {
+ const capture = {};
+ const MockPlayButton = (props) => {
+ Object.assign(capture, props);
+ return <button data-testid="play-button" />;
+ };
+ MockPlayButton.playButtonCapture = capture;
+ return { __esModule: true, default: MockPlayButton };
+});
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, onClick, className }) => (
+ <svg data-testid={`fa-icon-${icon}`} className={className} onClick={onClick} />
+ ),
+}));
+
+import CollapsedAnimationWidget from './collapsed-animation-widget';
+
+let draggableCapture;
+let playButtonCapture;
+
+beforeAll(() => {
+ const { default: MockDraggable } = jest.requireMock('react-draggable');
+ draggableCapture = MockDraggable.draggableCapture;
+ const { default: MockPlayButton } = jest.requireMock('../../components/animation-widget/play-button');
+ playButtonCapture = MockPlayButton.playButtonCapture;
+});
+
+let defaultProps;
+
+beforeEach(() => {
+ defaultProps = {
+ breakpoints: { small: 768 },
+ collapsedWidgetPosition: { x: 10, y: 20 },
+ handleDragStart: jest.fn(),
+ hasSubdailyLayers: false,
+ isDistractionFreeModeActive: false,
+ isLandscape: false,
+ isMobile: false,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ isPlaying: false,
+ isPortrait: false,
+ onClose: jest.fn(),
+ onCollapsedDrag: jest.fn(),
+ onPushPause: jest.fn(),
+ onPushPlay: jest.fn(),
+ playDisabled: false,
+ screenWidth: 1024,
+ toggleCollapse: jest.fn(),
+ };
+ Object.keys(draggableCapture).forEach((k) => delete draggableCapture[k]);
+ Object.keys(playButtonCapture).forEach((k) => delete playButtonCapture[k]);
+});
+
+const renderWidget = (overrides = {}) => render(
+ <CollapsedAnimationWidget {...defaultProps} {...overrides} />,
+);
+
+describe('CollapsedAnimationWidget visibility', () => {
+ test('renders when isMobile is false and playDisabled is false', () => {
+ renderWidget();
+ expect(screen.getByTestId('play-button')).toBeInTheDocument();
+ });
+
+ test('renders when isMobile is true and playDisabled is false', () => {
+ renderWidget({ isMobile: true, playDisabled: false });
+ expect(screen.getByTestId('play-button')).toBeInTheDocument();
+ });
+
+ test('renders when isMobile is false and playDisabled is true', () => {
+ renderWidget({ isMobile: false, playDisabled: true });
+ expect(screen.getByTestId('play-button')).toBeInTheDocument();
+ });
+
+ test('renders nothing when isMobile and playDisabled are both true', () => {
+ renderWidget({ isMobile: true, playDisabled: true });
+ expect(screen.queryByTestId('play-button')).not.toBeInTheDocument();
+ });
+});
+
+describe('CollapsedAnimationWidget CSS classes', () => {
+ test('always includes base wrapper classes', () => {
+ const { container } = renderWidget();
+ const wrapper = container.querySelector('.wv-animation-widget-wrapper');
+ expect(wrapper).toBeInTheDocument();
+ expect(wrapper).toHaveClass('minimized');
+ });
+
+ test('adds subdaily class when hasSubdailyLayers is true', () => {
+ const { container } = renderWidget({ hasSubdailyLayers: true });
+ expect(container.querySelector('.wv-animation-widget-wrapper')).toHaveClass('subdaily');
+ });
+
+ test('does not add subdaily class when hasSubdailyLayers is false', () => {
+ const { container } = renderWidget({ hasSubdailyLayers: false });
+ expect(container.querySelector('.wv-animation-widget-wrapper')).not.toHaveClass('subdaily');
+ });
+
+ test('adds mobile class when isMobile is true', () => {
+ const { container } = renderWidget({ isMobile: true });
+ expect(container.querySelector('.wv-animation-widget-wrapper')).toHaveClass('mobile');
+ });
+
+ test('does not add mobile class when isMobile is false', () => {
+ const { container } = renderWidget({ isMobile: false });
+ expect(container.querySelector('.wv-animation-widget-wrapper')).not.toHaveClass('mobile');
+ });
+
+ test('adds landscape class when isLandscape is true', () => {
+ const { container } = renderWidget({ isLandscape: true });
+ expect(container.querySelector('.wv-animation-widget-wrapper')).toHaveClass('landscape');
+ });
+
+ test('does not add landscape class when isLandscape is false', () => {
+ const { container } = renderWidget({ isLandscape: false });
+ expect(container.querySelector('.wv-animation-widget-wrapper')).not.toHaveClass('landscape');
+ });
+
+ test('inner widget div has correct classes', () => {
+ const { container } = renderWidget();
+ const inner = container.querySelector('#wv-animation-widget');
+ expect(inner).toHaveClass('wv-animation-widget', 'minimized');
+ });
+});
+
+describe('CollapsedAnimationWidget getWidgetIDs — desktop default', () => {
+ test('returns undefined for desktop (large screen, non-mobile)', () => {
+ const { container } = renderWidget();
+ expect(container.querySelector('[id^="collapsed-animate-widget"]').id).toBe('collapsed-animate-widgetundefined');
+ });
+});
+
+describe('CollapsedAnimationWidget getWidgetIDs — distraction free', () => {
+ test('returns phone-portrait-distraction-free when active, portrait, screenWidth < 670', () => {
+ const { container } = renderWidget({
+ isDistractionFreeModeActive: true,
+ isPortrait: true,
+ screenWidth: 600,
+ });
+ expect(container.querySelector('#collapsed-animate-widget-phone-portrait-distraction-free')).toBeInTheDocument();
+ });
+
+ test('does not return distraction-free id when screenWidth >= 670', () => {
+ const { container } = renderWidget({
+ isDistractionFreeModeActive: true,
+ isPortrait: true,
+ screenWidth: 670,
+ });
+ expect(container.querySelector('#collapsed-animate-widget-phone-portrait-distraction-free')).not.toBeInTheDocument();
+ });
+});
+
+describe('CollapsedAnimationWidget getWidgetIDs — phone portrait', () => {
+ test('returns phone-portrait when isMobilePhone and isPortrait', () => {
+ const { container } = renderWidget({ isMobilePhone: true, isPortrait: true });
+ expect(container.querySelector('#collapsed-animate-widget-phone-portrait')).toBeInTheDocument();
+ });
+
+ test('returns phone-portrait-subdaily when isMobilePhone, isPortrait, hasSubdailyLayers', () => {
+ const { container } = renderWidget({
+ isMobilePhone: true,
+ isPortrait: true,
+ hasSubdailyLayers: true,
+ });
+ expect(container.querySelector('#collapsed-animate-widget-phone-portrait-subdaily')).toBeInTheDocument();
+ });
+
+ test('returns phone-portrait-subdaily for narrow screen with subdaily layers and not tablet', () => {
+ const { container } = renderWidget({
+ isMobileTablet: false,
+ screenWidth: 600,
+ hasSubdailyLayers: true,
+ });
+ expect(container.querySelector('#collapsed-animate-widget-phone-portrait-subdaily')).toBeInTheDocument();
+ });
+
+ test('returns phone-portrait for very narrow screen without subdaily layers and not tablet', () => {
+ const { container } = renderWidget({
+ isMobileTablet: false,
+ screenWidth: 500,
+ hasSubdailyLayers: false,
+ });
+ expect(container.querySelector('#collapsed-animate-widget-phone-portrait')).toBeInTheDocument();
+ });
+});
+
+describe('CollapsedAnimationWidget getWidgetIDs — phone landscape', () => {
+ test('returns phone-landscape when isMobilePhone and isLandscape', () => {
+ const { container } = renderWidget({ isMobilePhone: true, isLandscape: true });
+ expect(container.querySelector('#collapsed-animate-widget-phone-landscape')).toBeInTheDocument();
+ });
+
+ test('returns phone-landscape-subdaily when isMobilePhone, isLandscape, hasSubdailyLayers', () => {
+ const { container } = renderWidget({
+ isMobilePhone: true,
+ isLandscape: true,
+ hasSubdailyLayers: true,
+ });
+ expect(container.querySelector('#collapsed-animate-widget-phone-landscape-subdaily')).toBeInTheDocument();
+ });
+});
+
+describe('CollapsedAnimationWidget getWidgetIDs — tablet portrait', () => {
+ test('returns tablet-portrait when isMobileTablet and isPortrait', () => {
+ const { container } = renderWidget({ isMobileTablet: true, isPortrait: true });
+ expect(container.querySelector('#collapsed-animate-widget-tablet-portrait')).toBeInTheDocument();
+ });
+
+ test('returns tablet-portrait-subdaily when isMobileTablet, isPortrait, hasSubdailyLayers', () => {
+ const { container } = renderWidget({
+ isMobileTablet: true,
+ isPortrait: true,
+ hasSubdailyLayers: true,
+ });
+ expect(container.querySelector('#collapsed-animate-widget-tablet-portrait-subdaily')).toBeInTheDocument();
+ });
+
+ test('returns tablet-portrait when not phone and screenWidth < breakpoints.small', () => {
+ const { container } = renderWidget({
+ isMobilePhone: false,
+ screenWidth: 600,
+ breakpoints: { small: 768 },
+ });
+ expect(container.querySelector('#collapsed-animate-widget-tablet-portrait')).toBeInTheDocument();
+ });
+});
+
+describe('CollapsedAnimationWidget getWidgetIDs — tablet landscape', () => {
+ test('returns tablet-landscape when isMobileTablet and isLandscape', () => {
+ const { container } = renderWidget({ isMobileTablet: true, isLandscape: true });
+ expect(container.querySelector('#collapsed-animate-widget-tablet-landscape')).toBeInTheDocument();
+ });
+
+ test('returns tablet-landscape-subdaily when isMobileTablet, isLandscape, hasSubdailyLayers', () => {
+ const { container } = renderWidget({
+ isMobileTablet: true,
+ isLandscape: true,
+ hasSubdailyLayers: true,
+ });
+ expect(container.querySelector('#collapsed-animate-widget-tablet-landscape-subdaily')).toBeInTheDocument();
+ });
+});
+
+describe('CollapsedAnimationWidget Draggable props', () => {
+ test('passes collapsedWidgetPosition as position', () => {
+ const position = { x: 50, y: 100 };
+ renderWidget({ collapsedWidgetPosition: position });
+ expect(draggableCapture.position).toEqual(position);
+ });
+
+ test('passes handleDragStart as onStart', () => {
+ renderWidget();
+ expect(draggableCapture.onStart).toBe(defaultProps.handleDragStart);
+ });
+
+ test('passes onCollapsedDrag as onDrag', () => {
+ renderWidget();
+ expect(draggableCapture.onDrag).toBe(defaultProps.onCollapsedDrag);
+ });
+
+ test('passes isMobile as disabled', () => {
+ renderWidget({ isMobile: true });
+ expect(draggableCapture.disabled).toBe(true);
+ });
+
+ test('disabled is false when isMobile is false', () => {
+ renderWidget({ isMobile: false });
+ expect(draggableCapture.disabled).toBe(false);
+ });
+
+ test('passes "body" as bounds', () => {
+ renderWidget();
+ expect(draggableCapture.bounds).toBe('body');
+ });
+
+ test('passes ".no-drag, svg" as cancel', () => {
+ renderWidget();
+ expect(draggableCapture.cancel).toBe('.no-drag, svg');
+ });
+});
+
+describe('CollapsedAnimationWidget PlayButton props', () => {
+ test('passes isPlaying as playing', () => {
+ renderWidget({ isPlaying: true });
+ expect(playButtonCapture.playing).toBe(true);
+ });
+
+ test('passes onPushPlay as play', () => {
+ renderWidget();
+ expect(playButtonCapture.play).toBe(defaultProps.onPushPlay);
+ });
+
+ test('passes onPushPause as pause', () => {
+ renderWidget();
+ expect(playButtonCapture.pause).toBe(defaultProps.onPushPause);
+ });
+
+ test('passes playDisabled as isDisabled', () => {
+ renderWidget({ playDisabled: true });
+ expect(playButtonCapture.isDisabled).toBe(true);
+ });
+
+ test('passes isMobile as isMobile', () => {
+ renderWidget({ isMobile: true });
+ expect(playButtonCapture.isMobile).toBe(true);
+ });
+});
+
+describe('CollapsedAnimationWidget icons', () => {
+ test('shows chevron-up and times icons when not mobile', () => {
+ renderWidget({ isMobile: false });
+ expect(screen.getByTestId('fa-icon-chevron-up')).toBeInTheDocument();
+ expect(screen.getByTestId('fa-icon-times')).toBeInTheDocument();
+ });
+
+ test('does not show icons when isMobile is true', () => {
+ renderWidget({ isMobile: true });
+ expect(screen.queryByTestId('fa-icon-chevron-up')).not.toBeInTheDocument();
+ expect(screen.queryByTestId('fa-icon-times')).not.toBeInTheDocument();
+ });
+
+ test('chevron-up has wv-expand class', () => {
+ renderWidget({ isMobile: false });
+ expect(screen.getByTestId('fa-icon-chevron-up')).toHaveClass('wv-expand');
+ });
+
+ test('times icon has wv-close class', () => {
+ renderWidget({ isMobile: false });
+ expect(screen.getByTestId('fa-icon-times')).toHaveClass('wv-close');
+ });
+
+ test('clicking chevron-up calls toggleCollapse', () => {
+ renderWidget({ isMobile: false });
+ fireEvent.click(screen.getByTestId('fa-icon-chevron-up'));
+ expect(defaultProps.toggleCollapse).toHaveBeenCalledTimes(1);
+ });
+
+ test('clicking times icon calls onClose', () => {
+ renderWidget({ isMobile: false });
+ fireEvent.click(screen.getByTestId('fa-icon-times'));
+ expect(defaultProps.onClose).toHaveBeenCalledTimes(1);
+ });
});
diff --git a/web/js/containers/animation-widget/desktop-animation-widget.test.js b/web/js/containers/animation-widget/desktop-animation-widget.test.js
index a6cc8a41f..c91856eda 100644
--- a/web/js/containers/animation-widget/desktop-animation-widget.test.js
+++ b/web/js/containers/animation-widget/desktop-animation-widget.test.js
@@ -1,3 +1,432 @@
-test('desktop-animation-widget container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('react-draggable', () => {
+ const capture = {};
+ const MockDraggable = ({ children, ...props }) => {
+ Object.assign(capture, props);
+ return children;
+ };
+ MockDraggable.draggableCapture = capture;
+ return { __esModule: true, default: MockDraggable };
+});
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, onClick, className }) => (
+ <svg data-testid={`fa-icon-${icon}`} className={className} onClick={onClick} />
+ ),
+}));
+
+jest.mock('../../components/animation-widget/play-button', () => {
+ const capture = {};
+ const MockPlayButton = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="play-button" />;
+ };
+ MockPlayButton.capture = capture;
+ return { __esModule: true, default: MockPlayButton };
+});
+
+jest.mock('../../components/animation-widget/loop-button', () => {
+ const capture = {};
+ const MockLoopButton = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="loop-button" />;
+ };
+ MockLoopButton.capture = capture;
+ return { __esModule: true, default: MockLoopButton };
+});
+
+jest.mock('../../components/animation-widget/gif-button', () => {
+ const capture = {};
+ const MockGifButton = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="gif-button" />;
+ };
+ MockGifButton.capture = capture;
+ return { __esModule: true, default: MockGifButton };
+});
+
+jest.mock('../../components/date-selector/date-range-selector', () => {
+ const capture = {};
+ const MockDateRangeSelector = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="date-range-selector" />;
+ };
+ MockDateRangeSelector.capture = capture;
+ return { __esModule: true, default: MockDateRangeSelector };
+});
+
+jest.mock('../../components/timeline/timeline-controls/timescale-interval-change', () => {
+ const capture = {};
+ const MockTimeScaleIntervalChange = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="timescale-interval-change" />;
+ };
+ MockTimeScaleIntervalChange.capture = capture;
+ return { __esModule: true, default: MockTimeScaleIntervalChange };
+});
+
+jest.mock('../../components/timeline/custom-interval-selector/custom-interval-selector', () => {
+ const capture = {};
+ const MockCustomIntervalSelector = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="custom-interval-selector" />;
+ };
+ MockCustomIntervalSelector.capture = capture;
+ return { __esModule: true, default: MockCustomIntervalSelector };
+});
+
+import DesktopAnimationWidget from './desktop-animation-widget';
+
+let draggableCapture;
+let playButtonCapture;
+let loopButtonCapture;
+let gifButtonCapture;
+let dateRangeSelectorCapture;
+let timeScaleCapture;
+let customIntervalCapture;
+
+beforeAll(() => {
+ draggableCapture = jest.requireMock('react-draggable').default.draggableCapture;
+ playButtonCapture = jest.requireMock('../../components/animation-widget/play-button').default.capture;
+ loopButtonCapture = jest.requireMock('../../components/animation-widget/loop-button').default.capture;
+ gifButtonCapture = jest.requireMock('../../components/animation-widget/gif-button').default.capture;
+ dateRangeSelectorCapture = jest.requireMock('../../components/date-selector/date-range-selector').default.capture;
+ timeScaleCapture = jest.requireMock('../../components/timeline/timeline-controls/timescale-interval-change').default.capture;
+ customIntervalCapture = jest.requireMock('../../components/timeline/custom-interval-selector/custom-interval-selector').default.capture;
+});
+
+const clearCaptures = () => {
+ [draggableCapture, playButtonCapture, loopButtonCapture, gifButtonCapture,
+ dateRangeSelectorCapture, timeScaleCapture, customIntervalCapture].forEach((cap) => {
+ Object.keys(cap).forEach((k) => delete cap[k]);
+ });
+};
+
+let defaultProps;
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ clearCaptures();
+ defaultProps = {
+ animationCustomModalOpen: false,
+ customModalType: { ANIMATION: 'ANIMATION' },
+ endDate: new Date('2023-01-10'),
+ handleDragStart: jest.fn(),
+ hasSubdailyLayers: false,
+ interval: 'day',
+ isDistractionFreeModeActive: false,
+ isPlaying: false,
+ looping: false,
+ maxDate: new Date('2023-12-31'),
+ minDate: new Date('2020-01-01'),
+ numberOfFrames: 10,
+ onClose: jest.fn(),
+ onDateChange: jest.fn(),
+ onExpandedDrag: jest.fn(),
+ onLoop: jest.fn(),
+ onPushPause: jest.fn(),
+ onPushPlay: jest.fn(),
+ onSlide: jest.fn(),
+ playDisabled: false,
+ toggleCollapse: jest.fn(),
+ setSpeed: jest.fn(),
+ sliderLabel: 'FPS',
+ speed: 5,
+ startDate: new Date('2023-01-01'),
+ subDailyMode: false,
+ widgetPosition: { x: 0, y: 0 },
+ zeroDates: jest.fn(),
+ };
+});
+
+const renderWidget = (overrides = {}) => render(
+ <DesktopAnimationWidget {...defaultProps} {...overrides} />,
+);
+
+describe('DesktopAnimationWidget rendering', () => {
+ test('renders all child components', () => {
+ renderWidget();
+ expect(screen.getByTestId('timescale-interval-change')).toBeInTheDocument();
+ expect(screen.getByTestId('custom-interval-selector')).toBeInTheDocument();
+ expect(screen.getByTestId('play-button')).toBeInTheDocument();
+ expect(screen.getByTestId('loop-button')).toBeInTheDocument();
+ expect(screen.getByTestId('gif-button')).toBeInTheDocument();
+ expect(screen.getByTestId('date-range-selector')).toBeInTheDocument();
+ expect(screen.getByTestId('fa-icon-chevron-down')).toBeInTheDocument();
+ expect(screen.getByTestId('fa-icon-times')).toBeInTheDocument();
+ });
+
+ test('renders header text', () => {
+ const { container } = renderWidget();
+ const header = container.querySelector('.wv-animation-widget-header');
+ expect(header.textContent).toContain('Animate Map in');
+ expect(header.textContent).toContain('Increments');
+ });
+
+ test('renders speed value and slider label', () => {
+ const { container } = renderWidget({ speed: 3, sliderLabel: 'FPS' });
+ const label = container.querySelector('.wv-slider-label');
+ expect(label.textContent).toContain('3');
+ expect(label.textContent).toContain('FPS');
+ });
+});
+
+describe('DesktopAnimationWidget CSS classes', () => {
+ test('wrapper does not have d-none when isDistractionFreeModeActive is false', () => {
+ const { container } = renderWidget({ isDistractionFreeModeActive: false });
+ expect(container.querySelector('.wv-animation-widget-wrapper')).not.toHaveClass('d-none');
+ });
+
+ test('wrapper has d-none when isDistractionFreeModeActive is true', () => {
+ const { container } = renderWidget({ isDistractionFreeModeActive: true });
+ expect(container.querySelector('.wv-animation-widget-wrapper')).toHaveClass('d-none');
+ });
+
+ test('inner widget does not have subdaily class when subDailyMode is false', () => {
+ const { container } = renderWidget({ subDailyMode: false });
+ expect(container.querySelector('#wv-animation-widget')).not.toHaveClass('subdaily');
+ });
+
+ test('inner widget has subdaily class when subDailyMode is true', () => {
+ const { container } = renderWidget({ subDailyMode: true });
+ expect(container.querySelector('#wv-animation-widget')).toHaveClass('subdaily');
+ });
+
+ test('chevron-down icon has wv-minimize class', () => {
+ renderWidget();
+ expect(screen.getByTestId('fa-icon-chevron-down')).toHaveClass('wv-minimize');
+ });
+
+ test('times icon has wv-close class', () => {
+ renderWidget();
+ expect(screen.getByTestId('fa-icon-times')).toHaveClass('wv-close');
+ });
+});
+
+describe('DesktopAnimationWidget Draggable props', () => {
+ test('passes widgetPosition as position', () => {
+ const position = { x: 50, y: 100 };
+ renderWidget({ widgetPosition: position });
+ expect(draggableCapture.position).toEqual(position);
+ });
+
+ test('passes handleDragStart as onStart', () => {
+ renderWidget();
+ expect(draggableCapture.onStart).toBe(defaultProps.handleDragStart);
+ });
+
+ test('passes onExpandedDrag as onDrag', () => {
+ renderWidget();
+ expect(draggableCapture.onDrag).toBe(defaultProps.onExpandedDrag);
+ });
+
+ test('passes "body" as bounds', () => {
+ renderWidget();
+ expect(draggableCapture.bounds).toBe('body');
+ });
+
+ test('passes ".no-drag, .date-arrows" as cancel', () => {
+ renderWidget();
+ expect(draggableCapture.cancel).toBe('.no-drag, .date-arrows');
+ });
+
+ test('passes ".wv-animation-widget-header" as handle', () => {
+ renderWidget();
+ expect(draggableCapture.handle).toBe('.wv-animation-widget-header');
+ });
+});
+
+describe('DesktopAnimationWidget TimeScaleIntervalChange props', () => {
+ test('passes interval as timeScaleChangeUnit', () => {
+ renderWidget({ interval: 'month' });
+ expect(timeScaleCapture.timeScaleChangeUnit).toBe('month');
+ });
+
+ test('passes hasSubdailyLayers', () => {
+ renderWidget({ hasSubdailyLayers: true });
+ expect(timeScaleCapture.hasSubdailyLayers).toBe(true);
+ });
+
+ test('passes customModalType.ANIMATION as modalType', () => {
+ renderWidget({ customModalType: { ANIMATION: 'ANIMATION' } });
+ expect(timeScaleCapture.modalType).toBe('ANIMATION');
+ });
+
+ test('passes isPlaying as isDisabled', () => {
+ renderWidget({ isPlaying: true });
+ expect(timeScaleCapture.isDisabled).toBe(true);
+ });
+
+ test('isDisabled is false when not playing', () => {
+ renderWidget({ isPlaying: false });
+ expect(timeScaleCapture.isDisabled).toBe(false);
+ });
+});
+
+describe('DesktopAnimationWidget CustomIntervalSelector props', () => {
+ test('passes animationCustomModalOpen as modalOpen', () => {
+ renderWidget({ animationCustomModalOpen: true });
+ expect(customIntervalCapture.modalOpen).toBe(true);
+ });
+
+ test('passes hasSubdailyLayers', () => {
+ renderWidget({ hasSubdailyLayers: true });
+ expect(customIntervalCapture.hasSubdailyLayers).toBe(true);
+ });
+});
+
+describe('DesktopAnimationWidget PlayButton props', () => {
+ test('passes isPlaying as playing', () => {
+ renderWidget({ isPlaying: true });
+ expect(playButtonCapture.playing).toBe(true);
+ });
+
+ test('passes onPushPlay as play', () => {
+ renderWidget();
+ expect(playButtonCapture.play).toBe(defaultProps.onPushPlay);
+ });
+
+ test('passes onPushPause as pause', () => {
+ renderWidget();
+ expect(playButtonCapture.pause).toBe(defaultProps.onPushPause);
+ });
+
+ test('passes playDisabled as isDisabled', () => {
+ renderWidget({ playDisabled: true });
+ expect(playButtonCapture.isDisabled).toBe(true);
+ });
+});
+
+describe('DesktopAnimationWidget LoopButton props', () => {
+ test('passes looping', () => {
+ renderWidget({ looping: true });
+ expect(loopButtonCapture.looping).toBe(true);
+ });
+
+ test('passes onLoop', () => {
+ renderWidget();
+ expect(loopButtonCapture.onLoop).toBe(defaultProps.onLoop);
+ });
+});
+
+describe('DesktopAnimationWidget GifButton props', () => {
+ test('passes zeroDates', () => {
+ renderWidget();
+ expect(gifButtonCapture.zeroDates).toBe(defaultProps.zeroDates);
+ });
+
+ test('passes numberOfFrames', () => {
+ renderWidget({ numberOfFrames: 25 });
+ expect(gifButtonCapture.numberOfFrames).toBe(25);
+ });
+});
+
+describe('DesktopAnimationWidget DateRangeSelector props', () => {
+ test('passes idSuffix as animation-widget', () => {
+ renderWidget();
+ expect(dateRangeSelectorCapture.idSuffix).toBe('animation-widget');
+ });
+
+ test('passes startDate', () => {
+ const startDate = new Date('2023-03-01');
+ renderWidget({ startDate });
+ expect(dateRangeSelectorCapture.startDate).toBe(startDate);
+ });
+
+ test('passes endDate', () => {
+ const endDate = new Date('2023-03-31');
+ renderWidget({ endDate });
+ expect(dateRangeSelectorCapture.endDate).toBe(endDate);
+ });
+
+ test('passes onDateChange as setDateRange', () => {
+ renderWidget();
+ expect(dateRangeSelectorCapture.setDateRange).toBe(defaultProps.onDateChange);
+ });
+
+ test('passes minDate', () => {
+ const minDate = new Date('2019-01-01');
+ renderWidget({ minDate });
+ expect(dateRangeSelectorCapture.minDate).toBe(minDate);
+ });
+
+ test('passes maxDate', () => {
+ const maxDate = new Date('2024-01-01');
+ renderWidget({ maxDate });
+ expect(dateRangeSelectorCapture.maxDate).toBe(maxDate);
+ });
+
+ test('passes subDailyMode', () => {
+ renderWidget({ subDailyMode: true });
+ expect(dateRangeSelectorCapture.subDailyMode).toBe(true);
+ });
+
+ test('passes isPlaying as isDisabled', () => {
+ renderWidget({ isPlaying: true });
+ expect(dateRangeSelectorCapture.isDisabled).toBe(true);
+ });
+
+ test('isDisabled is false when not playing', () => {
+ renderWidget({ isPlaying: false });
+ expect(dateRangeSelectorCapture.isDisabled).toBe(false);
+ });
+});
+
+describe('DesktopAnimationWidget FPS slider', () => {
+ test('slider has correct attributes', () => {
+ renderWidget({ speed: 3 });
+ const slider = screen.getByRole('slider');
+ expect(slider).toHaveAttribute('type', 'range');
+ expect(slider).toHaveAttribute('step', '0.5');
+ expect(slider).toHaveAttribute('min', '0.5');
+ expect(slider).toHaveAttribute('max', '10');
+ expect(slider).toHaveValue('3');
+ });
+
+ test('slider is disabled when isPlaying is true', () => {
+ renderWidget({ isPlaying: true });
+ expect(screen.getByRole('slider')).toBeDisabled();
+ });
+
+ test('slider is enabled when isPlaying is false', () => {
+ renderWidget({ isPlaying: false });
+ expect(screen.getByRole('slider')).not.toBeDisabled();
+ });
+
+ test('onChange calls setSpeed with parsed float value', () => {
+ renderWidget({ speed: 5 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '7.5' } });
+ expect(defaultProps.setSpeed).toHaveBeenCalledWith(7.5);
+ });
+
+ test('onChange calls onSlide with the current speed prop (not the new value)', () => {
+ renderWidget({ speed: 5 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '7.5' } });
+ expect(defaultProps.onSlide).toHaveBeenCalledWith(5);
+ });
+
+ test('onChange with integer string value parses correctly', () => {
+ renderWidget({ speed: 2 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '4' } });
+ expect(defaultProps.setSpeed).toHaveBeenCalledWith(4);
+ expect(defaultProps.onSlide).toHaveBeenCalledWith(2);
+ });
+});
+
+describe('DesktopAnimationWidget icon interactions', () => {
+ test('clicking chevron-down calls toggleCollapse', () => {
+ renderWidget();
+ fireEvent.click(screen.getByTestId('fa-icon-chevron-down'));
+ expect(defaultProps.toggleCollapse).toHaveBeenCalledTimes(1);
+ });
+
+ test('clicking times calls onClose', () => {
+ renderWidget();
+ fireEvent.click(screen.getByTestId('fa-icon-times'));
+ expect(defaultProps.onClose).toHaveBeenCalledTimes(1);
+ });
});
diff --git a/web/js/containers/animation-widget/kiosk-animation-widget.test.js b/web/js/containers/animation-widget/kiosk-animation-widget.test.js
index 728aebb8d..df3783b4b 100644
--- a/web/js/containers/animation-widget/kiosk-animation-widget.test.js
+++ b/web/js/containers/animation-widget/kiosk-animation-widget.test.js
@@ -1,3 +1,103 @@
-test('kiosk-animation-widget container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('../../components/kiosk/util', () => ({
+ formatKioskDate: jest.fn((date, hasSubdailyLayers) => (
+ hasSubdailyLayers
+ ? `subdaily:${date.toISOString()}`
+ : `daily:${date.toISOString()}`
+ )),
+}));
+
+import { formatKioskDate } from '../../components/kiosk/util';
+import KioskAnimationWidget from './kiosk-animation-widget';
+
+const startDate = new Date('2023-01-01T00:00:00.000Z');
+const endDate = new Date('2023-01-10T00:00:00.000Z');
+
+const defaultProps = {
+ startDate,
+ endDate,
+ hasSubdailyLayers: false,
+};
+
+const renderWidget = (overrides = {}) => render(
+ <KioskAnimationWidget {...defaultProps} {...overrides} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('KioskAnimationWidget rendering', () => {
+ test('renders wrapper and widget divs', () => {
+ const { container } = renderWidget();
+ expect(container.querySelector('.wv-kiosk-animation-wrapper')).toBeInTheDocument();
+ expect(container.querySelector('.wv-kiosk-animation-widget')).toBeInTheDocument();
+ expect(container.querySelector('.kiosk-animation-widget-row')).toBeInTheDocument();
+ });
+
+ test('renders " to " middle label', () => {
+ const { container } = renderWidget();
+ const middle = container.querySelector('#kiosk-animation-widget-middle-label');
+ expect(middle).toBeInTheDocument();
+ expect(middle.textContent).toBe(' to ');
+ });
+
+ test('renders two label spans', () => {
+ const { container } = renderWidget();
+ const labels = container.querySelectorAll('.kiosk-animation-widget-label');
+ expect(labels).toHaveLength(2);
+ });
+
+ test('renders formatted start date in first label', () => {
+ renderWidget({ hasSubdailyLayers: false });
+ const labels = document.querySelectorAll('.kiosk-animation-widget-label');
+ expect(labels[0].textContent).toBe(`daily:${startDate.toISOString()}`);
+ });
+
+ test('renders formatted end date in second label', () => {
+ renderWidget({ hasSubdailyLayers: false });
+ const labels = document.querySelectorAll('.kiosk-animation-widget-label');
+ expect(labels[1].textContent).toBe(`daily:${endDate.toISOString()}`);
+ });
+
+ test('renders subdaily formatted dates when hasSubdailyLayers is true', () => {
+ renderWidget({ hasSubdailyLayers: true });
+ const labels = document.querySelectorAll('.kiosk-animation-widget-label');
+ expect(labels[0].textContent).toBe(`subdaily:${startDate.toISOString()}`);
+ expect(labels[1].textContent).toBe(`subdaily:${endDate.toISOString()}`);
+ });
+});
+
+describe('KioskAnimationWidget formatKioskDate calls', () => {
+ test('calls formatKioskDate with startDate and hasSubdailyLayers', () => {
+ renderWidget({ hasSubdailyLayers: false });
+ expect(formatKioskDate).toHaveBeenCalledWith(startDate, false);
+ });
+
+ test('calls formatKioskDate with endDate and hasSubdailyLayers', () => {
+ renderWidget({ hasSubdailyLayers: false });
+ expect(formatKioskDate).toHaveBeenCalledWith(endDate, false);
+ });
+
+ test('calls formatKioskDate twice per render', () => {
+ renderWidget();
+ expect(formatKioskDate).toHaveBeenCalledTimes(2);
+ });
+
+ test('passes hasSubdailyLayers true to formatKioskDate', () => {
+ renderWidget({ hasSubdailyLayers: true });
+ expect(formatKioskDate).toHaveBeenCalledWith(startDate, true);
+ expect(formatKioskDate).toHaveBeenCalledWith(endDate, true);
+ });
+
+ test('uses return value of formatKioskDate for display', () => {
+ formatKioskDate.mockReturnValue('Mocked Date');
+ renderWidget();
+ const labels = document.querySelectorAll('.kiosk-animation-widget-label');
+ expect(labels[0].textContent).toBe('Mocked Date');
+ expect(labels[1].textContent).toBe('Mocked Date');
+ });
});
diff --git a/web/js/containers/animation-widget/mobile-animation-widget.test.js b/web/js/containers/animation-widget/mobile-animation-widget.test.js
index 919262222..c8efd3b3e 100644
--- a/web/js/containers/animation-widget/mobile-animation-widget.test.js
+++ b/web/js/containers/animation-widget/mobile-animation-widget.test.js
@@ -1,3 +1,364 @@
-test('mobile-animation-widget container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('lodash', () => ({
+ debounce: jest.fn((fn) => fn),
+}));
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, onClick, className }) => (
+ <svg data-testid={`fa-icon-${icon}`} className={className} onClick={onClick} />
+ ),
+}));
+
+jest.mock('../../components/timeline/date-util', () => ({
+ getISODateFormatted: jest.fn((date) => (date ? date.toISOString().split('T')[0] : '')),
+}));
+
+jest.mock('../../components/animation-widget/loop-button', () => {
+ const capture = {};
+ const MockLoopButton = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="loop-button" />;
+ };
+ MockLoopButton.capture = capture;
+ return { __esModule: true, default: MockLoopButton };
+});
+
+jest.mock('../../components/timeline/custom-interval-selector/mobile-custom-interval-selector', () => {
+ const capture = {};
+ const MockMobileCustomIntervalSelector = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="mobile-custom-interval-selector" />;
+ };
+ MockMobileCustomIntervalSelector.capture = capture;
+ return { __esModule: true, default: MockMobileCustomIntervalSelector };
+});
+
+jest.mock('../../components/timeline/mobile-date-picker', () => {
+ const captures = [];
+ const MockMobileDatePicker = (props) => {
+ captures.push({ ...props });
+ return <div data-testid="mobile-date-picker" />;
+ };
+ MockMobileDatePicker.captures = captures;
+ return { __esModule: true, default: MockMobileDatePicker };
+});
+
+import MobileAnimationWidget from './mobile-animation-widget';
+
+let loopButtonCapture;
+let mobileCustomIntervalCapture;
+let mobileDatePickerCaptures;
+
+beforeAll(() => {
+ loopButtonCapture = jest.requireMock('../../components/animation-widget/loop-button').default.capture;
+ mobileCustomIntervalCapture = jest.requireMock('../../components/timeline/custom-interval-selector/mobile-custom-interval-selector').default.capture;
+ mobileDatePickerCaptures = jest.requireMock('../../components/timeline/mobile-date-picker').default.captures;
+});
+
+let defaultProps;
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ Object.keys(loopButtonCapture).forEach((k) => delete loopButtonCapture[k]);
+ Object.keys(mobileCustomIntervalCapture).forEach((k) => delete mobileCustomIntervalCapture[k]);
+ mobileDatePickerCaptures.length = 0;
+
+ defaultProps = {
+ breakpoints: { small: 768 },
+ endDate: new Date('2023-01-10T00:00:00.000Z'),
+ hasSubdailyLayers: false,
+ isEmbedModeActive: false,
+ isLandscape: false,
+ isMobile: true,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ isPlaying: false,
+ isPortrait: false,
+ looping: false,
+ maxDate: new Date('2023-12-31T00:00:00.000Z'),
+ minDate: new Date('2020-01-01T00:00:00.000Z'),
+ onLoop: jest.fn(),
+ onSlide: jest.fn(),
+ onUpdateEndDate: jest.fn(),
+ onUpdateStartDate: jest.fn(),
+ playDisabled: false,
+ selectDate: jest.fn(),
+ screenHeight: 900,
+ screenWidth: 1024,
+ setSpeed: jest.fn(),
+ sliderLabel: 'FPS',
+ speed: 5,
+ startDate: new Date('2023-01-01T00:00:00.000Z'),
+ subDailyMode: false,
+ toggleCollapse: jest.fn(),
+ };
+});
+
+const renderWidget = (overrides = {}) => render(
+ <MobileAnimationWidget {...defaultProps} {...overrides} />,
+);
+
+describe('MobileAnimationWidget rendering', () => {
+ test('renders all major child components', () => {
+ renderWidget();
+ expect(screen.getByTestId('loop-button')).toBeInTheDocument();
+ expect(screen.getByTestId('mobile-custom-interval-selector')).toBeInTheDocument();
+ expect(screen.getAllByTestId('mobile-date-picker')).toHaveLength(2);
+ expect(screen.getByTestId('fa-icon-times')).toBeInTheDocument();
+ });
+
+ test('renders Loop label text', () => {
+ renderWidget();
+ expect(screen.getByText('Loop')).toBeInTheDocument();
+ });
+
+ test('renders Start Date and End Date labels', () => {
+ renderWidget();
+ expect(screen.getByText('Start Date')).toBeInTheDocument();
+ expect(screen.getByText('End Date')).toBeInTheDocument();
+ });
+
+ test('renders speed and sliderLabel in slider label span', () => {
+ const { container } = renderWidget({ speed: 3, sliderLabel: 'FPS' });
+ const label = container.querySelector('.wv-slider-label');
+ expect(label.textContent).toContain('3');
+ expect(label.textContent).toContain('FPS');
+ });
+
+ test('renders warning message text', () => {
+ renderWidget();
+ expect(screen.getByText(/Too many animation frames/)).toBeInTheDocument();
+ });
+});
+
+describe('MobileAnimationWidget getMobileIDs', () => {
+ test('returns mobile-phone-landscape for isMobilePhone + isLandscape', () => {
+ const { container } = renderWidget({ isMobilePhone: true, isLandscape: true });
+ expect(container.querySelector('#mobile-animation-widget-mobile-phone-landscape')).toBeInTheDocument();
+ });
+
+ test('returns mobile-phone-landscape for small screenHeight non-phone non-tablet', () => {
+ const { container } = renderWidget({
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenHeight: 700,
+ });
+ expect(container.querySelector('#mobile-animation-widget-mobile-phone-landscape')).toBeInTheDocument();
+ });
+
+ test('returns mobile-phone-portrait for isMobilePhone + isPortrait', () => {
+ const { container } = renderWidget({ isMobilePhone: true, isPortrait: true });
+ expect(container.querySelector('#mobile-animation-widget-mobile-phone-portrait')).toBeInTheDocument();
+ });
+
+ test('returns mobile-phone-portrait for narrow screenWidth non-phone non-tablet', () => {
+ const { container } = renderWidget({
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenWidth: 500,
+ screenHeight: 900,
+ });
+ expect(container.querySelector('#mobile-animation-widget-mobile-phone-portrait')).toBeInTheDocument();
+ });
+
+ test('returns tablet for isMobileTablet', () => {
+ const { container } = renderWidget({ isMobileTablet: true });
+ expect(container.querySelector('#mobile-animation-widget-tablet')).toBeInTheDocument();
+ });
+
+ test('returns tablet when screenWidth <= breakpoints.small', () => {
+ const { container } = renderWidget({
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenWidth: 768,
+ breakpoints: { small: 768 },
+ screenHeight: 900,
+ });
+ expect(container.querySelector('#mobile-animation-widget-tablet')).toBeInTheDocument();
+ });
+
+ test('returns undefined for desktop-sized non-mobile', () => {
+ const { container } = renderWidget({
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenWidth: 1024,
+ screenHeight: 900,
+ });
+ expect(container.querySelector('#mobile-animation-widget-undefined')).toBeInTheDocument();
+ });
+});
+
+describe('MobileAnimationWidget CSS classes', () => {
+ test('inner widget has subdaily class when subDailyMode is true', () => {
+ const { container } = renderWidget({ subDailyMode: true });
+ expect(container.querySelector('#wv-animation-widget')).toHaveClass('subdaily');
+ });
+
+ test('inner widget does not have subdaily class when subDailyMode is false', () => {
+ const { container } = renderWidget({ subDailyMode: false });
+ expect(container.querySelector('#wv-animation-widget')).not.toHaveClass('subdaily');
+ });
+});
+
+describe('MobileAnimationWidget header justifyContent', () => {
+ test('header uses flex-end when isEmbedModeActive is false', () => {
+ const { container } = renderWidget({ isEmbedModeActive: false });
+ const header = container.querySelector('.mobile-animation-header');
+ expect(header.style.justifyContent).toBe('flex-end');
+ });
+
+ test('header uses flex-start when isEmbedModeActive is true', () => {
+ const { container } = renderWidget({ isEmbedModeActive: true });
+ const header = container.querySelector('.mobile-animation-header');
+ expect(header.style.justifyContent).toBe('flex-start');
+ });
+});
+
+describe('MobileAnimationWidget warning message', () => {
+ test('warning span has id when playDisabled is true', () => {
+ const { container } = renderWidget({ playDisabled: true });
+ expect(container.querySelector('#mobile-animation-warning-message')).toBeInTheDocument();
+ });
+
+ test('warning span has no id when playDisabled is false', () => {
+ const { container } = renderWidget({ playDisabled: false });
+ expect(container.querySelector('#mobile-animation-warning-message')).not.toBeInTheDocument();
+ });
+});
+
+describe('MobileAnimationWidget close button', () => {
+ test('clicking close button calls toggleCollapse', () => {
+ renderWidget();
+ fireEvent.click(screen.getByRole('button', { name: 'Close' }));
+ expect(defaultProps.toggleCollapse).toHaveBeenCalledTimes(1);
+ });
+});
+
+describe('MobileAnimationWidget FPS slider', () => {
+ test('slider has correct attributes', () => {
+ renderWidget({ speed: 3 });
+ const slider = screen.getByRole('slider');
+ expect(slider).toHaveAttribute('step', '0.5');
+ expect(slider).toHaveAttribute('min', '0.5');
+ expect(slider).toHaveAttribute('max', '10');
+ expect(slider).toHaveValue('3');
+ });
+
+ test('slider is disabled when isPlaying', () => {
+ renderWidget({ isPlaying: true });
+ expect(screen.getByRole('slider')).toBeDisabled();
+ });
+
+ test('slider is enabled when not playing', () => {
+ renderWidget({ isPlaying: false });
+ expect(screen.getByRole('slider')).not.toBeDisabled();
+ });
+
+ test('slider onChange calls setSpeed with parsed float', () => {
+ renderWidget({ speed: 5 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '7.5' } });
+ expect(defaultProps.setSpeed).toHaveBeenCalledWith(7.5);
+ });
+
+ test('slider onChange calls onSlide with the current speed prop', () => {
+ renderWidget({ speed: 5 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '7.5' } });
+ expect(defaultProps.onSlide).toHaveBeenCalledWith(5);
+ });
+});
+
+describe('MobileAnimationWidget LoopButton props', () => {
+ test('passes looping prop', () => {
+ renderWidget({ looping: true });
+ expect(loopButtonCapture.looping).toBe(true);
+ });
+
+ test('passes onLoop prop', () => {
+ renderWidget();
+ expect(loopButtonCapture.onLoop).toBe(defaultProps.onLoop);
+ });
+
+ test('passes isMobile prop', () => {
+ renderWidget({ isMobile: true });
+ expect(loopButtonCapture.isMobile).toBe(true);
+ });
+});
+
+describe('MobileAnimationWidget MobileCustomIntervalSelector props', () => {
+ test('passes hasSubdailyLayers', () => {
+ renderWidget({ hasSubdailyLayers: true });
+ expect(mobileCustomIntervalCapture.hasSubdailyLayers).toBe(true);
+ });
+});
+
+describe('MobileAnimationWidget MobileDatePicker props', () => {
+ test('start picker receives startDate as date', () => {
+ renderWidget();
+ expect(mobileDatePickerCaptures[0].date).toBe(defaultProps.startDate);
+ });
+
+ test('start picker startDateLimit is formatted minDate', () => {
+ renderWidget();
+ expect(mobileDatePickerCaptures[0].startDateLimit).toBe('2020-01-01');
+ });
+
+ test('start picker endDateLimit is formatted endDate', () => {
+ renderWidget();
+ expect(mobileDatePickerCaptures[0].endDateLimit).toBe('2023-01-10');
+ });
+
+ test('start picker passes hasSubdailyLayers and isMobile', () => {
+ renderWidget({ hasSubdailyLayers: true, isMobile: true });
+ expect(mobileDatePickerCaptures[0].hasSubdailyLayers).toBe(true);
+ expect(mobileDatePickerCaptures[0].isMobile).toBe(true);
+ });
+
+ test('end picker receives endDate as date', () => {
+ renderWidget();
+ expect(mobileDatePickerCaptures[1].date).toBe(defaultProps.endDate);
+ });
+
+ test('end picker startDateLimit is formatted startDate', () => {
+ renderWidget();
+ expect(mobileDatePickerCaptures[1].startDateLimit).toBe('2023-01-01');
+ });
+
+ test('end picker endDateLimit is formatted maxDate', () => {
+ renderWidget();
+ expect(mobileDatePickerCaptures[1].endDateLimit).toBe('2023-12-31');
+ });
+});
+
+describe('MobileAnimationWidget date change callbacks', () => {
+ test('start picker onDateChange calls selectDate and onUpdateStartDate with Date object', () => {
+ renderWidget();
+ const dateStr = '2023-03-15';
+ mobileDatePickerCaptures[0].onDateChange(dateStr);
+ expect(defaultProps.selectDate).toHaveBeenCalledWith(new Date(dateStr));
+ expect(defaultProps.onUpdateStartDate).toHaveBeenCalledWith(new Date(dateStr));
+ });
+
+ test('end picker onDateChange calls selectDate and onUpdateEndDate with Date object', () => {
+ renderWidget();
+ const dateStr = '2023-06-20';
+ mobileDatePickerCaptures[1].onDateChange(dateStr);
+ expect(defaultProps.selectDate).toHaveBeenCalledWith(new Date(dateStr));
+ expect(defaultProps.onUpdateEndDate).toHaveBeenCalledWith(new Date(dateStr));
+ });
+
+ test('start picker callback does not call onUpdateEndDate', () => {
+ renderWidget();
+ mobileDatePickerCaptures[0].onDateChange('2023-03-15');
+ expect(defaultProps.onUpdateEndDate).not.toHaveBeenCalled();
+ });
+
+ test('end picker callback does not call onUpdateStartDate', () => {
+ renderWidget();
+ mobileDatePickerCaptures[1].onDateChange('2023-06-20');
+ expect(defaultProps.onUpdateStartDate).not.toHaveBeenCalled();
+ });
});
diff --git a/web/js/containers/map-interactions/map-interactions.test.js b/web/js/containers/map-interactions/map-interactions.test.js
index 4e4c9130e..61d8a222b 100644
--- a/web/js/containers/map-interactions/map-interactions.test.js
+++ b/web/js/containers/map-interactions/map-interactions.test.js
@@ -1,3 +1,230 @@
-test('map-interactoins container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('react-redux', () => {
+ const actual = jest.requireActual('react-redux');
+ const capture = {};
+ const mockConnect = (msp) => {
+ capture.msp = msp;
+ return (Component) => Component;
+ };
+ mockConnect.connectCapture = capture;
+ return { ...actual, connect: mockConnect };
+});
+
+jest.mock('../../util/context-menu', () => ({
+ ContextMenuTrigger: ({ children }) => <div data-testid="context-menu-trigger">{children}</div>,
+}));
+
+jest.mock('../../components/context-menu/context-menu', () => () => <div data-testid="right-click-menu" />);
+jest.mock('../../components/map/zoom', () => () => <div data-testid="ol-zoom-buttons" />);
+jest.mock('../../components/map/rotation', () => () => <div data-testid="ol-rotation-buttons" />);
+jest.mock('./ol-vector-interactions', () => () => <div data-testid="ol-vector-interactions" />);
+jest.mock('../../components/map/ol-measure-tool', () => () => <div data-testid="ol-measure-tool" />);
+jest.mock('../../components/location-search/ol-coordinates-marker', () => () => <div data-testid="ol-coordinates-marker" />);
+jest.mock('../../map/natural-events/natural-events', () => () => <div data-testid="natural-events" />);
+jest.mock('../../components/dateline/datelines', () => () => <div data-testid="date-lines" />);
+
+jest.mock('../../components/map/ol-coordinates', () => {
+ const capture = {};
+ const MockOlCoordinates = (props) => {
+ Object.assign(capture, props);
+ return <div data-testid="ol-coordinates" />;
+ };
+ MockOlCoordinates.capture = capture;
+ return { __esModule: true, default: MockOlCoordinates };
+});
+
+import MapInteractions from './map-interactions';
+
+let capturedMapStateToProps;
+let olCoordinatesCapture;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ olCoordinatesCapture = jest.requireMock('../../components/map/ol-coordinates').default.capture;
+});
+
+const defaultProps = {
+ isShowingClick: false,
+ isDistractionFreeModeActive: false,
+ isCoordinateSearchActive: false,
+ isNaturalEventsActive: false,
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ Object.keys(olCoordinatesCapture).forEach((k) => delete olCoordinatesCapture[k]);
+});
+
+const renderComponent = (overrides = {}) => render(
+ <MapInteractions {...defaultProps} {...overrides} />,
+);
+
+describe('MapInteractions rendering', () => {
+ test('renders all child components', () => {
+ renderComponent();
+ expect(screen.getByTestId('context-menu-trigger')).toBeInTheDocument();
+ expect(screen.getByTestId('right-click-menu')).toBeInTheDocument();
+ expect(screen.getByTestId('ol-zoom-buttons')).toBeInTheDocument();
+ expect(screen.getByTestId('ol-rotation-buttons')).toBeInTheDocument();
+ expect(screen.getByTestId('ol-coordinates')).toBeInTheDocument();
+ expect(screen.getByTestId('ol-vector-interactions')).toBeInTheDocument();
+ expect(screen.getByTestId('ol-measure-tool')).toBeInTheDocument();
+ expect(screen.getByTestId('ol-coordinates-marker')).toBeInTheDocument();
+ expect(screen.getByTestId('date-lines')).toBeInTheDocument();
+ });
+
+ test('renders the wv-map div inside ContextMenuTrigger', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#wv-map')).toBeInTheDocument();
+ });
+
+ test('renders NaturalEvents when isNaturalEventsActive is true', () => {
+ renderComponent({ isNaturalEventsActive: true });
+ expect(screen.getByTestId('natural-events')).toBeInTheDocument();
+ });
+
+ test('does not render NaturalEvents when isNaturalEventsActive is false', () => {
+ renderComponent({ isNaturalEventsActive: false });
+ expect(screen.queryByTestId('natural-events')).not.toBeInTheDocument();
+ });
+});
+
+describe('MapInteractions getMapClasses', () => {
+ test('wv-map div always has base wv-map class', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#wv-map')).toHaveClass('wv-map');
+ });
+
+ test('adds cursor-pointer when isShowingClick and not isCoordinateSearchActive', () => {
+ const { container } = renderComponent({
+ isShowingClick: true,
+ isCoordinateSearchActive: false,
+ });
+ expect(container.querySelector('#wv-map')).toHaveClass('cursor-pointer');
+ });
+
+ test('does not add cursor-pointer when isShowingClick is false', () => {
+ const { container } = renderComponent({
+ isShowingClick: false,
+ isCoordinateSearchActive: false,
+ });
+ expect(container.querySelector('#wv-map')).not.toHaveClass('cursor-pointer');
+ });
+
+ test('does not add cursor-pointer when isCoordinateSearchActive is true', () => {
+ const { container } = renderComponent({
+ isShowingClick: true,
+ isCoordinateSearchActive: true,
+ isDistractionFreeModeActive: true,
+ });
+ expect(container.querySelector('#wv-map')).not.toHaveClass('cursor-pointer');
+ });
+
+ test('adds cursor-crosshair when isCoordinateSearchActive and not isDistractionFreeModeActive', () => {
+ const { container } = renderComponent({
+ isCoordinateSearchActive: true,
+ isDistractionFreeModeActive: false,
+ });
+ expect(container.querySelector('#wv-map')).toHaveClass('cursor-crosshair');
+ });
+
+ test('does not add cursor-crosshair when isDistractionFreeModeActive is true', () => {
+ const { container } = renderComponent({
+ isCoordinateSearchActive: true,
+ isDistractionFreeModeActive: true,
+ });
+ expect(container.querySelector('#wv-map')).not.toHaveClass('cursor-crosshair');
+ });
+
+ test('does not add cursor-crosshair when isCoordinateSearchActive is false', () => {
+ const { container } = renderComponent({
+ isCoordinateSearchActive: false,
+ isDistractionFreeModeActive: false,
+ });
+ expect(container.querySelector('#wv-map')).not.toHaveClass('cursor-crosshair');
+ });
+
+ test('adds distraction-free-active when isDistractionFreeModeActive is true', () => {
+ const { container } = renderComponent({ isDistractionFreeModeActive: true });
+ expect(container.querySelector('#wv-map')).toHaveClass('distraction-free-active');
+ });
+
+ test('does not add distraction-free-active when isDistractionFreeModeActive is false', () => {
+ const { container } = renderComponent({ isDistractionFreeModeActive: false });
+ expect(container.querySelector('#wv-map')).not.toHaveClass('distraction-free-active');
+ });
+
+ test('can combine cursor-pointer and distraction-free-active classes', () => {
+ const { container } = renderComponent({
+ isShowingClick: true,
+ isCoordinateSearchActive: false,
+ isDistractionFreeModeActive: true,
+ });
+ const mapDiv = container.querySelector('#wv-map');
+ expect(mapDiv).toHaveClass('cursor-pointer');
+ expect(mapDiv).toHaveClass('distraction-free-active');
+ });
+});
+
+describe('MapInteractions OlCoordinates props', () => {
+ test('passes show=true when isDistractionFreeModeActive is false', () => {
+ renderComponent({ isDistractionFreeModeActive: false });
+ expect(olCoordinatesCapture.show).toBe(true);
+ });
+
+ test('passes show=false when isDistractionFreeModeActive is true', () => {
+ renderComponent({ isDistractionFreeModeActive: true });
+ expect(olCoordinatesCapture.show).toBe(false);
+ });
+});
+
+describe('MapInteractions mapStateToProps', () => {
+ const buildState = ({
+ naturalEvents = true,
+ isCoordinateSearchActive = false,
+ isClickable = false,
+ isDistractionFreeModeActive = false,
+ eventsActive = false,
+ } = {}) => ({
+ config: { features: { naturalEvents } },
+ locationSearch: { isCoordinateSearchActive },
+ map: { isClickable },
+ ui: { isDistractionFreeModeActive },
+ events: { active: eventsActive },
+ });
+
+ test('maps map.isClickable to isShowingClick', () => {
+ const result = capturedMapStateToProps(buildState({ isClickable: true }));
+ expect(result.isShowingClick).toBe(true);
+ });
+
+ test('maps ui.isDistractionFreeModeActive', () => {
+ const result = capturedMapStateToProps(buildState({ isDistractionFreeModeActive: true }));
+ expect(result.isDistractionFreeModeActive).toBe(true);
+ });
+
+ test('maps locationSearch.isCoordinateSearchActive', () => {
+ const result = capturedMapStateToProps(buildState({ isCoordinateSearchActive: true }));
+ expect(result.isCoordinateSearchActive).toBe(true);
+ });
+
+ test('isNaturalEventsActive is true when naturalEvents and events.active are both true', () => {
+ const result = capturedMapStateToProps(buildState({ naturalEvents: true, eventsActive: true }));
+ expect(result.isNaturalEventsActive).toBe(true);
+ });
+
+ test('isNaturalEventsActive is false when config.features.naturalEvents is false', () => {
+ const result = capturedMapStateToProps(buildState({ naturalEvents: false, eventsActive: true }));
+ expect(result.isNaturalEventsActive).toBe(false);
+ });
+
+ test('isNaturalEventsActive is false when events.active is false', () => {
+ const result = capturedMapStateToProps(buildState({ naturalEvents: true, eventsActive: false }));
+ expect(result.isNaturalEventsActive).toBe(false);
+ });
});
diff --git a/web/js/containers/map-interactions/ol-vector-interactions.test.js b/web/js/containers/map-interactions/ol-vector-interactions.test.js
index bcab2c0ee..eced20571 100644
--- a/web/js/containers/map-interactions/ol-vector-interactions.test.js
+++ b/web/js/containers/map-interactions/ol-vector-interactions.test.js
@@ -1,9 +1,42 @@
+import React from 'react';
import { act } from 'react';
import renderer from 'react-test-renderer';
+import { Provider } from 'react-redux';
import util from '../../util/util';
import { VectorInteractions } from './ol-vector-interactions';
+import VectorInteractionsConnected from './ol-vector-interactions';
import { registerProjections } from '../../fixtures';
-import { MAP_MOUSE_MOVE, MAP_SINGLE_CLICK, GRANULE_HOVERED } from '../../util/constants';
+import { MAP_MOUSE_MOVE, MAP_SINGLE_CLICK, GRANULE_HOVERED, MAP_MOVE_END, MAP_MOUSE_OUT, GRANULE_HOVER_UPDATE } from '../../util/constants';
+import { hasNonClickableVectorLayer } from '../../modules/layers/util';
+import { areCoordinatesAndPolygonExtentValid } from '../../map/granule/util';
+
+jest.mock('../../modules/layers/util', () => ({
+ hasNonClickableVectorLayer: jest.fn(() => false),
+}));
+jest.mock('../../map/granule/util', () => ({
+ areCoordinatesAndPolygonExtentValid: jest.fn(() => false),
+}));
+jest.mock('../../modules/compare/util', () => ({
+ isFromActiveCompareRegion: jest.fn(() => true),
+}));
+jest.mock('../../modules/layers/selectors', () => ({
+ getActiveLayers: jest.fn(() => []),
+ getGranulePlatform: jest.fn(() => null),
+ getActiveGranuleFootPrints: jest.fn(() => null),
+}));
+jest.mock('../../modules/vector-styles/util', () => ({
+ onMapClickGetVectorFeatures: jest.fn(() => ({ metaArray: [], selected: {} })),
+}));
+jest.mock('../../modules/modal/actions', () => ({
+ openCustomContent: jest.fn(() => ({ type: 'OPEN_CUSTOM_CONTENT' })),
+ onClose: jest.fn(() => ({ type: 'ON_CLOSE' })),
+}));
+jest.mock('../../modules/vector-styles/actions', () => ({
+ selectVectorFeatures: jest.fn(() => ({ type: 'SELECT_VECTOR_FEATURES' })),
+}));
+jest.mock('../../modules/map/actions', () => ({
+ changeCursor: jest.fn(() => ({ type: 'CHANGE_CURSOR' })),
+}));
let consoleErrorSpy;
let originalConsoleError;
@@ -20,6 +53,11 @@ afterAll(() => {
if (consoleErrorSpy) consoleErrorSpy.mockRestore();
});
+afterEach(() => {
+ // Unmount the shared component so its event listeners don't bleed into subsequent tests.
+ try { act(() => { component.unmount(); }); } catch { /* already unmounted by the test */ }
+});
+
const { events } = util;
let component;
let map;
@@ -291,3 +329,569 @@ describe('componentDidUpdate - clear orphaned granule footprint', () => {
expect(instance.state.granuleDate).toBe('2024-01-15');
});
});
+
+// ---------------------------------------------------------------------------
+// Helper used by the tests below — uses createElement to avoid JSX prop spreading
+// ---------------------------------------------------------------------------
+function makeComponent(extraProps = {}) {
+ const baseProps = {
+ mouseEvents: events,
+ isShowingClick: false,
+ changeCursor,
+ getDialogObject,
+ openVectorDialog,
+ selectVectorFeatures,
+ lastSelected: {},
+ measureIsActive: false,
+ onCloseModal: jest.fn(),
+ modalState: { id: [], isOpen: false },
+ isDistractionFreeModeActive: false,
+ isMobile: false,
+ proj: { id: 'geographic' },
+ activeLayers: [{ def: { type: 'vector' } }],
+ };
+ let comp;
+ act(() => {
+ comp = renderer.create(
+ React.createElement(VectorInteractions, Object.assign({}, baseProps, extraProps)),
+ );
+ });
+ return comp;
+}
+
+// ---------------------------------------------------------------------------
+// moveEnd
+// ---------------------------------------------------------------------------
+describe('moveEnd', () => {
+ test('triggers GRANULE_HOVER_UPDATE when granuleDate and granulePlatform are set', () => {
+ const spy = jest.fn();
+ events.on(GRANULE_HOVER_UPDATE, spy);
+ act(() => {
+ component.getInstance().setState({ granuleDate: '2024-01-15', granulePlatform: 'MODIS' });
+ });
+ events.trigger(MAP_MOVE_END);
+ expect(spy).toHaveBeenCalledWith('MODIS', '2024-01-15');
+ events.off(GRANULE_HOVER_UPDATE, spy);
+ });
+
+ test('does not trigger GRANULE_HOVER_UPDATE when granule state is empty', () => {
+ const spy = jest.fn();
+ events.on(GRANULE_HOVER_UPDATE, spy);
+ events.trigger(MAP_MOVE_END);
+ expect(spy).not.toHaveBeenCalled();
+ events.off(GRANULE_HOVER_UPDATE, spy);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// mouseOut
+// ---------------------------------------------------------------------------
+test('mouseOut triggers GRANULE_HOVERED with null', () => {
+ const spy = jest.fn();
+ events.on(GRANULE_HOVERED, spy);
+ events.trigger(MAP_MOUSE_OUT);
+ expect(spy).toHaveBeenCalledWith(null);
+ events.off(GRANULE_HOVERED, spy);
+});
+
+// ---------------------------------------------------------------------------
+// mouseMove early returns
+// ---------------------------------------------------------------------------
+describe('mouseMove early returns', () => {
+ test('returns early when measureIsActive is true', () => {
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ measureIsActive: true });
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = jest.fn();
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).not.toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('returns early when isCoordinateSearchActive is true', () => {
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ isCoordinateSearchActive: true });
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = jest.fn();
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).not.toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('returns early when coordinates are out of bounds', () => {
+ act(() => { component.unmount(); });
+ // isShowingClick=true so changeCursor(false) would fire if not for early return
+ const testComp = makeComponent({ isShowingClick: true });
+ map.hasFeatureAtPixel = () => false;
+ map.getCoordinateFromPixel = () => [300, 0]; // lon 300 > 250
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).not.toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+});
+
+// ---------------------------------------------------------------------------
+// handleCursorChange
+// ---------------------------------------------------------------------------
+describe('handleCursorChange', () => {
+ test('calls changeCursor(true) when an active non-reference feature is at pixel', () => {
+ const mockFeature = { getGeometry: () => ({ getType: () => 'Point' }) };
+ const mockLayer = {
+ wv: { def: { layergroup: 'Data' }, group: 'active' },
+ get: () => null,
+ };
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = (pixel, cb) => { cb(mockFeature, mockLayer); };
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).toHaveBeenCalledWith(true);
+ });
+
+ test('calls changeCursor(false) when no features and isShowingClick is true', () => {
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ isShowingClick: true });
+ map.hasFeatureAtPixel = () => false;
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).toHaveBeenCalledWith(false);
+ act(() => { testComp.unmount(); });
+ });
+
+ test('does not call changeCursor(true) when feature is on a Reference layer', () => {
+ const mockFeature = { getGeometry: () => ({ getType: () => 'Point' }) };
+ const mockLayer = {
+ wv: { def: { layergroup: 'Reference' }, group: 'active' },
+ get: () => null,
+ };
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = (pixel, cb) => { cb(mockFeature, mockLayer); };
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).not.toHaveBeenCalledWith(true);
+ });
+
+ test('skips feature when geometry type is in clickDisabledFeatures', () => {
+ const mockFeature = { getGeometry: () => ({ getType: () => 'Point' }) };
+ const mockLayer = {
+ wv: { def: { layergroup: 'Data', clickDisabledFeatures: ['Point'] }, group: 'active' },
+ get: () => null,
+ };
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = (pixel, cb) => { cb(mockFeature, mockLayer); };
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).not.toHaveBeenCalledWith(true);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// singleClick additional branches
+// ---------------------------------------------------------------------------
+describe('singleClick additional branches', () => {
+ test('returns early when measureIsActive is true', () => {
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ measureIsActive: true });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(openVectorDialog).not.toHaveBeenCalled();
+ expect(selectVectorFeatures).not.toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('returns early when isCoordinateSearchActive is true', () => {
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ isCoordinateSearchActive: true });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(openVectorDialog).not.toHaveBeenCalled();
+ expect(selectVectorFeatures).not.toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('returns early when isCoordinatesMarker is true', () => {
+ const markerDialog = () => ({
+ isCoordinatesMarker: true,
+ metaArray: [{ id: 'some' }],
+ selected: {},
+ offsetLeft: 10,
+ offsetTop: 10,
+ });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ getDialogObject: markerDialog });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(openVectorDialog).not.toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('activates zoom alert when hasNonClickableVectorLayer is true and metaArray has items', () => {
+ hasNonClickableVectorLayer.mockReturnValueOnce(true);
+ const activateVectorZoomAlert = jest.fn();
+ const dialogWithMeta = () => ({
+ metaArray: [{ id: 'some-layer' }],
+ selected: {},
+ offsetLeft: 10,
+ offsetTop: 10,
+ });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ getDialogObject: dialogWithMeta, activateVectorZoomAlert });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(activateVectorZoomAlert).toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('activates zoom alert when hasNonClickableVectorLayer is true and metaArray is empty', () => {
+ hasNonClickableVectorLayer.mockReturnValueOnce(true);
+ const activateVectorZoomAlert = jest.fn();
+ const emptyDialog = () => ({ metaArray: [], selected: {}, offsetLeft: 10, offsetTop: 10 });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ getDialogObject: emptyDialog, activateVectorZoomAlert });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(activateVectorZoomAlert).toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('activates exceeded results alert when exceededLengthLimit is true', () => {
+ const activateVectorExceededResultsAlert = jest.fn();
+ const exceededDialog = () => ({
+ metaArray: [{ id: 'some-layer' }],
+ selected: {},
+ offsetLeft: 10,
+ offsetTop: 10,
+ exceededLengthLimit: true,
+ });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ getDialogObject: exceededDialog,
+ activateVectorExceededResultsAlert,
+ });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(activateVectorExceededResultsAlert).toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('clears exceeded results alert when isVectorExceededAlertPresent and no exceeded limit', () => {
+ const clearVectorExceededResultsAlert = jest.fn();
+ const normalDialog = () => ({
+ metaArray: [{ id: 'some-layer' }],
+ selected: {},
+ offsetLeft: 10,
+ offsetTop: 10,
+ });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ getDialogObject: normalDialog,
+ clearVectorExceededResultsAlert,
+ isVectorExceededAlertPresent: true,
+ });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(clearVectorExceededResultsAlert).toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('closes modal and clears features when vector modal is open but no selection', () => {
+ const onCloseModal = jest.fn();
+ const emptyDialog = () => ({ metaArray: [], selected: {}, offsetLeft: 10, offsetTop: 10 });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ getDialogObject: emptyDialog,
+ modalState: { id: ['vector_dialog'], isOpen: true },
+ onCloseModal,
+ lastSelected: {},
+ });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(onCloseModal).toHaveBeenCalled();
+ expect(selectVectorFeatures).toHaveBeenCalledWith({});
+ act(() => { testComp.unmount(); });
+ });
+
+ test('calls handleGranuleHover on mobile click', () => {
+ act(() => { component.unmount(); });
+ const emptyDialog = () => ({ metaArray: [], selected: {}, offsetLeft: 10, offsetTop: 10 });
+ const testComp = makeComponent({
+ getDialogObject: emptyDialog,
+ isMobile: true,
+ screenSize: { screenWidth: 375, screenHeight: 667, isMobileDevice: true },
+ granuleFootprints: { '2024-01-15': [[[0, 0], [1, 0], [1, 1]]] },
+ granulePlatform: 'MODIS',
+ compareState: { active: false },
+ visibleExtent: [-180, -90, 180, 90],
+ });
+ // should not throw
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ act(() => { testComp.unmount(); });
+ });
+});
+
+// ---------------------------------------------------------------------------
+// handleGranuleHover via mouseMove
+// ---------------------------------------------------------------------------
+describe('handleGranuleHover', () => {
+ test('triggers GRANULE_HOVERED with platform and date when a valid polygon is found', () => {
+ areCoordinatesAndPolygonExtentValid.mockReturnValue(true);
+ const spy = jest.fn();
+ events.on(GRANULE_HOVERED, spy);
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ granuleFootprints: { '2024-01-15': [[[0, 0], [1, 0], [1, 1]]] },
+ granulePlatform: 'MODIS',
+ compareState: { active: false },
+ visibleExtent: [-180, -90, 180, 90],
+ isMobile: false,
+ });
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(spy).toHaveBeenCalledWith('MODIS', '2024-01-15');
+ areCoordinatesAndPolygonExtentValid.mockReturnValue(false);
+ events.off(GRANULE_HOVERED, spy);
+ act(() => { testComp.unmount(); });
+ });
+
+ test('clears granule footprint via GRANULE_HOVERED null when no valid polygon found', () => {
+ areCoordinatesAndPolygonExtentValid.mockReturnValue(false);
+ const spy = jest.fn();
+ events.on(GRANULE_HOVERED, spy);
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ granuleFootprints: { '2024-01-15': [[[0, 0], [1, 0], [1, 1]]] },
+ granulePlatform: 'MODIS',
+ compareState: { active: false },
+ visibleExtent: [-180, -90, 180, 90],
+ isMobile: false,
+ });
+ act(() => {
+ testComp.getInstance().setState({ granuleDate: '2024-01-15', granulePlatform: 'MODIS' });
+ });
+ spy.mockClear();
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(spy).toHaveBeenCalledWith(null);
+ events.off(GRANULE_HOVERED, spy);
+ act(() => { testComp.unmount(); });
+ });
+
+ test('returns early when compare is active and pixel is outside active region', () => {
+ const { isFromActiveCompareRegion: mockIsFAR } = require('../../modules/compare/util');
+ mockIsFAR.mockReturnValueOnce(false);
+ areCoordinatesAndPolygonExtentValid.mockReturnValue(true);
+ const spy = jest.fn();
+ events.on(GRANULE_HOVERED, spy);
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ granuleFootprints: { '2024-01-15': [[[0, 0], [1, 0], [1, 1]]] },
+ granulePlatform: 'MODIS',
+ compareState: { active: true, activeString: 'active', mode: 'swipe' },
+ visibleExtent: [-180, -90, 180, 90],
+ swipeOffset: 100,
+ isMobile: false,
+ });
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(spy).not.toHaveBeenCalledWith('MODIS', '2024-01-15');
+ areCoordinatesAndPolygonExtentValid.mockReturnValue(false);
+ events.off(GRANULE_HOVERED, spy);
+ act(() => { testComp.unmount(); });
+ });
+});
+
+// ---------------------------------------------------------------------------
+// handleCursorChange — additional branch coverage
+// ---------------------------------------------------------------------------
+describe('handleCursorChange additional branches', () => {
+ test('skips feature when layer is null', () => {
+ const mockFeature = { getGeometry: () => ({ getType: () => 'Point' }) };
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = (pixel, cb) => { cb(mockFeature, null); };
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).not.toHaveBeenCalledWith(true);
+ });
+
+ test('skips feature when layer has no wv.def', () => {
+ const mockFeature = { getGeometry: () => ({ getType: () => 'Point' }) };
+ const mockLayer = { wv: {}, get: () => null };
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = (pixel, cb) => { cb(mockFeature, mockLayer); };
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).not.toHaveBeenCalledWith(true);
+ });
+
+ test('skips feature when coordinate is outside layer extent', () => {
+ const mockFeature = { getGeometry: () => ({ getType: () => 'Point' }) };
+ const mockLayer = {
+ wv: { def: { layergroup: 'Data' }, group: 'active' },
+ get: () => [10, 10, 20, 20], // extent that does not contain [0,0]
+ };
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = (pixel, cb) => { cb(mockFeature, mockLayer); };
+ map.getCoordinateFromPixel = () => [0, 0]; // outside [10,10,20,20]
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).not.toHaveBeenCalledWith(true);
+ });
+
+ test('treats feature as rendered when layer is wrapped (wrapadjacentdays=true)', () => {
+ const mockFeature = { getGeometry: () => ({ getType: () => 'Point' }) };
+ const mockLayer = {
+ wv: { def: { layergroup: 'Data', wrapadjacentdays: true }, group: 'active' },
+ get: () => null,
+ };
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = (pixel, cb) => { cb(mockFeature, mockLayer); };
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(changeCursor).toHaveBeenCalledWith(true);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// singleClick — additional branch coverage
+// ---------------------------------------------------------------------------
+describe('singleClick additional branch coverage', () => {
+ test('uses AERONET modal width when metaArray item id includes AERONET', () => {
+ const aeronetDialog = () => ({
+ metaArray: [{ id: 'AERONET_Points_All' }],
+ selected: { AERONET_Points_All: [{}] },
+ offsetLeft: 10,
+ offsetTop: 10,
+ });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({ getDialogObject: aeronetDialog });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ // openVectorDialog should be called (not zoom alert, since hasNonClickableVectorLayer = false)
+ expect(openVectorDialog).toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('calls selectVectorFeatures when lastSelected has entries and modal is not open', () => {
+ const emptyMeta = () => ({
+ metaArray: [],
+ selected: {},
+ offsetLeft: 10,
+ offsetTop: 10,
+ });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ getDialogObject: emptyMeta,
+ lastSelected: { someLayer: [{}] },
+ modalState: { id: [], isOpen: false },
+ });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(selectVectorFeatures).toHaveBeenCalledWith({});
+ act(() => { testComp.unmount(); });
+ });
+
+ test('skips selectVectorFeatures on mobile when hasNonClickableVectorLayer', () => {
+ hasNonClickableVectorLayer.mockReturnValueOnce(true);
+ const activateVectorZoomAlert = jest.fn();
+ const dialogWithSelected = () => ({
+ metaArray: [],
+ selected: { someLayer: [{}] },
+ offsetLeft: 10,
+ offsetTop: 10,
+ });
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ getDialogObject: dialogWithSelected,
+ activateVectorZoomAlert,
+ isMobile: true,
+ screenSize: { screenWidth: 375, screenHeight: 667, isMobileDevice: true },
+ lastSelected: { someLayer: [{}] },
+ compareState: { active: false },
+ visibleExtent: [-180, -90, 180, 90],
+ granuleFootprints: {},
+ });
+ act(() => { events.trigger(MAP_SINGLE_CLICK, { pixel: [0, 0] }, map, 'EPSG:4326'); });
+ expect(selectVectorFeatures).not.toHaveBeenCalled();
+ act(() => { testComp.unmount(); });
+ });
+
+ test('mouseMove skips granuleHover when isMobile is true', () => {
+ areCoordinatesAndPolygonExtentValid.mockReturnValue(true);
+ const spy = jest.fn();
+ events.on(GRANULE_HOVERED, spy);
+ act(() => { component.unmount(); });
+ const testComp = makeComponent({
+ granuleFootprints: { '2024-01-15': [[[0, 0], [1, 0], [1, 1]]] },
+ granulePlatform: 'MODIS',
+ compareState: { active: false },
+ visibleExtent: [-180, -90, 180, 90],
+ isMobile: true,
+ });
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(spy).not.toHaveBeenCalledWith('MODIS', '2024-01-15');
+ areCoordinatesAndPolygonExtentValid.mockReturnValue(false);
+ events.off(GRANULE_HOVERED, spy);
+ act(() => { testComp.unmount(); });
+ });
+});
+
+// ---------------------------------------------------------------------------
+// componentWillUnmount
+// ---------------------------------------------------------------------------
+test('componentWillUnmount removes event listeners so events no longer reach handlers', () => {
+ const spy = jest.fn();
+ events.on(GRANULE_HOVERED, spy);
+
+ // Confirm handler is active before unmount
+ events.trigger(MAP_MOUSE_OUT);
+ expect(spy).toHaveBeenCalledTimes(1);
+ spy.mockClear();
+
+ act(() => { component.unmount(); });
+
+ // After unmount the component's mouseOut handler is unregistered; GRANULE_HOVERED won't fire
+ events.trigger(MAP_MOUSE_OUT);
+ expect(spy).not.toHaveBeenCalled();
+
+ events.off(GRANULE_HOVERED, spy);
+});
+
+// ---------------------------------------------------------------------------
+// Connected component — exercises mapStateToProps and mapDispatchToProps
+// ---------------------------------------------------------------------------
+describe('connected component', () => {
+ const mockReduxState = {
+ animation: { isPlaying: false },
+ screenSize: { screenWidth: 1000, screenHeight: 800, isMobileDevice: false },
+ compare: { active: false, mode: 'swipe', value: 50 },
+ config: { projections: { geographic: { maxExtent: [-180, -90, 180, 90] } } },
+ map: { isClickable: false },
+ measure: { isActive: false },
+ modal: { id: [], isOpen: false },
+ proj: { id: 'geographic', selected: { crs: 'EPSG:4326' } },
+ ui: { isDistractionFreeModeActive: false },
+ vectorStyles: { selected: {} },
+ alerts: { isVectorExceededAlertPresent: false },
+ locationSearch: { isCoordinateSearchActive: false },
+ embed: { isEmbedModeActive: false },
+ };
+
+ const mockStore = {
+ getState: () => mockReduxState,
+ subscribe: () => () => {},
+ dispatch: jest.fn(),
+ };
+
+ test('renders via Redux connect, exercising mapStateToProps and mapDispatchToProps', () => {
+ act(() => { component.unmount(); });
+ let connectedComp;
+ act(() => {
+ connectedComp = renderer.create(
+ React.createElement(Provider, { store: mockStore },
+ React.createElement(VectorInteractionsConnected, null)),
+ );
+ });
+ expect(connectedComp.toJSON()).toBeNull();
+ act(() => { connectedComp.unmount(); });
+ });
+
+ test('connected component dispatches changeCursor on mouse move with feature', () => {
+ act(() => { component.unmount(); });
+ const mockFeature = { getGeometry: () => ({ getType: () => 'Point' }) };
+ const mockLayer = {
+ wv: { def: { layergroup: 'Data' }, group: 'active' },
+ get: () => null,
+ };
+ map.hasFeatureAtPixel = () => true;
+ map.forEachFeatureAtPixel = (pixel, cb) => { cb(mockFeature, mockLayer); };
+
+ let connectedComp;
+ act(() => {
+ connectedComp = renderer.create(
+ React.createElement(Provider, { store: mockStore },
+ React.createElement(VectorInteractionsConnected, null)),
+ );
+ });
+ events.trigger(MAP_MOUSE_MOVE, { pixel: [0, 0] }, map, 'EPSG:4326');
+ expect(mockStore.dispatch).toHaveBeenCalled();
+ act(() => { connectedComp.unmount(); });
+ });
+});
diff --git a/web/js/containers/sidebar/add-layers-content.test.js b/web/js/containers/sidebar/add-layers-content.test.js
index 2e1f25956..78b001e57 100644
--- a/web/js/containers/sidebar/add-layers-content.test.js
+++ b/web/js/containers/sidebar/add-layers-content.test.js
@@ -1,3 +1,356 @@
-test('add-layers-content container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, fireEvent } 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('react-device-detect', () => ({
+ isMobileOnly: false,
+ isTablet: false,
+}));
+
+jest.mock('../../modules/layers/actions', () => ({
+ toggleOverlayGroups: jest.fn(() => ({ type: 'TOGGLE_OVERLAY_GROUPS' })),
+}));
+
+jest.mock('../../modules/modal/actions', () => ({
+ openCustomContent: jest.fn(() => ({ type: 'OPEN_CUSTOM_CONTENT' })),
+}));
+
+jest.mock('../../modules/animation/actions', () => ({
+ stop: jest.fn(() => ({ type: 'STOP_ANIMATION' })),
+}));
+
+jest.mock('../../components/layer/product-picker/search-ui-provider', () => () => (
+ <div data-testid="search-ui-provider" />
+));
+
+jest.mock('../../components/util/button', () => function MockButton({ onClick, text, id, className }) {
+ return (
+ <button
+ type="button"
+ data-testid={id || 'mock-button'}
+ className={className}
+ onClick={onClick}
+ >
+ {text}
+ </button>
+ );
+});
+
+jest.mock('../../components/util/checkbox', () => function MockCheckbox({ id, checked, onCheck, label }) {
+ return (
+ <input
+ type="checkbox"
+ data-testid={id || 'mock-checkbox'}
+ checked={checked}
+ onChange={onCheck}
+ aria-label={label}
+ />
+ );
+});
+
+jest.mock('@edsc/earthdata-react-icons/horizon-design-system/hds/ui', () => ({
+ Plus: () => <span data-testid="plus-icon" />,
+}));
+
+import AddLayersContent from './add-layers-content';
+import { toggleOverlayGroups as toggleOverlayGroupsAction } from '../../modules/layers/actions';
+import { openCustomContent } from '../../modules/modal/actions';
+import { stop as stopAnimationAction } from '../../modules/animation/actions';
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ const reactDeviceDetect = require('react-device-detect');
+ reactDeviceDetect.isMobileOnly = false;
+ reactDeviceDetect.isTablet = false;
+});
+
+const defaultProps = {
+ groupOverlays: false,
+ isActive: true,
+ isAnimating: false,
+ isEmbedModeActive: false,
+ isMobile: false,
+ breakpoints: {},
+ screenWidth: 1024,
+ toggleOverlayGroups: jest.fn(),
+ addLayers: jest.fn(),
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <AddLayersContent {...defaultProps} {...propOverrides} />,
+);
+
+describe('AddLayersContent rendering', () => {
+ it('renders product-buttons section when isActive and not in embed mode', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.product-buttons')).toBeInTheDocument();
+ });
+
+ it('renders the Add Layers button', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('layers-add')).toBeInTheDocument();
+ });
+
+ it('renders the group overlays checkbox', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('group-overlays-checkbox')).toBeInTheDocument();
+ });
+
+ it('renders the hr separator', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.product-section-break')).toBeInTheDocument();
+ });
+
+ it('renders nothing when isActive is false', () => {
+ const { container } = renderComponent({ isActive: false });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders nothing when isEmbedModeActive is true', () => {
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders nothing when isActive is false and isEmbedModeActive is true', () => {
+ const { container } = renderComponent({ isActive: false, isEmbedModeActive: true });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders checkbox as checked when groupOverlays is true', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: true });
+ expect(getByTestId('group-overlays-checkbox')).toBeChecked();
+ });
+
+ it('renders checkbox as unchecked when groupOverlays is false', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: false });
+ expect(getByTestId('group-overlays-checkbox')).not.toBeChecked();
+ });
+});
+
+describe('AddLayersContent interactions', () => {
+ it('calls addLayers when Add Layers button is clicked', () => {
+ const addLayers = jest.fn();
+ const { getByTestId } = renderComponent({ addLayers });
+ fireEvent.click(getByTestId('layers-add'));
+ expect(addLayers).toHaveBeenCalledTimes(1);
+ });
+
+ it('passes isAnimating, isMobile, breakpoints, screenWidth to addLayers', () => {
+ const addLayers = jest.fn();
+ const breakpoints = { sm: 576 };
+ const { getByTestId } = renderComponent({
+ addLayers,
+ isAnimating: true,
+ isMobile: true,
+ breakpoints,
+ screenWidth: 768,
+ });
+ fireEvent.click(getByTestId('layers-add'));
+ expect(addLayers).toHaveBeenCalledWith(true, true, breakpoints, 768);
+ });
+
+ it('pushes add_layers event to googleTagManager on button click', () => {
+ const { getByTestId } = renderComponent();
+ window.dataLayer = [];
+ fireEvent.click(getByTestId('layers-add'));
+ expect(window.dataLayer).toEqual(
+ expect.arrayContaining([expect.objectContaining({ event: 'add_layers' })]),
+ );
+ });
+
+ it('calls toggleOverlayGroups when checkbox changes', () => {
+ const toggleOverlayGroups = jest.fn();
+ const { getByTestId } = renderComponent({ toggleOverlayGroups });
+ fireEvent.click(getByTestId('group-overlays-checkbox'));
+ expect(toggleOverlayGroups).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls e.stopPropagation on Add Layers button click', () => {
+ const addLayers = jest.fn();
+ const { getByTestId } = renderComponent({ addLayers });
+ const stopPropagation = jest.fn();
+ fireEvent.click(getByTestId('layers-add'), { stopPropagation });
+ // stopPropagation is called internally via the synthetic event wrapper
+ expect(addLayers).toHaveBeenCalled();
+ });
+});
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ embed: { isEmbedModeActive: false },
+ layers: {
+ active: { groupOverlays: true },
+ activeB: { groupOverlays: false },
+ },
+ animation: { isPlaying: false },
+ screenSize: {
+ isMobileDevice: false,
+ breakpoints: { sm: 576, md: 768 },
+ screenWidth: 1280,
+ },
+ ...overrides,
+ });
+
+ 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 isAnimating false when animation is not playing', () => {
+ const state = makeState({ animation: { isPlaying: false } });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.isAnimating).toBe(false);
+ });
+
+ 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, breakpoints: {}, screenWidth: 375 },
+ });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.isMobile).toBe(true);
+ });
+
+ it('maps breakpoints from screenSize.breakpoints', () => {
+ const breakpoints = { sm: 576, md: 768, lg: 992 };
+ const state = makeState({
+ screenSize: { isMobileDevice: false, breakpoints, screenWidth: 1024 },
+ });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.breakpoints).toBe(breakpoints);
+ });
+
+ it('maps screenWidth from screenSize.screenWidth', () => {
+ const state = makeState({
+ screenSize: { isMobileDevice: false, breakpoints: {}, screenWidth: 1920 },
+ });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.screenWidth).toBe(1920);
+ });
+
+ it('maps groupOverlays from layers[compareState].groupOverlays for active', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.groupOverlays).toBe(true);
+ });
+
+ it('maps groupOverlays from layers[compareState].groupOverlays for activeB', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, { compareState: 'activeB' });
+ expect(result.groupOverlays).toBe(false);
+ });
+});
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+ let mappedDispatch;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ mappedDispatch = capturedMapDispatchToProps(dispatch);
+ jest.useFakeTimers();
+ });
+
+ afterEach(() => {
+ jest.useRealTimers();
+ });
+
+ describe('toggleOverlayGroups', () => {
+ it('dispatches toggleOverlayGroupsAction after a setTimeout', () => {
+ mappedDispatch.toggleOverlayGroups();
+ expect(dispatch).not.toHaveBeenCalled();
+ jest.runAllTimers();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_OVERLAY_GROUPS' });
+ expect(toggleOverlayGroupsAction).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe('addLayers', () => {
+ it('dispatches openCustomContent with desktop class when not mobile/tablet', () => {
+ mappedDispatch.addLayers(false);
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'LAYER_PICKER_COMPONENT',
+ expect.objectContaining({
+ modalClassName: 'custom-layer-dialog light',
+ headerText: null,
+ backdrop: true,
+ wrapClassName: '',
+ }),
+ );
+ });
+
+ it('dispatches openCustomContent with mobile class when isMobileOnly', () => {
+ const reactDeviceDetect = require('react-device-detect');
+ reactDeviceDetect.isMobileOnly = true;
+ mappedDispatch.addLayers(false);
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'LAYER_PICKER_COMPONENT',
+ expect.objectContaining({
+ modalClassName: 'custom-layer-dialog-mobile custom-layer-dialog light',
+ }),
+ );
+ });
+
+ it('dispatches openCustomContent with mobile class when isTablet', () => {
+ const reactDeviceDetect = require('react-device-detect');
+ reactDeviceDetect.isTablet = true;
+ mappedDispatch.addLayers(false);
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'LAYER_PICKER_COMPONENT',
+ expect.objectContaining({
+ modalClassName: 'custom-layer-dialog-mobile custom-layer-dialog light',
+ }),
+ );
+ });
+
+ it('dispatches stopAnimationAction when isPlaying is true', () => {
+ mappedDispatch.addLayers(true);
+ expect(stopAnimationAction).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'STOP_ANIMATION' });
+ });
+
+ it('does not dispatch stopAnimationAction when isPlaying is false', () => {
+ mappedDispatch.addLayers(false);
+ expect(stopAnimationAction).not.toHaveBeenCalled();
+ });
+
+ it('always dispatches openCustomContent regardless of isPlaying', () => {
+ mappedDispatch.addLayers(true);
+ expect(openCustomContent).toHaveBeenCalledTimes(1);
+ });
+
+ it('passes a function as CompletelyCustomModal', () => {
+ mappedDispatch.addLayers(false);
+ const callArgs = openCustomContent.mock.calls[0][1];
+ expect(typeof callArgs.CompletelyCustomModal).toBe('function');
+ });
+ });
});
diff --git a/web/js/containers/sidebar/charting.test.js b/web/js/containers/sidebar/charting.test.js
index 82eaa0942..cfdeff9a8 100644
--- a/web/js/containers/sidebar/charting.test.js
+++ b/web/js/containers/sidebar/charting.test.js
@@ -1,3 +1,444 @@
-test('charting container test', () => {
+/* 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' });
+ });
});
diff --git a/web/js/containers/sidebar/compare.test.js b/web/js/containers/sidebar/compare.test.js
index bce53d0d3..25fb86889 100644
--- a/web/js/containers/sidebar/compare.test.js
+++ b/web/js/containers/sidebar/compare.test.js
@@ -1,3 +1,238 @@
-test('compare container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, fireEvent } 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('reactstrap', () => ({
+ Nav: ({ children }) => <nav data-testid="nav">{children}</nav>,
+ NavItem: ({ children }) => <div data-testid="nav-item">{children}</div>,
+ NavLink: ({ children, className, onClick }) => (
+ <a data-testid="nav-link" className={className} onClick={onClick}>{children}</a>
+ ),
+ TabContent: ({ children, activeTab }) => (
+ <div data-testid="tab-content" data-active-tab={activeTab}>{children}</div>
+ ),
+ TabPane: ({ children, tabId }) => (
+ <div data-testid={`tab-pane-${tabId}`}>{children}</div>
+ ),
+}));
+
+jest.mock('./layers-container', () => function MockLayersContainer({ isActive, compareState, height }) {
+ return (
+ <div
+ data-testid={`layers-container-${compareState}`}
+ data-is-active={String(isActive)}
+ data-height={height}
+ />
+ );
+});
+
+jest.mock('../../modules/compare/actions', () => ({
+ toggleActiveCompareState: jest.fn(() => ({ type: 'TOGGLE_ACTIVE_COMPARE_STATE' })),
+}));
+
+jest.mock('../../modules/compare/selectors', () => ({
+ getCompareDates: jest.fn(() => ({ dateA: '2021-01-01', dateB: '2021-06-01' })),
+}));
+
+jest.mock('../../components/util/monospace-date', () => function MockMonospaceDate({ date }) {
+ return <span data-testid="monospace-date">{date}</span>;
+});
+
+import CompareCase from './compare';
+import { toggleActiveCompareState as toggleActiveCompareStateAction } from '../../modules/compare/actions';
+import { getCompareDates } from '../../modules/compare/selectors';
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ getCompareDates.mockReturnValue({ dateA: '2021-01-01', dateB: '2021-06-01' });
+});
+
+const defaultProps = {
+ isActive: true,
+ dateA: '2021-01-01',
+ dateB: '2021-06-01',
+ toggleActiveCompareState: jest.fn(),
+ isCompareA: true,
+ height: 400,
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <CompareCase {...defaultProps} {...propOverrides} />,
+);
+
+// ─── Rendering ────────────────────────────────────────────────────────────────
+
+describe('CompareCase rendering', () => {
+ it('renders without hidden class when isActive is true', () => {
+ const { container } = renderComponent();
+ expect(container.firstChild.className).toBe('');
+ });
+
+ it('renders with hidden class when isActive is false', () => {
+ const { container } = renderComponent({ isActive: false });
+ expect(container.firstChild.className).toContain('hidden');
+ });
+
+ it('renders two NavLinks', () => {
+ const { getAllByTestId } = renderComponent();
+ expect(getAllByTestId('nav-link')).toHaveLength(2);
+ });
+
+ it('renders two MonospaceDate components with correct dates', () => {
+ const { getAllByTestId } = renderComponent();
+ const dates = getAllByTestId('monospace-date');
+ expect(dates[0].textContent).toBe('2021-01-01');
+ expect(dates[1].textContent).toBe('2021-06-01');
+ });
+
+ it('renders two LayersContainers (one per tab pane)', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('layers-container-active')).toBeInTheDocument();
+ expect(getByTestId('layers-container-activeB')).toBeInTheDocument();
+ });
+
+ it('passes height to both LayersContainers', () => {
+ const { getByTestId } = renderComponent({ height: 600 });
+ expect(getByTestId('layers-container-active')).toHaveAttribute('data-height', '600');
+ expect(getByTestId('layers-container-activeB')).toHaveAttribute('data-height', '600');
+ });
+});
+
+// ─── Tab active state ─────────────────────────────────────────────────────────
+
+describe('CompareCase tab active state', () => {
+ it('marks first NavLink active when isCompareA is true', () => {
+ const { getAllByTestId } = renderComponent({ isCompareA: true });
+ const [linkA, linkB] = getAllByTestId('nav-link');
+ expect(linkA.className).toContain('active');
+ expect(linkB.className).not.toContain('active');
+ });
+
+ it('marks second NavLink active when isCompareA is false', () => {
+ const { getAllByTestId } = renderComponent({ isCompareA: false });
+ const [linkA, linkB] = getAllByTestId('nav-link');
+ expect(linkA.className).not.toContain('active');
+ expect(linkB.className).toContain('active');
+ });
+
+ it('sets TabContent activeTab to "1" when isCompareA is true', () => {
+ const { getByTestId } = renderComponent({ isCompareA: true });
+ expect(getByTestId('tab-content')).toHaveAttribute('data-active-tab', '1');
+ });
+
+ it('sets TabContent activeTab to "2" when isCompareA is false', () => {
+ const { getByTestId } = renderComponent({ isCompareA: false });
+ expect(getByTestId('tab-content')).toHaveAttribute('data-active-tab', '2');
+ });
+
+ it('sets LayersContainer active=true for "active" compareState when isCompareA is true', () => {
+ const { getByTestId } = renderComponent({ isCompareA: true });
+ expect(getByTestId('layers-container-active')).toHaveAttribute('data-is-active', 'true');
+ expect(getByTestId('layers-container-activeB')).toHaveAttribute('data-is-active', 'false');
+ });
+
+ it('sets LayersContainer active=true for "activeB" compareState when isCompareA is false', () => {
+ const { getByTestId } = renderComponent({ isCompareA: false });
+ expect(getByTestId('layers-container-active')).toHaveAttribute('data-is-active', 'false');
+ expect(getByTestId('layers-container-activeB')).toHaveAttribute('data-is-active', 'true');
+ });
+
+ it('first NavLink has first-tab class', () => {
+ const { getAllByTestId } = renderComponent();
+ expect(getAllByTestId('nav-link')[0].className).toContain('first-tab');
+ });
+
+ it('second NavLink has second-tab class', () => {
+ const { getAllByTestId } = renderComponent();
+ expect(getAllByTestId('nav-link')[1].className).toContain('second-tab');
+ });
+});
+
+// ─── Interactions ─────────────────────────────────────────────────────────────
+
+describe('CompareCase interactions', () => {
+ it('calls toggleActiveCompareState when first NavLink is clicked', () => {
+ const toggleActiveCompareState = jest.fn();
+ const { getAllByTestId } = renderComponent({ toggleActiveCompareState });
+ fireEvent.click(getAllByTestId('nav-link')[0]);
+ expect(toggleActiveCompareState).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls toggleActiveCompareState when second NavLink is clicked', () => {
+ const toggleActiveCompareState = jest.fn();
+ const { getAllByTestId } = renderComponent({ toggleActiveCompareState });
+ fireEvent.click(getAllByTestId('nav-link')[1]);
+ expect(toggleActiveCompareState).toHaveBeenCalledTimes(1);
+ });
+});
+
+// ─── mapStateToProps ──────────────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ compare: { isCompareA: true, active: true },
+ screenSize: { isMobileDevice: false },
+ ...overrides,
+ });
+
+ it('maps isCompareA from compare.isCompareA', () => {
+ const state = makeState({ compare: { isCompareA: false, active: true } });
+ const result = capturedMapStateToProps(state);
+ expect(result.isCompareA).toBe(false);
+ });
+
+ it('maps isActive from compare.active', () => {
+ const state = makeState({ compare: { isCompareA: true, active: false } });
+ const result = capturedMapStateToProps(state);
+ expect(result.isActive).toBe(false);
+ });
+
+ it('maps isMobile from screenSize.isMobileDevice', () => {
+ const state = makeState({ screenSize: { isMobileDevice: true } });
+ const result = capturedMapStateToProps(state);
+ expect(result.isMobile).toBe(true);
+ });
+
+ it('maps dateA and dateB from getCompareDates', () => {
+ getCompareDates.mockReturnValue({ dateA: '2022-03-01', dateB: '2022-09-15' });
+ const state = makeState();
+ const result = capturedMapStateToProps(state);
+ expect(result.dateA).toBe('2022-03-01');
+ expect(result.dateB).toBe('2022-09-15');
+ expect(getCompareDates).toHaveBeenCalledWith(state);
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ it('toggleActiveCompareState dispatches the correct action', () => {
+ const dispatch = jest.fn();
+ const { toggleActiveCompareState } = capturedMapDispatchToProps(dispatch);
+ toggleActiveCompareState();
+ expect(toggleActiveCompareStateAction).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_ACTIVE_COMPARE_STATE' });
+ });
});
diff --git a/web/js/containers/sidebar/events.test.js b/web/js/containers/sidebar/events.test.js
index f9bd4b06a..f99a434d8 100644
--- a/web/js/containers/sidebar/events.test.js
+++ b/web/js/containers/sidebar/events.test.js
@@ -1,3 +1,670 @@
-test('events container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, fireEvent } 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('react-device-detect', () => ({
+ isMobileOnly: false,
+ isTablet: false,
+}));
+
+jest.mock('reactstrap', () => ({
+ Button: ({
+ children, onClick, id, className, disabled,
+ }) => (
+ <button
+ type="button"
+ data-testid={id || 'reactstrap-button'}
+ className={className}
+ onClick={onClick}
+ disabled={disabled}
+ >
+ {children}
+ </button>
+ ),
+}));
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon }) => <span data-testid={`fa-icon-${icon}`} />,
+}));
+
+jest.mock('../../components/sidebar/event', () => function MockEvent(props) {
+ return (
+ <li
+ data-testid={`event-${props.event.id}`}
+ data-is-selected={String(props.isSelected)}
+ data-is-highlighted={String(props.isHighlighted)}
+ >
+ <button
+ type="button"
+ data-testid={`select-${props.event.id}`}
+ onClick={() => props.selectEvent(props.event.id, props.event.date)}
+ >
+ select
+ </button>
+ <button
+ type="button"
+ data-testid={`deselect-${props.event.id}`}
+ onClick={props.deselectEvent}
+ >
+ deselect
+ </button>
+ <button
+ type="button"
+ data-testid={`highlight-${props.event.id}`}
+ onClick={() => props.highlightEvent(props.event.id, props.event.date)}
+ >
+ highlight
+ </button>
+ <button
+ type="button"
+ data-testid={`unhighlight-${props.event.id}`}
+ onClick={props.unHighlightEvent}
+ >
+ unhighlight
+ </button>
+ </li>
+ );
+});
+
+jest.mock('../../components/sidebar/event-icon', () => function MockEventIcon({ id, category, title }) {
+ return <span data-testid={`event-icon-${category}`} title={title}>{id}</span>;
+});
+
+jest.mock('../../components/sidebar/events-filter', () => function MockEventFilterModalBody() {
+ return <div data-testid="events-filter-modal-body" />;
+});
+
+jest.mock('../../components/util/scrollbar', () => function MockScrollbars({ children, style, className }) {
+ return (
+ <div
+ data-testid="scrollbars"
+ className={className}
+ style={style}
+ >
+ {children}
+ </div>
+ );
+});
+
+jest.mock('../../modules/natural-events/actions', () => ({
+ selectEvent: jest.fn((id, date) => ({ type: 'SELECT_EVENT', id, date })),
+ deselectEvent: jest.fn(() => ({ type: 'DESELECT_EVENT' })),
+ highlightEvent: jest.fn((id, date) => ({ type: 'HIGHLIGHT_EVENT', id, date })),
+ unHighlightEvent: jest.fn(() => ({ type: 'UNHIGHLIGHT_EVENT' })),
+}));
+
+jest.mock('../../modules/sidebar/actions', () => ({
+ collapseSidebar: jest.fn(() => ({ type: 'COLLAPSE_SIDEBAR' })),
+}));
+
+jest.mock('../../modules/date/selectors', () => ({
+ getSelectedDate: jest.fn(() => new Date('2021-06-15')),
+}));
+
+jest.mock('../../modules/modal/actions', () => ({
+ toggleCustomContent: jest.fn((key, opts) => ({ type: 'TOGGLE_CUSTOM_CONTENT', key, opts })),
+}));
+
+jest.mock('../../modules/layers/actions', () => ({
+ addLayer: jest.fn((id) => ({ type: 'ADD_LAYER', id })),
+ removeGroup: jest.fn((ids) => ({ type: 'REMOVE_GROUP', ids })),
+ toggleVisibility: jest.fn((ids, vis) => ({ type: 'TOGGLE_VISIBILITY', ids, vis })),
+ toggleGroupVisibility: jest.fn((ids, vis) => ({ type: 'TOGGLE_GROUP_VISIBILITY', ids, vis })),
+}));
+
+jest.mock('../../util/util', () => ({
+ toISOStringDate: jest.fn(() => '2021-06-15'),
+}));
+
+jest.mock('../../modules/date/util', () => ({
+ formatDisplayDate: jest.fn((d) => d || ''),
+}));
+
+import Events from './events';
+import {
+ selectEvent as selectEventActionCreator,
+ deselectEvent as deselectEventActionCreator,
+ highlightEvent as highlightEventActionCreator,
+ unHighlightEvent as unHighlightEventActionCreator,
+} from '../../modules/natural-events/actions';
+import { collapseSidebar } from '../../modules/sidebar/actions';
+import { toggleCustomContent } from '../../modules/modal/actions';
+import {
+ addLayer as addLayerAction,
+ removeGroup as removeGroupAction,
+ toggleVisibility as toggleVisibilityAction,
+ toggleGroupVisibility as toggleGroupVisibilityAction,
+} from '../../modules/layers/actions';
+import { getSelectedDate } from '../../modules/date/selectors';
+import { formatDisplayDate } from '../../modules/date/util';
+import util from '../../util/util';
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ formatDisplayDate.mockImplementation((d) => d || '');
+ util.toISOStringDate.mockReturnValue('2021-06-15');
+ getSelectedDate.mockReturnValue(new Date('2021-06-15'));
+ const rdd = require('react-device-detect');
+ rdd.isMobileOnly = false;
+ rdd.isTablet = false;
+});
+
+const defaultEvent = { id: 'EVT001', date: '2021-06-10' };
+
+const defaultProps = {
+ defaultEventLayer: 'HLS_Shortwave_Infrared_Combination',
+ deselectEvent: jest.fn(),
+ eventLayers: [],
+ eventsData: [],
+ hasRequestError: false,
+ height: 600,
+ highlighted: { id: null },
+ highlightEvent: jest.fn(),
+ isLoading: false,
+ isMobile: false,
+ isEmbedModeActive: false,
+ layers: [],
+ openFilterModal: jest.fn(),
+ removeGroup: jest.fn(),
+ selectedDate: '2021-06-15',
+ selected: { id: null },
+ selectEvent: jest.fn(),
+ selectedStartDate: '2021-01-01',
+ selectedEndDate: '2021-12-31',
+ selectedCategories: [],
+ showAlert: false,
+ showDates: false,
+ sources: [{ id: 'src1', title: 'Source 1' }],
+ toggleVisibility: jest.fn(),
+ toggleGroupVisibility: jest.fn(),
+ unHighlightEvent: jest.fn(),
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <Events {...defaultProps} {...propOverrides} />,
+);
+
+// ─── Rendering ────────────────────────────────────────────────────────────────
+
+describe('Events rendering', () => {
+ it('renders the event container', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.event-container')).toBeInTheDocument();
+ });
+
+ it('renders the filter controls section', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.filter-controls')).toBeInTheDocument();
+ });
+
+ it('renders the filter button', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('event-filter-button')).toBeInTheDocument();
+ });
+
+ it('renders the scrollbars component', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('scrollbars')).toBeInTheDocument();
+ });
+
+ it('shows "no events" message when eventsData is empty and not loading', () => {
+ const { container } = renderComponent({ eventsData: [], isLoading: false });
+ expect(container.querySelector('.no-events')).toBeInTheDocument();
+ });
+
+ it('does not show "no events" message when loading', () => {
+ const { container } = renderComponent({ eventsData: [], isLoading: true });
+ expect(container.querySelector('.no-events')).not.toBeInTheDocument();
+ });
+
+ it('shows loading text when isLoading is true', () => {
+ const { container } = renderComponent({ isLoading: true });
+ expect(container.querySelector('.events-loading-text')).toBeInTheDocument();
+ expect(container.querySelector('.events-loading-text').textContent).toContain('Loading ...');
+ });
+
+ it('shows error text when hasRequestError is true', () => {
+ const { container } = renderComponent({ hasRequestError: true, isLoading: false });
+ const el = container.querySelector('.events-loading-text');
+ expect(el).toBeInTheDocument();
+ expect(el.textContent).toContain('ERROR');
+ });
+
+ it('shows error icon when hasRequestError is true', () => {
+ const { getByTestId } = renderComponent({ hasRequestError: true, isLoading: false });
+ expect(getByTestId('fa-icon-exclamation-triangle')).toBeInTheDocument();
+ });
+
+ it('does not show error icon when hasRequestError is false', () => {
+ const { queryByTestId } = renderComponent({ isLoading: true, hasRequestError: false });
+ expect(queryByTestId('fa-icon-exclamation-triangle')).not.toBeInTheDocument();
+ });
+
+ it('renders event list when eventsData has items', () => {
+ const { getByTestId } = renderComponent({ eventsData: [defaultEvent] });
+ expect(getByTestId(`event-${defaultEvent.id}`)).toBeInTheDocument();
+ });
+
+ it('renders one Event component per event', () => {
+ const events = [{ id: 'E1', date: 'd1' }, { id: 'E2', date: 'd2' }, { id: 'E3', date: 'd3' }];
+ const { getAllByTestId } = renderComponent({ eventsData: events });
+ // each event renders 4 buttons plus the li
+ expect(getAllByTestId(/^event-E/)).toHaveLength(3);
+ });
+
+ it('marks event as selected when selected.id matches', () => {
+ const { getByTestId } = renderComponent({
+ eventsData: [defaultEvent],
+ selected: { id: defaultEvent.id },
+ });
+ expect(getByTestId(`event-${defaultEvent.id}`)).toHaveAttribute('data-is-selected', 'true');
+ });
+
+ it('marks event as not selected when selected.id does not match', () => {
+ const { getByTestId } = renderComponent({
+ eventsData: [defaultEvent],
+ selected: { id: 'other' },
+ });
+ expect(getByTestId(`event-${defaultEvent.id}`)).toHaveAttribute('data-is-selected', 'false');
+ });
+
+ it('marks event as highlighted when highlighted.id matches', () => {
+ const { getByTestId } = renderComponent({
+ eventsData: [defaultEvent],
+ highlighted: { id: defaultEvent.id },
+ });
+ expect(getByTestId(`event-${defaultEvent.id}`)).toHaveAttribute('data-is-highlighted', 'true');
+ });
+
+ it('shows date range when showDates is true', () => {
+ formatDisplayDate.mockImplementation((d) => d);
+ const { container } = renderComponent({
+ showDates: true,
+ selectedStartDate: '2021-01-01',
+ selectedEndDate: '2021-12-31',
+ });
+ expect(container.querySelector('.filter-dates').textContent).toContain('2021-01-01');
+ expect(container.querySelector('.filter-dates').textContent).toContain('2021-12-31');
+ });
+
+ it('does not show date range when showDates is false', () => {
+ const { container } = renderComponent({ showDates: false });
+ expect(container.querySelector('.filter-dates').textContent).toBe('');
+ });
+
+ it('renders EventIcon for each selected category', () => {
+ const cats = [{ id: 'volcanoes', title: 'Volcanoes' }, { id: 'floods', title: 'Floods' }];
+ const { getByTestId } = renderComponent({ selectedCategories: cats });
+ expect(getByTestId('event-icon-volcanoes')).toBeInTheDocument();
+ expect(getByTestId('event-icon-floods')).toBeInTheDocument();
+ });
+});
+
+// ─── Scrollbar height ─────────────────────────────────────────────────────────
+
+describe('Events scrollbar height', () => {
+ it('uses pixel maxHeight when not in embed mode', () => {
+ const { getByTestId } = renderComponent({ height: 600, isEmbedModeActive: false });
+ const scrollbars = getByTestId('scrollbars');
+ expect(scrollbars.style.maxHeight).toBe('485px');
+ });
+
+ it('uses 50vh maxHeight in embed mode', () => {
+ const { getByTestId } = renderComponent({ isEmbedModeActive: true });
+ const scrollbars = getByTestId('scrollbars');
+ expect(scrollbars.style.maxHeight).toBe('50vh');
+ });
+
+ it('clamps maxHeight to at least 166px for small heights', () => {
+ const { getByTestId } = renderComponent({ height: 100, isEmbedModeActive: false });
+ const scrollbars = getByTestId('scrollbars');
+ expect(scrollbars.style.maxHeight).toBe('166px');
+ });
+});
+
+// ─── Filter button ────────────────────────────────────────────────────────────
+
+describe('Events filter button', () => {
+ it('has filter-button class when not in embed mode', () => {
+ const { getByTestId } = renderComponent({ isEmbedModeActive: false });
+ expect(getByTestId('event-filter-button').className).toBe('filter-button');
+ });
+
+ it('has filter-button-hidden class in embed mode', () => {
+ const { getByTestId } = renderComponent({ isEmbedModeActive: true });
+ expect(getByTestId('event-filter-button').className).toBe('filter-button-hidden');
+ });
+
+ it('is disabled when isLoading is true', () => {
+ const { getByTestId } = renderComponent({ isLoading: true });
+ expect(getByTestId('event-filter-button')).toBeDisabled();
+ });
+
+ it('is enabled when isLoading is false', () => {
+ const { getByTestId } = renderComponent({ isLoading: false });
+ expect(getByTestId('event-filter-button')).not.toBeDisabled();
+ });
+
+ it('calls openFilterModal when filter button is clicked', () => {
+ const openFilterModal = jest.fn();
+ const { getByTestId } = renderComponent({ openFilterModal });
+ fireEvent.click(getByTestId('event-filter-button'));
+ expect(openFilterModal).toHaveBeenCalledTimes(1);
+ });
+});
+
+// ─── Event interactions ───────────────────────────────────────────────────────
+
+describe('Events event interactions', () => {
+ it('calls selectEvent with event id and date when event is selected', () => {
+ const selectEvent = jest.fn();
+ const { getByTestId } = renderComponent({
+ eventsData: [defaultEvent],
+ selectEvent,
+ });
+ fireEvent.click(getByTestId(`select-${defaultEvent.id}`));
+ expect(selectEvent).toHaveBeenCalledWith(defaultEvent.id, defaultEvent.date, false);
+ });
+
+ it('passes isMobile to selectEvent', () => {
+ const selectEvent = jest.fn();
+ const { getByTestId } = renderComponent({
+ eventsData: [defaultEvent],
+ selectEvent,
+ isMobile: true,
+ });
+ fireEvent.click(getByTestId(`select-${defaultEvent.id}`));
+ expect(selectEvent).toHaveBeenCalledWith(defaultEvent.id, defaultEvent.date, true);
+ });
+
+ it('calls deselectEvent when deselect is triggered', () => {
+ const deselectEvent = jest.fn();
+ const { getByTestId } = renderComponent({
+ eventsData: [defaultEvent],
+ deselectEvent,
+ });
+ fireEvent.click(getByTestId(`deselect-${defaultEvent.id}`));
+ expect(deselectEvent).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls highlightEvent with id and date', () => {
+ const highlightEvent = jest.fn();
+ const { getByTestId } = renderComponent({
+ eventsData: [defaultEvent],
+ highlightEvent,
+ });
+ fireEvent.click(getByTestId(`highlight-${defaultEvent.id}`));
+ expect(highlightEvent).toHaveBeenCalledWith(defaultEvent.id, defaultEvent.date);
+ });
+
+ it('calls unHighlightEvent when triggered', () => {
+ const unHighlightEvent = jest.fn();
+ const { getByTestId } = renderComponent({
+ eventsData: [defaultEvent],
+ unHighlightEvent,
+ });
+ fireEvent.click(getByTestId(`unhighlight-${defaultEvent.id}`));
+ expect(unHighlightEvent).toHaveBeenCalledTimes(1);
+ });
+});
+
+// ─── mapStateToProps ──────────────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ animation: { isPlaying: false },
+ config: { naturalEvents: { defaultLayer: 'default-layer' } },
+ embed: { isEmbedModeActive: false },
+ events: {
+ selected: { id: 'EVT1' },
+ highlighted: { id: null },
+ showAll: true,
+ selectedDates: { start: '2021-01-01', end: '2021-12-31' },
+ selectedCategories: [{ id: 'volcanoes', title: 'Volcanoes' }],
+ isAnimatingToEvent: false,
+ },
+ screenSize: { isMobileDevice: false },
+ layers: {
+ eventLayers: ['layer1'],
+ active: { layers: [{ id: 'active-layer' }] },
+ },
+ ...overrides,
+ });
+
+ it('maps defaultEventLayer from config', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.defaultEventLayer).toBe('default-layer');
+ });
+
+ it('maps eventLayers from layers.eventLayers', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.eventLayers).toEqual(['layer1']);
+ });
+
+ it('maps isPlaying from animation.isPlaying', () => {
+ const state = makeState({ animation: { isPlaying: true } });
+ expect(capturedMapStateToProps(state).isPlaying).toBe(true);
+ });
+
+ it('maps isMobile from screenSize.isMobileDevice', () => {
+ const state = makeState({ screenSize: { isMobileDevice: true } });
+ expect(capturedMapStateToProps(state).isMobile).toBe(true);
+ });
+
+ it('maps isEmbedModeActive from embed state', () => {
+ const state = makeState({ embed: { isEmbedModeActive: true } });
+ expect(capturedMapStateToProps(state).isEmbedModeActive).toBe(true);
+ });
+
+ it('maps layers from layers.active.layers', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.layers).toEqual([{ id: 'active-layer' }]);
+ });
+
+ it('maps showAll from events.showAll', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.showAll).toBe(true);
+ });
+
+ it('maps selected from events.selected', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.selected).toEqual({ id: 'EVT1' });
+ });
+
+ it('maps highlighted from events.highlighted', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.highlighted).toEqual({ id: null });
+ });
+
+ it('maps selectedCategories from events.selectedCategories', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.selectedCategories).toEqual([{ id: 'volcanoes', title: 'Volcanoes' }]);
+ });
+
+ it('maps selectedStartDate from selectedDates.start', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.selectedStartDate).toBe('2021-01-01');
+ });
+
+ it('maps selectedEndDate from selectedDates.end', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.selectedEndDate).toBe('2021-12-31');
+ });
+
+ it('sets showDates to true when both start and end are set', () => {
+ const result = capturedMapStateToProps(makeState());
+ expect(result.showDates).toBe(true);
+ });
+
+ it('sets showDates to false when start is missing', () => {
+ const state = makeState();
+ state.events.selectedDates = { start: null, end: '2021-12-31' };
+ expect(capturedMapStateToProps(state).showDates).toBe(false);
+ });
+
+ it('sets showDates to false when end is missing', () => {
+ const state = makeState();
+ state.events.selectedDates = { start: '2021-01-01', end: null };
+ expect(capturedMapStateToProps(state).showDates).toBe(false);
+ });
+
+ it('maps selectedDate via util.toISOStringDate and getSelectedDate', () => {
+ util.toISOStringDate.mockReturnValue('2021-06-15');
+ const state = makeState();
+ const result = capturedMapStateToProps(state);
+ expect(result.selectedDate).toBe('2021-06-15');
+ expect(getSelectedDate).toHaveBeenCalledWith(state);
+ });
+
+ it('maps isAnimatingToEvent from events.isAnimatingToEvent', () => {
+ const state = makeState();
+ state.events.isAnimatingToEvent = true;
+ expect(capturedMapStateToProps(state).isAnimatingToEvent).toBe(true);
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+ let mapped;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ mapped = capturedMapDispatchToProps(dispatch);
+ });
+
+ describe('selectEvent', () => {
+ it('dispatches selectEventActionCreator with id and date', () => {
+ mapped.selectEvent('EVT1', '2021-06-10', false);
+ expect(selectEventActionCreator).toHaveBeenCalledWith('EVT1', '2021-06-10');
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'SELECT_EVENT' }));
+ });
+
+ it('dispatches collapseSidebar when shouldCollapse is true', () => {
+ mapped.selectEvent('EVT1', '2021-06-10', true);
+ expect(collapseSidebar).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'COLLAPSE_SIDEBAR' }));
+ });
+
+ it('does not dispatch collapseSidebar when shouldCollapse is false', () => {
+ mapped.selectEvent('EVT1', '2021-06-10', false);
+ expect(collapseSidebar).not.toHaveBeenCalled();
+ });
+ });
+
+ it('deselectEvent dispatches deselectEventActionCreator', () => {
+ mapped.deselectEvent();
+ expect(deselectEventActionCreator).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'DESELECT_EVENT' });
+ });
+
+ it('highlightEvent dispatches highlightEventActionCreator with id and date', () => {
+ mapped.highlightEvent('EVT1', '2021-06-10');
+ expect(highlightEventActionCreator).toHaveBeenCalledWith('EVT1', '2021-06-10');
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'HIGHLIGHT_EVENT' }));
+ });
+
+ it('unHighlightEvent dispatches unHighlightEventActionCreator', () => {
+ mapped.unHighlightEvent();
+ expect(unHighlightEventActionCreator).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'UNHIGHLIGHT_EVENT' });
+ });
+
+ describe('openFilterModal', () => {
+ it('dispatches toggleCustomContent with events-filter key', () => {
+ mapped.openFilterModal();
+ expect(toggleCustomContent).toHaveBeenCalledWith(
+ 'events-filter',
+ expect.objectContaining({ headerText: 'Filter Events' }),
+ );
+ });
+
+ it('uses desktop modal class when not mobile/tablet', () => {
+ mapped.openFilterModal();
+ const opts = toggleCustomContent.mock.calls[0][1];
+ expect(opts.modalClassName).toBe('sidebar-modal event-filter-modal');
+ });
+
+ it('uses mobile modal class when isMobileOnly is true', () => {
+ const rdd = require('react-device-detect');
+ rdd.isMobileOnly = true;
+ mapped.openFilterModal();
+ const opts = toggleCustomContent.mock.calls[0][1];
+ expect(opts.modalClassName).toBe(
+ 'sidebar-modal-mobile event-filter-modal-mobile',
+ );
+ });
+
+ it('uses mobile modal class when isTablet is true', () => {
+ const rdd = require('react-device-detect');
+ rdd.isTablet = true;
+ mapped.openFilterModal();
+ const opts = toggleCustomContent.mock.calls[0][1];
+ expect(opts.modalClassName).toBe(
+ 'sidebar-modal-mobile event-filter-modal-mobile',
+ );
+ });
+
+ it('sets footer to true and backdrop to false', () => {
+ mapped.openFilterModal();
+ const opts = toggleCustomContent.mock.calls[0][1];
+ expect(opts.footer).toBe(true);
+ expect(opts.backdrop).toBe(false);
+ });
+
+ it('sets timeout to 150', () => {
+ mapped.openFilterModal();
+ const opts = toggleCustomContent.mock.calls[0][1];
+ expect(opts.timeout).toBe(150);
+ });
+ });
+
+ it('addLayer dispatches addLayerAction with id', () => {
+ mapped.addLayer('MODIS_Terra_CorrectedReflectance');
+ expect(addLayerAction).toHaveBeenCalledWith('MODIS_Terra_CorrectedReflectance');
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'ADD_LAYER' }));
+ });
+
+ it('toggleVisibility dispatches toggleVisibilityAction with ids and visible', () => {
+ mapped.toggleVisibility(['layer1', 'layer2'], true);
+ expect(toggleVisibilityAction).toHaveBeenCalledWith(['layer1', 'layer2'], true);
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'TOGGLE_VISIBILITY' }));
+ });
+
+ it('removeGroup dispatches removeGroupAction with ids', () => {
+ mapped.removeGroup(['group1']);
+ expect(removeGroupAction).toHaveBeenCalledWith(['group1']);
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'REMOVE_GROUP' }));
+ });
+
+ it('toggleGroupVisibility dispatches toggleGroupVisibilityAction', () => {
+ mapped.toggleGroupVisibility(['layer1'], false);
+ expect(toggleGroupVisibilityAction).toHaveBeenCalledWith(['layer1'], false);
+ expect(dispatch).toHaveBeenCalledWith(
+ expect.objectContaining({ type: 'TOGGLE_GROUP_VISIBILITY' }),
+ );
+ });
});
diff --git a/web/js/containers/sidebar/footer-content.test.js b/web/js/containers/sidebar/footer-content.test.js
index 9533a02ed..1d5ade196 100644
--- a/web/js/containers/sidebar/footer-content.test.js
+++ b/web/js/containers/sidebar/footer-content.test.js
@@ -1,3 +1,647 @@
-test('footer-content container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import React from 'react';
+import { render, fireEvent } 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('react-device-detect', () => ({
+ isMobileOnly: false,
+ isTablet: false,
+}));
+
+jest.mock('reactstrap', () => ({
+ UncontrolledTooltip: ({ children, id, target, placement }) => (
+ <div
+ data-testid={`tooltip-${target || id}`}
+ data-placement={placement}
+ >
+ {children}
+ </div>
+ ),
+}));
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, id }) => <span data-testid={`fa-${id || icon}`} />,
+}));
+
+jest.mock('../../components/charting/charting-info', () => function MockChartingInfo() {
+ return <div data-testid="charting-info" />;
+});
+
+jest.mock('../../components/util/button', () => function MockButton({
+ id, onClick, className, text, style,
+}) {
+ return (
+ <button
+ type="button"
+ data-testid={id}
+ className={className}
+ style={style}
+ onClick={onClick}
+ >
+ {text}
+ </button>
+ );
+});
+
+jest.mock('../../components/sidebar/compare-mode-options', () => function MockCompareModeOptions({
+ isActive, isMobile, selected, onclick,
+}) {
+ return (
+ <div
+ data-testid="compare-mode-options"
+ data-is-active={String(isActive)}
+ data-is-mobile={String(isMobile)}
+ data-selected={selected}
+ >
+ <button type="button" data-testid="compare-mode-change" onClick={() => onclick('spy')} />
+ </div>
+ );
+});
+
+jest.mock('../../components/sidebar/charting-mode-options', () => function MockChartingModeOptions({
+ isChartingActive, isMobile, sidebarHeight,
+}) {
+ return (
+ <div
+ data-testid="charting-mode-options"
+ data-is-active={String(isChartingActive)}
+ data-sidebar-height={sidebarHeight}
+ />
+ );
+});
+
+jest.mock('../../components/layer/product-picker/search-ui-provider', () => function MockSearchUiProvider() {
+ return <div data-testid="search-ui-provider" />;
+});
+
+jest.mock('../../modules/compare/actions', () => ({
+ toggleCompareOnOff: jest.fn(() => ({ type: 'TOGGLE_COMPARE' })),
+ changeMode: jest.fn((str) => ({ type: 'CHANGE_MODE', str })),
+}));
+
+jest.mock('../../modules/charting/actions', () => ({
+ toggleChartingModeOnOff: jest.fn(() => ({ type: 'TOGGLE_CHARTING' })),
+}));
+
+jest.mock('../../modules/modal/actions', () => ({
+ openCustomContent: jest.fn((key, opts) => ({ type: 'OPEN_CUSTOM_CONTENT', key, opts })),
+ onClose: jest.fn(() => ({ type: 'CLOSE_MODAL' })),
+}));
+
+jest.mock('../../modules/natural-events/selectors', () => ({
+ getFilteredEvents: jest.fn(() => []),
+}));
+
+jest.mock('../../modules/natural-events/constants', () => ({
+ LIMIT_EVENT_REQUEST_COUNT: 50,
+}));
+
+jest.mock('../../modules/layers/actions', () => ({
+ toggleOverlayGroups: jest.fn(() => ({ type: 'TOGGLE_OVERLAY_GROUPS' })),
+}));
+
+jest.mock('../../modules/animation/actions', () => ({
+ stop: jest.fn(() => ({ type: 'STOP_ANIMATION' })),
+}));
+
+import FooterContent from './footer-content';
+import {
+ toggleCompareOnOff,
+ changeMode,
+} from '../../modules/compare/actions';
+import { toggleChartingModeOnOff } from '../../modules/charting/actions';
+import {
+ openCustomContent,
+ onClose as closeModal,
+} from '../../modules/modal/actions';
+import { getFilteredEvents } from '../../modules/natural-events/selectors';
+import { stop as stopAnimationAction } from '../../modules/animation/actions';
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ getFilteredEvents.mockReturnValue([]);
+ const rdd = require('react-device-detect');
+ rdd.isMobileOnly = false;
+ rdd.isTablet = false;
+});
+
+const defaultProps = {
+ activeTab: 'layers',
+ changeCompareMode: jest.fn(),
+ chartFeature: true,
+ chartingModeAccessible: true,
+ compareFeature: true,
+ compareMode: 'swipe',
+ eventsData: [],
+ isChartingActive: false,
+ isCompareActive: false,
+ isMobile: false,
+ closeModalAction: jest.fn(),
+ openChartingInfoModal: jest.fn(),
+ toggleCompare: jest.fn(),
+ toggleCharting: jest.fn(),
+ sidebarHeight: 500,
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <FooterContent {...defaultProps} {...propOverrides} />,
+);
+
+// ─── Rendering ────────────────────────────────────────────────────────────────
+
+describe('FooterContent rendering', () => {
+ it('renders a footer element', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('footer')).toBeInTheDocument();
+ });
+
+ it('renders layers footer when activeTab is "layers"', () => {
+ const { getByTestId } = renderComponent({ activeTab: 'layers' });
+ expect(getByTestId('compare-mode-options')).toBeInTheDocument();
+ });
+
+ it('renders events footer when activeTab is "events"', () => {
+ const { container } = renderComponent({
+ activeTab: 'events',
+ eventsData: [{ id: 'e1' }],
+ });
+ expect(container.querySelector('.event-count')).toBeInTheDocument();
+ });
+
+ it('renders nothing inside footer when activeTab is neither layers nor events', () => {
+ const { container } = renderComponent({ activeTab: 'other' });
+ expect(container.querySelector('footer').textContent).toBe('');
+ });
+
+ it('renders with a forwarded ref', () => {
+ const ref = React.createRef();
+ render(<FooterContent {...defaultProps} ref={ref} />);
+ expect(ref.current).toBeInstanceOf(HTMLElement);
+ expect(ref.current.tagName).toBe('FOOTER');
+ });
+});
+
+// ─── Layers footer ────────────────────────────────────────────────────────────
+
+describe('FooterContent layers footer', () => {
+ it('renders CompareModeOptions with correct props', () => {
+ const { getByTestId } = renderComponent({ isCompareActive: true, compareMode: 'swipe' });
+ const opts = getByTestId('compare-mode-options');
+ expect(opts).toHaveAttribute('data-is-active', 'true');
+ expect(opts).toHaveAttribute('data-selected', 'swipe');
+ });
+
+ it('passes isMobile to CompareModeOptions', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(getByTestId('compare-mode-options')).toHaveAttribute('data-is-mobile', 'true');
+ });
+
+ it('calls changeCompareMode when CompareModeOptions triggers change', () => {
+ const changeCompareMode = jest.fn();
+ const { getByTestId } = renderComponent({ changeCompareMode });
+ fireEvent.click(getByTestId('compare-mode-change'));
+ expect(changeCompareMode).toHaveBeenCalledWith('spy');
+ });
+
+ it('renders ChartingModeOptions when isChartingActive is true', () => {
+ const { getByTestId } = renderComponent({ isChartingActive: true });
+ expect(getByTestId('charting-mode-options')).toBeInTheDocument();
+ });
+
+ it('does not render ChartingModeOptions when isChartingActive is false', () => {
+ const { queryByTestId } = renderComponent({ isChartingActive: false });
+ expect(queryByTestId('charting-mode-options')).not.toBeInTheDocument();
+ });
+
+ it('passes sidebarHeight to ChartingModeOptions', () => {
+ const { getByTestId } = renderComponent({ isChartingActive: true, sidebarHeight: 750 });
+ expect(getByTestId('charting-mode-options')).toHaveAttribute('data-sidebar-height', '750');
+ });
+});
+
+// ─── Chart toggle button ──────────────────────────────────────────────────────
+
+describe('FooterContent chart toggle button', () => {
+ it('renders chart button when not mobile, not compare active, and chartFeature is true', () => {
+ const { getByTestId } = renderComponent({
+ isMobile: false, isCompareActive: false, chartFeature: true,
+ });
+ expect(getByTestId('chart-toggle-button')).toBeInTheDocument();
+ });
+
+ it('does not render chart button when isMobile is true', () => {
+ const { queryByTestId } = renderComponent({ isMobile: true });
+ expect(queryByTestId('chart-toggle-button')).not.toBeInTheDocument();
+ });
+
+ it('does not render chart button when isCompareActive is true', () => {
+ const { queryByTestId } = renderComponent({ isCompareActive: true });
+ expect(queryByTestId('chart-toggle-button')).not.toBeInTheDocument();
+ });
+
+ it('does not render chart button when chartFeature is false', () => {
+ const { queryByTestId } = renderComponent({ chartFeature: false });
+ expect(queryByTestId('chart-toggle-button')).not.toBeInTheDocument();
+ });
+
+ it('shows "Start Charting" text when isChartingActive is false', () => {
+ const { getByTestId } = renderComponent({ isChartingActive: false });
+ expect(getByTestId('chart-toggle-button').textContent).toBe('Start Charting');
+ });
+
+ it('shows "Exit Charting" text when isChartingActive is true', () => {
+ // chart button only shows when !isChartingActive, so test via button text
+ // when isChartingActive flips to true the button disappears — test text via charting=false
+ const { getByTestId } = renderComponent({ isChartingActive: false });
+ expect(getByTestId('chart-toggle-button').textContent).toContain('Start Charting');
+ });
+
+ it('has accessible class when chartingModeAccessible is true', () => {
+ const { getByTestId } = renderComponent({ chartingModeAccessible: true });
+ expect(getByTestId('chart-toggle-button').className).not.toContain('disabled');
+ });
+
+ it('has disabled class when chartingModeAccessible is false', () => {
+ const { getByTestId } = renderComponent({ chartingModeAccessible: false });
+ expect(getByTestId('chart-toggle-button').className).toContain('disabled');
+ });
+
+ it('renders tooltip when chartingModeAccessible is false', () => {
+ const { getByTestId } = renderComponent({ chartingModeAccessible: false });
+ expect(getByTestId('tooltip-chart-toggle-button')).toBeInTheDocument();
+ });
+
+ it('does not render tooltip when chartingModeAccessible is true', () => {
+ const { queryByTestId } = renderComponent({ chartingModeAccessible: true });
+ expect(queryByTestId('tooltip-chart-toggle-button')).not.toBeInTheDocument();
+ });
+});
+
+// ─── Compare toggle button ────────────────────────────────────────────────────
+
+describe('FooterContent compare toggle button', () => {
+ it('renders compare button when isChartingActive is false', () => {
+ const { getByTestId } = renderComponent({ isChartingActive: false });
+ expect(getByTestId('compare-toggle-button')).toBeInTheDocument();
+ });
+
+ it('does not render compare button when isChartingActive is true', () => {
+ const { queryByTestId } = renderComponent({ isChartingActive: true });
+ expect(queryByTestId('compare-toggle-button')).not.toBeInTheDocument();
+ });
+
+ it('shows "Start Comparison" on desktop when not comparing', () => {
+ const { getByTestId } = renderComponent({ isCompareActive: false, isMobile: false });
+ expect(getByTestId('compare-toggle-button').textContent).toBe('Start Comparison');
+ });
+
+ it('shows "Exit Comparison" on desktop when comparing', () => {
+ const { getByTestId } = renderComponent({ isCompareActive: true, isMobile: false });
+ expect(getByTestId('compare-toggle-button').textContent).toBe('Exit Comparison');
+ });
+
+ it('shows "Start Comparison Mode" on mobile when not comparing', () => {
+ const { getByTestId } = renderComponent({ isCompareActive: false, isMobile: true });
+ expect(getByTestId('compare-toggle-button').textContent).toBe('Start Comparison Mode');
+ });
+
+ it('shows "Exit Comparison Mode" on mobile when comparing', () => {
+ const { getByTestId } = renderComponent({ isCompareActive: true, isMobile: true });
+ expect(getByTestId('compare-toggle-button').textContent).toBe('Exit Comparison Mode');
+ });
+});
+
+// ─── onClickToggleCompare ─────────────────────────────────────────────────────
+
+describe('FooterContent onClickToggleCompare', () => {
+ it('calls toggleCompare when compare button is clicked', () => {
+ const toggleCompare = jest.fn();
+ const { getByTestId } = renderComponent({ toggleCompare });
+ fireEvent.click(getByTestId('compare-toggle-button'));
+ expect(toggleCompare).toHaveBeenCalledTimes(1);
+ });
+
+ it('pushes comparison_mode event to GTM when compare button is clicked', () => {
+ window.dataLayer = [];
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('compare-toggle-button'));
+ expect(window.dataLayer).toEqual(
+ expect.arrayContaining([expect.objectContaining({ event: 'comparison_mode' })]),
+ );
+ });
+});
+
+// ─── onClickToggleCharting ────────────────────────────────────────────────────
+
+describe('FooterContent onClickToggleCharting', () => {
+ it('calls toggleCharting when chart button is clicked', () => {
+ const toggleCharting = jest.fn();
+ const { getByTestId } = renderComponent({ toggleCharting, isChartingActive: false });
+ fireEvent.click(getByTestId('chart-toggle-button'));
+ expect(toggleCharting).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls openChartingInfoModal when activating charting (isChartingActive is false)', () => {
+ const openChartingInfoModal = jest.fn();
+ const closeModalAction = jest.fn();
+ const { getByTestId } = renderComponent({
+ isChartingActive: false,
+ openChartingInfoModal,
+ closeModalAction,
+ });
+ fireEvent.click(getByTestId('chart-toggle-button'));
+ expect(openChartingInfoModal).toHaveBeenCalledTimes(1);
+ expect(closeModalAction).not.toHaveBeenCalled();
+ });
+
+ it('calls closeModalAction when deactivating charting (isChartingActive is true)', () => {
+ const openChartingInfoModal = jest.fn();
+ const closeModalAction = jest.fn();
+ // chart button is shown when !isMobile && !isCompareActive && chartFeature
+ // regardless of isChartingActive — clicking it when active hits the else branch
+ const { getByTestId } = renderComponent({
+ isChartingActive: true,
+ chartingModeAccessible: true,
+ openChartingInfoModal,
+ closeModalAction,
+ });
+ fireEvent.click(getByTestId('chart-toggle-button'));
+ expect(closeModalAction).toHaveBeenCalledTimes(1);
+ expect(openChartingInfoModal).not.toHaveBeenCalled();
+ });
+
+ it('pushes charting_mode event to GTM when chart button is clicked', () => {
+ window.dataLayer = [];
+ const { getByTestId } = renderComponent({ isChartingActive: false });
+ fireEvent.click(getByTestId('chart-toggle-button'));
+ expect(window.dataLayer).toEqual(
+ expect.arrayContaining([expect.objectContaining({ event: 'charting_mode' })]),
+ );
+ });
+});
+
+// ─── Events footer ────────────────────────────────────────────────────────────
+
+describe('FooterContent events footer', () => {
+ it('shows event count when events are below the limit', () => {
+ const events = Array.from({ length: 10 }, (_, i) => ({ id: `e${i}` }));
+ const { container } = renderComponent({ activeTab: 'events', eventsData: events });
+ expect(container.querySelector('.event-count').textContent).toContain('Showing 10 events');
+ });
+
+ it('shows "first N events" message and info icon when at the limit (50)', () => {
+ const events = Array.from({ length: 50 }, (_, i) => ({ id: `e${i}` }));
+ const { container, getByTestId } = renderComponent({
+ activeTab: 'events', eventsData: events,
+ });
+ expect(container.querySelector('.event-count').textContent).toContain('Showing the first 50 events');
+ expect(getByTestId('fa-filter-info-icon')).toBeInTheDocument();
+ });
+
+ it('renders tooltip on info icon when at the limit', () => {
+ const events = Array.from({ length: 50 }, (_, i) => ({ id: `e${i}` }));
+ const { getByTestId } = renderComponent({ activeTab: 'events', eventsData: events });
+ expect(getByTestId('tooltip-filter-info-icon')).toBeInTheDocument();
+ });
+
+ it('shows zero events when eventsData is empty', () => {
+ const { container } = renderComponent({ activeTab: 'events', eventsData: [] });
+ expect(container.querySelector('.event-count').textContent).toContain('Showing 0 events');
+ });
+
+ it('shows zero events when eventsData is null', () => {
+ const { container } = renderComponent({ activeTab: 'events', eventsData: null });
+ expect(container.querySelector('.event-count').textContent).toContain('Showing 0 events');
+ });
+});
+
+// ─── mapStateToProps ──────────────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ animation: { isPlaying: false },
+ config: { features: { charting: true, compare: true } },
+ compare: { mode: 'swipe', active: false },
+ charting: { active: false },
+ screenSize: { isMobileDevice: false, breakpoints: {}, screenWidth: 1024 },
+ ...overrides,
+ });
+
+ it('maps chartFeature from config.features.charting', () => {
+ const state = makeState({ config: { features: { charting: false, compare: true } } });
+ expect(capturedMapStateToProps(state, {}).chartFeature).toBe(false);
+ });
+
+ it('maps compareFeature from config.features.compare', () => {
+ const state = makeState({ config: { features: { charting: true, compare: false } } });
+ expect(capturedMapStateToProps(state, {}).compareFeature).toBe(false);
+ });
+
+ it('maps compareMode from compare.mode', () => {
+ const state = makeState({ compare: { mode: 'opacity', active: false } });
+ expect(capturedMapStateToProps(state, {}).compareMode).toBe('opacity');
+ });
+
+ it('maps isCompareActive from compare.active', () => {
+ const state = makeState({ compare: { mode: 'swipe', active: true } });
+ expect(capturedMapStateToProps(state, {}).isCompareActive).toBe(true);
+ });
+
+ it('maps isChartingActive from charting.active', () => {
+ const state = makeState({ charting: { active: true } });
+ expect(capturedMapStateToProps(state, {}).isChartingActive).toBe(true);
+ });
+
+ it('maps isMobile from screenSize.isMobileDevice', () => {
+ const state = makeState({
+ screenSize: {
+ isMobileDevice: true,
+ breakpoints: {},
+ screenWidth: 375,
+ },
+ });
+ expect(capturedMapStateToProps(state, {}).isMobile).toBe(true);
+ });
+
+ it('maps isPlaying from animation.isPlaying', () => {
+ const state = makeState({ animation: { isPlaying: true } });
+ expect(capturedMapStateToProps(state, {}).isPlaying).toBe(true);
+ });
+
+ it('maps breakpoints from screenSize.breakpoints', () => {
+ const bp = { sm: 576 };
+ const state = makeState({
+ screenSize: {
+ isMobileDevice: false,
+ breakpoints: bp,
+ screenWidth: 1024,
+ },
+ });
+ expect(capturedMapStateToProps(state, {}).breakpoints).toBe(bp);
+ });
+
+ it('maps screenWidth from screenSize.screenWidth', () => {
+ const state = makeState({
+ screenSize: {
+ isMobileDevice: false,
+ breakpoints: {},
+ screenWidth: 1920,
+ },
+ });
+ expect(capturedMapStateToProps(state, {}).screenWidth).toBe(1920);
+ });
+
+ it('maps eventsData from getFilteredEvents', () => {
+ const events = [{ id: 'e1' }];
+ getFilteredEvents.mockReturnValue(events);
+ const state = makeState();
+ expect(capturedMapStateToProps(state, {}).eventsData).toBe(events);
+ expect(getFilteredEvents).toHaveBeenCalledWith(state);
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+ let mapped;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ mapped = capturedMapDispatchToProps(dispatch);
+ });
+
+ it('toggleCompare dispatches toggleCompareOnOff', () => {
+ mapped.toggleCompare();
+ expect(toggleCompareOnOff).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_COMPARE' });
+ });
+
+ it('changeCompareMode dispatches changeMode with the string', () => {
+ mapped.changeCompareMode('opacity');
+ expect(changeMode).toHaveBeenCalledWith('opacity');
+ expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_MODE', str: 'opacity' });
+ });
+
+ it('toggleCharting dispatches toggleChartingModeOnOff', () => {
+ mapped.toggleCharting();
+ expect(toggleChartingModeOnOff).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_CHARTING' });
+ });
+
+ it('toggleOverlayGroups dispatches toggleOverlayGroupsAction after setTimeout', () => {
+ jest.useFakeTimers();
+ mapped.toggleOverlayGroups();
+ expect(dispatch).not.toHaveBeenCalled();
+ jest.runAllTimers();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_OVERLAY_GROUPS' });
+ jest.useRealTimers();
+ });
+
+ it('closeModalAction dispatches closeModal', () => {
+ mapped.closeModalAction();
+ expect(closeModal).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'CLOSE_MODAL' });
+ });
+
+ describe('openChartingInfoModal', () => {
+ it('dispatches openCustomContent with CHARTING_INFO_MODAL key', () => {
+ mapped.openChartingInfoModal();
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'CHARTING_INFO_MODAL',
+ expect.objectContaining({ headerText: 'Charting Tool - BETA' }),
+ );
+ });
+
+ it('sets backdrop to false', () => {
+ mapped.openChartingInfoModal();
+ expect(openCustomContent.mock.calls[0][1].backdrop).toBe(false);
+ });
+
+ it('sets wrapClassName to clickable-behind-modal', () => {
+ mapped.openChartingInfoModal();
+ expect(openCustomContent.mock.calls[0][1].wrapClassName).toBe('clickable-behind-modal');
+ });
+ });
+
+ describe('openChartingDateModal', () => {
+ it('dispatches openCustomContent with CHARTING_DATE_MODAL key', () => {
+ mapped.openChartingDateModal();
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'CHARTING_DATE_MODAL',
+ expect.objectContaining({ headerText: 'Charting Mode Date Selection' }),
+ );
+ });
+ });
+
+ describe('addLayers', () => {
+ it('dispatches openCustomContent with LAYER_PICKER_COMPONENT', () => {
+ mapped.addLayers(false);
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'LAYER_PICKER_COMPONENT',
+ expect.objectContaining({ backdrop: true, headerText: null }),
+ );
+ });
+
+ it('dispatches stopAnimationAction when isPlaying is true', () => {
+ mapped.addLayers(true);
+ expect(stopAnimationAction).toHaveBeenCalledTimes(1);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'STOP_ANIMATION' });
+ });
+
+ it('does not dispatch stopAnimationAction when isPlaying is false', () => {
+ mapped.addLayers(false);
+ expect(stopAnimationAction).not.toHaveBeenCalled();
+ });
+
+ it('uses desktop modal class when not mobile/tablet', () => {
+ mapped.addLayers(false);
+ const opts = openCustomContent.mock.calls[0][1];
+ expect(opts.modalClassName).toBe('custom-layer-dialog light');
+ });
+
+ it('uses mobile modal class when isMobileOnly is true', () => {
+ const rdd = require('react-device-detect');
+ rdd.isMobileOnly = true;
+ mapped.addLayers(false);
+ const opts = openCustomContent.mock.calls[0][1];
+ expect(opts.modalClassName).toBe('custom-layer-dialog-mobile custom-layer-dialog light');
+ });
+
+ it('uses mobile modal class when isTablet is true', () => {
+ const rdd = require('react-device-detect');
+ rdd.isTablet = true;
+ mapped.addLayers(false);
+ const opts = openCustomContent.mock.calls[0][1];
+ expect(opts.modalClassName).toBe('custom-layer-dialog-mobile custom-layer-dialog light');
+ });
+
+ it('passes a function as CompletelyCustomModal', () => {
+ mapped.addLayers(false);
+ const opts = openCustomContent.mock.calls[0][1];
+ expect(typeof opts.CompletelyCustomModal).toBe('function');
+ });
+ });
});
diff --git a/web/js/containers/sidebar/layer-list.test.js b/web/js/containers/sidebar/layer-list.test.js
index ce68d2bc9..62f222cb7 100644
--- a/web/js/containers/sidebar/layer-list.test.js
+++ b/web/js/containers/sidebar/layer-list.test.js
@@ -1,3 +1,742 @@
-test('layer-list container test', () => {
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('@dnd-kit/core', () => {
+ const React = require('react');
+ return {
+ DndContext: ({ children, onDragEnd }) => {
+ global.__capturedOnDragEnd = onDragEnd;
+ return React.createElement('div', { 'data-testid': 'dnd-context' }, children);
+ },
+ closestCenter: {},
+ };
+});
+
+jest.mock('@dnd-kit/sortable', () => {
+ const React = require('react');
+ return {
+ SortableContext: ({ children }) => React.createElement(
+ 'div',
+ { 'data-testid': 'sortable-context' },
+ children,
+ ),
+ verticalListSortingStrategy: {},
+ arrayMove: jest.fn((arr, from, to) => {
+ const result = [...arr];
+ const [item] = result.splice(from, 1);
+ result.splice(to, 0, item);
+ return result;
+ }),
+ };
+});
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({
+ icon, className, onClick, onPointerDown, onMouseDown,
+ }) => {
+ const React = require('react');
+ return React.createElement('span', {
+ 'data-testid': `fa-icon-${icon}`,
+ className,
+ onClick,
+ onPointerDown,
+ onMouseDown,
+ });
+ },
+}));
+
+jest.mock('reactstrap', () => {
+ const React = require('react');
+ return {
+ Dropdown: ({
+ children, isOpen, toggle, className,
+ }) => React.createElement(
+ 'div',
+ { 'data-testid': 'dropdown', 'data-is-open': String(isOpen), className },
+ React.createElement('button', { 'data-testid': 'dropdown-outer-toggle', onClick: toggle }),
+ children,
+ ),
+ DropdownToggle: ({ children, onPointerDown, onMouseDown }) => React.createElement(
+ 'button',
+ { 'data-testid': 'dropdown-toggle', onPointerDown, onMouseDown },
+ children,
+ ),
+ DropdownMenu: ({ children, onPointerDown, onMouseDown }) => React.createElement(
+ 'div',
+ { 'data-testid': 'dropdown-menu', onPointerDown, onMouseDown },
+ children,
+ ),
+ DropdownItem: ({
+ children, id, onClick, onPointerDown, onMouseDown,
+ }) => React.createElement(
+ 'button',
+ {
+ 'data-testid': `dropdown-item-${id}`,
+ onClick,
+ onPointerDown,
+ onMouseDown,
+ },
+ children,
+ ),
+ };
+});
+
+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-row', () => function MockLayerRow({
+ layer, compareState, isChartingActive, isDisabled, isVisible,
+}) {
+ return (
+ <div
+ data-testid={`layer-row-${layer.id}`}
+ data-compare-state={compareState}
+ data-is-charting={String(isChartingActive)}
+ data-is-disabled={String(isDisabled)}
+ data-is-visible={String(isVisible)}
+ />
+ );
+});
+
+jest.mock('../../util/util', () => ({
+ encodeId: jest.fn((id) => id),
+}));
+
+jest.mock('lodash', () => ({
+ get: jest.fn((obj, path) => {
+ if (!obj || !path) return undefined;
+ return path.split('.').reduce(
+ (acc, key) => (acc !== null && acc !== undefined ? acc[key] : undefined),
+ obj,
+ );
+ }),
+}));
+
+jest.mock('../../modules/layers/selectors', () => ({
+ replaceSubGroup: jest.fn((layerId, nextLayerId, activeLayers) => activeLayers),
+ getZotsForActiveLayers: jest.fn(() => ({ layer1: 'zot-data' })),
+ getTitles: jest.fn(() => ({ title: 'Layer Title', subtitle: '' })),
+ getActiveLayers: jest.fn(() => [
+ { id: 'layer1', layergroup: 'Overlays', visible: true },
+ { id: 'layer2', layergroup: 'Reference', visible: false },
+ ]),
+ memoizedAvailable: jest.fn(() => jest.fn(() => true)),
+}));
+
+jest.mock('../../modules/layers/actions', () => ({
+ reorderLayers: jest.fn(() => ({ type: 'REORDER_LAYERS' })),
+ removeGroup: jest.fn(() => ({ type: 'REMOVE_GROUP' })),
+ toggleGroupVisibility: jest.fn(() => ({ type: 'TOGGLE_GROUP_VISIBILITY' })),
+}));
+
+import LayerList from './layer-list';
+import {
+ replaceSubGroup,
+ getZotsForActiveLayers,
+ getTitles,
+ memoizedAvailable,
+} from '../../modules/layers/selectors';
+import {
+ reorderLayers as reorderLayersAction,
+ removeGroup as removeGroupAction,
+ toggleGroupVisibility as toggleGroupVisibilityAction,
+} from '../../modules/layers/actions';
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ delete global.__capturedOnDragEnd;
+});
+
+const defaultLayers = [
+ { id: 'layer1', projections: { 'EPSG:4326': true }, visible: true },
+ { id: 'layer2', projections: { 'EPSG:4326': true }, visible: false },
+];
+
+const defaultProps = {
+ activeLayers: [...defaultLayers],
+ activeChartingLayer: null,
+ available: jest.fn(() => true),
+ collapsed: false,
+ compareState: 'active',
+ dragHandleProps: {},
+ getNames: jest.fn(() => ({ title: 'Layer Title', subtitle: '' })),
+ groupId: 'group1',
+ isAnimating: false,
+ isChartingActive: false,
+ isMobile: false,
+ layerSplit: 0,
+ layers: defaultLayers,
+ numVisible: 1,
+ projId: 'EPSG:4326',
+ reorderLayers: jest.fn(),
+ removeGroup: jest.fn(),
+ title: 'Test Group',
+ toggleCollapse: jest.fn(),
+ toggleVisibility: jest.fn(),
+ zots: {},
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <LayerList {...defaultProps} {...propOverrides} />,
+);
+
+// ─── Rendering ────────────────────────────────────────────────────────────────
+
+describe('LayerList rendering', () => {
+ it('renders container div with id composed of compareState and groupId', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#active-group1')).toBeInTheDocument();
+ });
+
+ it('uses correct id with different compareState and groupId', () => {
+ const { container } = renderComponent({ compareState: 'activeB', groupId: 'grp2' });
+ expect(container.querySelector('#activeB-grp2')).toBeInTheDocument();
+ });
+
+ it('renders layer group header', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.layer-group-header')).toBeInTheDocument();
+ });
+
+ it('renders title in h3', () => {
+ const { container } = renderComponent({ title: 'My Layers' });
+ expect(container.querySelector('.layer-group-title').textContent).toContain('My Layers');
+ });
+
+ it('appends collapsed count when collapsed is true', () => {
+ const { container } = renderComponent({ collapsed: true, numVisible: 1 });
+ // layersInProj = both layers (both in EPSG:4326)
+ expect(container.querySelector('.layer-group-title').textContent).toContain('(1/2)');
+ });
+
+ it('does not append count when collapsed is false', () => {
+ const { container } = renderComponent({ collapsed: false });
+ expect(container.querySelector('.layer-group-title').textContent).not.toContain('(');
+ });
+
+ it('counts only layers in current projection for collapsed total', () => {
+ const mixedLayers = [
+ { id: 'layer1', projections: { 'EPSG:4326': true }, visible: true },
+ { id: 'layer2', projections: { 'EPSG:3413': true }, visible: false },
+ ];
+ const { container } = renderComponent({
+ layers: mixedLayers,
+ projId: 'EPSG:4326',
+ collapsed: true,
+ numVisible: 1,
+ });
+ expect(container.querySelector('.layer-group-title').textContent).toContain('(1/1)');
+ });
+
+ it('renders layer list without hidden class when not collapsed', () => {
+ const { container } = renderComponent({ collapsed: false });
+ expect(container.querySelector('.category')).not.toHaveClass('hidden');
+ });
+
+ it('renders layer list with hidden class when collapsed', () => {
+ const { container } = renderComponent({ collapsed: true });
+ expect(container.querySelector('.category')).toHaveClass('hidden');
+ });
+
+ it('renders a LayerRow for each layer', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('layer-row-layer1')).toBeInTheDocument();
+ expect(getByTestId('layer-row-layer2')).toBeInTheDocument();
+ });
+
+ it('passes compareState to LayerRow', () => {
+ const { getByTestId } = renderComponent({ compareState: 'activeB' });
+ expect(getByTestId('layer-row-layer1')).toHaveAttribute('data-compare-state', 'activeB');
+ });
+
+ it('passes isChartingActive to LayerRow', () => {
+ const { getByTestId } = renderComponent({ isChartingActive: true });
+ expect(getByTestId('layer-row-layer1')).toHaveAttribute('data-is-charting', 'true');
+ });
+
+ it('passes isDisabled based on available(id)', () => {
+ const available = jest.fn((id) => id !== 'layer1');
+ const { getByTestId } = renderComponent({ available });
+ expect(getByTestId('layer-row-layer1')).toHaveAttribute('data-is-disabled', 'true');
+ expect(getByTestId('layer-row-layer2')).toHaveAttribute('data-is-disabled', 'false');
+ });
+
+ it('passes isVisible from layer.visible', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('layer-row-layer1')).toHaveAttribute('data-is-visible', 'true');
+ expect(getByTestId('layer-row-layer2')).toHaveAttribute('data-is-visible', 'false');
+ });
+
+ it('renders DndContext', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('dnd-context')).toBeInTheDocument();
+ });
+
+ it('renders collapse caret-down icon when not collapsed', () => {
+ const { queryByTestId } = renderComponent({ collapsed: false });
+ expect(queryByTestId('fa-icon-caret-down')).toBeInTheDocument();
+ });
+
+ it('renders collapse caret-left icon when collapsed', () => {
+ const { queryByTestId } = renderComponent({ collapsed: true });
+ expect(queryByTestId('fa-icon-caret-left')).toBeInTheDocument();
+ });
+
+ it('does not render collapse icon when isChartingActive is true', () => {
+ const { queryByTestId } = renderComponent({ isChartingActive: true });
+ expect(queryByTestId('fa-icon-caret-down')).not.toBeInTheDocument();
+ expect(queryByTestId('fa-icon-caret-left')).not.toBeInTheDocument();
+ });
+
+ it('spreads dragHandleProps onto the header div', () => {
+ const { container } = renderComponent({ dragHandleProps: { 'data-drag': 'handle' } });
+ expect(container.querySelector('.layer-group-header')).toHaveAttribute('data-drag', 'handle');
+ });
+});
+
+// ─── Layer sorting ────────────────────────────────────────────────────────────
+
+describe('LayerList layer sorting', () => {
+ const sortLayers = [
+ { id: 'layerA', projections: { 'EPSG:4326': true }, visible: true, shouldHide: false },
+ { id: 'layerB', projections: { 'EPSG:4326': true }, visible: false, shouldHide: true },
+ { id: 'layerC', projections: { 'EPSG:4326': true }, visible: true, shouldHide: false },
+ ];
+
+ it('preserves layer order when isChartingActive is false', () => {
+ const { getAllByTestId } = render(
+ <LayerList {...defaultProps} layers={sortLayers} isChartingActive={false} />,
+ );
+ const ids = getAllByTestId(/^layer-row-/).map((el) => el.getAttribute('data-testid'));
+ expect(ids).toEqual(['layer-row-layerA', 'layer-row-layerB', 'layer-row-layerC']);
+ });
+
+ it('sorts shouldHide=true layers to the end when isChartingActive is true', () => {
+ const { getAllByTestId } = render(
+ <LayerList {...defaultProps} layers={sortLayers} isChartingActive />,
+ );
+ const ids = getAllByTestId(/^layer-row-/).map((el) => el.getAttribute('data-testid'));
+ expect(ids.indexOf('layer-row-layerB')).toBeGreaterThan(ids.indexOf('layer-row-layerA'));
+ expect(ids.indexOf('layer-row-layerB')).toBeGreaterThan(ids.indexOf('layer-row-layerC'));
+ });
+
+ it('keeps equal shouldHide layers in original order when charting', () => {
+ const equalLayers = [
+ { id: 'layerX', projections: { 'EPSG:4326': true }, visible: true, shouldHide: false },
+ { id: 'layerY', projections: { 'EPSG:4326': true }, visible: true, shouldHide: false },
+ ];
+ const { getAllByTestId } = render(
+ <LayerList {...defaultProps} layers={equalLayers} isChartingActive />,
+ );
+ const ids = getAllByTestId(/^layer-row-/).map((el) => el.getAttribute('data-testid'));
+ expect(ids[0]).toBe('layer-row-layerX');
+ expect(ids[1]).toBe('layer-row-layerY');
+ });
+});
+
+// ─── Dropdown visibility ──────────────────────────────────────────────────────
+
+describe('LayerList dropdown visibility', () => {
+ it('does not render dropdown before mouseEnter when isMobile is false', () => {
+ const { queryByTestId } = renderComponent({ isMobile: false });
+ expect(queryByTestId('dropdown')).not.toBeInTheDocument();
+ });
+
+ it('renders dropdown after mouseEnter when not animating and not charting', () => {
+ const { container, getByTestId } = renderComponent({ isMobile: false });
+ fireEvent.mouseEnter(container.querySelector('.layer-group-header'));
+ expect(getByTestId('dropdown')).toBeInTheDocument();
+ });
+
+ it('hides dropdown after mouseLeave', () => {
+ const { container, queryByTestId } = renderComponent({ isMobile: false });
+ const header = container.querySelector('.layer-group-header');
+ fireEvent.mouseEnter(header);
+ fireEvent.mouseLeave(header);
+ expect(queryByTestId('dropdown')).not.toBeInTheDocument();
+ });
+
+ it('always renders dropdown when isMobile is true', () => {
+ const { queryByTestId } = renderComponent({ isMobile: true });
+ expect(queryByTestId('dropdown')).toBeInTheDocument();
+ });
+
+ it('does not render dropdown when isAnimating even if isMobile', () => {
+ const { queryByTestId } = renderComponent({ isMobile: true, isAnimating: true });
+ expect(queryByTestId('dropdown')).not.toBeInTheDocument();
+ });
+
+ it('does not render dropdown when isChartingActive even if isMobile', () => {
+ const { queryByTestId } = renderComponent({ isMobile: true, isChartingActive: true });
+ expect(queryByTestId('dropdown')).not.toBeInTheDocument();
+ });
+
+ it('does not hide dropdown button on mouseLeave when menu is open', () => {
+ const { container, getByTestId } = renderComponent({ isMobile: false });
+ const header = container.querySelector('.layer-group-header');
+ fireEvent.mouseEnter(header);
+ fireEvent.click(getByTestId('dropdown-outer-toggle')); // open menu
+ fireEvent.mouseLeave(header); // should not hide because menu is open
+ expect(getByTestId('dropdown')).toBeInTheDocument();
+ });
+
+ it('hides dropdown button when menu is toggled closed', () => {
+ const { container, queryByTestId, getByTestId } = renderComponent({ isMobile: false });
+ const header = container.querySelector('.layer-group-header');
+ fireEvent.mouseEnter(header);
+ fireEvent.click(getByTestId('dropdown-outer-toggle')); // open
+ fireEvent.click(getByTestId('dropdown-outer-toggle')); // close — also clears showDropdownBtn
+ expect(queryByTestId('dropdown')).not.toBeInTheDocument();
+ });
+
+ it('dropdown isOpen starts false', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(getByTestId('dropdown')).toHaveAttribute('data-is-open', 'false');
+ });
+
+ it('dropdown isOpen becomes true after toggle click', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ fireEvent.click(getByTestId('dropdown-outer-toggle'));
+ expect(getByTestId('dropdown')).toHaveAttribute('data-is-open', 'true');
+ });
+});
+
+// ─── Dropdown menu item actions ───────────────────────────────────────────────
+
+describe('LayerList dropdown menu actions', () => {
+ it('calls toggleVisibility with layer ids and true when Show All is clicked', () => {
+ const toggleVisibility = jest.fn();
+ const { getByTestId } = renderComponent({ isMobile: true, toggleVisibility });
+ fireEvent.click(getByTestId('dropdown-item-show-all'));
+ expect(toggleVisibility).toHaveBeenCalledWith(['layer1', 'layer2'], true);
+ });
+
+ it('calls toggleVisibility with layer ids and false when Hide All is clicked', () => {
+ const toggleVisibility = jest.fn();
+ const { getByTestId } = renderComponent({ isMobile: true, toggleVisibility });
+ fireEvent.click(getByTestId('dropdown-item-hide-all'));
+ expect(toggleVisibility).toHaveBeenCalledWith(['layer1', 'layer2'], false);
+ });
+
+ it('calls removeGroup with layer ids when Remove Group is clicked', () => {
+ const removeGroup = jest.fn();
+ const { getByTestId } = renderComponent({ isMobile: true, removeGroup });
+ fireEvent.click(getByTestId('dropdown-item-remove-group'));
+ expect(removeGroup).toHaveBeenCalledWith(['layer1', 'layer2']);
+ });
+
+ it('passes correct groupLayerIds when layers change', () => {
+ const toggleVisibility = jest.fn();
+ const extraLayers = [
+ ...defaultLayers,
+ { id: 'layer3', projections: { 'EPSG:4326': true }, visible: true },
+ ];
+ const { getByTestId } = renderComponent({
+ isMobile: true,
+ layers: extraLayers,
+ toggleVisibility,
+ });
+ fireEvent.click(getByTestId('dropdown-item-show-all'));
+ expect(toggleVisibility).toHaveBeenCalledWith(['layer1', 'layer2', 'layer3'], true);
+ });
+});
+
+// ─── Collapse/expand ──────────────────────────────────────────────────────────
+
+describe('LayerList collapse interactions', () => {
+ it('calls toggleCollapse with groupId and true when not collapsed', () => {
+ const toggleCollapse = jest.fn();
+ const { getByTestId } = renderComponent({ toggleCollapse, collapsed: false });
+ fireEvent.click(getByTestId('fa-icon-caret-down'));
+ expect(toggleCollapse).toHaveBeenCalledWith('group1', true);
+ });
+
+ it('calls toggleCollapse with groupId and false when collapsed', () => {
+ const toggleCollapse = jest.fn();
+ const { getByTestId } = renderComponent({ toggleCollapse, collapsed: true });
+ fireEvent.click(getByTestId('fa-icon-caret-left'));
+ expect(toggleCollapse).toHaveBeenCalledWith('group1', false);
+ });
+});
+
+// ─── stopDndActivation ────────────────────────────────────────────────────────
+
+describe('LayerList stopDndActivation', () => {
+ it('does not throw when pointer events fire on dropdown toggle', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(() => {
+ fireEvent.pointerDown(getByTestId('dropdown-toggle'));
+ fireEvent.mouseDown(getByTestId('dropdown-toggle'));
+ }).not.toThrow();
+ });
+
+ it('does not throw when pointer events fire on dropdown menu', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(() => {
+ fireEvent.pointerDown(getByTestId('dropdown-menu'));
+ fireEvent.mouseDown(getByTestId('dropdown-menu'));
+ }).not.toThrow();
+ });
+
+ it('does not throw when pointer events fire on dropdown items', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(() => {
+ fireEvent.pointerDown(getByTestId('dropdown-item-show-all'));
+ }).not.toThrow();
+ });
+
+ it('does not throw when pointer events fire on collapse icon', () => {
+ const { getByTestId } = renderComponent();
+ expect(() => {
+ fireEvent.pointerDown(getByTestId('fa-icon-caret-down'));
+ fireEvent.mouseDown(getByTestId('fa-icon-caret-down'));
+ }).not.toThrow();
+ });
+});
+
+// ─── DnD onDragEnd ────────────────────────────────────────────────────────────
+
+describe('LayerList onDragEnd', () => {
+ it('returns early when over is null', () => {
+ const reorderLayers = jest.fn();
+ renderComponent({ reorderLayers });
+ global.__capturedOnDragEnd({ active: { id: 'layer1-active' }, over: null });
+ expect(reorderLayers).not.toHaveBeenCalled();
+ });
+
+ it('returns early when active.id equals over.id', () => {
+ const reorderLayers = jest.fn();
+ renderComponent({ reorderLayers });
+ global.__capturedOnDragEnd({
+ active: { id: 'layer1-active' },
+ over: { id: 'layer1-active' },
+ });
+ expect(reorderLayers).not.toHaveBeenCalled();
+ });
+
+ it('returns early when active.id is not found in sortableLayerIds', () => {
+ const reorderLayers = jest.fn();
+ renderComponent({ reorderLayers });
+ global.__capturedOnDragEnd({
+ active: { id: 'nonexistent-active' },
+ over: { id: 'layer2-active' },
+ });
+ expect(reorderLayers).not.toHaveBeenCalled();
+ });
+
+ it('calls replaceSubGroup and reorderLayers on valid drag', () => {
+ const reorderLayers = jest.fn();
+ renderComponent({ reorderLayers });
+ global.__capturedOnDragEnd({
+ active: { id: 'layer1-active' },
+ over: { id: 'layer2-active' },
+ });
+ expect(replaceSubGroup).toHaveBeenCalled();
+ expect(reorderLayers).toHaveBeenCalledTimes(1);
+ });
+
+ it('strips compareState suffix from active.id when calling replaceSubGroup', () => {
+ const reorderLayers = jest.fn();
+ renderComponent({ reorderLayers, compareState: 'active' });
+ global.__capturedOnDragEnd({
+ active: { id: 'layer1-active' },
+ over: { id: 'layer2-active' },
+ });
+ const [layerId] = replaceSubGroup.mock.calls[0];
+ expect(layerId).toBe('layer1');
+ });
+
+ it('passes null as nextLayerId when dragged to last position', () => {
+ const reorderLayers = jest.fn();
+ // 2 layers: move layer1 (idx 0) to layer2 (idx 1) → destination is last, nextLayerId = null
+ renderComponent({ reorderLayers });
+ global.__capturedOnDragEnd({
+ active: { id: 'layer1-active' },
+ over: { id: 'layer2-active' },
+ });
+ const [, nextLayerId] = replaceSubGroup.mock.calls[0];
+ expect(nextLayerId).toBeNull();
+ });
+
+ it('passes nextLayerId when dragged to non-last position', () => {
+ const threeLayers = [
+ { id: 'layer1', projections: { 'EPSG:4326': true }, visible: true },
+ { id: 'layer2', projections: { 'EPSG:4326': true }, visible: true },
+ { id: 'layer3', projections: { 'EPSG:4326': true }, visible: false },
+ ];
+ const reorderLayers = jest.fn();
+ render(<LayerList {...defaultProps} layers={threeLayers} reorderLayers={reorderLayers} />);
+ // Move layer1 (idx 0) to layer2 (idx 1):
+ // arrayMove([l1,l2,l3], 0, 1) = [l2,l1,l3]; destination=1, nextIndex=2, nextLayerId='layer3'
+ global.__capturedOnDragEnd({
+ active: { id: 'layer1-active' },
+ over: { id: 'layer2-active' },
+ });
+ expect(replaceSubGroup).toHaveBeenCalled();
+ const [, nextLayerId] = replaceSubGroup.mock.calls[0];
+ expect(nextLayerId).toBe('layer3');
+ });
+});
+
+// ─── mapStateToProps ──────────────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ embed: { isEmbedModeActive: false },
+ proj: { id: 'EPSG:4326' },
+ config: { layers: {} },
+ map: { ui: { selected: null } },
+ animation: { isPlaying: false },
+ screenSize: { isMobileDevice: false },
+ charting: { active: false, activeLayer: null },
+ ...overrides,
+ });
+
+ it('maps projId from proj.id', () => {
+ const state = makeState({ proj: { id: 'EPSG:3413' } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.projId).toBe('EPSG:3413');
+ });
+
+ it('maps isAnimating from animation.isPlaying', () => {
+ const state = makeState({ animation: { isPlaying: true } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.isAnimating).toBe(true);
+ });
+
+ it('maps isMobile from screenSize.isMobileDevice', () => {
+ const state = makeState({ screenSize: { isMobileDevice: true } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.isMobile).toBe(true);
+ });
+
+ it('maps isChartingActive from charting.active', () => {
+ const state = makeState({ charting: { active: true, activeLayer: null } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.isChartingActive).toBe(true);
+ });
+
+ it('maps activeChartingLayer from charting.activeLayer', () => {
+ const state = makeState({ charting: { active: false, activeLayer: 'layer2' } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.activeChartingLayer).toBe('layer2');
+ });
+
+ it('maps isEmbedModeActive from embed.isEmbedModeActive', () => {
+ const state = makeState({ embed: { isEmbedModeActive: true } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.isEmbedModeActive).toBe(true);
+ });
+
+ it('maps zots to empty object when map.ui.selected is null', () => {
+ const state = makeState({ map: { ui: { selected: null } } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.zots).toEqual({});
+ expect(getZotsForActiveLayers).not.toHaveBeenCalled();
+ });
+
+ it('calls getZotsForActiveLayers and maps zots when map.ui.selected is truthy', () => {
+ const state = makeState({ map: { ui: { selected: {} } } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(getZotsForActiveLayers).toHaveBeenCalledWith(state);
+ expect(result.zots).toEqual({ layer1: 'zot-data' });
+ });
+
+ it('filters Reference layers from activeLayers when isEmbedModeActive', () => {
+ const state = makeState({ embed: { isEmbedModeActive: true } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.activeLayers.every((l) => l.layergroup !== 'Reference')).toBe(true);
+ expect(result.activeLayers.some((l) => l.layergroup === 'Overlays')).toBe(true);
+ });
+
+ it('includes all activeLayers including Reference when not in embed mode', () => {
+ const state = makeState({ embed: { isEmbedModeActive: false } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ expect(result.activeLayers).toHaveLength(2);
+ expect(result.activeLayers.some((l) => l.layergroup === 'Reference')).toBe(true);
+ });
+
+ it('calculates numVisible from visible layers in ownProps.layers', () => {
+ const state = makeState();
+ const ownLayers = [{ visible: true }, { visible: true }, { visible: false }];
+ const result = capturedMapStateToProps(state, { layers: ownLayers });
+ expect(result.numVisible).toBe(2);
+ });
+
+ it('numVisible is 0 when ownProps.layers is undefined', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, {});
+ expect(result.numVisible).toBe(0);
+ });
+
+ it('getNames calls getTitles with config, layerId, and projId', () => {
+ const state = makeState({ proj: { id: 'EPSG:4326' }, config: { layers: {} } });
+ const result = capturedMapStateToProps(state, { layers: [] });
+ result.getNames('layer1');
+ expect(getTitles).toHaveBeenCalledWith(state.config, 'layer1', 'EPSG:4326');
+ });
+
+ it('available calls memoizedAvailable(state) then result with layerId', () => {
+ const mockFn = jest.fn(() => true);
+ memoizedAvailable.mockReturnValue(mockFn);
+ const state = makeState();
+ const result = capturedMapStateToProps(state, { layers: [] });
+ result.available('layer1');
+ expect(memoizedAvailable).toHaveBeenCalledWith(state);
+ expect(mockFn).toHaveBeenCalledWith('layer1');
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+ let mapped;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ mapped = capturedMapDispatchToProps(dispatch);
+ });
+
+ it('reorderLayers dispatches reorderLayersAction with new layer array', () => {
+ const newLayers = [{ id: 'layer2' }, { id: 'layer1' }];
+ mapped.reorderLayers(newLayers);
+ expect(reorderLayersAction).toHaveBeenCalledWith(newLayers);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'REORDER_LAYERS' });
+ });
+
+ it('removeGroup dispatches removeGroupAction with layer ids', () => {
+ const layerIds = ['layer1', 'layer2'];
+ mapped.removeGroup(layerIds);
+ expect(removeGroupAction).toHaveBeenCalledWith(layerIds);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'REMOVE_GROUP' });
+ });
+
+ it('toggleVisibility dispatches toggleGroupVisibilityAction with layerIds and visible', () => {
+ const layerIds = ['layer1', 'layer2'];
+ mapped.toggleVisibility(layerIds, false);
+ expect(toggleGroupVisibilityAction).toHaveBeenCalledWith(layerIds, false);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_GROUP_VISIBILITY' });
+ });
});
diff --git a/web/js/containers/sidebar/layer-row.test.js b/web/js/containers/sidebar/layer-row.test.js
index 11f28ae03..9c46d4abd 100644
--- a/web/js/containers/sidebar/layer-row.test.js
+++ b/web/js/containers/sidebar/layer-row.test.js
@@ -1,3 +1,1384 @@
-test('layer-row container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, fireEvent, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('@dnd-kit/sortable', () => ({
+ useSortable: jest.fn(() => ({
+ attributes: {},
+ listeners: {},
+ setNodeRef: jest.fn(),
+ setActivatorNodeRef: jest.fn(),
+ transform: null,
+ transition: null,
+ isDragging: false,
+ })),
+}));
+
+jest.mock('@fortawesome/free-solid-svg-icons', () => ({
+ faCircleDot: 'faCircleDot',
+ faCircle: 'faCircle',
+}));
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, className }) => {
+ const React = require('react');
+ const iconStr = Array.isArray(icon) ? icon.join('-') : String(icon);
+ return React.createElement('span', { 'data-testid': `fa-${iconStr}`, className });
+ },
+}));
+
+jest.mock('reactstrap', () => {
+ const React = require('react');
+ return {
+ UncontrolledTooltip: ({ children }) => React.createElement('div', { 'data-testid': 'tooltip' }, children),
+ Dropdown: ({
+ children, isOpen, toggle, className,
+ }) => React.createElement(
+ 'div',
+ { 'data-testid': 'dropdown', 'data-is-open': String(isOpen), className },
+ React.createElement('button', { 'data-testid': 'dropdown-outer-toggle', onClick: toggle }),
+ children,
+ ),
+ DropdownToggle: ({ children, onPointerDown, onMouseDown }) => React.createElement(
+ 'button',
+ { 'data-testid': 'dropdown-toggle', onPointerDown, onMouseDown },
+ children,
+ ),
+ DropdownMenu: ({ children }) => React.createElement('div', { 'data-testid': 'dropdown-menu' }, children),
+ DropdownItem: ({
+ children, id, onClick, onPointerDown, onMouseDown,
+ }) => React.createElement(
+ 'button',
+ {
+ 'data-testid': `dropdown-item-${id}`,
+ id,
+ onClick,
+ onPointerDown,
+ onMouseDown,
+ },
+ children,
+ ),
+ };
+});
+
+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('googleTagManager', () => ({ pushEvent: jest.fn() }));
+
+jest.mock('../../components/sidebar/paletteLegend', () => function MockPaletteLegend({ layer }) {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': `palette-legend-${layer.id}` });
+});
+
+jest.mock('../../util/util', () => ({
+ encodeId: jest.fn((id) => id),
+ events: {
+ on: jest.fn(),
+ off: jest.fn(),
+ trigger: jest.fn(),
+ },
+}));
+
+jest.mock('../../util/cmr', () => ({
+ buildGranulesUrl: jest.fn(() => 'http://mock-cmr'),
+ cmrFetch: jest.fn(() => Promise.resolve({ ok: false })),
+}));
+
+jest.mock('lodash', () => ({
+ isEmpty: jest.fn((val) => !val || (typeof val === 'object' && Object.keys(val).length === 0)),
+ get: jest.fn((obj, path) => {
+ if (!obj || !path) return undefined;
+ try {
+ return path.split('.').reduce(
+ (acc, key) => (acc !== null && acc !== undefined ? acc[key] : undefined),
+ obj,
+ );
+ } catch {
+ return undefined;
+ }
+ }),
+}));
+
+jest.mock('../../modules/palettes/selectors', () => ({
+ getPalette: jest.fn(() => ({})),
+ getPaletteLegends: jest.fn(() => []),
+}));
+
+jest.mock('../../modules/modal/actions', () => ({
+ toggleCustomContent: jest.fn(() => ({ type: 'TOGGLE_CUSTOM_CONTENT' })),
+ openCustomContent: jest.fn(() => ({ type: 'OPEN_CUSTOM_CONTENT' })),
+}));
+
+jest.mock('../../components/layer/info/info', () => function MockLayerInfo() { return null; });
+jest.mock('../../components/layer/settings/layer-settings', () => function MockLayerSettings() { return null; });
+
+jest.mock('../../modules/palettes/actions', () => ({
+ requestPalette: jest.fn(() => ({ type: 'REQUEST_PALETTE' })),
+}));
+
+jest.mock('../../modules/layers/actions', () => ({
+ toggleVisibility: jest.fn(() => ({ type: 'TOGGLE_VISIBILITY' })),
+ removeLayer: jest.fn(() => ({ type: 'REMOVE_LAYER' })),
+}));
+
+jest.mock('./orbit-track', () => function MockOrbitTrack({ trackLayer }) {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': `orbit-track-${trackLayer.id}` });
+});
+
+jest.mock('./zot', () => function MockZot({ zot }) {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'zot', 'data-has-zot': String(!!zot) });
+});
+
+jest.mock('../../modules/layers/util', () => ({
+ isVectorLayerClickable: jest.fn(() => false),
+}));
+
+jest.mock('../../modules/alerts/constants', () => ({
+ MODAL_PROPERTIES: {
+ vectorModalProps: { id: 'vector-modal', props: {} },
+ granuleModalProps: { id: 'granule-modal', props: {} },
+ zoomModalProps: { id: 'zoom-modal', props: {} },
+ },
+}));
+
+jest.mock('../../modules/layers/selectors', () => ({
+ getActiveLayers: jest.fn(() => []),
+ makeGetDescription: jest.fn(() => jest.fn(() => 'mock-description-path')),
+ getCollections: jest.fn(() => null),
+}));
+
+jest.mock('../../mapUI/components/kiosk/tile-measurement/utils/date-util', () => ({
+ formatDailyDate: jest.fn(() => '2021-01-01'),
+ formatSubdailyDate: jest.fn(() => '2021-01-01T00:00:00'),
+}));
+
+jest.mock('../../modules/date/util', () => ({
+ coverageDateFormatter: jest.fn((type, date) => String(date)),
+}));
+
+jest.mock('../../modules/charting/actions', () => ({
+ updateActiveChartingLayerAction: jest.fn(() => ({ type: 'UPDATE_ACTIVE_CHARTING_LAYER' })),
+}));
+
+jest.mock('../../components/util/alert', () => function MockAlertUtil({
+ id, onDismiss, onClick,
+}) {
+ const React = require('react');
+ return React.createElement(
+ 'div',
+ { 'data-testid': `alert-${id}` },
+ React.createElement('button', { 'data-testid': `alert-dismiss-${id}`, onClick: onDismiss }),
+ React.createElement('button', { 'data-testid': `alert-action-${id}`, onClick }),
+ );
+});
+
+jest.mock('../../modules/alerts/actions', () => ({
+ enableDDVZoomAlert: jest.fn(() => ({ type: 'ENABLE_DDV_ZOOM_ALERT' })),
+ enableDDVLocationAlert: jest.fn(() => ({ type: 'ENABLE_DDV_LOCATION_ALERT' })),
+ disableDDVLocationAlert: jest.fn(() => ({ type: 'DISABLE_DDV_LOCATION_ALERT' })),
+ disableDDVZoomAlert: jest.fn(() => ({ type: 'DISABLE_DDV_ZOOM_ALERT' })),
+}));
+
+import LayerRow from './layer-row';
+import { toggleVisibility as toggleVisibilityAction, removeLayer as removeLayerAction } from '../../modules/layers/actions';
+import { toggleCustomContent, openCustomContent } from '../../modules/modal/actions';
+import { updateActiveChartingLayerAction } from '../../modules/charting/actions';
+import { requestPalette as requestPaletteAction } from '../../modules/palettes/actions';
+import util from '../../util/util';
+import {
+ enableDDVZoomAlert as enableDDVZoomAlertAction,
+ enableDDVLocationAlert as enableDDVLocationAlertAction,
+ disableDDVLocationAlert as disableDDVLocationAlertAction,
+ disableDDVZoomAlert as disableDDVZoomAlertAction,
+} from '../../modules/alerts/actions';
+
+let capturedMakeMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMakeMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ util.encodeId.mockImplementation((id) => id);
+ const { useSortable } = jest.requireMock('@dnd-kit/sortable');
+ useSortable.mockReturnValue({
+ attributes: {},
+ listeners: {},
+ setNodeRef: jest.fn(),
+ setActivatorNodeRef: jest.fn(),
+ transform: null,
+ transition: null,
+ isDragging: false,
+ });
+});
+
+const defaultLayer = {
+ id: 'layer1',
+ title: 'Test Layer',
+ subtitle: 'Subtitle',
+ type: 'wms',
+ palette: {},
+};
+
+const defaultProps = {
+ compare: { active: false, activeString: 'active' },
+ layer: defaultLayer,
+ compareState: 'active',
+ collections: null,
+ ddvLocationAlerts: [],
+ ddvZoomAlerts: [],
+ paletteLegends: [],
+ getPalette: jest.fn(() => ({})),
+ palette: { id: 'palette1' },
+ renderedPalette: {},
+ requestPalette: jest.fn(),
+ globalTemperatureUnit: 'K',
+ isCustomPalette: false,
+ isDistractionFreeModeActive: false,
+ isEmbedModeActive: false,
+ isLoading: false,
+ isMobile: false,
+ zot: null,
+ names: { title: 'Test Layer', subtitle: 'Subtitle' },
+ onRemoveClick: jest.fn(),
+ onInfoClick: jest.fn(),
+ onOptionsClick: jest.fn(),
+ hasClickableFeature: false,
+ openVectorAlertModal: jest.fn(),
+ openGranuleAlertModal: jest.fn(),
+ openZoomAlertModal: jest.fn(),
+ toggleVisibility: jest.fn(),
+ isDisabled: false,
+ isVisible: true,
+ hasPalette: false,
+ isInProjection: true,
+ tracksForLayer: [],
+ isVectorLayer: false,
+ isChartableLayer: false,
+ measurementDescriptionPath: 'description-path',
+ isAnimating: false,
+ palettes: { rendered: {}, custom: {}, isLoading: {} },
+ isChartingActive: false,
+ activeChartingLayer: null,
+ updateActiveChartingLayer: jest.fn(),
+ enableDDVZoomAlert: jest.fn(),
+ enableDDVLocationAlert: jest.fn(),
+ disableDDVLocationAlert: jest.fn(),
+ disableDDVZoomAlert: jest.fn(),
+ map: { extent: [-180, -90, 180, 90] },
+ selectedDate: new Date('2021-01-01'),
+ describeDomainsUrl: 'https://example.com',
+ cmrBaseUrl: 'https://cmr.earthdata.nasa.gov',
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <LayerRow {...defaultProps} {...propOverrides} />,
+);
+
+// ─── Rendering ────────────────────────────────────────────────────────────────
+
+describe('LayerRow rendering', () => {
+ it('renders li with correct id when isInProjection', () => {
+ const { container } = renderComponent();
+ const li = container.querySelector('li');
+ expect(li).toBeInTheDocument();
+ expect(li.id).toBe('active-layer1');
+ });
+
+ it('renders placeholder li when not isInProjection', () => {
+ const { container } = renderComponent({ isInProjection: false });
+ expect(container.querySelector('li')).toHaveClass('layer-list-placeholder');
+ });
+
+ it('renders layer title in h4', () => {
+ const { getByText } = renderComponent();
+ expect(getByText('Test Layer')).toBeInTheDocument();
+ });
+
+ it('renders subtitle paragraph', () => {
+ const { container } = renderComponent();
+ const p = container.querySelector('p');
+ expect(p).toBeInTheDocument();
+ expect(p.innerHTML).toBe('Subtitle');
+ });
+
+ it('renders Zot component', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('zot')).toBeInTheDocument();
+ });
+
+ it('renders visibility button when not embedded and not charting', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.visibility')).toBeInTheDocument();
+ });
+
+ it('does not render visibility button when isEmbedModeActive', () => {
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ expect(container.querySelector('.visibility')).not.toBeInTheDocument();
+ });
+
+ it('hides controls when not hovering and not isMobile', () => {
+ const { queryByLabelText } = renderComponent({ isMobile: false });
+ expect(queryByLabelText('View Options')).not.toBeInTheDocument();
+ });
+
+ it('shows dropdown when isMobile', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(getByTestId('dropdown')).toBeInTheDocument();
+ });
+
+ it('hides subtitle when layer.shouldHide', () => {
+ const { queryByText } = renderComponent({ layer: { ...defaultLayer, shouldHide: true } });
+ expect(queryByText('Subtitle')).not.toBeInTheDocument();
+ });
+
+ it('uses wv-vector-layer class when isVectorLayer', () => {
+ const { container } = renderComponent({ isVectorLayer: true });
+ expect(container.querySelector('.wv-vector-layer')).toBeInTheDocument();
+ });
+});
+
+// ─── Layer item classes ────────────────────────────────────────────────────────
+
+describe('getLayerItemClasses', () => {
+ it('layer-visible when isVisible and not disabled', () => {
+ const { container } = renderComponent({ isVisible: true });
+ expect(container.querySelector('li')).toHaveClass('layer-visible');
+ });
+
+ it('layer-hidden when isVisible is false', () => {
+ const { container } = renderComponent({ isVisible: false });
+ expect(container.querySelector('li')).toHaveClass('layer-hidden');
+ });
+
+ it('layer-hidden when isDisabled', () => {
+ const { container } = renderComponent({ isDisabled: true });
+ expect(container.querySelector('li')).toHaveClass('layer-hidden');
+ });
+
+ it('layer-hidden and mini when layer.shouldHide', () => {
+ const { container } = renderComponent({ layer: { ...defaultLayer, shouldHide: true } });
+ const li = container.querySelector('li');
+ expect(li).toHaveClass('layer-hidden');
+ expect(li).toHaveClass('mini');
+ });
+
+ it('disabled class when isAnimating', () => {
+ const { container } = renderComponent({ isAnimating: true });
+ expect(container.querySelector('li')).toHaveClass('disabled');
+ });
+
+ it('zotted class when zot provided', () => {
+ const { container } = renderComponent({ zot: { underZoomValue: 0 } });
+ expect(container.querySelector('li')).toHaveClass('zotted');
+ });
+});
+
+// ─── Visibility toggle ─────────────────────────────────────────────────────────
+
+describe('Visibility toggle', () => {
+ it('has layer-visible class when visible and not disabled', () => {
+ const { container } = renderComponent({ isVisible: true });
+ expect(container.querySelector('.visibility')).toHaveClass('layer-visible');
+ });
+
+ it('has layer-hidden class when isVisible is false', () => {
+ const { container } = renderComponent({ isVisible: false });
+ expect(container.querySelector('.visibility')).toHaveClass('layer-hidden');
+ });
+
+ it('has disabled class when isDisabled', () => {
+ const { container } = renderComponent({ isDisabled: true });
+ expect(container.querySelector('.visibility')).toHaveClass('disabled');
+ });
+
+ it('has disabled class when layer.shouldHide', () => {
+ const { container } = renderComponent({ layer: { ...defaultLayer, shouldHide: true } });
+ expect(container.querySelector('.visibility')).toHaveClass('disabled');
+ });
+
+ it('calls toggleVisibility on click when not disabled or animating', () => {
+ const toggleVisibility = jest.fn();
+ const { container } = renderComponent({ toggleVisibility, isVisible: true });
+ fireEvent.click(container.querySelector('.visibility'));
+ expect(toggleVisibility).toHaveBeenCalledWith('layer1', false);
+ });
+
+ it('does not call toggleVisibility when isAnimating', () => {
+ const toggleVisibility = jest.fn();
+ const { container } = renderComponent({ isAnimating: true, toggleVisibility });
+ fireEvent.click(container.querySelector('.visibility'));
+ expect(toggleVisibility).not.toHaveBeenCalled();
+ });
+
+ it('does not call toggleVisibility when isDisabled', () => {
+ const toggleVisibility = jest.fn();
+ const { container } = renderComponent({ isDisabled: true, toggleVisibility });
+ fireEvent.click(container.querySelector('.visibility'));
+ expect(toggleVisibility).not.toHaveBeenCalled();
+ });
+
+ it('shows Hide layer tooltip when visible and not disabled', () => {
+ const { getAllByTestId } = renderComponent({ isVisible: true });
+ const tooltips = getAllByTestId('tooltip');
+ expect(tooltips.some((t) => t.textContent === 'Hide layer')).toBe(true);
+ });
+
+ it('shows Show layer tooltip when not visible and not disabled', () => {
+ const { getAllByTestId } = renderComponent({ isVisible: false, isDisabled: false });
+ const tooltips = getAllByTestId('tooltip');
+ expect(tooltips.some((t) => t.textContent === 'Show layer')).toBe(true);
+ });
+});
+
+// ─── getDisabledTitle ──────────────────────────────────────────────────────────
+
+describe('getDisabledTitle', () => {
+ it('shows No data message when layer has no dates', () => {
+ const { getAllByTestId } = renderComponent({ isDisabled: true });
+ const tooltips = getAllByTestId('tooltip');
+ expect(tooltips.some((t) => t.textContent.includes('No data on selected date'))).toBe(true);
+ });
+
+ it('shows both dates when layer has startDate and endDate', () => {
+ const { getAllByTestId } = renderComponent({
+ isDisabled: true,
+ layer: { ...defaultLayer, startDate: '2020-01-01', endDate: '2021-12-31', period: 'daily' },
+ });
+ const tooltips = getAllByTestId('tooltip');
+ expect(tooltips.some((t) => t.textContent.includes('2020-01-01'))).toBe(true);
+ expect(tooltips.some((t) => t.textContent.includes('2021-12-31'))).toBe(true);
+ });
+
+ it('shows Present when only startDate present', () => {
+ const { getAllByTestId } = renderComponent({
+ isDisabled: true,
+ layer: { ...defaultLayer, startDate: '2020-01-01', period: 'daily' },
+ });
+ const tooltips = getAllByTestId('tooltip');
+ expect(tooltips.some((t) => t.textContent.includes('Present'))).toBe(true);
+ });
+});
+
+// ─── Mouse interactions ────────────────────────────────────────────────────────
+
+describe('Mouse interactions', () => {
+ it('shows controls on mouseOver', () => {
+ const { container, getByLabelText } = renderComponent({ isMobile: false });
+ fireEvent.mouseOver(container.querySelector('li'));
+ expect(getByLabelText('View Options')).toBeInTheDocument();
+ });
+
+ it('hides controls on mouseLeave', () => {
+ const { container, queryByLabelText } = renderComponent({ isMobile: false });
+ fireEvent.mouseOver(container.querySelector('li'));
+ fireEvent.mouseLeave(container.querySelector('li'));
+ expect(queryByLabelText('View Options')).not.toBeInTheDocument();
+ });
+
+ it('triggers SIDEBAR_LAYER_HOVER true on mouseOver', () => {
+ const { container } = renderComponent();
+ fireEvent.mouseOver(container.querySelector('li'));
+ expect(util.events.trigger).toHaveBeenCalledWith('sidebar:layer-hover', 'layer1', true);
+ });
+
+ it('triggers SIDEBAR_LAYER_HOVER false on mouseLeave', () => {
+ const { container } = renderComponent();
+ fireEvent.mouseOver(container.querySelector('li'));
+ fireEvent.mouseLeave(container.querySelector('li'));
+ expect(util.events.trigger).toHaveBeenCalledWith('sidebar:layer-hover', 'layer1', false);
+ });
+
+ it('does not trigger events on mouseOver when isMobile', () => {
+ const { container } = renderComponent({ isMobile: true });
+ util.events.trigger.mockClear();
+ fireEvent.mouseOver(container.querySelector('li'));
+ expect(util.events.trigger).not.toHaveBeenCalled();
+ });
+
+ it('does not trigger events on mouseLeave when isMobile', () => {
+ const { container } = renderComponent({ isMobile: true });
+ util.events.trigger.mockClear();
+ fireEvent.mouseLeave(container.querySelector('li'));
+ expect(util.events.trigger).not.toHaveBeenCalled();
+ });
+});
+
+// ─── Controls ─────────────────────────────────────────────────────────────────
+
+describe('Controls', () => {
+ it('renders remove, options, info buttons on hover', () => {
+ const { container, getByLabelText } = renderComponent({ isMobile: false });
+ fireEvent.mouseOver(container.querySelector('li'));
+ expect(getByLabelText('Remove Layer')).toBeInTheDocument();
+ expect(getByLabelText('View Options')).toBeInTheDocument();
+ expect(getByLabelText('View Description')).toBeInTheDocument();
+ });
+
+ it('does not render remove button when isChartingActive', () => {
+ const { container, queryByLabelText } = renderComponent({ isChartingActive: true });
+ fireEvent.mouseOver(container.querySelector('li'));
+ expect(queryByLabelText('Remove Layer')).not.toBeInTheDocument();
+ });
+
+ it('does not render controls when isAnimating', () => {
+ const { container, queryByLabelText } = renderComponent({ isAnimating: true });
+ fireEvent.mouseOver(container.querySelector('li'));
+ expect(queryByLabelText('View Options')).not.toBeInTheDocument();
+ });
+
+ it('calls onOptionsClick with correct args', () => {
+ const onOptionsClick = jest.fn();
+ const { container, getByLabelText } = renderComponent({ isMobile: false, onOptionsClick });
+ fireEvent.mouseOver(container.querySelector('li'));
+ fireEvent.click(getByLabelText('View Options'));
+ expect(onOptionsClick).toHaveBeenCalledWith(defaultLayer, 'Test Layer', null);
+ });
+
+ it('calls onInfoClick with correct args', () => {
+ const onInfoClick = jest.fn();
+ const { container, getByLabelText } = renderComponent({ isMobile: false, onInfoClick });
+ fireEvent.mouseOver(container.querySelector('li'));
+ fireEvent.click(getByLabelText('View Description'));
+ expect(onInfoClick).toHaveBeenCalledWith(defaultLayer, 'Test Layer', 'description-path', 'https://example.com');
+ });
+});
+
+// ─── removeLayer ──────────────────────────────────────────────────────────────
+
+describe('removeLayer', () => {
+ it('calls onRemoveClick with layer.id on remove click', () => {
+ const onRemoveClick = jest.fn();
+ const { container, getByLabelText } = renderComponent({ onRemoveClick });
+ fireEvent.mouseOver(container.querySelector('li'));
+ fireEvent.click(getByLabelText('Remove Layer'));
+ expect(onRemoveClick).toHaveBeenCalledWith('layer1');
+ });
+
+ it('calls disableDDVLocationAlert when layer title is in ddvLocationAlerts', () => {
+ const disableDDVLocationAlert = jest.fn();
+ const { container, getByLabelText } = renderComponent({
+ disableDDVLocationAlert,
+ ddvLocationAlerts: ['Test Layer'],
+ });
+ fireEvent.mouseOver(container.querySelector('li'));
+ fireEvent.click(getByLabelText('Remove Layer'));
+ expect(disableDDVLocationAlert).toHaveBeenCalledWith('Test Layer');
+ });
+
+ it('calls disableDDVZoomAlert when layer title is in ddvZoomAlerts', () => {
+ const disableDDVZoomAlert = jest.fn();
+ const { container, getByLabelText } = renderComponent({
+ disableDDVZoomAlert,
+ ddvZoomAlerts: ['Test Layer'],
+ });
+ fireEvent.mouseOver(container.querySelector('li'));
+ fireEvent.click(getByLabelText('Remove Layer'));
+ expect(disableDDVZoomAlert).toHaveBeenCalledWith('Test Layer');
+ });
+});
+
+// ─── Dropdown menu ─────────────────────────────────────────────────────────────
+
+describe('Dropdown menu (isMobile)', () => {
+ it('toggles dropdown open on toggle click', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(getByTestId('dropdown')).toHaveAttribute('data-is-open', 'false');
+ fireEvent.click(getByTestId('dropdown-outer-toggle'));
+ expect(getByTestId('dropdown')).toHaveAttribute('data-is-open', 'true');
+ });
+
+ it('calls onInfoClick from dropdown info item', () => {
+ const onInfoClick = jest.fn();
+ const { getByTestId } = renderComponent({ isMobile: true, onInfoClick });
+ fireEvent.click(getByTestId('dropdown-item-layer-info-btn-layer1'));
+ expect(onInfoClick).toHaveBeenCalledWith(defaultLayer, 'Test Layer', 'description-path', 'https://example.com');
+ });
+
+ it('calls onOptionsClick from dropdown options item', () => {
+ const onOptionsClick = jest.fn();
+ const { getByTestId } = renderComponent({ isMobile: true, onOptionsClick });
+ fireEvent.click(getByTestId('dropdown-item-layer-options-btn-layer1'));
+ expect(onOptionsClick).toHaveBeenCalledWith(defaultLayer, 'Test Layer', null);
+ });
+
+ it('calls onRemoveClick from dropdown remove item', () => {
+ const onRemoveClick = jest.fn();
+ const { getByTestId } = renderComponent({ isMobile: true, onRemoveClick });
+ fireEvent.click(getByTestId('dropdown-item-close-activelayer1'));
+ expect(onRemoveClick).toHaveBeenCalledWith('layer1');
+ });
+
+ it('closes dropdown on second toggle', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ fireEvent.click(getByTestId('dropdown-outer-toggle'));
+ fireEvent.click(getByTestId('dropdown-outer-toggle'));
+ expect(getByTestId('dropdown')).toHaveAttribute('data-is-open', 'false');
+ });
+});
+
+// ─── Charting mode ────────────────────────────────────────────────────────────
+
+describe('Charting mode', () => {
+ it('renders radio button when isChartingActive and layer not shouldHide', () => {
+ const { container } = renderComponent({ isChartingActive: true });
+ expect(container.querySelector('[role="radio"]')).toBeInTheDocument();
+ });
+
+ it('radio button has active-chart class when layer matches activeChartingLayer', () => {
+ const { container } = renderComponent({ isChartingActive: true, activeChartingLayer: 'layer1' });
+ const radio = container.querySelector('[role="radio"]');
+ expect(radio).toHaveClass('active-chart');
+ expect(radio).toHaveAttribute('aria-checked', 'true');
+ });
+
+ it('radio button does not have active-chart for non-active layer', () => {
+ const { container } = renderComponent({ isChartingActive: true, activeChartingLayer: 'other' });
+ const radio = container.querySelector('[role="radio"]');
+ expect(radio).not.toHaveClass('active-chart');
+ expect(radio).toHaveAttribute('aria-checked', 'false');
+ });
+
+ it('calls updateActiveChartingLayer on radio click when not already active', () => {
+ const updateActiveChartingLayer = jest.fn();
+ const { container } = renderComponent({
+ isChartingActive: true,
+ activeChartingLayer: 'other',
+ updateActiveChartingLayer,
+ });
+ fireEvent.click(container.querySelector('[role="radio"]'));
+ expect(updateActiveChartingLayer).toHaveBeenCalledWith('layer1');
+ });
+
+ it('does not call updateActiveChartingLayer when layer already active', () => {
+ const updateActiveChartingLayer = jest.fn();
+ const { container } = renderComponent({
+ isChartingActive: true,
+ activeChartingLayer: 'layer1',
+ updateActiveChartingLayer,
+ });
+ fireEvent.click(container.querySelector('[role="radio"]'));
+ expect(updateActiveChartingLayer).not.toHaveBeenCalled();
+ });
+
+ it('calls updateActiveChartingLayer on Enter keydown', () => {
+ const updateActiveChartingLayer = jest.fn();
+ const { container } = renderComponent({
+ isChartingActive: true,
+ activeChartingLayer: 'other',
+ updateActiveChartingLayer,
+ });
+ fireEvent.keyDown(container.querySelector('[role="radio"]'), { key: 'Enter' });
+ expect(updateActiveChartingLayer).toHaveBeenCalledWith('layer1');
+ });
+
+ it('does not call updateActiveChartingLayer on non-Enter keydown', () => {
+ const updateActiveChartingLayer = jest.fn();
+ const { container } = renderComponent({
+ isChartingActive: true,
+ activeChartingLayer: 'other',
+ updateActiveChartingLayer,
+ });
+ fireEvent.keyDown(container.querySelector('[role="radio"]'), { key: 'Space' });
+ expect(updateActiveChartingLayer).not.toHaveBeenCalled();
+ });
+
+ it('renders visibility-class anchor when shouldHide and isChartingActive', () => {
+ const { container } = renderComponent({
+ isChartingActive: true,
+ layer: { ...defaultLayer, shouldHide: true },
+ });
+ expect(container.querySelector('a.visibility')).toBeInTheDocument();
+ });
+
+ it('renders faCircleDot when layer is active charting layer', () => {
+ const { getByTestId } = renderComponent({ isChartingActive: true, activeChartingLayer: 'layer1' });
+ expect(getByTestId('fa-faCircleDot')).toBeInTheDocument();
+ });
+
+ it('renders faCircle when layer is not active charting layer', () => {
+ const { getByTestId } = renderComponent({ isChartingActive: true, activeChartingLayer: 'other' });
+ expect(getByTestId('fa-faCircle')).toBeInTheDocument();
+ });
+});
+
+// ─── Vector layer icon ────────────────────────────────────────────────────────
+
+describe('Vector layer icon', () => {
+ it('renders when isVectorLayer and isVisible', () => {
+ const { container } = renderComponent({ isVectorLayer: true, isVisible: true });
+ expect(container.querySelector('.layer-pointer-icon')).toBeInTheDocument();
+ });
+
+ it('does not render when isVisible is false', () => {
+ const { container } = renderComponent({ isVectorLayer: true, isVisible: false });
+ expect(container.querySelector('.layer-pointer-icon')).not.toBeInTheDocument();
+ });
+
+ it('has disabled class when hasClickableFeature is false', () => {
+ const { container } = renderComponent({ isVectorLayer: true, isVisible: true, hasClickableFeature: false });
+ expect(container.querySelector('.layer-pointer-icon')).toHaveClass('disabled');
+ });
+
+ it('does not have disabled class when hasClickableFeature is true', () => {
+ const { container } = renderComponent({ isVectorLayer: true, isVisible: true, hasClickableFeature: true });
+ expect(container.querySelector('.layer-pointer-icon')).not.toHaveClass('disabled');
+ });
+
+ it('calls openVectorAlertModal on click', () => {
+ const openVectorAlertModal = jest.fn();
+ const { container } = renderComponent({ isVectorLayer: true, isVisible: true, openVectorAlertModal });
+ fireEvent.click(container.querySelector('.layer-pointer-icon'));
+ expect(openVectorAlertModal).toHaveBeenCalled();
+ });
+});
+
+// ─── Chartable icon ───────────────────────────────────────────────────────────
+
+describe('Chartable layer icon', () => {
+ it('renders when isChartableLayer, isVisible, and not isChartingActive', () => {
+ const { container } = renderComponent({ isChartableLayer: true, isVisible: true });
+ expect(container.querySelector('.layer-chartable-icon')).toBeInTheDocument();
+ });
+
+ it('does not render when isChartingActive', () => {
+ const { container } = renderComponent({ isChartableLayer: true, isVisible: true, isChartingActive: true });
+ expect(container.querySelector('.layer-chartable-icon')).not.toBeInTheDocument();
+ });
+
+ it('does not render when isVisible is false', () => {
+ const { container } = renderComponent({ isChartableLayer: true, isVisible: false });
+ expect(container.querySelector('.layer-chartable-icon')).not.toBeInTheDocument();
+ });
+});
+
+// ─── Palette legend ───────────────────────────────────────────────────────────
+
+describe('Palette legend', () => {
+ it('renders PaletteLegend when hasPalette and renderedPalette is not empty', () => {
+ const { getByTestId } = renderComponent({
+ hasPalette: true,
+ renderedPalette: { id: 'palette1', maps: [] },
+ });
+ expect(getByTestId('palette-legend-layer1')).toBeInTheDocument();
+ });
+
+ it('does not render when hasPalette is false', () => {
+ const { queryByTestId } = renderComponent({ hasPalette: false, renderedPalette: { id: 'p1' } });
+ expect(queryByTestId('palette-legend-layer1')).not.toBeInTheDocument();
+ });
+
+ it('does not render when renderedPalette is empty', () => {
+ const { queryByTestId } = renderComponent({ hasPalette: true, renderedPalette: {} });
+ expect(queryByTestId('palette-legend-layer1')).not.toBeInTheDocument();
+ });
+});
+
+// ─── Orbit tracks ─────────────────────────────────────────────────────────────
+
+describe('Orbit tracks', () => {
+ it('renders OrbitTrack for each track', () => {
+ const tracks = [{ id: 'track1' }, { id: 'track2' }];
+ const { getByTestId } = renderComponent({ tracksForLayer: tracks });
+ expect(getByTestId('orbit-track-track1')).toBeInTheDocument();
+ expect(getByTestId('orbit-track-track2')).toBeInTheDocument();
+ });
+
+ it('renders no OrbitTrack when tracksForLayer is empty', () => {
+ const { queryByTestId } = renderComponent({ tracksForLayer: [] });
+ expect(queryByTestId(/^orbit-track-/)).not.toBeInTheDocument();
+ });
+});
+
+// ─── Collection display ───────────────────────────────────────────────────────
+
+describe('Collection display', () => {
+ it('renders collection identifier when collections truthy and isVisible', () => {
+ const { container } = renderComponent({ collections: { version: '6.0', type: 'NRT' }, isVisible: true });
+ const span = container.querySelector('#collection-identifier');
+ expect(span).toBeInTheDocument();
+ expect(span.textContent).toContain('6.0');
+ expect(span.textContent).toContain('NRT');
+ });
+
+ it('does not render collection when isVisible is false', () => {
+ const { container } = renderComponent({ collections: { version: '6.0', type: 'NRT' }, isVisible: false });
+ expect(container.querySelector('#collection-identifier')).not.toBeInTheDocument();
+ });
+
+ it('uses bg-secondary badge for NRT type', () => {
+ const { container } = renderComponent({ collections: { version: '6.0', type: 'NRT' }, isVisible: true });
+ expect(container.querySelector('#collection-identifier').className).toContain('bg-secondary');
+ });
+
+ it('uses bg-light badge for non-NRT type', () => {
+ const { container } = renderComponent({ collections: { version: '6.0', type: 'STD' }, isVisible: true });
+ expect(container.querySelector('#collection-identifier').className).toContain('bg-light');
+ });
+});
+
+// ─── Sortable / drag ──────────────────────────────────────────────────────────
+
+describe('Drag style', () => {
+ it('applies zIndex 1 to li when isDragging', () => {
+ const { useSortable } = jest.requireMock('@dnd-kit/sortable');
+ useSortable.mockReturnValue({
+ attributes: {},
+ listeners: {},
+ setNodeRef: jest.fn(),
+ setActivatorNodeRef: jest.fn(),
+ transform: { x: 5, y: 10 },
+ transition: '200ms',
+ isDragging: true,
+ });
+ const { container } = renderComponent();
+ expect(container.querySelector('li').style.zIndex).toBe('1');
+ });
+
+ it('does not set zIndex when not dragging', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('li').style.zIndex).toBe('');
+ });
+});
+
+// ─── useEffects ────────────────────────────────────────────────────────────────
+
+describe('useEffects', () => {
+ it('registers MAP_RUNNING_DATA listener on mount', () => {
+ renderComponent();
+ expect(util.events.on).toHaveBeenCalledWith('map:running-data', expect.any(Function));
+ });
+
+ it('unregisters MAP_RUNNING_DATA listener on unmount', () => {
+ const { unmount } = renderComponent();
+ unmount();
+ expect(util.events.off).toHaveBeenCalledWith('map:running-data', expect.any(Function));
+ });
+
+ it('calls requestPalette when hasPalette and renderedPalette empty and not loading', () => {
+ const requestPalette = jest.fn();
+ renderComponent({ hasPalette: true, renderedPalette: {}, isLoading: false, requestPalette });
+ expect(requestPalette).toHaveBeenCalledWith('layer1');
+ });
+
+ it('does not call requestPalette when hasPalette false', () => {
+ const requestPalette = jest.fn();
+ renderComponent({ hasPalette: false, renderedPalette: {}, isLoading: false, requestPalette });
+ expect(requestPalette).not.toHaveBeenCalled();
+ });
+
+ it('does not call requestPalette when renderedPalette not empty', () => {
+ const requestPalette = jest.fn();
+ renderComponent({ hasPalette: true, renderedPalette: { maps: [] }, isLoading: false, requestPalette });
+ expect(requestPalette).not.toHaveBeenCalled();
+ });
+
+ it('does not call requestPalette when isLoading', () => {
+ const requestPalette = jest.fn();
+ renderComponent({ hasPalette: true, renderedPalette: {}, isLoading: true, requestPalette });
+ expect(requestPalette).not.toHaveBeenCalled();
+ });
+
+ it('shows buttons when isMobile prop changes from false to true', () => {
+ const { rerender, queryByTestId } = render(<LayerRow {...defaultProps} isMobile={false} />);
+ expect(queryByTestId('dropdown')).not.toBeInTheDocument();
+ rerender(<LayerRow {...defaultProps} isMobile />);
+ expect(queryByTestId('dropdown')).toBeInTheDocument();
+ });
+});
+
+// ─── mapStateToProps (factory) ────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ screenSize: { isMobileDevice: false },
+ palettes: { rendered: {}, custom: {}, isLoading: {} },
+ config: { layers: {}, features: {} },
+ embed: { isEmbedModeActive: false },
+ map: { ui: { selected: null }, extent: [-180, -90, 180, 90] },
+ compare: { active: false, activeString: 'active' },
+ proj: { id: 'EPSG:4326' },
+ ui: { isDistractionFreeModeActive: false },
+ settings: { globalTemperatureUnit: 'K' },
+ animation: { isPlaying: false },
+ layers: {},
+ date: { selected: new Date('2021-01-01'), selectedB: new Date('2021-06-01') },
+ alerts: { ddvZoomAlerts: [], ddvLocationAlerts: [] },
+ ...overrides,
+ });
+
+ const ownProps = {
+ layer: { id: 'layer1', palette: { id: 'palette1' } },
+ isVisible: true,
+ compareState: 'active',
+ };
+
+ it('maps isMobile from screenSize.isMobileDevice', () => {
+ const msp = capturedMakeMapStateToProps();
+ expect(msp(makeState({ screenSize: { isMobileDevice: true } }), ownProps).isMobile).toBe(true);
+ });
+
+ it('maps isEmbedModeActive from embed', () => {
+ const msp = capturedMakeMapStateToProps();
+ expect(msp(makeState({ embed: { isEmbedModeActive: true } }), ownProps).isEmbedModeActive).toBe(true);
+ });
+
+ it('maps isAnimating from animation.isPlaying', () => {
+ const msp = capturedMakeMapStateToProps();
+ expect(msp(makeState({ animation: { isPlaying: true } }), ownProps).isAnimating).toBe(true);
+ });
+
+ it('maps isDistractionFreeModeActive from ui', () => {
+ const msp = capturedMakeMapStateToProps();
+ expect(msp(makeState({ ui: { isDistractionFreeModeActive: true } }), ownProps).isDistractionFreeModeActive).toBe(true);
+ });
+
+ it('maps ddvZoomAlerts and ddvLocationAlerts', () => {
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState({ alerts: { ddvZoomAlerts: ['A'], ddvLocationAlerts: ['B'] } }),
+ ownProps,
+ );
+ expect(result.ddvZoomAlerts).toEqual(['A']);
+ expect(result.ddvLocationAlerts).toEqual(['B']);
+ });
+
+ it('hasPalette is true when layer.palette has id', () => {
+ const msp = capturedMakeMapStateToProps();
+ expect(msp(makeState(), ownProps).hasPalette).toBe(true);
+ });
+
+ it('hasPalette is false when layer.palette is empty', () => {
+ const msp = capturedMakeMapStateToProps();
+ expect(msp(makeState(), { ...ownProps, layer: { id: 'layer1', palette: {} } }).hasPalette).toBe(false);
+ });
+
+ it('maps compare from state.compare', () => {
+ const msp = capturedMakeMapStateToProps();
+ const compare = { active: true, activeString: 'active' };
+ expect(msp(makeState({ compare }), ownProps).compare).toEqual(compare);
+ });
+
+ it('maps map from state.map', () => {
+ const msp = capturedMakeMapStateToProps();
+ const mapState = { ui: { selected: null }, extent: [-180, -90, 180, 90] };
+ expect(msp(makeState({ map: mapState }), ownProps).map).toEqual(mapState);
+ });
+
+ it('isVectorLayer is true when layer.type is vector', () => {
+ const msp = capturedMakeMapStateToProps();
+ expect(msp(makeState(), { ...ownProps, layer: { id: 'layer1', type: 'vector', palette: {} } }).isVectorLayer).toBe(true);
+ });
+
+ it('isVectorLayer is false for non-vector type', () => {
+ const msp = capturedMakeMapStateToProps();
+ expect(msp(makeState(), ownProps).isVectorLayer).toBe(false);
+ });
+
+ it('selectedDate uses date.selected when activeString is active', () => {
+ const selected = new Date('2021-03-15');
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState({ compare: { active: false, activeString: 'active' }, date: { selected, selectedB: new Date() } }),
+ ownProps,
+ );
+ expect(result.selectedDate).toEqual(selected);
+ });
+
+ it('selectedDate uses date.selectedB when activeString is not active', () => {
+ const selectedB = new Date('2021-06-01');
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState({ compare: { active: false, activeString: 'activeB' }, date: { selected: new Date(), selectedB } }),
+ ownProps,
+ );
+ expect(result.selectedDate).toEqual(selectedB);
+ });
+
+ it('isCustomPalette truthy when palettes.custom has layer id', () => {
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState({ palettes: { rendered: {}, custom: { layer1: 'custom' }, isLoading: {} } }),
+ ownProps,
+ );
+ expect(result.isCustomPalette).toBeTruthy();
+ });
+
+ it('maps describeDomainsUrl from config', () => {
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState({ config: { layers: {}, features: { describeDomains: { url: 'https://gibs.example.com' } } } }),
+ ownProps,
+ );
+ expect(result.describeDomainsUrl).toBe('https://gibs.example.com');
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ it('toggleVisibility dispatches action', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).toggleVisibility('layer1', false);
+ expect(toggleVisibilityAction).toHaveBeenCalledWith('layer1', false);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_VISIBILITY' });
+ });
+
+ it('onRemoveClick dispatches removeLayerAction', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).onRemoveClick('layer1');
+ expect(removeLayerAction).toHaveBeenCalledWith('layer1');
+ expect(dispatch).toHaveBeenCalledWith({ type: 'REMOVE_LAYER' });
+ });
+
+ it('openVectorAlertModal dispatches openCustomContent', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).openVectorAlertModal();
+ expect(openCustomContent).toHaveBeenCalledWith('vector-modal', {});
+ expect(dispatch).toHaveBeenCalledWith({ type: 'OPEN_CUSTOM_CONTENT' });
+ });
+
+ it('openGranuleAlertModal dispatches openCustomContent', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).openGranuleAlertModal();
+ expect(openCustomContent).toHaveBeenCalledWith('granule-modal', {});
+ });
+
+ it('openZoomAlertModal dispatches openCustomContent', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).openZoomAlertModal();
+ expect(openCustomContent).toHaveBeenCalledWith('zoom-modal', {});
+ });
+
+ it('onOptionsClick dispatches toggleCustomContent', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).onOptionsClick(defaultLayer, 'Test Layer', null);
+ expect(toggleCustomContent).toHaveBeenCalled();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_CUSTOM_CONTENT' });
+ });
+
+ it('onInfoClick dispatches toggleCustomContent', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).onInfoClick(defaultLayer, 'Test Layer', 'desc', 'https://example.com');
+ expect(toggleCustomContent).toHaveBeenCalled();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_CUSTOM_CONTENT' });
+ });
+
+ it('requestPalette dispatches requestPaletteAction', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).requestPalette('layer1');
+ expect(requestPaletteAction).toHaveBeenCalledWith('layer1');
+ expect(dispatch).toHaveBeenCalledWith({ type: 'REQUEST_PALETTE' });
+ });
+
+ it('updateActiveChartingLayer dispatches action', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).updateActiveChartingLayer('layer1');
+ expect(updateActiveChartingLayerAction).toHaveBeenCalledWith('layer1');
+ });
+
+ it('enableDDVZoomAlert dispatches action', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).enableDDVZoomAlert('Layer');
+ expect(enableDDVZoomAlertAction).toHaveBeenCalledWith('Layer');
+ });
+
+ it('disableDDVZoomAlert dispatches action', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).disableDDVZoomAlert('Layer');
+ expect(disableDDVZoomAlertAction).toHaveBeenCalledWith('Layer');
+ });
+
+ it('enableDDVLocationAlert dispatches action', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).enableDDVLocationAlert('Layer');
+ expect(enableDDVLocationAlertAction).toHaveBeenCalledWith('Layer');
+ });
+
+ it('disableDDVLocationAlert dispatches action', () => {
+ const dispatch = jest.fn();
+ capturedMapDispatchToProps(dispatch).disableDDVLocationAlert('Layer');
+ expect(disableDDVLocationAlertAction).toHaveBeenCalledWith('Layer');
+ });
+});
+
+// ─── stopDndActivation and stopPropagation ────────────────────────────────────
+
+describe('stopDndActivation and stopPropagation', () => {
+ it('stopDndActivation fires without error on dropdown toggle pointerDown', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(() => fireEvent.pointerDown(getByTestId('dropdown-toggle'))).not.toThrow();
+ });
+
+ it('stopDndActivation fires without error on dropdown toggle mouseDown', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(() => fireEvent.mouseDown(getByTestId('dropdown-toggle'))).not.toThrow();
+ });
+
+ it('stopPropagation fires without error on options button mouseDown', () => {
+ const { container, getByLabelText } = renderComponent({ isMobile: false });
+ fireEvent.mouseOver(container.querySelector('li'));
+ expect(() => fireEvent.mouseDown(getByLabelText('View Options'))).not.toThrow();
+ });
+
+ it('stopPropagation fires without error on info button mouseDown', () => {
+ const { container, getByLabelText } = renderComponent({ isMobile: false });
+ fireEvent.mouseOver(container.querySelector('li'));
+ expect(() => fireEvent.mouseDown(getByLabelText('View Description'))).not.toThrow();
+ });
+});
+
+// ─── Palette legend embed mode ────────────────────────────────────────────────
+
+describe('Palette legend embed mode', () => {
+ it('renders PaletteLegend in embed mode', () => {
+ const { getByTestId } = renderComponent({
+ hasPalette: true,
+ renderedPalette: { id: 'palette1', maps: [] },
+ isEmbedModeActive: true,
+ });
+ expect(getByTestId('palette-legend-layer1')).toBeInTheDocument();
+ });
+
+ it('renders PaletteLegend with compare.active=true path', () => {
+ const { getByTestId } = renderComponent({
+ hasPalette: true,
+ renderedPalette: { id: 'palette1', maps: [] },
+ compare: { active: true, activeString: 'active' },
+ });
+ expect(getByTestId('palette-legend-layer1')).toBeInTheDocument();
+ });
+});
+
+// ─── DDV alert effects (initial render) ──────────────────────────────────────
+
+describe('DDV alert effects', () => {
+ it('calls disableDDVZoomAlert when titiler layer is already in zoom alerts on mount', () => {
+ const disableDDVZoomAlert = jest.fn();
+ renderComponent({
+ layer: { ...defaultLayer, type: 'titiler' },
+ ddvZoomAlerts: ['Test Layer'],
+ disableDDVZoomAlert,
+ });
+ expect(disableDDVZoomAlert).toHaveBeenCalledWith('Test Layer');
+ });
+
+ it('calls disableDDVLocationAlert when titiler layer is already in location alerts on mount', () => {
+ const disableDDVLocationAlert = jest.fn();
+ renderComponent({
+ layer: { ...defaultLayer, type: 'titiler' },
+ ddvLocationAlerts: ['Test Layer'],
+ disableDDVLocationAlert,
+ });
+ expect(disableDDVLocationAlert).toHaveBeenCalledWith('Test Layer');
+ });
+});
+
+// ─── Async CMR effect ─────────────────────────────────────────────────────────
+
+describe('Async CMR effect', () => {
+ const cmrLayer = {
+ ...defaultLayer,
+ enableCMRDataFinder: true,
+ conceptIds: [{ value: 'C123' }],
+ };
+
+ beforeEach(() => {
+ const { cmrFetch } = jest.requireMock('../../util/cmr');
+ cmrFetch.mockResolvedValue({
+ ok: true,
+ json: jest.fn().mockResolvedValue({ feed: { entry: [] } }),
+ });
+ });
+
+ it('does not run CMR fetch when layer.enableCMRDataFinder is false', () => {
+ const { cmrFetch } = jest.requireMock('../../util/cmr');
+ renderComponent({ layer: { ...defaultLayer, enableCMRDataFinder: false }, isVisible: true });
+ expect(cmrFetch).not.toHaveBeenCalled();
+ });
+
+ it('does not run CMR fetch when isVisible is false', () => {
+ const { cmrFetch } = jest.requireMock('../../util/cmr');
+ renderComponent({ layer: cmrLayer, isVisible: false });
+ expect(cmrFetch).not.toHaveBeenCalled();
+ });
+
+ it('shows granule alert when CMR returns empty entries', async () => {
+ const { findByTestId } = renderComponent({ layer: cmrLayer, isVisible: true, zot: null });
+ await findByTestId('alert-granule-alert');
+ });
+
+ it('shows zoom alert when zot.underZoomValue > 0 and CMR returns empty entries', async () => {
+ const { findByTestId } = renderComponent({
+ layer: cmrLayer,
+ isVisible: true,
+ zot: { underZoomValue: 1 },
+ });
+ await findByTestId('alert-zoom-alert');
+ });
+
+ it('dismisses granule alert on dismiss click', async () => {
+ const { findByTestId, queryByTestId } = renderComponent({
+ layer: cmrLayer,
+ isVisible: true,
+ zot: null,
+ });
+ const btn = await findByTestId('alert-dismiss-granule-alert');
+ fireEvent.click(btn);
+ expect(queryByTestId('alert-granule-alert')).not.toBeInTheDocument();
+ });
+
+ it('dismisses zoom alert on dismiss click', async () => {
+ const { findByTestId, queryByTestId } = renderComponent({
+ layer: cmrLayer,
+ isVisible: true,
+ zot: { underZoomValue: 1 },
+ });
+ const btn = await findByTestId('alert-dismiss-zoom-alert');
+ fireEvent.click(btn);
+ expect(queryByTestId('alert-zoom-alert')).not.toBeInTheDocument();
+ });
+
+ it('calls enableDDVZoomAlert for dismissable layer when zoom alert activates', async () => {
+ const enableDDVZoomAlert = jest.fn();
+ renderComponent({
+ layer: { ...cmrLayer, type: 'titiler' },
+ isVisible: true,
+ zot: { underZoomValue: 1 },
+ enableDDVZoomAlert,
+ ddvZoomAlerts: [],
+ });
+ await waitFor(() => expect(enableDDVZoomAlert).toHaveBeenCalledWith('Test Layer'));
+ });
+
+ it('calls enableDDVLocationAlert for dismissable layer when granule alert activates', async () => {
+ const enableDDVLocationAlert = jest.fn();
+ renderComponent({
+ layer: { ...cmrLayer, type: 'titiler' },
+ isVisible: true,
+ zot: null,
+ enableDDVLocationAlert,
+ ddvLocationAlerts: [],
+ });
+ await waitFor(() => expect(enableDDVLocationAlert).toHaveBeenCalledWith('Test Layer'));
+ });
+
+ it('does not show alerts when CMR response is not ok', async () => {
+ const { cmrFetch } = jest.requireMock('../../util/cmr');
+ cmrFetch.mockResolvedValue({ ok: false });
+ const { queryByTestId } = renderComponent({ layer: cmrLayer, isVisible: true });
+ await waitFor(() => expect(cmrFetch).toHaveBeenCalled());
+ expect(queryByTestId('alert-granule-alert')).not.toBeInTheDocument();
+ });
+});
+
+// ─── Additional mapStateToProps branches ──────────────────────────────────────
+
+describe('mapStateToProps additional', () => {
+ const makeState = (overrides = {}) => ({
+ screenSize: { isMobileDevice: false },
+ palettes: { rendered: {}, custom: {}, isLoading: {} },
+ config: { layers: {}, features: {} },
+ embed: { isEmbedModeActive: false },
+ map: { ui: { selected: null }, extent: [-180, -90, 180, 90] },
+ compare: { active: false, activeString: 'active' },
+ proj: { id: 'EPSG:4326' },
+ ui: { isDistractionFreeModeActive: false },
+ settings: { globalTemperatureUnit: 'K' },
+ animation: { isPlaying: false },
+ layers: {},
+ date: { selected: new Date('2021-01-01'), selectedB: new Date('2021-06-01') },
+ alerts: { ddvZoomAlerts: [], ddvLocationAlerts: [] },
+ ...overrides,
+ });
+
+ it('isChartableLayer true when all charting conditions met', () => {
+ const msp = capturedMakeMapStateToProps();
+ const layer = {
+ id: 'layer1',
+ palette: { id: 'palette1' },
+ layerPeriod: 'Daily',
+ disableCharting: false,
+ };
+ const state = makeState({
+ palettes: {
+ rendered: { palette1: { maps: [{ type: 'continuous' }] } },
+ custom: {},
+ isLoading: {},
+ },
+ });
+ expect(msp(state, { layer, isVisible: true, compareState: 'active' }).isChartableLayer).toBe(true);
+ });
+
+ it('isChartableLayer false when palette type is not continuous', () => {
+ const msp = capturedMakeMapStateToProps();
+ const layer = { id: 'layer1', palette: { id: 'palette1' }, layerPeriod: 'Daily' };
+ const state = makeState({
+ palettes: {
+ rendered: { palette1: { maps: [{ type: 'classification' }] } },
+ custom: {},
+ isLoading: {},
+ },
+ });
+ expect(msp(state, { layer, isVisible: true, compareState: 'active' }).isChartableLayer).toBe(false);
+ });
+
+ it('hasClickableFeature true when vector, visible, and isVectorLayerClickable returns true', () => {
+ const { isVectorLayerClickable } = jest.requireMock('../../modules/layers/util');
+ isVectorLayerClickable.mockReturnValue(true);
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState(),
+ { layer: { id: 'layer1', type: 'vector', palette: {} }, isVisible: true, compareState: 'active' },
+ );
+ expect(result.hasClickableFeature).toBe(true);
+ });
+
+ it('hasClickableFeature false when isVectorLayerClickable returns false', () => {
+ const { isVectorLayerClickable } = jest.requireMock('../../modules/layers/util');
+ isVectorLayerClickable.mockReturnValue(false);
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState(),
+ { layer: { id: 'layer1', type: 'vector', palette: {} }, isVisible: true, compareState: 'active' },
+ );
+ expect(result.hasClickableFeature).toBe(false);
+ });
+
+ it('globalTemperatureUnit is empty when layer.disableUnitConversion is truthy', () => {
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState({ settings: { globalTemperatureUnit: 'K' } }),
+ { layer: { id: 'layer1', palette: {}, disableUnitConversion: true }, isVisible: true, compareState: 'active' },
+ );
+ expect(result.globalTemperatureUnit).toBe('');
+ });
+
+ it('tracksForLayer filters active layers matching orbitTracks', () => {
+ const { getActiveLayers } = jest.requireMock('../../modules/layers/selectors');
+ getActiveLayers.mockReturnValue([{ id: 'track1' }, { id: 'other' }]);
+ const msp = capturedMakeMapStateToProps();
+ const result = msp(
+ makeState(),
+ { layer: { id: 'layer1', palette: {}, orbitTracks: ['track1'] }, isVisible: true, compareState: 'active' },
+ );
+ expect(result.tracksForLayer).toEqual([{ id: 'track1' }]);
+ });
});
diff --git a/web/js/containers/sidebar/layers-container.test.js b/web/js/containers/sidebar/layers-container.test.js
index ab3bef99d..895ba649f 100644
--- a/web/js/containers/sidebar/layers-container.test.js
+++ b/web/js/containers/sidebar/layers-container.test.js
@@ -1,3 +1,699 @@
-test('layers-container container test', () => {
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// ─── Mock DnD ────────────────────────────────────────────────────────────────
+
+let mockUseSortableReturn = {
+ attributes: {},
+ listeners: {},
+ setNodeRef: jest.fn(),
+ setActivatorNodeRef: jest.fn(),
+ transform: null,
+ transition: undefined,
+ isDragging: false,
+};
+
+jest.mock('@dnd-kit/core', () => {
+ const React = require('react');
+ return {
+ DndContext: ({ children, onDragEnd }) => {
+ global.__capturedOnDragEnd = onDragEnd;
+ return React.createElement('div', { 'data-testid': 'dnd-context' }, children);
+ },
+ closestCenter: {},
+ };
+});
+
+jest.mock('@dnd-kit/sortable', () => {
+ const React = require('react');
+ return {
+ SortableContext: ({ children }) => React.createElement('div', { 'data-testid': 'sortable-context' }, children),
+ verticalListSortingStrategy: {},
+ arrayMove: jest.fn((arr, from, to) => {
+ const result = [...arr];
+ const [item] = result.splice(from, 1);
+ result.splice(to, 0, item);
+ return result;
+ }),
+ useSortable: jest.fn(() => mockUseSortableReturn),
+ };
+});
+
+// ─── Mock react-redux ─────────────────────────────────────────────────────────
+
+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 };
+});
+
+// ─── Mock LayerList ───────────────────────────────────────────────────────────
+
+jest.mock('./layer-list', () => function MockLayerList({
+ title, groupId, collapsed, compareState, layerSplit, layers, dragHandleProps, toggleCollapse,
+}) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': `layer-list-${groupId}`,
+ 'data-title': title,
+ 'data-collapsed': String(collapsed),
+ 'data-compare-state': compareState,
+ 'data-layer-split': String(layerSplit),
+ 'data-layers-count': layers ? String(layers.length) : '0',
+ onClick: toggleCollapse,
+ });
+});
+
+// ─── Mock util ────────────────────────────────────────────────────────────────
+
+jest.mock('../../util/util', () => ({
+ cleanId: jest.fn((id) => id.replace(/\s+/g, '-').toLowerCase()),
+}));
+
+// ─── Mock selectors ───────────────────────────────────────────────────────────
+
+jest.mock('../../modules/layers/selectors', () => ({
+ getAllActiveOverlaysBaselayers: jest.fn(() => ({
+ baselayers: [{ id: 'base1', visible: true }],
+ overlays: [
+ { id: 'overlay1', visible: true, layergroup: 'Overlays' },
+ { id: 'overlay2', visible: false, layergroup: 'Reference' },
+ ],
+ })),
+ getActiveOverlayGroups: jest.fn(() => [
+ { groupName: 'Group A', layers: ['overlay1'], collapsed: false },
+ { groupName: 'Group B', layers: ['overlay2'], collapsed: true },
+ ]),
+ getActiveLayersMap: jest.fn(() => ({
+ overlay1: { id: 'overlay1', visible: true, layergroup: 'Overlays' },
+ overlay2: { id: 'overlay2', visible: false, layergroup: 'Reference' },
+ base1: { id: 'base1', visible: true },
+ })),
+ getFilteredOverlayGroups: jest.fn((groups, overlays) => {
+ return groups.filter((g) => g.layers.some((id) => overlays.find((o) => o.id === id)));
+ }),
+}));
+
+// ─── Mock actions ─────────────────────────────────────────────────────────────
+
+jest.mock('../../modules/layers/actions', () => ({
+ reorderOverlayGroups: jest.fn(() => ({ type: 'REORDER_OVERLAY_GROUPS' })),
+ toggleGroupCollapsed: jest.fn(() => ({ type: 'TOGGLE_GROUP_COLLAPSED' })),
+}));
+
+jest.mock('../../modules/modal/actions', () => ({
+ openCustomContent: jest.fn(() => ({ type: 'OPEN_CUSTOM_CONTENT' })),
+}));
+
+jest.mock('../../modules/animation/actions', () => ({
+ stop: jest.fn(() => ({ type: 'STOP_ANIMATION' })),
+}));
+
+// ─── Mock react-device-detect ─────────────────────────────────────────────────
+
+jest.mock('react-device-detect', () => ({
+ isMobileOnly: false,
+ isTablet: false,
+}));
+
+// ─── Mock SearchUiProvider ────────────────────────────────────────────────────
+
+jest.mock('../../components/layer/product-picker/search-ui-provider', () => function MockSearchUiProvider() {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'search-ui-provider' });
+});
+
+// ─── Imports after mocks ──────────────────────────────────────────────────────
+
+import LayersContainer from './layers-container';
+import { arrayMove } from '@dnd-kit/sortable';
+import {
+ getAllActiveOverlaysBaselayers,
+ getActiveOverlayGroups,
+ getActiveLayersMap,
+ getFilteredOverlayGroups,
+} from '../../modules/layers/selectors';
+import {
+ reorderOverlayGroups as reorderOverlayGroupsAction,
+ toggleGroupCollapsed as toggleGroupCollapsedAction,
+} from '../../modules/layers/actions';
+import { openCustomContent } from '../../modules/modal/actions';
+import { stop as stopAnimationAction } from '../../modules/animation/actions';
+
+// ─── Shared captured connect ──────────────────────────────────────────────────
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ delete global.__capturedOnDragEnd;
+ mockUseSortableReturn = {
+ attributes: {},
+ listeners: {},
+ setNodeRef: jest.fn(),
+ setActivatorNodeRef: jest.fn(),
+ transform: null,
+ transition: undefined,
+ isDragging: false,
+ };
+ const { useSortable } = jest.requireMock('@dnd-kit/sortable');
+ useSortable.mockImplementation(() => mockUseSortableReturn);
+});
+
+// ─── Shared fixtures ──────────────────────────────────────────────────────────
+
+const defaultOverlays = [
+ { id: 'overlay1', visible: true, layergroup: 'Overlays' },
+ { id: 'overlay2', visible: false, layergroup: 'Reference' },
+];
+
+const defaultBaselayers = [
+ { id: 'base1', visible: true },
+];
+
+const defaultOverlayGroups = [
+ { groupName: 'Group A', layers: ['overlay1'], collapsed: false },
+ { groupName: 'Group B', layers: ['overlay2'], collapsed: true },
+];
+
+const defaultActiveLayersMap = {
+ overlay1: { id: 'overlay1', visible: true, layergroup: 'Overlays' },
+ overlay2: { id: 'overlay2', visible: false, layergroup: 'Reference' },
+ base1: { id: 'base1', visible: true },
+};
+
+const defaultProps = {
+ activeLayersMap: defaultActiveLayersMap,
+ baselayers: defaultBaselayers,
+ compareState: 'active',
+ groupOverlays: false,
+ height: 400,
+ isActive: true,
+ isAnimating: false,
+ isEmbedModeActive: false,
+ overlayGroups: defaultOverlayGroups,
+ overlays: defaultOverlays,
+ reorderOverlayGroups: jest.fn(),
+ toggleCollapse: jest.fn(),
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <LayersContainer {...defaultProps} {...propOverrides} />,
+);
+
+// ─── LayersContainer – active/inactive ───────────────────────────────────────
+
+describe('LayersContainer active/inactive', () => {
+ it('renders nothing when isActive is false', () => {
+ const { container } = renderComponent({ isActive: false });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders scroll container when isActive is true', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#layers-scroll-container')).toBeInTheDocument();
+ });
+});
+
+// ─── LayersContainer – scroll container styles ────────────────────────────────
+
+describe('LayersContainer scroll container styles', () => {
+ it('sets minHeight to 100px and maxHeight to height+px in normal mode', () => {
+ const { container } = renderComponent({ height: 350 });
+ const el = container.querySelector('#layers-scroll-container');
+ expect(el.style.minHeight).toBe('100px');
+ expect(el.style.maxHeight).toBe('350px');
+ });
+
+ it('sets minHeight to 25px and maxHeight to 55vh in embed mode', () => {
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ const el = container.querySelector('#layers-scroll-container');
+ expect(el.style.minHeight).toBe('25px');
+ expect(el.style.maxHeight).toBe('55vh');
+ });
+
+ it('always sets overflowY to auto', () => {
+ const { container } = renderComponent();
+ const el = container.querySelector('#layers-scroll-container');
+ expect(el.style.overflowY).toBe('auto');
+ });
+});
+
+// ─── LayersContainer – overlay rendering ─────────────────────────────────────
+
+describe('LayersContainer overlay rendering', () => {
+ it('renders overlays LayerList when groupOverlays is false', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: false });
+ expect(getByTestId('layer-list-overlays')).toBeInTheDocument();
+ });
+
+ it('renders DndContext when groupOverlays is true', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: true });
+ expect(getByTestId('dnd-context')).toBeInTheDocument();
+ });
+
+ it('renders SortableContext with group names when groupOverlays is true', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: true });
+ expect(getByTestId('sortable-context')).toBeInTheDocument();
+ });
+
+ it('renders a SortableOverlayGroup for each overlayGroup', () => {
+ const { getAllByTestId } = renderComponent({ groupOverlays: true });
+ // SortableOverlayGroup renders LayerList for each group
+ const lists = getAllByTestId(/^layer-list-Group/);
+ expect(lists).toHaveLength(2);
+ });
+
+ it('does not render DndContext when groupOverlays is false', () => {
+ const { queryByTestId } = renderComponent({ groupOverlays: false });
+ expect(queryByTestId('dnd-context')).not.toBeInTheDocument();
+ });
+
+ it('hides overlays LayerList in embed mode when overlays is empty', () => {
+ const { queryByTestId } = renderComponent({
+ isEmbedModeActive: true,
+ overlays: [],
+ groupOverlays: false,
+ });
+ expect(queryByTestId('layer-list-overlays')).not.toBeInTheDocument();
+ });
+
+ it('shows overlays LayerList in embed mode when overlays is non-empty', () => {
+ const { getByTestId } = renderComponent({
+ isEmbedModeActive: true,
+ overlays: defaultOverlays,
+ groupOverlays: false,
+ });
+ expect(getByTestId('layer-list-overlays')).toBeInTheDocument();
+ });
+
+ it('passes overlays.length as layerSplit to the overlays LayerList', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: false });
+ expect(getByTestId('layer-list-overlays')).toHaveAttribute('data-layer-split', String(defaultOverlays.length));
+ });
+});
+
+// ─── LayersContainer – baselayer rendering ───────────────────────────────────
+
+describe('LayersContainer baselayer rendering', () => {
+ it('renders baselayers LayerList', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('layer-list-baselayers')).toBeInTheDocument();
+ });
+
+ it('hides baselayers in embed mode when baselayers is empty', () => {
+ const { queryByTestId } = renderComponent({
+ isEmbedModeActive: true,
+ baselayers: [],
+ });
+ expect(queryByTestId('layer-list-baselayers')).not.toBeInTheDocument();
+ });
+
+ it('shows baselayers in embed mode when baselayers is non-empty', () => {
+ const { getByTestId } = renderComponent({
+ isEmbedModeActive: true,
+ baselayers: defaultBaselayers,
+ });
+ expect(getByTestId('layer-list-baselayers')).toBeInTheDocument();
+ });
+
+ it('passes overlays.length as layerSplit to baselayers LayerList', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('layer-list-baselayers')).toHaveAttribute('data-layer-split', String(defaultOverlays.length));
+ });
+
+ it('passes compareState to baselayers LayerList', () => {
+ const { getByTestId } = renderComponent({ compareState: 'activeB' });
+ expect(getByTestId('layer-list-baselayers')).toHaveAttribute('data-compare-state', 'activeB');
+ });
+});
+
+// ─── LayersContainer – overlaysCollapsed toggle ───────────────────────────────
+
+describe('LayersContainer collapse toggles', () => {
+ it('overlaysCollapsed starts false', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: false });
+ expect(getByTestId('layer-list-overlays')).toHaveAttribute('data-collapsed', 'false');
+ });
+
+ it('toggles overlaysCollapsed when overlays LayerList onClick fires', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: false });
+ fireEvent.click(getByTestId('layer-list-overlays'));
+ expect(getByTestId('layer-list-overlays')).toHaveAttribute('data-collapsed', 'true');
+ });
+
+ it('baselayersCollapsed starts false', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('layer-list-baselayers')).toHaveAttribute('data-collapsed', 'false');
+ });
+
+ it('toggles baselayersCollapsed when baselayers LayerList onClick fires', () => {
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('layer-list-baselayers'));
+ expect(getByTestId('layer-list-baselayers')).toHaveAttribute('data-collapsed', 'true');
+ });
+
+ it('toggles back to false on second click for overlays', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: false });
+ fireEvent.click(getByTestId('layer-list-overlays'));
+ fireEvent.click(getByTestId('layer-list-overlays'));
+ expect(getByTestId('layer-list-overlays')).toHaveAttribute('data-collapsed', 'false');
+ });
+});
+
+// ─── LayersContainer – onDragEnd ─────────────────────────────────────────────
+
+describe('LayersContainer onDragEnd', () => {
+ it('returns early when over is null', () => {
+ const reorderOverlayGroups = jest.fn();
+ renderComponent({ groupOverlays: true, reorderOverlayGroups });
+ global.__capturedOnDragEnd({ active: { id: 'Group A' }, over: null });
+ expect(reorderOverlayGroups).not.toHaveBeenCalled();
+ });
+
+ it('returns early when active.id equals over.id', () => {
+ const reorderOverlayGroups = jest.fn();
+ renderComponent({ groupOverlays: true, reorderOverlayGroups });
+ global.__capturedOnDragEnd({ active: { id: 'Group A' }, over: { id: 'Group A' } });
+ expect(reorderOverlayGroups).not.toHaveBeenCalled();
+ });
+
+ it('returns early when source group is not found', () => {
+ const reorderOverlayGroups = jest.fn();
+ renderComponent({ groupOverlays: true, reorderOverlayGroups });
+ global.__capturedOnDragEnd({ active: { id: 'Unknown Group' }, over: { id: 'Group B' } });
+ expect(reorderOverlayGroups).not.toHaveBeenCalled();
+ });
+
+ it('returns early when destination group is not found', () => {
+ const reorderOverlayGroups = jest.fn();
+ renderComponent({ groupOverlays: true, reorderOverlayGroups });
+ global.__capturedOnDragEnd({ active: { id: 'Group A' }, over: { id: 'Unknown Group' } });
+ expect(reorderOverlayGroups).not.toHaveBeenCalled();
+ });
+
+ it('calls arrayMove and reorderOverlayGroups on valid drag', () => {
+ const reorderOverlayGroups = jest.fn();
+ renderComponent({ groupOverlays: true, reorderOverlayGroups });
+ global.__capturedOnDragEnd({ active: { id: 'Group A' }, over: { id: 'Group B' } });
+ expect(arrayMove).toHaveBeenCalled();
+ expect(reorderOverlayGroups).toHaveBeenCalledTimes(1);
+ });
+
+ it('passes reordered layers concatenated with baselayers to reorderOverlayGroups', () => {
+ const reorderOverlayGroups = jest.fn();
+ renderComponent({ groupOverlays: true, reorderOverlayGroups });
+ global.__capturedOnDragEnd({ active: { id: 'Group A' }, over: { id: 'Group B' } });
+ const [newLayers] = reorderOverlayGroups.mock.calls[0];
+ // Should end with the baselayer
+ expect(newLayers[newLayers.length - 1]).toEqual(defaultBaselayers[0]);
+ });
+
+ it('passes reordered groups as second argument to reorderOverlayGroups', () => {
+ const reorderOverlayGroups = jest.fn();
+ renderComponent({ groupOverlays: true, reorderOverlayGroups });
+ global.__capturedOnDragEnd({ active: { id: 'Group A' }, over: { id: 'Group B' } });
+ const [, newGroups] = reorderOverlayGroups.mock.calls[0];
+ expect(Array.isArray(newGroups)).toBe(true);
+ expect(newGroups).toHaveLength(2);
+ });
+});
+
+// ─── SortableOverlayGroup – rendered via LayersContainer ─────────────────────
+
+describe('SortableOverlayGroup rendering', () => {
+ it('renders li with id combining compareState and groupName', () => {
+ const { container } = renderComponent({ groupOverlays: true, compareState: 'active' });
+ expect(container.querySelector('#active-group-a')).toBeInTheDocument();
+ });
+
+ it('renders LayerList inside each group li', () => {
+ const { getAllByTestId } = renderComponent({ groupOverlays: true });
+ expect(getAllByTestId(/^layer-list-Group/)).toHaveLength(2);
+ });
+
+ it('passes groupName as title to LayerList', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: true });
+ expect(getByTestId('layer-list-Group A')).toHaveAttribute('data-title', 'Group A');
+ });
+
+ it('passes collapsed from group to LayerList', () => {
+ const { getByTestId } = renderComponent({ groupOverlays: true });
+ expect(getByTestId('layer-list-Group A')).toHaveAttribute('data-collapsed', 'false');
+ expect(getByTestId('layer-list-Group B')).toHaveAttribute('data-collapsed', 'true');
+ });
+
+ it('returns null when group has no layers property', () => {
+ const groups = [{ groupName: 'Empty Group', layers: null, collapsed: false }];
+ const { queryByTestId } = renderComponent({
+ groupOverlays: true,
+ overlayGroups: groups,
+ });
+ expect(queryByTestId('layer-list-Empty Group')).not.toBeInTheDocument();
+ });
+
+ it('applies transform style when useSortable returns a transform', () => {
+ const { useSortable } = jest.requireMock('@dnd-kit/sortable');
+ useSortable.mockReturnValue({
+ ...mockUseSortableReturn,
+ transform: { x: 10, y: 20 },
+ transition: 'transform 200ms',
+ });
+ const { container } = renderComponent({ groupOverlays: true });
+ const li = container.querySelector('li');
+ expect(li.style.transform).toBe('translate3d(10px, 20px, 0)');
+ expect(li.style.transition).toBe('transform 200ms');
+ });
+
+ it('applies opacity style when isDragging is true', () => {
+ const { useSortable } = jest.requireMock('@dnd-kit/sortable');
+ useSortable.mockReturnValue({
+ ...mockUseSortableReturn,
+ isDragging: true,
+ });
+ const { container } = renderComponent({ groupOverlays: true });
+ const li = container.querySelector('li');
+ expect(li.style.opacity).toBe('0.8');
+ });
+
+ it('does not set opacity style when isDragging is false', () => {
+ const { container } = renderComponent({ groupOverlays: true });
+ const li = container.querySelector('li');
+ expect(li.style.opacity).toBe('');
+ });
+
+ it('disables useSortable when isEmbedModeActive is true', () => {
+ const { useSortable } = jest.requireMock('@dnd-kit/sortable');
+ renderComponent({ groupOverlays: true, isEmbedModeActive: true });
+ const callArg = useSortable.mock.calls[0][0];
+ expect(callArg.disabled).toBe(true);
+ });
+
+ it('disables useSortable when isAnimating is true', () => {
+ const { useSortable } = jest.requireMock('@dnd-kit/sortable');
+ renderComponent({ groupOverlays: true, isAnimating: true });
+ const callArg = useSortable.mock.calls[0][0];
+ expect(callArg.disabled).toBe(true);
+ });
+
+ it('enables useSortable when neither embed nor animating', () => {
+ const { useSortable } = jest.requireMock('@dnd-kit/sortable');
+ renderComponent({ groupOverlays: true, isEmbedModeActive: false, isAnimating: false });
+ const callArg = useSortable.mock.calls[0][0];
+ expect(callArg.disabled).toBe(false);
+ });
+});
+
+// ─── mapStateToProps ──────────────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ compare: { active: false },
+ embed: { isEmbedModeActive: false },
+ layers: {
+ active: { groupOverlays: true },
+ activeB: { groupOverlays: false },
+ },
+ animation: { isPlaying: false },
+ screenSize: { isMobileDevice: false, breakpoints: {}, screenWidth: 1024 },
+ ...overrides,
+ });
+
+ 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 isEmbedModeActive from embed.isEmbedModeActive', () => {
+ 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, breakpoints: {}, screenWidth: 400 },
+ });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.isMobile).toBe(true);
+ });
+
+ it('maps breakpoints from screenSize.breakpoints', () => {
+ const bp = { sm: 576, md: 768 };
+ const state = makeState({
+ screenSize: { isMobileDevice: false, breakpoints: bp, screenWidth: 1024 },
+ });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.breakpoints).toEqual(bp);
+ });
+
+ it('maps screenWidth from screenSize.screenWidth', () => {
+ const state = makeState({
+ screenSize: { isMobileDevice: false, breakpoints: {}, screenWidth: 800 },
+ });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.screenWidth).toBe(800);
+ });
+
+ it('uses compareState from ownProps to read groupOverlays', () => {
+ const result = capturedMapStateToProps(makeState(), { compareState: 'activeB' });
+ expect(result.groupOverlays).toBe(false);
+ });
+
+ it('calls getAllActiveOverlaysBaselayers and returns baselayers and overlays', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(getAllActiveOverlaysBaselayers).toHaveBeenCalledWith(state);
+ expect(result.baselayers).toEqual([{ id: 'base1', visible: true }]);
+ expect(result.overlays.length).toBe(2);
+ });
+
+ it('calls getActiveLayersMap and returns activeLayersMap', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(getActiveLayersMap).toHaveBeenCalledWith(state);
+ expect(result.activeLayersMap).toBeDefined();
+ });
+
+ it('returns empty overlayGroups when groupOverlays is false', () => {
+ const result = capturedMapStateToProps(makeState(), { compareState: 'activeB' });
+ expect(result.overlayGroups).toEqual([]);
+ expect(getActiveOverlayGroups).not.toHaveBeenCalled();
+ });
+
+ it('calls getActiveOverlayGroups when groupOverlays is true', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(getActiveOverlayGroups).toHaveBeenCalledWith(state);
+ expect(result.overlayGroups.length).toBeGreaterThan(0);
+ });
+
+ it('filters baselayers to visible only in embed mode', () => {
+ getAllActiveOverlaysBaselayers.mockReturnValueOnce({
+ baselayers: [
+ { id: 'base1', visible: true },
+ { id: 'base2', visible: false },
+ ],
+ overlays: [],
+ });
+ const state = makeState({ embed: { isEmbedModeActive: true } });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.baselayers.every((l) => l.visible)).toBe(true);
+ expect(result.baselayers.some((l) => !l.visible)).toBe(false);
+ });
+
+ it('filters overlays to visible and non-Reference in embed mode', () => {
+ const state = makeState({ embed: { isEmbedModeActive: true } });
+ const result = capturedMapStateToProps(state, { compareState: 'active' });
+ expect(result.overlays.every((l) => l.visible && l.layergroup !== 'Reference')).toBe(true);
+ });
+
+ it('calls getFilteredOverlayGroups in embed mode', () => {
+ const state = makeState({ embed: { isEmbedModeActive: true } });
+ capturedMapStateToProps(state, { compareState: 'active' });
+ expect(getFilteredOverlayGroups).toHaveBeenCalled();
+ });
+
+ it('does not call getFilteredOverlayGroups when not in embed mode', () => {
+ capturedMapStateToProps(makeState(), { compareState: 'active' });
+ expect(getFilteredOverlayGroups).not.toHaveBeenCalled();
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+ let mapped;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ mapped = capturedMapDispatchToProps(dispatch);
+ });
+
+ it('reorderOverlayGroups dispatches reorderOverlayGroupsAction', () => {
+ const layers = [{ id: 'overlay1' }];
+ const groups = [{ groupName: 'Group A' }];
+ mapped.reorderOverlayGroups(layers, groups);
+ expect(reorderOverlayGroupsAction).toHaveBeenCalledWith(layers, groups);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'REORDER_OVERLAY_GROUPS' });
+ });
+
+ it('toggleCollapse dispatches toggleGroupCollapsedAction', () => {
+ mapped.toggleCollapse('Group A', true);
+ expect(toggleGroupCollapsedAction).toHaveBeenCalledWith('Group A', true);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_GROUP_COLLAPSED' });
+ });
+
+ it('addLayers dispatches openCustomContent when not animating', () => {
+ mapped.addLayers(false);
+ expect(stopAnimationAction).not.toHaveBeenCalled();
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'LAYER_PICKER_COMPONENT',
+ expect.objectContaining({ backdrop: true }),
+ );
+ expect(dispatch).toHaveBeenCalledWith({ type: 'OPEN_CUSTOM_CONTENT' });
+ });
+
+ it('addLayers dispatches stop animation before openCustomContent when animating', () => {
+ mapped.addLayers(true);
+ expect(stopAnimationAction).toHaveBeenCalled();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'STOP_ANIMATION' });
+ expect(dispatch).toHaveBeenCalledWith({ type: 'OPEN_CUSTOM_CONTENT' });
+ });
+
+ it('addLayers passes headerText null to openCustomContent', () => {
+ mapped.addLayers(false);
+ const [, opts] = openCustomContent.mock.calls[0];
+ expect(opts.headerText).toBeNull();
+ });
+
+ it('addLayers sets wrapClassName to empty string', () => {
+ mapped.addLayers(false);
+ const [, opts] = openCustomContent.mock.calls[0];
+ expect(opts.wrapClassName).toBe('');
+ });
});
diff --git a/web/js/containers/sidebar/orbit-track.test.js b/web/js/containers/sidebar/orbit-track.test.js
index 81289ec80..3ab178443 100644
--- a/web/js/containers/sidebar/orbit-track.test.js
+++ b/web/js/containers/sidebar/orbit-track.test.js
@@ -1,3 +1,355 @@
-test('orbit-track container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// ─── Mocks ───────────────────────────────────────────────────────────────────
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon }) => {
+ const React = require('react');
+ return React.createElement('span', { 'data-testid': `fa-icon-${icon}` });
+ },
+}));
+
+jest.mock('../../components/sidebar/paletteLegend', () => function MockPaletteLegend({
+ layer, parentLayer, isDistractionFreeModeActive, isMobile,
+}) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': 'palette-legend',
+ 'data-layer-id': layer.id,
+ 'data-parent-layer-id': parentLayer ? parentLayer.id : '',
+ 'data-distraction-free': String(isDistractionFreeModeActive),
+ 'data-is-mobile': String(isMobile),
+ });
+});
+
+jest.mock('../../modules/palettes/selectors', () => ({
+ getPalette: jest.fn(() => ({ id: 'default' })),
+ getPaletteLegends: jest.fn(() => [{ id: 'legend1' }]),
+}));
+
+jest.mock('../../modules/palettes/actions', () => ({
+ requestPalette: jest.fn((id) => ({ type: 'REQUEST_PALETTE', id })),
+}));
+
+jest.mock('../../modules/layers/util', () => ({
+ getOrbitTrackTitle: jest.fn((layer) => `Title for ${layer.id}`),
+}));
+
+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('lodash', () => ({
+ isEmpty: jest.fn((val) => !val || Object.keys(val).length === 0),
+ get: jest.fn((obj, path) => {
+ if (!obj || !path) return undefined;
+ return path.split(/[.[\]']+/).filter(Boolean)
+ .reduce(
+ (acc, key) => (acc != null ? acc[key] : undefined),
+ obj,
+ );
+ }),
+}));
+
+// ─── Imports after mocks ──────────────────────────────────────────────────────
+
+import OrbitTrack from './orbit-track';
+import { getPaletteLegends, getPalette as getPaletteSelector } from '../../modules/palettes/selectors';
+import { requestPalette as requestPaletteAction } from '../../modules/palettes/actions';
+import { getOrbitTrackTitle } from '../../modules/layers/util';
+
+// ─── Shared captured connect ──────────────────────────────────────────────────
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+const trackLayer = { id: 'orbit1', visible: true, palette: { id: 'pal1' } };
+const parentLayer = { id: 'parent1' };
+
+const defaultProps = {
+ trackLayer,
+ parentLayer,
+ paletteLegends: [],
+ getPalette: jest.fn(() => ({ id: 'default' })),
+ renderedPalette: { id: 'pal1' },
+ requestPalette: jest.fn(),
+ isDistractionFreeModeActive: false,
+ isMobile: false,
+ hasPalette: true,
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <OrbitTrack {...defaultProps} {...propOverrides} />,
+);
+
+// ─── OrbitTrack rendering ─────────────────────────────────────────────────────
+
+describe('OrbitTrack rendering', () => {
+ it('renders outer div with wv-orbit-track class', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.wv-orbit-track')).toBeInTheDocument();
+ });
+
+ it('does not add not-visible class when trackLayer.visible is true', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.wv-orbit-track')).not.toHaveClass('not-visible');
+ });
+
+ it('adds not-visible class when trackLayer.visible is false', () => {
+ const { container } = renderComponent({ trackLayer: { ...trackLayer, visible: false } });
+ expect(container.querySelector('.wv-orbit-track')).toHaveClass('not-visible');
+ });
+
+ it('renders satellite FontAwesomeIcon', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('fa-icon-satellite')).toBeInTheDocument();
+ });
+
+ it('renders orbit track label span', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.wv-orbit-track-label')).toBeInTheDocument();
+ });
+
+ it('displays title from getOrbitTrackTitle', () => {
+ getOrbitTrackTitle.mockReturnValue('Ascending');
+ const { container } = renderComponent();
+ expect(container.querySelector('.wv-orbit-track-label').textContent).toBe('Ascending');
+ });
+
+ it('calls getOrbitTrackTitle with trackLayer', () => {
+ renderComponent();
+ expect(getOrbitTrackTitle).toHaveBeenCalledWith(trackLayer);
+ });
+});
+
+// ─── OrbitTrack palette via useEffect ────────────────────────────────────────
+
+describe('OrbitTrack palette rendering via useEffect', () => {
+ it('renders PaletteLegend when hasPalette and renderedPalette are truthy', async () => {
+ const { findByTestId } = renderComponent();
+ expect(await findByTestId('palette-legend')).toBeInTheDocument();
+ });
+
+ it('passes trackLayer to PaletteLegend', async () => {
+ const { findByTestId } = renderComponent();
+ expect(await findByTestId('palette-legend')).toHaveAttribute('data-layer-id', 'orbit1');
+ });
+
+ it('passes parentLayer to PaletteLegend', async () => {
+ const { findByTestId } = renderComponent();
+ expect(await findByTestId('palette-legend')).toHaveAttribute('data-parent-layer-id', 'parent1');
+ });
+
+ it('passes isDistractionFreeModeActive to PaletteLegend', async () => {
+ const { findByTestId } = renderComponent({ isDistractionFreeModeActive: true });
+ expect(await findByTestId('palette-legend')).toHaveAttribute('data-distraction-free', 'true');
+ });
+
+ it('passes isMobile to PaletteLegend', async () => {
+ const { findByTestId } = renderComponent({ isMobile: true });
+ expect(await findByTestId('palette-legend')).toHaveAttribute('data-is-mobile', 'true');
+ });
+
+ it('does not render PaletteLegend when hasPalette is true but renderedPalette is null', () => {
+ const { queryByTestId } = renderComponent({ hasPalette: true, renderedPalette: null });
+ expect(queryByTestId('palette-legend')).not.toBeInTheDocument();
+ });
+
+ it('still renders PaletteLegend when hasPalette is false (no early return)', async () => {
+ const { findByTestId } = renderComponent({ hasPalette: false, renderedPalette: null });
+ expect(await findByTestId('palette-legend')).toBeInTheDocument();
+ });
+
+ it('calls requestPalette when hasPalette is true but renderedPalette is null', () => {
+ const requestPalette = jest.fn();
+ renderComponent({ hasPalette: true, renderedPalette: null, requestPalette });
+ expect(requestPalette).toHaveBeenCalledWith('orbit1');
+ });
+
+ it('does not call requestPalette when renderedPalette is already available', () => {
+ const requestPalette = jest.fn();
+ renderComponent({ hasPalette: true, renderedPalette: { id: 'pal1' }, requestPalette });
+ expect(requestPalette).not.toHaveBeenCalled();
+ });
+
+ it('does not call requestPalette when hasPalette is false', () => {
+ const requestPalette = jest.fn();
+ renderComponent({ hasPalette: false, renderedPalette: null, requestPalette });
+ expect(requestPalette).not.toHaveBeenCalled();
+ });
+
+ it('renders PaletteLegend after renderedPalette prop changes from null to truthy', async () => {
+ const { queryByTestId, rerender, findByTestId } = render(
+ <OrbitTrack {...defaultProps} renderedPalette={null} />,
+ );
+ expect(queryByTestId('palette-legend')).not.toBeInTheDocument();
+ await act(async () => {
+ rerender(<OrbitTrack {...defaultProps} renderedPalette={{ id: 'pal1' }} />);
+ });
+ expect(await findByTestId('palette-legend')).toBeInTheDocument();
+ });
+});
+
+// ─── mapStateToProps ──────────────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ palettes: {
+ rendered: {},
+ custom: {},
+ ...overrides.palettes,
+ },
+ config: {
+ layers: {
+ orbit1: { palette: { id: 'pal1' } },
+ },
+ ...overrides.config,
+ },
+ ui: { isDistractionFreeModeActive: false, ...overrides.ui },
+ screenSize: { isMobileDevice: false, ...overrides.screenSize },
+ ...overrides,
+ });
+
+ const defaultOwnProps = {
+ trackLayer: { id: 'orbit1', palette: { id: 'pal1' } },
+ compareState: 'active',
+ };
+
+ it('returns trackLayer from ownProps', () => {
+ const result = capturedMapStateToProps(makeState(), defaultOwnProps);
+ expect(result.trackLayer).toBe(defaultOwnProps.trackLayer);
+ });
+
+ it('maps isMobile from screenSize.isMobileDevice', () => {
+ const state = makeState({ screenSize: { isMobileDevice: true } });
+ const result = capturedMapStateToProps(state, defaultOwnProps);
+ expect(result.isMobile).toBe(true);
+ });
+
+ it('maps isDistractionFreeModeActive from ui', () => {
+ const state = makeState({ ui: { isDistractionFreeModeActive: true } });
+ const result = capturedMapStateToProps(state, defaultOwnProps);
+ expect(result.isDistractionFreeModeActive).toBe(true);
+ });
+
+ it('sets hasPalette true when trackLayer.palette is non-empty', () => {
+ const result = capturedMapStateToProps(makeState(), defaultOwnProps);
+ expect(result.hasPalette).toBe(true);
+ });
+
+ it('sets hasPalette false when trackLayer.palette is empty object', () => {
+ const ownProps = { ...defaultOwnProps, trackLayer: { id: 'orbit1', palette: {} } };
+ const result = capturedMapStateToProps(makeState(), ownProps);
+ expect(result.hasPalette).toBe(false);
+ });
+
+ it('sets hasPalette false when trackLayer.palette is undefined', () => {
+ const ownProps = { ...defaultOwnProps, trackLayer: { id: 'orbit1' } };
+ const result = capturedMapStateToProps(makeState(), ownProps);
+ expect(result.hasPalette).toBe(false);
+ });
+
+ it('returns renderedPalette from palettes.rendered by palette id', () => {
+ const paletteData = { id: 'pal1', entries: [] };
+ const state = makeState({ palettes: { rendered: { pal1: paletteData }, custom: {} } });
+ const result = capturedMapStateToProps(state, defaultOwnProps);
+ expect(result.renderedPalette).toBe(paletteData);
+ });
+
+ it('returns undefined renderedPalette when not yet rendered', () => {
+ const result = capturedMapStateToProps(makeState(), defaultOwnProps);
+ expect(result.renderedPalette).toBeUndefined();
+ });
+
+ it('returns empty paletteLegends array when renderedPalettes does not have paletteName', () => {
+ const result = capturedMapStateToProps(makeState(), defaultOwnProps);
+ expect(result.paletteLegends).toEqual([]);
+ expect(getPaletteLegends).not.toHaveBeenCalled();
+ });
+
+ it('calls getPaletteLegends when hasPalette and palette is rendered', () => {
+ const state = makeState({ palettes: { rendered: { pal1: { id: 'pal1' } }, custom: {} } });
+ capturedMapStateToProps(state, defaultOwnProps);
+ expect(getPaletteLegends).toHaveBeenCalledWith('orbit1', 'active', state);
+ });
+
+ it('returns paletteLegends from getPaletteLegends when palette is rendered', () => {
+ getPaletteLegends.mockReturnValueOnce([{ id: 'legend1' }]);
+ const state = makeState({ palettes: { rendered: { pal1: { id: 'pal1' } }, custom: {} } });
+ const result = capturedMapStateToProps(state, defaultOwnProps);
+ expect(result.paletteLegends).toEqual([{ id: 'legend1' }]);
+ });
+
+ it('returns empty paletteLegends when hasPalette is false', () => {
+ const ownProps = { ...defaultOwnProps, trackLayer: { id: 'orbit1', palette: {} } };
+ const state = makeState({ palettes: { rendered: { pal1: { id: 'pal1' } }, custom: {} } });
+ const result = capturedMapStateToProps(state, ownProps);
+ expect(result.paletteLegends).toEqual([]);
+ });
+
+ it('sets isCustomPalette true when palettes.custom has trackLayer id', () => {
+ const state = makeState({ palettes: { rendered: {}, custom: { orbit1: true } } });
+ const result = capturedMapStateToProps(state, defaultOwnProps);
+ expect(result.isCustomPalette).toBeTruthy();
+ });
+
+ it('sets isCustomPalette falsy when palettes.custom does not have trackLayer id', () => {
+ const result = capturedMapStateToProps(makeState(), defaultOwnProps);
+ expect(result.isCustomPalette).toBeFalsy();
+ });
+
+ it('getPalette calls getPaletteSelector with correct args', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, defaultOwnProps);
+ result.getPalette('orbit1', 2);
+ expect(getPaletteSelector).toHaveBeenCalledWith('orbit1', 2, 'active', state);
+ });
+
+ it('getPalette uses trackLayer.id regardless of layerId argument', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, defaultOwnProps);
+ result.getPalette('some-other-id', 0);
+ expect(getPaletteSelector).toHaveBeenCalledWith('orbit1', 0, 'active', state);
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+ let mapped;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ mapped = capturedMapDispatchToProps(dispatch);
+ });
+
+ it('requestPalette dispatches requestPaletteAction with the layer id', () => {
+ mapped.requestPalette('orbit1');
+ expect(requestPaletteAction).toHaveBeenCalledWith('orbit1');
+ expect(dispatch).toHaveBeenCalledWith({ type: 'REQUEST_PALETTE', id: 'orbit1' });
+ });
});
diff --git a/web/js/containers/sidebar/sidebar.test.js b/web/js/containers/sidebar/sidebar.test.js
index cc23e7199..4075448c6 100644
--- a/web/js/containers/sidebar/sidebar.test.js
+++ b/web/js/containers/sidebar/sidebar.test.js
@@ -1,3 +1,1086 @@
-test('sidebar container test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, fireEvent, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// ─── Mocks ───────────────────────────────────────────────────────────────────
+
+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('reactstrap', () => {
+ const React = require('react');
+ return {
+ TabContent: ({ children, activeTab }) => React.createElement('div', { 'data-testid': 'tab-content', 'data-active-tab': activeTab }, children),
+ TabPane: ({ children, tabId }) => React.createElement('div', { 'data-testid': `tab-pane-${tabId}` }, children),
+ };
+});
+
+jest.mock('googleTagManager', () => ({ pushEvent: jest.fn() }));
+
+jest.mock('./layers-container', () => function MockLayersContainer({ isActive, compareState, height }) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': 'layers-container',
+ 'data-is-active': String(isActive),
+ 'data-compare-state': compareState,
+ 'data-height': String(height),
+ });
+});
+
+jest.mock('./charting', () => function MockChartingLayerMenu({ isActive, height, compareState, chartState, chartingModeAccessible }) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': 'charting-layer-menu',
+ 'data-is-active': String(isActive),
+ 'data-height': String(height),
+ });
+});
+
+jest.mock('./events', () => function MockEvents({ height, isLoading, hasRequestError }) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': 'events',
+ 'data-height': String(height),
+ 'data-is-loading': String(isLoading),
+ });
+});
+
+jest.mock('./smart-handoff', () => function MockSmartHandoff({ isActive }) {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'smart-handoff', 'data-is-active': String(isActive) });
+});
+
+jest.mock('./compare', () => function MockCompareCase({ isActive, height }) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': 'compare-case',
+ 'data-is-active': String(isActive),
+ 'data-height': String(height),
+ });
+});
+
+jest.mock('./footer-content', () => {
+ const React = require('react');
+ return React.forwardRef(function MockFooterContent({
+ activeTab, tabTypes, chartingModeAccessible, sidebarHeight,
+ }, ref) {
+ return React.createElement('div', { 'data-testid': 'footer-content', ref });
+ });
+});
+
+jest.mock('./add-layers-content', () => {
+ const React = require('react');
+ return React.forwardRef(function MockAddLayersContent({ isActive, compareState }, ref) {
+ return React.createElement('div', {
+ 'data-testid': 'add-layers-content',
+ 'data-is-active': String(isActive),
+ ref,
+ });
+ });
+});
+
+jest.mock('../../components/sidebar/collapsed-button', () => function MockCollapsedButton({ onclick, numberOfLayers, isMobile, isEmbed }) {
+ const React = require('react');
+ return React.createElement('button', {
+ 'data-testid': 'collapsed-button',
+ 'data-num-layers': String(numberOfLayers),
+ onClick: onclick,
+ }, String(numberOfLayers));
+});
+
+jest.mock('../../components/sidebar/nav/nav-case', () => function MockNavCase({
+ activeTab, toggleSidebar, isEventsTabDisabledEmbed, isCompareMode, isChartMode,
+}) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': 'nav-case',
+ 'data-active-tab': activeTab,
+ 'data-events-tab-disabled': String(isEventsTabDisabledEmbed),
+ }, React.createElement('button', { 'data-testid': 'toggle-sidebar', onClick: toggleSidebar }, 'toggle'));
+});
+
+jest.mock('../../modules/palettes/util', () => ({
+ loadCustom: jest.fn(() => Promise.resolve([])),
+}));
+
+jest.mock('../../modules/palettes/actions', () => ({
+ loadedCustomPalettes: jest.fn(() => ({ type: 'LOADED_CUSTOM_PALETTES' })),
+}));
+
+jest.mock('../../modules/date/selectors', () => ({
+ getSelectedDate: jest.fn(() => new Date('2023-01-01')),
+}));
+
+jest.mock('../../modules/link/util', () => ({
+ getPermalink: jest.fn(() => 'https://worldview.earthdata.nasa.gov?permalink=test'),
+}));
+
+jest.mock('../../modules/natural-events/actions', () => ({
+ requestEvents: jest.fn(() => ({ type: 'REQUEST_EVENTS' })),
+ requestSources: jest.fn(() => ({ type: 'REQUEST_SOURCES' })),
+}));
+
+jest.mock('../../modules/layers/selectors', () => ({
+ getAllActiveLayers: jest.fn(() => []),
+}));
+
+jest.mock('../../modules/natural-events/selectors', () => ({
+ getFilteredEvents: jest.fn(() => []),
+}));
+
+jest.mock('../error-boundary', () => function MockErrorBoundary({ children }) {
+ return children;
+});
+
+jest.mock('../../modules/sidebar/actions', () => ({
+ changeTab: jest.fn((str) => ({ type: 'CHANGE_TAB', str })),
+ toggleSidebarCollapse: jest.fn(() => ({ type: 'TOGGLE_SIDEBAR_COLLAPSE' })),
+ expandSidebar: jest.fn(() => ({ type: 'EXPAND_SIDEBAR' })),
+}));
+
+jest.mock('../../main', () => ({
+ __esModule: true,
+ default: { location: { search: '' } },
+}));
+
+jest.mock('../../util/local-storage', () => ({
+ __esModule: true,
+ default: {
+ keys: { SIDEBAR_COLLAPSED: 'SIDEBAR_COLLAPSED' },
+ setItem: jest.fn(),
+ getItem: jest.fn(),
+ },
+}));
+
+jest.mock('../../util/customHooks', () => ({
+ __esModule: true,
+ default: jest.fn(() => undefined),
+}));
+
+// ─── Imports after mocks ──────────────────────────────────────────────────────
+
+import Sidebar from './sidebar';
+import googleTagManager from 'googleTagManager';
+import { loadCustom as loadCustomPalette } from '../../modules/palettes/util';
+import { loadedCustomPalettes as loadedCustomPalettesAction } from '../../modules/palettes/actions';
+import { getFilteredEvents } from '../../modules/natural-events/selectors';
+import { getAllActiveLayers } from '../../modules/layers/selectors';
+import { getSelectedDate } from '../../modules/date/selectors';
+import {
+ requestEvents as requestEventsActionCreator,
+ requestSources as requestSourcesActionCreator,
+} from '../../modules/natural-events/actions';
+import {
+ changeTab as changeTabAction,
+ toggleSidebarCollapse as toggleSidebarCollapseAction,
+ expandSidebar as expandSidebarAction,
+} from '../../modules/sidebar/actions';
+import safeLocalStorage from '../../util/local-storage';
+
+// ─── Shared captured connect ──────────────────────────────────────────────────
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ window.history.pushState({}, '', '/');
+});
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+const defaultConfig = {
+ features: { naturalEvents: true, smartHandoffs: true },
+ layers: {},
+};
+
+const defaultProps = {
+ activeTab: 'layers',
+ activeString: 'active',
+ changeTab: jest.fn(),
+ chartingModeAccessible: false,
+ collapseExpandToggle: jest.fn(),
+ config: defaultConfig,
+ displayStaticMap: false,
+ eventsData: [],
+ eventsSources: [],
+ hasEventRequestError: false,
+ isCollapsed: false,
+ isCompareMode: false,
+ isChartMode: false,
+ isDataDisabled: false,
+ isDistractionFreeModeActive: false,
+ isEmbedModeActive: false,
+ isKioskModeActive: false,
+ isLoadingEvents: false,
+ isMobile: false,
+ loadedCustomPalettes: jest.fn(),
+ mapIsRendered: false,
+ numberOfLayers: 3,
+ onTabClick: jest.fn(),
+ requestEvents: jest.fn(),
+ requestSources: jest.fn(),
+ screenHeight: 800,
+ selectedDate: new Date('2023-01-01'),
+ selectedMap: null,
+ tabTypes: { layers: true, events: true, download: true },
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <Sidebar {...defaultProps} {...propOverrides} />,
+);
+
+// ─── Sidebar structure ────────────────────────────────────────────────────────
+
+describe('Sidebar structure', () => {
+ it('renders #wv-sidebar section', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#wv-sidebar')).toBeInTheDocument();
+ });
+
+ it('renders #products-holder div', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#products-holder')).toBeInTheDocument();
+ });
+
+ it('renders NavCase', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('nav-case')).toBeInTheDocument();
+ });
+
+ it('renders AddLayersContent with isActive=true when activeTab is layers', () => {
+ const { getByTestId } = renderComponent({ activeTab: 'layers' });
+ expect(getByTestId('add-layers-content')).toHaveAttribute('data-is-active', 'true');
+ });
+
+ it('renders AddLayersContent with isActive=false when activeTab is not layers', () => {
+ const { getByTestId } = renderComponent({ activeTab: 'events' });
+ expect(getByTestId('add-layers-content')).toHaveAttribute('data-is-active', 'false');
+ });
+
+ it('renders FooterContent when not kiosk mode', () => {
+ const { getByTestId } = renderComponent({ isKioskModeActive: false });
+ expect(getByTestId('footer-content')).toBeInTheDocument();
+ });
+
+ it('does not render FooterContent in kiosk mode', () => {
+ const { queryByTestId } = renderComponent({ isKioskModeActive: true });
+ expect(queryByTestId('footer-content')).not.toBeInTheDocument();
+ });
+});
+
+// ─── Logo rendering ───────────────────────────────────────────────────────────
+
+describe('Logo rendering', () => {
+ it('renders logo anchor element when not in kiosk mode', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#wv-logo').tagName).toBe('A');
+ });
+
+ it('renders logo span element in kiosk mode', () => {
+ const { container } = renderComponent({ isKioskModeActive: true });
+ expect(container.querySelector('#wv-logo').tagName).toBe('SPAN');
+ });
+
+ it('does not render logo when displayStaticMap is true', () => {
+ const { container } = renderComponent({ displayStaticMap: true });
+ expect(container.querySelector('#wv-logo')).not.toBeInTheDocument();
+ });
+
+ it('logo href is permalink in embed mode', () => {
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ expect(container.querySelector('#wv-logo').getAttribute('href')).toBe('https://worldview.earthdata.nasa.gov?permalink=test');
+ });
+
+ it('logo href is / in non-embed mode', () => {
+ const { container } = renderComponent({ isEmbedModeActive: false });
+ expect(container.querySelector('#wv-logo').getAttribute('href')).toBe('/');
+ });
+
+ it('logo title mentions New Tab in embed mode', () => {
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ expect(container.querySelector('#wv-logo').getAttribute('title')).toContain('New Tab');
+ });
+
+ it('logo title mentions Reset in non-embed mode', () => {
+ const { container } = renderComponent({ isEmbedModeActive: false });
+ expect(container.querySelector('#wv-logo').getAttribute('title')).toContain('Reset');
+ });
+
+ it('logo has distraction-free class when isDistractionFreeModeActive', () => {
+ const { container } = renderComponent({ isDistractionFreeModeActive: true });
+ expect(container.querySelector('#wv-logo').className).toContain('wv-logo-distraction-free-mode');
+ });
+
+ it('logo span has distraction-free class in kiosk mode when distraction free', () => {
+ const { container } = renderComponent({
+ isKioskModeActive: true, isDistractionFreeModeActive: true,
+ });
+ expect(container.querySelector('#wv-logo').className).toContain('wv-logo-distraction-free-mode');
+ });
+
+ it('renders Worldview text on desktop', () => {
+ const { container } = renderComponent({ isMobile: false });
+ expect(container.querySelector('#wv-logo').textContent).toBe('Worldview');
+ });
+
+ it('renders empty logo text on mobile', () => {
+ const { container } = renderComponent({ isMobile: true });
+ expect(container.querySelector('#wv-logo').textContent).toBe('');
+ });
+});
+
+// ─── CollapsedButton ──────────────────────────────────────────────────────────
+
+describe('CollapsedButton', () => {
+ it('renders when isCollapsed is true and not distraction free', () => {
+ const { getByTestId } = renderComponent({ isCollapsed: true });
+ expect(getByTestId('collapsed-button')).toBeInTheDocument();
+ });
+
+ it('does not render when isCollapsed is false', () => {
+ const { queryByTestId } = renderComponent({ isCollapsed: false });
+ expect(queryByTestId('collapsed-button')).not.toBeInTheDocument();
+ });
+
+ it('does not render when isDistractionFreeModeActive is true', () => {
+ const { queryByTestId } = renderComponent({
+ isCollapsed: true, isDistractionFreeModeActive: true,
+ });
+ expect(queryByTestId('collapsed-button')).not.toBeInTheDocument();
+ });
+
+ it('passes numberOfLayers to CollapsedButton', () => {
+ const { getByTestId } = renderComponent({ isCollapsed: true, numberOfLayers: 7 });
+ expect(getByTestId('collapsed-button')).toHaveAttribute('data-num-layers', '7');
+ });
+});
+
+// ─── getProductsToRender ──────────────────────────────────────────────────────
+
+describe('getProductsToRender', () => {
+ it('renders LayersContainer in normal mode', () => {
+ const { getByTestId } = renderComponent({ activeTab: 'layers' });
+ expect(getByTestId('layers-container')).toBeInTheDocument();
+ });
+
+ it('passes compareState to LayersContainer', () => {
+ const { getByTestId } = renderComponent({ activeTab: 'layers', activeString: 'activeB' });
+ expect(getByTestId('layers-container')).toHaveAttribute('data-compare-state', 'activeB');
+ });
+
+ it('renders CompareCase when isCompareMode is true', () => {
+ const { getByTestId } = renderComponent({ isCompareMode: true });
+ expect(getByTestId('compare-case')).toBeInTheDocument();
+ });
+
+ it('does not render LayersContainer when isCompareMode is true', () => {
+ const { queryByTestId } = renderComponent({ isCompareMode: true });
+ expect(queryByTestId('layers-container')).not.toBeInTheDocument();
+ });
+
+ it('renders ChartingLayerMenu when isChartMode is true', () => {
+ const { getByTestId } = renderComponent({ isChartMode: true });
+ expect(getByTestId('charting-layer-menu')).toBeInTheDocument();
+ });
+
+ it('does not render LayersContainer when isChartMode is true', () => {
+ const { queryByTestId } = renderComponent({ isChartMode: true });
+ expect(queryByTestId('layers-container')).not.toBeInTheDocument();
+ });
+
+ it('compare mode takes precedence over chart mode', () => {
+ const { getByTestId, queryByTestId } = renderComponent({
+ isCompareMode: true, isChartMode: true,
+ });
+ expect(getByTestId('compare-case')).toBeInTheDocument();
+ expect(queryByTestId('charting-layer-menu')).not.toBeInTheDocument();
+ });
+});
+
+// ─── Events TabPane ───────────────────────────────────────────────────────────
+
+describe('Events TabPane', () => {
+ it('renders Events when activeTab is events and naturalEvents enabled', () => {
+ const { getByTestId } = renderComponent({ activeTab: 'events' });
+ expect(getByTestId('events')).toBeInTheDocument();
+ });
+
+ it('does not render Events when naturalEvents feature is false', () => {
+ const config = { features: { naturalEvents: false, smartHandoffs: true }, layers: {} };
+ const { queryByTestId } = renderComponent({ activeTab: 'events', config });
+ expect(queryByTestId('events')).not.toBeInTheDocument();
+ });
+
+ it('does not render Events when activeTab is not events', () => {
+ const { queryByTestId } = renderComponent({ activeTab: 'layers' });
+ expect(queryByTestId('events')).not.toBeInTheDocument();
+ });
+
+ it('passes height to Events component', () => {
+ const { getByTestId } = renderComponent({ activeTab: 'events', screenHeight: 800 });
+ const height = parseInt(getByTestId('events').getAttribute('data-height'), 10);
+ expect(height).toBeGreaterThan(0);
+ });
+});
+
+// ─── Download TabPane ─────────────────────────────────────────────────────────
+
+describe('Download TabPane', () => {
+ it('renders SmartHandoff when activeTab is download and smartHandoffs enabled', () => {
+ const { getByTestId } = renderComponent({ activeTab: 'download' });
+ expect(getByTestId('smart-handoff')).toBeInTheDocument();
+ });
+
+ it('does not render SmartHandoff when smartHandoffs feature is false', () => {
+ const config = { features: { naturalEvents: true, smartHandoffs: false }, layers: {} };
+ const { queryByTestId } = renderComponent({ activeTab: 'download', config });
+ expect(queryByTestId('smart-handoff')).not.toBeInTheDocument();
+ });
+
+ it('does not render SmartHandoff when activeTab is not download', () => {
+ const { queryByTestId } = renderComponent({ activeTab: 'layers' });
+ expect(queryByTestId('smart-handoff')).not.toBeInTheDocument();
+ });
+});
+
+// ─── Tab redirect (download → layers) ────────────────────────────────────────
+
+describe('Tab redirect', () => {
+ it('calls changeTab("layers") when isMobile and activeTab is download', () => {
+ const changeTab = jest.fn();
+ renderComponent({ isMobile: true, activeTab: 'download', changeTab });
+ expect(changeTab).toHaveBeenCalledWith('layers');
+ });
+
+ it('calls changeTab("layers") when isEmbedModeActive and activeTab is download', () => {
+ const changeTab = jest.fn();
+ renderComponent({ isEmbedModeActive: true, activeTab: 'download', changeTab });
+ expect(changeTab).toHaveBeenCalledWith('layers');
+ });
+
+ it('does not call changeTab when desktop non-embed with layers tab', () => {
+ const changeTab = jest.fn();
+ renderComponent({ activeTab: 'layers', changeTab });
+ expect(changeTab).not.toHaveBeenCalled();
+ });
+
+ it('does not call changeTab when desktop non-embed with download tab', () => {
+ const changeTab = jest.fn();
+ renderComponent({ isMobile: false, isEmbedModeActive: false, activeTab: 'download', changeTab });
+ expect(changeTab).not.toHaveBeenCalled();
+ });
+});
+
+// ─── Sidebar styles ───────────────────────────────────────────────────────────
+
+describe('Sidebar styles', () => {
+ it('products-holder maxHeight is screenHeight px when not collapsed and not embed', () => {
+ const { container } = renderComponent({
+ isCollapsed: false, isEmbedModeActive: false, screenHeight: 800,
+ });
+ expect(container.querySelector('#products-holder').style.maxHeight).toBe('800px');
+ });
+
+ it('products-holder maxHeight is 0 when collapsed', () => {
+ const { container } = renderComponent({ isCollapsed: true });
+ expect(container.querySelector('#products-holder').style.maxHeight).toBe('0');
+ });
+
+ it('products-holder maxHeight is 95vh in embed mode when not collapsed', () => {
+ const { container } = renderComponent({ isEmbedModeActive: true, isCollapsed: false });
+ expect(container.querySelector('#products-holder').style.maxHeight).toBe('95vh');
+ });
+
+ it('products-holder has display:none when distraction free and not mobile', () => {
+ const { container } = renderComponent({ isDistractionFreeModeActive: true, isMobile: false });
+ expect(container.querySelector('#products-holder').style.display).toBe('none');
+ });
+
+ it('sets #wv-sidebar position:static in mobile non-distraction-free mode', () => {
+ const { container } = renderComponent({ isMobile: true, isDistractionFreeModeActive: false });
+ expect(container.querySelector('#wv-sidebar').style.position).toBe('static');
+ });
+
+ it('does not set #wv-sidebar position in desktop mode', () => {
+ const { container } = renderComponent({ isMobile: false });
+ expect(container.querySelector('#wv-sidebar').style.position).toBe('');
+ });
+});
+
+// ─── toggleSidebar ────────────────────────────────────────────────────────────
+
+describe('toggleSidebar', () => {
+ it('calls collapseExpandToggle in mobile mode', () => {
+ const collapseExpandToggle = jest.fn();
+ const { getByTestId } = renderComponent({ isMobile: true, collapseExpandToggle });
+ fireEvent.click(getByTestId('toggle-sidebar'));
+ expect(collapseExpandToggle).toHaveBeenCalled();
+ });
+
+ it('does not fire googleTagManager event in mobile mode', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ fireEvent.click(getByTestId('toggle-sidebar'));
+ expect(googleTagManager.pushEvent).not.toHaveBeenCalled();
+ });
+
+ it('calls collapseExpandToggle in desktop mode', () => {
+ const collapseExpandToggle = jest.fn();
+ const { getByTestId } = renderComponent({ isMobile: false, collapseExpandToggle });
+ fireEvent.click(getByTestId('toggle-sidebar'));
+ expect(collapseExpandToggle).toHaveBeenCalled();
+ });
+
+ it('fires sidebar_chevron gtm event in desktop mode', () => {
+ const { getByTestId } = renderComponent({ isMobile: false });
+ fireEvent.click(getByTestId('toggle-sidebar'));
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({ event: 'sidebar_chevron' });
+ });
+
+ it('saves collapsed to localStorage when sidebar is currently expanded (desktop)', () => {
+ const { getByTestId } = renderComponent({ isMobile: false, isCollapsed: false });
+ fireEvent.click(getByTestId('toggle-sidebar'));
+ expect(safeLocalStorage.setItem).toHaveBeenCalledWith('SIDEBAR_COLLAPSED', 'collapsed');
+ });
+
+ it('saves expanded to localStorage when sidebar is currently collapsed (desktop)', () => {
+ const { getByTestId } = renderComponent({ isMobile: false, isCollapsed: true });
+ fireEvent.click(getByTestId('toggle-sidebar'));
+ expect(safeLocalStorage.setItem).toHaveBeenCalledWith('SIDEBAR_COLLAPSED', 'expanded');
+ });
+
+ it('CollapsedButton onclick also calls toggleSidebar in desktop mode', () => {
+ const collapseExpandToggle = jest.fn();
+ const { getByTestId } = renderComponent({
+ isMobile: false, isCollapsed: true, collapseExpandToggle,
+ });
+ fireEvent.click(getByTestId('collapsed-button'));
+ expect(collapseExpandToggle).toHaveBeenCalled();
+ });
+});
+
+// ─── handleWorldviewLogoClick ─────────────────────────────────────────────────
+
+describe('handleWorldviewLogoClick', () => {
+ beforeEach(() => {
+ window.confirm = jest.fn();
+ window.open = jest.fn();
+ });
+
+ it('does nothing when window.location.search is empty', () => {
+ // default URL is '/' with empty search
+ const { container } = renderComponent();
+ fireEvent.click(container.querySelector('#wv-logo'));
+ expect(window.confirm).not.toHaveBeenCalled();
+ });
+
+ it('calls window.open with permalink in embed mode when confirmed', () => {
+ window.history.pushState({}, '', '/?state=test');
+ window.confirm = jest.fn(() => true);
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ fireEvent.click(container.querySelector('#wv-logo'));
+ expect(window.open).toHaveBeenCalledWith(
+ 'https://worldview.earthdata.nasa.gov?permalink=test',
+ '_blank',
+ );
+ });
+
+ it('does not call window.open when confirm cancelled in embed mode', () => {
+ window.history.pushState({}, '', '/?state=test');
+ window.confirm = jest.fn(() => false);
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ fireEvent.click(container.querySelector('#wv-logo'));
+ expect(window.open).not.toHaveBeenCalled();
+ });
+
+ it('calls gtm logo_page_reset in non-embed mode when confirmed', () => {
+ window.history.pushState({}, '', '/?state=test');
+ window.confirm = jest.fn(() => true);
+ // jsdom logs a navigation error when document.location.href is set; suppress it
+ jest.spyOn(console, 'error').mockImplementation(() => {});
+ const { container } = renderComponent({ isEmbedModeActive: false });
+ fireEvent.click(container.querySelector('#wv-logo'));
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({ event: 'logo_page_reset' });
+ });
+
+ it('does not call gtm when confirm cancelled in non-embed mode', () => {
+ window.history.pushState({}, '', '/?state=test');
+ window.confirm = jest.fn(() => false);
+ const { container } = renderComponent({ isEmbedModeActive: false });
+ fireEvent.click(container.querySelector('#wv-logo'));
+ expect(googleTagManager.pushEvent).not.toHaveBeenCalled();
+ });
+
+ it('embed confirm prompt contains @NAME@ placeholder', () => {
+ window.history.pushState({}, '', '/?state=test');
+ window.confirm = jest.fn(() => false);
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ fireEvent.click(container.querySelector('#wv-logo'));
+ expect(window.confirm.mock.calls[0][0]).toContain('@NAME@');
+ });
+
+ it('non-embed confirm prompt mentions reset', () => {
+ window.history.pushState({}, '', '/?state=test');
+ window.confirm = jest.fn(() => false);
+ const { container } = renderComponent({ isEmbedModeActive: false });
+ fireEvent.click(container.querySelector('#wv-logo'));
+ expect(window.confirm.mock.calls[0][0]).toContain('reset');
+ });
+});
+
+// ─── useEffect on mount ───────────────────────────────────────────────────────
+
+describe('useEffect on mount', () => {
+ it('calls loadCustomPalette with config', () => {
+ renderComponent();
+ expect(loadCustomPalette).toHaveBeenCalledWith(defaultConfig);
+ });
+
+ it('calls loadedCustomPalettes with resolved palettes', async () => {
+ const palettes = [{ id: 'custom1' }];
+ loadCustomPalette.mockResolvedValueOnce(palettes);
+ const loadedCustomPalettes = jest.fn();
+ renderComponent({ loadedCustomPalettes });
+ await waitFor(() => expect(loadedCustomPalettes).toHaveBeenCalledWith(palettes));
+ });
+
+ it('calls requestSources on mount', () => {
+ const requestSources = jest.fn();
+ renderComponent({ requestSources });
+ expect(requestSources).toHaveBeenCalled();
+ });
+
+ it('sets isEventsTabDisabledEmbed in NavCase when embed mode and layers tab', async () => {
+ const { getByTestId } = renderComponent({ isEmbedModeActive: true, activeTab: 'layers' });
+ await waitFor(() => {
+ expect(getByTestId('nav-case')).toHaveAttribute('data-events-tab-disabled', 'true');
+ });
+ });
+
+ it('does not set isEventsTabDisabledEmbed when not embed mode', () => {
+ const { getByTestId } = renderComponent({ isEmbedModeActive: false, activeTab: 'layers' });
+ expect(getByTestId('nav-case')).toHaveAttribute('data-events-tab-disabled', 'false');
+ });
+
+ it('does not set isEventsTabDisabledEmbed when embed mode but not layers tab', () => {
+ const { getByTestId } = renderComponent({ isEmbedModeActive: true, activeTab: 'events' });
+ expect(getByTestId('nav-case')).toHaveAttribute('data-events-tab-disabled', 'false');
+ });
+});
+
+// ─── useEffect update – requestEvents ────────────────────────────────────────
+
+describe('useEffect update – requestEvents', () => {
+ it('calls requestEvents when activeTab is events with no existing data', () => {
+ const requestEvents = jest.fn();
+ renderComponent({ activeTab: 'events', eventsData: [], isLoadingEvents: false, requestEvents });
+ expect(requestEvents).toHaveBeenCalled();
+ });
+
+ it('does not call requestEvents when activeTab is not events', () => {
+ const requestEvents = jest.fn();
+ renderComponent({ activeTab: 'layers', requestEvents });
+ expect(requestEvents).not.toHaveBeenCalled();
+ });
+
+ it('does not call requestEvents when isLoadingEvents is true', () => {
+ const requestEvents = jest.fn();
+ renderComponent({ activeTab: 'events', isLoadingEvents: true, requestEvents });
+ expect(requestEvents).not.toHaveBeenCalled();
+ });
+
+ it('does not call requestEvents when eventsData is non-empty', () => {
+ const requestEvents = jest.fn();
+ renderComponent({ activeTab: 'events', eventsData: [{ id: '1' }], requestEvents });
+ expect(requestEvents).not.toHaveBeenCalled();
+ });
+
+ it('calls requestEvents when mapIsRendered is true and activeTab is events', () => {
+ const requestEvents = jest.fn();
+ renderComponent({ activeTab: 'events', mapIsRendered: true, requestEvents });
+ expect(requestEvents).toHaveBeenCalled();
+ });
+});
+
+// ─── updateDimensions ─────────────────────────────────────────────────────────
+
+describe('updateDimensions', () => {
+ it('calculates height for non-mobile desktop (fallback footer/addLayers heights)', async () => {
+ // footerHeight=20, addLayersHeight=30, tabHeight=32, groupCheckboxHeight=35
+ // iconHeight=53, topOffset=10, basePadding=130
+ // newHeight = 800 - (53+10+32+35+130+20+30) - 10 = 480
+ const { getByTestId } = renderComponent({ screenHeight: 800, isMobile: false });
+ await waitFor(() => {
+ expect(getByTestId('layers-container')).toHaveAttribute('data-height', '480');
+ });
+ });
+
+ it('calculates height for mobile without compare mode', async () => {
+ // tabHeight = compareModeHeight = 40 (no compare), groupCheckboxHeight=35
+ // newHeight = 800 - (40 + 35 + 20 + 30) = 675
+ const { getByTestId } = renderComponent({
+ screenHeight: 800, isMobile: true, isCompareMode: false,
+ });
+ await waitFor(() => {
+ expect(getByTestId('layers-container')).toHaveAttribute('data-height', '675');
+ });
+ });
+
+ it('subtracts 130 from height when isChartMode is true and height > 300', async () => {
+ // non-mobile: 480 base height; isChartMode=true → 480-130=350
+ const { getByTestId } = renderComponent({
+ screenHeight: 800, isMobile: false, isChartMode: true,
+ });
+ await waitFor(() => {
+ expect(getByTestId('charting-layer-menu')).toHaveAttribute('data-height', '350');
+ });
+ });
+
+ it('uses larger compareModeHeight for mobile in compare mode', async () => {
+ // mobile + compare: tabHeight = 80
+ // newHeight = 800 - (80 + 35 + 20 + 30) = 635
+ const { getByTestId } = renderComponent({
+ screenHeight: 800, isMobile: true, isCompareMode: true,
+ });
+ await waitFor(() => {
+ expect(getByTestId('compare-case')).toHaveAttribute('data-height', '635');
+ });
+ });
+});
+
+// ─── mapStateToProps ──────────────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ animation: { gifActive: false },
+ compare: { active: false, activeString: 'active' },
+ charting: { active: false },
+ config: {
+ features: { naturalEvents: true, smartHandoffs: true },
+ layers: {},
+ },
+ embed: { isEmbedModeActive: false },
+ events: { isAnimatingToEvent: false },
+ layers: { active: { layers: [] } },
+ measure: { isActive: false },
+ modal: { isOpen: false, id: null },
+ map: { ui: { selected: null } },
+ palettes: { rendered: {}, custom: {} },
+ requestedEvents: { isLoading: false, error: null },
+ requestedEventSources: { isLoading: false, error: null, response: [] },
+ screenSize: { screenHeight: 800, isMobileDevice: false },
+ sidebar: { activeTab: 'layers', isCollapsed: false, mobileCollapsed: false },
+ ui: { isDistractionFreeModeActive: false, isKioskModeActive: false, displayStaticMap: false },
+ ...overrides,
+ });
+
+ it('maps activeTab from sidebar.activeTab', () => {
+ const state = makeState({ sidebar: { activeTab: 'events', isCollapsed: false, mobileCollapsed: false } });
+ expect(capturedMapStateToProps(state).activeTab).toBe('events');
+ });
+
+ it('maps activeString from compare.activeString', () => {
+ const state = makeState({ compare: { active: false, activeString: 'activeB' } });
+ expect(capturedMapStateToProps(state).activeString).toBe('activeB');
+ });
+
+ it('maps isCompareMode from compare.active', () => {
+ const state = makeState({ compare: { active: true, activeString: 'active' } });
+ expect(capturedMapStateToProps(state).isCompareMode).toBe(true);
+ });
+
+ it('maps isChartMode from charting.active', () => {
+ const state = makeState({ charting: { active: true } });
+ expect(capturedMapStateToProps(state).isChartMode).toBe(true);
+ });
+
+ it('maps isEmbedModeActive from embed.isEmbedModeActive', () => {
+ const state = makeState({ embed: { isEmbedModeActive: true } });
+ expect(capturedMapStateToProps(state).isEmbedModeActive).toBe(true);
+ });
+
+ it('maps isMobile from screenSize.isMobileDevice', () => {
+ const state = makeState({ screenSize: { screenHeight: 800, isMobileDevice: true } });
+ expect(capturedMapStateToProps(state).isMobile).toBe(true);
+ });
+
+ it('maps isKioskModeActive from ui', () => {
+ const state = makeState({
+ ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, displayStaticMap: false },
+ });
+ expect(capturedMapStateToProps(state).isKioskModeActive).toBe(true);
+ });
+
+ it('maps isDistractionFreeModeActive from ui', () => {
+ const state = makeState({
+ ui: { isDistractionFreeModeActive: true, isKioskModeActive: false, displayStaticMap: false },
+ });
+ expect(capturedMapStateToProps(state).isDistractionFreeModeActive).toBe(true);
+ });
+
+ it('maps displayStaticMap from ui.displayStaticMap', () => {
+ const state = makeState({
+ ui: { isDistractionFreeModeActive: false, isKioskModeActive: false, displayStaticMap: true },
+ });
+ expect(capturedMapStateToProps(state).displayStaticMap).toBe(true);
+ });
+
+ it('maps screenHeight from screenSize.screenHeight', () => {
+ const state = makeState({ screenSize: { screenHeight: 1200, isMobileDevice: false } });
+ expect(capturedMapStateToProps(state).screenHeight).toBe(1200);
+ });
+
+ it('maps isLoadingEvents true when requestedEvents.isLoading is true', () => {
+ const state = makeState({ requestedEvents: { isLoading: true, error: null } });
+ expect(capturedMapStateToProps(state).isLoadingEvents).toBe(true);
+ });
+
+ it('maps isLoadingEvents true when requestedEventSources.isLoading is true', () => {
+ const state = makeState({
+ requestedEventSources: { isLoading: true, error: null, response: [] },
+ });
+ expect(capturedMapStateToProps(state).isLoadingEvents).toBe(true);
+ });
+
+ it('maps hasEventRequestError true when requestedEvents has error', () => {
+ const state = makeState({ requestedEvents: { isLoading: false, error: 'network error' } });
+ expect(capturedMapStateToProps(state).hasEventRequestError).toBe(true);
+ });
+
+ it('maps hasEventRequestError true when requestedEventSources has error', () => {
+ const state = makeState({ requestedEventSources: { isLoading: false, error: 'fail', response: [] } });
+ expect(capturedMapStateToProps(state).hasEventRequestError).toBe(true);
+ });
+
+ it('maps isDataDisabled from events.isAnimatingToEvent', () => {
+ const state = makeState({ events: { isAnimatingToEvent: true } });
+ expect(capturedMapStateToProps(state).isDataDisabled).toBe(true);
+ });
+
+ it('isCollapsed uses mobileCollapsed for mobile', () => {
+ const state = makeState({
+ screenSize: { screenHeight: 800, isMobileDevice: true },
+ sidebar: { activeTab: 'layers', isCollapsed: false, mobileCollapsed: true },
+ });
+ expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
+ });
+
+ it('isCollapsed uses sidebar.isCollapsed for desktop', () => {
+ const state = makeState({ sidebar: { activeTab: 'layers', isCollapsed: true, mobileCollapsed: false } });
+ expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
+ });
+
+ it('isCollapsed true via snapshotModalOpen', () => {
+ const state = makeState({ modal: { isOpen: true, id: 'TOOLBAR_SNAPSHOT' } });
+ expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
+ });
+
+ it('isCollapsed false when modal is open but not snapshot id', () => {
+ const state = makeState({ modal: { isOpen: true, id: 'OTHER_MODAL' } });
+ expect(capturedMapStateToProps(state).isCollapsed).toBe(false);
+ });
+
+ it('isCollapsed true via measure.isActive', () => {
+ const state = makeState({ measure: { isActive: true } });
+ expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
+ });
+
+ it('isCollapsed true via animation.gifActive', () => {
+ const state = makeState({ animation: { gifActive: true } });
+ expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
+ });
+
+ it('numberOfLayers counts all active layers when not embed mode', () => {
+ getAllActiveLayers.mockReturnValueOnce([{ id: 'l1', visible: true }, { id: 'l2', visible: false }]);
+ const state = makeState();
+ expect(capturedMapStateToProps(state).numberOfLayers).toBe(2);
+ });
+
+ it('numberOfLayers counts only visible non-Reference layers in embed mode', () => {
+ getAllActiveLayers.mockReturnValueOnce([
+ { id: 'l1', visible: true, layergroup: 'Overlays' },
+ { id: 'l2', visible: false, layergroup: 'Overlays' },
+ { id: 'l3', visible: true, layergroup: 'Reference' },
+ ]);
+ const state = makeState({ embed: { isEmbedModeActive: true } });
+ expect(capturedMapStateToProps(state).numberOfLayers).toBe(1);
+ });
+
+ it('mapIsRendered is true when selectedMap.isRendered() returns true', () => {
+ const mockMap = { isRendered: jest.fn(() => true) };
+ const state = makeState({ map: { ui: { selected: mockMap } } });
+ expect(capturedMapStateToProps(state).mapIsRendered).toBe(true);
+ });
+
+ it('mapIsRendered is falsy when selectedMap is null', () => {
+ const state = makeState({ map: { ui: { selected: null } } });
+ expect(capturedMapStateToProps(state).mapIsRendered).toBeFalsy();
+ });
+
+ it('selectedMap comes from map.ui.selected', () => {
+ const mockMap = { isRendered: jest.fn(() => false) };
+ const state = makeState({ map: { ui: { selected: mockMap } } });
+ expect(capturedMapStateToProps(state).selectedMap).toBe(mockMap);
+ });
+
+ it('chartingModeAccessible true for qualifying layer', () => {
+ const state = makeState({
+ palettes: { rendered: { pal1: { maps: [{ type: 'continuous' }] } }, custom: {} },
+ layers: {
+ active: {
+ layers: [{
+ id: 'layer1', palette: { id: 'pal1' }, layerPeriod: 'Daily', disableCharting: false,
+ }],
+ },
+ },
+ });
+ expect(capturedMapStateToProps(state).chartingModeAccessible).toBe(true);
+ });
+
+ it('chartingModeAccessible false when no qualifying layers', () => {
+ expect(capturedMapStateToProps(makeState()).chartingModeAccessible).toBe(false);
+ });
+
+ it('chartingModeAccessible false when layer has disableCharting=true', () => {
+ const state = makeState({
+ palettes: { rendered: { pal1: { maps: [{ type: 'continuous' }] } }, custom: {} },
+ layers: {
+ active: {
+ layers: [{
+ id: 'layer1', palette: { id: 'pal1' }, layerPeriod: 'Daily', disableCharting: true,
+ }],
+ },
+ },
+ });
+ expect(capturedMapStateToProps(state).chartingModeAccessible).toBe(false);
+ });
+
+ it('chartingModeAccessible false when palette type is not continuous', () => {
+ const state = makeState({
+ palettes: { rendered: { pal1: { maps: [{ type: 'classification' }] } }, custom: {} },
+ layers: {
+ active: {
+ layers: [{
+ id: 'layer1', palette: { id: 'pal1' }, layerPeriod: 'Daily', disableCharting: false,
+ }],
+ },
+ },
+ });
+ expect(capturedMapStateToProps(state).chartingModeAccessible).toBe(false);
+ });
+
+ it('tabTypes.layers is always true', () => {
+ expect(capturedMapStateToProps(makeState()).tabTypes.layers).toBe(true);
+ });
+
+ it('tabTypes.events reflects features.naturalEvents', () => {
+ const state = makeState({
+ config: { features: { naturalEvents: false, smartHandoffs: true }, layers: {} },
+ });
+ expect(capturedMapStateToProps(state).tabTypes.events).toBe(false);
+ });
+
+ it('tabTypes.download reflects features.smartHandoffs', () => {
+ const state = makeState({
+ config: { features: { naturalEvents: true, smartHandoffs: false }, layers: {} },
+ });
+ expect(capturedMapStateToProps(state).tabTypes.download).toBe(false);
+ });
+
+ it('eventsSources maps from requestedEventSources.response', () => {
+ const sources = [{ id: 'VIIRS' }];
+ const state = makeState({
+ requestedEventSources: { isLoading: false, error: null, response: sources },
+ });
+ expect(capturedMapStateToProps(state).eventsSources).toBe(sources);
+ });
+
+ it('calls getSelectedDate with state', () => {
+ const state = makeState();
+ capturedMapStateToProps(state);
+ expect(getSelectedDate).toHaveBeenCalledWith(state);
+ });
+
+ it('calls getFilteredEvents with state', () => {
+ const state = makeState();
+ capturedMapStateToProps(state);
+ expect(getFilteredEvents).toHaveBeenCalledWith(state);
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+ let mapped;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ mapped = capturedMapDispatchToProps(dispatch);
+ });
+
+ it('changeTab dispatches changeTabAction', () => {
+ mapped.changeTab('events');
+ expect(changeTabAction).toHaveBeenCalledWith('events');
+ expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_TAB', str: 'events' });
+ });
+
+ it('onTabClick does nothing when str equals activeStr', () => {
+ mapped.onTabClick('events', 'events');
+ expect(dispatch).not.toHaveBeenCalled();
+ expect(googleTagManager.pushEvent).not.toHaveBeenCalled();
+ });
+
+ it('onTabClick dispatches changeTabAction and fires gtm when tab changes', () => {
+ mapped.onTabClick('events', 'layers');
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({ event: 'events_tab' });
+ expect(changeTabAction).toHaveBeenCalledWith('events');
+ });
+
+ it('collapseExpandToggle dispatches toggleSidebarCollapseAction', () => {
+ mapped.collapseExpandToggle();
+ expect(toggleSidebarCollapseAction).toHaveBeenCalled();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_SIDEBAR_COLLAPSE' });
+ });
+
+ it('expandSidebar dispatches expandSidebarAction', () => {
+ mapped.expandSidebar();
+ expect(expandSidebarAction).toHaveBeenCalled();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'EXPAND_SIDEBAR' });
+ });
+
+ it('loadedCustomPalettes dispatches loadedCustomPalettesAction', () => {
+ const customs = [{ id: 'custom1' }];
+ mapped.loadedCustomPalettes(customs);
+ expect(loadedCustomPalettesAction).toHaveBeenCalledWith(customs);
+ expect(dispatch).toHaveBeenCalledWith({ type: 'LOADED_CUSTOM_PALETTES' });
+ });
+
+ it('requestEvents dispatches requestEventsActionCreator', () => {
+ mapped.requestEvents();
+ expect(requestEventsActionCreator).toHaveBeenCalled();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'REQUEST_EVENTS' });
+ });
+
+ it('requestSources dispatches requestSourcesActionCreator', () => {
+ mapped.requestSources();
+ expect(requestSourcesActionCreator).toHaveBeenCalled();
+ expect(dispatch).toHaveBeenCalledWith({ type: 'REQUEST_SOURCES' });
+ });
});
diff --git a/web/js/containers/sidebar/smart-handoff.test.js b/web/js/containers/sidebar/smart-handoff.test.js
index 823234c17..c3508b4e1 100644
--- a/web/js/containers/sidebar/smart-handoff.test.js
+++ b/web/js/containers/sidebar/smart-handoff.test.js
@@ -1,3 +1,1000 @@
-test('smart-handoff container test', () => {
+/* eslint-disable react/prop-types */
+import React from 'react';
+import { render, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// ─── Mocks ───────────────────────────────────────────────────────────────────
+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('googleTagManager', () => ({ pushEvent: jest.fn() }), { virtual: true });
+
+jest.mock('ol/proj', () => ({
+ transform: jest.fn((coords) => coords),
+}));
+
+jest.mock('lodash', () => ({
+ isEqual: jest.fn((a, b) => JSON.stringify(a) === JSON.stringify(b)),
+}));
+
+jest.mock('moment', () => {
+ const m = () => ({
+ format: jest.fn(() => '2020-01-01'),
+ });
+ m.utc = jest.fn(() => ({ format: jest.fn(() => '2020-01-01') }));
+ return m;
+});
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon }) => {
+ const React = require('react');
+ return React.createElement('span', { 'data-testid': `fa-icon-${icon}` });
+ },
+}));
+
+jest.mock('reactstrap', () => ({
+ Spinner: () => {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'spinner' });
+ },
+ UncontrolledTooltip: ({ children, target }) => {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'tooltip', 'data-target': target }, children);
+ },
+}));
+
+jest.mock('../../components/util/button', () => function MockButton({ onClick, text, valid }) {
+ const React = require('react');
+ return React.createElement('button', {
+ 'data-testid': 'download-btn',
+ 'data-valid': String(valid),
+ onClick,
+ }, text);
+});
+
+jest.mock('../../components/util/checkbox', () => function MockCheckbox({
+ id, label, checked, onCheck,
+}) {
+ const React = require('react');
+ return React.createElement('input', {
+ 'data-testid': 'crop-checkbox',
+ id,
+ 'aria-label': label,
+ type: 'checkbox',
+ checked,
+ onChange: onCheck,
+ onClick: onCheck,
+ });
+});
+
+jest.mock('../../components/util/image-crop', () => function MockCrop({
+ onChange, onDragStop, x, y,
+}) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': 'crop-tool',
+ 'data-x': x,
+ 'data-y': y,
+ onClick: () => {
+ onChange({ x: 10, y: 10, width: 50, height: 50 }, false);
+ },
+ onDoubleClick: () => {
+ onDragStop({ x: 10, y: 10, width: 50, height: 50 });
+ },
+ });
+});
+
+jest.mock('../../components/util/alert', () => function MockAlert({ id, message }) {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'alert', id }, message);
+});
+
+jest.mock('../../components/smart-handoffs/smart-handoff-modal', () => function MockModal() {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'smart-handoff-modal' });
+});
+
+jest.mock(
+ '../../components/smart-handoffs/smart-handoff-not-available-modal',
+ () => function MockNotAvailableModal() {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'not-available-modal' });
+ },
+);
+
+jest.mock(
+ '../../components/smart-handoffs/smart-handoff-granule-alert',
+ () => function MockGranuleAlert() {
+ const React = require('react');
+ return React.createElement('div', { 'data-testid': 'granule-alert' });
+ },
+);
+
+jest.mock('../../components/smart-handoffs/granule-count', () => function MockGranuleCount({
+ displayDate, selectedCollection,
+}) {
+ const React = require('react');
+ return React.createElement('div', {
+ 'data-testid': 'granule-count',
+ 'data-display-date': displayDate,
+ 'data-collection': selectedCollection ? selectedCollection.value : '',
+ });
+});
+
+jest.mock('../../modules/image-download/util', () => ({
+ imageUtilGetCoordsFromPixelValues: jest.fn(() => [[-100, 30], [-80, 50]]),
+}));
+
+jest.mock('../../modules/modal/actions', () => ({
+ onClose: jest.fn(),
+ openCustomContent: jest.fn((id, opts) => ({ type: 'OPEN_CUSTOM_CONTENT', id, opts })),
+}));
+
+jest.mock('../../modules/layers/selectors', () => ({
+ getActiveGranuleLayers: jest.fn(() => ({})),
+}));
+
+jest.mock('../../modules/smart-handoff/selectors', () => ({
+ getValidLayersForHandoffs: jest.fn(() => []),
+ getConceptUrl: jest.fn(() => jest.fn((val) => `https://cmr.example.com/${val}`)),
+ getGranulesUrl: jest.fn(() => jest.fn()),
+}));
+
+jest.mock('../../modules/date/selectors', () => ({
+ getSelectedDate: jest.fn(() => new Date('2020-01-01')),
+}));
+
+jest.mock('../../util/local-storage', () => ({
+ __esModule: true,
+ default: {
+ keys: { HIDE_EDS_WARNING: 'HIDE_EDS_WARNING' },
+ getItem: jest.fn(() => null),
+ setItem: jest.fn(),
+ },
+}));
+
+jest.mock('../../modules/smart-handoff/util', () => ({
+ __esModule: true,
+ default: jest.fn(() => undefined),
+ getStartEndDates: jest.fn(() => ({
+ startDate: '2020-01-01T00:00:00.000Z',
+ endDate: '2020-01-01T23:59:59.999Z',
+ })),
+}));
+
+jest.mock('../../modules/smart-handoff/actions', () => ({
+ selectCollection: jest.fn((conceptId, layerId) => ({
+ type: 'SELECT_COLLECTION', conceptId, layerId,
+ })),
+ fetchAvailableTools: jest.fn(() => ({ type: 'FETCH_AVAILABLE_TOOLS' })),
+ validateLayersConceptIds: jest.fn((layers) => ({
+ type: 'VALIDATE_LAYERS', layers,
+ })),
+}));
+
+jest.mock('../../modules/map/constants', () => ({
+ CRS: { GEOGRAPHIC: 'EPSG:4326' },
+}));
+
+jest.mock('../../util/util', () => ({
+ __esModule: true,
+ default: {
+ encodeId: jest.fn((id) => String(id).replace(/[^a-zA-Z0-9]/g, '-')),
+ formatCoordinate: jest.fn(([x, y]) => `${x.toFixed(2)}, ${y.toFixed(2)}`),
+ },
+}));
+
+jest.mock('../../modules/date/util', () => ({
+ formatDisplayDate: jest.fn((date) => '2020 JAN 01'),
+}));
+
+// ─── Imports after mocks ──────────────────────────────────────────────────────
+
+import SmartHandoff from './smart-handoff';
+import googleTagManager from 'googleTagManager';
+import safeLocalStorage from '../../util/local-storage';
+import openEarthDataSearch from '../../modules/smart-handoff/util';
+import { openCustomContent } from '../../modules/modal/actions';
+import {
+ selectCollection as selectCollectionAction,
+ fetchAvailableTools as fetchAvailableToolsAction,
+ validateLayersConceptIds as validateLayersConceptIdsAction,
+} from '../../modules/smart-handoff/actions';
+
+// ─── Shared captured connect ──────────────────────────────────────────────────
+
+let capturedMapStateToProps;
+let capturedMapDispatchToProps;
+
+beforeAll(() => {
+ const { connect } = jest.requireMock('react-redux');
+ capturedMapStateToProps = connect.connectCapture.msp;
+ capturedMapDispatchToProps = connect.connectCapture.mdp;
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ safeLocalStorage.getItem.mockReturnValue(null);
+});
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+const layer1 = {
+ id: 'layer1',
+ title: 'Layer One',
+ subtitle: 'Subtitle One',
+ type: 'wms',
+ conceptIds: [
+ { type: 'STD', value: 'C1-STD', version: '6.0' },
+ { type: 'NRT', value: 'C1-NRT' },
+ ],
+};
+
+const defaultProps = {
+ availableLayers: [layer1],
+ availableTools: [],
+ displayDate: '2020 JAN 01',
+ isLoading: false,
+ isGranuleLayer: false,
+ endDate: '2020-01-01T23:59:59.999Z',
+ startDate: '2020-01-01T00:00:00.000Z',
+ getConceptUrl: jest.fn((val) => `https://cmr.example.com/${val}`),
+ getGranulesUrl: jest.fn(),
+ granuleLayers: {},
+ map: {
+ ui: { selected: {} },
+ extent: [-180, -90, 180, 90],
+ },
+ proj: {
+ id: 'geographic',
+ crs: 'EPSG:4326',
+ maxExtent: [-180, -90, 180, 90],
+ },
+ fetchAvailableTools: jest.fn(),
+ requestFailed: false,
+ screenHeight: 800,
+ screenWidth: 1200,
+ selectCollection: jest.fn(),
+ selectedDate: '2020-01-01',
+ selectedLayer: layer1,
+ selectedCollection: { type: 'STD', value: 'C1-STD', version: '6.0', title: 'Layer One' },
+ showWarningModal: jest.fn(),
+ showGranuleHelpModal: jest.fn(),
+ showNotAvailableModal: jest.fn(),
+ validatedLayers: [layer1],
+ validatedConceptIds: { 'C1-STD': true, 'C1-NRT': true },
+ validateLayersConceptIds: jest.fn(),
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ React.createElement(SmartHandoff, { ...defaultProps, ...propOverrides }),
+);
+
+// ─── Loading state ────────────────────────────────────────────────────────────
+
+describe('SmartHandoff loading state', () => {
+ it('renders spinner when isLoading is true', () => {
+ const { getByTestId } = renderComponent({ isLoading: true });
+ expect(getByTestId('spinner')).toBeInTheDocument();
+ });
+
+ it('does not render panel when loading', () => {
+ renderComponent({ isLoading: true });
+ expect(document.querySelector('.smart-handoff-side-panel')).not.toBeInTheDocument();
+ });
+});
+
+// ─── No layers state ─────────────────────────────────────────────────────────
+
+describe('SmartHandoff no layers state', () => {
+ it('renders no-layers panel when validatedLayers is empty', () => {
+ const { container } = renderComponent({ validatedLayers: [] });
+ expect(container.querySelector('.smart-handoff-side-panel.error')).toBeInTheDocument();
+ });
+
+ it('renders CMR error message when requestFailed is true', () => {
+ const { getByText } = renderComponent({ validatedLayers: [], requestFailed: true });
+ expect(getByText(/Common Metadata Repository/)).toBeInTheDocument();
+ });
+
+ it('renders not-available message when requestFailed is false', () => {
+ const { getByText } = renderComponent({ validatedLayers: [] });
+ expect(getByText(/None of your current layers are available/)).toBeInTheDocument();
+ });
+
+ it('renders help link when requestFailed is false', () => {
+ const { getByText } = renderComponent({ validatedLayers: [] });
+ expect(getByText(/Why are my layers not available/)).toBeInTheDocument();
+ });
+
+ it('calls showNotAvailableModal when help link is clicked in no-layers view', () => {
+ const showNotAvailableModal = jest.fn();
+ const { getByText } = renderComponent({ validatedLayers: [], showNotAvailableModal });
+ fireEvent.click(getByText(/Why are my layers not available/));
+ expect(showNotAvailableModal).toHaveBeenCalled();
+ });
+});
+
+// ─── Main panel rendering ─────────────────────────────────────────────────────
+
+describe('SmartHandoff main panel', () => {
+ it('renders the side panel', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.smart-handoff-side-panel')).toBeInTheDocument();
+ });
+
+ it('renders the Earthdata Search notification text', () => {
+ const { getByText } = renderComponent();
+ expect(getByText(/Downloading data will be performed using/)).toBeInTheDocument();
+ });
+
+ it('renders the help link button', () => {
+ const { getByText } = renderComponent();
+ expect(getByText(/Why are some layers not available/)).toBeInTheDocument();
+ });
+
+ it('calls showNotAvailableModal when help link is clicked', () => {
+ const showNotAvailableModal = jest.fn();
+ const { getByText } = renderComponent({ showNotAvailableModal });
+ fireEvent.click(getByText(/Why are some layers not available/));
+ expect(showNotAvailableModal).toHaveBeenCalled();
+ });
+
+ it('renders download button', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('download-btn')).toBeInTheDocument();
+ });
+
+ it('download button is valid when selectedLayer and selectedCollection present', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('download-btn')).toHaveAttribute('data-valid', 'true');
+ });
+
+ it('download button is not valid when no selectedLayer', () => {
+ const { getByTestId } = renderComponent({ selectedLayer: null, selectedCollection: null });
+ expect(getByTestId('download-btn')).toHaveAttribute('data-valid', 'false');
+ });
+
+ it('download button is not valid when no selectedCollection', () => {
+ const { getByTestId } = renderComponent({ selectedCollection: null });
+ expect(getByTestId('download-btn')).toHaveAttribute('data-valid', 'false');
+ });
+
+ it('renders GranuleCount when isValidDownload', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('granule-count')).toBeInTheDocument();
+ });
+
+ it('does not render GranuleCount when no selectedLayer', () => {
+ const { queryByTestId } = renderComponent({ selectedLayer: null, selectedCollection: null });
+ expect(queryByTestId('granule-count')).not.toBeInTheDocument();
+ });
+});
+
+// ─── renderLayerChoices ───────────────────────────────────────────────────────
+
+describe('renderLayerChoices', () => {
+ it('renders layer list div', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.smart-handoff-layer-list')).toBeInTheDocument();
+ });
+
+ it('renders layer title', () => {
+ const { getByText } = renderComponent();
+ expect(getByText('Layer One')).toBeInTheDocument();
+ });
+
+ it('renders layer subtitle', () => {
+ const { getByText } = renderComponent();
+ expect(getByText('Subtitle One')).toBeInTheDocument();
+ });
+
+ it('renders radio inputs for validated conceptIds', () => {
+ const { container } = renderComponent();
+ const radios = container.querySelectorAll('input[type="radio"]');
+ expect(radios.length).toBe(2);
+ });
+
+ it('marks selected collection radio as checked', () => {
+ const { container } = renderComponent();
+ const checked = container.querySelector('input[type="radio"]:checked');
+ expect(checked).toBeInTheDocument();
+ });
+
+ it('renders Standard label for STD type', () => {
+ const { getByText } = renderComponent();
+ expect(getByText(/Standard - v6\.0/)).toBeInTheDocument();
+ });
+
+ it('renders Near Real-Time label for NRT type', () => {
+ const { getByText } = renderComponent();
+ expect(getByText(/Near Real-Time/)).toBeInTheDocument();
+ });
+
+ it('calls selectCollection when unselected radio is clicked', () => {
+ const selectCollection = jest.fn();
+ const { container } = renderComponent({ selectCollection });
+ // First radio is already checked; click the second (unselected) one to trigger onChange
+ const radios = container.querySelectorAll('input[type="radio"]');
+ fireEvent.click(radios[1]);
+ expect(selectCollection).toHaveBeenCalled();
+ });
+
+ it('selected item has selected class when layerIsSelected', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.layer-item.selected')).toBeInTheDocument();
+ });
+
+ it('does not filter out conceptIds with validated value', () => {
+ const { container } = renderComponent({
+ validatedConceptIds: { 'C1-STD': true },
+ });
+ const radios = container.querySelectorAll('input[type="radio"]');
+ expect(radios.length).toBe(1);
+ });
+
+ it('renders tooltip for collection with value', () => {
+ const { getAllByTestId } = renderComponent();
+ expect(getAllByTestId('tooltip').length).toBeGreaterThan(0);
+ });
+
+ it('does not render tooltip when collection has no value', () => {
+ const noValueLayer = {
+ ...layer1,
+ conceptIds: [{ type: 'STD', value: '' }],
+ };
+ const { queryAllByTestId } = renderComponent({
+ validatedLayers: [noValueLayer],
+ validatedConceptIds: { '': true },
+ });
+ expect(queryAllByTestId('tooltip').length).toBe(0);
+ });
+});
+
+// ─── renderCropBox ────────────────────────────────────────────────────────────
+
+describe('renderCropBox', () => {
+ it('renders checkbox when selectedLayer, selectedCollection and geographic proj', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('crop-checkbox')).toBeInTheDocument();
+ });
+
+ it('does not render checkbox when proj is not geographic', () => {
+ const { queryByTestId } = renderComponent({ proj: { id: 'arctic', crs: 'EPSG:3413', maxExtent: [-180, 60, 180, 90] } });
+ expect(queryByTestId('crop-checkbox')).not.toBeInTheDocument();
+ });
+
+ it('does not render checkbox when no selectedCollection', () => {
+ const { queryByTestId } = renderComponent({ selectedCollection: null });
+ expect(queryByTestId('crop-checkbox')).not.toBeInTheDocument();
+ });
+
+ it('does not render crop tool initially', () => {
+ const { queryByTestId } = renderComponent();
+ expect(queryByTestId('crop-tool')).not.toBeInTheDocument();
+ });
+
+ it('shows crop tool after checking the checkbox', () => {
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ expect(getByTestId('crop-tool')).toBeInTheDocument();
+ });
+
+ it('pushes GTM event when checkbox is toggled on', () => {
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({
+ event: 'smart_handoffs_toggle_true_target_area',
+ });
+ });
+
+ it('hides crop tool when checkbox is toggled off', () => {
+ const { getByTestId, queryByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ expect(getByTestId('crop-tool')).toBeInTheDocument();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ expect(queryByTestId('crop-tool')).not.toBeInTheDocument();
+ });
+
+ it('crop tool onChange calls onBoundaryChange', () => {
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ fireEvent.click(getByTestId('crop-tool'));
+ });
+
+ it('crop tool onDragStop calls onBoundaryChange with setExtent=true', () => {
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ fireEvent.doubleClick(getByTestId('crop-tool'));
+ });
+});
+
+// ─── onBoundaryChange ─────────────────────────────────────────────────────────
+
+describe('onBoundaryChange', () => {
+ it('does nothing when no selectedCollection', () => {
+ renderComponent({ selectedCollection: null, selectedLayer: layer1 });
+ // No crop checkbox rendered without selectedCollection, so nothing to fire
+ expect(document.querySelector('.smart-handoff-crop-toggle')).not.toBeInTheDocument();
+ });
+
+ it('updates currentExtent when setExtent is true (onDragStop)', () => {
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ // doubleClick triggers onDragStop which calls onBoundaryChange with setExtent=true
+ fireEvent.doubleClick(getByTestId('crop-tool'));
+ // GranuleCount should still be present (isValidDownload still true)
+ expect(getByTestId('granule-count')).toBeInTheDocument();
+ });
+
+ it('clamps coordinates exceeding positive bounds (x1>180, y1>90, x2>180, y2>90)', () => {
+ const { imageUtilGetCoordsFromPixelValues } = require('../../modules/image-download/util');
+ // Both points outside positive bounds → hits x=180 and y=90 clamp branches
+ imageUtilGetCoordsFromPixelValues.mockReturnValue([[200, 100], [210, 95]]);
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ expect(getByTestId('crop-checkbox')).toBeInTheDocument();
+ imageUtilGetCoordsFromPixelValues.mockReturnValue([[-100, 30], [-80, 50]]);
+ });
+
+ it('clamps coordinates below negative bounds (x1<-180, x2<-180, y1<-90, y2<-90)', () => {
+ const { imageUtilGetCoordsFromPixelValues } = require('../../modules/image-download/util');
+ // Both points outside negative bounds → hits x=-180 and y=-90 clamp branches
+ imageUtilGetCoordsFromPixelValues.mockReturnValue([[-200, -100], [-190, -95]]);
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ expect(getByTestId('crop-checkbox')).toBeInTheDocument();
+ imageUtilGetCoordsFromPixelValues.mockReturnValue([[-100, 30], [-80, 50]]);
+ });
+});
+
+// ─── renderSelectionWarning ───────────────────────────────────────────────────
+
+describe('renderSelectionWarning', () => {
+ it('does not render alert by default', () => {
+ const { queryByTestId } = renderComponent();
+ expect(queryByTestId('alert')).not.toBeInTheDocument();
+ });
+
+ it('renders dateline alert when zoomed into dateline (left wing)', () => {
+ const { container } = render(
+ React.createElement(SmartHandoff, {
+ ...defaultProps,
+ map: { ui: { selected: {} }, extent: [-200, -90, -185, 90] },
+ proj: {
+ id: 'geographic',
+ crs: 'EPSG:4326',
+ maxExtent: [-180, -90, 180, 90],
+ },
+ }),
+ );
+ expect(container.querySelector('#data-download-unavailable-dateline-alert')).toBeInTheDocument();
+ });
+
+ it('renders dateline alert when zoomed into dateline (right wing)', () => {
+ const { container } = render(
+ React.createElement(SmartHandoff, {
+ ...defaultProps,
+ map: { ui: { selected: {} }, extent: [185, -90, 200, 90] },
+ proj: {
+ id: 'geographic',
+ crs: 'EPSG:4326',
+ maxExtent: [-180, -90, 180, 90],
+ },
+ }),
+ );
+ expect(container.querySelector('#data-download-unavailable-dateline-alert')).toBeInTheDocument();
+ });
+
+ it('download button not valid when showZoomedIntoDatelineAlert is true', () => {
+ const { getByTestId } = render(
+ React.createElement(SmartHandoff, {
+ ...defaultProps,
+ map: { ui: { selected: {} }, extent: [-200, -90, -185, 90] },
+ proj: {
+ id: 'geographic',
+ crs: 'EPSG:4326',
+ maxExtent: [-180, -90, 180, 90],
+ },
+ }),
+ );
+ expect(getByTestId('download-btn')).toHaveAttribute('data-valid', 'false');
+ });
+});
+
+// ─── onClickDownload ──────────────────────────────────────────────────────────
+
+describe('onClickDownload', () => {
+ it('calls showWarningModal when HIDE_EDS_WARNING not set', () => {
+ safeLocalStorage.getItem.mockReturnValue(null);
+ const showWarningModal = jest.fn();
+ const { getByTestId } = renderComponent({ showWarningModal });
+ fireEvent.click(getByTestId('download-btn'));
+ expect(showWarningModal).toHaveBeenCalledWith(
+ '2020 JAN 01',
+ layer1,
+ defaultProps.selectedCollection,
+ expect.any(Function),
+ );
+ });
+
+ it('calls openEarthDataSearch when HIDE_EDS_WARNING is set', () => {
+ safeLocalStorage.getItem.mockReturnValue('true');
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('download-btn'));
+ expect(openEarthDataSearch).toHaveBeenCalled();
+ });
+
+ it('uses granule date range when isGranuleLayer is true', () => {
+ safeLocalStorage.getItem.mockReturnValue(null);
+ const showWarningModal = jest.fn();
+ const { getByTestId } = renderComponent({
+ showWarningModal,
+ isGranuleLayer: true,
+ startDate: '2020-01-01T00:00:00.000Z',
+ endDate: '2020-01-01T23:59:59.999Z',
+ });
+ fireEvent.click(getByTestId('download-btn'));
+ expect(showWarningModal).toHaveBeenCalledWith(
+ expect.stringContaining(' - '),
+ expect.anything(),
+ expect.anything(),
+ expect.any(Function),
+ );
+ });
+
+ it('continueToEDS calls openEarthDataSearch with correct options', () => {
+ safeLocalStorage.getItem.mockReturnValue(null);
+ let capturedContinue;
+ const showWarningModal = jest.fn((date, layer, collection, continueToEDS) => {
+ capturedContinue = continueToEDS;
+ });
+ const { getByTestId } = renderComponent({ showWarningModal });
+ fireEvent.click(getByTestId('download-btn'));
+ capturedContinue();
+ expect(openEarthDataSearch).toHaveBeenCalledWith(
+ defaultProps.availableTools,
+ expect.objectContaining({
+ projection: defaultProps.proj.crs,
+ conceptId: defaultProps.selectedCollection.value,
+ }),
+ );
+ });
+});
+
+// ─── componentDidMount ────────────────────────────────────────────────────────
+
+describe('componentDidMount', () => {
+ it('calls fetchAvailableTools on mount', () => {
+ const fetchAvailableTools = jest.fn();
+ renderComponent({ fetchAvailableTools });
+ expect(fetchAvailableTools).toHaveBeenCalled();
+ });
+
+ it('calls validateLayersConceptIds with availableLayers on mount', () => {
+ const validateLayersConceptIds = jest.fn();
+ renderComponent({ validateLayersConceptIds });
+ expect(validateLayersConceptIds).toHaveBeenCalledWith([layer1]);
+ });
+
+ it('does not check extent when proj is not geographic', () => {
+ // No dateline alert rendered for non-geographic proj
+ const { queryByTestId } = renderComponent({
+ proj: { id: 'arctic', crs: 'EPSG:3413', maxExtent: [-180, 60, 180, 90] },
+ });
+ expect(queryByTestId('alert')).not.toBeInTheDocument();
+ });
+});
+
+// ─── componentDidUpdate ───────────────────────────────────────────────────────
+
+describe('componentDidUpdate', () => {
+ it('calls validateLayersConceptIds when availableLayers changes', () => {
+ const validateLayersConceptIds = jest.fn();
+ const { rerender } = renderComponent({ validateLayersConceptIds });
+ validateLayersConceptIds.mockClear();
+ const newLayer = { ...layer1, id: 'layer2' };
+ rerender(React.createElement(SmartHandoff, {
+ ...defaultProps,
+ validateLayersConceptIds,
+ availableLayers: [newLayer],
+ }));
+ expect(validateLayersConceptIds).toHaveBeenCalledWith([newLayer]);
+ });
+
+ it('resets to baseState when selectedCollection set but layer no longer active', () => {
+ const { rerender, getByTestId, queryByTestId } = renderComponent();
+ // Toggle bounding box on to verify initial state mutation
+ fireEvent.click(getByTestId('crop-checkbox'));
+ // Rerender with layer gone AND collection cleared (parent would do this after reset)
+ rerender(React.createElement(SmartHandoff, {
+ ...defaultProps,
+ availableLayers: [],
+ selectedCollection: null,
+ validatedLayers: [layer1],
+ }));
+ // showBoundingBox resets to false — crop tool no longer visible
+ expect(queryByTestId('crop-tool')).not.toBeInTheDocument();
+ });
+
+ it('hides bounding box when proj changes away from geographic', () => {
+ const { rerender, getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('crop-checkbox'));
+ rerender(React.createElement(SmartHandoff, {
+ ...defaultProps,
+ proj: { id: 'arctic', crs: 'EPSG:3413', maxExtent: [-180, 60, 180, 90] },
+ }));
+ // Crop box should be gone (not geographic)
+ expect(document.querySelector('.smart-handoff-crop-toggle')).not.toBeInTheDocument();
+ });
+
+ it('re-checks extent when map.extent changes in geographic proj', () => {
+ const { rerender, container } = renderComponent();
+ // Initially normal extent, no alert
+ expect(container.querySelector('#data-download-unavailable-dateline-alert')).not.toBeInTheDocument();
+ // Rerender with dateline extent
+ rerender(React.createElement(SmartHandoff, {
+ ...defaultProps,
+ map: { ui: { selected: {} }, extent: [-200, -90, -185, 90] },
+ }));
+ expect(container.querySelector('#data-download-unavailable-dateline-alert')).toBeInTheDocument();
+ });
+
+ it('clears showZoomedIntoDatelineAlert when proj changes to non-geographic', () => {
+ const { rerender, container } = render(
+ React.createElement(SmartHandoff, {
+ ...defaultProps,
+ map: { ui: { selected: {} }, extent: [-200, -90, -185, 90] },
+ }),
+ );
+ expect(container.querySelector('#data-download-unavailable-dateline-alert')).toBeInTheDocument();
+ rerender(React.createElement(SmartHandoff, {
+ ...defaultProps,
+ map: { ui: { selected: {} }, extent: [-200, -90, -185, 90] },
+ proj: { id: 'arctic', crs: 'EPSG:3413', maxExtent: [-180, 60, 180, 90] },
+ }));
+ expect(container.querySelector('#data-download-unavailable-dateline-alert')).not.toBeInTheDocument();
+ });
+});
+
+// ─── updateSelectionAlerts ────────────────────────────────────────────────────
+
+describe('updateSelectionAlerts', () => {
+ it('renders selection outside extents alert when selection is outside map area', async () => {
+ const { imageUtilGetCoordsFromPixelValues } = require('../../modules/image-download/util');
+ // Return coords outside bounds so x1 > 180 → entireSelectionOutside = true
+ imageUtilGetCoordsFromPixelValues.mockReturnValue([[190, 30], [200, 50]]);
+ const { getByTestId, findByTestId } = renderComponent();
+ await act(async () => {
+ fireEvent.click(getByTestId('crop-checkbox'));
+ });
+ expect(await findByTestId('alert')).toBeInTheDocument();
+ // Restore default mock
+ imageUtilGetCoordsFromPixelValues.mockReturnValue([[-100, 30], [-80, 50]]);
+ });
+});
+
+// ─── mapStateToProps ──────────────────────────────────────────────────────────
+
+describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ screenSize: { screenWidth: 1200, screenHeight: 800, ...overrides.screenSize },
+ map: {
+ ui: { selected: {} },
+ extent: [-180, -90, 180, 90],
+ ...overrides.map,
+ },
+ proj: {
+ selected: {
+ id: 'geographic',
+ crs: 'EPSG:4326',
+ maxExtent: [-180, -90, 180, 90],
+ },
+ ...overrides.proj,
+ },
+ smartHandoffs: {
+ conceptId: 'C1-STD',
+ layerId: 'layer1',
+ availableTools: [],
+ validatedConceptIds: { 'C1-STD': true },
+ validatedLayers: [layer1],
+ isLoadingTools: false,
+ isValidatingCollections: false,
+ requestFailed: false,
+ ...overrides.smartHandoffs,
+ },
+ date: {},
+ layers: {},
+ config: {},
+ ...overrides,
+ });
+
+ beforeEach(() => {
+ const selectors = jest.requireMock('../../modules/smart-handoff/selectors');
+ selectors.getValidLayersForHandoffs.mockReturnValue([layer1]);
+ selectors.getConceptUrl.mockReturnValue((val) => `https://cmr.example.com/${val}`);
+ selectors.getGranulesUrl.mockReturnValue(jest.fn());
+ const dateSelectors = jest.requireMock('../../modules/date/selectors');
+ dateSelectors.getSelectedDate.mockReturnValue(new Date('2020-01-01'));
+ const layerSelectors = jest.requireMock('../../modules/layers/selectors');
+ layerSelectors.getActiveGranuleLayers.mockReturnValue({});
+ });
+
+ it('returns screenWidth and screenHeight from screenSize', () => {
+ const result = capturedMapStateToProps(makeState(), {});
+ expect(result.screenWidth).toBe(1200);
+ expect(result.screenHeight).toBe(800);
+ });
+
+ it('returns proj.selected as proj', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, {});
+ expect(result.proj.id).toBe('geographic');
+ });
+
+ it('returns map from state', () => {
+ const state = makeState();
+ const result = capturedMapStateToProps(state, {});
+ expect(result.map).toBe(state.map);
+ });
+
+ it('returns requestFailed from smartHandoffs', () => {
+ const result = capturedMapStateToProps(makeState({
+ smartHandoffs: { requestFailed: true },
+ }), {});
+ expect(result.requestFailed).toBe(true);
+ });
+
+ it('sets isLoading true when isLoadingTools is true', () => {
+ const result = capturedMapStateToProps(
+ makeState({ smartHandoffs: { isLoadingTools: true } }),
+ {},
+ );
+ expect(result.isLoading).toBe(true);
+ });
+
+ it('sets isLoading true when isValidatingCollections is true', () => {
+ const result = capturedMapStateToProps(
+ makeState({ smartHandoffs: { isValidatingCollections: true } }),
+ {},
+ );
+ expect(result.isLoading).toBe(true);
+ });
+
+ it('selectedLayer is the layer matching layerId', () => {
+ const result = capturedMapStateToProps(makeState(), {});
+ expect(result.selectedLayer).toBe(layer1);
+ });
+
+ it('selectedLayer is undefined when layerId does not match', () => {
+ const result = capturedMapStateToProps(
+ makeState({ smartHandoffs: { layerId: 'nonexistent' } }),
+ {},
+ );
+ expect(result.selectedLayer).toBeUndefined();
+ });
+
+ it('selectedCollection is the collection matching conceptId', () => {
+ const result = capturedMapStateToProps(makeState(), {});
+ expect(result.selectedCollection.value).toBe('C1-STD');
+ });
+
+ it('selectedCollection is undefined when no selectedLayer', () => {
+ const result = capturedMapStateToProps(
+ makeState({ smartHandoffs: { layerId: 'nonexistent' } }),
+ {},
+ );
+ expect(result.selectedCollection).toBeUndefined();
+ });
+
+ it('isGranuleLayer is true for granule type layer', () => {
+ const granuleLayer = { ...layer1, type: 'granule', conceptIds: [{ type: 'STD', value: 'C1-STD' }] };
+ jest.requireMock('../../modules/smart-handoff/selectors')
+ .getValidLayersForHandoffs.mockReturnValue([granuleLayer]);
+ const result = capturedMapStateToProps(makeState(), {});
+ expect(result.isGranuleLayer).toBe(true);
+ });
+
+ it('startDate and endDate come from getStartEndDates for regular layer', () => {
+ const result = capturedMapStateToProps(makeState(), {});
+ expect(result.startDate).toBe('2020-01-01T00:00:00.000Z');
+ expect(result.endDate).toBe('2020-01-01T23:59:59.999Z');
+ });
+
+ it('startDate/endDate are undefined when no selectedLayer', () => {
+ const result = capturedMapStateToProps(
+ makeState({ smartHandoffs: { layerId: 'none' } }),
+ {},
+ );
+ expect(result.startDate).toBeUndefined();
+ expect(result.endDate).toBeUndefined();
+ });
+
+ it('returns validatedConceptIds from smartHandoffs', () => {
+ const result = capturedMapStateToProps(makeState(), {});
+ expect(result.validatedConceptIds).toEqual({ 'C1-STD': true });
+ });
+
+ it('returns availableTools from smartHandoffs', () => {
+ const result = capturedMapStateToProps(makeState(), {});
+ expect(result.availableTools).toEqual([]);
+ });
+});
+
+// ─── mapDispatchToProps ───────────────────────────────────────────────────────
+
+describe('mapDispatchToProps', () => {
+ let dispatch;
+ let mapped;
+
+ beforeEach(() => {
+ dispatch = jest.fn();
+ mapped = capturedMapDispatchToProps(dispatch);
+ });
+
+ it('selectCollection dispatches selectCollectionAction', () => {
+ mapped.selectCollection('C1-STD', 'layer1');
+ expect(selectCollectionAction).toHaveBeenCalledWith('C1-STD', 'layer1');
+ expect(dispatch).toHaveBeenCalled();
+ });
+
+ it('fetchAvailableTools dispatches fetchAvailableToolsAction', () => {
+ mapped.fetchAvailableTools();
+ expect(fetchAvailableToolsAction).toHaveBeenCalled();
+ expect(dispatch).toHaveBeenCalled();
+ });
+
+ it('validateLayersConceptIds dispatches validateLayersConceptIdsAction', () => {
+ mapped.validateLayersConceptIds([layer1]);
+ expect(validateLayersConceptIdsAction).toHaveBeenCalledWith([layer1]);
+ expect(dispatch).toHaveBeenCalled();
+ });
+
+ it('showWarningModal pushes GTM event', () => {
+ mapped.showWarningModal('2020 JAN 01', layer1, { value: 'C1-STD' }, jest.fn());
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({
+ event: 'smart_handoffs_open_warning_modal',
+ });
+ });
+
+ it('showWarningModal dispatches openCustomContent', () => {
+ mapped.showWarningModal('2020 JAN 01', layer1, { value: 'C1-STD' }, jest.fn());
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'transferring-to-earthdata-search',
+ expect.objectContaining({ headerText: 'Leaving @NAME@' }),
+ );
+ expect(dispatch).toHaveBeenCalled();
+ });
+
+ it('showNotAvailableModal dispatches openCustomContent', () => {
+ mapped.showNotAvailableModal();
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'layers-not-available',
+ expect.objectContaining({ headerText: 'Data Download Availability' }),
+ );
+ });
+
+ it('showGranuleHelpModal pushes GTM event', () => {
+ mapped.showGranuleHelpModal();
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({
+ event: 'smart_handoffs_open_granule_help_link',
+ });
+ });
+
+ it('showGranuleHelpModal dispatches openCustomContent', () => {
+ mapped.showGranuleHelpModal();
+ expect(openCustomContent).toHaveBeenCalledWith(
+ 'granule-help',
+ expect.objectContaining({ headerText: 'Granule Availability' }),
+ );
+ });
});
diff --git a/web/js/containers/sidebar/zot.test.js b/web/js/containers/sidebar/zot.test.js
index f25fecb9a..2fc49202e 100644
--- a/web/js/containers/sidebar/zot.test.js
+++ b/web/js/containers/sidebar/zot.test.js
@@ -1,3 +1,234 @@
-test('zot container test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// ─── Mocks ────────────────────────────────────────────────────────────────────
+
+jest.mock('../../util/util', () => ({
+ __esModule: true,
+ default: {
+ encodeId: jest.fn((id) => String(id).replace(/[^a-zA-Z0-9]/g, '-')),
+ },
+}));
+
+jest.mock('reactstrap', () => ({
+ UncontrolledTooltip: function MockTooltip({ children, target, delay, autohide }) {
+ const React = require('react');
+ return React.createElement(
+ 'div',
+ {
+ 'data-testid': 'tooltip',
+ 'data-target': target,
+ 'data-delay-show': delay ? delay.show : undefined,
+ 'data-delay-hide': delay ? delay.hide : undefined,
+ 'data-autohide': String(autohide),
+ },
+ children,
+ );
+ },
+}));
+
+// ─── Imports after mocks ──────────────────────────────────────────────────────
+
+import Zot from './zot';
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+const defaultProps = {
+ layer: 'layer-abc',
+ zot: null,
+ isMobile: false,
+};
+
+const renderComponent = (propOverrides = {}) => render(
+ <Zot {...defaultProps} {...propOverrides} />,
+);
+
+// ─── Base rendering ───────────────────────────────────────────────────────────
+
+describe('Zot base rendering', () => {
+ it('renders a div with default "zot" class when zot prop is null', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.zot')).toBeInTheDocument();
+ });
+
+ it('renders the "!" bold marker', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('b').textContent).toBe('!');
+ });
+
+ it('renders UncontrolledTooltip', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('tooltip')).toBeInTheDocument();
+ });
+
+ it('sets tooltip target to encoded layer id with -zot suffix', () => {
+ const { getByTestId } = renderComponent({ layer: 'my:layer' });
+ expect(getByTestId('tooltip')).toHaveAttribute('data-target', 'my-layer-zot');
+ });
+
+ it('sets div id to encoded layer id with -zot suffix', () => {
+ const { container } = renderComponent({ layer: 'my:layer' });
+ expect(container.querySelector('.zot').id).toBe('my-layer-zot');
+ });
+
+ it('calls util.encodeId with the layer prop', () => {
+ const { default: util } = require('../../util/util');
+ renderComponent({ layer: 'test-layer' });
+ expect(util.encodeId).toHaveBeenCalledWith('test-layer');
+ });
+});
+
+// ─── isMobile delay ───────────────────────────────────────────────────────────
+
+describe('Zot isMobile delay', () => {
+ it('uses show:50, hide:500 delay when isMobile is false', () => {
+ const { getByTestId } = renderComponent({ isMobile: false });
+ expect(getByTestId('tooltip')).toHaveAttribute('data-delay-show', '50');
+ expect(getByTestId('tooltip')).toHaveAttribute('data-delay-hide', '500');
+ });
+
+ it('uses show:300, hide:300 delay when isMobile is true', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(getByTestId('tooltip')).toHaveAttribute('data-delay-show', '300');
+ expect(getByTestId('tooltip')).toHaveAttribute('data-delay-hide', '300');
+ });
+
+ it('passes autohide=false to tooltip when isMobile is false', () => {
+ const { getByTestId } = renderComponent({ isMobile: false });
+ expect(getByTestId('tooltip')).toHaveAttribute('data-autohide', 'false');
+ });
+
+ it('passes autohide=true to tooltip when isMobile is true', () => {
+ const { getByTestId } = renderComponent({ isMobile: true });
+ expect(getByTestId('tooltip')).toHaveAttribute('data-autohide', 'true');
+ });
+});
+
+// ─── no zot prop ──────────────────────────────────────────────────────────────
+
+describe('Zot with no zot prop', () => {
+ it('renders plain "zot" class when zot is null', () => {
+ const { container } = renderComponent({ zot: null });
+ expect(container.querySelector('.zot').className).toBe('zot');
+ });
+
+ it('renders empty tooltip content when zot is null', () => {
+ const { getByTestId } = renderComponent({ zot: null });
+ const inner = getByTestId('tooltip').querySelector('[dangerouslySetInnerHTML]') || getByTestId('tooltip').querySelector('div');
+ expect(inner).toBeInTheDocument();
+ });
+});
+
+// ─── overZoomValue ────────────────────────────────────────────────────────────
+
+describe('Zot with overZoomValue', () => {
+ it('adds "overzoom" class when overZoomValue is set', () => {
+ const { container } = renderComponent({ zot: { overZoomValue: 3 } });
+ expect(container.querySelector('.zot')).toHaveClass('overzoom');
+ });
+
+ it('does not add "underzoom" class when overZoomValue is set', () => {
+ const { container } = renderComponent({ zot: { overZoomValue: 3 } });
+ expect(container.querySelector('.zot')).not.toHaveClass('underzoom');
+ });
+
+ it('tooltip contains overzoomed message with multiplier', () => {
+ const { getByTestId } = renderComponent({ zot: { overZoomValue: 2 } });
+ expect(getByTestId('tooltip').innerHTML).toContain('overzoomed by 2x');
+ });
+});
+
+// ─── underZoomValue ───────────────────────────────────────────────────────────
+
+describe('Zot with underZoomValue', () => {
+ it('adds "underzoom" class when underZoomValue > 0', () => {
+ const { container } = renderComponent({ zot: { underZoomValue: 4 } });
+ expect(container.querySelector('.zot')).toHaveClass('underzoom');
+ });
+
+ it('does not add "overzoom" class when only underZoomValue is set', () => {
+ const { container } = renderComponent({ zot: { underZoomValue: 4 } });
+ expect(container.querySelector('.zot')).not.toHaveClass('overzoom');
+ });
+
+ it('tooltip contains underzoomed message with multiplier', () => {
+ const { getByTestId } = renderComponent({ zot: { underZoomValue: 4 } });
+ expect(getByTestId('tooltip').innerHTML).toContain('underzoomed by 4x');
+ });
+
+ it('does not add underzoom class when underZoomValue is 0', () => {
+ const { container } = renderComponent({ zot: { underZoomValue: 0 } });
+ expect(container.querySelector('.zot').className).toBe('zot');
+ });
+
+ it('does not add underzoom class when underZoomValue is negative', () => {
+ const { container } = renderComponent({ zot: { underZoomValue: -1 } });
+ expect(container.querySelector('.zot').className).toBe('zot');
+ });
+});
+
+// ─── hasGranules ──────────────────────────────────────────────────────────────
+
+describe('Zot with hasGranules', () => {
+ it('adds "no-granules" class when hasGranules is false and property exists', () => {
+ const { container } = renderComponent({ zot: { hasGranules: false } });
+ expect(container.querySelector('.zot')).toHaveClass('no-granules');
+ });
+
+ it('does not add "no-granules" class when hasGranules is true', () => {
+ const { container } = renderComponent({ zot: { hasGranules: true } });
+ expect(container.querySelector('.zot').className).toBe('zot');
+ });
+
+ it('does not add "no-granules" class when hasGranules key is absent', () => {
+ const { container } = renderComponent({ zot: {} });
+ expect(container.querySelector('.zot').className).toBe('zot');
+ });
+
+ it('tooltip contains no-imagery message when hasGranules is false', () => {
+ const { getByTestId } = renderComponent({ zot: { hasGranules: false } });
+ expect(getByTestId('tooltip').innerHTML).toContain('No visible imagery');
+ });
+});
+
+// ─── layerNotices ─────────────────────────────────────────────────────────────
+
+describe('Zot with layerNotices', () => {
+ it('adds "layer-notice" class when layerNotices is set', () => {
+ const { container } = renderComponent({ zot: { layerNotices: 'Some notice.' } });
+ expect(container.querySelector('.zot')).toHaveClass('layer-notice');
+ });
+
+ it('appends layerNotices text to tooltip', () => {
+ const { getByTestId } = renderComponent({ zot: { layerNotices: 'Custom notice text.' } });
+ expect(getByTestId('tooltip').innerHTML).toContain('Custom notice text.');
+ });
+
+ it('applies both "overzoom" and "layer-notice" classes when both are set', () => {
+ const { container } = renderComponent({ zot: { overZoomValue: 2, layerNotices: 'Also a notice.' } });
+ const el = container.querySelector('.zot');
+ expect(el).toHaveClass('overzoom');
+ expect(el).toHaveClass('layer-notice');
+ });
+
+ it('tooltip contains both overzoom and notice text when both are set', () => {
+ const { getByTestId } = renderComponent({ zot: { overZoomValue: 2, layerNotices: 'Notice here.' } });
+ expect(getByTestId('tooltip').innerHTML).toContain('overzoomed by 2x');
+ expect(getByTestId('tooltip').innerHTML).toContain('Notice here.');
+ });
+
+ it('layerNotices overrides underzoom class (layerNotices wins)', () => {
+ const { container } = renderComponent({ zot: { underZoomValue: 3, layerNotices: 'A notice.' } });
+ const el = container.querySelector('.zot');
+ expect(el).toHaveClass('layer-notice');
+ });
+
+ it('layerNotices overrides no-granules class', () => {
+ const { container } = renderComponent({ zot: { hasGranules: false, layerNotices: 'A notice.' } });
+ const el = container.querySelector('.zot');
+ expect(el).toHaveClass('layer-notice');
+ expect(el).not.toHaveClass('no-granules');
+ });
});