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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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.jsindex 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');+ });});