Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

Checking next round of unit tests for components/ dir

Jason Hurleyee0c65531ca6
diff --git a/web/js/components/sidebar/charting-mode-options.test.js b/web/js/components/sidebar/charting-mode-options.test.js
index 4b9586d28..39aca49d7 100644
--- a/web/js/components/sidebar/charting-mode-options.test.js
+++ b/web/js/components/sidebar/charting-mode-options.test.js
@@ -1,3 +1,515 @@
-test('charting-mode-options component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import {
+ render, fireEvent, act, waitFor,
+} from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import ChartingModeOptions from './charting-mode-options';
+let capturedPostrender = null;
+
+jest.mock('ol/proj', () => ({
+ // identity transform that returns numbers so .toFixed works
+ transform: (coord) => [coord[0], coord[1]],
+}));
+
+jest.mock('ol/source', () => ({
+ Vector: class {},
+}));
+
+jest.mock('googleTagManager', () => ({
+ pushEvent: jest.fn(),
+}));
+
+jest.mock('../charting/charting-info', () => () => null);
+jest.mock('../charting/charting-error', () => () => null);
+jest.mock('../charting/simple-statistics', () => () => null);
+jest.mock('../charting/charting-date-selector', () => () => null);
+jest.mock('../charting/chart-component', () => () => null);
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: (props) => (
+ <span data-testid="fa-info" onClick={props.onClick} />
+ ),
+}));
+
+jest.mock('../image-download/lat-long-inputs', () => (props) => (
+ <button
+ type="button"
+ data-testid="lat-long-select"
+ onClick={() => props.onLatLongChange([10, 20, 30, 40])}
+ >
+ latlong
+ </button>
+));
+
+jest.mock('../util/checkbox', () => (props) => (
+ <button type="button" data-testid="map-view-checkbox" onClick={props.onCheck}>
+ {`checked:${props.checked}`}
+ </button>
+));
+
+jest.mock('../util/button', () => (props) => (
+ <button
+ type="button"
+ data-testid={props.id}
+ data-valid={`${props.valid}`}
+ onClick={props.onClick}
+ >
+ {typeof props.text === 'string' ? props.text : 'btn'}
+ </button>
+));
+
+jest.mock('../util/image-crop', () => (props) => (
+ <button
+ type="button"
+ data-testid="crop"
+ onClick={() => props.onChange({
+ x: 5, y: 5, width: 60, height: 60,
+ })}
+ >
+ crop
+ </button>
+));
+
+jest.mock('../util/wait', () => (props) => (
+ <button type="button" data-testid="wait-cancel" onClick={props.onCancel}>
+ {props.statusText}
+ </button>
+));
+
+jest.mock('../../modules/charting/actions', () => ({
+ updateChartingAOICoordinates: jest.fn((extent) => ({ type: 'AOI', extent })),
+ updateChartingDateSelection: jest.fn((b) => ({ type: 'DATE_SELECTION', b })),
+ updateRequestInProgressAction: jest.fn((s) => ({ type: 'REQ', s })),
+ updateModalOpenAction: jest.fn((s) => ({ type: 'MODAL_OPEN', s })),
+ changeChartingStartDate: jest.fn((d) => ({ type: 'START', d })),
+ changeChartingEndDate: jest.fn((d) => ({ type: 'END', d })),
+}));
+
+jest.mock('../../modules/modal/actions', () => ({
+ openCustomContent: jest.fn((key, opts) => ({ type: 'OPEN_CUSTOM', key, opts })),
+ onClose: jest.fn(() => ({ type: 'CLOSE' })),
+}));
+
+const { openCustomContent } = require('../../modules/modal/actions');
+
+function createOlMap(overrides = {}) {
+ return {
+ getCoordinateFromPixel: jest.fn(([px, py]) => [px, py]),
+ getPixelFromCoordinate: jest.fn(([lon, lat]) => [lon + 100, lat + 100]),
+ getView: jest.fn(() => ({
+ calculateExtent: jest.fn(() => [-50, -50, 50, 50]),
+ })),
+ getSize: jest.fn(() => [800, 600]),
+ once: jest.fn((event, cb) => {
+ capturedPostrender = cb;
+ }),
+ ...overrides,
+ };
+}
+
+const layer = {
+ id: 'MODIS_Layer',
+ title: 'MODIS Title',
+ subtitle: 'MODIS Subtitle',
+ startDate: '2020-01-01T00:00:00Z',
+ endDate: '2024-01-01T00:00:00Z',
+ palette: { id: 'modis_palette' },
+ projections: { geographic: { source: 'GIBS:geographic' } },
+};
+
+function buildState(overrides = {}) {
+ const charting = {
+ activeLayer: 'MODIS_Layer',
+ aoiActive: false,
+ aoiCoordinates: [],
+ aoiSelected: false,
+ chartRequestInProgress: false,
+ timeSpanSelection: 'range',
+ timeSpanStartDate: new Date('2023-05-01T00:00:00Z'),
+ timeSpanEndDate: new Date('2023-05-03T00:00:00Z'),
+ fromButton: false,
+ isChartOpen: false,
+ ...(overrides.charting || {}),
+ };
+ return {
+ charting,
+ map: { ui: { selected: overrides.olMap === undefined ? createOlMap() : overrides.olMap } },
+ proj: {
+ selected: {
+ crs: 'EPSG:4326',
+ maxExtent: overrides.maxExtent === undefined ? [-180, -90, 180, 90] : overrides.maxExtent,
+ },
+ },
+ config: { projections: { geographic: { crs: 'EPSG:4326' } } },
+ layers: { active: { layers: overrides.layers || [layer] } },
+ date: {
+ selected: new Date('2023-05-02T00:00:00Z'),
+ appNow: new Date('2023-06-01T00:00:00Z'),
+ },
+ palettes: {
+ rendered: overrides.renderedPalettes === undefined
+ ? { modis_palette: { maps: [{ legend: { units: 'K' } }] } }
+ : overrides.renderedPalettes,
+ },
+ screenSize: {
+ screenWidth: overrides.screenWidth || 1024,
+ screenHeight: overrides.screenHeight || 768,
+ },
+ modal: {
+ isOpen: overrides.isModalOpen || false,
+ id: overrides.modalId || '',
+ },
+ };
+}
+
+const mockStore = configureStore([]);
+
+function renderComponent(stateOverrides = {}, ownProps = {}) {
+ const store = mockStore(buildState(stateOverrides));
+ store.dispatch = jest.fn();
+ const utils = render(
+ <Provider store={store}>
+ <ChartingModeOptions
+ isChartingActive
+ isMobile={false}
+ sidebarHeight={500}
+ {...ownProps}
+ />
+ </Provider>,
+ );
+ return { store, ...utils };
+}
+
+const statsBody = {
+ min: { '2023-05-01T00:00:00Z': '1.234', '2023-05-02T00:00:00Z': '2.345' },
+ max: { '2023-05-01T00:00:00Z': '5.111', '2023-05-02T00:00:00Z': '6.222' },
+ mean: { '2023-05-01T00:00:00Z': '3.0', '2023-05-02T00:00:00Z': '4.0' },
+ median: { '2023-05-01T00:00:00Z': '3.0', '2023-05-02T00:00:00Z': '4.0' },
+ stdev: { '2023-05-01T00:00:00Z': '0.5', '2023-05-02T00:00:00Z': '0.6' },
+ errors: { error_count: 0, error_days: [] },
+ hist: [],
+ stderr: 0,
+};
+
+function mockFetchText(text) {
+ global.fetch = jest.fn(() => Promise.resolve({ text: () => Promise.resolve(text) }));
+}
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ capturedPostrender = null;
+});
+
+describe('ChartingModeOptions rendering', () => {
+ it('returns null when olMap is not present', () => {
+ const { container } = renderComponent({ olMap: null });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders the charting container, title and layer name', () => {
+ const { getByText, getByTestId } = renderComponent();
+ expect(getByText('Charting Mode - BETA')).toBeTruthy();
+ expect(getByText('MODIS Title')).toBeTruthy();
+ expect(getByTestId('charting-date-button')).toBeTruthy();
+ expect(getByTestId('charting-create-button')).toBeTruthy();
+ });
+
+ it('shows date range value for range selection and single date label for date selection', () => {
+ const { getByTestId } = renderComponent({ charting: { timeSpanSelection: 'date' } });
+ expect(getByTestId('charting-date-button')).toBeTruthy();
+ });
+
+ it('handles getLatLongFromPixelValue returning [0,0] when no coordinate', () => {
+ const olMap = createOlMap({ getCoordinateFromPixel: jest.fn(() => null) });
+ const { getByText } = renderComponent({ olMap });
+ expect(getByText('Charting Mode - BETA')).toBeTruthy();
+ });
+
+ it('renders in-progress spinner text when a chart request is in progress', () => {
+ const { getByTestId } = renderComponent({ charting: { chartRequestInProgress: true } });
+ expect(getByTestId('wait-cancel')).toBeTruthy();
+ });
+});
+
+describe('ChartingModeOptions interactions', () => {
+ it('dispatches date selection when One Date / Date Range buttons are clicked', () => {
+ const { getByText, store } = renderComponent();
+ fireEvent.click(getByText('One Date'));
+ fireEvent.click(getByText('Date Range'));
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+
+ it('opens the charting info modal when info icon is clicked', () => {
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('fa-info'));
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING_INFO_MODAL', expect.any(Object));
+ });
+
+ it('opens the date modal and sets css offset when date button is clicked', () => {
+ const setProperty = jest.spyOn(document.body.style, 'setProperty');
+ const { getByTestId } = renderComponent();
+ fireEvent.click(getByTestId('charting-date-button'));
+ expect(setProperty).toHaveBeenCalledWith('--charting-date-modal-offset', '450px');
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING-DATE-MODAL', expect.any(Object));
+ });
+
+ it('updates coordinates when lat/long inputs change', () => {
+ const { getByTestId, store } = renderComponent();
+ fireEvent.click(getByTestId('lat-long-select'));
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+
+ it('toggles map view selection on and off', () => {
+ const { getByTestId } = renderComponent();
+ const checkbox = getByTestId('map-view-checkbox');
+ fireEvent.click(checkbox);
+ fireEvent.click(checkbox);
+ expect(checkbox).toBeTruthy();
+ });
+
+ it('renders the Crop component and handles boundary updates when AOI is active', () => {
+ const { getByTestId, store } = renderComponent(
+ { charting: { aoiActive: true, fromButton: true } },
+ );
+ const crop = getByTestId('crop');
+ fireEvent.click(crop);
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+});
+
+describe('ChartingModeOptions chart request flow', () => {
+ it('opens an error modal when no valid layer is detected', async () => {
+ mockFetchText(JSON.stringify(statsBody));
+ const { getByTestId } = renderComponent({ charting: { activeLayer: 'does-not-exist' } });
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING_ERROR_MODAL', expect.any(Object));
+ });
+
+ it('generates a chart for a range request (GIBS layer) and opens the chart modal', async () => {
+ mockFetchText(JSON.stringify(statsBody));
+ const { getByTestId } = renderComponent();
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING-CHART', expect.any(Object));
+ });
+ });
+
+ it('generates simple statistics for a single date request', async () => {
+ mockFetchText(JSON.stringify(statsBody));
+ const { getByTestId } = renderComponent({ charting: { timeSpanSelection: 'date' } });
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING-STATS-MODAL', expect.any(Object));
+ });
+ });
+
+ it('opens an error modal when the server returns "Internal Server Error"', async () => {
+ mockFetchText('Internal Server Error');
+ const { getByTestId } = renderComponent();
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING_ERROR_MODAL', expect.any(Object));
+ });
+ });
+
+ it('opens an error modal when no data is returned', async () => {
+ mockFetchText('null');
+ const { getByTestId } = renderComponent();
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING_ERROR_MODAL', expect.any(Object));
+ });
+ });
+
+ it('opens an error modal when fetch throws', async () => {
+ global.fetch = jest.fn(() => Promise.reject(new Error('network')));
+ const { getByTestId } = renderComponent();
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING_ERROR_MODAL', expect.any(Object));
+ });
+ });
+
+ it('opens an error modal when response status is 204', async () => {
+ mockFetchText(JSON.stringify({ status: 204 }));
+ const { getByTestId } = renderComponent();
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING_ERROR_MODAL', expect.any(Object));
+ });
+ });
+
+ it('handles a non-GIBS layer source without making a request', async () => {
+ const nonGibsLayer = {
+ ...layer,
+ projections: { geographic: { source: 'OTHER' } },
+ };
+ const { getByTestId } = renderComponent({ layers: [nonGibsLayer] });
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ expect(openCustomContent).not.toHaveBeenCalledWith('CHARTING-CHART', expect.any(Object));
+ });
+
+ it('does nothing when a request is already in progress', async () => {
+ mockFetchText(JSON.stringify(statsBody));
+ const { getByTestId } = renderComponent({ charting: { chartRequestInProgress: true } });
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ expect(global.fetch).not.toHaveBeenCalled();
+ });
+
+ it('renders a chart with error days included in the dataset', async () => {
+ const bodyWithErrors = {
+ ...statsBody,
+ errors: { error_count: 2, error_days: "['2023-05-04T00:00:00Z','2023-05-05T00:00:00Z']" },
+ };
+ mockFetchText(JSON.stringify(bodyWithErrors));
+ const { getByTestId } = renderComponent();
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING-CHART', expect.any(Object));
+ });
+ });
+
+ it('generates a chart on a wide screen (wide modal layout)', async () => {
+ mockFetchText(JSON.stringify(statsBody));
+ const { getByTestId } = renderComponent({ screenWidth: 1200 });
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING-CHART', expect.any(Object));
+ });
+ });
+
+ it('combines multiple requests for a long date range', async () => {
+ mockFetchText(JSON.stringify(statsBody));
+ const { getByTestId } = renderComponent({
+ charting: {
+ timeSpanSelection: 'range',
+ timeSpanStartDate: new Date('2023-05-01T00:00:00Z'),
+ timeSpanEndDate: new Date('2023-06-10T00:00:00Z'),
+ },
+ });
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(global.fetch.mock.calls.length).toBeGreaterThan(1);
+ });
+ });
+
+ it('auto-renders a chart when isChartOpen is set and the palette is rendered', async () => {
+ mockFetchText(JSON.stringify(statsBody));
+ renderComponent({ charting: { isChartOpen: true, fromButton: true } });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING-CHART', expect.any(Object));
+ });
+ });
+
+ it('handles a palette legend without units', async () => {
+ mockFetchText(JSON.stringify(statsBody));
+ const { getByTestId } = renderComponent({
+ renderedPalettes: { modis_palette: { maps: [{ legend: {} }] } },
+ });
+ await act(async () => {
+ fireEvent.click(getByTestId('charting-create-button'));
+ });
+ await waitFor(() => {
+ expect(openCustomContent).toHaveBeenCalledWith('CHARTING-CHART', expect.any(Object));
+ });
+ });
+});
+
+describe('ChartingModeOptions cancel + modal effects', () => {
+ it('cancels an in-progress chart request', () => {
+ const { getByTestId, store } = renderComponent({ charting: { chartRequestInProgress: true } });
+ fireEvent.click(getByTestId('wait-cancel'));
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+
+ it('updates modal open state when the chart modal is open', () => {
+ const { store } = renderComponent({ modalId: 'CHARTING-CHART', isModalOpen: true });
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+
+ it('resets request status when the chart modal is closed', () => {
+ const { store } = renderComponent({ modalId: 'CHARTING-CHART', isModalOpen: false });
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+});
+
+describe('ChartingModeOptions postrender behavior', () => {
+ it('initializes dates and AOI on postrender when no aoi coordinates exist', () => {
+ renderComponent();
+ expect(capturedPostrender).toBeInstanceOf(Function);
+ act(() => {
+ capturedPostrender();
+ });
+ });
+
+ it('uses existing aoi coordinates on postrender and checks map view match', () => {
+ renderComponent({
+ charting: { aoiCoordinates: [-50, -50, 50, 50] },
+ });
+ expect(capturedPostrender).toBeInstanceOf(Function);
+ act(() => {
+ capturedPostrender();
+ });
+ });
+
+ it('handles postrender with aoi coordinates that do not match the view extent', () => {
+ renderComponent({
+ charting: { aoiCoordinates: [1, 2, 3, 4] },
+ });
+ act(() => {
+ capturedPostrender();
+ });
+ });
+});
+
+describe('ChartingModeOptions screen resize', () => {
+ it('recomputes boundaries when the screen size changes', () => {
+ const store = mockStore(buildState());
+ store.dispatch = jest.fn();
+ const { rerender } = render(
+ <Provider store={store}>
+ <ChartingModeOptions isChartingActive isMobile={false} sidebarHeight={500} />
+ </Provider>,
+ );
+ const resizedStore = mockStore(buildState({ screenWidth: 500, screenHeight: 400 }));
+ resizedStore.dispatch = jest.fn();
+ rerender(
+ <Provider store={resizedStore}>
+ <ChartingModeOptions isChartingActive isMobile={false} sidebarHeight={500} />
+ </Provider>,
+ );
+ expect(resizedStore.dispatch).toBeDefined();
+ });
+
+ it('handles maxExtent being absent', () => {
+ const { getByText } = renderComponent({ maxExtent: null });
+ expect(getByText('Charting Mode - BETA')).toBeTruthy();
+ });
});
diff --git a/web/js/components/sidebar/collapsed-button.test.js b/web/js/components/sidebar/collapsed-button.test.js
index b435b2494..c5003762b 100644
--- a/web/js/components/sidebar/collapsed-button.test.js
+++ b/web/js/components/sidebar/collapsed-button.test.js
@@ -1,3 +1,43 @@
-test('collapse-button component test', () => {
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import CollapsedButton from './collapsed-button';
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: (props) => <span data-testid={`fa-${props.icon}`} className={props.className} />,
+}));
+
+describe('CollapsedButton', () => {
+ it('renders the expand button with the correct aria-label', () => {
+ const { getByLabelText } = render(<CollapsedButton numberOfLayers={3} onclick={() => {}} />);
+ expect(getByLabelText('Expand sidebar')).toBeTruthy();
+ });
+
+ it('renders desktop layout with "N Layers" text and a caret icon', () => {
+ const { getByText, getByTestId, container } = render(
+ <CollapsedButton isMobile={false} numberOfLayers={5} onclick={() => {}} />,
+ );
+ expect(getByText('5 Layers')).toBeTruthy();
+ expect(getByTestId('fa-caret-down')).toBeTruthy();
+ expect(getByTestId('fa-layer-group')).toBeTruthy();
+ expect(container.querySelector('.sidebar-expand')).toBeTruthy();
+ expect(container.querySelector('.sidebar-expand.mobile')).toBeNull();
+ });
+
+ it('renders mobile layout with just the count and no caret icon', () => {
+ const { getByText, queryByTestId, container } = render(
+ <CollapsedButton isMobile numberOfLayers={7} onclick={() => {}} />,
+ );
+ expect(getByText('7')).toBeTruthy();
+ expect(queryByTestId('fa-caret-down')).toBeNull();
+ expect(container.querySelector('.sidebar-expand.mobile')).toBeTruthy();
+ });
+
+ it('calls onclick when the button is clicked', () => {
+ const onclick = jest.fn();
+ const { getByLabelText } = render(
+ <CollapsedButton isMobile={false} numberOfLayers={2} onclick={onclick} />,
+ );
+ fireEvent.click(getByLabelText('Expand sidebar'));
+ expect(onclick).toHaveBeenCalledTimes(1);
+ });
});
diff --git a/web/js/components/sidebar/compare-mode-options.test.js b/web/js/components/sidebar/compare-mode-options.test.js
index 15eb19ec2..40c4b52f2 100644
--- a/web/js/components/sidebar/compare-mode-options.test.js
+++ b/web/js/components/sidebar/compare-mode-options.test.js
@@ -1,3 +1,67 @@
-test('compare-mode-options component test', () => {
+import { render, fireEvent } from '@testing-library/react';
+import CompareModeOptions from './compare-mode-options';
+describe('CompareModeOptions', () => {
+ it('is visible when active and not mobile', () => {
+ const { container } = render(
+ <CompareModeOptions isActive isMobile={false} selected="swipe" onclick={() => {}} />,
+ );
+ const wrapper = container.querySelector('#wv-ab-mode-selection-case');
+ expect(wrapper).toBeTruthy();
+ expect(wrapper.style.display).toBe('block');
+ });
+
+ it('is hidden when not active', () => {
+ const { container } = render(
+ <CompareModeOptions isActive={false} isMobile={false} selected="swipe" onclick={() => {}} />,
+ );
+ expect(container.querySelector('#wv-ab-mode-selection-case').style.display).toBe('none');
+ });
+
+ it('is hidden on mobile even when active', () => {
+ const { container } = render(
+ <CompareModeOptions isActive isMobile selected="swipe" onclick={() => {}} />,
+ );
+ expect(container.querySelector('#wv-ab-mode-selection-case').style.display).toBe('none');
+ });
+
+ it('renders the title and the three comparison type buttons', () => {
+ const { getByText } = render(
+ <CompareModeOptions isActive isMobile={false} selected="swipe" onclick={() => {}} />,
+ );
+ expect(getByText('Comparison Mode')).toBeTruthy();
+ expect(getByText('Swipe')).toBeTruthy();
+ expect(getByText('Opacity')).toBeTruthy();
+ expect(getByText('Spy')).toBeTruthy();
+ });
+
+ it('disables only the currently selected mode button', () => {
+ const { getByText } = render(
+ <CompareModeOptions isActive isMobile={false} selected="opacity" onclick={() => {}} />,
+ );
+ expect(getByText('Swipe').disabled).toBe(false);
+ expect(getByText('Opacity').disabled).toBe(true);
+ expect(getByText('Spy').disabled).toBe(false);
+ });
+
+ it('calls onclick with the mode when an enabled button is clicked', () => {
+ const onclick = jest.fn();
+ const { getByText } = render(
+ <CompareModeOptions isActive isMobile={false} selected="swipe" onclick={onclick} />,
+ );
+ fireEvent.click(getByText('Opacity'));
+ expect(onclick).toHaveBeenCalledWith('opacity');
+
+ fireEvent.click(getByText('Spy'));
+ expect(onclick).toHaveBeenCalledWith('spy');
+ });
+
+ it('calls onclick with "swipe" when the Swipe button is enabled and clicked', () => {
+ const onclick = jest.fn();
+ const { getByText } = render(
+ <CompareModeOptions isActive isMobile={false} selected="opacity" onclick={onclick} />,
+ );
+ fireEvent.click(getByText('Swipe'));
+ expect(onclick).toHaveBeenCalledWith('swipe');
+ });
});
diff --git a/web/js/components/sidebar/event-icon.test.js b/web/js/components/sidebar/event-icon.test.js
index 85a6be1a0..57fb3c40d 100644
--- a/web/js/components/sidebar/event-icon.test.js
+++ b/web/js/components/sidebar/event-icon.test.js
@@ -1,3 +1,29 @@
-test('event-icon component test', () => {
+import { render } from '@testing-library/react';
+import EventIcon from './event-icon';
+describe('EventIcon', () => {
+ it('renders the icon element with id and category-based class', () => {
+ const { container } = render(<EventIcon id="EONET_123" category="Wildfires" title="Fire" />);
+ const icon = container.querySelector('#EONET_123Wildfires');
+ expect(icon).toBeTruthy();
+ expect(icon.className).toBe('event-icon event-icon-Wildfires');
+ });
+
+ it('renders the tooltip when hideTooltip is not set', () => {
+ // UncontrolledTooltip branch should be exercised without throwing
+ const { container } = render(<EventIcon id="a" category="Storms" title="A Storm" />);
+ expect(container.querySelector('#aStorms')).toBeTruthy();
+ });
+
+ it('does not render a tooltip when hideTooltip is true', () => {
+ const { container } = render(
+ <EventIcon id="b" category="Floods" title="A Flood" hideTooltip />,
+ );
+ expect(container.querySelector('#bFloods')).toBeTruthy();
+ });
+
+ it('falls back to category when no title is provided', () => {
+ const { container } = render(<EventIcon id="c" category="Drought" />);
+ expect(container.querySelector('#cDrought')).toBeTruthy();
+ });
});
diff --git a/web/js/components/sidebar/event.test.js b/web/js/components/sidebar/event.test.js
index deb60ee93..3d559eeff 100644
--- a/web/js/components/sidebar/event.test.js
+++ b/web/js/components/sidebar/event.test.js
@@ -1,3 +1,246 @@
-test('event component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent } from '@testing-library/react';
+import Event from './event';
+import util from '../../util/util';
+jest.mock('googleTagManager', () => ({
+ pushEvent: jest.fn(),
+}));
+
+jest.mock('./event-icon', () => (props) => (
+ <span data-testid="event-icon" data-category={props.category} />
+));
+
+jest.mock('../util/monospace-date', () => (props) => (
+ <span data-testid="monospace-date">{props.date}</span>
+));
+
+const googleTagManager = require('googleTagManager');
+
+const date1 = '2023-05-01T00:00:00Z';
+const date2 = '2023-05-02T00:00:00Z';
+
+function buildEvent(overrides = {}) {
+ return {
+ id: 'EONET_1000',
+ title: 'Test Wildfire',
+ categories: [{ id: 'wildfires', title: 'Wildfires' }],
+ sources: [{ id: 'src1', url: 'http://example.com/event' }],
+ geometry: [{ date: date1 }],
+ ...overrides,
+ };
+}
+
+function buildProps(overrides = {}) {
+ const { event: eventOverride, ...rest } = overrides;
+ return {
+ defaultEventLayer: 'default-layer',
+ deselectEvent: jest.fn(),
+ eventLayers: ['eventLayerA'],
+ highlightEvent: jest.fn(),
+ isSelected: false,
+ isHighlighted: false,
+ layers: [
+ { id: 'L1', group: 'overlays', layergroup: 'Other' },
+ { id: 'L2', group: 'overlays', layergroup: 'Reference' },
+ { id: 'L3', group: 'baselayers', layergroup: 'Other' },
+ ],
+ removeGroup: jest.fn(),
+ selectedDate: util.toISOStringDate(date1),
+ selectEvent: jest.fn(),
+ sources: [{ id: 'src1', title: 'Source One' }],
+ toggleGroupVisibility: jest.fn(),
+ toggleVisibility: jest.fn(),
+ unHighlightEvent: jest.fn(),
+ ...rest,
+ event: buildEvent(eventOverride),
+ };
+}
+
+function renderEvent(overrides = {}) {
+ const props = buildProps(overrides);
+ const utils = render(<ul><Event {...props} /></ul>);
+ return { props, ...utils };
+}
+
+beforeAll(() => {
+ window.HTMLElement.prototype.scrollIntoView = jest.fn();
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('Event rendering', () => {
+ it('renders the event title and icon', () => {
+ const { getByText, getByTestId } = renderEvent();
+ expect(getByText('Test Wildfire')).toBeTruthy();
+ expect(getByTestId('event-icon').getAttribute('data-category')).toBe('wildfires');
+ });
+
+ it('renders the MonospaceDate when not selected', () => {
+ const { getByTestId } = renderEvent({ isSelected: false });
+ expect(getByTestId('monospace-date')).toBeTruthy();
+ });
+
+ it('applies the selected class and shows the reference list when selected', () => {
+ const { container } = renderEvent({ isSelected: true });
+ expect(container.querySelector('.item-selected')).toBeTruthy();
+ expect(container.querySelector('.natural-event-link')).toBeTruthy();
+ });
+
+ it('applies the selected class when highlighted', () => {
+ const { container } = renderEvent({ isHighlighted: true });
+ expect(container.querySelector('.item-selected')).toBeTruthy();
+ });
+});
+
+describe('Event selection', () => {
+ it('selects the event and pushes analytics when an unselected event is clicked', () => {
+ const { container, props } = renderEvent({ isSelected: false });
+ fireEvent.click(container.querySelector('li.event'));
+ expect(props.toggleVisibility).toHaveBeenCalledWith('default-layer', false);
+ expect(props.selectEvent).toHaveBeenCalledWith('EONET_1000', expect.any(String));
+ expect(googleTagManager.pushEvent).toHaveBeenCalled();
+ });
+
+ it('deselects the event and hides overlay layers when a selected event is clicked', () => {
+ const { container, props } = renderEvent({ isSelected: true });
+ fireEvent.click(container.querySelector('li.event'));
+ expect(props.toggleGroupVisibility).toHaveBeenCalledWith(['L1'], false);
+ expect(props.removeGroup).toHaveBeenCalledWith(['eventLayerA']);
+ expect(props.toggleVisibility).toHaveBeenCalledWith('default-layer', true);
+ expect(props.deselectEvent).toHaveBeenCalled();
+ });
+});
+
+describe('Event highlight', () => {
+ it('highlights on mouse enter and un-highlights on mouse leave', () => {
+ const { container, props } = renderEvent();
+ const li = container.querySelector('li.event');
+ fireEvent.mouseEnter(li);
+ expect(props.highlightEvent).toHaveBeenCalledWith('EONET_1000', expect.any(String));
+ fireEvent.mouseLeave(li);
+ expect(props.unHighlightEvent).toHaveBeenCalled();
+ });
+});
+
+describe('Event date list (multi-geometry)', () => {
+ const multiGeometry = {
+ event: { geometry: [{ date: date1 }, { date: date2 }] },
+ };
+
+ it('renders a list of dates when the event has multiple geometries', () => {
+ const { container } = renderEvent({ ...multiGeometry, isSelected: true });
+ expect(container.querySelectorAll('ul.dates li.date').length).toBe(2);
+ });
+
+ it('marks the currently selected date as active and stops propagation on click', () => {
+ const { container, props } = renderEvent({
+ ...multiGeometry,
+ isSelected: true,
+ selectedDate: util.toISOStringDate(date1),
+ });
+ const active = container.querySelector('.active');
+ expect(active).toBeTruthy();
+ fireEvent.click(active);
+ // clicking the active date must not trigger another selection
+ expect(props.selectEvent).not.toHaveBeenCalled();
+ });
+
+ it('selects a different date when a non-active date link is clicked', () => {
+ const { container, props } = renderEvent({
+ ...multiGeometry,
+ isSelected: true,
+ selectedDate: util.toISOStringDate(date1),
+ });
+ const link = container.querySelector('a[role="link"]');
+ fireEvent.click(link);
+ expect(props.selectEvent).toHaveBeenCalledWith('EONET_1000', util.toISOStringDate(date2));
+ });
+
+ it('hides the date list when not selected', () => {
+ const { container } = renderEvent({ ...multiGeometry, isSelected: false });
+ expect(container.querySelector('ul.dates').style.display).toBe('none');
+ });
+});
+
+describe('Event magnitude output', () => {
+ it('renders wind speed for kts magnitude', () => {
+ const { getByText } = renderEvent({
+ isSelected: true,
+ event: {
+ geometry: [
+ { date: date1 },
+ { date: date2, magnitudeUnit: 'kts', magnitudeValue: 50 },
+ ],
+ },
+ });
+ expect(getByText(/Wind Speed:/)).toBeTruthy();
+ });
+
+ it('renders surface area for non-kts magnitude', () => {
+ const { getByText } = renderEvent({
+ isSelected: true,
+ event: {
+ geometry: [
+ { date: date1 },
+ { date: date2, magnitudeUnit: 'NM2', magnitudeValue: 1200 },
+ ],
+ },
+ });
+ expect(getByText(/Surface Area:/)).toBeTruthy();
+ });
+});
+
+describe('Event reference list', () => {
+ it('renders a plain source title when a reference has no url', () => {
+ const { getByText } = renderEvent({
+ isSelected: true,
+ event: { sources: [{ id: 'src1' }] },
+ });
+ expect(getByText(/Source One/)).toBeTruthy();
+ });
+
+ it('handles sources provided as a single object rather than an array', () => {
+ const { container } = renderEvent({
+ isSelected: true,
+ event: { sources: { id: 'src1', url: 'http://example.com' } },
+ });
+ expect(container.querySelector('.natural-event-link')).toBeTruthy();
+ });
+
+ it('renders no reference links when the sources array is empty', () => {
+ const { container } = renderEvent({
+ isSelected: true,
+ event: { sources: [] },
+ });
+ expect(container.querySelector('.natural-event-link')).toBeNull();
+ });
+
+ it('stops propagation when a reference link is clicked', () => {
+ const { container, props } = renderEvent({ isSelected: true });
+ fireEvent.click(container.querySelector('.natural-event-link'));
+ // clicking the link should not bubble up to select/deselect the event
+ expect(props.deselectEvent).not.toHaveBeenCalled();
+ });
+});
+
+describe('Event scroll into view', () => {
+ it('scrolls the selected event into view', () => {
+ jest.useFakeTimers();
+ renderEvent({ isSelected: true });
+ jest.runAllTimers();
+ expect(window.HTMLElement.prototype.scrollIntoView).toHaveBeenCalled();
+ jest.useRealTimers();
+ });
+
+ it('does not scroll when the event is not selected', () => {
+ jest.useFakeTimers();
+ renderEvent({ isSelected: false });
+ jest.runAllTimers();
+ expect(window.HTMLElement.prototype.scrollIntoView).not.toHaveBeenCalled();
+ jest.useRealTimers();
+ });
});
diff --git a/web/js/components/sidebar/events-filter.test.js b/web/js/components/sidebar/events-filter.test.js
index 262f2829d..f4f73d728 100644
--- a/web/js/components/sidebar/events-filter.test.js
+++ b/web/js/components/sidebar/events-filter.test.js
@@ -1,3 +1,258 @@
-test('events-filter component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import EventsFilter from './events-filter';
+import util from '../../util/util';
+jest.mock('googleTagManager', () => ({
+ pushEvent: jest.fn(),
+}));
+
+// UncontrolledTooltip throws in jsdom because it can't locate its target on mount
+jest.mock('reactstrap', () => ({
+ ...jest.requireActual('reactstrap'),
+ UncontrolledTooltip: ({ children }) => <span>{children}</span>,
+}));
+
+jest.mock('../util/switch', () => (props) => (
+ <button
+ type="button"
+ data-testid={`switch-${props.id}`}
+ data-active={`${props.active}`}
+ onClick={props.toggle}
+ >
+ {props.label}
+ </button>
+));
+
+jest.mock('../util/checkbox', () => (props) => (
+ <button
+ type="button"
+ data-testid={`checkbox-${props.id}`}
+ data-checked={`${props.checked}`}
+ onClick={props.onCheck}
+ >
+ {props.label}
+ </button>
+));
+
+jest.mock('../date-selector/date-range-selector', () => (props) => (
+ <button
+ type="button"
+ data-testid="date-range-selector"
+ onClick={() => props.setDateRange([new Date('2023-01-01'), new Date('2023-02-01')])}
+ >
+ date-range
+ </button>
+));
+
+jest.mock('../../modules/natural-events/actions', () => ({
+ setEventsFilter: jest.fn((...args) => ({ type: 'SET_EVENTS_FILTER', args })),
+}));
+
+const { setEventsFilter } = require('../../modules/natural-events/actions');
+const googleTagManager = require('googleTagManager');
+
+const eventCategories = [
+ { id: 'wildfires', title: 'Wildfires', description: 'Fire events' },
+ { id: 'storms', title: 'Severe Storms', description: 'Storm events' },
+];
+
+const PARENT_ID = 'event-filter-modal';
+
+function buildState(overrides = {}) {
+ return {
+ events: {
+ selectedCategories: overrides.selectedCategories || [eventCategories[0]],
+ selectedDates: overrides.selectedDates || { start: null, end: null },
+ showAll: overrides.showAll ?? true,
+ showAllTracks: overrides.showAllTracks ?? false,
+ },
+ proj: { selected: { crs: overrides.crs || 'EPSG:4326' } },
+ config: { naturalEvents: { categories: eventCategories } },
+ screenSize: {
+ isMobileDevice: overrides.isMobile || false,
+ screenHeight: 800,
+ },
+ };
+}
+
+const mockStore = configureStore([]);
+
+function renderFilter(stateOverrides = {}, ownProps = {}) {
+ // provide a modal-footer node for the portal
+ const parent = document.createElement('div');
+ parent.id = PARENT_ID;
+ const footer = document.createElement('div');
+ footer.className = 'modal-footer';
+ parent.appendChild(footer);
+ document.body.appendChild(parent);
+
+ const store = mockStore(buildState(stateOverrides));
+ store.dispatch = jest.fn();
+ const utils = render(
+ <Provider store={store}>
+ <EventsFilter
+ parentId={PARENT_ID}
+ closeModal={ownProps.closeModal || jest.fn()}
+ {...ownProps}
+ />
+ </Provider>,
+ );
+ return {
+ store, footer, ...utils,
+ };
+}
+
+afterEach(() => {
+ document.body.innerHTML = '';
+ jest.clearAllMocks();
+});
+
+describe('EventsFilter rendering', () => {
+ it('renders the date range selector and category switches', () => {
+ const { getByTestId } = renderFilter();
+ expect(getByTestId('date-range-selector')).toBeTruthy();
+ expect(getByTestId('switch-wildfires-switch')).toBeTruthy();
+ expect(getByTestId('switch-storms-switch')).toBeTruthy();
+ });
+
+ it('renders the map-extent checkbox for non-polar projections', () => {
+ const { getByTestId } = renderFilter();
+ expect(getByTestId('checkbox-map-extent-filter')).toBeTruthy();
+ });
+
+ it('hides the map-extent checkbox for polar projections', () => {
+ const { queryByTestId } = renderFilter({ crs: 'EPSG:3413' });
+ expect(queryByTestId('checkbox-map-extent-filter')).toBeNull();
+ });
+
+ it('renders the show-all-tracks checkbox', () => {
+ const { getByTestId } = renderFilter();
+ expect(getByTestId('checkbox-show-all-tracks-filter')).toBeTruthy();
+ });
+
+ it('renders the Apply and Cancel buttons in the modal footer portal', () => {
+ const { footer } = renderFilter();
+ expect(footer.querySelector('#filter-apply-btn')).toBeTruthy();
+ expect(footer.querySelector('#filter-cancel-btn')).toBeTruthy();
+ });
+
+ it('applies mobile font styling when on a mobile device', () => {
+ const { container } = renderFilter({ isMobile: true });
+ expect(container.querySelector('.wv-header').style.fontSize).toBe('14px');
+ });
+});
+
+describe('EventsFilter category toggles', () => {
+ it('removes a category when an active switch is toggled off', () => {
+ const { getByTestId, footer } = renderFilter();
+ // wildfires is active by default; toggling removes it -> Apply becomes disabled
+ fireEvent.click(getByTestId('switch-wildfires-switch'));
+ expect(footer.querySelector('#filter-apply-btn').disabled).toBe(true);
+ });
+
+ it('adds a category when an inactive switch is toggled on', () => {
+ const { getByTestId, footer } = renderFilter();
+ fireEvent.click(getByTestId('switch-storms-switch'));
+ expect(footer.querySelector('#filter-apply-btn').disabled).toBe(false);
+ });
+
+ it('selects all categories when the All switch is toggled on', () => {
+ const { getByTestId, footer } = renderFilter({ selectedCategories: [] });
+ // with no selected categories, allNone starts false -> toggling selects all
+ fireEvent.click(getByTestId('switch-header-disable'));
+ expect(footer.querySelector('#filter-apply-btn').disabled).toBe(false);
+ });
+
+ it('clears all categories when the All switch is toggled off', () => {
+ const { getByTestId, footer } = renderFilter();
+ // with selected categories, allNone starts true -> toggling clears them
+ fireEvent.click(getByTestId('switch-header-disable'));
+ expect(footer.querySelector('#filter-apply-btn').disabled).toBe(true);
+ });
+});
+
+describe('EventsFilter checkboxes', () => {
+ it('toggles the list-all (map extent) option', () => {
+ const { getByTestId } = renderFilter();
+ const checkbox = getByTestId('checkbox-map-extent-filter');
+ expect(checkbox.getAttribute('data-checked')).toBe('false');
+ fireEvent.click(checkbox);
+ expect(getByTestId('checkbox-map-extent-filter').getAttribute('data-checked')).toBe('true');
+ });
+
+ it('toggles the show-all-tracks option', () => {
+ const { getByTestId } = renderFilter();
+ const checkbox = getByTestId('checkbox-show-all-tracks-filter');
+ expect(checkbox.getAttribute('data-checked')).toBe('false');
+ fireEvent.click(checkbox);
+ expect(getByTestId('checkbox-show-all-tracks-filter').getAttribute('data-checked')).toBe('true');
+ });
+});
+
+describe('EventsFilter apply', () => {
+ it('closes the modal and dispatches the filter on apply', () => {
+ const closeModal = jest.fn();
+ const { footer, store } = renderFilter({}, { closeModal });
+ fireEvent.click(footer.querySelector('#filter-apply-btn'));
+ expect(closeModal).toHaveBeenCalled();
+ expect(setEventsFilter).toHaveBeenCalled();
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+
+ it('passes formatted dates to the filter when a date range is set', () => {
+ const closeModal = jest.fn();
+ const { getByTestId, footer } = renderFilter({}, { closeModal });
+ fireEvent.click(getByTestId('date-range-selector'));
+ fireEvent.click(footer.querySelector('#filter-apply-btn'));
+ const callArgs = setEventsFilter.mock.calls[0];
+ expect(callArgs[1]).toBe(util.toISOStringDate(new Date('2023-01-01')));
+ expect(callArgs[2]).toBe(util.toISOStringDate(new Date('2023-02-01')));
+ });
+
+ it('pushes an analytics event when the show-all setting changes', () => {
+ const { getByTestId, footer } = renderFilter({ showAll: true });
+ // toggle list-all off so listAll !== showAll
+ fireEvent.click(getByTestId('checkbox-map-extent-filter'));
+ fireEvent.click(footer.querySelector('#filter-apply-btn'));
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({
+ event: 'natural_events_current_view_only',
+ });
+ });
+
+ it('pushes the show-all analytics event when enabling show all', () => {
+ const { getByTestId, footer } = renderFilter({ showAll: false });
+ fireEvent.click(getByTestId('checkbox-map-extent-filter'));
+ fireEvent.click(footer.querySelector('#filter-apply-btn'));
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({
+ event: 'natural_events_show_all',
+ });
+ });
+
+ it('disables apply when only one of start/end date is set', () => {
+ const { footer } = renderFilter({
+ selectedDates: { start: '2023-01-01', end: null },
+ });
+ const applyBtn = footer.querySelector('#filter-apply-btn');
+ expect(applyBtn.disabled).toBe(true);
+ expect(applyBtn.title).toContain('Must have both start and end date');
+ });
+
+ it('initializes the date range from the selected start and end dates', () => {
+ const { footer } = renderFilter({
+ selectedDates: { start: '2023-03-01', end: '2023-03-15' },
+ });
+ // both dates present + a category selected -> apply enabled
+ expect(footer.querySelector('#filter-apply-btn').disabled).toBe(false);
+ });
+
+ it('cancels via the Cancel button', () => {
+ const closeModal = jest.fn();
+ const { footer } = renderFilter({}, { closeModal });
+ fireEvent.click(footer.querySelector('#filter-cancel-btn'));
+ expect(closeModal).toHaveBeenCalled();
+ });
});
diff --git a/web/js/components/sidebar/paletteLegend.test.js b/web/js/components/sidebar/paletteLegend.test.js
index 42f925ef8..0e8ca1594 100644
--- a/web/js/components/sidebar/paletteLegend.test.js
+++ b/web/js/components/sidebar/paletteLegend.test.js
@@ -1,3 +1,422 @@
-test('paletteLegend component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import PaletteLegend from './paletteLegend';
+// reactstrap Tooltip tries to locate its target in the DOM on mount and throws in jsdom
+jest.mock('reactstrap', () => ({
+ ...jest.requireActual('reactstrap'),
+ Tooltip: ({ children }) => <span className="mock-tooltip">{children}</span>,
+}));
+
+// VisibilitySensor renders its child via a render-prop
+jest.mock('../util/visibility-sensor', () => ({ children }) => children());
+
+jest.mock('../../modules/palettes/util', () => ({
+ drawSidebarPaletteOnCanvas: jest.fn(),
+ drawTicksOnCanvas: jest.fn(),
+}));
+
+jest.mock('../../modules/settings/util', () => ({
+ checkTemperatureUnitConversion: jest.fn(() => ({ needsConversion: false, legendTempUnit: 'K' })),
+ convertPaletteValue: jest.fn((val) => `conv(${val})`),
+}));
+
+jest.mock('../../modules/layers/util', () => ({
+ getOrbitTrackTitle: jest.fn(() => 'Orbit Track'),
+}));
+
+jest.mock('../../modules/palettes/actions', () => ({
+ setToggledClassification: jest.fn((...args) => ({ type: 'TOGGLE', args })),
+ refreshDisabledClassification: jest.fn((...args) => ({ type: 'REFRESH', args })),
+}));
+
+const settingsUtil = require('../../modules/settings/util');
+const palettesUtil = require('../../modules/palettes/util');
+const palettesActions = require('../../modules/palettes/actions');
+
+const continuousLegend = {
+ id: 'leg1',
+ title: 'Continuous Legend',
+ type: 'continuous',
+ colors: ['ff0000ff', '00ff00ff', '0000ffff'],
+ tooltips: ['0', '50', '100'],
+ refs: ['r0', 'r1', 'r2'],
+ units: 'K',
+ minLabel: 'lo',
+ maxLabel: 'hi',
+};
+
+const classificationLegend = {
+ id: 'leg2',
+ title: 'Classification Legend',
+ type: 'classification',
+ colors: ['ff0000ff', '00ff00ff'],
+ tooltips: ['Class A', 'Class B'],
+ refs: ['r0', 'r1'],
+};
+
+function buildPalette(overrides = {}) {
+ return {
+ disabled: [],
+ min: 0,
+ max: 0,
+ noclip: false,
+ squash: false,
+ entries: { refs: ['r0', 'r1', 'r2'] },
+ custom: undefined,
+ ...overrides,
+ };
+}
+
+function buildLayer(overrides = {}) {
+ return {
+ id: 'MODIS_Layer',
+ palette: { id: 'modis_palette' },
+ type: 'wmts',
+ colormapType: 'continuous',
+ track: undefined,
+ disabled: false,
+ ...overrides,
+ };
+}
+
+const mockStore = configureStore([]);
+
+function renderLegend(props = {}) {
+ const palette = props.palette || buildPalette();
+ const getPalette = props.getPalette || jest.fn(() => palette);
+ const store = mockStore({});
+ store.dispatch = jest.fn();
+
+ const allProps = {
+ isRunningData: false,
+ colorHex: null,
+ width: 231,
+ height: 12,
+ getPalette,
+ parentLayer: null,
+ compareState: 'active',
+ isDistractionFreeModeActive: false,
+ paletteLegends: [continuousLegend],
+ globalTemperatureUnit: '',
+ isEmbedModeActive: false,
+ isMobile: false,
+ palettes: { custom: {} },
+ paletteId: 'palette-1',
+ isCustomPalette: false,
+ showingVectorHand: false,
+ showingChartingIcon: false,
+ toggleAllClassifications: jest.fn(),
+ ...props,
+ layer: buildLayer(props.layer),
+ };
+
+ const utils = render(
+ <Provider store={store}>
+ <PaletteLegend {...allProps} />
+ </Provider>,
+ );
+ return {
+ store, getPalette, palette, ...utils,
+ };
+}
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ settingsUtil.checkTemperatureUnitConversion.mockReturnValue({
+ needsConversion: false,
+ legendTempUnit: 'K',
+ });
+});
+
+describe('PaletteLegend rendering', () => {
+ it('returns nothing when the layer has no palette', () => {
+ const { container } = renderLegend({ layer: { palette: null } });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders the panel with the palette id', () => {
+ const { container } = renderLegend();
+ expect(container.querySelector('#palette-1_panel')).toBeTruthy();
+ });
+
+ it('renders a continuous colorbar canvas', () => {
+ const { container } = renderLegend();
+ expect(container.querySelector('canvas.wv-palettes-colorbar')).toBeTruthy();
+ expect(palettesUtil.drawSidebarPaletteOnCanvas).toHaveBeenCalled();
+ });
+
+ it('renders min/max labels with units', () => {
+ const { getByText } = renderLegend();
+ expect(getByText('lo K')).toBeTruthy();
+ expect(getByText(/hi K/)).toBeTruthy();
+ });
+
+ it('renders a title when there is more than one colorbar', () => {
+ const { container } = renderLegend({
+ paletteLegends: [continuousLegend, { ...continuousLegend, id: 'leg1b' }],
+ });
+ const titles = container.querySelectorAll('.wv-palettes-title');
+ expect(titles.length).toBe(2);
+ expect(titles[0].textContent).toBe('Continuous Legend');
+ });
+
+ it('renders classification legends through the visibility sensor', () => {
+ const { container } = renderLegend({ paletteLegends: [classificationLegend] });
+ expect(container.querySelector('.wv-palettes-classes')).toBeTruthy();
+ });
+
+ it('ignores colormaps with an unsupported type', () => {
+ const { container } = renderLegend({
+ paletteLegends: [{ ...continuousLegend, type: 'mystery' }],
+ });
+ // panel renders but no colorbar for the unsupported type
+ expect(container.querySelector('canvas.wv-palettes-colorbar')).toBeNull();
+ });
+
+ it('applies the custom palette class', () => {
+ const { container } = renderLegend({ isCustomPalette: true });
+ expect(container.querySelector('.is_custom')).toBeTruthy();
+ });
+
+ it('applies bottomspace class when showing the charting icon', () => {
+ const { container } = renderLegend({ showingChartingIcon: true });
+ expect(container.querySelector('.bottomspace-palette')).toBeTruthy();
+ });
+
+ it('applies bottomspace class for AERONET vector hand', () => {
+ const { container } = renderLegend({
+ showingVectorHand: true,
+ layer: { id: 'AERONET_Layer' },
+ });
+ expect(container.querySelector('.bottomspace-palette')).toBeTruthy();
+ });
+
+ it('applies mobile colorbar styling', () => {
+ const { container } = renderLegend({ isMobile: true });
+ const canvas = container.querySelector('canvas.wv-palettes-colorbar');
+ expect(canvas.style.width).toBe('100%');
+ });
+});
+
+describe('PaletteLegend default classification disabling', () => {
+ it('toggles all classifications from palette defaults on mount', () => {
+ // toggleAllClassifications comes from connect's mapDispatchToProps, which dispatches
+ // refreshDisabledClassification - assert against the mocked action creator
+ const palette = buildPalette({ disabled: ['0', '1'] });
+ renderLegend({
+ palette,
+ getPalette: jest.fn(() => palette),
+ layer: { disabled: undefined },
+ });
+ expect(palettesActions.refreshDisabledClassification)
+ .toHaveBeenCalledWith('MODIS_Layer', [0, 1], 0, 'active');
+ });
+
+ it('does not toggle when the layer already has a disabled value', () => {
+ renderLegend({ layer: { disabled: false } });
+ expect(palettesActions.refreshDisabledClassification).not.toHaveBeenCalled();
+ });
+});
+
+describe('PaletteLegend running data (continuous)', () => {
+ it('renders the running label when hovering produces a legend match', () => {
+ const { container } = renderLegend({
+ isRunningData: true,
+ colorHex: 'ff0000ff',
+ });
+ expect(container.querySelector('.wv-running')).toBeTruthy();
+ });
+
+ it('converts min/max labels when temperature conversion is needed', () => {
+ settingsUtil.checkTemperatureUnitConversion.mockReturnValue({
+ needsConversion: true,
+ legendTempUnit: 'K',
+ });
+ renderLegend({ isRunningData: true, colorHex: 'ff0000ff', globalTemperatureUnit: 'C' });
+ expect(settingsUtil.convertPaletteValue).toHaveBeenCalled();
+ });
+
+ it('handles noclip palettes that label values outside the range', () => {
+ const palette = buildPalette({ noclip: true, min: 1, max: 1 });
+ expect(() => renderLegend({
+ isRunningData: true,
+ colorHex: 'ff0000ff',
+ palette,
+ getPalette: jest.fn(() => palette),
+ })).not.toThrow();
+ });
+
+ it('adjusts running offset when embed mode is active', () => {
+ const { container } = renderLegend({
+ isRunningData: true,
+ colorHex: 'ff0000ff',
+ isEmbedModeActive: true,
+ });
+ expect(container.querySelector('.wv-palettes-legend')).toBeTruthy();
+ });
+});
+
+describe('PaletteLegend colorbar interactions', () => {
+ it('updates running state on mouse enter/leave of the colorbar', () => {
+ const { container } = renderLegend();
+ const canvas = container.querySelector('canvas.wv-palettes-colorbar');
+ fireEvent.mouseEnter(canvas);
+ expect(container.querySelector('.active-legend')).toBeTruthy();
+ fireEvent.mouseLeave(canvas);
+ expect(container.querySelector('.active-legend')).toBeNull();
+ });
+
+ it('reads canvas color on mouse move', () => {
+ const { container } = renderLegend();
+ const canvas = container.querySelector('canvas.wv-palettes-colorbar');
+ expect(() => fireEvent.mouseMove(canvas, { clientX: 5, clientY: 5 })).not.toThrow();
+ });
+});
+
+describe('PaletteLegend classification rendering', () => {
+ it('marks the active key when running data matches', () => {
+ const { container } = renderLegend({
+ paletteLegends: [classificationLegend],
+ isRunningData: true,
+ colorHex: 'ff0000ff',
+ });
+ expect(container.querySelector('.wv-active')).toBeTruthy();
+ });
+
+ it('renders a single-key classification with a category label', () => {
+ const singleKeyLegend = {
+ ...classificationLegend,
+ colors: ['ff0000ff'],
+ tooltips: ['Only Class'],
+ };
+ const { container } = renderLegend({ paletteLegends: [singleKeyLegend] });
+ const label = container.querySelector('.wv-running-category-label');
+ expect(label).toBeTruthy();
+ expect(label.textContent).toBe('Only Class');
+ });
+
+ it('renders an orbit track label for track layers', () => {
+ const singleKeyLegend = {
+ ...classificationLegend,
+ colors: ['ff0000ff'],
+ tooltips: ['Track'],
+ };
+ const { container } = renderLegend({
+ paletteLegends: [singleKeyLegend],
+ layer: { track: 'ascending' },
+ });
+ expect(container.querySelector('.wv-running-category-label').textContent)
+ .toContain('Orbit Track');
+ });
+
+ it('renders an invisible (checkerbox) classification key without a tooltip', () => {
+ const invisibleLegend = {
+ ...classificationLegend,
+ colors: ['00000000', 'ff0000ff'],
+ tooltips: ['Invisible', 'Visible'],
+ };
+ const { container } = renderLegend({ paletteLegends: [invisibleLegend] });
+ expect(container.querySelector('.checkerbox-bg')).toBeTruthy();
+ });
+
+ it('marks disabled classification keys', () => {
+ const palette = buildPalette({ disabled: [0] });
+ const { container } = renderLegend({
+ paletteLegends: [classificationLegend],
+ palette,
+ getPalette: jest.fn(() => palette),
+ });
+ expect(container.querySelector('.disabled-classification')).toBeTruthy();
+ });
+
+ it('uses a custom palette color when palette.custom is set', () => {
+ const palette = buildPalette({ custom: 'myCustom' });
+ const { container } = renderLegend({
+ paletteLegends: [classificationLegend],
+ palette,
+ getPalette: jest.fn(() => palette),
+ palettes: { custom: { myCustom: { colors: ['abcdefff'] } } },
+ });
+ expect(container.querySelector('.wv-palettes-class')).toBeTruthy();
+ });
+
+ it('renders a sublayer key when a parentLayer is provided', () => {
+ const { container } = renderLegend({
+ paletteLegends: [classificationLegend],
+ parentLayer: { id: 'PARENT' },
+ });
+ expect(container.querySelector('.wv-palettes-classes')).toBeTruthy();
+ });
+
+ it('handles classification mouse interactions', () => {
+ const { container } = renderLegend({ paletteLegends: [classificationLegend] });
+ const key = container.querySelector('.wv-palettes-class');
+ fireEvent.mouseMove(key);
+ fireEvent.mouseEnter(key);
+ fireEvent.mouseLeave(key);
+ expect(key).toBeTruthy();
+ });
+});
+
+describe('PaletteLegend prop change effects', () => {
+ const baseProps = () => {
+ const palette = buildPalette();
+ return {
+ getPalette: jest.fn(() => palette),
+ width: 231,
+ height: 12,
+ parentLayer: null,
+ compareState: 'active',
+ isDistractionFreeModeActive: false,
+ paletteLegends: [continuousLegend],
+ globalTemperatureUnit: '',
+ isEmbedModeActive: false,
+ isMobile: false,
+ palettes: { custom: {} },
+ paletteId: 'palette-1',
+ isCustomPalette: false,
+ showingVectorHand: false,
+ showingChartingIcon: false,
+ toggleAllClassifications: jest.fn(),
+ };
+ };
+
+ it('recomputes the canvas when the layer changes', () => {
+ const store = mockStore({});
+ store.dispatch = jest.fn();
+ const props = baseProps();
+ const { rerender } = render(
+ <Provider store={store}>
+ <PaletteLegend {...props} isRunningData={false} colorHex={null} layer={buildLayer()} />
+ </Provider>,
+ );
+ palettesUtil.drawSidebarPaletteOnCanvas.mockClear();
+ rerender(
+ <Provider store={store}>
+ <PaletteLegend {...props} isRunningData={false} colorHex={null} layer={buildLayer({ id: 'NEW_Layer' })} />
+ </Provider>,
+ );
+ expect(palettesUtil.drawSidebarPaletteOnCanvas).toHaveBeenCalled();
+ });
+
+ it('updates color hex and running-data state when those props change', () => {
+ const store = mockStore({});
+ store.dispatch = jest.fn();
+ const props = baseProps();
+ const { rerender, container } = render(
+ <Provider store={store}>
+ <PaletteLegend {...props} isRunningData={false} colorHex="ff0000ff" layer={buildLayer()} />
+ </Provider>,
+ );
+ rerender(
+ <Provider store={store}>
+ <PaletteLegend {...props} isRunningData colorHex="00ff00ff" layer={buildLayer()} />
+ </Provider>,
+ );
+ expect(container.querySelector('#palette-1_panel')).toBeTruthy();
+ });
});
diff --git a/web/js/components/smart-handoffs/granule-count.test.js b/web/js/components/smart-handoffs/granule-count.test.js
index e0858a99f..9496858cc 100644
--- a/web/js/components/smart-handoffs/granule-count.test.js
+++ b/web/js/components/smart-handoffs/granule-count.test.js
@@ -1,3 +1,151 @@
-test('granule-count component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent, waitFor } from '@testing-library/react';
+import GranuleCount from './granule-count';
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: (props) => <span data-testid={`fa-${props.icon}`} />,
+}));
+
+jest.mock('../../util/cmr', () => ({
+ cmrFetch: jest.fn(),
+}));
+
+const { cmrFetch } = require('../../util/cmr');
+
+function mockGranules(entriesByUrl) {
+ // entriesByUrl: function(url) => entries array, OR a single array used for all calls
+ cmrFetch.mockImplementation((url) => {
+ const entries = typeof entriesByUrl === 'function' ? entriesByUrl(url) : entriesByUrl;
+ return Promise.resolve({ json: () => Promise.resolve({ feed: { entry: entries } }) });
+ });
+}
+
+function buildProps(overrides = {}) {
+ return {
+ getGranulesUrl: jest.fn((params) => `https://cmr/search?concept=${params.conceptId}${params.bbox ? `&bbox=${params.bbox}` : ''}`),
+ currentExtent: null,
+ displayDate: '2023-05-01',
+ startDate: '2023-05-01T00:00:00Z',
+ endDate: '2023-05-02T00:00:00Z',
+ selectedDate: '2023-05-01',
+ selectedCollection: { value: 'C123-PROV' },
+ showGranuleHelpModal: jest.fn(),
+ ...overrides,
+ };
+}
+
+function renderCount(overrides = {}) {
+ const props = buildProps(overrides);
+ const utils = render(<GranuleCount {...props} />);
+ return { props, ...utils };
+}
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('GranuleCount', () => {
+ it('returns null when there is no selected collection', () => {
+ const { container } = renderCount({ selectedCollection: null });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders the header with the display date', () => {
+ mockGranules([]);
+ const { getByText } = renderCount();
+ expect(getByText(/Available granules for/)).toBeTruthy();
+ });
+
+ it('shows the total granule count after a successful fetch', async () => {
+ mockGranules([{ granule_size: '5' }, { granule_size: '5' }, { granule_size: '5' }]);
+ const { container } = renderCount();
+ await waitFor(() => {
+ expect(container.querySelector('.granule-count-info').textContent).toContain('3');
+ });
+ });
+
+ it('shows NONE when no granules are returned', async () => {
+ mockGranules([]);
+ const { getByText } = renderCount();
+ await waitFor(() => {
+ expect(getByText('NONE')).toBeTruthy();
+ });
+ });
+
+ it('requests granules with a bbox and shows the selected-of-total count when an extent is set', async () => {
+ // bbox request returns 2, total request returns 5
+ mockGranules((url) => (url.includes('bbox')
+ ? [{ granule_size: '10' }, { granule_size: '10' }]
+ : [
+ { granule_size: '10' }, { granule_size: '10' }, { granule_size: '10' },
+ { granule_size: '10' }, { granule_size: '10' },
+ ]));
+ const { container, props } = renderCount({
+ currentExtent: { southWest: '-10,-10', northEast: '10,10' },
+ });
+ await waitFor(() => {
+ expect(container.querySelector('.granule-count-info').textContent).toContain('2 of ');
+ });
+ // a bbox URL should have been requested
+ expect(props.getGranulesUrl).toHaveBeenCalledWith(
+ expect.objectContaining({ bbox: '-10,-10,10,10' }),
+ );
+ });
+
+ it('displays the download size in MB for small totals', async () => {
+ mockGranules([{ granule_size: '4.5' }, { granule_size: '4.5' }]);
+ const { container } = renderCount();
+ await waitFor(() => {
+ expect(container.querySelector('.granule-size').textContent).toContain('MB');
+ });
+ });
+
+ it('displays the download size in GB for large totals', async () => {
+ mockGranules([{ granule_size: '2000' }]);
+ const { container } = renderCount();
+ await waitFor(() => {
+ expect(container.querySelector('.granule-size').textContent).toContain('GB');
+ });
+ });
+
+ it('handles granules without a granule_size field', async () => {
+ mockGranules([{}, {}]);
+ const { container } = renderCount();
+ await waitFor(() => {
+ expect(container.querySelector('.granule-count-info').textContent).toContain('2');
+ });
+ });
+
+ it('omits the date params when start/end dates are missing', async () => {
+ mockGranules([]);
+ const { props } = renderCount({ startDate: null, endDate: null });
+ await waitFor(() => {
+ expect(props.getGranulesUrl).toHaveBeenCalled();
+ });
+ const callArg = props.getGranulesUrl.mock.calls[0][0];
+ expect(callArg.startDate).toBeUndefined();
+ expect(callArg.endDate).toBeUndefined();
+ });
+
+ it('logs an error and renders NONE when the fetch fails', async () => {
+ const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+ cmrFetch.mockRejectedValue(new Error('network failure'));
+ const { getByText } = renderCount();
+ await waitFor(() => {
+ expect(errorSpy).toHaveBeenCalled();
+ });
+ expect(getByText('NONE')).toBeTruthy();
+ errorSpy.mockRestore();
+ });
+
+ it('calls showGranuleHelpModal when the help button is clicked', async () => {
+ mockGranules([]);
+ const { container, props } = renderCount();
+ await waitFor(() => {
+ expect(container.querySelector('.help-link')).toBeTruthy();
+ });
+ fireEvent.click(container.querySelector('.help-link'));
+ expect(props.showGranuleHelpModal).toHaveBeenCalled();
+ });
});
diff --git a/web/js/components/smart-handoffs/smart-handoff-granule-alert.test.js b/web/js/components/smart-handoffs/smart-handoff-granule-alert.test.js
index 7314ee343..8a29e4871 100644
--- a/web/js/components/smart-handoffs/smart-handoff-granule-alert.test.js
+++ b/web/js/components/smart-handoffs/smart-handoff-granule-alert.test.js
@@ -1,3 +1,30 @@
-test('smart-handoff-granule-alert component test', () => {
+import { render } from '@testing-library/react';
+import GranuleAlertModalBody from './smart-handoff-granule-alert';
+describe('GranuleAlertModalBody', () => {
+ it('renders the modal heading', () => {
+ const { getByRole } = render(<GranuleAlertModalBody />);
+ expect(getByRole('heading', { level: 1 }).textContent).toContain('NONE');
+ });
+
+ it('renders the explanatory paragraphs and the numbered list', () => {
+ const { container } = render(<GranuleAlertModalBody />);
+ expect(container.querySelectorAll('p').length).toBe(3);
+ expect(container.querySelectorAll('ol li').length).toBe(2);
+ });
+
+ it('renders external reference links that open in a new tab safely', () => {
+ const { container } = render(<GranuleAlertModalBody />);
+ const links = container.querySelectorAll('a[target="_blank"]');
+ expect(links.length).toBe(2);
+ links.forEach((link) => {
+ expect(link.getAttribute('rel')).toBe('noopener noreferrer');
+ expect(link.getAttribute('href')).toMatch(/^https:\/\//);
+ });
+ });
+
+ it('renders within the basic-modal wrapper', () => {
+ const { container } = render(<GranuleAlertModalBody />);
+ expect(container.querySelector('.basic-modal')).toBeTruthy();
+ });
});
diff --git a/web/js/components/smart-handoffs/smart-handoff-modal.test.js b/web/js/components/smart-handoffs/smart-handoff-modal.test.js
index aee18fb03..50c81c694 100644
--- a/web/js/components/smart-handoffs/smart-handoff-modal.test.js
+++ b/web/js/components/smart-handoffs/smart-handoff-modal.test.js
@@ -1,3 +1,165 @@
-test('smart-handoff-modal component test', () => {
+/* eslint-disable no-restricted-globals */
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import SmartHandoffModal from './smart-handoff-modal';
+import safeLocalStorage from '../../util/local-storage';
+jest.mock('googleTagManager', () => ({
+ pushEvent: jest.fn(),
+}));
+
+jest.mock('../util/button', () => (props) => (
+ <button type="button" data-testid={props.id} onClick={props.onClick}>
+ {props.text}
+ </button>
+));
+
+jest.mock('../util/checkbox', () => (props) => (
+ <button
+ type="button"
+ data-testid={props.id}
+ data-checked={`${props.checked}`}
+ onClick={props.onCheck}
+ >
+ {props.label}
+ </button>
+));
+
+jest.mock('../../modules/smart-handoff/selectors', () => ({
+ getConceptUrl: jest.fn(() => () => 'https://cmr.example.com/concept/C123'),
+}));
+
+const googleTagManager = require('googleTagManager');
+
+const { HIDE_EDS_WARNING } = safeLocalStorage.keys;
+const mockStore = configureStore([]);
+
+function buildProps(overrides = {}) {
+ return {
+ displayDate: '2023-05-01',
+ continueToEDS: jest.fn(),
+ selectedLayer: {
+ title: 'MODIS Layer',
+ subtitle: 'Terra',
+ dateRanges: [{ startDate: '2020-01-01' }],
+ },
+ selectedCollection: {
+ value: 'C123-PROV',
+ title: 'MODIS Collection',
+ type: 'STD',
+ version: '6.1',
+ },
+ ...overrides,
+ };
+}
+
+function renderModal(overrides = {}) {
+ const props = buildProps(overrides);
+ const store = mockStore({});
+ store.dispatch = jest.fn();
+ const utils = render(
+ <Provider store={store}>
+ <SmartHandoffModal {...props} />
+ </Provider>,
+ );
+ return { props, ...utils };
+}
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ localStorage.clear();
+});
+
+describe('SmartHandoffModal rendering', () => {
+ it('renders the collection type label with version', () => {
+ const { getByText } = renderModal();
+ expect(getByText('Standard - v6.1')).toBeTruthy();
+ });
+
+ it('renders the collection type label without version when none is set', () => {
+ const { getByText } = renderModal({
+ selectedCollection: {
+ value: 'C1', title: 'C', type: 'NRT', version: undefined,
+ },
+ });
+ expect(getByText('Near Real-Time')).toBeTruthy();
+ });
+
+ it('renders the collection detail link with the title', () => {
+ const { getByText } = renderModal();
+ const link = getByText('MODIS Collection');
+ expect(link.getAttribute('href')).toBe('https://cmr.example.com/concept/C123');
+ });
+
+ it('falls back to "Details" when the collection has no title', () => {
+ const { getByText } = renderModal({
+ selectedCollection: {
+ value: 'C1', title: '', type: 'STD', version: '1',
+ },
+ });
+ expect(getByText('Details')).toBeTruthy();
+ });
+
+ it('renders the layer title and subtitle', () => {
+ const { getByText } = renderModal();
+ expect(getByText('MODIS Layer')).toBeTruthy();
+ expect(getByText('Terra')).toBeTruthy();
+ });
+
+ it('renders the date when the layer has date ranges', () => {
+ const { container } = renderModal();
+ expect(container.querySelector('.handoff-modal-date').textContent).toBe('2023-05-01');
+ });
+
+ it('omits the date when the layer has no date ranges', () => {
+ const { container } = renderModal({
+ selectedLayer: { title: 'L', subtitle: 'S', dateRanges: null },
+ });
+ expect(container.querySelector('.handoff-modal-date')).toBeNull();
+ });
+});
+
+describe('SmartHandoffModal interactions', () => {
+ it('toggles the "About Earthdata Search" info section', () => {
+ const { getByText, container, queryByText } = renderModal();
+ expect(container.querySelector('.smart-handoff-about')).toBeNull();
+ fireEvent.click(getByText('Show More Info'));
+ expect(container.querySelector('.smart-handoff-about')).toBeTruthy();
+ expect(getByText('Hide Info')).toBeTruthy();
+ fireEvent.click(getByText('Hide Info'));
+ expect(container.querySelector('.smart-handoff-about')).toBeNull();
+ expect(queryByText('Hide Info')).toBeNull();
+ });
+
+ it('calls continueToEDS when Continue is clicked', () => {
+ const { getByTestId, props } = renderModal();
+ fireEvent.click(getByTestId('continue-btn'));
+ expect(props.continueToEDS).toHaveBeenCalled();
+ });
+
+ it('hides the modal and stores the preference when the checkbox is checked', () => {
+ const { getByTestId } = renderModal();
+ const checkbox = getByTestId('hide-eds-checkbox');
+ expect(checkbox.getAttribute('data-checked')).toBe('false');
+ fireEvent.click(checkbox);
+ expect(safeLocalStorage.getItem(HIDE_EDS_WARNING)).toBeTruthy();
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({
+ event: 'smart_handoffs_toggle_true_hide_warning',
+ });
+ expect(getByTestId('hide-eds-checkbox').getAttribute('data-checked')).toBe('true');
+ });
+
+ it('clears the stored preference when the checkbox is unchecked', () => {
+ safeLocalStorage.setItem(HIDE_EDS_WARNING, true);
+ const { getByTestId } = renderModal();
+ const checkbox = getByTestId('hide-eds-checkbox');
+ // starts checked because the preference is already stored
+ expect(checkbox.getAttribute('data-checked')).toBe('true');
+ fireEvent.click(checkbox);
+ expect(safeLocalStorage.getItem(HIDE_EDS_WARNING)).toBeFalsy();
+ expect(getByTestId('hide-eds-checkbox').getAttribute('data-checked')).toBe('false');
+ });
});
diff --git a/web/js/components/smart-handoffs/smart-handoff-not-available-modal.test.js b/web/js/components/smart-handoffs/smart-handoff-not-available-modal.test.js
index f206ad202..4dad3b878 100644
--- a/web/js/components/smart-handoffs/smart-handoff-not-available-modal.test.js
+++ b/web/js/components/smart-handoffs/smart-handoff-not-available-modal.test.js
@@ -1,3 +1,27 @@
-test('smart-handoff-not-available-modal component test', () => {
+import { render } from '@testing-library/react';
+import SmartHandoffNotAvailableModal from './smart-handoff-not-available-modal';
+describe('SmartHandoffNotAvailableModal', () => {
+ it('renders the modal heading', () => {
+ const { getByRole } = render(<SmartHandoffNotAvailableModal />);
+ expect(getByRole('heading', { level: 1 }).textContent)
+ .toContain('Why are some layers not available for download?');
+ });
+
+ it('renders the explanatory paragraphs', () => {
+ const { container } = render(<SmartHandoffNotAvailableModal />);
+ expect(container.querySelectorAll('p').length).toBe(4);
+ });
+
+ it('renders the MODIS True Color reference link safely', () => {
+ const { container } = render(<SmartHandoffNotAvailableModal />);
+ const link = container.querySelector('a[target="_blank"]');
+ expect(link.getAttribute('rel')).toBe('noreferrer');
+ expect(link.getAttribute('href')).toMatch(/^https:\/\//);
+ });
+
+ it('renders within the basic-modal wrapper', () => {
+ const { container } = render(<SmartHandoffNotAvailableModal />);
+ expect(container.querySelector('.basic-modal')).toBeTruthy();
+ });
});
diff --git a/web/js/components/timeline/custom-interval-selector/custom-interval-selector.test.js b/web/js/components/timeline/custom-interval-selector/custom-interval-selector.test.js
index b234d47e8..c71b3955e 100644
--- a/web/js/components/timeline/custom-interval-selector/custom-interval-selector.test.js
+++ b/web/js/components/timeline/custom-interval-selector/custom-interval-selector.test.js
@@ -1,3 +1,117 @@
-test('custom-interval-selector component test', () => {
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import CustomIntervalSelector from './custom-interval-selector';
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: (props) => <span data-testid="close-icon" onClick={props.onClick} />,
+}));
+
+jest.mock('./delta-input', () => (props) => (
+ <div>
+ <button type="button" data-testid="delta-valid" onClick={() => props.changeDelta(5)}>v</button>
+ <button type="button" data-testid="delta-invalid" onClick={() => props.changeDelta(2000)}>i</button>
+ </div>
+));
+
+jest.mock('./interval-select', () => (props) => (
+ <button type="button" data-testid="interval-select" onClick={() => props.changeZoomLevel('month')}>
+ {props.zoomLevel}
+ </button>
+));
+
+jest.mock('../../../modules/date/actions', () => ({
+ toggleCustomModal: jest.fn((open, by) => ({ type: 'TOGGLE_MODAL', open, by })),
+ changeCustomInterval: jest.fn((delta, scale) => ({ type: 'CHANGE_INTERVAL', delta, scale })),
+}));
+
+const dateActions = require('../../../modules/date/actions');
+
+const mockStore = configureStore([]);
+
+function renderSelector(props = {}, stateOverrides = {}) {
+ const store = mockStore({
+ date: {
+ customDelta: stateOverrides.customDelta,
+ customInterval: stateOverrides.customInterval,
+ interval: stateOverrides.interval ?? 3,
+ },
+ });
+ store.dispatch = jest.fn();
+ const utils = render(
+ <Provider store={store}>
+ <CustomIntervalSelector
+ modalOpen={props.modalOpen ?? true}
+ hasSubdailyLayers={props.hasSubdailyLayers}
+ />
+ </Provider>,
+ );
+ return { store, ...utils };
+}
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('CustomIntervalSelector', () => {
+ it('renders nothing when the modal is closed', () => {
+ const { container } = renderSelector({ modalOpen: false });
+ expect(container.querySelector('.custom-interval-widget')).toBeNull();
+ });
+
+ it('renders the widget and header when the modal is open', () => {
+ const { getByText, container } = renderSelector({ modalOpen: true });
+ expect(getByText('Custom Interval Selector')).toBeTruthy();
+ expect(container.querySelector('.custom-interval-widget')).toBeTruthy();
+ });
+
+ it('adds the subdaily class when subdaily layers exist', () => {
+ const { container } = renderSelector({ modalOpen: true, hasSubdailyLayers: true });
+ expect(container.querySelector('.custom-interval-widget.subdaily')).toBeTruthy();
+ });
+
+ it('dispatches a custom interval change for a valid delta', () => {
+ const { getByTestId, store } = renderSelector();
+ fireEvent.click(getByTestId('delta-valid'));
+ expect(dateActions.changeCustomInterval).toHaveBeenCalledWith(5, 3);
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+
+ it('does not dispatch for an out-of-range delta', () => {
+ const { getByTestId } = renderSelector();
+ fireEvent.click(getByTestId('delta-invalid'));
+ expect(dateActions.changeCustomInterval).not.toHaveBeenCalled();
+ });
+
+ it('dispatches a custom interval change when the zoom level changes', () => {
+ const { getByTestId } = renderSelector();
+ fireEvent.click(getByTestId('interval-select'));
+ // TIME_SCALE_TO_NUMBER.month === 2
+ expect(dateActions.changeCustomInterval).toHaveBeenCalledWith(1, 2);
+ });
+
+ it('closes the modal when the close icon is clicked', () => {
+ const { getByTestId } = renderSelector();
+ fireEvent.click(getByTestId('close-icon'));
+ expect(dateActions.toggleCustomModal).toHaveBeenCalledWith(false, undefined);
+ });
+
+ it('closes the modal on Escape keypress', () => {
+ const { container } = renderSelector();
+ fireEvent.keyDown(container.querySelector('.custom-interval-widget'), { key: 'Escape' });
+ expect(dateActions.toggleCustomModal).toHaveBeenCalledWith(false, undefined);
+ });
+
+ it('ignores non-Escape keypresses', () => {
+ const { container } = renderSelector();
+ fireEvent.keyDown(container.querySelector('.custom-interval-widget'), { key: 'Enter' });
+ expect(dateActions.toggleCustomModal).not.toHaveBeenCalled();
+ });
+
+ it('uses customDelta and customInterval from state when present', () => {
+ const { getByTestId } = renderSelector({}, { customDelta: 4, customInterval: 2 });
+ fireEvent.click(getByTestId('delta-valid'));
+ expect(dateActions.changeCustomInterval).toHaveBeenCalledWith(5, 2);
+ });
});
diff --git a/web/js/components/timeline/custom-interval-selector/delta-input.test.js b/web/js/components/timeline/custom-interval-selector/delta-input.test.js
index 7ce8c02ab..68f87ee33 100644
--- a/web/js/components/timeline/custom-interval-selector/delta-input.test.js
+++ b/web/js/components/timeline/custom-interval-selector/delta-input.test.js
@@ -1,3 +1,95 @@
-test('delta-input component test', () => {
+import { render, fireEvent } from '@testing-library/react';
+import DeltaInput from './delta-input';
+function renderInput(props = {}) {
+ const changeDelta = props.changeDelta || jest.fn();
+ const utils = render(<DeltaInput deltaValue={props.deltaValue ?? 5} changeDelta={changeDelta} />);
+ const input = utils.container.querySelector('input.custom-interval-delta-input');
+ return { changeDelta, input, ...utils };
+}
+
+describe('DeltaInput', () => {
+ it('initializes the input value from deltaValue on mount', () => {
+ const { input } = renderInput({ deltaValue: 7 });
+ expect(input.value).toBe('7');
+ });
+
+ it('accepts numeric input below 1000', () => {
+ const { input } = renderInput();
+ fireEvent.change(input, { target: { value: '42' } });
+ expect(input.value).toBe('42');
+ });
+
+ it('allows clearing the input to empty (zero)', () => {
+ const { input } = renderInput();
+ fireEvent.change(input, { target: { value: '' } });
+ expect(input.value).toBe('0');
+ });
+
+ it('ignores non-numeric input', () => {
+ const { input } = renderInput({ deltaValue: 3 });
+ fireEvent.change(input, { target: { value: 'abc' } });
+ expect(input.value).toBe('3');
+ });
+
+ it('ignores input of 1000 or greater', () => {
+ const { input } = renderInput({ deltaValue: 3 });
+ fireEvent.change(input, { target: { value: '2000' } });
+ expect(input.value).toBe('3');
+ });
+
+ it('calls changeDelta and marks valid on blur with a valid value', () => {
+ const { input, changeDelta } = renderInput({ deltaValue: 5 });
+ fireEvent.blur(input);
+ expect(changeDelta).toHaveBeenCalledWith(5);
+ expect(input.style.borderColor).toBe('');
+ });
+
+ it('marks the input invalid on blur with an out-of-range value', () => {
+ const { input, changeDelta } = renderInput();
+ fireEvent.change(input, { target: { value: '' } }); // becomes 0
+ fireEvent.blur(input);
+ expect(changeDelta).not.toHaveBeenCalled();
+ // jsdom normalizes the hex color to rgb form
+ expect(input.style.borderColor).toBe('rgb(255, 0, 0)');
+ });
+
+ it('selects the text on focus', () => {
+ const { input } = renderInput();
+ const selectSpy = jest.spyOn(input, 'select');
+ fireEvent.focus(input);
+ expect(selectSpy).toHaveBeenCalled();
+ });
+
+ it('increments the value on ArrowUp', () => {
+ const { input } = renderInput({ deltaValue: 5 });
+ fireEvent.keyDown(input, { key: 'ArrowUp' });
+ expect(input.value).toBe('6');
+ });
+
+ it('decrements the value on ArrowDown', () => {
+ const { input } = renderInput({ deltaValue: 5 });
+ fireEvent.keyDown(input, { key: 'ArrowDown' });
+ expect(input.value).toBe('4');
+ });
+
+ it('does not decrement below 1', () => {
+ const { input } = renderInput({ deltaValue: 1 });
+ fireEvent.keyDown(input, { key: 'ArrowDown' });
+ expect(input.value).toBe('1');
+ });
+
+ it('does not increment at or above 1000', () => {
+ const { input } = renderInput({ deltaValue: 999 });
+ fireEvent.change(input, { target: { value: '999' } });
+ fireEvent.keyDown(input, { key: 'ArrowUp' }); // 999 -> 1000
+ fireEvent.keyDown(input, { key: 'ArrowUp' }); // 1000 is not < 1000, stays
+ expect(input.value).toBe('1000');
+ });
+
+ it('submits the value on Enter', () => {
+ const { input, changeDelta } = renderInput({ deltaValue: 8 });
+ fireEvent.keyDown(input, { key: 'Enter' });
+ expect(changeDelta).toHaveBeenCalledWith(8);
+ });
});
diff --git a/web/js/components/timeline/custom-interval-selector/interval-select.test.js b/web/js/components/timeline/custom-interval-selector/interval-select.test.js
index 17eaf6a97..091dd9220 100644
--- a/web/js/components/timeline/custom-interval-selector/interval-select.test.js
+++ b/web/js/components/timeline/custom-interval-selector/interval-select.test.js
@@ -1,3 +1,107 @@
-test('interval-select component test', () => {
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import IntervalSelect from './interval-select';
+// Mock reactstrap dropdown so the menu items always render and toggle is reachable
+jest.mock('reactstrap', () => ({
+ Dropdown: ({ children, toggle }) => (
+ <div>
+ <button type="button" data-testid="dropdown-toggle-trigger" onClick={toggle}>toggle</button>
+ {children}
+ </div>
+ ),
+ DropdownToggle: ({ children }) => <div className="dd-toggle">{children}</div>,
+ DropdownMenu: ({ children }) => <div className="dd-menu">{children}</div>,
+ DropdownItem: ({ children }) => <div className="dd-item">{children}</div>,
+}));
+
+describe('IntervalSelect (desktop)', () => {
+ it('renders the base timescale options', () => {
+ const { container } = render(
+ <IntervalSelect zoomLevel="day" hasSubdailyLayers={false} changeZoomLevel={jest.fn()} />,
+ );
+ const options = container.querySelectorAll('option');
+ expect(options.length).toBe(3);
+ expect([...options].map((o) => o.value)).toEqual(['year', 'month', 'day']);
+ });
+
+ it('includes hour and minute options when subdaily layers are present', () => {
+ const { container } = render(
+ <IntervalSelect zoomLevel="day" hasSubdailyLayers changeZoomLevel={jest.fn()} />,
+ );
+ expect(container.querySelectorAll('option').length).toBe(5);
+ });
+
+ it('calls changeZoomLevel when a new option is selected', () => {
+ const changeZoomLevel = jest.fn();
+ const { container } = render(
+ <IntervalSelect zoomLevel="day" hasSubdailyLayers changeZoomLevel={changeZoomLevel} />,
+ );
+ fireEvent.change(container.querySelector('select'), { target: { value: 'month' } });
+ expect(changeZoomLevel).toHaveBeenCalledWith('month');
+ });
+
+ it('prevents default form submission', () => {
+ const { container } = render(
+ <IntervalSelect zoomLevel="day" hasSubdailyLayers={false} changeZoomLevel={jest.fn()} />,
+ );
+ const form = container.querySelector('form');
+ const submitEvent = new Event('submit', { bubbles: true, cancelable: true });
+ const prevented = !form.dispatchEvent(submitEvent);
+ expect(prevented).toBe(true);
+ });
+});
+
+describe('IntervalSelect (mobile)', () => {
+ const renderMobile = (props = {}) => render(
+ <IntervalSelect
+ isMobile
+ interval={3}
+ zoomLevel="day"
+ hasSubdailyLayers={props.hasSubdailyLayers || false}
+ changeZoomLevel={props.changeZoomLevel || jest.fn()}
+ />,
+ );
+
+ it('renders the mobile dropdown with the current interval label', () => {
+ const { container } = renderMobile();
+ expect(container.querySelector('.mobile-timescale-dropdown')).toBeTruthy();
+ expect(container.querySelector('.dd-toggle').textContent).toBe('DAY');
+ });
+
+ it('renders only year/month/day items without subdaily layers', () => {
+ const { getByText, queryByText } = renderMobile();
+ expect(getByText('Year')).toBeTruthy();
+ expect(getByText('Month')).toBeTruthy();
+ expect(getByText('Day')).toBeTruthy();
+ expect(queryByText('Hour')).toBeNull();
+ expect(queryByText('Minute')).toBeNull();
+ });
+
+ it('renders hour/minute items with subdaily layers', () => {
+ const { getByText } = renderMobile({ hasSubdailyLayers: true });
+ expect(getByText('Hour')).toBeTruthy();
+ expect(getByText('Minute')).toBeTruthy();
+ });
+
+ it('calls changeZoomLevel with the chosen increment on mobile', () => {
+ const changeZoomLevel = jest.fn();
+ const { getByText } = renderMobile({ hasSubdailyLayers: true, changeZoomLevel });
+ fireEvent.click(getByText('Year'));
+ expect(changeZoomLevel).toHaveBeenCalledWith('year');
+ fireEvent.click(getByText('Month'));
+ expect(changeZoomLevel).toHaveBeenCalledWith('month');
+ fireEvent.click(getByText('Day'));
+ expect(changeZoomLevel).toHaveBeenCalledWith('day');
+ fireEvent.click(getByText('Hour'));
+ expect(changeZoomLevel).toHaveBeenCalledWith('hour');
+ fireEvent.click(getByText('Minute'));
+ expect(changeZoomLevel).toHaveBeenCalledWith('minute');
+ });
+
+ it('toggles the dropdown open state', () => {
+ const { getByTestId } = renderMobile();
+ // exercising the toggle handler should not throw
+ expect(() => fireEvent.click(getByTestId('dropdown-toggle-trigger'))).not.toThrow();
+ });
});
diff --git a/web/js/components/timeline/custom-interval-selector/mobile-custom-interval-selector.test.js b/web/js/components/timeline/custom-interval-selector/mobile-custom-interval-selector.test.js
index 8be170569..a4eee5e5c 100644
--- a/web/js/components/timeline/custom-interval-selector/mobile-custom-interval-selector.test.js
+++ b/web/js/components/timeline/custom-interval-selector/mobile-custom-interval-selector.test.js
@@ -1,3 +1,88 @@
-test('mobile-custom-interval-selector component test', () => {
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import MobileCustomIntervalSelector from './mobile-custom-interval-selector';
+jest.mock('./delta-input', () => (props) => (
+ <div>
+ <button type="button" data-testid="delta-valid" onClick={() => props.changeDelta(5)}>v</button>
+ <button type="button" data-testid="delta-invalid" onClick={() => props.changeDelta(2000)}>i</button>
+ </div>
+));
+
+jest.mock('./interval-select', () => (props) => (
+ <button type="button" data-testid="interval-select" onClick={() => props.changeZoomLevel('month')}>
+ {props.zoomLevel}
+ </button>
+));
+
+jest.mock('../../../modules/date/actions', () => ({
+ selectInterval: jest.fn((...args) => ({ type: 'SELECT_INTERVAL', args })),
+ changeCustomInterval: jest.fn((delta, scale) => ({ type: 'CHANGE_INTERVAL', delta, scale })),
+}));
+
+const dateActions = require('../../../modules/date/actions');
+
+const mockStore = configureStore([]);
+
+function renderSelector(stateOverrides = {}, ownProps = {}) {
+ const store = mockStore({
+ date: {
+ interval: stateOverrides.interval ?? 3,
+ customInterval: stateOverrides.customInterval,
+ customDelta: stateOverrides.customDelta,
+ customSelected: stateOverrides.customSelected ?? false,
+ },
+ screenSize: { isMobileDevice: stateOverrides.isMobile ?? true },
+ });
+ store.dispatch = jest.fn();
+ const utils = render(
+ <Provider store={store}>
+ <MobileCustomIntervalSelector hasSubdailyLayers={ownProps.hasSubdailyLayers} />
+ </Provider>,
+ );
+ return { store, ...utils };
+}
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('MobileCustomIntervalSelector', () => {
+ it('renders the interval selector header and controls', () => {
+ const { getByText, getByTestId } = renderSelector();
+ expect(getByText('Interval Selector')).toBeTruthy();
+ expect(getByTestId('delta-valid')).toBeTruthy();
+ expect(getByTestId('interval-select')).toBeTruthy();
+ });
+
+ it('dispatches a custom interval change for a valid delta', () => {
+ const { getByTestId, store } = renderSelector();
+ fireEvent.click(getByTestId('delta-valid'));
+ // customInterval defaults to interval (3) when unset
+ expect(dateActions.changeCustomInterval).toHaveBeenCalledWith(5, 3);
+ expect(store.dispatch).toHaveBeenCalled();
+ });
+
+ it('does not dispatch for an out-of-range delta', () => {
+ const { getByTestId } = renderSelector();
+ fireEvent.click(getByTestId('delta-invalid'));
+ expect(dateActions.changeCustomInterval).not.toHaveBeenCalled();
+ });
+
+ it('dispatches a custom interval change when the zoom level changes', () => {
+ const { getByTestId } = renderSelector();
+ fireEvent.click(getByTestId('interval-select'));
+ // customDelta defaults to 1, TIME_SCALE_TO_NUMBER.month === 2
+ expect(dateActions.changeCustomInterval).toHaveBeenCalledWith(1, 2);
+ });
+
+ it('uses customDelta and customInterval from state when present', () => {
+ const { getByTestId } = renderSelector({ customDelta: 7, customInterval: 4 });
+ fireEvent.click(getByTestId('delta-valid'));
+ expect(dateActions.changeCustomInterval).toHaveBeenCalledWith(5, 4);
+ fireEvent.click(getByTestId('interval-select'));
+ expect(dateActions.changeCustomInterval).toHaveBeenCalledWith(7, 2);
+ });
});
diff --git a/web/js/components/timeline/date-util.test.js b/web/js/components/timeline/date-util.test.js
index b2f843dce..bf9fc579a 100644
--- a/web/js/components/timeline/date-util.test.js
+++ b/web/js/components/timeline/date-util.test.js
@@ -1,3 +1,154 @@
-test('date-util component test', () => {
+import {
+ getIsBetween,
+ getDaysInYear,
+ getISODateFormatted,
+ getDisplayDate,
+ removeBackMultipleInPlace,
+ removeFrontMultipleInPlace,
+} from './date-util';
+import { formatDisplayDate } from '../../modules/date/util';
+jest.mock('../../modules/date/util', () => ({
+ formatDisplayDate: jest.fn((date, isSubdaily) => `MOCK_${isSubdaily ? 'subdaily' : 'default'}`),
+}));
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('getIsBetween', () => {
+ const front = '2020-01-01T00:00:00Z';
+ const back = '2020-12-31T00:00:00Z';
+
+ it('returns true when date is strictly between front and back', () => {
+ expect(getIsBetween('2020-06-01T00:00:00Z', front, back)).toBe(true);
+ });
+
+ it('returns true when date equals frontDate (inclusive lower bound)', () => {
+ expect(getIsBetween(front, front, back)).toBe(true);
+ });
+
+ it('returns true when date equals backDate (inclusive upper bound)', () => {
+ expect(getIsBetween(back, front, back)).toBe(true);
+ });
+
+ it('returns false when date is before frontDate', () => {
+ expect(getIsBetween('2019-12-31T00:00:00Z', front, back)).toBe(false);
+ });
+
+ it('returns false when date is after backDate', () => {
+ expect(getIsBetween('2021-01-01T00:00:00Z', front, back)).toBe(false);
+ });
+});
+
+describe('getDaysInYear', () => {
+ it('returns 1 for January 1', () => {
+ expect(getDaysInYear('2020-01-01T00:00:00Z')).toBe(1);
+ });
+
+ it('returns 2 for January 2', () => {
+ expect(getDaysInYear('2020-01-02T00:00:00Z')).toBe(2);
+ });
+
+ it('returns 366 for December 31 in a leap year (2020)', () => {
+ expect(getDaysInYear('2020-12-31T00:00:00Z')).toBe(366);
+ });
+
+ it('returns 365 for December 31 in a non-leap year (2021)', () => {
+ expect(getDaysInYear('2021-12-31T00:00:00Z')).toBe(365);
+ });
+
+ it('returns 32 for February 1', () => {
+ expect(getDaysInYear('2020-02-01T00:00:00Z')).toBe(32);
+ });
+});
+
+describe('getISODateFormatted', () => {
+ it('strips milliseconds and appends Z', () => {
+ expect(getISODateFormatted('2020-06-15T12:30:45.123Z')).toBe('2020-06-15T12:30:45Z');
+ });
+
+ it('handles midnight UTC correctly', () => {
+ expect(getISODateFormatted('2020-01-01T00:00:00.000Z')).toBe('2020-01-01T00:00:00Z');
+ });
+
+ it('handles end-of-day time correctly', () => {
+ expect(getISODateFormatted('2020-12-31T23:59:59.999Z')).toBe('2020-12-31T23:59:59Z');
+ });
+});
+
+describe('getDisplayDate', () => {
+ it('calls formatDisplayDate with a Date object and isSubdaily=false', () => {
+ const result = getDisplayDate('2020-06-01T00:00:00Z', false);
+ expect(formatDisplayDate).toHaveBeenCalledWith(expect.any(Date), false);
+ expect(result).toBe('MOCK_default');
+ });
+
+ it('calls formatDisplayDate with isSubdaily=true', () => {
+ const result = getDisplayDate('2020-06-01T12:00:00Z', true);
+ expect(formatDisplayDate).toHaveBeenCalledWith(expect.any(Date), true);
+ expect(result).toBe('MOCK_subdaily');
+ });
+
+ it('returns whatever formatDisplayDate returns', () => {
+ formatDisplayDate.mockReturnValueOnce('custom-display');
+ const result = getDisplayDate('2020-01-01T00:00:00Z', false);
+ expect(result).toBe('custom-display');
+ });
+});
+
+describe('removeBackMultipleInPlace', () => {
+ it('pops num elements from the end of the array', () => {
+ const arr = [1, 2, 3, 4, 5];
+ removeBackMultipleInPlace(arr, 3);
+ expect(arr).toEqual([1, 2]);
+ });
+
+ it('does nothing when num=0', () => {
+ const arr = [1, 2, 3];
+ removeBackMultipleInPlace(arr, 0);
+ expect(arr).toEqual([1, 2, 3]);
+ });
+
+ it('removes a single element when num=1', () => {
+ const arr = ['a', 'b', 'c'];
+ removeBackMultipleInPlace(arr, 1);
+ expect(arr).toEqual(['a', 'b']);
+ });
+
+ it('mutates the original array reference', () => {
+ const arr = [10, 20, 30];
+ const ref = arr;
+ removeBackMultipleInPlace(arr, 2);
+ expect(ref).toBe(arr);
+ expect(ref).toEqual([10]);
+ });
+});
+
+describe('removeFrontMultipleInPlace', () => {
+ it('shifts num elements from the front of the array', () => {
+ const arr = [1, 2, 3, 4, 5];
+ removeFrontMultipleInPlace(arr, 2);
+ expect(arr).toEqual([3, 4, 5]);
+ });
+
+ it('does nothing when num=0', () => {
+ const arr = [1, 2, 3];
+ removeFrontMultipleInPlace(arr, 0);
+ expect(arr).toEqual([1, 2, 3]);
+ });
+
+ it('removes a single element when num=1', () => {
+ const arr = ['a', 'b', 'c'];
+ removeFrontMultipleInPlace(arr, 1);
+ expect(arr).toEqual(['b', 'c']);
+ });
+
+ it('mutates the original array reference', () => {
+ const arr = [10, 20, 30];
+ const ref = arr;
+ removeFrontMultipleInPlace(arr, 2);
+ expect(ref).toBe(arr);
+ expect(ref).toEqual([30]);
+ });
});
diff --git a/web/js/components/timeline/kiosk-timestamp.test.js b/web/js/components/timeline/kiosk-timestamp.test.js
index 370cce3f6..387721ec5 100644
--- a/web/js/components/timeline/kiosk-timestamp.test.js
+++ b/web/js/components/timeline/kiosk-timestamp.test.js
@@ -1,3 +1,172 @@
-test('kiosk-timestamp component test', () => {
+/* eslint-disable react/jsx-boolean-value */
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import KioskTimeStamp from './kiosk-timestamp';
+jest.mock('../../util/util', () => ({
+ __esModule: true,
+ default: {
+ pad: jest.fn((num, width, char) => String(num).padStart(width, char)),
+ },
+}));
+
+jest.mock('../../modules/date/constants', () => ({
+ MONTH_STRING_ARRAY: ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC'],
+}));
+
+// June 15, 2020 12:00 UTC = June 15 08:00 EDT (America/New_York, UTC-4 summer)
+const summerDate = new Date('2020-06-15T12:00:00Z');
+// January 15, 2020 17:00 UTC = January 15 12:00 EST (America/New_York, UTC-5 winter)
+const winterDate = new Date('2020-01-15T17:00:00Z');
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('KioskTimeStamp', () => {
+ describe('subdaily=false — only date elements rendered', () => {
+ it('renders day, month, and year elements', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={false} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-day')).toBeInTheDocument();
+ expect(container.querySelector('.kiosk-month')).toBeInTheDocument();
+ expect(container.querySelector('.kiosk-year')).toBeInTheDocument();
+ });
+
+ it('does not render time or timezone elements', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={false} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-hours')).not.toBeInTheDocument();
+ expect(container.querySelector('.kiosk-minutes')).not.toBeInTheDocument();
+ expect(container.querySelector('.kiosk-seconds')).not.toBeInTheDocument();
+ expect(container.querySelector('.kiosk-timezone')).not.toBeInTheDocument();
+ });
+
+ it('shows UTC day, month, year when isKioskModeActive=false', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={false} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-day').textContent.trim()).toBe('15');
+ expect(container.querySelector('.kiosk-month').textContent.trim()).toBe('JUN');
+ expect(container.querySelector('.kiosk-year').textContent.trim()).toBe('2020');
+ });
+
+ it('still shows UTC values when isKioskModeActive=true but subdaily=false (updateKioskModeTime=false)', () => {
+ // updateKioskModeTime = true && false = false → UTC values, not kiosk values
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={false} isKioskModeActive={true} />,
+ );
+ expect(container.querySelector('.kiosk-month').textContent.trim()).toBe('JUN');
+ expect(container.querySelector('.kiosk-year').textContent.trim()).toBe('2020');
+ });
+ });
+
+ describe('subdaily=true, isKioskModeActive=false — UTC mode', () => {
+ it('renders all time elements', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-hours')).toBeInTheDocument();
+ expect(container.querySelector('.kiosk-minutes')).toBeInTheDocument();
+ expect(container.querySelector('.kiosk-seconds')).toBeInTheDocument();
+ expect(container.querySelector('.kiosk-timezone')).toBeInTheDocument();
+ });
+
+ it('renders 2 colon separators', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={false} />,
+ );
+ expect(container.querySelectorAll('.kiosk-colon')).toHaveLength(2);
+ });
+
+ it('shows "UTC" timezone label', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-timezone').textContent.trim()).toBe('UTC');
+ });
+
+ it('shows seconds as "00"', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-seconds').textContent.trim()).toBe('00');
+ });
+
+ it('shows UTC day, month, year', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-day').textContent.trim()).toBe('15');
+ expect(container.querySelector('.kiosk-month').textContent.trim()).toBe('JUN');
+ expect(container.querySelector('.kiosk-year').textContent.trim()).toBe('2020');
+ });
+
+ it('shows UTC hour (12 for noon UTC)', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-hours').textContent.trim()).toBe('12');
+ });
+
+ it('shows Intl minutes (NY-timezone minutes from formatToParts)', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={false} />,
+ );
+ expect(container.querySelector('.kiosk-minutes').textContent.trim()).toBe('00');
+ });
+ });
+
+ describe('subdaily=true, isKioskModeActive=true — kiosk (America/New_York) mode', () => {
+ it('renders kiosk year and Intl-formatted month (3-letter slice, mixed case)', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={true} />,
+ );
+ expect(container.querySelector('.kiosk-year').textContent.trim()).toBe('2020');
+ // Intl gives 'June', sliced to 'Jun' — distinct from UTC path 'JUN'
+ expect(container.querySelector('.kiosk-month').textContent.trim()).toBe('Jun');
+ });
+
+ it('shows America/New_York hour (UTC 12:00 = EDT 08:00)', () => {
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={true} />,
+ );
+ expect(container.querySelector('.kiosk-hours').textContent.trim()).toBe('08');
+ });
+
+ it('shows EDT when DST is active (mocked getTimezoneOffset simulates summer offset)', () => {
+ // Force current time to July so toLocaleString gives a summer NY date,
+ // then mock getTimezoneOffset to return summer vs winter offsets.
+ jest.useFakeTimers();
+ jest.setSystemTime(new Date('2020-07-15T12:00:00Z'));
+ const tzSpy = jest.spyOn(Date.prototype, 'getTimezoneOffset').mockImplementation(function() {
+ const m = this.getMonth();
+ // EDT months (April–October): offset 240 min (UTC-4); EST: 300 min (UTC-5)
+ return (m >= 3 && m <= 9) ? 240 : 300;
+ });
+
+ const { container } = render(
+ <KioskTimeStamp date={summerDate} subdaily={true} isKioskModeActive={true} />,
+ );
+ expect(container.querySelector('.kiosk-timezone').textContent.trim()).toBe('EDT');
+
+ tzSpy.mockRestore();
+ jest.useRealTimers();
+ });
+
+ it('shows EST when DST is not active (all offsets equal → isDaylightSavingTime=false)', () => {
+ // Constant offset means dateObj.getTimezoneOffset() === Jan1.getTimezoneOffset(),
+ // so 300 < 300 = false → EST.
+ const tzSpy = jest.spyOn(Date.prototype, 'getTimezoneOffset').mockReturnValue(300);
+
+ const { container } = render(
+ <KioskTimeStamp date={winterDate} subdaily={true} isKioskModeActive={true} />,
+ );
+ expect(container.querySelector('.kiosk-timezone').textContent.trim()).toBe('EST');
+
+ tzSpy.mockRestore();
+ });
+ });
});
diff --git a/web/js/components/timeline/mobile-date-picker.test.js b/web/js/components/timeline/mobile-date-picker.test.js
index c53ce7fc6..f535c7a3a 100644
--- a/web/js/components/timeline/mobile-date-picker.test.js
+++ b/web/js/components/timeline/mobile-date-picker.test.js
@@ -1,3 +1,312 @@
-test('mobile-date-picker component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, act, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import MobileDatePicker from './mobile-date-picker';
+import { getDisplayDate, getISODateFormatted } from './date-util';
+let mockDatePickerProps = {};
+
+jest.mock('../../util/react-mobile-datepicker', () => function MockDatePicker(props) {
+ mockDatePickerProps = props;
+ return <div data-testid="mock-datepicker" />;
+});
+
+jest.mock('./date-util', () => ({
+ getDisplayDate: jest.fn(() => 'MOCK_DISPLAY_DATE'),
+ getISODateFormatted: jest.fn(() => 'MOCK_ISO_DATE'),
+}));
+
+jest.mock('../../modules/date/constants', () => ({
+ MONTH_STRING_ARRAY: ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC'],
+}));
+
+const defaultProps = {
+ date: '2020-06-15T12:00:00Z',
+ isEmbedModeActive: false,
+ startDateLimit: '2000-01-01T00:00:00Z',
+ endDateLimit: '2021-12-31T00:00:00Z',
+ onDateChange: jest.fn(),
+ hasSubdailyLayers: false,
+};
+
+const renderComponent = (props = {}) => render(
+ <MobileDatePicker {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ mockDatePickerProps = {};
+ jest.clearAllMocks();
+});
+
+afterEach(() => {
+ document.querySelectorAll('.Modal-Portal').forEach((el) => el.remove());
+});
+
+describe('MobileDatePicker', () => {
+ describe('initial render', () => {
+ it('renders the date select button', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.mobile-date-picker-select-btn')).toBeInTheDocument();
+ });
+
+ it('displays the result of getDisplayDate(date, hasSubdailyLayers) in the button', () => {
+ const { container } = renderComponent();
+ expect(getDisplayDate).toHaveBeenCalledWith(defaultProps.date, false);
+ expect(container.querySelector('.mobile-date-picker-select-btn-text').textContent).toBe('MOCK_DISPLAY_DATE');
+ });
+
+ it('calls getDisplayDate with hasSubdailyLayers=true when prop is true', () => {
+ renderComponent({ hasSubdailyLayers: true });
+ expect(getDisplayDate).toHaveBeenCalledWith(defaultProps.date, true);
+ });
+
+ it('does not render the datepicker modal on initial render', () => {
+ renderComponent();
+ expect(document.body.querySelector('.datepicker-modal')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('handleClickDateButton', () => {
+ it('opens the datepicker modal when isEmbedModeActive=false', () => {
+ const { container } = renderComponent({ isEmbedModeActive: false });
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ expect(document.body.querySelector('.datepicker-modal')).toBeInTheDocument();
+ });
+
+ it('does not open the picker when isEmbedModeActive=true', () => {
+ const { container } = renderComponent({ isEmbedModeActive: true });
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ expect(document.body.querySelector('.datepicker-modal')).not.toBeInTheDocument();
+ });
+
+ it('appends a Modal-Portal element to document.body', () => {
+ const { container } = renderComponent();
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ expect(document.body.querySelector('.Modal-Portal')).toBeInTheDocument();
+ });
+
+ it('does not create duplicate Modal-Portal elements when button clicked twice', () => {
+ const { container } = renderComponent();
+ const btn = container.querySelector('.mobile-date-picker-select-btn');
+ act(() => { fireEvent.click(btn); });
+ act(() => { fireEvent.click(btn); });
+ expect(document.body.querySelectorAll('.Modal-Portal')).toHaveLength(1);
+ });
+ });
+
+ describe('handleCancel', () => {
+ const openPicker = (container) => {
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ };
+
+ it('closes the datepicker modal', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ act(() => { mockDatePickerProps.onCancel(); });
+ expect(document.body.querySelector('.datepicker-modal')).not.toBeInTheDocument();
+ });
+
+ it('removes the Modal-Portal from body', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ act(() => { mockDatePickerProps.onCancel(); });
+ expect(document.body.querySelector('.Modal-Portal')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('handleChange', () => {
+ it('updates the DatePicker value prop when onChange is called', () => {
+ const { container } = renderComponent();
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ const newDate = new Date('2020-07-01T00:00:00Z');
+ act(() => { mockDatePickerProps.onChange(newDate); });
+ expect(mockDatePickerProps.value).toEqual(newDate);
+ });
+ });
+
+ describe('handleSelect', () => {
+ const openPicker = (container) => {
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ };
+
+ it('closes the datepicker modal on select', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ act(() => { mockDatePickerProps.onSelect(new Date('2020-07-01T00:00:00Z')); });
+ expect(document.body.querySelector('.datepicker-modal')).not.toBeInTheDocument();
+ });
+
+ it('removes the Modal-Portal from body on select', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ act(() => { mockDatePickerProps.onSelect(new Date('2020-07-01T00:00:00Z')); });
+ expect(document.body.querySelector('.Modal-Portal')).not.toBeInTheDocument();
+ });
+
+ it('calls onDateChange with the result of getISODateFormatted', () => {
+ const onDateChange = jest.fn();
+ const { container } = renderComponent({ onDateChange });
+ openPicker(container);
+ act(() => { mockDatePickerProps.onSelect(new Date('2020-07-01T00:00:00Z')); });
+ expect(onDateChange).toHaveBeenCalledWith('MOCK_ISO_DATE');
+ });
+
+ it('calls getISODateFormatted with a Date object (local-converted)', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ act(() => { mockDatePickerProps.onSelect(new Date('2020-07-01T00:00:00Z')); });
+ expect(getISODateFormatted).toHaveBeenCalledWith(expect.any(Date));
+ });
+ });
+
+ describe('handleBackdropClick', () => {
+ const openPicker = (container) => {
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ };
+
+ it('closes the modal when clicking directly on the backdrop (target === currentTarget)', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ const modal = document.body.querySelector('.datepicker-modal');
+ act(() => { fireEvent.click(modal); });
+ expect(document.body.querySelector('.datepicker-modal')).not.toBeInTheDocument();
+ });
+
+ it('keeps the modal open when clicking a child element (target !== currentTarget)', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ const child = document.body.querySelector('[data-testid="mock-datepicker"]');
+ act(() => { fireEvent.click(child); });
+ expect(document.body.querySelector('.datepicker-modal')).toBeInTheDocument();
+ });
+ });
+
+ describe('hasSubdailyLayers — dateConfig selection', () => {
+ const openPicker = (container) => {
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ };
+
+ it('passes defaultDateConfig (no hour/minute) when hasSubdailyLayers=false', () => {
+ const { container } = renderComponent({ hasSubdailyLayers: false });
+ openPicker(container);
+ expect(mockDatePickerProps.dateConfig).not.toHaveProperty('hour');
+ expect(mockDatePickerProps.dateConfig).not.toHaveProperty('minute');
+ expect(mockDatePickerProps.dateConfig).toHaveProperty('year');
+ expect(mockDatePickerProps.dateConfig).toHaveProperty('month');
+ expect(mockDatePickerProps.dateConfig).toHaveProperty('date');
+ });
+
+ it('passes subDailyDateConfig (with hour and minute) when hasSubdailyLayers=true', () => {
+ const { container } = renderComponent({ hasSubdailyLayers: true });
+ openPicker(container);
+ expect(mockDatePickerProps.dateConfig).toHaveProperty('hour');
+ expect(mockDatePickerProps.dateConfig).toHaveProperty('minute');
+ });
+
+ it('month.format in dateConfig uses MONTH_STRING_ARRAY indexed by getMonth()', () => {
+ const { container } = renderComponent({ hasSubdailyLayers: false });
+ openPicker(container);
+ const janDate = new Date(2020, 0, 1);
+ const junDate = new Date(2020, 5, 1);
+ expect(mockDatePickerProps.dateConfig.month.format(janDate)).toBe('JAN');
+ expect(mockDatePickerProps.dateConfig.month.format(junDate)).toBe('JUN');
+ });
+ });
+
+ describe('DatePicker static props', () => {
+ const openPicker = (container) => {
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ };
+
+ it('passes isOpen=true, min, max, value as Date instances', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ expect(mockDatePickerProps.isOpen).toBe(true);
+ expect(mockDatePickerProps.min).toBeInstanceOf(Date);
+ expect(mockDatePickerProps.max).toBeInstanceOf(Date);
+ expect(mockDatePickerProps.value).toBeInstanceOf(Date);
+ });
+
+ it('passes confirmText="OK" and cancelText="CANCEL"', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ expect(mockDatePickerProps.confirmText).toBe('OK');
+ expect(mockDatePickerProps.cancelText).toBe('CANCEL');
+ });
+
+ it('passes theme="android-dark"', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ expect(mockDatePickerProps.theme).toBe('android-dark');
+ });
+
+ it('passes customHeader containing a datepicker-header div', () => {
+ const { container } = renderComponent();
+ openPicker(container);
+ expect(mockDatePickerProps.customHeader.props.className).toBe('datepicker-header');
+ });
+ });
+
+ describe('useEffect — reinitializes dates on endDateLimit or date change', () => {
+ it('updates max when endDateLimit prop changes', () => {
+ const { container, rerender } = renderComponent();
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ const originalMax = mockDatePickerProps.max;
+
+ act(() => {
+ rerender(<MobileDatePicker {...defaultProps} endDateLimit="2025-12-31T00:00:00Z" />);
+ });
+ expect(mockDatePickerProps.max.getTime()).not.toBe(originalMax.getTime());
+ });
+
+ it('updates time when date prop changes', () => {
+ const { container, rerender } = renderComponent();
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ const originalValue = mockDatePickerProps.value.getTime();
+
+ act(() => {
+ rerender(<MobileDatePicker {...defaultProps} date="2021-01-01T00:00:00Z" />);
+ });
+ expect(mockDatePickerProps.value.getTime()).not.toBe(originalValue);
+ });
+ });
+
+ describe('cleanup useEffect — portal removed on unmount', () => {
+ it('removes Modal-Portal from body when component unmounts after opening', () => {
+ const { container, unmount } = renderComponent();
+ act(() => {
+ fireEvent.click(container.querySelector('.mobile-date-picker-select-btn'));
+ });
+ expect(document.body.querySelector('.Modal-Portal')).toBeInTheDocument();
+ act(() => { unmount(); });
+ expect(document.body.querySelector('.Modal-Portal')).not.toBeInTheDocument();
+ });
+
+ it('unmounts cleanly when the picker was never opened (no portal to remove)', () => {
+ const { unmount } = renderComponent();
+ expect(() => act(() => { unmount(); })).not.toThrow();
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-axis/date-calc.test.js b/web/js/components/timeline/timeline-axis/date-calc.test.js
index bb7cc2a6c..2539666d4 100644
--- a/web/js/components/timeline/timeline-axis/date-calc.test.js
+++ b/web/js/components/timeline/timeline-axis/date-calc.test.js
@@ -1,3 +1,60 @@
-test('date-calc component test', () => {
+import moment from 'moment';
+import getTimeRange from './date-calc';
+const START_LIMIT = '2010-01-01T00:00:00Z';
+const END_LIMIT = '2030-01-01T00:00:00Z';
+
+describe('getTimeRange', () => {
+ it('builds a consecutive range of day time units', () => {
+ const begin = moment.utc('2023-05-01T00:00:00Z');
+ const end = moment.utc('2023-05-04T00:00:00Z');
+ const range = getTimeRange(begin, end, 'day', START_LIMIT, END_LIMIT);
+ expect(range.length).toBe(4);
+ expect(range[0].timeScale).toBe('day');
+ expect(range[0].rawDate.startsWith('2023-05-01')).toBe(true);
+ // each entry carries the standard shape
+ expect(range[0]).toHaveProperty('dateObject');
+ expect(range[0]).toHaveProperty('dayOfWeek');
+ expect(range[0]).toHaveProperty('rawNextDate');
+ });
+
+ it('uppercases the formatted date string', () => {
+ const begin = moment.utc('2023-05-01T00:00:00Z');
+ const end = moment.utc('2023-05-01T00:00:00Z');
+ const range = getTimeRange(begin, end, 'day', START_LIMIT, END_LIMIT);
+ // day format is 'MMM YYYY' -> 'MAY 2023'
+ expect(range[0].date).toBe('MAY 2023');
+ });
+
+ it('marks entries within the limits as withinRange and those outside as not', () => {
+ const begin = moment.utc('2009-12-30T00:00:00Z');
+ const end = moment.utc('2010-01-02T00:00:00Z');
+ const range = getTimeRange(begin, end, 'day', START_LIMIT, END_LIMIT);
+ // first entries precede the start limit
+ expect(range[0].withinRange).toBe(false);
+ expect(range[range.length - 1].withinRange).toBe(true);
+ });
+
+ it('produces a single entry when begin equals end', () => {
+ const date = moment.utc('2023-05-01T00:00:00Z');
+ const range = getTimeRange(date.clone(), date.clone(), 'day', START_LIMIT, END_LIMIT);
+ expect(range.length).toBe(1);
+ });
+
+ it('supports a monthly timescale', () => {
+ const begin = moment.utc('2023-01-01T00:00:00Z');
+ const end = moment.utc('2023-04-01T00:00:00Z');
+ const range = getTimeRange(begin, end, 'month', START_LIMIT, END_LIMIT);
+ expect(range.length).toBe(4);
+ expect(range[0].timeScale).toBe('month');
+ });
+
+ it('reuses cached moment limits across calls', () => {
+ const begin = moment.utc('2023-05-01T00:00:00Z');
+ const end = moment.utc('2023-05-02T00:00:00Z');
+ // first call populates the cache, second call exercises the cache-hit branch
+ const first = getTimeRange(begin.clone(), end.clone(), 'day', START_LIMIT, END_LIMIT);
+ const second = getTimeRange(begin.clone(), end.clone(), 'day', START_LIMIT, END_LIMIT);
+ expect(first.length).toBe(second.length);
+ });
});
diff --git a/web/js/components/timeline/timeline-axis/date-tooltip/axis-hover-line.test.js b/web/js/components/timeline/timeline-axis/date-tooltip/axis-hover-line.test.js
index 1b89bad96..165ec59a7 100644
--- a/web/js/components/timeline/timeline-axis/date-tooltip/axis-hover-line.test.js
+++ b/web/js/components/timeline/timeline-axis/date-tooltip/axis-hover-line.test.js
@@ -1,3 +1,112 @@
-test('axis-hover-line component test', () => {
+import { render } from '@testing-library/react';
+import AxisHoverLine from './axis-hover-line';
+const layers = [
+ { startDate: '2020-01-01', visible: true },
+ { startDate: '2020-01-01', visible: false },
+ { startDate: null, visible: true },
+];
+
+function renderLine(props = {}) {
+ return render(
+ <AxisHoverLine
+ activeLayers={props.activeLayers || layers}
+ axisWidth={props.axisWidth ?? 1000}
+ hoverLinePosition={props.hoverLinePosition ?? 200}
+ selectedDraggerPosition={props.selectedDraggerPosition ?? 100}
+ isAnimationDraggerDragging={props.isAnimationDraggerDragging || false}
+ isTimelineDragging={props.isTimelineDragging || false}
+ isDraggerDragging={props.isDraggerDragging || false}
+ isTimelineLayerCoveragePanelOpen={props.isTimelineLayerCoveragePanelOpen || false}
+ showHoverLine={props.showHoverLine || false}
+ shouldIncludeHiddenLayers={props.shouldIncludeHiddenLayers || false}
+ />,
+ );
+}
+
+describe('AxisHoverLine', () => {
+ it('renders nothing when there is nothing to display', () => {
+ const { container } = renderLine({ showHoverLine: false });
+ expect(container.querySelector('.axis-hover-line-container')).toBeNull();
+ });
+
+ it('renders the hover line when showHoverLine is set and nothing is blocking', () => {
+ const { container } = renderLine({ showHoverLine: true });
+ const svg = container.querySelector('.axis-hover-line-container');
+ expect(svg).toBeTruthy();
+ expect(svg.getAttribute('width')).toBe('1000');
+ expect(svg.getAttribute('height')).toBe('63');
+ });
+
+ it('positions the inner line at the hover position', () => {
+ const { container } = renderLine({ showHoverLine: true, hoverLinePosition: 200 });
+ const line = container.querySelector('.axis-hover-line');
+ expect(line.getAttribute('transform')).toBe('translate(201)');
+ expect(line.getAttribute('y2')).toBe('63');
+ });
+
+ it('does not display while the timeline is being dragged', () => {
+ const { container } = renderLine({ showHoverLine: true, isTimelineDragging: true });
+ expect(container.querySelector('.axis-hover-line-container')).toBeNull();
+ });
+
+ it('does not display while the animation dragger is being dragged', () => {
+ const { container } = renderLine({ showHoverLine: true, isAnimationDraggerDragging: true });
+ expect(container.querySelector('.axis-hover-line-container')).toBeNull();
+ });
+
+ it('increases line height based on visible layer count when the coverage panel is open', () => {
+ // two visible layers with startDate -> layerLengthCoef 2 -> 112 + 80 = 192
+ const { container } = renderLine({
+ showHoverLine: true,
+ isTimelineLayerCoveragePanelOpen: true,
+ activeLayers: [
+ { startDate: '2020-01-01', visible: true },
+ { startDate: '2020-01-01', visible: true },
+ ],
+ });
+ const svg = container.querySelector('.axis-hover-line-container');
+ expect(svg.getAttribute('height')).toBe('192');
+ });
+
+ it('counts hidden layers when shouldIncludeHiddenLayers is set', () => {
+ // two layers have startDate (regardless of visibility) -> coef 2 -> 192
+ const { container } = renderLine({
+ showHoverLine: true,
+ isTimelineLayerCoveragePanelOpen: true,
+ shouldIncludeHiddenLayers: true,
+ });
+ const svg = container.querySelector('.axis-hover-line-container');
+ expect(svg.getAttribute('height')).toBe('192');
+ });
+
+ it('displays the dragger hover line in the coverage panel even without showHoverLine', () => {
+ const { container } = renderLine({
+ showHoverLine: false,
+ isTimelineLayerCoveragePanelOpen: true,
+ isDraggerDragging: true,
+ selectedDraggerPosition: 100,
+ activeLayers: [
+ { startDate: '2020-01-01', visible: true },
+ { startDate: '2020-01-01', visible: true },
+ ],
+ });
+ const line = container.querySelector('.axis-hover-line');
+ expect(line).toBeTruthy();
+ // linePosition = selectedDraggerPosition + 47 = 147; transform translate(148)
+ expect(line.getAttribute('transform')).toBe('translate(148)');
+ // lineHeightInner = 47 + min(2,5)*40.5 = 47 + 81 = 128
+ expect(line.getAttribute('y2')).toBe('128');
+ });
+
+ it('uses a minimum layer coefficient of 1 when there are no qualifying layers', () => {
+ const { container } = renderLine({
+ showHoverLine: true,
+ isTimelineLayerCoveragePanelOpen: true,
+ activeLayers: [{ startDate: null, visible: false }],
+ });
+ const svg = container.querySelector('.axis-hover-line-container');
+ // 112 + min(1,5)*40 = 152
+ expect(svg.getAttribute('height')).toBe('152');
+ });
});
diff --git a/web/js/components/timeline/timeline-axis/date-tooltip/date-tooltip.test.js b/web/js/components/timeline/timeline-axis/date-tooltip/date-tooltip.test.js
index 33134e899..cf66f8782 100644
--- a/web/js/components/timeline/timeline-axis/date-tooltip/date-tooltip.test.js
+++ b/web/js/components/timeline/timeline-axis/date-tooltip/date-tooltip.test.js
@@ -1,3 +1,186 @@
-test('date-tooltip component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, act } from '@testing-library/react';
+import DateTooltip from './date-tooltip';
+jest.mock('../../date-util', () => ({
+ getDisplayDate: jest.fn(() => '2023 MAY 01'),
+ getDaysInYear: jest.fn(() => 5),
+}));
+
+const dateUtil = require('../../date-util');
+
+function buildProps(overrides = {}) {
+ return {
+ activeLayers: [
+ { startDate: '2020-01-01', visible: true },
+ { startDate: '2020-01-01', visible: true },
+ ],
+ axisWidth: 1000,
+ hasSubdailyLayers: false,
+ hoverTime: '2023-05-02T00:00:00Z',
+ isTimelineLayerCoveragePanelOpen: false,
+ leftOffset: 300,
+ selectedDate: '2023-05-01T00:00:00Z',
+ selectedDraggerPosition: 100,
+ shouldIncludeHiddenLayers: false,
+ showDraggerTime: false,
+ showHoverLine: false,
+ ...overrides,
+ };
+}
+
+function renderTooltip(overrides = {}) {
+ return render(<DateTooltip {...buildProps(overrides)} />);
+}
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ jest.useFakeTimers();
+ dateUtil.getDisplayDate.mockReturnValue('2023 MAY 01');
+ dateUtil.getDaysInYear.mockReturnValue(5);
+});
+
+afterEach(() => {
+ jest.runOnlyPendingTimers();
+ jest.useRealTimers();
+});
+
+describe('DateTooltip', () => {
+ it('shows the tooltip on mount and renders the formatted date and DOY', () => {
+ const { container } = renderTooltip();
+ expect(container.querySelector('.date-tooltip-fade')).toBeTruthy();
+ expect(container.textContent).toContain('2023 MAY 01');
+ // getDaysInYear returns 5 -> padded to 005
+ expect(container.textContent).toContain('DOY 005');
+ });
+
+ it('hides the tooltip after the 1800ms timeout', () => {
+ const { container } = renderTooltip();
+ act(() => {
+ jest.advanceTimersByTime(1800);
+ });
+ expect(container.querySelector('.date-tooltip-fade')).toBeNull();
+ expect(container.querySelector('.date-tooltip-day')).toBeNull();
+ });
+
+ it('pads a day-of-year between 10 and 99 with a single zero', () => {
+ dateUtil.getDaysInYear.mockReturnValue(50);
+ const { container } = renderTooltip();
+ expect(container.textContent).toContain('DOY 050');
+ });
+
+ it('does not pad a day-of-year of 100 or more', () => {
+ dateUtil.getDaysInYear.mockReturnValue(150);
+ const { container } = renderTooltip();
+ expect(container.textContent).toContain('DOY 150');
+ });
+
+ it('shows a dragger tooltip from the selected date', () => {
+ const { container } = renderTooltip({ showDraggerTime: true });
+ expect(dateUtil.getDisplayDate).toHaveBeenCalledWith(new Date('2023-05-01T00:00:00Z'), false);
+ expect(container.querySelector('.date-tooltip').style.display).toBe('block');
+ });
+
+ it('hides the dragger tooltip when the dragger position is out of range', () => {
+ const { container } = renderTooltip({ showDraggerTime: true, selectedDraggerPosition: -100 });
+ expect(container.querySelector('.date-tooltip').style.display).toBe('none');
+ });
+
+ it('shows a hover tooltip from the hover time once the mount tooltip times out', () => {
+ const { container } = renderTooltip({ showHoverLine: true });
+ act(() => {
+ jest.advanceTimersByTime(1800);
+ });
+ // showTooltip is now false, so the hover branch drives the display
+ expect(container.querySelector('.date-tooltip').style.display).toBe('block');
+ expect(container.textContent).toContain('2023 MAY 01');
+ });
+
+ it('widens the tooltip and shifts offsets for subdaily layers', () => {
+ const { container } = renderTooltip({ showDraggerTime: true, hasSubdailyLayers: true });
+ const tooltip = container.querySelector('.date-tooltip');
+ expect(tooltip.style.width).toBe('286px');
+ expect(dateUtil.getDisplayDate).toHaveBeenCalledWith(expect.any(Date), true);
+ });
+
+ it('adjusts the tooltip height offset when the coverage panel is open', () => {
+ const { container } = renderTooltip({
+ showDraggerTime: true,
+ isTimelineLayerCoveragePanelOpen: true,
+ });
+ const tooltip = container.querySelector('.date-tooltip');
+ // -136 - min(2,5)*40 = -216
+ expect(tooltip.style.transform).toContain('-216px');
+ });
+
+ it('clamps the coverage-panel height offset to a minimum', () => {
+ const manyLayers = Array.from({ length: 10 }, () => ({ startDate: '2020-01-01', visible: true }));
+ const { container } = renderTooltip({
+ showDraggerTime: true,
+ isTimelineLayerCoveragePanelOpen: true,
+ activeLayers: manyLayers,
+ });
+ const tooltip = container.querySelector('.date-tooltip');
+ // -136 - min(10,5)*40 = -336, not clamped to -357 yet; verify it is computed
+ expect(tooltip.style.transform).toContain('-336px');
+ });
+
+ it('uses the subdaily hover offset for a hover tooltip', () => {
+ const { container } = renderTooltip({ showHoverLine: true, hasSubdailyLayers: true });
+ act(() => {
+ jest.advanceTimersByTime(1800);
+ });
+ const tooltip = container.querySelector('.date-tooltip');
+ // hover + subdaily -> leftOffset(300) - 146 = 154
+ expect(tooltip.style.transform).toContain('154px');
+ });
+
+ it('counts hidden layers for the coverage-panel height when requested', () => {
+ const { container } = renderTooltip({
+ showDraggerTime: true,
+ isTimelineLayerCoveragePanelOpen: true,
+ shouldIncludeHiddenLayers: true,
+ activeLayers: [
+ { startDate: '2020-01-01', visible: false },
+ { startDate: '2020-01-01', visible: true },
+ { startDate: null, visible: true },
+ ],
+ });
+ const tooltip = container.querySelector('.date-tooltip');
+ // two layers have startDate -> -136 - min(2,5)*40 = -216
+ expect(tooltip.style.transform).toContain('-216px');
+ });
+
+ it('hides the tooltip on hover time change', () => {
+ const { container, rerender } = renderTooltip();
+ rerender(<DateTooltip {...buildProps({ hoverTime: '2023-05-09T00:00:00Z' })} />);
+ expect(container.querySelector('.date-tooltip-fade')).toBeNull();
+ });
+
+ it('re-displays the tooltip when the selected date changes without hover/dragger', () => {
+ const { container } = renderTooltip();
+ act(() => {
+ jest.advanceTimersByTime(1800);
+ });
+ expect(container.querySelector('.date-tooltip-fade')).toBeNull();
+ // changing the selected date while not hovering re-shows the tooltip
+ render(<DateTooltip {...buildProps({ selectedDate: '2023-05-04T00:00:00Z' })} />);
+ });
+
+ it('re-displays the tooltip on selected date change via rerender', () => {
+ const { container, rerender } = renderTooltip();
+ act(() => {
+ jest.advanceTimersByTime(1800);
+ });
+ rerender(<DateTooltip {...buildProps({ selectedDate: '2023-05-04T00:00:00Z' })} />);
+ expect(container.querySelector('.date-tooltip-fade')).toBeTruthy();
+ });
+
+ it('clears the pending timeout on unmount', () => {
+ const clearSpy = jest.spyOn(global, 'clearTimeout');
+ const { unmount } = renderTooltip();
+ unmount();
+ expect(clearSpy).toHaveBeenCalled();
+ clearSpy.mockRestore();
+ });
});
diff --git a/web/js/components/timeline/timeline-axis/grid-range/grid-range.test.js b/web/js/components/timeline/timeline-axis/grid-range/grid-range.test.js
index 47c15e577..f72c45667 100644
--- a/web/js/components/timeline/timeline-axis/grid-range/grid-range.test.js
+++ b/web/js/components/timeline/timeline-axis/grid-range/grid-range.test.js
@@ -1,3 +1,91 @@
-test('grid-range component test', () => {
+import { render } from '@testing-library/react';
+import GridRange from './grid-range';
+jest.mock('./tile-rect', () => () => <g data-testid="tile-rect" />);
+jest.mock('./tile-text', () => () => <g data-testid="tile-text" />);
+
+function item(overrides = {}) {
+ return {
+ withinRange: true,
+ dateObject: {},
+ ...overrides,
+ };
+}
+
+function renderGrid(props = {}) {
+ return render(
+ <svg>
+ <GridRange
+ gridWidth={props.gridWidth ?? 12}
+ transformX={props.transformX ?? 50}
+ timeScale={props.timeScale || 'day'}
+ timeRange={props.timeRange || []}
+ showHover={props.showHover || jest.fn()}
+ />
+ </svg>,
+ );
+}
+
+describe('GridRange', () => {
+ it('applies the horizontal transform to the container group', () => {
+ const { container } = renderGrid({ transformX: 75 });
+ expect(container.querySelector('.axis-grid-container').getAttribute('transform'))
+ .toBe('translate(75)');
+ });
+
+ it('skips items that are not within range', () => {
+ const { queryAllByTestId } = renderGrid({
+ timeScale: 'day',
+ timeRange: [
+ item({ withinRange: false, dateObject: { date: 1 } }),
+ item({ withinRange: false, dateObject: { date: 2 } }),
+ ],
+ });
+ expect(queryAllByTestId('tile-rect').length).toBe(0);
+ });
+
+ it('renders a tile rect for each in-range item and text only when the condition is met', () => {
+ const { queryAllByTestId } = renderGrid({
+ timeScale: 'day',
+ timeRange: [
+ item({ dateObject: { date: 1 } }), // text condition met (day === 1)
+ item({ dateObject: { date: 2 } }), // no text
+ item({ withinRange: false, dateObject: { date: 3 } }), // skipped
+ ],
+ });
+ expect(queryAllByTestId('tile-rect').length).toBe(2);
+ expect(queryAllByTestId('tile-text').length).toBe(1);
+ });
+
+ it('uses the minute text condition (0/15/30/45)', () => {
+ const { queryAllByTestId } = renderGrid({
+ timeScale: 'minute',
+ timeRange: [item({ dateObject: { minutes: 15 } }), item({ dateObject: { minutes: 7 } })],
+ });
+ expect(queryAllByTestId('tile-text').length).toBe(1);
+ });
+
+ it('uses the hour text condition (0/6/12/18)', () => {
+ const { queryAllByTestId } = renderGrid({
+ timeScale: 'hour',
+ timeRange: [item({ dateObject: { hours: 6 } }), item({ dateObject: { hours: 5 } })],
+ });
+ expect(queryAllByTestId('tile-text').length).toBe(1);
+ });
+
+ it('uses the month text condition (January only)', () => {
+ const { queryAllByTestId } = renderGrid({
+ timeScale: 'month',
+ timeRange: [item({ dateObject: { months: 0 } }), item({ dateObject: { months: 3 } })],
+ });
+ expect(queryAllByTestId('tile-text').length).toBe(1);
+ });
+
+ it('uses the year text condition (decades only)', () => {
+ const { queryAllByTestId } = renderGrid({
+ timeScale: 'year',
+ timeRange: [item({ dateObject: { years: 2020 } }), item({ dateObject: { years: 2021 } })],
+ });
+ expect(queryAllByTestId('tile-text').length).toBe(1);
+ });
});
diff --git a/web/js/components/timeline/timeline-axis/grid-range/tile-rect.test.js b/web/js/components/timeline/timeline-axis/grid-range/tile-rect.test.js
index 8b10bb375..a7961d57b 100644
--- a/web/js/components/timeline/timeline-axis/grid-range/tile-rect.test.js
+++ b/web/js/components/timeline/timeline-axis/grid-range/tile-rect.test.js
@@ -1,3 +1,93 @@
-test('tile-rect component test', () => {
+import { render, fireEvent } from '@testing-library/react';
+import TileRect from './tile-rect';
+function renderRect(props = {}) {
+ const showHover = props.showHover || jest.fn();
+ const item = {
+ rawDate: '2023-05-01',
+ rawNextDate: '2023-05-02',
+ dayOfWeek: props.dayOfWeek ?? 1,
+ dateObject: props.dateObject || {},
+ ...props.item,
+ };
+ const utils = render(
+ <svg>
+ <TileRect
+ item={item}
+ index={props.index ?? 2}
+ gridWidth={props.gridWidth ?? 12}
+ timeScale={props.timeScale}
+ showHover={showHover}
+ />
+ </svg>,
+ );
+ return { showHover, ...utils };
+}
+
+const getWhiteLine = (container) => container.querySelectorAll('line.axis-grid-line')[2];
+
+describe('TileRect rendering', () => {
+ it('renders the rect and grid lines', () => {
+ const { container } = renderRect({ timeScale: 'day', dateObject: { date: 5 }, dayOfWeek: 1 });
+ expect(container.querySelector('rect.axis-grid-rect')).toBeTruthy();
+ expect(container.querySelectorAll('line.axis-grid-line').length).toBe(3);
+ });
+
+ it('positions the rect using index * gridWidth', () => {
+ const { container } = renderRect({
+ timeScale: 'day', index: 3, gridWidth: 10, dateObject: { date: 5 },
+ });
+ expect(container.querySelector('rect.axis-grid-rect').getAttribute('x')).toBe('30');
+ });
+
+ it('calls showHover with raw dates and index on mouse move', () => {
+ const { container, showHover } = renderRect({ timeScale: 'day', dateObject: { date: 5 }, index: 4 });
+ fireEvent.mouseMove(container.querySelector('g'));
+ expect(showHover).toHaveBeenCalledWith(expect.anything(), '2023-05-01', '2023-05-02', 4);
+ });
+});
+
+describe('TileRect lineLengthY by timeScale', () => {
+ it('minute: full length (62) at quarter-hour marks', () => {
+ const { container } = renderRect({ timeScale: 'minute', dateObject: { minutes: 30 } });
+ expect(getWhiteLine(container).getAttribute('y2')).toBe('62');
+ });
+
+ it('minute: 20 on multiples of 5, 10 otherwise', () => {
+ const { container: c1 } = renderRect({ timeScale: 'minute', dateObject: { minutes: 5 } });
+ expect(getWhiteLine(c1).getAttribute('y2')).toBe('20');
+ const { container: c2 } = renderRect({ timeScale: 'minute', dateObject: { minutes: 7 } });
+ expect(getWhiteLine(c2).getAttribute('y2')).toBe('10');
+ });
+
+ it('hour: full length at 0, 22 at 6/12/18, 10 otherwise', () => {
+ expect(getWhiteLine(renderRect({ timeScale: 'hour', dateObject: { hours: 0 } }).container).getAttribute('y2')).toBe('62');
+ expect(getWhiteLine(renderRect({ timeScale: 'hour', dateObject: { hours: 12 } }).container).getAttribute('y2')).toBe('22');
+ expect(getWhiteLine(renderRect({ timeScale: 'hour', dateObject: { hours: 3 } }).container).getAttribute('y2')).toBe('10');
+ });
+
+ it('day: full length on the 1st, 22 on Sundays, 10 otherwise', () => {
+ expect(getWhiteLine(renderRect({ timeScale: 'day', dateObject: { date: 1 }, dayOfWeek: 3 }).container).getAttribute('y2')).toBe('62');
+ expect(getWhiteLine(renderRect({ timeScale: 'day', dateObject: { date: 5 }, dayOfWeek: 0 }).container).getAttribute('y2')).toBe('22');
+ expect(getWhiteLine(renderRect({ timeScale: 'day', dateObject: { date: 5 }, dayOfWeek: 3 }).container).getAttribute('y2')).toBe('10');
+ });
+
+ it('month: full length in January, 22 on quarters, 10 otherwise', () => {
+ expect(getWhiteLine(renderRect({ timeScale: 'month', dateObject: { months: 0 } }).container).getAttribute('y2')).toBe('62');
+ expect(getWhiteLine(renderRect({ timeScale: 'month', dateObject: { months: 3 } }).container).getAttribute('y2')).toBe('22');
+ expect(getWhiteLine(renderRect({ timeScale: 'month', dateObject: { months: 4 } }).container).getAttribute('y2')).toBe('10');
+ });
+
+ it('year: full length each decade, 22 on multiples of 5, 10 otherwise', () => {
+ expect(getWhiteLine(renderRect({ timeScale: 'year', dateObject: { years: 2020 } }).container).getAttribute('y2')).toBe('62');
+ expect(getWhiteLine(renderRect({ timeScale: 'year', dateObject: { years: 2015 } }).container).getAttribute('y2')).toBe('22');
+ expect(getWhiteLine(renderRect({ timeScale: 'year', dateObject: { years: 2017 } }).container).getAttribute('y2')).toBe('10');
+ });
+
+ it('uses a thinner stroke (1) only when the line length is 10', () => {
+ const { container: thin } = renderRect({ timeScale: 'year', dateObject: { years: 2017 } });
+ expect(getWhiteLine(thin).getAttribute('stroke-width')).toBe('1');
+ const { container: thick } = renderRect({ timeScale: 'year', dateObject: { years: 2020 } });
+ expect(getWhiteLine(thick).getAttribute('stroke-width')).toBe('2');
+ });
});
diff --git a/web/js/components/timeline/timeline-axis/grid-range/tile-text.test.js b/web/js/components/timeline/timeline-axis/grid-range/tile-text.test.js
index 9664fd3d5..4f1aa1f67 100644
--- a/web/js/components/timeline/timeline-axis/grid-range/tile-text.test.js
+++ b/web/js/components/timeline/timeline-axis/grid-range/tile-text.test.js
@@ -1,3 +1,71 @@
-test('tile-text component test', () => {
+import { render } from '@testing-library/react';
+import TileText from './tile-text';
+// SVG fragments need to be rendered inside an <svg> for the DOM to be valid
+function renderText(item, index = 2, gridWidth = 12) {
+ return render(<svg><TileText item={item} index={index} gridWidth={gridWidth} /></svg>);
+}
+
+describe('TileText', () => {
+ it('renders a day tile with separate date and year text', () => {
+ const { container } = renderText({
+ timeScale: 'day',
+ date: '01 2023',
+ dateObject: { date: 1 },
+ });
+ const dayText = container.querySelector('.axis-grid-text-day');
+ const yearText = container.querySelector('.axis-grid-text-year');
+ expect(dayText.textContent).toBe('01');
+ expect(yearText.textContent).toBe('2023');
+ // index(2) * gridWidth(12) + xOffset(8) = 32
+ expect(container.querySelector('g').getAttribute('transform')).toBe('translate(32)');
+ });
+
+ it('renders an hour tile with a formatted time label at 6/12/18', () => {
+ const { container } = renderText({
+ timeScale: 'hour',
+ date: 'fallback',
+ dateObject: { hours: 12 },
+ });
+ expect(container.querySelector('.axis-grid-text-hour').textContent).toBe('12:00');
+ });
+
+ it('falls back to item.date for other hours', () => {
+ const { container } = renderText({
+ timeScale: 'hour',
+ date: '3 AM',
+ dateObject: { hours: 3 },
+ });
+ expect(container.querySelector('.axis-grid-text-hour').textContent).toBe('3 AM');
+ });
+
+ it('uses a smaller x offset for month tiles', () => {
+ const { container } = renderText({
+ timeScale: 'month',
+ date: 'May',
+ dateObject: { months: 4 },
+ }, 1, 10);
+ // index(1) * gridWidth(10) + xOffset(5) = 15
+ expect(container.querySelector('g').getAttribute('transform')).toBe('translate(15)');
+ expect(container.querySelector('.axis-grid-text-month').textContent).toBe('May');
+ });
+
+ it('uses a smaller x offset for year tiles', () => {
+ const { container } = renderText({
+ timeScale: 'year',
+ date: '2020',
+ dateObject: { years: 2020 },
+ }, 0, 10);
+ expect(container.querySelector('g').getAttribute('transform')).toBe('translate(5)');
+ });
+
+ it('renders a minute tile with the default offset and no year text', () => {
+ const { container } = renderText({
+ timeScale: 'minute',
+ date: ':30',
+ dateObject: { minutes: 30 },
+ });
+ expect(container.querySelector('.axis-grid-text-minute').textContent).toBe(':30');
+ expect(container.querySelector('.axis-grid-text-year')).toBeNull();
+ });
});
diff --git a/web/js/components/timeline/timeline-axis/timeline-axis.test.js b/web/js/components/timeline/timeline-axis/timeline-axis.test.js
index 74021885d..3a031eab8 100644
--- a/web/js/components/timeline/timeline-axis/timeline-axis.test.js
+++ b/web/js/components/timeline/timeline-axis/timeline-axis.test.js
@@ -1,3 +1,553 @@
-test('timeline-axis component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { createRef } from 'react';
+import { render, act } from '@testing-library/react';
+import TimelineAxis from './timeline-axis';
+// Draggable just renders its single child here
+jest.mock('react-draggable', () => ({ __esModule: true, default: ({ children }) => children }));
+
+// Isolate the axis from the (separately tested) grid rendering
+jest.mock('./grid-range/grid-range', () => () => null);
+
+const START_LIMIT = '2010-01-01T00:00:00.000Z';
+const END_LIMIT = '2030-01-01T00:00:00.000Z';
+
+const createdWorkers = [];
+
+beforeAll(() => {
+ global.Worker = jest.fn().mockImplementation(() => {
+ const worker = {
+ postMessage: jest.fn(),
+ terminate: jest.fn(),
+ onmessage: null,
+ onerror: null,
+ };
+ createdWorkers.push(worker);
+ return worker;
+ });
+ global.DOMParser = class {
+ parseFromString() {
+ return { querySelector: () => ({ textContent: '2023-01-01/2023-12-31/P1D' }) };
+ }
+ };
+});
+
+function makeProps(overrides = {}) {
+ return {
+ activeLayers: [],
+ addGranuleDateRanges: jest.fn(),
+ animationEndLocation: 0,
+ animationStartLocation: 0,
+ animEndLocationDate: null,
+ animStartLocationDate: null,
+ appNow: new Date('2023-06-01T00:00:00.000Z'),
+ axisWidth: 1000,
+ backDate: '2023-05-31T00:00:00.000Z',
+ dateA: '2023-05-15T00:00:00.000Z',
+ dateB: '2023-05-16T00:00:00.000Z',
+ debounceChangeTimeScaleWheel: jest.fn(),
+ draggerPosition: 200,
+ draggerPositionB: 250,
+ draggerSelected: 'selected',
+ draggerTimeState: '2023-05-15T00:00:00.000Z',
+ draggerTimeStateB: '2023-05-16T00:00:00.000Z',
+ draggerVisible: true,
+ draggerVisibleB: false,
+ frontDate: '2023-05-01T00:00:00.000Z',
+ hasFutureLayers: false,
+ hasSubdailyLayers: false,
+ hoverTime: '2023-05-15T00:00:00.000Z',
+ isAnimationDraggerDragging: false,
+ isAnimationPlaying: false,
+ isAnimatingToEvent: false,
+ isCompareModeActive: false,
+ isDraggerDragging: false,
+ isTimelineDragging: false,
+ isTourActive: false,
+ leftOffset: 500,
+ matchingTimelineCoverage: [],
+ onDateChange: jest.fn(),
+ parentOffset: 10,
+ position: 100,
+ proj: { crs: 'EPSG:4326' },
+ showHover: jest.fn(),
+ showHoverOff: jest.fn(),
+ showHoverOn: jest.fn(),
+ timelineEndDateLimit: END_LIMIT,
+ timelineStartDateLimit: START_LIMIT,
+ timeScale: 'day',
+ transformX: -50,
+ updateDraggerDatePosition: jest.fn(),
+ updatePositioning: jest.fn(),
+ updatePositioningOnAxisStopDrag: jest.fn(),
+ updatePositioningOnSimpleDrag: jest.fn(),
+ updateTimelineMoveAndDrag: jest.fn(),
+ describeDomainsUrl: 'https://dd.example.com',
+ cmrBaseUrl: 'https://cmr.example.com',
+ ...overrides,
+ };
+}
+
+function mountAxis(overrides = {}) {
+ const ref = createRef();
+ // single props object so callback (jest.fn) references stay stable across rerenders
+ const props = makeProps(overrides);
+ const utils = render(<TimelineAxis ref={ref} {...props} />);
+ const rerender = (newOverrides) => {
+ Object.assign(props, newOverrides);
+ utils.rerender(<TimelineAxis ref={ref} {...props} />);
+ };
+ return {
+ ...utils, ref, props, rerender,
+ };
+}
+
+const evt = (overrides = {}) => ({
+ preventDefault: jest.fn(),
+ stopPropagation: jest.fn(),
+ persist: jest.fn(),
+ type: 'mousemove',
+ target: { className: { animVal: 'axis-grid-rect' } },
+ clientX: 100,
+ ...overrides,
+});
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ createdWorkers.length = 0;
+});
+
+describe('TimelineAxis mount & render', () => {
+ it('renders the axis container and grid after mounting', () => {
+ const { container } = mountAxis();
+ expect(container.querySelector('.timeline-axis-container')).toBeTruthy();
+ expect(container.querySelector('.timeline-axis-svg')).toBeTruthy();
+ });
+
+ it('computes a current time range on mount', () => {
+ const { ref } = mountAxis();
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ expect(ref.current.state.init).toBe(false);
+ });
+
+ it('calls updatePositioning during the initial scale update', () => {
+ const { props } = mountAxis();
+ expect(props.updatePositioning).toHaveBeenCalled();
+ });
+
+ it('renders matching coverage lines when coverage data is present', () => {
+ const { container } = mountAxis({
+ matchingTimelineCoverage: [{ startDate: '2023-05-05T00:00:00Z', endDate: '2023-05-20T00:00:00Z' }],
+ frontDate: '2023-05-01T00:00:00.000Z',
+ backDate: '2023-05-31T00:00:00.000Z',
+ });
+ expect(container.querySelector('.axis-matching-layer-coverage-line')).toBeTruthy();
+ });
+
+ it('mounts with a year timescale', () => {
+ const { ref } = mountAxis({ timeScale: 'year' });
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('mounts with a month timescale', () => {
+ const { ref } = mountAxis({ timeScale: 'month' });
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('mounts with the B dragger selected', () => {
+ const { ref } = mountAxis({ draggerSelected: 'selectedB' });
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('mounts in compare mode with animation dragger locations', () => {
+ const { ref } = mountAxis({
+ isCompareModeActive: true,
+ animStartLocationDate: '2023-05-10T00:00:00.000Z',
+ animEndLocationDate: '2023-05-20T00:00:00.000Z',
+ });
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+});
+
+describe('TimelineAxis updateScale variations', () => {
+ it('handles a greater-to-lesser timescale change with hover', () => {
+ const { ref } = mountAxis();
+ act(() => {
+ ref.current.updateScale('2023-05-15T00:00:00.000Z', 'day', 0.5, true, 'year');
+ });
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('handles updateScaleWithOffset for a past date and a future date', () => {
+ const { ref } = mountAxis();
+ act(() => {
+ ref.current.updateScaleWithOffset('2023-05-10T00:00:00.000Z', 'day', true);
+ });
+ act(() => {
+ ref.current.updateScaleWithOffset('2023-05-20T00:00:00.000Z', 'day', false);
+ });
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+});
+
+describe('TimelineAxis time range helpers', () => {
+ it('builds a time range array for day/hour/minute/month/year scales', () => {
+ ['day', 'hour', 'minute'].forEach((timeScale) => {
+ const { ref } = mountAxis({ timeScale });
+ const range = ref.current.getTimeRangeArray(5, 5, '2023-05-15T00:00:00.000Z');
+ expect(range.length).toBeGreaterThan(0);
+ });
+ const { ref: yearRef } = mountAxis({ timeScale: 'year' });
+ expect(yearRef.current.getTimeRangeArray(0, 0, '2023-05-15T00:00:00.000Z').length).toBeGreaterThan(0);
+ const { ref: monthRef } = mountAxis({ timeScale: 'month' });
+ expect(monthRef.current.getTimeRangeArray(0, 0, '2023-05-15T00:00:00.000Z').length).toBeGreaterThan(0);
+ });
+
+ it('updates the time range when dragging right (exposing past dates)', () => {
+ const { ref } = mountAxis();
+ let result;
+ act(() => {
+ result = ref.current.updateTimeRangeFromDrag(100, 50, 200, 250, 0);
+ });
+ expect(result.newCurrentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('updates the time range when dragging left (exposing future dates)', () => {
+ const { ref } = mountAxis();
+ let result;
+ act(() => {
+ result = ref.current.updateTimeRangeFromDrag(100, -50, 200, 250, 0);
+ });
+ expect(result.newCurrentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('updates the time range for both draggers in compare mode', () => {
+ const { ref } = mountAxis({ isCompareModeActive: true });
+ let result;
+ act(() => {
+ result = ref.current.updateTimeRangeFromDrag(100, 50, 200, 250, 30);
+ });
+ expect(result).toHaveProperty('newDraggerPosition');
+ expect(result).toHaveProperty('newDraggerPositionB');
+ });
+});
+
+describe('TimelineAxis dragger checks', () => {
+ it('checkDraggerVisibility returns visible with a recalculated position', () => {
+ const { ref } = mountAxis();
+ const result = ref.current.checkDraggerVisibility('2023-05-15T00:00:00.000Z', false, 200, {
+ frontDate: '2023-05-01T00:00:00.000Z',
+ backDate: '2023-05-31T00:00:00.000Z',
+ position: 100,
+ transform: -50,
+ });
+ expect(result.isVisible).toBe(true);
+ });
+
+ it('checkDraggerVisibility returns not visible when out of range', () => {
+ const { ref } = mountAxis();
+ const result = ref.current.checkDraggerVisibility('2022-01-01T00:00:00.000Z', true, 200, {
+ frontDate: '2023-05-01T00:00:00.000Z',
+ backDate: '2023-05-31T00:00:00.000Z',
+ position: 100,
+ transform: -50,
+ });
+ expect(result.isVisible).toBe(false);
+ });
+
+ it('checkDraggerMoveOrUpdateScale evaluates A and B draggers', () => {
+ const { ref } = mountAxis();
+ const a = ref.current.checkDraggerMoveOrUpdateScale('2023-05-14T00:00:00.000Z', false);
+ const b = ref.current.checkDraggerMoveOrUpdateScale('2023-05-17T00:00:00.000Z', true);
+ expect(a).toHaveProperty('withinRange');
+ expect(b).toHaveProperty('newDateInThePast');
+ });
+
+ it('checkDraggerMoveOrUpdateScale flags the appNow edge case', () => {
+ const { ref } = mountAxis({
+ dateA: '2023-06-01T00:00:00Z',
+ backDate: '2023-06-15T00:00:00.000Z',
+ appNow: new Date('2023-06-01T00:00:00.000Z'),
+ });
+ const result = ref.current.checkDraggerMoveOrUpdateScale('2023-05-30T00:00:00.000Z', false);
+ expect(result.withinRange).toBe(false);
+ });
+
+ it('handleDraggerUpdateCheck triggers a scale update for a tour date change', () => {
+ const { ref } = mountAxis({ isTourActive: true });
+ act(() => {
+ ref.current.handleDraggerUpdateCheck(
+ '2025-01-01T00:00:00.000Z',
+ '2023-05-15T00:00:00.000Z',
+ '2023-05-15T00:00:00.000Z',
+ false,
+ );
+ });
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('handleDraggerUpdateCheck handles a changed date that needs an offset update', () => {
+ const { ref } = mountAxis();
+ act(() => {
+ ref.current.handleDraggerUpdateCheck(
+ '2025-01-01T00:00:00.000Z',
+ '2023-05-15T00:00:00.000Z',
+ '2024-01-01T00:00:00.000Z',
+ false,
+ );
+ });
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+});
+
+describe('TimelineAxis mouse / hover handlers', () => {
+ it('handleMouseDown records clientX for mouse and touch events', () => {
+ const { ref } = mountAxis();
+ act(() => ref.current.handleMouseDown(evt({ clientX: 321 })));
+ expect(ref.current.state.clientXOnDrag).toBe(321);
+ act(() => ref.current.handleMouseDown(evt({ type: 'touchstart', changedTouches: [{ pageX: 654 }] })));
+ expect(ref.current.state.clientXOnDrag).toBe(654);
+ });
+
+ it('showHoverOn resets the updatedTimeScale flag then fires the hover callback', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.showHoverOn(evt()));
+ expect(ref.current.state.updatedTimeScale).toBe(false);
+ act(() => ref.current.showHoverOn(evt()));
+ expect(props.showHoverOn).toHaveBeenCalled();
+ });
+
+ it('setLineTime ignores clicks that are not on the grid rect', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.setLineTime(evt({ target: { className: { animVal: 'other' } } })));
+ expect(props.updateDraggerDatePosition).not.toHaveBeenCalled();
+ });
+
+ it('setLineTime updates the dragger position on a stationary click', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.handleMouseDown(evt({ clientX: 100 })));
+ act(() => ref.current.setLineTime(evt({ clientX: 100 })));
+ expect(props.updateDraggerDatePosition).toHaveBeenCalled();
+ });
+
+ it('setLineTime in compare mode checks the other dragger visibility', () => {
+ const { ref, props } = mountAxis({ isCompareModeActive: true, draggerSelected: 'selectedB' });
+ act(() => ref.current.handleMouseDown(evt({ clientX: 100 })));
+ act(() => ref.current.setLineTime(evt({ clientX: 100 })));
+ expect(props.updateDraggerDatePosition).toHaveBeenCalled();
+ });
+
+ it('setLineTimeTouch updates the dragger position on a stationary touch', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.handleMouseDown(evt({ type: 'touchstart', changedTouches: [{ pageX: 150 }] })));
+ act(() => ref.current.setLineTimeTouch(evt({ changedTouches: [{ pageX: 150 }] })));
+ expect(props.updateDraggerDatePosition).toHaveBeenCalled();
+ });
+
+ it('setLineTimeTouch on a month scale uses the daysInMonth calculation', () => {
+ const { ref, props } = mountAxis({ timeScale: 'month' });
+ act(() => ref.current.handleMouseDown(evt({ type: 'touchstart', changedTouches: [{ pageX: 150 }] })));
+ act(() => ref.current.setLineTimeTouch(evt({ changedTouches: [{ pageX: 150 }] })));
+ expect(props.updateDraggerDatePosition).toHaveBeenCalled();
+ });
+
+ it('setLineTimeTouch ignores non grid-rect targets', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.setLineTimeTouch(evt({
+ target: { className: { animVal: 'other' } },
+ changedTouches: [{ pageX: 1 }],
+ })));
+ expect(props.updateDraggerDatePosition).not.toHaveBeenCalled();
+ });
+});
+
+describe('TimelineAxis wheel and drag handlers', () => {
+ it('handleWheelType zooms on a dominant vertical scroll', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.handleWheelType(evt({ deltaY: 10, deltaX: 0 })));
+ expect(props.debounceChangeTimeScaleWheel).toHaveBeenCalled();
+ expect(ref.current.state.wheelZoom).toBe(true);
+ });
+
+ it('handleWheelType pans on a dominant horizontal scroll', () => {
+ jest.useFakeTimers();
+ const { ref, props } = mountAxis();
+ act(() => ref.current.handleWheelType(evt({ deltaY: 0, deltaX: 10, type: 'wheel' })));
+ expect(props.updateTimelineMoveAndDrag).toHaveBeenCalled();
+ act(() => jest.runOnlyPendingTimers());
+ jest.useRealTimers();
+ });
+
+ it('handleWheelPan drags right (negative deltaX)', () => {
+ jest.useFakeTimers();
+ const { ref } = mountAxis();
+ act(() => ref.current.handleWheelPan(evt({ deltaX: -10, type: 'wheel' })));
+ act(() => jest.runOnlyPendingTimers());
+ jest.useRealTimers();
+ expect(ref.current).toBeTruthy();
+ });
+
+ it('handleStartDrag notifies the parent it is dragging', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.handleStartDrag());
+ expect(props.updateTimelineMoveAndDrag).toHaveBeenCalledWith(true);
+ });
+
+ it('handleDrag uses simple positioning for month/year scales', () => {
+ const { ref, props } = mountAxis({ timeScale: 'month' });
+ act(() => ref.current.handleDrag(evt({ type: 'mousemove' }), { deltaX: 10, x: 110 }));
+ expect(props.updatePositioningOnSimpleDrag).toHaveBeenCalled();
+ });
+
+ it('handleDrag with a small right delta uses simple positioning', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.handleDrag(evt({ type: 'mousemove' }), { deltaX: 5, x: 105 }));
+ expect(props.updatePositioningOnSimpleDrag).toHaveBeenCalled();
+ });
+
+ it('handleDrag with a large right delta rebuilds the time range', () => {
+ const { ref, props } = mountAxis();
+ const big = ref.current.state.dragSentinelChangeNumber * 2 + 50;
+ act(() => ref.current.handleDrag(evt({ type: 'mousemove' }), { deltaX: big, x: 100 + big }));
+ expect(props.updatePositioning).toHaveBeenCalled();
+ });
+
+ it('handleDrag with a large left delta rebuilds the time range', () => {
+ const { ref, props } = mountAxis();
+ const big = ref.current.state.dragSentinelChangeNumber * 2 + 50;
+ act(() => ref.current.handleDrag(evt({ type: 'mousemove' }), { deltaX: -big, x: 100 - big }));
+ expect(props.updatePositioning).toHaveBeenCalled();
+ });
+
+ it('handleDrag with a small left delta uses simple positioning', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.handleDrag(evt({ type: 'mousemove' }), { deltaX: -5, x: 95 }));
+ expect(props.updatePositioningOnSimpleDrag).toHaveBeenCalled();
+ });
+
+ it('handleStopDrag treats a moved drag as a position update', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.handleStopDrag(evt(), { x: 9999 }, false));
+ expect(props.updatePositioningOnAxisStopDrag).toHaveBeenCalled();
+ });
+
+ it('handleStopDrag treats a non-moved drag using existing hover time', () => {
+ const { ref, props } = mountAxis();
+ const { midPoint } = ref.current.state;
+ act(() => ref.current.handleStopDrag(evt(), { x: midPoint }, false));
+ expect(props.updatePositioningOnAxisStopDrag).toHaveBeenCalled();
+ });
+
+ it('handleStopDrag on a month scale calculates hover time from the front date', () => {
+ const { ref, props } = mountAxis({ timeScale: 'month' });
+ act(() => ref.current.handleStopDrag(evt(), { x: 9999 }, true));
+ expect(props.updatePositioningOnAxisStopDrag).toHaveBeenCalled();
+ });
+});
+
+describe('TimelineAxis coverage line + granule ranges', () => {
+ it('getMatchingCoverageLineDimensions computes visibility and offsets', () => {
+ const { ref } = mountAxis({
+ frontDate: '2023-05-01T00:00:00.000Z',
+ backDate: '2023-05-31T00:00:00.000Z',
+ position: 0,
+ transformX: 0,
+ matchingTimelineCoverage: [
+ { startDate: '2023-06-01T00:00:00Z', endDate: '2023-06-10T00:00:00Z' },
+ { startDate: '2023-04-01T00:00:00Z', endDate: '2023-05-15T00:00:00Z' },
+ { startDate: '2023-05-10T00:00:00Z', endDate: '2023-05-20T00:00:00Z' },
+ { startDate: '2023-05-10T00:00:00Z', endDate: '2023-07-01T00:00:00Z' },
+ ],
+ });
+ const dims = ref.current.getMatchingCoverageLineDimensions();
+ expect(dims[0].visible).toBe(false);
+ expect(dims[1].leftOffset).toBe(0);
+ expect(dims[2].visible).toBe(true);
+ expect(dims[3].width).toBeGreaterThan(0);
+ });
+
+ it('addTimeRanges spins up a CMR worker for CMR-availability layers', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.addTimeRanges(
+ { id: 'L1', cmrAvailability: true, startDate: '2020-01-01' },
+ { crs: 'EPSG:4326' },
+ null,
+ ));
+ expect(global.Worker).toHaveBeenCalled();
+ act(() => createdWorkers[0].onmessage({ data: [{ startDate: '2020', endDate: '2021' }] }));
+ expect(props.addGranuleDateRanges).toHaveBeenCalled();
+ });
+
+ it('addTimeRanges spins up a DescribeDomains worker and parses domains', () => {
+ const { ref, props } = mountAxis();
+ act(() => ref.current.addTimeRanges(
+ {
+ id: 'L2', dataAvailability: 'dd', startDate: '2020-01-01', endDate: '2021-01-01',
+ },
+ { crs: 'EPSG:4326' },
+ ['2020-01-01', '2021-01-01'],
+ ));
+ expect(global.Worker).toHaveBeenCalled();
+ act(() => createdWorkers[0].onmessage({ data: [{ startDate: '2020', endDate: '2021' }] }));
+ expect(props.addGranuleDateRanges).toHaveBeenCalled();
+ act(() => createdWorkers[0].onmessage({ data: '<xml/>' }));
+ expect(createdWorkers[0].postMessage).toHaveBeenCalled();
+ });
+});
+
+describe('TimelineAxis componentDidUpdate', () => {
+ it('updates the scale when the timescale changes', () => {
+ const { ref, rerender } = mountAxis();
+ act(() => rerender({ timeScale: 'month' }));
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('updates the scale when the timescale changes during a wheel zoom', () => {
+ const { ref, rerender } = mountAxis();
+ act(() => { ref.current.setState({ wheelZoom: true }); });
+ act(() => rerender({ timeScale: 'hour' }));
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('updates the scale when the axis width changes', () => {
+ const { props, rerender } = mountAxis();
+ props.updatePositioning.mockClear();
+ act(() => rerender({ axisWidth: 1200 }));
+ expect(props.updatePositioning).toHaveBeenCalled();
+ });
+
+ it('updates the scale when finishing an animate-to-event', () => {
+ const { props, rerender } = mountAxis({ isAnimatingToEvent: true });
+ props.updatePositioning.mockClear();
+ act(() => rerender({ isAnimatingToEvent: false }));
+ expect(props.updatePositioning).toHaveBeenCalled();
+ });
+
+ it('updates the date when the end date limit changes', () => {
+ const { props, rerender } = mountAxis();
+ act(() => rerender({ timelineEndDateLimit: '2031-01-01T00:00:00.000Z' }));
+ expect(props.onDateChange).toHaveBeenCalled();
+ });
+
+ it('handles the A/B dragger focus switch in compare mode', () => {
+ const { ref, rerender } = mountAxis({ isCompareModeActive: true, draggerSelected: 'selected' });
+ act(() => rerender({ isCompareModeActive: true, draggerSelected: 'selectedB' }));
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('handles animation turning on', () => {
+ const { ref, rerender } = mountAxis();
+ act(() => rerender({ isAnimationPlaying: true }));
+ expect(ref.current.state.currentTimeRange.length).toBeGreaterThan(0);
+ });
+
+ it('adds time ranges when the active layers change', () => {
+ const { rerender } = mountAxis();
+ act(() => rerender({
+ activeLayers: [{
+ id: 'L1', cmrAvailability: true, startDate: '2020-01-01', visible: true,
+ }],
+ }));
+ expect(global.Worker).toHaveBeenCalled();
+ });
});
diff --git a/web/js/components/timeline/timeline-controls/animation-button.test.js b/web/js/components/timeline/timeline-controls/animation-button.test.js
index bca8fdd4e..d5ddfc421 100644
--- a/web/js/components/timeline/timeline-controls/animation-button.test.js
+++ b/web/js/components/timeline/timeline-controls/animation-button.test.js
@@ -1,3 +1,336 @@
-test('anitmation-button component 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('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, className, size }) => (
+ <svg data-testid="font-awesome-icon" data-icon={icon} className={className} data-size={size} />
+ ),
+}));
+
+jest.mock('reactstrap', () => ({
+ UncontrolledTooltip: ({ children, target, placement }) => (
+ <div data-testid="tooltip" data-target={target} data-placement={placement}>
+ {children}
+ </div>
+ ),
+}));
+
+import AnimationButton from './animation-button';
+
+const defaultProps = {
+ disabled: false,
+ label: 'Set up animation',
+ clickAnimationButton: jest.fn(),
+ breakpoints: { small: 768 },
+ screenWidth: 1024,
+ isKioskModeActive: false,
+ isLandscape: false,
+ isPortrait: false,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ isMobile: false,
+ hasSubdailyLayers: false,
+ isEmbedModeActive: false,
+};
+
+const renderButton = (props = {}) => render(<AnimationButton {...defaultProps} {...props} />);
+
+describe('AnimationButton', () => {
+ beforeEach(() => {
+ defaultProps.clickAnimationButton.mockClear();
+ });
+
+ describe('rendering', () => {
+ it('renders a button element', () => {
+ const { getByRole } = renderButton();
+ expect(getByRole('button')).toBeInTheDocument();
+ });
+
+ it('renders the FontAwesome video icon', () => {
+ const { getByTestId } = renderButton();
+ expect(getByTestId('font-awesome-icon')).toBeInTheDocument();
+ expect(getByTestId('font-awesome-icon').dataset.icon).toBe('video');
+ });
+
+ it('uses provided label as aria-label', () => {
+ const { getByRole } = renderButton({ label: 'Custom Label' });
+ expect(getByRole('button')).toHaveAttribute('aria-label', 'Custom Label');
+ });
+
+ it('falls back to default aria-label when label is not provided', () => {
+ const { getByRole } = renderButton({ label: undefined });
+ expect(getByRole('button')).toHaveAttribute('aria-label', 'Set up animation');
+ });
+
+ it('shows tooltip on desktop (non-mobile)', () => {
+ const { getByTestId } = renderButton({ isMobile: false });
+ expect(getByTestId('tooltip')).toBeInTheDocument();
+ });
+
+ it('does not show tooltip on mobile', () => {
+ const { queryByTestId } = renderButton({
+ isMobile: true,
+ isMobilePhone: true,
+ isPortrait: true,
+ });
+ expect(queryByTestId('tooltip')).not.toBeInTheDocument();
+ });
+
+ it('tooltip targets animate-button id', () => {
+ const { getByTestId } = renderButton({ isMobile: false });
+ expect(getByTestId('tooltip').dataset.target).toBe('animate-button');
+ });
+
+ it('tooltip uses top placement', () => {
+ const { getByTestId } = renderButton({ isMobile: false });
+ expect(getByTestId('tooltip').dataset.placement).toBe('top');
+ });
+
+ it('tooltip displays label text', () => {
+ const { getByTestId } = renderButton({ label: 'My Animation' });
+ expect(getByTestId('tooltip').textContent).toBe('My Animation');
+ });
+ });
+
+ describe('click behavior', () => {
+ it('calls clickAnimationButton when button is clicked', () => {
+ const clickMock = jest.fn();
+ const { getByRole } = renderButton({ clickAnimationButton: clickMock });
+ fireEvent.click(getByRole('button'));
+ expect(clickMock).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe('className — kiosk mode', () => {
+ it('sets d-none when isKioskModeActive is true', () => {
+ const { getByRole } = renderButton({ isKioskModeActive: true });
+ expect(getByRole('button')).toHaveClass('d-none');
+ });
+ });
+
+ describe('className — disabled', () => {
+ it('sets disabled class when disabled is true and kiosk mode is off', () => {
+ const { getByRole } = renderButton({ disabled: true });
+ expect(getByRole('button')).toHaveClass('wv-disabled-button', 'button-action-group', 'animate-button');
+ });
+ });
+
+ describe('className — desktop non-embed', () => {
+ it('uses standard animate-button class on desktop', () => {
+ const { getByRole } = renderButton({ isMobile: false, isEmbedModeActive: false });
+ expect(getByRole('button')).toHaveClass('button-action-group', 'animate-button');
+ expect(getByRole('button')).not.toHaveClass('mobile-animate-button');
+ });
+ });
+
+ describe('className — mobile fallback (embed or mobile)', () => {
+ it('uses mobile-animate-button class when isMobile and no specific breakpoint class', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobileTablet: true,
+ isLandscape: true,
+ hasSubdailyLayers: false,
+ });
+ const btn = getByRole('button');
+ expect(btn).toHaveClass('button-action-group', 'mobile-animate-button');
+ });
+ });
+
+ describe('getButtonClassName — phone portrait', () => {
+ it('returns phone-portrait for isMobilePhone + isPortrait', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: true,
+ isPortrait: true,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-phone-portrait');
+ });
+
+ it('returns phone-portrait-subdaily for isMobilePhone + isPortrait + hasSubdailyLayers', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: true,
+ isPortrait: true,
+ hasSubdailyLayers: true,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-phone-portrait-subdaily');
+ });
+
+ it('returns phone-portrait-embed for isMobilePhone + isPortrait + isEmbedModeActive', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: true,
+ isPortrait: true,
+ isEmbedModeActive: true,
+ });
+ expect(getByRole('button').className).toContain('animate-button-phone-portrait-embed');
+ });
+
+ it('returns phone-portrait for non-tablet narrowWidth + hasSubdailyLayers + screenWidth < 670', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenWidth: 600,
+ hasSubdailyLayers: true,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-phone-portrait-subdaily');
+ });
+
+ it('returns phone-portrait for non-tablet + screenWidth < 575 + no subdaily layers', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenWidth: 500,
+ hasSubdailyLayers: false,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-phone-portrait');
+ });
+
+ it('returns embed for non-tablet + screenWidth < 575 + embed mode', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenWidth: 500,
+ hasSubdailyLayers: false,
+ isEmbedModeActive: true,
+ });
+ expect(getByRole('button').className).toContain('animate-button-phone-portrait-embed');
+ });
+ });
+
+ describe('getButtonClassName — phone landscape', () => {
+ it('returns phone-landscape for isMobilePhone + isLandscape', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: true,
+ isLandscape: true,
+ isPortrait: false,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-phone-landscape');
+ });
+
+ it('returns phone-landscape-subdaily for isMobilePhone + isLandscape + hasSubdailyLayers', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: true,
+ isLandscape: true,
+ isPortrait: false,
+ hasSubdailyLayers: true,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-phone-landscape-subdaily');
+ });
+ });
+
+ describe('getButtonClassName — tablet portrait', () => {
+ it('returns tablet-portrait for isMobileTablet + isPortrait', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobileTablet: true,
+ isPortrait: true,
+ isMobilePhone: false,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-tablet-portrait');
+ });
+
+ it('returns tablet-portrait-subdaily for isMobileTablet + isPortrait + hasSubdailyLayers', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobileTablet: true,
+ isPortrait: true,
+ isMobilePhone: false,
+ hasSubdailyLayers: true,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-tablet-portrait-subdaily');
+ });
+
+ it('returns tablet-portrait-embed for isMobileTablet + isPortrait + isEmbedModeActive', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobileTablet: true,
+ isPortrait: true,
+ isMobilePhone: false,
+ isEmbedModeActive: true,
+ });
+ expect(getByRole('button').className).toContain('animate-button-tablet-portrait-embed');
+ });
+
+ it('returns tablet-portrait when 575 < screenWidth < breakpoints.small for non-phone non-tablet', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenWidth: 650,
+ breakpoints: { small: 768 },
+ hasSubdailyLayers: false,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-tablet-portrait');
+ });
+
+ it('returns tablet-portrait-embed for non-mobile + embed mode (embed forces tablet-portrait)', () => {
+ const { getByRole } = renderButton({
+ isMobile: false,
+ isMobilePhone: false,
+ isMobileTablet: false,
+ screenWidth: 1024,
+ breakpoints: { small: 768 },
+ isEmbedModeActive: true,
+ });
+ expect(getByRole('button').className).toContain('animate-button-tablet-portrait-embed');
+ });
+ });
+
+ describe('getButtonClassName — tablet landscape', () => {
+ it('returns tablet-landscape for isMobileTablet + isLandscape', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobileTablet: true,
+ isLandscape: true,
+ isPortrait: false,
+ isMobilePhone: false,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-tablet-landscape');
+ });
+
+ it('returns tablet-landscape-subdaily for isMobileTablet + isLandscape + hasSubdailyLayers', () => {
+ const { getByRole } = renderButton({
+ isMobile: true,
+ isMobileTablet: true,
+ isLandscape: true,
+ isPortrait: false,
+ isMobilePhone: false,
+ hasSubdailyLayers: true,
+ isEmbedModeActive: false,
+ });
+ expect(getByRole('button').className).toContain('animate-button-tablet-landscape-subdaily');
+ });
+ });
+
+ describe('getButtonClassName — returns undefined (desktop non-embed)', () => {
+ it('does not append a buttonClass suffix for desktop non-embed', () => {
+ const { getByRole } = renderButton({
+ isMobile: false,
+ isEmbedModeActive: false,
+ screenWidth: 1200,
+ breakpoints: { small: 768 },
+ });
+ const btn = getByRole('button');
+ expect(btn).toHaveClass('button-action-group', 'animate-button');
+ expect(btn.className).not.toContain('undefined');
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-controls/axis-timescale-change-controls.test.js b/web/js/components/timeline/timeline-controls/axis-timescale-change-controls.test.js
index c390df8a4..5b7c4a1b2 100644
--- a/web/js/components/timeline/timeline-controls/axis-timescale-change-controls.test.js
+++ b/web/js/components/timeline/timeline-controls/axis-timescale-change-controls.test.js
@@ -1,3 +1,155 @@
-test('axis-timescale-change-controls component 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('./axis-timescale-change-tooltip', () => function MockTooltip({
+ timeScale, toolTipHovered, changeTimeScale, hasSubdailyLayers,
+}) {
+ return (
+ <div
+ data-testid="tooltip"
+ data-timescale={timeScale}
+ data-tooltip-hovered={String(toolTipHovered)}
+ data-has-subdaily={String(hasSubdailyLayers)}
+ >
+ <button type="button" data-testid="change-timescale-btn" onClick={() => changeTimeScale('day')}>
+ change
+ </button>
+ </div>
+ );
+});
+
+jest.mock('../../util/arrow', () => function MockArrow({ direction, onClick, type }) {
+ return (
+ <button
+ type="button"
+ data-testid={`arrow-${direction}`}
+ data-type={type}
+ onClick={onClick}
+ >
+ {direction}
+ </button>
+ );
+});
+
+import AxisTimeScaleChangeControls from './axis-timescale-change-controls';
+
+const defaultProps = {
+ timeScale: 'day',
+ toolTipHovered: false,
+ changeTimeScale: jest.fn(),
+ hasSubdailyLayers: false,
+ decrementTimeScale: jest.fn(),
+ incrementTimeScale: jest.fn(),
+};
+
+const renderControls = (props = {}) => render(
+ <AxisTimeScaleChangeControls {...defaultProps} {...props} />,
+);
+
+describe('AxisTimeScaleChangeControls', () => {
+ beforeEach(() => {
+ defaultProps.changeTimeScale.mockClear();
+ defaultProps.decrementTimeScale.mockClear();
+ defaultProps.incrementTimeScale.mockClear();
+ });
+
+ describe('rendering', () => {
+ it('renders the outer container with correct class', () => {
+ const { container } = renderControls();
+ expect(container.firstChild).toHaveClass('zoom-level-change-arrows');
+ });
+
+ it('renders the tooltip child', () => {
+ const { getByTestId } = renderControls();
+ expect(getByTestId('tooltip')).toBeInTheDocument();
+ });
+
+ it('renders an up arrow', () => {
+ const { getByTestId } = renderControls();
+ expect(getByTestId('arrow-up')).toBeInTheDocument();
+ });
+
+ it('renders a down arrow', () => {
+ const { getByTestId } = renderControls();
+ expect(getByTestId('arrow-down')).toBeInTheDocument();
+ });
+
+ it('up arrow has zoom-level-up type', () => {
+ const { getByTestId } = renderControls();
+ expect(getByTestId('arrow-up').dataset.type).toBe('zoom-level-up');
+ });
+
+ it('down arrow has zoom-level-down type', () => {
+ const { getByTestId } = renderControls();
+ expect(getByTestId('arrow-down').dataset.type).toBe('zoom-level-down');
+ });
+ });
+
+ describe('prop forwarding to tooltip', () => {
+ it('passes timeScale to tooltip', () => {
+ const { getByTestId } = renderControls({ timeScale: 'month' });
+ expect(getByTestId('tooltip').dataset.timescale).toBe('month');
+ });
+
+ it('passes toolTipHovered=true to tooltip', () => {
+ const { getByTestId } = renderControls({ toolTipHovered: true });
+ expect(getByTestId('tooltip').dataset.tooltipHovered).toBe('true');
+ });
+
+ it('passes toolTipHovered=false to tooltip', () => {
+ const { getByTestId } = renderControls({ toolTipHovered: false });
+ expect(getByTestId('tooltip').dataset.tooltipHovered).toBe('false');
+ });
+
+ it('passes hasSubdailyLayers=true to tooltip', () => {
+ const { getByTestId } = renderControls({ hasSubdailyLayers: true });
+ expect(getByTestId('tooltip').dataset.hasSubdaily).toBe('true');
+ });
+
+ it('passes hasSubdailyLayers=false to tooltip', () => {
+ const { getByTestId } = renderControls({ hasSubdailyLayers: false });
+ expect(getByTestId('tooltip').dataset.hasSubdaily).toBe('false');
+ });
+
+ it('passes changeTimeScale through to tooltip and it is callable', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderControls({ changeTimeScale });
+ fireEvent.click(getByTestId('change-timescale-btn'));
+ expect(changeTimeScale).toHaveBeenCalledWith('day');
+ });
+ });
+
+ describe('onClickUp', () => {
+ it('calls decrementTimeScale when up arrow is clicked', () => {
+ const decrementTimeScale = jest.fn();
+ const { getByTestId } = renderControls({ decrementTimeScale });
+ fireEvent.click(getByTestId('arrow-up'));
+ expect(decrementTimeScale).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call incrementTimeScale when up arrow is clicked', () => {
+ const incrementTimeScale = jest.fn();
+ const { getByTestId } = renderControls({ incrementTimeScale });
+ fireEvent.click(getByTestId('arrow-up'));
+ expect(incrementTimeScale).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('onClickDown', () => {
+ it('calls incrementTimeScale when down arrow is clicked', () => {
+ const incrementTimeScale = jest.fn();
+ const { getByTestId } = renderControls({ incrementTimeScale });
+ fireEvent.click(getByTestId('arrow-down'));
+ expect(incrementTimeScale).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call decrementTimeScale when down arrow is clicked', () => {
+ const decrementTimeScale = jest.fn();
+ const { getByTestId } = renderControls({ decrementTimeScale });
+ fireEvent.click(getByTestId('arrow-down'));
+ expect(decrementTimeScale).not.toHaveBeenCalled();
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-controls/axis-timescale-change-tooltip.test.js b/web/js/components/timeline/timeline-controls/axis-timescale-change-tooltip.test.js
index fabb18c5d..d8adaf9a3 100644
--- a/web/js/components/timeline/timeline-controls/axis-timescale-change-tooltip.test.js
+++ b/web/js/components/timeline/timeline-controls/axis-timescale-change-tooltip.test.js
@@ -1,3 +1,156 @@
-test('axis-timescale-change-tooltip component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import AxisTimeScaleChangeTooltip from './axis-timescale-change-tooltip';
+
+const defaultProps = {
+ timeScale: 'day',
+ toolTipHovered: false,
+ changeTimeScale: jest.fn(),
+ hasSubdailyLayers: false,
+};
+
+const renderTooltip = (props = {}) => render(
+ <AxisTimeScaleChangeTooltip {...defaultProps} {...props} />,
+);
+
+describe('AxisTimeScaleChangeTooltip', () => {
+ beforeEach(() => {
+ defaultProps.changeTimeScale.mockClear();
+ });
+
+ describe('rendering', () => {
+ it('renders the outer container with id zoom-btn-container-axis', () => {
+ const { container } = renderTooltip();
+ expect(container.querySelector('#zoom-btn-container-axis')).toBeInTheDocument();
+ });
+
+ it('renders the current zoom span with the timeScale text', () => {
+ const { getByText } = renderTooltip({ timeScale: 'Month' });
+ expect(getByText('Month')).toBeInTheDocument();
+ });
+
+ it('current zoom span has zoom-level-display-text class', () => {
+ const { container } = renderTooltip();
+ expect(container.querySelector('#current-zoom')).toHaveClass('zoom-level-display-text');
+ });
+
+ it('current zoom span includes zoom-{timeScale} class (lowercased)', () => {
+ const { container } = renderTooltip({ timeScale: 'Day' });
+ expect(container.querySelector('#current-zoom')).toHaveClass('zoom-day');
+ });
+
+ it('renders YEAR, MONTH, DAY menu items always', () => {
+ const { getByText } = renderTooltip();
+ expect(getByText('YEAR')).toBeInTheDocument();
+ expect(getByText('MONTH')).toBeInTheDocument();
+ expect(getByText('DAY')).toBeInTheDocument();
+ });
+
+ it('does not render HOUR or MINUTE when hasSubdailyLayers is false', () => {
+ const { queryByText } = renderTooltip({ hasSubdailyLayers: false });
+ expect(queryByText('HOUR')).not.toBeInTheDocument();
+ expect(queryByText('MINUTE')).not.toBeInTheDocument();
+ });
+
+ it('renders HOUR and MINUTE when hasSubdailyLayers is true', () => {
+ const { getByText } = renderTooltip({ hasSubdailyLayers: true });
+ expect(getByText('HOUR')).toBeInTheDocument();
+ expect(getByText('MINUTE')).toBeInTheDocument();
+ });
+ });
+
+ describe('tooltip visibility', () => {
+ it('hides the zoom tooltip when toolTipHovered is false', () => {
+ const { container } = renderTooltip({ toolTipHovered: false });
+ expect(container.querySelector('.wv-zoom-tooltip').style.display).toBe('none');
+ });
+
+ it('shows the zoom tooltip when toolTipHovered is true', () => {
+ const { container } = renderTooltip({ toolTipHovered: true });
+ expect(container.querySelector('.wv-zoom-tooltip').style.display).toBe('block');
+ });
+ });
+
+ describe('changeTimeScale calls', () => {
+ it('calls changeTimeScale with 1 when YEAR is clicked', () => {
+ const changeTimeScale = jest.fn();
+ const { getByText } = renderTooltip({ changeTimeScale });
+ fireEvent.click(getByText('YEAR'));
+ expect(changeTimeScale).toHaveBeenCalledWith(1);
+ });
+
+ it('calls changeTimeScale with 2 when MONTH is clicked', () => {
+ const changeTimeScale = jest.fn();
+ const { getByText } = renderTooltip({ changeTimeScale });
+ fireEvent.click(getByText('MONTH'));
+ expect(changeTimeScale).toHaveBeenCalledWith(2);
+ });
+
+ it('calls changeTimeScale with 3 when DAY is clicked', () => {
+ const changeTimeScale = jest.fn();
+ const { getByText } = renderTooltip({ changeTimeScale });
+ fireEvent.click(getByText('DAY'));
+ expect(changeTimeScale).toHaveBeenCalledWith(3);
+ });
+
+ it('calls changeTimeScale with 4 when HOUR is clicked', () => {
+ const changeTimeScale = jest.fn();
+ const { getByText } = renderTooltip({ changeTimeScale, hasSubdailyLayers: true });
+ fireEvent.click(getByText('HOUR'));
+ expect(changeTimeScale).toHaveBeenCalledWith(4);
+ });
+
+ it('calls changeTimeScale with 5 when MINUTE is clicked', () => {
+ const changeTimeScale = jest.fn();
+ const { getByText } = renderTooltip({ changeTimeScale, hasSubdailyLayers: true });
+ fireEvent.click(getByText('MINUTE'));
+ expect(changeTimeScale).toHaveBeenCalledWith(5);
+ });
+
+ it('calls changeTimeScale exactly once per click', () => {
+ const changeTimeScale = jest.fn();
+ const { getByText } = renderTooltip({ changeTimeScale });
+ fireEvent.click(getByText('YEAR'));
+ expect(changeTimeScale).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe('zoom span classes and ids', () => {
+ it('YEAR span has id zoom-years and class zoom-years', () => {
+ const { container } = renderTooltip();
+ const el = container.querySelector('#zoom-years');
+ expect(el).toBeInTheDocument();
+ expect(el).toHaveClass('zoom-years');
+ });
+
+ it('MONTH span has id zoom-months and class zoom-months', () => {
+ const { container } = renderTooltip();
+ const el = container.querySelector('#zoom-months');
+ expect(el).toBeInTheDocument();
+ expect(el).toHaveClass('zoom-months');
+ });
+
+ it('DAY span has id zoom-days and class zoom-days', () => {
+ const { container } = renderTooltip();
+ const el = container.querySelector('#zoom-days');
+ expect(el).toBeInTheDocument();
+ expect(el).toHaveClass('zoom-days');
+ });
+
+ it('HOUR span has id zoom-hours and class zoom-hours when subdaily', () => {
+ const { container } = renderTooltip({ hasSubdailyLayers: true });
+ const el = container.querySelector('#zoom-hours');
+ expect(el).toBeInTheDocument();
+ expect(el).toHaveClass('zoom-hours');
+ });
+
+ it('MINUTE span has id zoom-minutes and class zoom-minutes when subdaily', () => {
+ const { container } = renderTooltip({ hasSubdailyLayers: true });
+ const el = container.querySelector('#zoom-minutes');
+ expect(el).toBeInTheDocument();
+ expect(el).toHaveClass('zoom-minutes');
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-controls/axis-timescale-change.test.js b/web/js/components/timeline/timeline-controls/axis-timescale-change.test.js
index 9ea4524b0..d998c4f5c 100644
--- a/web/js/components/timeline/timeline-controls/axis-timescale-change.test.js
+++ b/web/js/components/timeline/timeline-controls/axis-timescale-change.test.js
@@ -1,3 +1,242 @@
-test('axis-timescale-change component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('./axis-timescale-change-controls', () => function MockControls({
+ timeScale,
+ hasSubdailyLayers,
+ toolTipHovered,
+ changeTimeScale,
+ incrementTimeScale,
+ decrementTimeScale,
+}) {
+ return (
+ <div
+ data-testid="controls"
+ data-timescale={timeScale}
+ data-has-subdaily={String(hasSubdailyLayers)}
+ data-tooltip-hovered={String(toolTipHovered)}
+ >
+ <button type="button" data-testid="increment-btn" onClick={incrementTimeScale}>increment</button>
+ <button type="button" data-testid="decrement-btn" onClick={decrementTimeScale}>decrement</button>
+ <button type="button" data-testid="change-btn" onClick={() => changeTimeScale(3)}>change</button>
+ </div>
+ );
+});
+
+import AxisTimeScaleChange from './axis-timescale-change';
+
+const defaultProps = {
+ timeScale: 'day',
+ timelineHidden: false,
+ hasSubdailyLayers: false,
+ isDraggerDragging: false,
+ changeTimeScale: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <AxisTimeScaleChange {...defaultProps} {...props} />,
+);
+
+describe('AxisTimeScaleChange', () => {
+ beforeEach(() => {
+ defaultProps.changeTimeScale.mockClear();
+ });
+
+ describe('rendering', () => {
+ it('renders outer container with zoom-level-change class', () => {
+ const { container } = renderComponent();
+ expect(container.firstChild).toHaveClass('zoom-level-change');
+ });
+
+ it('shows controls when timeScale is provided', () => {
+ const { getByTestId } = renderComponent({ timeScale: 'day' });
+ expect(getByTestId('controls')).toBeInTheDocument();
+ });
+
+ it('renders nothing inside hover wrapper when timeScale is falsy', () => {
+ const { queryByTestId } = renderComponent({ timeScale: '' });
+ expect(queryByTestId('controls')).not.toBeInTheDocument();
+ });
+
+ it('is visible when timelineHidden is false', () => {
+ const { container } = renderComponent({ timelineHidden: false });
+ expect(container.firstChild.style.display).toBe('block');
+ });
+
+ it('is hidden when timelineHidden is true', () => {
+ const { container } = renderComponent({ timelineHidden: true });
+ expect(container.firstChild.style.display).toBe('none');
+ });
+ });
+
+ describe('prop forwarding to controls', () => {
+ it('passes timeScale to controls', () => {
+ const { getByTestId } = renderComponent({ timeScale: 'month' });
+ expect(getByTestId('controls').dataset.timescale).toBe('month');
+ });
+
+ it('passes hasSubdailyLayers=true to controls', () => {
+ const { getByTestId } = renderComponent({ hasSubdailyLayers: true });
+ expect(getByTestId('controls').dataset.hasSubdaily).toBe('true');
+ });
+
+ it('passes hasSubdailyLayers=false to controls', () => {
+ const { getByTestId } = renderComponent({ hasSubdailyLayers: false });
+ expect(getByTestId('controls').dataset.hasSubdaily).toBe('false');
+ });
+
+ it('initially passes toolTipHovered=false to controls', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('controls').dataset.tooltipHovered).toBe('false');
+ });
+
+ it('passes changeTimeScale through to controls and it is callable', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ changeTimeScale });
+ fireEvent.click(getByTestId('change-btn'));
+ expect(changeTimeScale).toHaveBeenCalledWith(3);
+ });
+ });
+
+ describe('toolTipHoverOn / toolTipHoverOff', () => {
+ it('sets toolTipHovered to true on mouseenter when not dragging', () => {
+ const { getByTestId, container } = renderComponent({ isDraggerDragging: false });
+ fireEvent.mouseEnter(container.firstChild.firstChild);
+ expect(getByTestId('controls').dataset.tooltipHovered).toBe('true');
+ });
+
+ it('does not set toolTipHovered when isDraggerDragging is true', () => {
+ const { getByTestId, container } = renderComponent({ isDraggerDragging: true });
+ fireEvent.mouseEnter(container.firstChild.firstChild);
+ expect(getByTestId('controls').dataset.tooltipHovered).toBe('false');
+ });
+
+ it('sets toolTipHovered back to false on mouseleave', () => {
+ const { getByTestId, container } = renderComponent({ isDraggerDragging: false });
+ const hoverWrapper = container.firstChild.firstChild;
+ fireEvent.mouseEnter(hoverWrapper);
+ expect(getByTestId('controls').dataset.tooltipHovered).toBe('true');
+ fireEvent.mouseLeave(hoverWrapper);
+ expect(getByTestId('controls').dataset.tooltipHovered).toBe('false');
+ });
+
+ it('mouseleave resets tooltip even if dragging prevented hover-on', () => {
+ const { getByTestId, container } = renderComponent({ isDraggerDragging: true });
+ const hoverWrapper = container.firstChild.firstChild;
+ fireEvent.mouseLeave(hoverWrapper);
+ expect(getByTestId('controls').dataset.tooltipHovered).toBe('false');
+ });
+ });
+
+ describe('disableMapScales', () => {
+ it('sets opacity to 0 on imperial and metric scale elements on hover', () => {
+ const imperial = document.createElement('div');
+ imperial.className = 'wv-map-scale-imperial';
+ imperial.style.opacity = '1';
+ const metric = document.createElement('div');
+ metric.className = 'wv-map-scale-metric';
+ metric.style.opacity = '1';
+ document.body.appendChild(imperial);
+ document.body.appendChild(metric);
+
+ const { container } = renderComponent({ isDraggerDragging: false });
+ fireEvent.mouseEnter(container.firstChild.firstChild);
+
+ expect(imperial.style.opacity).toBe('0');
+ expect(metric.style.opacity).toBe('0');
+
+ document.body.removeChild(imperial);
+ document.body.removeChild(metric);
+ });
+
+ it('restores opacity to 1 on mouse leave', () => {
+ const imperial = document.createElement('div');
+ imperial.className = 'wv-map-scale-imperial';
+ const metric = document.createElement('div');
+ metric.className = 'wv-map-scale-metric';
+ document.body.appendChild(imperial);
+ document.body.appendChild(metric);
+
+ const { container } = renderComponent({ isDraggerDragging: false });
+ const hoverWrapper = container.firstChild.firstChild;
+ fireEvent.mouseEnter(hoverWrapper);
+ fireEvent.mouseLeave(hoverWrapper);
+
+ expect(imperial.style.opacity).toBe('1');
+ expect(metric.style.opacity).toBe('1');
+
+ document.body.removeChild(imperial);
+ document.body.removeChild(metric);
+ });
+ });
+
+ describe('incrementTimeScale', () => {
+ it('calls changeTimeScale with timeScaleNumber+1 when below max (no subdaily)', () => {
+ const changeTimeScale = jest.fn();
+ // day=3, max=3 without subdaily — use month(2) so it can increment
+ const { getByTestId } = renderComponent({ timeScale: 'month', hasSubdailyLayers: false, changeTimeScale });
+ fireEvent.click(getByTestId('increment-btn'));
+ expect(changeTimeScale).toHaveBeenCalledWith(3);
+ });
+
+ it('does not call changeTimeScale when already at max without subdaily (day=3)', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ timeScale: 'day', hasSubdailyLayers: false, changeTimeScale });
+ fireEvent.click(getByTestId('increment-btn'));
+ expect(changeTimeScale).not.toHaveBeenCalled();
+ });
+
+ it('calls changeTimeScale when below subdaily max (hour=4 → minute=5)', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ timeScale: 'hour', hasSubdailyLayers: true, changeTimeScale });
+ fireEvent.click(getByTestId('increment-btn'));
+ expect(changeTimeScale).toHaveBeenCalledWith(5);
+ });
+
+ it('does not call changeTimeScale at subdaily max (minute=5)', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ timeScale: 'minute', hasSubdailyLayers: true, changeTimeScale });
+ fireEvent.click(getByTestId('increment-btn'));
+ expect(changeTimeScale).not.toHaveBeenCalled();
+ });
+
+ it('increments day(3) to hour(4) when hasSubdailyLayers is true', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ timeScale: 'day', hasSubdailyLayers: true, changeTimeScale });
+ fireEvent.click(getByTestId('increment-btn'));
+ expect(changeTimeScale).toHaveBeenCalledWith(4);
+ });
+ });
+
+ describe('decrementTimeScale', () => {
+ it('calls changeTimeScale with timeScaleNumber-1 when above min (day=3 → month=2)', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ timeScale: 'day', changeTimeScale });
+ fireEvent.click(getByTestId('decrement-btn'));
+ expect(changeTimeScale).toHaveBeenCalledWith(2);
+ });
+
+ it('does not call changeTimeScale when already at min (year=1)', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ timeScale: 'year', changeTimeScale });
+ fireEvent.click(getByTestId('decrement-btn'));
+ expect(changeTimeScale).not.toHaveBeenCalled();
+ });
+
+ it('decrements month(2) to year(1)', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ timeScale: 'month', changeTimeScale });
+ fireEvent.click(getByTestId('decrement-btn'));
+ expect(changeTimeScale).toHaveBeenCalledWith(1);
+ });
+
+ it('decrements minute(5) to hour(4)', () => {
+ const changeTimeScale = jest.fn();
+ const { getByTestId } = renderComponent({ timeScale: 'minute', hasSubdailyLayers: true, changeTimeScale });
+ fireEvent.click(getByTestId('decrement-btn'));
+ expect(changeTimeScale).toHaveBeenCalledWith(4);
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-controls/date-change-arrows.test.js b/web/js/components/timeline/timeline-controls/date-change-arrows.test.js
index 2d6be2070..2979dbb70 100644
--- a/web/js/components/timeline/timeline-controls/date-change-arrows.test.js
+++ b/web/js/components/timeline/timeline-controls/date-change-arrows.test.js
@@ -1,3 +1,355 @@
-test('date-change-arrows component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// Passthrough connect so we can supply all props directly.
+// mapStateToProps and mapDispatchToProps are captured for direct testing.
+// DateChangeArrows is loaded via require() in beforeAll (not a static import) so
+// the module initializes after these let declarations are in scope — avoiding TDZ.
+let capturedMapState;
+let capturedMapDispatch;
+jest.mock('react-redux', () => ({
+ connect: (mapState, mapDispatch) => {
+ capturedMapState = mapState;
+ capturedMapDispatch = mapDispatch;
+ return (Component) => Component;
+ },
+}));
+
+jest.mock('@edsc/earthdata-react-icons/horizon-design-system/hds/ui', () => ({
+ ArrowChevronLeft: ({ className, size }) => (
+ <svg data-testid="arrow-left" className={className} data-size={size} />
+ ),
+ ArrowChevronRight: ({ className, size }) => (
+ <svg data-testid="arrow-right" className={className} data-size={size} />
+ ),
+}));
+
+jest.mock('../../util/hover-tooltip', () => function MockHoverTooltip({ labelText, target }) {
+ return <div data-testid={`tooltip-${target}`}>{labelText}</div>;
+});
+
+jest.mock('../../animation-widget/loading-indicator', () => function MockLoadingIndicator({ title }) {
+ return <div data-testid="loading-indicator">{title}</div>;
+});
+
+jest.mock('../../../modules/date/actions', () => ({
+ setArrowDown: jest.fn((dir) => ({ type: 'SET_ARROW_DOWN', dir })),
+ setArrowUp: jest.fn(() => ({ type: 'SET_ARROW_UP' })),
+}));
+
+let DateChangeArrows;
+beforeAll(() => {
+ DateChangeArrows = require('./date-change-arrows').default;
+});
+
+const defaultProps = {
+ handleSelectNowButton: jest.fn(),
+ isMobile: false,
+ leftArrowDisabled: false,
+ leftArrowDown: jest.fn(),
+ nowButtonDisabled: false,
+ rightArrowDisabled: false,
+ rightArrowDown: jest.fn(),
+ arrowDown: null,
+ tilesPreloaded: false,
+ isKioskModeActive: false,
+ isEmbedModeActive: false,
+ setArrowDown: jest.fn(),
+ setArrowUp: jest.fn(),
+};
+
+const renderArrows = (props = {}) => render(
+ <DateChangeArrows {...defaultProps} {...props} />,
+);
+
+describe('DateChangeArrows', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ jest.useFakeTimers();
+ });
+
+ afterEach(() => {
+ jest.useRealTimers();
+ });
+
+ describe('rendering', () => {
+ it('renders the arrow-group container', () => {
+ const { container } = renderArrows();
+ expect(container.firstChild).toHaveClass('arrow-group');
+ });
+
+ it('renders left arrow button', () => {
+ const { getByLabelText } = renderArrows();
+ expect(getByLabelText('Decrement date')).toBeInTheDocument();
+ });
+
+ it('renders right arrow button', () => {
+ const { getByLabelText } = renderArrows();
+ expect(getByLabelText('Increment date')).toBeInTheDocument();
+ });
+
+ it('renders now button', () => {
+ const { getByLabelText } = renderArrows();
+ expect(getByLabelText('Latest available date')).toBeInTheDocument();
+ });
+
+ it('renders tooltips for each button', () => {
+ const { getByTestId } = renderArrows();
+ expect(getByTestId('tooltip-left-arrow-group')).toBeInTheDocument();
+ expect(getByTestId('tooltip-right-arrow-group')).toBeInTheDocument();
+ expect(getByTestId('tooltip-now-button-group')).toBeInTheDocument();
+ });
+
+ it('does not render loading indicator when arrowDown is null', () => {
+ const { queryByTestId } = renderArrows({ arrowDown: null });
+ expect(queryByTestId('loading-indicator')).not.toBeInTheDocument();
+ });
+
+ it('does not render loading indicator when arrowDown is set but tilesPreloaded is true', () => {
+ const { queryByTestId } = renderArrows({ arrowDown: 'left', tilesPreloaded: true });
+ expect(queryByTestId('loading-indicator')).not.toBeInTheDocument();
+ });
+
+ it('renders loading indicator when arrowDown is set and tilesPreloaded is false', () => {
+ const { getByTestId } = renderArrows({ arrowDown: 'left', tilesPreloaded: false });
+ expect(getByTestId('loading-indicator')).toBeInTheDocument();
+ });
+ });
+
+ describe('disabled classes', () => {
+ it('adds button-disabled class to left arrow when leftArrowDisabled', () => {
+ const { getByLabelText } = renderArrows({ leftArrowDisabled: true });
+ expect(getByLabelText('Decrement date')).toHaveClass('button-disabled');
+ });
+
+ it('does not add button-disabled to left arrow when not disabled', () => {
+ const { getByLabelText } = renderArrows({ leftArrowDisabled: false });
+ expect(getByLabelText('Decrement date')).not.toHaveClass('button-disabled');
+ });
+
+ it('adds button-disabled class to right arrow when rightArrowDisabled', () => {
+ const { getByLabelText } = renderArrows({ rightArrowDisabled: true });
+ expect(getByLabelText('Increment date')).toHaveClass('button-disabled');
+ });
+
+ it('does not add button-disabled to right arrow when not disabled', () => {
+ const { getByLabelText } = renderArrows({ rightArrowDisabled: false });
+ expect(getByLabelText('Increment date')).not.toHaveClass('button-disabled');
+ });
+
+ it('adds button-disabled to now button when nowButtonDisabled', () => {
+ const { getByLabelText } = renderArrows({ nowButtonDisabled: true });
+ expect(getByLabelText('Latest available date')).toHaveClass('button-disabled');
+ });
+
+ it('sets aria-disabled=true on left arrow when leftArrowDisabled', () => {
+ const { getByLabelText } = renderArrows({ leftArrowDisabled: true });
+ expect(getByLabelText('Decrement date')).toHaveAttribute('aria-disabled', 'true');
+ });
+ });
+
+ describe('kiosk / embed mode visibility', () => {
+ it('adds d-none to left arrow in kiosk mode when not embed', () => {
+ const { getByLabelText } = renderArrows({
+ isKioskModeActive: true,
+ isEmbedModeActive: false,
+ });
+ expect(getByLabelText('Decrement date')).toHaveClass('d-none');
+ });
+
+ it('does not add d-none to left arrow in kiosk mode when embed is active', () => {
+ const { getByLabelText } = renderArrows({ isKioskModeActive: true, isEmbedModeActive: true });
+ expect(getByLabelText('Decrement date')).not.toHaveClass('d-none');
+ });
+
+ it('does not add d-none to left arrow when kiosk mode is off', () => {
+ const { getByLabelText } = renderArrows({ isKioskModeActive: false });
+ expect(getByLabelText('Decrement date')).not.toHaveClass('d-none');
+ });
+
+ it('adds d-none to now button in kiosk mode (regardless of embed)', () => {
+ const { getByLabelText } = renderArrows({ isKioskModeActive: true, isEmbedModeActive: true });
+ expect(getByLabelText('Latest available date')).toHaveClass('d-none');
+ });
+
+ it('does not add d-none to now button when kiosk mode is off', () => {
+ const { getByLabelText } = renderArrows({ isKioskModeActive: false });
+ expect(getByLabelText('Latest available date')).not.toHaveClass('d-none');
+ });
+ });
+
+ describe('now button', () => {
+ it('calls handleSelectNowButton when now button is clicked', () => {
+ const handleSelectNowButton = jest.fn();
+ const { getByLabelText } = renderArrows({ handleSelectNowButton });
+ fireEvent.click(getByLabelText('Latest available date'));
+ expect(handleSelectNowButton).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe('onArrowDown — immediate callback', () => {
+ it('calls leftArrowDown immediately on left mousedown', () => {
+ const leftArrowDown = jest.fn();
+ const { getByLabelText } = renderArrows({ leftArrowDown });
+ fireEvent.mouseDown(getByLabelText('Decrement date'));
+ expect(leftArrowDown).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls rightArrowDown immediately on right mousedown', () => {
+ const rightArrowDown = jest.fn();
+ const { getByLabelText } = renderArrows({ rightArrowDown });
+ fireEvent.mouseDown(getByLabelText('Increment date'));
+ expect(rightArrowDown).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe('onArrowDown — hold timer (setArrowDown)', () => {
+ it('calls setArrowDown("left") after CLICK_HOLD_DELAY (200ms)', () => {
+ const setArrowDown = jest.fn();
+ const { getByLabelText } = renderArrows({ setArrowDown });
+ fireEvent.mouseDown(getByLabelText('Decrement date'));
+ expect(setArrowDown).not.toHaveBeenCalled();
+ act(() => { jest.advanceTimersByTime(200); });
+ expect(setArrowDown).toHaveBeenCalledWith('left');
+ });
+
+ it('calls setArrowDown("right") after CLICK_HOLD_DELAY (200ms)', () => {
+ const setArrowDown = jest.fn();
+ const { getByLabelText } = renderArrows({ setArrowDown });
+ fireEvent.mouseDown(getByLabelText('Increment date'));
+ act(() => { jest.advanceTimersByTime(200); });
+ expect(setArrowDown).toHaveBeenCalledWith('right');
+ });
+ });
+
+ describe('onArrowUp — quick click (mouseUp before hold timer)', () => {
+ it('does not call setArrowDown when mouseup before 200ms', () => {
+ const setArrowDown = jest.fn();
+ const { getByLabelText } = renderArrows({ setArrowDown });
+ fireEvent.mouseDown(getByLabelText('Decrement date'));
+ fireEvent.mouseUp(getByLabelText('Decrement date'));
+ act(() => { jest.advanceTimersByTime(200); });
+ expect(setArrowDown).not.toHaveBeenCalled();
+ });
+
+ it('does not call setArrowUp when arrowDown is null on mouseup', () => {
+ const setArrowUp = jest.fn();
+ const { getByLabelText } = renderArrows({ arrowDown: null, setArrowUp });
+ fireEvent.mouseDown(getByLabelText('Decrement date'));
+ fireEvent.mouseUp(getByLabelText('Decrement date'));
+ expect(setArrowUp).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('onArrowUp — after hold (arrowDown set)', () => {
+ it('calls setArrowUp on mouseup when arrowDown is set', () => {
+ const setArrowUp = jest.fn();
+ const { getByLabelText } = renderArrows({ arrowDown: 'left', setArrowUp });
+ fireEvent.mouseUp(getByLabelText('Decrement date'));
+ expect(setArrowUp).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls setArrowUp on mouseLeave when arrowDown is set', () => {
+ const setArrowUp = jest.fn();
+ const { getByLabelText } = renderArrows({ arrowDown: 'right', setArrowUp });
+ fireEvent.mouseLeave(getByLabelText('Increment date'));
+ expect(setArrowUp).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe('interval — tilesPreloaded + arrowDown effect', () => {
+ it('repeatedly calls leftArrowDown every 600ms when tilesPreloaded and arrowDown=left', () => {
+ const leftArrowDown = jest.fn();
+ renderArrows({ arrowDown: 'left', tilesPreloaded: true, leftArrowDown });
+ act(() => { jest.advanceTimersByTime(600); });
+ expect(leftArrowDown).toHaveBeenCalledTimes(1);
+ act(() => { jest.advanceTimersByTime(600); });
+ expect(leftArrowDown).toHaveBeenCalledTimes(2);
+ });
+
+ it('repeatedly calls rightArrowDown every 600ms when tilesPreloaded and arrowDown=right', () => {
+ const rightArrowDown = jest.fn();
+ renderArrows({ arrowDown: 'right', tilesPreloaded: true, rightArrowDown });
+ act(() => { jest.advanceTimersByTime(600); });
+ expect(rightArrowDown).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not start interval when tilesPreloaded is false', () => {
+ const leftArrowDown = jest.fn();
+ renderArrows({ arrowDown: 'left', tilesPreloaded: false, leftArrowDown });
+ act(() => { jest.advanceTimersByTime(1200); });
+ // leftArrowDown is only called by the initial mousedown, not by interval
+ expect(leftArrowDown).not.toHaveBeenCalled();
+ });
+
+ it('does not start interval when arrowDown is null', () => {
+ const leftArrowDown = jest.fn();
+ renderArrows({ arrowDown: null, tilesPreloaded: true, leftArrowDown });
+ act(() => { jest.advanceTimersByTime(1200); });
+ expect(leftArrowDown).not.toHaveBeenCalled();
+ });
+
+ it('clears intervals on unmount', () => {
+ const leftArrowDown = jest.fn();
+ const { unmount } = renderArrows({ arrowDown: 'left', tilesPreloaded: true, leftArrowDown });
+ unmount();
+ act(() => { jest.advanceTimersByTime(1200); });
+ // After unmount no further calls beyond what happened before unmount
+ expect(leftArrowDown).toHaveBeenCalledTimes(0);
+ });
+ });
+
+ describe('mapStateToProps', () => {
+ it('maps tilesPreloaded from date.preloaded', () => {
+ const state = {
+ date: {
+ preloaded: true, arrowDown: null,
+ },
+ embed: { isEmbedModeActive: false },
+ ui: { isKioskModeActive: false },
+ };
+ expect(capturedMapState(state).tilesPreloaded).toBe(true);
+ });
+
+ it('maps arrowDown from date.arrowDown', () => {
+ const state = { date: { preloaded: false, arrowDown: 'left' }, embed: { isEmbedModeActive: false }, ui: { isKioskModeActive: false } };
+ expect(capturedMapState(state).arrowDown).toBe('left');
+ });
+
+ it('maps isKioskModeActive from ui.isKioskModeActive', () => {
+ const state = {
+ date: { preloaded: false, arrowDown: null },
+ embed: { isEmbedModeActive: false },
+ ui: { isKioskModeActive: true },
+ };
+ expect(capturedMapState(state).isKioskModeActive).toBe(true);
+ });
+
+ it('maps isEmbedModeActive from embed.isEmbedModeActive', () => {
+ const state = {
+ date: { preloaded: false, arrowDown: null },
+ embed: { isEmbedModeActive: true },
+ ui: { isKioskModeActive: false },
+ };
+ expect(capturedMapState(state).isEmbedModeActive).toBe(true);
+ });
+ });
+
+ describe('mapDispatchToProps', () => {
+ it('setArrowDown dispatches setArrowDownAction with direction', () => {
+ const dispatch = jest.fn();
+ const { setArrowDown } = capturedMapDispatch(dispatch);
+ setArrowDown('right');
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'SET_ARROW_DOWN' }));
+ });
+
+ it('setArrowUp dispatches setArrowUpAction', () => {
+ const dispatch = jest.fn();
+ const { setArrowUp } = capturedMapDispatch(dispatch);
+ setArrowUp();
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'SET_ARROW_UP' }));
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-controls/timescale-interval-change.test.js b/web/js/components/timeline/timeline-controls/timescale-interval-change.test.js
index 45414b4ef..894b2929b 100644
--- a/web/js/components/timeline/timeline-controls/timescale-interval-change.test.js
+++ b/web/js/components/timeline/timeline-controls/timescale-interval-change.test.js
@@ -1,3 +1,445 @@
-test('timescale-interval-change component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+// Capture mapState/mapDispatch from connect; load component via require() in
+// beforeAll so the module initializes after these let declarations are in scope.
+let capturedMapState;
+let capturedMapDispatch;
+jest.mock('react-redux', () => ({
+ connect: (mapState, mapDispatch) => {
+ capturedMapState = mapState;
+ capturedMapDispatch = mapDispatch;
+ return (Component) => Component;
+ },
+}));
+
+jest.mock('../../../modules/date/actions', () => ({
+ toggleCustomModal: jest.fn((isOpen, modalType) => ({ type: 'TOGGLE_CUSTOM_MODAL', isOpen, modalType })),
+ selectInterval: jest.fn((delta, timeScale, customSelected, autoSelected) => ({
+ type: 'SELECT_INTERVAL', delta, timeScale, customSelected, autoSelected,
+ })),
+}));
+
+let TimeScaleIntervalChange;
+beforeAll(() => {
+ TimeScaleIntervalChange = require('./timescale-interval-change').default;
+});
+
+const defaultProps = {
+ interval: 3,
+ customInterval: null,
+ customDelta: 1,
+ customSelected: false,
+ autoSelected: false,
+ hasSubdailyLayers: false,
+ hasTempoProduct: false,
+ isDisabled: false,
+ timeScaleChangeUnit: null,
+ modalType: 'TIMELINE_CUSTOM',
+ selectInterval: jest.fn(),
+ toggleCustomModal: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <TimeScaleIntervalChange {...defaultProps} {...props} />,
+);
+
+describe('TimeScaleIntervalChange', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('rendering', () => {
+ it('renders container with id timeline-interval-btn-container', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#timeline-interval-btn-container')).toBeInTheDocument();
+ });
+
+ it('renders container with interval-btn-container class', () => {
+ const { container } = renderComponent();
+ expect(container.firstChild).toHaveClass('interval-btn-container');
+ });
+
+ it('renders current-interval span', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#current-interval')).toBeInTheDocument();
+ });
+
+ it('displays "1 day" when interval=3', () => {
+ const { getByText } = renderComponent({ interval: 3 });
+ expect(getByText('1 day')).toBeInTheDocument();
+ });
+
+ it('displays "1 year" when interval=1', () => {
+ const { getByText } = renderComponent({ interval: 1 });
+ expect(getByText('1 year')).toBeInTheDocument();
+ });
+
+ it('displays "1 month" when interval=2', () => {
+ const { getByText } = renderComponent({ interval: 2 });
+ expect(getByText('1 month')).toBeInTheDocument();
+ });
+
+ it('displays "AUTO" when autoSelected is true', () => {
+ const { getByText } = renderComponent({ autoSelected: true });
+ expect(getByText('AUTO')).toBeInTheDocument();
+ });
+
+ it('displays customIntervalText in span when customSelected is true', () => {
+ const { container } = renderComponent({
+ customSelected: true,
+ customDelta: 3,
+ customInterval: 1,
+ });
+ expect(container.querySelector('#current-interval').textContent).toBe('3 year');
+ });
+
+ it('adds custom-interval-text class when customSelected', () => {
+ const { container } = renderComponent({ customSelected: true });
+ expect(container.querySelector('#current-interval')).toHaveClass('custom-interval-text');
+ });
+
+ it('does not add custom-interval-text class when not customSelected', () => {
+ const { container } = renderComponent({ customSelected: false });
+ expect(container.querySelector('#current-interval')).not.toHaveClass('custom-interval-text');
+ });
+
+ it('adds disabled class when isDisabled', () => {
+ const { container } = renderComponent({ isDisabled: true });
+ expect(container.querySelector('#current-interval')).toHaveClass('disabled');
+ });
+
+ it('does not render tooltip when isDisabled', () => {
+ const { container } = renderComponent({ isDisabled: true });
+ expect(container.querySelector('.wv-tooltip')).not.toBeInTheDocument();
+ });
+
+ it('renders tooltip when not isDisabled', () => {
+ const { container } = renderComponent({ isDisabled: false });
+ expect(container.querySelector('.wv-tooltip')).toBeInTheDocument();
+ });
+ });
+
+ describe('tooltip visibility', () => {
+ it('tooltip is hidden by default', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.wv-tooltip').style.display).toBe('none');
+ });
+
+ it('tooltip shows on mouseenter', () => {
+ const { container } = renderComponent();
+ fireEvent.mouseEnter(container.firstChild);
+ expect(container.querySelector('.wv-tooltip').style.display).toBe('block');
+ });
+
+ it('tooltip hides on mouseleave', () => {
+ const { container } = renderComponent();
+ fireEvent.mouseEnter(container.firstChild);
+ fireEvent.mouseLeave(container.firstChild);
+ expect(container.querySelector('.wv-tooltip').style.display).toBe('none');
+ });
+
+ it('mouseenter does not update state when isDisabled', () => {
+ const { container } = renderComponent({ isDisabled: true });
+ fireEvent.mouseEnter(container.firstChild);
+ expect(container.querySelector('.wv-tooltip')).not.toBeInTheDocument();
+ });
+
+ it('toggles tooltip visible on first container click', () => {
+ const { container } = renderComponent();
+ fireEvent.click(container.firstChild);
+ expect(container.querySelector('.wv-tooltip').style.display).toBe('block');
+ });
+
+ it('toggles tooltip back to hidden on second container click', () => {
+ const { container } = renderComponent();
+ fireEvent.click(container.firstChild);
+ fireEvent.click(container.firstChild);
+ expect(container.querySelector('.wv-tooltip').style.display).toBe('none');
+ });
+ });
+
+ describe('tooltip content', () => {
+ it('renders Year, Month, Day always', () => {
+ const { getByText } = renderComponent();
+ expect(getByText('Year')).toBeInTheDocument();
+ expect(getByText('Month')).toBeInTheDocument();
+ expect(getByText('Day')).toBeInTheDocument();
+ });
+
+ it('does not render Hour or Minute when hasSubdailyLayers is false', () => {
+ const { queryByText } = renderComponent({ hasSubdailyLayers: false });
+ expect(queryByText('Hour')).not.toBeInTheDocument();
+ expect(queryByText('Minute')).not.toBeInTheDocument();
+ });
+
+ it('renders Hour and Minute when hasSubdailyLayers is true', () => {
+ const { getByText } = renderComponent({ hasSubdailyLayers: true });
+ expect(getByText('Hour')).toBeInTheDocument();
+ expect(getByText('Minute')).toBeInTheDocument();
+ });
+
+ it('does not render Auto when hasTempoProduct is false', () => {
+ const { queryByText } = renderComponent({ hasTempoProduct: false });
+ expect(queryByText('Auto')).not.toBeInTheDocument();
+ });
+
+ it('renders Auto when hasTempoProduct is true', () => {
+ const { getByText } = renderComponent({ hasTempoProduct: true });
+ expect(getByText('Auto')).toBeInTheDocument();
+ });
+
+ it('always renders the static Custom button', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#interval-custom-static')).toBeInTheDocument();
+ });
+
+ it('dynamic custom span is hidden when customIntervalText is "Custom"', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#interval-custom').style.display).toBe('none');
+ });
+ });
+
+ describe('handleClickInterval — selectInterval calls', () => {
+ it('clicking Year calls selectInterval(1, 1, false, false)', () => {
+ const selectInterval = jest.fn();
+ const { getByText } = renderComponent({ selectInterval });
+ fireEvent.click(getByText('Year'));
+ expect(selectInterval).toHaveBeenCalledWith(1, 1, false, false);
+ });
+
+ it('clicking Month calls selectInterval(1, 2, false, false)', () => {
+ const selectInterval = jest.fn();
+ const { getByText } = renderComponent({ selectInterval });
+ fireEvent.click(getByText('Month'));
+ expect(selectInterval).toHaveBeenCalledWith(1, 2, false, false);
+ });
+
+ it('clicking Day calls selectInterval(1, 3, false, false)', () => {
+ const selectInterval = jest.fn();
+ const { getByText } = renderComponent({ selectInterval });
+ fireEvent.click(getByText('Day'));
+ expect(selectInterval).toHaveBeenCalledWith(1, 3, false, false);
+ });
+
+ it('clicking Hour calls selectInterval(1, 4, false, false)', () => {
+ const selectInterval = jest.fn();
+ const { getByText } = renderComponent({ hasSubdailyLayers: true, selectInterval });
+ fireEvent.click(getByText('Hour'));
+ expect(selectInterval).toHaveBeenCalledWith(1, 4, false, false);
+ });
+
+ it('clicking Minute calls selectInterval(1, 5, false, false)', () => {
+ const selectInterval = jest.fn();
+ const { getByText } = renderComponent({ hasSubdailyLayers: true, selectInterval });
+ fireEvent.click(getByText('Minute'));
+ expect(selectInterval).toHaveBeenCalledWith(1, 5, false, false);
+ });
+
+ it('clicking Auto calls selectInterval(1, 5, false, true)', () => {
+ const selectInterval = jest.fn();
+ const { getByText } = renderComponent({ hasTempoProduct: true, selectInterval });
+ fireEvent.click(getByText('Auto'));
+ expect(selectInterval).toHaveBeenCalledWith(1, 5, false, true);
+ });
+
+ it('clicking static Custom calls toggleCustomModal with openModal=true', () => {
+ const toggleCustomModal = jest.fn();
+ const { container } = renderComponent({ toggleCustomModal, modalType: 'TIMELINE_CUSTOM' });
+ fireEvent.click(container.querySelector('#interval-custom-static'));
+ expect(toggleCustomModal).toHaveBeenCalledWith(true, 'TIMELINE_CUSTOM');
+ });
+
+ it('clicking static Custom does not call selectInterval', () => {
+ const selectInterval = jest.fn();
+ const toggleCustomModal = jest.fn();
+ const { container } = renderComponent({ selectInterval, toggleCustomModal });
+ fireEvent.click(container.querySelector('#interval-custom-static'));
+ expect(selectInterval).not.toHaveBeenCalled();
+ });
+
+ it('clicking dynamic custom span calls selectInterval with customDelta and customInterval', () => {
+ const selectInterval = jest.fn();
+ const { container } = renderComponent({ selectInterval, customInterval: 3, customDelta: 2 });
+ fireEvent.click(container.querySelector('#interval-custom'));
+ expect(selectInterval).toHaveBeenCalledWith(2, 3, true, false);
+ });
+
+ it('clicking an interval closes the tooltip', () => {
+ const { container, getByText } = renderComponent();
+ fireEvent.mouseEnter(container.firstChild);
+ expect(container.querySelector('.wv-tooltip').style.display).toBe('block');
+ fireEvent.click(getByText('Year'));
+ expect(container.querySelector('.wv-tooltip').style.display).toBe('none');
+ });
+ });
+
+ describe('componentDidMount — setCustomIntervalText', () => {
+ it('sets customIntervalText when customDelta !== 1 and customInterval is set', () => {
+ // timeScaleChangeUnit must be truthy so componentDidUpdate's reset branch
+ // (condition: defaultDelta || !timeScaleChangeUnit) does not fire after mount.
+ const { container } = renderComponent({ customDelta: 2, customInterval: 3, timeScaleChangeUnit: 'day' });
+ expect(container.querySelector('#interval-custom').style.display).toBe('block');
+ expect(container.querySelector('#interval-custom').textContent).toBe('2 day');
+ });
+
+ it('does not set customIntervalText when customDelta === 1', () => {
+ const { container } = renderComponent({ customDelta: 1, customInterval: 3 });
+ expect(container.querySelector('#interval-custom').style.display).toBe('none');
+ });
+
+ it('does not set customIntervalText when customInterval is null', () => {
+ const { container } = renderComponent({ customDelta: 2, customInterval: null });
+ expect(container.querySelector('#interval-custom').style.display).toBe('none');
+ });
+ });
+
+ describe('componentDidUpdate — resetCustomIntervalText', () => {
+ it('resets customIntervalText when customSelected becomes false and defaultDelta is true', () => {
+ const { container, rerender } = render(
+ <TimeScaleIntervalChange
+ {...defaultProps}
+ customDelta={2}
+ customInterval={3}
+ customSelected
+ timeScaleChangeUnit="day"
+ />,
+ );
+ expect(container.querySelector('#interval-custom').style.display).toBe('block');
+
+ rerender(
+ <TimeScaleIntervalChange
+ {...defaultProps}
+ customDelta={1}
+ customInterval={3}
+ customSelected={false}
+ timeScaleChangeUnit="day"
+ />,
+ );
+ expect(container.querySelector('#interval-custom').style.display).toBe('none');
+ });
+ });
+
+ describe('componentDidUpdate — setCustomIntervalText', () => {
+ it('updates customIntervalText when customDelta changes while customSelected', () => {
+ const { container, rerender } = render(
+ <TimeScaleIntervalChange
+ {...defaultProps}
+ customDelta={2}
+ customInterval={3}
+ customSelected
+ timeScaleChangeUnit="day"
+ />,
+ );
+ expect(container.querySelector('#interval-custom').textContent).toBe('2 day');
+
+ rerender(
+ <TimeScaleIntervalChange
+ {...defaultProps}
+ customDelta={5}
+ customInterval={3}
+ customSelected
+ timeScaleChangeUnit="day"
+ />,
+ );
+ expect(container.querySelector('#interval-custom').textContent).toBe('5 day');
+ });
+
+ it('updates customIntervalText when timeScaleChangeUnit changes while customSelected', () => {
+ const { container, rerender } = render(
+ <TimeScaleIntervalChange
+ {...defaultProps}
+ customDelta={2}
+ customInterval={3}
+ customSelected
+ timeScaleChangeUnit="day"
+ />,
+ );
+ rerender(
+ <TimeScaleIntervalChange
+ {...defaultProps}
+ customDelta={2}
+ customInterval={2}
+ customSelected
+ timeScaleChangeUnit="month"
+ />,
+ );
+ expect(container.querySelector('#interval-custom').textContent).toBe('2 month');
+ });
+
+ it('does not update customIntervalText when neither customDelta nor timeScaleChangeUnit changes', () => {
+ const { container, rerender } = render(
+ <TimeScaleIntervalChange
+ {...defaultProps}
+ customDelta={2}
+ customInterval={3}
+ customSelected
+ timeScaleChangeUnit="day"
+ />,
+ );
+ expect(container.querySelector('#interval-custom').textContent).toBe('2 day');
+
+ rerender(
+ <TimeScaleIntervalChange
+ {...defaultProps}
+ customDelta={2}
+ customInterval={3}
+ customSelected
+ timeScaleChangeUnit="day"
+ hasSubdailyLayers
+ />,
+ );
+ expect(container.querySelector('#interval-custom').textContent).toBe('2 day');
+ });
+ });
+
+ describe('mapStateToProps', () => {
+ const makeState = (overrides = {}) => ({
+ date: {
+ interval: 3,
+ customInterval: null,
+ customDelta: 1,
+ customSelected: false,
+ autoSelected: false,
+ ...overrides,
+ },
+ });
+
+ it('maps interval from date.interval', () => {
+ expect(capturedMapState(makeState({ interval: 2 })).interval).toBe(2);
+ });
+
+ it('maps customInterval from date.customInterval', () => {
+ expect(capturedMapState(makeState({ customInterval: 4 })).customInterval).toBe(4);
+ });
+
+ it('maps customDelta from date.customDelta', () => {
+ expect(capturedMapState(makeState({ customDelta: 7 })).customDelta).toBe(7);
+ });
+
+ it('maps customSelected from date.customSelected', () => {
+ expect(capturedMapState(makeState({ customSelected: true })).customSelected).toBe(true);
+ });
+
+ it('maps autoSelected from date.autoSelected', () => {
+ expect(capturedMapState(makeState({ autoSelected: true })).autoSelected).toBe(true);
+ });
+ });
+
+ describe('mapDispatchToProps', () => {
+ it('toggleCustomModal dispatches toggleCustomModalAction', () => {
+ const dispatch = jest.fn();
+ const { toggleCustomModal } = capturedMapDispatch(dispatch);
+ toggleCustomModal(true, 'TIMELINE_CUSTOM');
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'TOGGLE_CUSTOM_MODAL' }));
+ });
+
+ it('selectInterval dispatches selectIntervalAction', () => {
+ const dispatch = jest.fn();
+ const { selectInterval } = capturedMapDispatch(dispatch);
+ selectInterval(1, 3, false, false);
+ expect(dispatch).toHaveBeenCalledWith(expect.objectContaining({ type: 'SELECT_INTERVAL' }));
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-coverage/coverage-item-container.test.js b/web/js/components/timeline/timeline-coverage/coverage-item-container.test.js
index e0439175a..7c3121551 100644
--- a/web/js/components/timeline/timeline-coverage/coverage-item-container.test.js
+++ b/web/js/components/timeline/timeline-coverage/coverage-item-container.test.js
@@ -1,3 +1,422 @@
-test('coverage-item-container component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('./coverage-line', () => function MockCoverageLine({
+ lineType, id, startDate, endDate, color, options, axisWidth,
+ positionTransformX, layerPeriod, index,
+}) {
+ return (
+ <div
+ data-testid={`coverage-line-${index}`}
+ data-line-type={lineType}
+ data-id={id}
+ data-start={startDate}
+ data-end={String(endDate)}
+ data-color={color}
+ data-axis-width={String(axisWidth)}
+ data-position-transform={String(positionTransformX)}
+ data-layer-period={layerPeriod}
+ data-options-count={String(options.length)}
+ />
+ );
+});
+
+import CoverageItemContainer from './coverage-item-container';
+
+const defaultLayer = {
+ id: 'layer-abc',
+ startDate: '2020-01-01',
+ endDate: '2020-12-31',
+ visible: true,
+ dateRanges: [],
+};
+
+const defaultProps = {
+ axisWidth: 800,
+ backDate: '2020-12-31',
+ frontDate: '2020-01-01',
+ layer: defaultLayer,
+ layerPeriod: 'day',
+ positionTransformX: 50,
+ needDateRangeBuilt: false,
+ getLayerItemStyles: jest.fn(() => ({ lineBackgroundColor: '#ff0000' })),
+ getMatchingCoverageLineDimensions: jest.fn(() => [{ visible: true }]),
+ getMaxEndDate: jest.fn(() => new Date('2020-12-31')),
+ getDatesInDateRange: jest.fn(() => []),
+ getRangeDateEndWithAddedInterval: jest.fn(() => new Date('2020-02-01')),
+};
+
+const renderComponent = (props = {}) => render(
+ <CoverageItemContainer {...defaultProps} {...props} />,
+);
+
+describe('CoverageItemContainer', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ defaultProps.getLayerItemStyles.mockReturnValue({ lineBackgroundColor: '#ff0000' });
+ defaultProps.getMatchingCoverageLineDimensions.mockReturnValue([{ visible: true }]);
+ defaultProps.getMaxEndDate.mockReturnValue(new Date('2020-12-31'));
+ defaultProps.getDatesInDateRange.mockReturnValue([]);
+ defaultProps.getRangeDateEndWithAddedInterval.mockReturnValue(new Date('2020-02-01'));
+ });
+
+ describe('rendering — single line (needDateRangeBuilt=false)', () => {
+ it('renders outer div with layer-coverage-line class', () => {
+ const { container } = renderComponent();
+ expect(container.firstChild).toHaveClass('layer-coverage-line');
+ });
+
+ it('applies axisWidth to container style', () => {
+ const { container } = renderComponent({ axisWidth: 600 });
+ expect(container.firstChild.style.width).toBe('600px');
+ });
+
+ it('renders svg with layer-coverage-line-svg class', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('svg')).toHaveClass('layer-coverage-line-svg');
+ });
+
+ it('sets svg width from axisWidth', () => {
+ const { container } = renderComponent({ axisWidth: 700 });
+ expect(container.querySelector('svg').getAttribute('width')).toBe('700px');
+ });
+
+ it('renders a single CoverageLine with lineType SINGLE', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.lineType).toBe('SINGLE');
+ });
+
+ it('passes layer startDate and endDate to single CoverageLine', () => {
+ const layer = { ...defaultLayer, startDate: '2019-01-01', endDate: '2021-12-31' };
+ const { getByTestId } = renderComponent({ layer });
+ const el = getByTestId('coverage-line-layer-abc-0');
+ expect(el.dataset.start).toBe('2019-01-01');
+ expect(el.dataset.end).toBe('2021-12-31');
+ });
+
+ it('passes lineBackgroundColor from getLayerItemStyles as color', () => {
+ defaultProps.getLayerItemStyles.mockReturnValue({ lineBackgroundColor: '#00ff00' });
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.color).toBe('#00ff00');
+ });
+
+ it('passes axisWidth to single CoverageLine', () => {
+ const { getByTestId } = renderComponent({ axisWidth: 400 });
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.axisWidth).toBe('400');
+ });
+
+ it('passes positionTransformX to single CoverageLine', () => {
+ const { getByTestId } = renderComponent({ positionTransformX: 123 });
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.positionTransform).toBe('123');
+ });
+
+ it('passes layerPeriod to single CoverageLine', () => {
+ const { getByTestId } = renderComponent({ layerPeriod: 'month' });
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.layerPeriod).toBe('month');
+ });
+
+ it('calls getLayerItemStyles with layer visible and id', () => {
+ const getLayerItemStyles = jest.fn(() => ({ lineBackgroundColor: '#abc' }));
+ renderComponent({ getLayerItemStyles });
+ expect(getLayerItemStyles).toHaveBeenCalledWith(true, 'layer-abc');
+ });
+
+ it('calls getMatchingCoverageLineDimensions with layer for single mode', () => {
+ const getMatchingCoverageLineDimensions = jest.fn(() => [{ visible: true }]);
+ renderComponent({ getMatchingCoverageLineDimensions });
+ expect(getMatchingCoverageLineDimensions).toHaveBeenCalledWith(defaultLayer);
+ });
+
+ it('filters out invisible dimensions for single line', () => {
+ defaultProps.getMatchingCoverageLineDimensions.mockReturnValue([
+ { visible: true },
+ { visible: false },
+ { visible: true },
+ ]);
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.optionsCount).toBe('2');
+ });
+ });
+
+ describe('componentDidMount — needDateRangeBuilt=false', () => {
+ it('does not call getDatesInDateRange when needDateRangeBuilt is false', () => {
+ const getDatesInDateRange = jest.fn();
+ renderComponent({ needDateRangeBuilt: false, getDatesInDateRange });
+ expect(getDatesInDateRange).not.toHaveBeenCalled();
+ });
+
+ it('does not call getMaxEndDate when needDateRangeBuilt is false', () => {
+ const getMaxEndDate = jest.fn();
+ renderComponent({ needDateRangeBuilt: false, getMaxEndDate });
+ expect(getMaxEndDate).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('componentDidMount — needDateRangeBuilt=true', () => {
+ const dateInRange = new Date('2020-06-15');
+ const singleRange = [{
+ startDate: '2020-01-01',
+ endDate: '2020-12-31',
+ dateInterval: '1',
+ }];
+
+ it('calls getDatesInDateRange on mount', () => {
+ const getDatesInDateRange = jest.fn(() => []);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ renderComponent({ needDateRangeBuilt: true, layer, getDatesInDateRange });
+ expect(getDatesInDateRange).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls getMaxEndDate with layer and isLastInRange=true for single range', () => {
+ const getMaxEndDate = jest.fn(() => new Date('2020-12-31'));
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ renderComponent({ needDateRangeBuilt: true, layer, getMaxEndDate });
+ expect(getMaxEndDate).toHaveBeenCalledWith(layer, true);
+ });
+
+ it('renders MULTI CoverageLines for dates within range', () => {
+ const getDatesInDateRange = jest.fn(() => [dateInRange]);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { getByTestId } = renderComponent({
+ needDateRangeBuilt: true, layer, getDatesInDateRange,
+ });
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.lineType).toBe('MULTI');
+ });
+
+ it('renders no MULTI CoverageLines when all dates fall outside range', () => {
+ const outOfRange = new Date('2019-01-01');
+ const getDatesInDateRange = jest.fn(() => [outOfRange]);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { container } = renderComponent({
+ needDateRangeBuilt: true, layer, getDatesInDateRange,
+ });
+ expect(container.querySelectorAll('[data-line-type="MULTI"]')).toHaveLength(0);
+ });
+
+ it('renders no CoverageLines when dateRanges is empty', () => {
+ const layer = { ...defaultLayer, dateRanges: [] };
+ const { container } = renderComponent({ needDateRangeBuilt: true, layer });
+ expect(container.querySelectorAll('[data-line-type="MULTI"]')).toHaveLength(0);
+ });
+
+ it('passes isLastInRange=false for non-last and true for last in multi-range', () => {
+ const twoRanges = [
+ { startDate: '2019-01-01', endDate: '2019-12-31', dateInterval: '1' },
+ { startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '1' },
+ ];
+ const getMaxEndDate = jest.fn(() => new Date('2020-12-31'));
+ const layer = { ...defaultLayer, dateRanges: twoRanges };
+ renderComponent({ needDateRangeBuilt: true, layer, getMaxEndDate });
+ expect(getMaxEndDate).toHaveBeenCalledWith(layer, false);
+ expect(getMaxEndDate).toHaveBeenCalledWith(layer, true);
+ });
+
+ it('passes MULTI start date from itemRange.date', () => {
+ const getDatesInDateRange = jest.fn(() => [dateInRange]);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { getByTestId } = renderComponent({
+ needDateRangeBuilt: true, layer, getDatesInDateRange,
+ });
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.start).toBe(dateInRange.toISOString());
+ });
+
+ it('calls getRangeDateEndWithAddedInterval for each range item', () => {
+ const getDatesInDateRange = jest.fn(() => [dateInRange]);
+ const getRangeDateEndWithAddedInterval = jest.fn(() => new Date('2020-07-01'));
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ renderComponent({
+ needDateRangeBuilt: true, layer, getDatesInDateRange, getRangeDateEndWithAddedInterval,
+ });
+ expect(getRangeDateEndWithAddedInterval).toHaveBeenCalledTimes(1);
+ expect(getRangeDateEndWithAddedInterval).toHaveBeenCalledWith(
+ layer,
+ new Date(dateInRange.toISOString()),
+ 'day',
+ 1,
+ undefined,
+ );
+ });
+
+ it('uses dateInterval as numeric interval in getRangeDateEndWithAddedInterval', () => {
+ const rangeWith5Interval = [{ startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '5' }];
+ const getDatesInDateRange = jest.fn(() => [dateInRange]);
+ const getRangeDateEndWithAddedInterval = jest.fn(() => new Date('2020-06-20'));
+ const layer = { ...defaultLayer, dateRanges: rangeWith5Interval };
+ renderComponent({
+ needDateRangeBuilt: true, layer, getDatesInDateRange, getRangeDateEndWithAddedInterval,
+ });
+ expect(getRangeDateEndWithAddedInterval).toHaveBeenCalledWith(
+ layer,
+ expect.any(Date),
+ 'day',
+ 5,
+ undefined,
+ );
+ });
+
+ it('calls getMatchingCoverageLineDimensions per MULTI range item', () => {
+ const getDatesInDateRange = jest.fn(() => [dateInRange]);
+ const getMatchingCoverageLineDimensions = jest.fn(() => [{ visible: true }]);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ renderComponent({
+ needDateRangeBuilt: true,
+ layer,
+ getDatesInDateRange,
+ getMatchingCoverageLineDimensions,
+ });
+ // once for the single MULTI item
+ expect(getMatchingCoverageLineDimensions).toHaveBeenCalledWith(
+ layer,
+ expect.any(Date),
+ expect.any(Date),
+ );
+ });
+
+ it('filters invisible dimensions for MULTI range items', () => {
+ const getDatesInDateRange = jest.fn(() => [dateInRange]);
+ const getMatchingCoverageLineDimensions = jest.fn(() => [
+ { visible: true },
+ { visible: false },
+ ]);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { getByTestId } = renderComponent({
+ needDateRangeBuilt: true, layer, getDatesInDateRange, getMatchingCoverageLineDimensions,
+ });
+ expect(getByTestId('coverage-line-layer-abc-0').dataset.optionsCount).toBe('1');
+ });
+
+ it('deduplicates dates from overlapping ranges via object key overwrite', () => {
+ const duplicateDate = new Date('2020-06-15');
+ const twoRanges = [
+ { startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '1' },
+ { startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '2' },
+ ];
+ // both ranges return the same date → key overwritten → only 1 entry
+ const getDatesInDateRange = jest.fn(() => [duplicateDate]);
+ const layer = { ...defaultLayer, dateRanges: twoRanges };
+ const { container } = renderComponent({
+ needDateRangeBuilt: true, layer, getDatesInDateRange,
+ });
+ expect(container.querySelectorAll('[data-line-type="MULTI"]')).toHaveLength(1);
+ });
+ });
+
+ describe('componentDidUpdate', () => {
+ const dateInRange = new Date('2020-06-15');
+ const singleRange = [{
+ startDate: '2020-01-01',
+ endDate: '2020-12-31',
+ dateInterval: '1',
+ }];
+
+ it('rebuilds date ranges when frontDate changes', () => {
+ const getDatesInDateRange = jest.fn(() => []);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { rerender } = renderComponent({
+ needDateRangeBuilt: true,
+ layer,
+ getDatesInDateRange,
+ });
+ const callsBefore = getDatesInDateRange.mock.calls.length;
+
+ rerender(
+ <CoverageItemContainer
+ {...defaultProps}
+ needDateRangeBuilt
+ layer={layer}
+ getDatesInDateRange={getDatesInDateRange}
+ frontDate="2020-03-01"
+ />,
+ );
+ expect(getDatesInDateRange.mock.calls.length).toBeGreaterThan(callsBefore);
+ });
+
+ it('rebuilds date ranges when backDate changes', () => {
+ const getDatesInDateRange = jest.fn(() => []);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { rerender } = renderComponent({
+ needDateRangeBuilt: true,
+ layer,
+ getDatesInDateRange,
+ });
+ const callsBefore = getDatesInDateRange.mock.calls.length;
+
+ rerender(
+ <CoverageItemContainer
+ {...defaultProps}
+ needDateRangeBuilt
+ layer={layer}
+ getDatesInDateRange={getDatesInDateRange}
+ backDate="2020-09-01"
+ />,
+ );
+ expect(getDatesInDateRange.mock.calls.length).toBeGreaterThan(callsBefore);
+ });
+
+ it('does not rebuild when neither frontDate nor backDate changes', () => {
+ const getDatesInDateRange = jest.fn(() => []);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { rerender } = renderComponent({
+ needDateRangeBuilt: true,
+ layer,
+ getDatesInDateRange,
+ });
+ const callsBefore = getDatesInDateRange.mock.calls.length;
+
+ rerender(
+ <CoverageItemContainer
+ {...defaultProps}
+ needDateRangeBuilt
+ layer={layer}
+ getDatesInDateRange={getDatesInDateRange}
+ layerPeriod="month"
+ />,
+ );
+ expect(getDatesInDateRange.mock.calls.length).toBe(callsBefore);
+ });
+
+ it('does not rebuild when date changes but needDateRangeBuilt is false', () => {
+ const getDatesInDateRange = jest.fn(() => []);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { rerender } = renderComponent({
+ needDateRangeBuilt: false,
+ layer,
+ getDatesInDateRange,
+ });
+
+ rerender(
+ <CoverageItemContainer
+ {...defaultProps}
+ needDateRangeBuilt={false}
+ layer={layer}
+ getDatesInDateRange={getDatesInDateRange}
+ frontDate="2020-03-01"
+ />,
+ );
+ expect(getDatesInDateRange).not.toHaveBeenCalled();
+ });
+
+ it('reflects updated layerDateRanges in render after frontDate change', () => {
+ const getDatesInDateRange = jest.fn(() => []);
+ const layer = { ...defaultLayer, dateRanges: singleRange };
+ const { rerender, container } = renderComponent({
+ needDateRangeBuilt: true, layer, getDatesInDateRange,
+ });
+ expect(container.querySelectorAll('[data-line-type="MULTI"]')).toHaveLength(0);
+
+ getDatesInDateRange.mockReturnValue([dateInRange]);
+ rerender(
+ <CoverageItemContainer
+ {...defaultProps}
+ needDateRangeBuilt
+ layer={layer}
+ getDatesInDateRange={getDatesInDateRange}
+ frontDate="2020-03-01"
+ />,
+ );
+ expect(container.querySelectorAll('[data-line-type="MULTI"]')).toHaveLength(1);
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-coverage/coverage-item-list.test.js b/web/js/components/timeline/timeline-coverage/coverage-item-list.test.js
index 9b5a88f2d..18fe4ca51 100644
--- a/web/js/components/timeline/timeline-coverage/coverage-item-list.test.js
+++ b/web/js/components/timeline/timeline-coverage/coverage-item-list.test.js
@@ -1,3 +1,686 @@
-test('coverage-item-list component 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('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon }) => <svg data-testid={`icon-${icon}`} />,
+}));
+
+jest.mock('../../util/monospace-date', () => function MockMonospaceDate({ date }) {
+ return <span data-testid="monospace-date">{date}</span>;
+});
+
+jest.mock('../../../modules/date/util', () => ({
+ formatDisplayDate: jest.fn((date) => `FMT:${date.toISOString().slice(0, 10)}`),
+}));
+
+jest.mock('../../../modules/layers/util', () => ({
+ datesInDateRanges: jest.fn(() => []),
+}));
+
+jest.mock('../../../util/util', () => ({
+ events: { on: jest.fn(), off: jest.fn() },
+ getUTCNumbers: jest.fn((date, prefix) => ({
+ [`${prefix}Year`]: date.getUTCFullYear(),
+ [`${prefix}Month`]: date.getUTCMonth(),
+ [`${prefix}Day`]: date.getUTCDate(),
+ [`${prefix}Hour`]: date.getUTCHours(),
+ [`${prefix}Minute`]: date.getUTCMinutes(),
+ })),
+ getTimezoneOffsetDate: jest.fn((date) => date),
+ encodeId: jest.fn((id) => id),
+}));
+
+// Capture the last set of props passed to CoverageItemContainer.
+// Assignment happens during React render (not at mock-factory time), so
+// `let` here is TDZ-safe — the variable is initialized before any render runs.
+let capturedContainerProps = null;
+jest.mock('./coverage-item-container', () => function MockCIC(props) {
+ capturedContainerProps = props;
+ return (
+ <div
+ data-testid="coverage-item-container"
+ data-layer-id={props.layer.id}
+ data-need-date-range={String(props.needDateRangeBuilt)}
+ data-layer-period={props.layerPeriod}
+ data-axis-width={String(props.axisWidth)}
+ data-position-transform={String(props.positionTransformX)}
+ />
+ );
+});
+
+import util from '../../../util/util';
+import { datesInDateRanges } from '../../../modules/layers/util';
+import CoverageItemList from './coverage-item-list';
+
+const appNow = new Date('2021-01-01T00:00:00Z');
+
+const defaultLayer = {
+ id: 'layer-test',
+ title: 'Test Layer',
+ subtitle: 'Sub',
+ startDate: '2020-01-01',
+ endDate: '2020-12-31',
+ visible: true,
+ ongoing: false,
+ period: 'daily',
+ dateRanges: [{ startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '1' }],
+};
+
+const defaultProps = {
+ activeLayers: [defaultLayer],
+ appNow,
+ axisWidth: 800,
+ backDate: '2020-12-31',
+ frontDate: '2020-01-01',
+ getMatchingCoverageLineDimensions: jest.fn(() => []),
+ positionTransformX: 50,
+ timeScale: 'day',
+};
+
+const renderComponent = (props = {}) => render(
+ <CoverageItemList {...defaultProps} {...props} />,
+);
+
+describe('CoverageItemList', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ capturedContainerProps = null;
+ });
+
+ // ── Static methods ────────────────────────────────────────────────────────
+
+ describe('getFormattedTimePeriod', () => {
+ it('maps "daily" → "day"', () => {
+ expect(CoverageItemList.getFormattedTimePeriod('daily')).toBe('day');
+ });
+
+ it('maps "monthly" → "monthly"', () => {
+ expect(CoverageItemList.getFormattedTimePeriod('monthly')).toBe('monthly');
+ });
+
+ it('maps "yearly" → "year"', () => {
+ expect(CoverageItemList.getFormattedTimePeriod('yearly')).toBe('year');
+ });
+
+ it('maps anything else → "minute"', () => {
+ expect(CoverageItemList.getFormattedTimePeriod('subdaily')).toBe('minute');
+ expect(CoverageItemList.getFormattedTimePeriod(undefined)).toBe('minute');
+ });
+ });
+
+ // ── Rendering ─────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders outer container with layer-coverage-layer-list class', () => {
+ const { container } = renderComponent();
+ expect(container.firstChild).toHaveClass('layer-coverage-layer-list');
+ });
+
+ it('renders empty message when activeLayers is empty', () => {
+ const { getByTestId } = renderComponent({ activeLayers: [] });
+ expect(getByTestId('icon-exclamation-triangle')).toBeInTheDocument();
+ });
+
+ it('renders one layer item per active layer', () => {
+ const layers = [
+ { ...defaultLayer, id: 'layer-1' },
+ { ...defaultLayer, id: 'layer-2' },
+ ];
+ const { getAllByTestId } = renderComponent({ activeLayers: layers });
+ expect(getAllByTestId('coverage-item-container')).toHaveLength(2);
+ });
+
+ it('returns null (no container) for a layer without dateRanges and startDate', () => {
+ const layerWithNothing = { ...defaultLayer, dateRanges: undefined, startDate: undefined };
+ const { queryByTestId } = renderComponent({ activeLayers: [layerWithNothing] });
+ expect(queryByTestId('coverage-item-container')).not.toBeInTheDocument();
+ });
+
+ it('renders a layer that has startDate but no dateRanges', () => {
+ const layer = { ...defaultLayer, dateRanges: undefined, startDate: '2020-01-01' };
+ const { getByTestId } = renderComponent({ activeLayers: [layer] });
+ expect(getByTestId('coverage-item-container')).toBeInTheDocument();
+ });
+
+ it('passes axisWidth to CoverageItemContainer', () => {
+ const { getByTestId } = renderComponent({ axisWidth: 640 });
+ expect(getByTestId('coverage-item-container').dataset.axisWidth).toBe('640');
+ });
+
+ it('passes positionTransformX to CoverageItemContainer', () => {
+ const { getByTestId } = renderComponent({ positionTransformX: 123 });
+ expect(getByTestId('coverage-item-container').dataset.positionTransform).toBe('123');
+ });
+
+ it('appends "s" to layerPeriod before passing to CoverageItemContainer', () => {
+ // period='daily' → getFormattedTimePeriod → 'day' → 'days'
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('coverage-item-container').dataset.layerPeriod).toBe('days');
+ });
+
+ it('applies visible layer background style', () => {
+ const { container } = renderComponent({ activeLayers: [{ ...defaultLayer, visible: true }] });
+ expect(container.querySelector('.layer-coverage-layer-list-item').style.background)
+ .toBe('rgb(204, 204, 204)');
+ });
+
+ it('applies invisible layer background style', () => {
+ const layer = { ...defaultLayer, visible: false };
+ const { container } = renderComponent({ activeLayers: [layer] });
+ expect(container.querySelector('.layer-coverage-layer-list-item').style.background)
+ .toBe('rgb(79, 79, 79)');
+ });
+ });
+
+ // ── needDateRangeBuilt logic ──────────────────────────────────────────────
+
+ describe('needDateRangeBuilt', () => {
+ it('is false when period=daily, timeScale=day, interval=1 (equal zoom, interval not >1)', () => {
+ const { getByTestId } = renderComponent({
+ timeScale: 'day',
+ activeLayers: [{
+ ...defaultLayer,
+ period: 'daily',
+ dateRanges: [{ startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '1' }],
+ }],
+ });
+ expect(getByTestId('coverage-item-container').dataset.needDateRange).toBe('false');
+ });
+
+ it('is true when period=daily, timeScale=day, interval=2 (equal zoom, interval >1)', () => {
+ const { getByTestId } = renderComponent({
+ timeScale: 'day',
+ activeLayers: [{
+ ...defaultLayer,
+ period: 'daily',
+ dateRanges: [{ startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '2' }],
+ }],
+ });
+ expect(getByTestId('coverage-item-container').dataset.needDateRange).toBe('true');
+ });
+
+ it('is true when layer period is coarser than zoom level (year < day)', () => {
+ const { getByTestId } = renderComponent({
+ timeScale: 'day',
+ activeLayers: [{
+ ...defaultLayer,
+ period: 'yearly',
+ dateRanges: [{ startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '1' }],
+ }],
+ });
+ expect(getByTestId('coverage-item-container').dataset.needDateRange).toBe('true');
+ });
+
+ it('is false for an id in the ignored-layer list', () => {
+ const { getByTestId } = renderComponent({
+ activeLayers: [{
+ ...defaultLayer,
+ id: 'GRACE_Tellus_Liquid_Water_Equivalent_Thickness_Mascon_CRI',
+ dateRanges: [{ startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '2' }],
+ }],
+ });
+ expect(getByTestId('coverage-item-container').dataset.needDateRange).toBe('false');
+ });
+
+ it('is false when dateRanges is falsy', () => {
+ const { getByTestId } = renderComponent({
+ activeLayers: [{
+ ...defaultLayer,
+ dateRanges: undefined,
+ startDate: '2020-01-01',
+ }],
+ });
+ expect(getByTestId('coverage-item-container').dataset.needDateRange).toBe('false');
+ });
+ });
+
+ // ── Header DOM element ────────────────────────────────────────────────────
+
+ describe('layer header', () => {
+ it('renders layer title', () => {
+ const { getByText } = renderComponent({ activeLayers: [{ ...defaultLayer, title: 'My Layer' }] });
+ expect(getByText('My Layer')).toBeInTheDocument();
+ });
+
+ it('renders layer subtitle', () => {
+ const { getByText } = renderComponent({ activeLayers: [{ ...defaultLayer, subtitle: 'v2' }] });
+ expect(getByText('v2')).toBeInTheDocument();
+ });
+
+ it('shows formatted startDate from formatDisplayDate', () => {
+ const { getAllByTestId } = renderComponent();
+ const dates = getAllByTestId('monospace-date').map((el) => el.textContent);
+ expect(dates.some((d) => d.startsWith('FMT:'))).toBe(true);
+ });
+
+ it('shows " Start " placeholder when layer has no startDate', () => {
+ const { getAllByTestId } = renderComponent({
+ activeLayers: [{ ...defaultLayer, startDate: undefined }],
+ });
+ expect(getAllByTestId('monospace-date')[0].textContent).toBe(' Start ');
+ });
+
+ it('shows " Present " placeholder when layer has no endDate', () => {
+ const { getAllByTestId } = renderComponent({
+ activeLayers: [{ ...defaultLayer, endDate: undefined }],
+ });
+ const texts = getAllByTestId('monospace-date').map((el) => el.textContent);
+ expect(texts).toContain(' Present ');
+ });
+
+ it('date range container width is 205px when any layer is not ongoing', () => {
+ // inactiveLayers = some(!ongoing) → at least one layer with ongoing=false
+ const { container } = renderComponent({
+ activeLayers: [{ ...defaultLayer, ongoing: false }],
+ });
+ const dateRangeEl = container.querySelector('.layer-coverage-item-date-range');
+ expect(dateRangeEl.style.width).toBe('205px');
+ });
+
+ it('date range container width is 175px when all ongoing and no endDate', () => {
+ const layer = { ...defaultLayer, ongoing: true, endDate: undefined };
+ const { container } = renderComponent({ activeLayers: [layer] });
+ const dateRangeEl = container.querySelector('.layer-coverage-item-date-range');
+ expect(dateRangeEl.style.width).toBe('175px');
+ });
+ });
+
+ // ── componentDidMount / componentWillUnmount ──────────────────────────────
+
+ describe('lifecycle', () => {
+ it('registers SIDEBAR_LAYER_HOVER callback on mount', () => {
+ renderComponent();
+ expect(util.events.on).toHaveBeenCalledWith('sidebar:layer-hover', expect.any(Function));
+ });
+
+ it('unregisters SIDEBAR_LAYER_HOVER callback on unmount', () => {
+ const { unmount } = renderComponent();
+ unmount();
+ expect(util.events.off).toHaveBeenCalledWith('sidebar:layer-hover', expect.any(Function));
+ });
+ });
+
+ // ── layerHoverCallback ────────────────────────────────────────────────────
+
+ describe('layerHoverCallback', () => {
+ const getHoverCallback = () => util.events.on.mock.calls[0][1];
+
+ it('hovering a matching layer id sets lighter background', () => {
+ const { container } = renderComponent();
+ act(() => { getHoverCallback()('layer-test', true); });
+ expect(container.querySelector('.layer-coverage-layer-list-item').style.background)
+ .toBe('rgb(230, 230, 230)');
+ });
+
+ it('hovering a matching layer adds an outline', () => {
+ const { container } = renderComponent();
+ act(() => { getHoverCallback()('layer-test', true); });
+ expect(container.querySelector('.layer-coverage-layer-list-item').style.outline)
+ .toBe('1px solid rgb(204, 204, 204)');
+ });
+
+ it('deactivating hover (active=false) restores standard background', () => {
+ const { container } = renderComponent();
+ act(() => { getHoverCallback()('layer-test', true); });
+ act(() => { getHoverCallback()('layer-test', false); });
+ expect(container.querySelector('.layer-coverage-layer-list-item').style.background)
+ .toBe('rgb(204, 204, 204)');
+ });
+
+ it('hovering a different id does not lighten this layer', () => {
+ const { container } = renderComponent();
+ act(() => { getHoverCallback()('other-layer', true); });
+ expect(container.querySelector('.layer-coverage-layer-list-item').style.background)
+ .toBe('rgb(204, 204, 204)');
+ });
+
+ it('invisible hovered layer uses gray lighter color', () => {
+ const { container } = renderComponent({
+ activeLayers: [{ ...defaultLayer, visible: false }],
+ });
+ act(() => { getHoverCallback()('layer-test', true); });
+ expect(container.querySelector('.layer-coverage-layer-list-item').style.background)
+ .toBe('rgb(101, 101, 101)');
+ });
+ });
+
+ // ── getLayerItemStyles (via capturedContainerProps) ───────────────────────
+
+ describe('getLayerItemStyles', () => {
+ it('visible=true gives blue lineBackgroundColor', () => {
+ renderComponent();
+ const styles = capturedContainerProps.getLayerItemStyles(true, 'layer-test');
+ expect(styles.lineBackgroundColor).toBe('rgb(0, 69, 123)');
+ });
+
+ it('visible=false gives gray lineBackgroundColor', () => {
+ renderComponent();
+ const styles = capturedContainerProps.getLayerItemStyles(false, 'layer-test');
+ expect(styles.lineBackgroundColor).toBe('rgb(116, 116, 116)');
+ });
+
+ it('non-hovered layer has no outline', () => {
+ renderComponent();
+ const styles = capturedContainerProps.getLayerItemStyles(true, 'layer-test');
+ expect(styles.layerItemOutline).toBe('');
+ });
+ });
+
+ // ── getMaxEndDate ─────────────────────────────────────────────────────────
+
+ describe('getMaxEndDate', () => {
+ const simpleLayer = { endDate: '2020-12-31', futureTime: false, ongoing: false };
+
+ it('returns backDate when backDate <= appNow', () => {
+ // backDate='2020-12-31', appNow='2021-01-01' → backDate < appNow → keep backDate
+ renderComponent({ backDate: '2020-12-31', appNow: new Date('2021-01-01T00:00:00Z') });
+ const result = capturedContainerProps.getMaxEndDate(simpleLayer, false);
+ expect(result).toEqual(new Date('2020-12-31'));
+ });
+
+ it('caps at appNow when backDate > appNow and no futureTime', () => {
+ const testAppNow = new Date('2020-06-01T00:00:00Z');
+ renderComponent({ backDate: '2021-01-01', appNow: testAppNow });
+ const result = capturedContainerProps.getMaxEndDate(simpleLayer, false);
+ expect(result).toEqual(testAppNow);
+ });
+
+ it('keeps backDate when futureTime=true even if backDate > appNow', () => {
+ renderComponent({ backDate: '2022-01-01', appNow: new Date('2020-06-01T00:00:00Z') });
+ const futureLayer = { ...simpleLayer, futureTime: true };
+ const result = capturedContainerProps.getMaxEndDate(futureLayer, false);
+ expect(result).toEqual(new Date('2022-01-01'));
+ });
+
+ it('ongoing + isLastInRange + futureTime + endDateLimit > layerEndDate → caps at layerEndDate', () => {
+ // backDate='2022-01-01' > appNow='2020-06-01', futureTime=true → endDateLimit=2022-01-01
+ // layerEndDate='2020-12-31' < endDateLimit → cap at layerEndDate
+ renderComponent({ backDate: '2022-01-01', appNow: new Date('2020-06-01T00:00:00Z') });
+ const layer = { endDate: '2020-12-31', futureTime: true, ongoing: true };
+ const result = capturedContainerProps.getMaxEndDate(layer, true);
+ expect(result).toEqual(new Date('2020-12-31'));
+ });
+
+ it('ongoing + isLastInRange + futureTime + endDateLimit <= layerEndDate → keeps endDateLimit', () => {
+ // backDate='2020-06-01', appNow='2021-01-01', futureTime=true → endDateLimit=2020-06-01
+ // layerEndDate='2022-01-01' > endDateLimit → keep endDateLimit
+ renderComponent({ backDate: '2020-06-01', appNow: new Date('2021-01-01T00:00:00Z') });
+ const layer = { endDate: '2022-01-01', futureTime: true, ongoing: true };
+ const result = capturedContainerProps.getMaxEndDate(layer, true);
+ expect(result).toEqual(new Date('2020-06-01'));
+ });
+
+ it('ongoing + isLastInRange + no futureTime + endDateLimit > appNow → caps at appNow', () => {
+ const testAppNow = new Date('2020-06-01T00:00:00Z');
+ renderComponent({ backDate: '2022-01-01', appNow: testAppNow });
+ // backDate '2022-01-01' > appNow '2020-06-01' → endDateLimit = appNow = 2020-06-01
+ // ongoing+isLastInRange, no futureTime, endDateLimit (2020-06-01) > appNow (2020-06-01)?
+ // They're equal, so else-if is false. First if already capped endDateLimit=appNow.
+ // The first if already set endDateLimit=appNow; the else-if won't change it.
+ const layer = { endDate: '2020-12-31', futureTime: false, ongoing: true };
+ const result = capturedContainerProps.getMaxEndDate(layer, true);
+ expect(result).toEqual(testAppNow);
+ });
+
+ it('ongoing + isLastInRange + futureTime=true + no endDate → caps at appNow', () => {
+ const testAppNow = new Date('2020-06-01T00:00:00Z');
+ renderComponent({ backDate: '2022-01-01', appNow: testAppNow });
+ // futureTime=true skips the first cap; endDate=undefined makes (futureTime && endDate)
+ // false → else-if fires → caps endDateLimit at appNow
+ const layer = { endDate: undefined, futureTime: true, ongoing: true };
+ const result = capturedContainerProps.getMaxEndDate(layer, true);
+ expect(result).toEqual(testAppNow);
+ });
+
+ it('isLastInRange=false skips ongoing checks', () => {
+ const testAppNow = new Date('2021-01-01T00:00:00Z');
+ renderComponent({ backDate: '2020-12-31', appNow: testAppNow });
+ const layer = { endDate: '2019-01-01', futureTime: false, ongoing: true };
+ const result = capturedContainerProps.getMaxEndDate(layer, false);
+ expect(result).toEqual(new Date('2020-12-31'));
+ });
+ });
+
+ // ── getRangeDateEndWithAddedInterval ──────────────────────────────────────
+
+ describe('getRangeDateEndWithAddedInterval', () => {
+ const rangeDate = new Date('2020-01-01T00:00:00Z');
+
+ it('caps rangeDateEnd at appNow when appNow is before computed end (no futureTime)', () => {
+ const earlyNow = new Date('2020-01-15T00:00:00Z');
+ renderComponent({ appNow: earlyNow });
+ // interval=365 days puts rangeDateEnd far into the future, so appNow caps it
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: false },
+ rangeDate,
+ 'days',
+ 365,
+ undefined,
+ );
+ expect(result).toBe(earlyNow.toISOString());
+ });
+
+ it('caps at endDate when futureTime=true and endDate is before rangeDateEnd', () => {
+ const earlyNow = new Date('2020-01-15T00:00:00Z');
+ const endDate = '2020-01-05';
+ renderComponent({ appNow: earlyNow });
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate, futureTime: true },
+ rangeDate,
+ 'days',
+ 365,
+ undefined,
+ );
+ // appNow (2020-01-15) < rangeDateEnd (2020+365days) → enter if
+ // futureTime=true → new Date('2020-01-05') > rangeDateEnd? No → use new Date(endDate)
+ expect(result).toBe(new Date(endDate).toISOString());
+ });
+
+ it('uses nextDate when nextDate is before computed rangeDateEnd', () => {
+ const futureNow = new Date('2025-01-01T00:00:00Z');
+ renderComponent({ appNow: futureNow });
+ const nextDate = { date: '2020-01-03T00:00:00Z' }; // before rangeDate + 365 days
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: false },
+ rangeDate,
+ 'days',
+ 365,
+ nextDate,
+ );
+ // nextDate (2020-01-03) < rangeDateEnd (2021-01-01) → use nextDate
+ expect(result).toBe(new Date(nextDate.date).toISOString());
+ });
+
+ it('adds years when layerPeriod=years', () => {
+ const futureNow = new Date('2025-01-01T00:00:00Z');
+ renderComponent({ appNow: futureNow });
+ // rangeDate UTC: year=2020, month=0, day=1 + yearAdd=2 → year 2022
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: false },
+ rangeDate,
+ 'years',
+ 2,
+ undefined,
+ );
+ // new Date(2020+2, 0, 1, ...) = Jan 1 2022 local; result contains '2022'
+ expect(result).toContain('2022');
+ });
+
+ it('does not use nextDate when nextDate is after computed rangeDateEnd', () => {
+ const futureNow = new Date('2025-01-01T00:00:00Z');
+ renderComponent({ appNow: futureNow });
+ // nextDate is far in the future — after the computed +365-day end
+ const nextDate = { date: '2022-01-01T00:00:00Z' };
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: false },
+ rangeDate,
+ 'days',
+ 365,
+ nextDate,
+ );
+ // nextDate (2022) > computed end (Dec 2020) → nextDate not used
+ // appNow (2025) >= computed end → no appNow cap → result is computed end
+ expect(result).not.toBe(new Date(nextDate.date).toISOString());
+ expect(result).toContain('2020');
+ });
+
+ it('adds months when layerPeriod=months', () => {
+ const futureNow = new Date('2025-01-01T00:00:00Z');
+ renderComponent({ appNow: futureNow });
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: false },
+ rangeDate,
+ 'months',
+ 3,
+ undefined,
+ );
+ expect(result).toContain('2020');
+ });
+
+ it('adds hours when layerPeriod=hours', () => {
+ const futureNow = new Date('2025-01-01T00:00:00Z');
+ renderComponent({ appNow: futureNow });
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: false },
+ rangeDate,
+ 'hours',
+ 6,
+ undefined,
+ );
+ expect(result).toContain('2020');
+ });
+
+ it('adds minutes when layerPeriod=minutes', () => {
+ const futureNow = new Date('2025-01-01T00:00:00Z');
+ renderComponent({ appNow: futureNow });
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: false },
+ rangeDate,
+ 'minutes',
+ 30,
+ undefined,
+ );
+ expect(result).toContain('2020');
+ });
+
+ it('keeps computed rangeDateEnd when appNow is after it (no cap applied)', () => {
+ const futureNow = new Date('2025-01-01T00:00:00Z');
+ renderComponent({ appNow: futureNow });
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: false },
+ rangeDate,
+ 'days',
+ 1,
+ undefined,
+ );
+ // appNow (2025) >= rangeDateEnd (2020-01-02) → no cap → contains '2020'
+ expect(result).toContain('2020');
+ });
+
+ it('futureTime=true: keeps rangeDateEnd when endDate is greater than rangeDateEnd', () => {
+ const earlyNow = new Date('2020-01-15T00:00:00Z');
+ renderComponent({ appNow: earlyNow });
+ const result = capturedContainerProps.getRangeDateEndWithAddedInterval(
+ { endDate: '2025-01-01', futureTime: true },
+ rangeDate,
+ 'days',
+ 365,
+ undefined,
+ );
+ // appNow (2020-01-15) < computed end → futureTime=true
+ // endDate (2025) > computed end → keep computed end (not capped to endDate)
+ expect(result).not.toContain('2025');
+ expect(result).toContain('2020');
+ });
+ });
+
+ // ── getDatesInDateRange ───────────────────────────────────────────────────
+
+ describe('getDatesInDateRange', () => {
+ const validRange = { startDate: '2020-01-01', endDate: '2020-12-31', dateInterval: '1' };
+ const endDateLimit = new Date('2021-01-01');
+
+ const makeDef = (overrides = {}) => ({
+ id: 'layer-test',
+ period: 'daily',
+ futureTime: false,
+ ongoing: false,
+ ...overrides,
+ });
+
+ it('calls datesInDateRanges when range overlaps axis window', () => {
+ renderComponent();
+ capturedContainerProps.getDatesInDateRange(makeDef(), validRange, endDateLimit, false);
+ expect(datesInDateRanges).toHaveBeenCalledTimes(1);
+ });
+
+ it('returns [] when startDate is after endDateLimit', () => {
+ renderComponent();
+ const futureRange = { ...validRange, startDate: '2022-01-01' };
+ const result = capturedContainerProps
+ .getDatesInDateRange(makeDef(), futureRange, endDateLimit, false);
+ expect(result).toEqual([]);
+ expect(datesInDateRanges).not.toHaveBeenCalled();
+ });
+
+ it('returns [] when rangeEnd is before startDateLimit', () => {
+ renderComponent();
+ // rangeEnd = new Date('2019-01-01'), startDateLimit ≈ 2019-12-31
+ const pastRange = { startDate: '2020-01-01', endDate: '2019-01-01', dateInterval: '1' };
+ const result = capturedContainerProps
+ .getDatesInDateRange(makeDef(), pastRange, endDateLimit, false);
+ expect(result).toEqual([]);
+ expect(datesInDateRanges).not.toHaveBeenCalled();
+ });
+
+ it('caches the result and avoids duplicate datesInDateRanges calls', () => {
+ renderComponent();
+ capturedContainerProps.getDatesInDateRange(makeDef(), validRange, endDateLimit, false);
+ capturedContainerProps.getDatesInDateRange(makeDef(), validRange, endDateLimit, false);
+ expect(datesInDateRanges).toHaveBeenCalledTimes(1);
+ });
+
+ it('uses cached result for second call', () => {
+ const fakeDate = new Date('2020-06-01');
+ datesInDateRanges.mockReturnValueOnce([fakeDate]);
+ renderComponent();
+ capturedContainerProps.getDatesInDateRange(makeDef(), validRange, endDateLimit, false);
+ const second = capturedContainerProps
+ .getDatesInDateRange(makeDef(), validRange, endDateLimit, false);
+ expect(second).toEqual([fakeDate]);
+ });
+
+ it('ongoing + isLastInRange + futureTime → rangeEnd = endDate', () => {
+ renderComponent();
+ const def = makeDef({ ongoing: true, futureTime: true });
+ const range = { startDate: '2020-01-01', endDate: '2020-06-01', dateInterval: '1' };
+ capturedContainerProps.getDatesInDateRange(def, range, endDateLimit, true);
+ expect(datesInDateRanges).toHaveBeenCalledTimes(1);
+ });
+
+ it('ongoing + isLastInRange + no futureTime → rangeEnd = appNow', () => {
+ renderComponent();
+ const def = makeDef({ ongoing: true, futureTime: false });
+ capturedContainerProps.getDatesInDateRange(def, validRange, endDateLimit, true);
+ expect(datesInDateRanges).toHaveBeenCalledTimes(1);
+ });
+
+ it('startDate < frontDate → startDateLimit uses frontDate', () => {
+ // startDate = 2019-01-01, frontDate = 2020-01-01 → startDateLimit = frontDate
+ renderComponent({ frontDate: '2020-01-01' });
+ const earlyRange = { startDate: '2019-01-01', endDate: '2020-12-31', dateInterval: '1' };
+ capturedContainerProps.getDatesInDateRange(makeDef(), earlyRange, endDateLimit, false);
+ expect(datesInDateRanges).toHaveBeenCalledTimes(1);
+ });
+
+ it('startDate >= frontDate → startDateLimit uses startDate', () => {
+ // startDate = 2020-06-01, frontDate = 2020-01-01 → startDateLimit = startDate
+ renderComponent({ frontDate: '2020-01-01' });
+ const laterRange = { startDate: '2020-06-01', endDate: '2020-12-31', dateInterval: '1' };
+ capturedContainerProps.getDatesInDateRange(makeDef(), laterRange, endDateLimit, false);
+ expect(datesInDateRanges).toHaveBeenCalledTimes(1);
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-coverage/coverage-line.test.js b/web/js/components/timeline/timeline-coverage/coverage-line.test.js
index 09fd48922..3d3739eba 100644
--- a/web/js/components/timeline/timeline-coverage/coverage-line.test.js
+++ b/web/js/components/timeline/timeline-coverage/coverage-line.test.js
@@ -1,3 +1,322 @@
-test('coverage-line component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import CoverageLine from './coverage-line';
+jest.mock('../../../modules/date/util', () => ({
+ formatDisplayDate: jest.fn((date) => `MOCK_${date.toISOString().split('T')[0]}`),
+}));
+
+const defaultOption = {
+ leftOffset: 0,
+ isWidthGreaterThanRendered: false,
+ width: 100,
+ layerStartBeforeAxisFront: false,
+ layerEndBeforeAxisBack: false,
+};
+
+const defaultProps = {
+ id: 'test-layer',
+ options: [{ ...defaultOption }],
+ lineType: 'SINGLE',
+ startDate: '2020-01-01T00:00:00.000Z',
+ endDate: '2020-12-31T00:00:00.000Z',
+ color: 'rgb(0, 69, 123)',
+ layerPeriod: 'days',
+ index: '0',
+ positionTransformX: 50,
+};
+
+const renderComponent = (props = {}) => render(
+ <svg>
+ <CoverageLine {...defaultProps} {...props} />
+ </svg>,
+);
+
+const getRect = (container) => container.querySelector('.layer-coverage-line');
+
+describe('CoverageLine', () => {
+ describe('getFormattedDisplayDates — SINGLE lineType', () => {
+ it('formats both dates and builds toolTipText', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'SINGLE', '2020-01-01T00:00:00.000Z', '2020-12-31T00:00:00.000Z', 'days',
+ );
+ expect(result.dateRangeStart).toBe('MOCK_2020-01-01');
+ expect(result.dateRangeEnd).toBe('MOCK_2020-12-31');
+ expect(result.toolTipText).toBe('MOCK_2020-01-01 to MOCK_2020-12-31');
+ });
+
+ it('uses "Start" when startDate is null', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'SINGLE', null, '2020-12-31T00:00:00.000Z', 'days',
+ );
+ expect(result.dateRangeStart).toBe('Start');
+ expect(result.toolTipText).toBe('Start to MOCK_2020-12-31');
+ });
+
+ it('uses "Present" when endDate is null', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'SINGLE', '2020-01-01T00:00:00.000Z', null, 'days',
+ );
+ expect(result.dateRangeEnd).toBe('Present');
+ expect(result.toolTipText).toBe('MOCK_2020-01-01 to Present');
+ });
+
+ it('uses "Start" and "Present" when both dates are null', () => {
+ const result = CoverageLine.getFormattedDisplayDates('SINGLE', null, null, 'days');
+ expect(result.dateRangeStart).toBe('Start');
+ expect(result.dateRangeEnd).toBe('Present');
+ expect(result.toolTipText).toBe('Start to Present');
+ });
+ });
+
+ describe('getFormattedDisplayDates — MULTI lineType / minutes period', () => {
+ it('extracts time portion and builds hh:mm toolTipText', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'MULTI', '2020-01-01T14:50:00.000Z', '2020-01-01T15:00:00.000Z', 'minutes',
+ );
+ expect(result.toolTipText).toBe('14:50 to 15:00');
+ });
+
+ it('replaces colons and dots in dateRangeStart with underscores', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'MULTI', '2020-01-01T14:50:00.000Z', '2020-01-01T15:00:00.000Z', 'minutes',
+ );
+ expect(result.dateRangeStart).toBe('14_50_00_000Z');
+ });
+
+ it('replaces colons and dots in dateRangeEnd with underscores', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'MULTI', '2020-01-01T14:50:00.000Z', '2020-01-01T15:00:00.000Z', 'minutes',
+ );
+ expect(result.dateRangeEnd).toBe('15_00_00_000Z');
+ });
+ });
+
+ describe('getFormattedDisplayDates — MULTI lineType / non-minutes period', () => {
+ it('formats full dates for days period', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'MULTI', '2020-01-01T00:00:00.000Z', '2020-12-31T00:00:00.000Z', 'days',
+ );
+ expect(result.dateRangeStart).toBe('MOCK_2020-01-01');
+ expect(result.dateRangeEnd).toBe('MOCK_2020-12-31');
+ expect(result.toolTipText).toBe('MOCK_2020-01-01 to MOCK_2020-12-31');
+ });
+
+ it('formats full dates for months period', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'MULTI', '2020-01-01T00:00:00.000Z', '2020-06-01T00:00:00.000Z', 'months',
+ );
+ expect(result.toolTipText).toBe('MOCK_2020-01-01 to MOCK_2020-06-01');
+ });
+ });
+
+ describe('getFormattedDisplayDates — unknown lineType', () => {
+ it('returns undefined values for unrecognised lineType', () => {
+ const result = CoverageLine.getFormattedDisplayDates(
+ 'UNKNOWN', '2020-01-01T00:00:00.000Z', '2020-12-31T00:00:00.000Z', 'days',
+ );
+ expect(result.dateRangeStart).toBeUndefined();
+ expect(result.dateRangeEnd).toBeUndefined();
+ expect(result.toolTipText).toBeUndefined();
+ });
+ });
+
+ describe('rendering', () => {
+ it('renders a <g> with clipPath per option', () => {
+ const { container } = renderComponent();
+ const groups = container.querySelectorAll('g[clip-path="url(#coverageLineBoundary)"]');
+ expect(groups).toHaveLength(1);
+ });
+
+ it('renders multiple <g> elements for multiple options', () => {
+ const { container } = renderComponent({
+ options: [{ ...defaultOption }, { ...defaultOption, leftOffset: 10 }],
+ });
+ const groups = container.querySelectorAll('g[clip-path="url(#coverageLineBoundary)"]');
+ expect(groups).toHaveLength(2);
+ });
+
+ it('renders a <rect> with class layer-coverage-line', () => {
+ const { container } = renderComponent();
+ expect(getRect(container)).toBeInTheDocument();
+ });
+
+ it('rect has a <title> containing the toolTipText', () => {
+ const { container } = renderComponent();
+ const title = getRect(container).querySelector('title');
+ expect(title.textContent).toBe('MOCK_2020-01-01 to MOCK_2020-12-31');
+ });
+
+ it('rect id encodes layer id, dateRangeStart and dateRangeEnd', () => {
+ const { container } = renderComponent();
+ const rect = getRect(container);
+ expect(rect.id).toContain('test-layer');
+ expect(rect.id).toContain('MOCK_2020-01-01');
+ expect(rect.id).toContain('MOCK_2020-12-31');
+ });
+
+ it('rect id for minutes MULTI uses underscore-encoded time strings', () => {
+ const { container } = renderComponent({
+ lineType: 'MULTI',
+ layerPeriod: 'minutes',
+ startDate: '2020-01-01T14:50:00.000Z',
+ endDate: '2020-01-01T15:00:00.000Z',
+ });
+ const rect = getRect(container);
+ expect(rect.id).toContain('14_50_00_000Z');
+ expect(rect.id).toContain('15_00_00_000Z');
+ });
+
+ it('renders nothing when options array is empty', () => {
+ const { container } = renderComponent({ options: [] });
+ expect(container.querySelector('.layer-coverage-line')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('patternType — rect fill', () => {
+ it('uses coverage-line-pattern for blue color', () => {
+ const { container } = renderComponent({ color: 'rgb(0, 69, 123)' });
+ expect(getRect(container).getAttribute('fill')).toBe('url(#coverage-line-pattern)');
+ });
+
+ it('uses coverage-line-pattern-hidden for non-blue color', () => {
+ const { container } = renderComponent({ color: 'rgb(116, 116, 116)' });
+ expect(getRect(container).getAttribute('fill')).toBe('url(#coverage-line-pattern-hidden)');
+ });
+ });
+
+ describe('lineWidth — Math.max(width, 0)', () => {
+ it('uses positive width as-is', () => {
+ const { container } = renderComponent({
+ options: [{ ...defaultOption, width: 80 }],
+ });
+ expect(getRect(container).getAttribute('width')).toBe('80px');
+ });
+
+ it('clamps negative width to 0', () => {
+ const { container } = renderComponent({
+ options: [{ ...defaultOption, width: -10 }],
+ });
+ expect(getRect(container).getAttribute('width')).toBe('0px');
+ });
+
+ it('uses 0 for zero width', () => {
+ const { container } = renderComponent({
+ options: [{ ...defaultOption, width: 0 }],
+ });
+ expect(getRect(container).getAttribute('width')).toBe('0px');
+ });
+ });
+
+ describe('rectTransform', () => {
+ it('uses positionTransformX when leftOffset=0, isWidthGreaterThanRendered=true, layerEndBeforeAxisBack=false', () => {
+ const { container } = renderComponent({
+ positionTransformX: 50,
+ options: [{
+ ...defaultOption,
+ leftOffset: 0,
+ isWidthGreaterThanRendered: true,
+ layerEndBeforeAxisBack: false,
+ }],
+ });
+ expect(getRect(container).getAttribute('transform')).toBe('translate(50)');
+ });
+
+ it('uses leftOffset when leftOffset is non-zero', () => {
+ const { container } = renderComponent({
+ options: [{ ...defaultOption, leftOffset: 30 }],
+ });
+ expect(getRect(container).getAttribute('transform')).toBe('translate(30)');
+ });
+
+ it('uses leftOffset when isWidthGreaterThanRendered is false', () => {
+ const { container } = renderComponent({
+ positionTransformX: 50,
+ options: [{ ...defaultOption, leftOffset: 0, isWidthGreaterThanRendered: false }],
+ });
+ expect(getRect(container).getAttribute('transform')).toBe('translate(0)');
+ });
+ });
+
+ describe('lineRadius — rect rx attribute', () => {
+ it('is "6" when isWidthGreaterThanRendered is false', () => {
+ const { container } = renderComponent({
+ options: [{ ...defaultOption, isWidthGreaterThanRendered: false }],
+ });
+ expect(getRect(container).getAttribute('rx')).toBe('6');
+ });
+
+ it('is "6" when isWidthGreaterThanRendered=true and leftOffset is non-zero', () => {
+ const { container } = renderComponent({
+ options: [{ ...defaultOption, isWidthGreaterThanRendered: true, leftOffset: 5 }],
+ });
+ expect(getRect(container).getAttribute('rx')).toBe('6');
+ });
+
+ it('is "0" when isWidthGreaterThanRendered=true, leftOffset=0, no false-transform', () => {
+ const { container } = renderComponent({
+ options: [{
+ ...defaultOption,
+ leftOffset: 0,
+ isWidthGreaterThanRendered: true,
+ layerEndBeforeAxisBack: false,
+ layerStartBeforeAxisFront: false,
+ }],
+ });
+ expect(getRect(container).getAttribute('rx')).toBe('0');
+ });
+ });
+
+ describe('false transform branch', () => {
+ it('fires when isWidthGreaterThanRendered=true and layerEndBeforeAxisBack=true: adjusts width, transform, rx=6', () => {
+ const { container } = renderComponent({
+ positionTransformX: 50,
+ options: [{
+ ...defaultOption,
+ leftOffset: 0,
+ isWidthGreaterThanRendered: true,
+ layerEndBeforeAxisBack: true,
+ width: 100,
+ }],
+ });
+ const rect = getRect(container);
+ expect(rect.getAttribute('width')).toBe('50px'); // 100 - 50
+ expect(rect.getAttribute('transform')).toBe('translate(50)'); // 0 + 50
+ expect(rect.getAttribute('rx')).toBe('6');
+ });
+
+ it('fires when isWidthGreaterThanRendered=false and layerStartBeforeAxisFront=true: adjusts width, transform, rx=6', () => {
+ const { container } = renderComponent({
+ positionTransformX: 50,
+ options: [{
+ ...defaultOption,
+ leftOffset: 0,
+ isWidthGreaterThanRendered: false,
+ layerStartBeforeAxisFront: true,
+ width: 100,
+ }],
+ });
+ const rect = getRect(container);
+ expect(rect.getAttribute('width')).toBe('50px');
+ expect(rect.getAttribute('transform')).toBe('translate(50)');
+ expect(rect.getAttribute('rx')).toBe('6');
+ });
+
+ it('does not fire when leftOffset is non-zero', () => {
+ const { container } = renderComponent({
+ positionTransformX: 50,
+ options: [{
+ ...defaultOption,
+ leftOffset: 10,
+ isWidthGreaterThanRendered: true,
+ layerEndBeforeAxisBack: true,
+ width: 100,
+ }],
+ });
+ const rect = getRect(container);
+ expect(rect.getAttribute('width')).toBe('100px');
+ expect(rect.getAttribute('transform')).toBe('translate(10)');
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-coverage/info-modal.test.js b/web/js/components/timeline/timeline-coverage/info-modal.test.js
index 73e7070b8..fa0b5bbc2 100644
--- a/web/js/components/timeline/timeline-coverage/info-modal.test.js
+++ b/web/js/components/timeline/timeline-coverage/info-modal.test.js
@@ -1,3 +1,74 @@
-test('info-modal component test', () => {
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import LayerCoverageInfoModal from './info-modal';
+describe('LayerCoverageInfoModal', () => {
+ it('renders the outer container with class layer-coverage-info', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ expect(container.querySelector('.layer-coverage-info')).toBeInTheDocument();
+ });
+
+ it('renders a <header> element', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ expect(container.querySelector('header')).toBeInTheDocument();
+ });
+
+ it('renders two paragraphs inside the header', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ const paragraphs = container.querySelector('header').querySelectorAll('p');
+ expect(paragraphs).toHaveLength(2);
+ });
+
+ it('first header paragraph mentions striped horizontal blue lines', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ const firstP = container.querySelector('header p');
+ expect(firstP.textContent).toContain('striped');
+ expect(firstP.textContent).toContain('blue lines');
+ });
+
+ it('second header paragraph mentions solid blue line', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ const paragraphs = container.querySelector('header').querySelectorAll('p');
+ expect(paragraphs[1].textContent).toContain('solid blue line');
+ });
+
+ it('renders the info-item-container div', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ expect(container.querySelector('.layer-coverage-info-item-container')).toBeInTheDocument();
+ });
+
+ it('renders the left section with class layer-coverage-info-item-left', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ expect(container.querySelector('.layer-coverage-info-item-left')).toBeInTheDocument();
+ });
+
+ it('renders the lc-axis image in the left section', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ const img = container.querySelector('.layer-coverage-info-item-left img');
+ expect(img).toBeInTheDocument();
+ expect(img.getAttribute('src')).toBe('images/lc-axis.png');
+ });
+
+ it('renders the right section with class layer-coverage-info-item-right', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ expect(container.querySelector('.layer-coverage-info-item-right')).toBeInTheDocument();
+ });
+
+ it('renders the lc-toggle image in the right section', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ const img = container.querySelector('.layer-coverage-info-item-right img');
+ expect(img).toBeInTheDocument();
+ expect(img.getAttribute('src')).toBe('images/lc-toggle.png');
+ });
+
+ it('renders a <strong>Note:</strong> element', () => {
+ const { getByText } = render(<LayerCoverageInfoModal />);
+ expect(getByText('Note:')).toBeInTheDocument();
+ });
+
+ it('note paragraph mentions monthly layers', () => {
+ const { container } = render(<LayerCoverageInfoModal />);
+ const sections = container.querySelectorAll('.layer-coverage-info-item-right div');
+ expect(sections[1].textContent).toContain('monthly layers');
+ });
});
diff --git a/web/js/components/timeline/timeline-coverage/timeline-coverage.test.js b/web/js/components/timeline/timeline-coverage/timeline-coverage.test.js
index 87b730ea9..879c7ab40 100644
--- a/web/js/components/timeline/timeline-coverage/timeline-coverage.test.js
+++ b/web/js/components/timeline/timeline-coverage/timeline-coverage.test.js
@@ -1,3 +1,910 @@
-test('timeline-coverage component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import {
+ render, fireEvent, act, waitFor,
+} from '@testing-library/react';
+import '@testing-library/jest-dom';
+import googleTagManager from 'googleTagManager';
+import { toggleCustomContent } from '../../../modules/modal/actions';
+// TDZ-safe Redux capture; component loaded in beforeAll to avoid TDZ.
+let capturedMapState;
+let capturedMapDispatch;
+jest.mock('react-redux', () => ({
+ connect: (mapState, mapDispatch) => {
+ capturedMapState = mapState;
+ capturedMapDispatch = mapDispatch;
+ return (Component) => Component;
+ },
+}));
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, className }) => (
+ <span data-testid={`icon-${icon}`} className={className} />
+ ),
+}));
+
+jest.mock('reactstrap', () => ({
+ UncontrolledTooltip: ({ children }) => <div data-testid="tooltip">{children}</div>,
+}));
+
+jest.mock('googleTagManager', () => ({ pushEvent: jest.fn() }));
+
+jest.mock('../../../modules/date/constants', () => ({
+ timeScaleOptions: {
+ day: { timeAxis: { gridWidth: 12 } },
+ month: { timeAxis: { gridWidth: 24 } },
+ year: { timeAxis: { gridWidth: 50 } },
+ },
+}));
+
+jest.mock('../../../modules/date/util', () => ({
+ filterProjLayersWithStartDate: jest.fn((layers) => layers),
+}));
+
+jest.mock('../../../modules/layers/selectors', () => ({
+ getActiveLayers: jest.fn((state) => state.layers?.active || []),
+}));
+
+jest.mock('../../../modules/modal/actions', () => ({
+ toggleCustomContent: jest.fn((key, config) => ({ type: 'TOGGLE_CUSTOM_CONTENT', key, config })),
+}));
+
+jest.mock('../../util/scrollbar', () => function MockScrollbars({ children, style }) {
+ return <div data-testid="scrollbars" style={style}>{children}</div>;
+});
+
+let capturedSwitchProps = null;
+jest.mock('../../util/switch', () => function MockSwitch(props) {
+ capturedSwitchProps = props;
+ return <div data-testid="switch" data-active={String(props.active)} />;
+});
+
+jest.mock('./info-modal', () => function MockInfoModal() {
+ return <div data-testid="info-modal" />;
+});
+
+let capturedItemListProps = null;
+jest.mock('./coverage-item-list', () => function MockCoverageItemList(props) {
+ capturedItemListProps = props;
+ return <div data-testid="coverage-item-list" />;
+});
+
+let TimelineLayerCoveragePanel;
+beforeAll(() => {
+ TimelineLayerCoveragePanel = require('./timeline-coverage').default;
+});
+
+const visibleLayer = {
+ id: 'layer1',
+ visible: true,
+ startDate: '2020-01-01T00:00:00.000Z',
+ endDate: '2020-12-31T00:00:00.000Z',
+ ongoing: false,
+};
+
+const hiddenLayer = {
+ id: 'layer2',
+ visible: false,
+ startDate: '2020-01-01T00:00:00.000Z',
+ endDate: '2020-12-31T00:00:00.000Z',
+ ongoing: false,
+};
+
+const defaultProps = {
+ activeLayers: [visibleLayer],
+ appNow: new Date('2021-01-01T00:00:00.000Z'),
+ axisWidth: 1000,
+ backDate: '2021-01-01T00:00:00.000Z',
+ frontDate: '2020-01-01T00:00:00.000Z',
+ isTimelineLayerCoveragePanelOpen: false,
+ isProductPickerOpen: false,
+ onInfoClick: jest.fn(),
+ parentOffset: 100,
+ positionTransformX: 0,
+ projection: 'geographic',
+ setMatchingTimelineCoverage: jest.fn(),
+ timelineStartDateLimit: '2000-01-01T00:00:00.000Z',
+ timeScale: 'day',
+ toggleLayerCoveragePanel: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <TimelineLayerCoveragePanel {...defaultProps} {...props} />,
+);
+
+describe('TimelineLayerCoveragePanel', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ capturedItemListProps = null;
+ capturedSwitchProps = null;
+ });
+
+ // ─── rendering ────────────────────────────────────────────────────────────
+
+ describe('rendering — panel closed', () => {
+ it('renders the panel handle button', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('#timeline-layer-coverage-panel-handle')).toBeInTheDocument();
+ });
+
+ it('renders the container div with timeline-layer-coverage-closed class', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.timeline-layer-coverage-container'))
+ .toHaveClass('timeline-layer-coverage-closed');
+ });
+
+ it('does not render CoverageItemList when panel is closed', () => {
+ const { queryByTestId } = renderComponent();
+ expect(queryByTestId('coverage-item-list')).not.toBeInTheDocument();
+ });
+
+ it('panel handle aria-label says "Show layer coverage panel" when closed', () => {
+ const { getByRole } = renderComponent({ isTimelineLayerCoveragePanelOpen: false });
+ expect(getByRole('button', { name: 'Show layer coverage panel' })).toBeInTheDocument();
+ });
+
+ it('chevron div has closed class', () => {
+ const { container } = renderComponent({ isTimelineLayerCoveragePanelOpen: false });
+ expect(container.querySelector('.timeline-layer-coverage-panel-handle-chevron'))
+ .toHaveClass('timeline-layer-coverage-panel-handle-chevron-closed');
+ });
+ });
+
+ describe('rendering — panel open', () => {
+ it('renders with timeline-layer-coverage-open class when open', () => {
+ const { container } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(container.querySelector('.timeline-layer-coverage-container'))
+ .toHaveClass('timeline-layer-coverage-open');
+ });
+
+ it('renders CoverageItemList when panel is open', () => {
+ const { getByTestId } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(getByTestId('coverage-item-list')).toBeInTheDocument();
+ });
+
+ it('renders Scrollbars when panel is open', () => {
+ const { getByTestId } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(getByTestId('scrollbars')).toBeInTheDocument();
+ });
+
+ it('renders "LAYER COVERAGE" header title', () => {
+ const { getByText } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(getByText('LAYER COVERAGE')).toBeInTheDocument();
+ });
+
+ it('renders info button', () => {
+ const { container } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(container.querySelector('#layer-coverage-info-button')).toBeInTheDocument();
+ });
+
+ it('renders "Include Hidden Layers" Switch', () => {
+ const { getByTestId } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(getByTestId('switch')).toBeInTheDocument();
+ });
+
+ it('Switch active=false by default', () => {
+ const { getByTestId } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(getByTestId('switch').dataset.active).toBe('false');
+ });
+
+ it('panel handle aria-label says "Collapse layer coverage panel" when open', () => {
+ const { getByRole } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(getByRole('button', { name: 'Collapse layer coverage panel' })).toBeInTheDocument();
+ });
+
+ it('chevron div has open class when panel is open', () => {
+ const { container } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(container.querySelector('.timeline-layer-coverage-panel-handle-chevron'))
+ .toHaveClass('timeline-layer-coverage-panel-handle-chevron-open');
+ });
+ });
+
+ // ─── stopPropagation ──────────────────────────────────────────────────────
+
+ describe('stopPropagation', () => {
+ it('calls stopImmediatePropagation, stopPropagation, and preventDefault', () => {
+ const e = {
+ nativeEvent: { stopImmediatePropagation: jest.fn() },
+ stopPropagation: jest.fn(),
+ preventDefault: jest.fn(),
+ };
+ TimelineLayerCoveragePanel.stopPropagation(e);
+ expect(e.nativeEvent.stopImmediatePropagation).toHaveBeenCalled();
+ expect(e.stopPropagation).toHaveBeenCalled();
+ expect(e.preventDefault).toHaveBeenCalled();
+ });
+
+ it('wheel event on container calls stopPropagation on the native event', () => {
+ const { container } = renderComponent();
+ const coverageContainer = container.querySelector('.timeline-layer-coverage-container');
+ const stopPropagation = jest.fn();
+ const wheelEvent = new Event('wheel');
+ wheelEvent.stopPropagation = stopPropagation;
+ coverageContainer.dispatchEvent(wheelEvent);
+ expect(stopPropagation).toHaveBeenCalled();
+ });
+ });
+
+ // ─── togglePanelOpenClose ─────────────────────────────────────────────────
+
+ describe('togglePanelOpenClose', () => {
+ it('calls toggleLayerCoveragePanel(true) when panel is closed', () => {
+ const toggleLayerCoveragePanel = jest.fn();
+ const { container } = renderComponent({
+ isTimelineLayerCoveragePanelOpen: false,
+ toggleLayerCoveragePanel,
+ });
+ fireEvent.click(container.querySelector('#timeline-layer-coverage-panel-handle'));
+ expect(toggleLayerCoveragePanel).toHaveBeenCalledWith(true);
+ });
+
+ it('calls toggleLayerCoveragePanel(false) when panel is open', () => {
+ const toggleLayerCoveragePanel = jest.fn();
+ const { container } = renderComponent({
+ isTimelineLayerCoveragePanelOpen: true,
+ toggleLayerCoveragePanel,
+ });
+ fireEvent.click(container.querySelector('#timeline-layer-coverage-panel-handle'));
+ expect(toggleLayerCoveragePanel).toHaveBeenCalledWith(false);
+ });
+ });
+
+ // ─── renderInfoButton ─────────────────────────────────────────────────────
+
+ describe('renderInfoButton', () => {
+ it('info button click calls onInfoClick', () => {
+ const onInfoClick = jest.fn();
+ const { container } = renderComponent({
+ isTimelineLayerCoveragePanelOpen: true,
+ onInfoClick,
+ });
+ fireEvent.click(container.querySelector('#layer-coverage-info-button'));
+ expect(onInfoClick).toHaveBeenCalledTimes(1);
+ });
+
+ it('renders question-circle icon inside info button', () => {
+ const { getByTestId } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ expect(getByTestId('icon-question-circle')).toBeInTheDocument();
+ });
+ });
+
+ // ─── getConditionalStyles ─────────────────────────────────────────────────
+
+ describe('getConditionalStyles', () => {
+ it('container style has correct width from axisWidth', () => {
+ const { container } = renderComponent({
+ isTimelineLayerCoveragePanelOpen: true,
+ axisWidth: 800,
+ });
+ const el = container.querySelector('.timeline-layer-coverage-container');
+ expect(el.style.width).toBe('801px');
+ });
+
+ it('container display is "none" when panel is closed', () => {
+ const { container } = renderComponent({ isTimelineLayerCoveragePanelOpen: false });
+ const el = container.querySelector('.timeline-layer-coverage-container');
+ expect(el.style.display).toBe('none');
+ });
+
+ it('container display is "block" when panel is open', () => {
+ const { container } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ const el = container.querySelector('.timeline-layer-coverage-container');
+ expect(el.style.display).toBe('block');
+ });
+
+ it('panel handle has top: -19px when closed', () => {
+ const { container } = renderComponent({ isTimelineLayerCoveragePanelOpen: false });
+ const handle = container.querySelector('#timeline-layer-coverage-panel-handle');
+ expect(handle.style.top).toBe('-19px');
+ });
+
+ it('panel handle top offset is not -19px when open', () => {
+ const { container } = renderComponent({ isTimelineLayerCoveragePanelOpen: true });
+ const handle = container.querySelector('#timeline-layer-coverage-panel-handle');
+ expect(handle.style.top).not.toBe('-19px');
+ });
+
+ it('container left offset uses parentOffset', () => {
+ const { container } = renderComponent({ parentOffset: 200 });
+ const el = container.querySelector('.timeline-layer-coverage-container');
+ expect(el.style.left).toBe('190px'); // 200 - 10
+ });
+ });
+
+ // ─── getActiveLayers ──────────────────────────────────────────────────────
+
+ describe('getActiveLayers — shouldIncludeHiddenLayers', () => {
+ it('filters out invisible layers by default (shouldIncludeHiddenLayers=false)', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ renderComponent({
+ isTimelineLayerCoveragePanelOpen: true,
+ activeLayers: [visibleLayer, hiddenLayer],
+ setMatchingTimelineCoverage,
+ });
+ await waitFor(() => {
+ expect(capturedItemListProps.activeLayers).toHaveLength(1);
+ expect(capturedItemListProps.activeLayers[0].id).toBe('layer1');
+ });
+ });
+
+ it('includes hidden layers when Switch is toggled on', async () => {
+ renderComponent({
+ isTimelineLayerCoveragePanelOpen: true,
+ activeLayers: [visibleLayer, hiddenLayer],
+ setMatchingTimelineCoverage: jest.fn(),
+ });
+ await act(async () => {
+ capturedSwitchProps.toggle();
+ });
+ await waitFor(() => {
+ expect(capturedItemListProps.activeLayers).toHaveLength(2);
+ });
+ });
+
+ it('Switch active becomes true after toggle', async () => {
+ const { getByTestId } = renderComponent({
+ isTimelineLayerCoveragePanelOpen: true,
+ setMatchingTimelineCoverage: jest.fn(),
+ });
+ await act(async () => {
+ capturedSwitchProps.toggle();
+ });
+ await waitFor(() => {
+ expect(getByTestId('switch').dataset.active).toBe('true');
+ });
+ });
+ });
+
+ // ─── addMatchingCoverageToTimeline ────────────────────────────────────────
+
+ describe('addMatchingCoverageToTimeline', () => {
+ it('calls setMatchingTimelineCoverage on mount', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ renderComponent({ setMatchingTimelineCoverage });
+ await waitFor(() => {
+ expect(setMatchingTimelineCoverage).toHaveBeenCalled();
+ });
+ });
+
+ it('passes dateRange and isChecked to setMatchingTimelineCoverage', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ renderComponent({ setMatchingTimelineCoverage, activeLayers: [visibleLayer] });
+ await waitFor(() => {
+ expect(setMatchingTimelineCoverage).toHaveBeenCalledWith(
+ expect.arrayContaining([
+ expect.objectContaining({ startDate: visibleLayer.startDate }),
+ ]),
+ false, // shouldIncludeHiddenLayers default
+ );
+ });
+ });
+
+ it('passes undefined when no active layers', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ renderComponent({ setMatchingTimelineCoverage, activeLayers: [] });
+ await waitFor(() => {
+ expect(setMatchingTimelineCoverage).toHaveBeenCalledWith(undefined, false);
+ });
+ });
+ });
+
+ // ─── getNewMatchingDatesRange ─────────────────────────────────────────────
+
+ describe('getNewMatchingDatesRange', () => {
+ it('returns array of {startDate, endDate} for normal layers', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ renderComponent({
+ setMatchingTimelineCoverage,
+ activeLayers: [visibleLayer],
+ });
+ await waitFor(() => {
+ const [[dateRange]] = setMatchingTimelineCoverage.mock.calls;
+ expect(dateRange[0].startDate).toBe(visibleLayer.startDate);
+ expect(dateRange[0].endDate).toBe(visibleLayer.endDate);
+ });
+ });
+
+ it('uses appNow when endDate is absent', async () => {
+ const appNow = new Date('2021-06-01T00:00:00.000Z');
+ const noEndLayer = { ...visibleLayer, endDate: undefined };
+ const setMatchingTimelineCoverage = jest.fn();
+ renderComponent({ setMatchingTimelineCoverage, activeLayers: [noEndLayer], appNow });
+ await waitFor(() => {
+ const [[dateRange]] = setMatchingTimelineCoverage.mock.calls;
+ expect(dateRange[0].endDate).toBe(appNow);
+ });
+ });
+
+ it('maps granuleDateRanges to {startDate, endDate} pairs', async () => {
+ const granuleLayer = {
+ ...visibleLayer,
+ granuleDateRanges: [
+ ['2020-01-01T00:00:00.000Z', '2020-06-30T00:00:00.000Z'],
+ ['2020-07-01T00:00:00.000Z', '2020-12-31T00:00:00.000Z'],
+ ],
+ };
+ const setMatchingTimelineCoverage = jest.fn();
+ renderComponent({ setMatchingTimelineCoverage, activeLayers: [granuleLayer] });
+ await waitFor(() => {
+ const [[dateRange]] = setMatchingTimelineCoverage.mock.calls;
+ expect(dateRange).toHaveLength(2);
+ expect(dateRange[0]).toEqual({ startDate: '2020-01-01T00:00:00.000Z', endDate: '2020-06-30T00:00:00.000Z' });
+ expect(dateRange[1]).toEqual({ startDate: '2020-07-01T00:00:00.000Z', endDate: '2020-12-31T00:00:00.000Z' });
+ });
+ });
+
+ it('returns undefined for empty activeLayers', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ renderComponent({ setMatchingTimelineCoverage, activeLayers: [] });
+ await waitFor(() => {
+ expect(setMatchingTimelineCoverage).toHaveBeenCalledWith(undefined, false);
+ });
+ });
+ });
+
+ // ─── getMatchingCoverageLineDimensions ────────────────────────────────────
+
+ describe('getMatchingCoverageLineDimensions', () => {
+ const renderOpen = (props = {}) => renderComponent({
+ isTimelineLayerCoveragePanelOpen: true,
+ setMatchingTimelineCoverage: jest.fn(),
+ ...props,
+ });
+
+ // frontDate=Jan1 2020, backDate=Jan1 2021, gridWidth=12, positionTransformX=0
+
+ it('returns visible=true for layer within axis range', () => {
+ renderOpen();
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ visibleLayer, null, null,
+ );
+ expect(result[0].visible).toBe(true);
+ });
+
+ it('returns visible=false when layerStart is after backDate', () => {
+ renderOpen();
+ const futureLayer = { ...visibleLayer, startDate: '2022-01-01T00:00:00.000Z', endDate: '2022-12-31T00:00:00.000Z' };
+ const result = capturedItemListProps
+ .getMatchingCoverageLineDimensions(futureLayer, null, null);
+ expect(result[0].visible).toBe(false);
+ });
+
+ it('returns visible=false when layerEnd is before frontDate', () => {
+ renderOpen();
+ const pastLayer = { ...visibleLayer, startDate: '2018-01-01T00:00:00.000Z', endDate: '2019-01-01T00:00:00.000Z' };
+ const result = capturedItemListProps
+ .getMatchingCoverageLineDimensions(pastLayer, null, null);
+ expect(result[0].visible).toBe(false);
+ });
+
+ it('leftOffset=0 when layer starts before axisFrontDate', () => {
+ renderOpen();
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ visibleLayer, null, null,
+ );
+ expect(result[0].leftOffset).toBe(0);
+ expect(result[0].layerStartBeforeAxisFront).toBe(true);
+ });
+
+ it('computes leftOffset via diff when layer starts after axisFrontDate', () => {
+ renderOpen({ positionTransformX: 0 });
+ const midLayer = {
+ ...visibleLayer,
+ startDate: '2020-07-01T00:00:00.000Z',
+ endDate: '2022-01-01T00:00:00.000Z',
+ ongoing: false,
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(midLayer, null, null);
+ expect(result[0].leftOffset).toBeGreaterThan(0);
+ expect(result[0].layerStartBeforeAxisFront).toBe(false);
+ });
+
+ it('computes width when layerEnd is before axisBackDate', () => {
+ renderOpen();
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ visibleLayer, null, null,
+ );
+ // Dec 31 2020 < Jan 1 2021, so layerEndBeforeAxisBack=true → width is calculated
+ expect(result[0].layerEndBeforeAxisBack).toBe(true);
+ expect(result[0].width).toBeLessThan(1000 * 5);
+ });
+
+ it('width is axisWidth*5 when layerEnd exceeds axisBackDate', () => {
+ renderOpen({ axisWidth: 500 });
+ const extendedLayer = {
+ ...visibleLayer,
+ endDate: '2025-01-01T00:00:00.000Z',
+ ongoing: false,
+ };
+ const result = capturedItemListProps
+ .getMatchingCoverageLineDimensions(extendedLayer, null, null);
+ expect(result[0].width).toBe(500 * 5);
+ expect(result[0].layerEndBeforeAxisBack).toBe(false);
+ });
+
+ it('uses timelineStartDateLimit when no rangeStart and no startDate', () => {
+ renderOpen();
+ const noStartLayer = {
+ id: 'no-start',
+ visible: true,
+ ongoing: false,
+ endDate: '2020-06-01T00:00:00.000Z',
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ noStartLayer, null, null,
+ );
+ // timelineStartDateLimit = Jan 1 2000, so layerStart well before axisFrontDate
+ expect(result[0].layerStartBeforeAxisFront).toBe(true);
+ });
+
+ it('uses rangeStart when provided', () => {
+ renderOpen({ positionTransformX: 0 });
+ const noStartLayer = { id: 'x', visible: true, ongoing: false, endDate: '2022-01-01T00:00:00.000Z' };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ noStartLayer, '2020-06-01T00:00:00.000Z', null,
+ );
+ expect(result[0].visible).toBe(true);
+ });
+
+ it('uses rangeEnd when provided', () => {
+ renderOpen();
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ visibleLayer, null, '2020-06-01T00:00:00.000Z',
+ );
+ expect(result[0].layerEndBeforeAxisBack).toBe(true);
+ });
+
+ it('uses endDate for futureTime ongoing layer', () => {
+ renderOpen();
+ const futureTimeLayer = {
+ ...visibleLayer,
+ ongoing: true,
+ futureTime: true,
+ endDate: '2025-01-01T00:00:00.000Z',
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ futureTimeLayer, null, null,
+ );
+ // futureTime + endDate → layerEnd = 2025, which is after axisBackDate
+ expect(result[0].layerEndBeforeAxisBack).toBe(false);
+ });
+
+ it('uses appNow for ongoing layer with no futureTime', () => {
+ renderOpen({ appNow: new Date('2021-01-01T00:00:00.000Z') });
+ const ongoingLayer = {
+ ...visibleLayer,
+ ongoing: true,
+ futureTime: false,
+ endDate: undefined,
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ ongoingLayer, null, null,
+ );
+ expect(result).toHaveLength(1);
+ });
+
+ it('isWidthGreaterThanRendered=true when layer spans beyond axis', () => {
+ renderOpen();
+ const bigLayer = {
+ ...visibleLayer,
+ startDate: '2019-01-01T00:00:00.000Z',
+ endDate: '2022-01-01T00:00:00.000Z',
+ ongoing: false,
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(bigLayer, null, null);
+ expect(result[0].isWidthGreaterThanRendered).toBe(true);
+ });
+
+ describe('granuleDateRanges path', () => {
+ it('returns one result per granule range', () => {
+ renderOpen();
+ const granuleLayer = {
+ visible: true,
+ ongoing: false,
+ granuleDateRanges: [
+ ['2020-01-01T00:00:00.000Z', '2020-06-30T00:00:00.000Z'],
+ ['2020-07-01T00:00:00.000Z', '2020-12-31T00:00:00.000Z'],
+ ],
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ granuleLayer, null, null,
+ );
+ expect(result).toHaveLength(2);
+ });
+
+ it('computes visible for each granule range', () => {
+ renderOpen();
+ const granuleLayer = {
+ visible: true,
+ ongoing: false,
+ granuleDateRanges: [
+ ['2020-01-01T00:00:00.000Z', '2020-06-30T00:00:00.000Z'],
+ ['2022-01-01T00:00:00.000Z', '2022-12-31T00:00:00.000Z'], // outside axis
+ ],
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ granuleLayer, null, null,
+ );
+ expect(result[0].visible).toBe(true);
+ expect(result[1].visible).toBe(false);
+ });
+
+ it('uses timelineStartDateLimit in granule path when no startDate in tuple', () => {
+ renderOpen();
+ const granuleLayer = {
+ visible: true,
+ ongoing: false,
+ granuleDateRanges: [
+ [null, '2020-06-30T00:00:00.000Z'],
+ ],
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ granuleLayer, null, null,
+ );
+ // startDate=null, rangeStart=null → use timelineStartDateLimit (Jan 1 2000)
+ expect(result[0].layerStartBeforeAxisFront).toBe(true);
+ });
+
+ it('uses positionTransformX in leftOffset calc for granule layers', () => {
+ renderOpen({ positionTransformX: 10 });
+ const granuleLayer = {
+ visible: true,
+ ongoing: false,
+ granuleDateRanges: [
+ ['2020-07-01T00:00:00.000Z', '2022-01-01T00:00:00.000Z'],
+ ],
+ };
+ const result = capturedItemListProps.getMatchingCoverageLineDimensions(
+ granuleLayer, null, null,
+ );
+ expect(result[0].leftOffset).toBeGreaterThan(0);
+ });
+ });
+ });
+
+ // ─── shouldComponentUpdate ────────────────────────────────────────────────
+
+ describe('shouldComponentUpdate', () => {
+ it('prevents re-render when timeScale changes but front/backDate are unchanged', () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ const { rerender } = renderComponent({ setMatchingTimelineCoverage });
+ const countAfterMount = setMatchingTimelineCoverage.mock.calls.length;
+
+ act(() => {
+ rerender(
+ <TimelineLayerCoveragePanel
+ {...defaultProps}
+ setMatchingTimelineCoverage={setMatchingTimelineCoverage}
+ timeScale="month"
+ />,
+ );
+ });
+ // SCU returned false → componentDidUpdate skipped → no additional calls
+ expect(setMatchingTimelineCoverage.mock.calls.length).toBe(countAfterMount);
+ });
+
+ it('allows re-render when timeScale changes and frontDate also changes', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ const { rerender } = renderComponent({ setMatchingTimelineCoverage });
+ const countAfterMount = setMatchingTimelineCoverage.mock.calls.length;
+
+ await act(async () => {
+ rerender(
+ <TimelineLayerCoveragePanel
+ {...defaultProps}
+ setMatchingTimelineCoverage={setMatchingTimelineCoverage}
+ timeScale="month"
+ frontDate="2019-01-01T00:00:00.000Z"
+ />,
+ );
+ });
+ // SCU returned true (frontDate changed) → componentDidUpdate fired
+ // But none of the 4 update triggers are hit (no layer/projection/appNow/toggle changes)
+ // So the count stays the same — just verify no crash
+ expect(setMatchingTimelineCoverage.mock.calls.length).toBeGreaterThanOrEqual(countAfterMount);
+ });
+
+ it('allows re-render when timeScale is unchanged', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ const { rerender } = renderComponent({ setMatchingTimelineCoverage });
+ const countAfterMount = setMatchingTimelineCoverage.mock.calls.length;
+
+ await act(async () => {
+ rerender(
+ <TimelineLayerCoveragePanel
+ {...defaultProps}
+ setMatchingTimelineCoverage={setMatchingTimelineCoverage}
+ projection="arctic"
+ />,
+ );
+ });
+ // SCU returns true (timeScale unchanged) → componentDidUpdate fires → projectionChange=true
+ await waitFor(() => {
+ expect(setMatchingTimelineCoverage.mock.calls.length).toBeGreaterThan(countAfterMount);
+ });
+ });
+ });
+
+ // ─── componentDidUpdate ───────────────────────────────────────────────────
+
+ describe('componentDidUpdate', () => {
+ it('toggles panel closed when product picker opens while panel is open', async () => {
+ const toggleLayerCoveragePanel = jest.fn();
+ const { rerender } = renderComponent({
+ isTimelineLayerCoveragePanelOpen: true,
+ isProductPickerOpen: false,
+ toggleLayerCoveragePanel,
+ });
+
+ await act(async () => {
+ rerender(
+ <TimelineLayerCoveragePanel
+ {...defaultProps}
+ isTimelineLayerCoveragePanelOpen
+ isProductPickerOpen
+ toggleLayerCoveragePanel={toggleLayerCoveragePanel}
+ />,
+ );
+ });
+ expect(toggleLayerCoveragePanel).toHaveBeenCalledWith(false);
+ });
+
+ it('updates on projection change', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ const { rerender } = renderComponent({ setMatchingTimelineCoverage });
+ const countAfterMount = setMatchingTimelineCoverage.mock.calls.length;
+
+ await act(async () => {
+ rerender(
+ <TimelineLayerCoveragePanel
+ {...defaultProps}
+ setMatchingTimelineCoverage={setMatchingTimelineCoverage}
+ projection="arctic"
+ />,
+ );
+ });
+ await waitFor(() => {
+ expect(setMatchingTimelineCoverage.mock.calls.length).toBeGreaterThan(countAfterMount);
+ });
+ });
+
+ it('updates on appNow change', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ const { rerender } = renderComponent({ setMatchingTimelineCoverage });
+ const countAfterMount = setMatchingTimelineCoverage.mock.calls.length;
+
+ await act(async () => {
+ rerender(
+ <TimelineLayerCoveragePanel
+ {...defaultProps}
+ setMatchingTimelineCoverage={setMatchingTimelineCoverage}
+ appNow={new Date('2021-06-01T00:00:00.000Z')}
+ />,
+ );
+ });
+ await waitFor(() => {
+ expect(setMatchingTimelineCoverage.mock.calls.length).toBeGreaterThan(countAfterMount);
+ });
+ });
+
+ it('updates on active layers change', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ const { rerender } = renderComponent({
+ setMatchingTimelineCoverage,
+ activeLayers: [visibleLayer],
+ });
+ const countAfterMount = setMatchingTimelineCoverage.mock.calls.length;
+
+ const newLayer = { ...visibleLayer, id: 'layer-new' };
+ await act(async () => {
+ rerender(
+ <TimelineLayerCoveragePanel
+ {...defaultProps}
+ setMatchingTimelineCoverage={setMatchingTimelineCoverage}
+ activeLayers={[visibleLayer, newLayer]}
+ />,
+ );
+ });
+ await waitFor(() => {
+ expect(setMatchingTimelineCoverage.mock.calls.length).toBeGreaterThan(countAfterMount);
+ });
+ });
+
+ it('does not update when isProductPickerOpen=false (no other changes)', async () => {
+ const setMatchingTimelineCoverage = jest.fn();
+ const { rerender } = renderComponent({ setMatchingTimelineCoverage });
+ const countAfterMount = setMatchingTimelineCoverage.mock.calls.length;
+
+ await act(async () => {
+ rerender(
+ <TimelineLayerCoveragePanel
+ {...defaultProps}
+ setMatchingTimelineCoverage={setMatchingTimelineCoverage}
+ isProductPickerOpen={false}
+ />,
+ );
+ });
+ // no change in any of the 4 tracked conditions
+ expect(setMatchingTimelineCoverage.mock.calls.length).toBe(countAfterMount);
+ });
+ });
+
+ // ─── mapStateToProps ──────────────────────────────────────────────────────
+
+ describe('mapStateToProps', () => {
+ const { getActiveLayers } = require('../../../modules/layers/selectors');
+ const { filterProjLayersWithStartDate } = require('../../../modules/date/util');
+
+ const makeState = (overrides = {}) => ({
+ date: { appNow: new Date('2021-01-01T00:00:00.000Z') },
+ modal: { isOpen: false, id: null },
+ proj: { id: 'geographic' },
+ layers: { active: [] },
+ ...overrides,
+ });
+
+ beforeEach(() => {
+ getActiveLayers.mockReturnValue([visibleLayer]);
+ filterProjLayersWithStartDate.mockImplementation((layers) => layers);
+ });
+
+ it('maps appNow from date.appNow', () => {
+ const appNow = new Date('2021-06-01T00:00:00.000Z');
+ const result = capturedMapState(makeState({ date: { appNow } }));
+ expect(result.appNow).toBe(appNow);
+ });
+
+ it('maps projection from proj.id', () => {
+ const result = capturedMapState(makeState({ proj: { id: 'arctic' } }));
+ expect(result.projection).toBe('arctic');
+ });
+
+ it('maps activeLayers via getActiveLayers and filterProjLayersWithStartDate', () => {
+ const result = capturedMapState(makeState());
+ expect(result.activeLayers).toEqual([visibleLayer]);
+ });
+
+ it('isProductPickerOpen=true when modal is open with LAYER_PICKER_COMPONENT id', () => {
+ const result = capturedMapState(makeState({
+ modal: { isOpen: true, id: 'LAYER_PICKER_COMPONENT' },
+ }));
+ expect(result.isProductPickerOpen).toBe(true);
+ });
+
+ it('isProductPickerOpen=false when modal id does not match', () => {
+ const result = capturedMapState(makeState({
+ modal: { isOpen: true, id: 'OTHER_MODAL' },
+ }));
+ expect(result.isProductPickerOpen).toBe(false);
+ });
+ });
+
+ // ─── mapDispatchToProps ───────────────────────────────────────────────────
+
+ describe('mapDispatchToProps', () => {
+ it('onInfoClick dispatches toggleCustomContent with correct key', () => {
+ const dispatch = jest.fn();
+ const { onInfoClick } = capturedMapDispatch(dispatch);
+ onInfoClick();
+ expect(dispatch).toHaveBeenCalledWith(
+ expect.objectContaining({ type: 'TOGGLE_CUSTOM_CONTENT', key: 'TIMELINE_LAYER_COVERAGE_INFO_MODAL' }),
+ );
+ });
+
+ it('onInfoClick calls googleTagManager.pushEvent', () => {
+ const dispatch = jest.fn();
+ const { onInfoClick } = capturedMapDispatch(dispatch);
+ onInfoClick();
+ expect(googleTagManager.pushEvent).toHaveBeenCalledWith({ event: 'layer_coverage_panel_info' });
+ });
+
+ it('onInfoClick passes LayerCoverageInfoModal as bodyComponent', () => {
+ const dispatch = jest.fn();
+ const { onInfoClick } = capturedMapDispatch(dispatch);
+ onInfoClick();
+ const [, config] = toggleCustomContent.mock.calls[0];
+ expect(config.bodyComponent).toBeDefined();
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-draggers/dragger-container.test.js b/web/js/components/timeline/timeline-draggers/dragger-container.test.js
index 36d74cc38..97f06478e 100644
--- a/web/js/components/timeline/timeline-draggers/dragger-container.test.js
+++ b/web/js/components/timeline/timeline-draggers/dragger-container.test.js
@@ -1,3 +1,545 @@
-test('dragger-container component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+let mockCapturedDraggers = {};
+jest.mock('./timeline-dragger', () => function MockDragger(props) {
+ mockCapturedDraggers[props.draggerName] = props;
+ return <g data-testid={`dragger-${props.draggerName}`} />;
+});
+
+jest.mock('../date-util', () => ({
+ getISODateFormatted: jest.fn((date) => `${new Date(date).toISOString()
+ .split('.')[0]}Z`),
+ getIsBetween: jest.fn((date, front, back) => {
+ const d = new Date(date).getTime();
+ return d >= new Date(front).getTime() && d <= new Date(back).getTime();
+ }),
+}));
+
+jest.mock('../../../modules/date/constants', () => ({
+ timeScaleOptions: {
+ day: { timeAxis: { gridWidth: 12, scaleMs: 86400000 } },
+ month: { timeAxis: { gridWidth: 12, scaleMs: null } },
+ year: { timeAxis: { gridWidth: 18, scaleMs: null } },
+ // synthetic scale to exercise the neither-year-nor-month branch in handleDragDragger
+ decade: { timeAxis: { gridWidth: 36, scaleMs: null } },
+ },
+}));
+
+import DraggerContainer from './dragger-container';
+
+const defaultProps = {
+ axisWidth: 800,
+ backDate: '2020-12-31T00:00:00Z',
+ draggerPosition: 100,
+ draggerPositionB: 200,
+ draggerSelected: 'selected',
+ draggerTimeState: '2020-06-01T00:00:00Z',
+ draggerTimeStateB: '2020-09-01T00:00:00Z',
+ draggerVisible: true,
+ draggerVisibleB: true,
+ frontDate: '2020-01-01T00:00:00Z',
+ isCompareModeActive: false,
+ isDraggerDragging: false,
+ onChangeSelectedDragger: jest.fn(),
+ position: 0,
+ setDraggerVisibility: jest.fn(),
+ timelineEndDateLimit: '2021-01-01T00:00:00Z',
+ timelineStartDateLimit: '2019-01-01T00:00:00Z',
+ timeScale: 'day',
+ toggleShowDraggerTime: jest.fn(),
+ transformX: 0,
+ updateDraggerDatePosition: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <DraggerContainer {...defaultProps} {...props} />,
+);
+
+describe('DraggerContainer', () => {
+ beforeEach(() => {
+ mockCapturedDraggers = {};
+ jest.clearAllMocks();
+ global.requestAnimationFrame = jest.fn((cb) => { cb(); });
+ });
+
+ describe('render — draggerSelected = selected', () => {
+ it('renders an svg.dragger-container with the correct axis width', () => {
+ const { container } = renderComponent();
+ const svg = container.querySelector('svg.dragger-container');
+ expect(svg).toBeInTheDocument();
+ expect(svg.getAttribute('width')).toBe('800');
+ });
+
+ it('renders only the A dragger when compare mode is off', () => {
+ const { getByTestId, queryByTestId } = renderComponent();
+ expect(getByTestId('dragger-selected')).toBeInTheDocument();
+ expect(queryByTestId('dragger-selectedB')).not.toBeInTheDocument();
+ });
+
+ it('renders both draggers when compare mode is on: A enabled, B disabled', () => {
+ renderComponent({ isCompareModeActive: true });
+ expect(mockCapturedDraggers['selected'].disabled).toBe(false);
+ expect(mockCapturedDraggers['selectedB'].disabled).toBe(true);
+ });
+
+ it('clipPath A width is Math.max(49, 49 + draggerPosition) for positive position', () => {
+ const { container } = renderComponent({ draggerPosition: 100 });
+ const clipA = container.querySelector('#selectedDraggerClipA rect');
+ expect(clipA.getAttribute('width')).toBe('149');
+ });
+
+ it('clipPath A width clamps to 49 when draggerPosition is very negative', () => {
+ const { container } = renderComponent({ draggerPosition: -200 });
+ const clipA = container.querySelector('#selectedDraggerClipA rect');
+ expect(clipA.getAttribute('width')).toBe('49');
+ });
+
+ it('clipPath B width is Math.max(49, 49 + draggerPositionB)', () => {
+ const { container } = renderComponent({ draggerPositionB: 200 });
+ const clipB = container.querySelector('#selectedDraggerClipB rect');
+ expect(clipB.getAttribute('width')).toBe('249');
+ });
+
+ it('passes correct props to the A dragger', () => {
+ renderComponent({ draggerPosition: 50, draggerVisible: false });
+ expect(mockCapturedDraggers['selected'].draggerPosition).toBe(50);
+ expect(mockCapturedDraggers['selected'].draggerVisible).toBe(false);
+ expect(mockCapturedDraggers['selected'].draggerName).toBe('selected');
+ });
+ });
+
+ describe('render — draggerSelected = selectedB', () => {
+ it('renders only the B dragger when compare mode is off', () => {
+ const { getByTestId, queryByTestId } = renderComponent({ draggerSelected: 'selectedB' });
+ expect(getByTestId('dragger-selectedB')).toBeInTheDocument();
+ expect(queryByTestId('dragger-selected')).not.toBeInTheDocument();
+ });
+
+ it('renders both draggers when compare mode is on: B enabled, A disabled', () => {
+ renderComponent({ draggerSelected: 'selectedB', isCompareModeActive: true });
+ expect(mockCapturedDraggers['selectedB'].disabled).toBe(false);
+ expect(mockCapturedDraggers['selected'].disabled).toBe(true);
+ });
+
+ it('passes correct props to the B dragger', () => {
+ renderComponent({ draggerSelected: 'selectedB', draggerPositionB: 150, draggerVisibleB: false });
+ expect(mockCapturedDraggers['selectedB'].draggerPosition).toBe(150);
+ expect(mockCapturedDraggers['selectedB'].draggerVisible).toBe(false);
+ });
+ });
+
+ describe('componentDidUpdate — compare mode change', () => {
+ it('calls setDraggerVisibility(true, true) when compare mode activates', () => {
+ const setDraggerVisibility = jest.fn();
+ const { rerender } = renderComponent({ setDraggerVisibility, isCompareModeActive: false });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ setDraggerVisibility={setDraggerVisibility}
+ isCompareModeActive
+ />,
+ );
+ });
+ expect(setDraggerVisibility).toHaveBeenCalledWith(true, true);
+ });
+
+ it('calls setDraggerVisibility(true, false) when compare mode deactivates with draggerSelected=selected', () => {
+ const setDraggerVisibility = jest.fn();
+ const { rerender } = renderComponent({
+ setDraggerVisibility, isCompareModeActive: true, draggerSelected: 'selected',
+ });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ setDraggerVisibility={setDraggerVisibility}
+ isCompareModeActive={false}
+ draggerSelected="selected"
+ />,
+ );
+ });
+ expect(setDraggerVisibility).toHaveBeenCalledWith(true, false);
+ });
+
+ it('calls setDraggerVisibility(false, true) when compare mode deactivates with draggerSelected=selectedB', () => {
+ const setDraggerVisibility = jest.fn();
+ const { rerender } = renderComponent({
+ setDraggerVisibility, isCompareModeActive: true, draggerSelected: 'selectedB',
+ });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ setDraggerVisibility={setDraggerVisibility}
+ isCompareModeActive={false}
+ draggerSelected="selectedB"
+ />,
+ );
+ });
+ expect(setDraggerVisibility).toHaveBeenCalledWith(false, true);
+ });
+
+ it('does not call setDraggerVisibility when compare mode does not change', () => {
+ const setDraggerVisibility = jest.fn();
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({ setDraggerVisibility, updateDraggerDatePosition });
+ setDraggerVisibility.mockClear();
+ updateDraggerDatePosition.mockClear();
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ setDraggerVisibility={setDraggerVisibility}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ axisWidth={900}
+ />,
+ );
+ });
+ expect(setDraggerVisibility).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('componentDidUpdate — dragger time state changes', () => {
+ it('calls updateDraggerDatePosition for A when draggerTimeState changes and selected=selected', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({ updateDraggerDatePosition, draggerSelected: 'selected' });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ draggerSelected="selected"
+ draggerTimeState="2020-07-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selected', expect.any(Number), expect.any(Boolean));
+ });
+
+ it('calls updateDraggerDatePosition for A when isCompareModeActive=true and draggerTimeState changes', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({
+ updateDraggerDatePosition, isCompareModeActive: true, draggerSelected: 'selectedB',
+ });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ isCompareModeActive
+ draggerSelected="selectedB"
+ draggerTimeState="2020-07-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selected', expect.any(Number), expect.any(Boolean));
+ });
+
+ it('calls updateDraggerDatePosition for B when draggerTimeStateB changes and selected=selectedB', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({ updateDraggerDatePosition, draggerSelected: 'selectedB' });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ draggerSelected="selectedB"
+ draggerTimeStateB="2020-10-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selectedB', expect.any(Number), expect.any(Boolean));
+ });
+
+ it('calls updateDraggerDatePosition for B when isCompareModeActive=true and draggerTimeStateB changes', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({
+ updateDraggerDatePosition, isCompareModeActive: true, draggerSelected: 'selected',
+ });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ isCompareModeActive
+ draggerSelected="selected"
+ draggerTimeStateB="2020-10-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selectedB', expect.any(Number), expect.any(Boolean));
+ });
+
+ it('does not update position when isDraggerDragging=true', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({ updateDraggerDatePosition, isDraggerDragging: true });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ isDraggerDragging
+ draggerTimeState="2020-07-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).not.toHaveBeenCalled();
+ });
+
+ it('does not update A when draggerTimeState changes but draggerSelected=selectedB and compare mode is off', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({
+ updateDraggerDatePosition, draggerSelected: 'selectedB', isCompareModeActive: false,
+ });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ draggerSelected="selectedB"
+ isCompareModeActive={false}
+ draggerTimeState="2020-07-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('setDraggerPosition', () => {
+ it('reports draggerVisible=true when inputTime is between frontDate and backDate', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({ updateDraggerDatePosition });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ draggerTimeState="2020-07-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selected', expect.any(Number), true);
+ });
+
+ it('uses oldDraggerPosition when inputTime is before frontDate', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({ updateDraggerDatePosition, draggerPosition: 100 });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ draggerPosition={100}
+ draggerTimeState="2019-01-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selected', 100, false);
+ });
+
+ it('uses oldDraggerPosition when inputTime is after backDate', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({ updateDraggerDatePosition, draggerPosition: 100 });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ draggerPosition={100}
+ draggerTimeState="2022-01-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selected', 100, false);
+ });
+
+ it('uses oldDraggerPosition when newDraggerPosition exceeds endDatePosition', () => {
+ const updateDraggerDatePosition = jest.fn();
+ // timelineEndDateLimit just 1 day after frontDate makes endDatePosition very small
+ const { rerender } = renderComponent({
+ updateDraggerDatePosition,
+ draggerPosition: 100,
+ timelineEndDateLimit: '2020-01-02T00:00:00Z',
+ });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ draggerPosition={100}
+ timelineEndDateLimit="2020-01-02T00:00:00Z"
+ draggerTimeState="2020-12-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selected', 100, expect.any(Boolean));
+ });
+
+ it('uses draggerPositionB and selectedB for isDraggerB=true', () => {
+ const updateDraggerDatePosition = jest.fn();
+ const { rerender } = renderComponent({
+ updateDraggerDatePosition, draggerSelected: 'selectedB', draggerPositionB: 200,
+ });
+ act(() => {
+ rerender(
+ <DraggerContainer
+ {...defaultProps}
+ updateDraggerDatePosition={updateDraggerDatePosition}
+ draggerSelected="selectedB"
+ draggerPositionB={200}
+ draggerTimeStateB="2020-10-01T00:00:00Z"
+ />,
+ );
+ });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(null, 'selectedB', expect.any(Number), expect.any(Boolean));
+ });
+ });
+
+ describe('selectDragger', () => {
+ it('calls onChangeSelectedDragger when a different dragger name is selected', () => {
+ const onChangeSelectedDragger = jest.fn();
+ renderComponent({ onChangeSelectedDragger, draggerSelected: 'selected' });
+ mockCapturedDraggers['selected'].selectDragger('selectedB', null);
+ expect(onChangeSelectedDragger).toHaveBeenCalledWith('selectedB');
+ });
+
+ it('does not call onChangeSelectedDragger when the same dragger is clicked', () => {
+ const onChangeSelectedDragger = jest.fn();
+ renderComponent({ onChangeSelectedDragger, draggerSelected: 'selected' });
+ mockCapturedDraggers['selected'].selectDragger('selected', null);
+ expect(onChangeSelectedDragger).not.toHaveBeenCalled();
+ });
+
+ it('calls e.stopPropagation and e.preventDefault when event is provided', () => {
+ const onChangeSelectedDragger = jest.fn();
+ renderComponent({ onChangeSelectedDragger, draggerSelected: 'selected' });
+ const e = { stopPropagation: jest.fn(), preventDefault: jest.fn() };
+ mockCapturedDraggers['selected'].selectDragger('selectedB', e);
+ expect(e.stopPropagation).toHaveBeenCalled();
+ expect(e.preventDefault).toHaveBeenCalled();
+ });
+
+ it('does not throw when event is null', () => {
+ renderComponent();
+ expect(() => mockCapturedDraggers['selected'].selectDragger('selectedB', null)).not.toThrow();
+ });
+ });
+
+ describe('handleDragDragger', () => {
+ it('returns without updating when deltaX is 0', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({ updateDraggerDatePosition });
+ mockCapturedDraggers['selected'].handleDragDragger(null, { deltaX: 0 });
+ expect(updateDraggerDatePosition).not.toHaveBeenCalled();
+ });
+
+ it('calls e.stopPropagation and e.preventDefault when event is provided', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({ updateDraggerDatePosition });
+ const e = { stopPropagation: jest.fn(), preventDefault: jest.fn() };
+ mockCapturedDraggers['selected'].handleDragDragger(e, { deltaX: 0 });
+ expect(e.stopPropagation).toHaveBeenCalled();
+ expect(e.preventDefault).toHaveBeenCalled();
+ });
+
+ it('updates A dragger position with day scale (scaleMs path)', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({ updateDraggerDatePosition, draggerSelected: 'selected', draggerPosition: 100 });
+ mockCapturedDraggers['selected'].handleDragDragger(null, { deltaX: 5 });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(
+ expect.any(String), 'selected', 105, null, null, true,
+ );
+ });
+
+ it('updates B dragger position with day scale', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({
+ updateDraggerDatePosition, draggerSelected: 'selectedB', draggerPositionB: 200,
+ });
+ mockCapturedDraggers['selectedB'].handleDragDragger(null, { deltaX: 10 });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(
+ expect.any(String), 'selectedB', 210, null, null, true,
+ );
+ });
+
+ it('clamps to timelineEndDateLimit when dragged past the end', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({ updateDraggerDatePosition });
+ mockCapturedDraggers['selected'].handleDragDragger(null, { deltaX: 9999999 });
+ expect(updateDraggerDatePosition).toHaveBeenCalledWith(
+ '2021-01-01T00:00:00Z',
+ 'selected',
+ expect.any(Number),
+ null,
+ null,
+ true,
+ );
+ });
+
+ it('returns false without updating when dragged before timelineStartDateLimit', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({ updateDraggerDatePosition });
+ mockCapturedDraggers['selected'].handleDragDragger(null, { deltaX: -9999999 });
+ expect(updateDraggerDatePosition).not.toHaveBeenCalled();
+ });
+
+ it('uses month scale complex path (no scaleMs, daysInMonth)', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({ updateDraggerDatePosition, timeScale: 'month', draggerSelected: 'selected', draggerPosition: 100 });
+ mockCapturedDraggers['selected'].handleDragDragger(null, { deltaX: 1 });
+ expect(updateDraggerDatePosition).toHaveBeenCalled();
+ });
+
+ it('uses year scale complex path with leap year (daysCount=366)', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({
+ updateDraggerDatePosition,
+ timeScale: 'year',
+ draggerSelected: 'selected',
+ draggerPosition: 0,
+ position: 40,
+ frontDate: '2020-01-01T00:00:00Z',
+ backDate: '2025-12-31T00:00:00Z',
+ timelineEndDateLimit: '2025-01-01T00:00:00Z',
+ });
+ mockCapturedDraggers['selected'].handleDragDragger(null, { deltaX: 1 });
+ expect(updateDraggerDatePosition).toHaveBeenCalled();
+ });
+
+ it('uses year scale complex path with non-leap year (daysCount=365)', () => {
+ const updateDraggerDatePosition = jest.fn();
+ // frontDate 2021, gridWidth=18: floor(48/18)=2 → add(2,'year') = 2023 (non-leap)
+ renderComponent({
+ updateDraggerDatePosition,
+ timeScale: 'year',
+ draggerSelected: 'selected',
+ draggerPosition: 0,
+ frontDate: '2021-01-01T00:00:00Z',
+ draggerTimeState: '2022-06-01T00:00:00Z',
+ backDate: '2030-12-31T00:00:00Z',
+ timelineEndDateLimit: '2030-01-01T00:00:00Z',
+ });
+ mockCapturedDraggers['selected'].handleDragDragger(null, { deltaX: 1 });
+ expect(updateDraggerDatePosition).toHaveBeenCalled();
+ });
+
+ it('handles neither-year-nor-month scale with null scaleMs (implicit else, daysCount undefined)', () => {
+ const updateDraggerDatePosition = jest.fn();
+ renderComponent({
+ updateDraggerDatePosition,
+ timeScale: 'decade',
+ draggerSelected: 'selected',
+ draggerPosition: 0,
+ });
+ expect(() => {
+ mockCapturedDraggers['selected'].handleDragDragger(null, { deltaX: 1 });
+ }).not.toThrow();
+ expect(updateDraggerDatePosition).toHaveBeenCalled();
+ });
+ });
});
diff --git a/web/js/components/timeline/timeline-draggers/timeline-dragger.test.js b/web/js/components/timeline/timeline-draggers/timeline-dragger.test.js
index 8f120f388..00770de93 100644
--- a/web/js/components/timeline/timeline-draggers/timeline-dragger.test.js
+++ b/web/js/components/timeline/timeline-draggers/timeline-dragger.test.js
@@ -1,3 +1,303 @@
-test('timeline-dragger component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, act } from '@testing-library/react';
+import { fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Dragger from './timeline-dragger';
+let mockDraggableProps = {};
+
+jest.mock('react-draggable', () => function MockDraggable(props) {
+ mockDraggableProps = props;
+ return props.children;
+});
+
+const defaultProps = {
+ axisWidth: 800,
+ disabled: false,
+ draggerName: 'selected',
+ draggerPosition: 100,
+ draggerVisible: true,
+ handleDragDragger: jest.fn(),
+ isCompareModeActive: false,
+ selectDragger: jest.fn(),
+ toggleShowDraggerTime: jest.fn(),
+ transformX: 0,
+};
+
+const renderComponent = (props = {}) => render(
+ <svg>
+ <Dragger {...defaultProps} {...props} />
+ </svg>,
+);
+
+beforeEach(() => {
+ mockDraggableProps = {};
+ jest.clearAllMocks();
+});
+
+describe('Dragger', () => {
+ describe('render — visibility', () => {
+ it('returns null when draggerVisible is false', () => {
+ const { container } = renderComponent({ draggerVisible: false });
+ expect(container.querySelector('.timeline-dragger')).not.toBeInTheDocument();
+ });
+
+ it('renders when draggerVisible is true', () => {
+ const { container } = renderComponent({ draggerVisible: true });
+ expect(container.querySelector('.timeline-dragger')).toBeInTheDocument();
+ });
+ });
+
+ describe('render — dragger name and letter', () => {
+ it('renders draggerA class and letter A for draggerName="selected"', () => {
+ const { container } = renderComponent({ draggerName: 'selected', isCompareModeActive: true });
+ expect(container.querySelector('.draggerA')).toBeInTheDocument();
+ expect(container.querySelector('text').textContent).toBe('A');
+ });
+
+ it('renders draggerB class and letter B for draggerName="selectedB"', () => {
+ const { container } = renderComponent({ draggerName: 'selectedB', isCompareModeActive: true });
+ expect(container.querySelector('.draggerB')).toBeInTheDocument();
+ expect(container.querySelector('text').textContent).toBe('B');
+ });
+ });
+
+ describe('render — compare mode content', () => {
+ it('renders a text element when isCompareModeActive=true', () => {
+ const { container } = renderComponent({ isCompareModeActive: true });
+ expect(container.querySelector('text')).toBeInTheDocument();
+ expect(container.querySelectorAll('rect[pointer-events="none"]')).toHaveLength(0);
+ });
+
+ it('renders 3 rects when isCompareModeActive=false', () => {
+ const { container } = renderComponent({ isCompareModeActive: false });
+ expect(container.querySelector('text')).not.toBeInTheDocument();
+ expect(container.querySelectorAll('rect[pointer-events="none"]')).toHaveLength(3);
+ });
+ });
+
+ describe('render — text fill in compare mode', () => {
+ it('text fill is #ccc when disabled=true', () => {
+ const { container } = renderComponent({ isCompareModeActive: true, disabled: true });
+ expect(container.querySelector('text').getAttribute('fill')).toBe('#ccc');
+ });
+
+ it('text fill is #000 when disabled=false', () => {
+ const { container } = renderComponent({ isCompareModeActive: true, disabled: false });
+ expect(container.querySelector('text').getAttribute('fill')).toBe('#000');
+ });
+ });
+
+ describe('render — Draggable props', () => {
+ it('Draggable position.x is draggerPosition + 25', () => {
+ renderComponent({ draggerPosition: 100 });
+ expect(mockDraggableProps.position).toEqual({ x: 125, y: 0 });
+ });
+
+ it('Draggable disabled=true is forwarded', () => {
+ renderComponent({ disabled: true });
+ expect(mockDraggableProps.disabled).toBe(true);
+ });
+
+ it('Draggable disabled=false is forwarded', () => {
+ renderComponent({ disabled: false });
+ expect(mockDraggableProps.disabled).toBe(false);
+ });
+ });
+
+ describe('render — g element attributes', () => {
+ it('g has transform derived from transformX', () => {
+ const { container } = renderComponent({ transformX: 42 });
+ expect(container.querySelector('.timeline-dragger').getAttribute('transform')).toBe('translate(42)');
+ });
+
+ it('g clipPath is selectedDraggerClipA for dragger A', () => {
+ const { container } = renderComponent({ draggerName: 'selected' });
+ expect(container.querySelector('.timeline-dragger').getAttribute('clip-path')).toBe('url(#selectedDraggerClipA)');
+ });
+
+ it('g clipPath is selectedDraggerClipB for dragger B', () => {
+ const { container } = renderComponent({ draggerName: 'selectedB' });
+ expect(container.querySelector('.timeline-dragger').getAttribute('clip-path')).toBe('url(#selectedDraggerClipB)');
+ });
+ });
+
+ describe('draggerFill (path fill) — not hovered', () => {
+ it('disabled=true, not hovered → #666666', () => {
+ const { container } = renderComponent({ disabled: true });
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#666666');
+ });
+
+ it('disabled=false, not hovered → #ccc', () => {
+ const { container } = renderComponent({ disabled: false });
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#ccc');
+ });
+ });
+
+ describe('draggerFill (path fill) — hovered via mouseEnter', () => {
+ it('disabled=false, hovered, isCompareModeActive=true → #a3a3a3', () => {
+ const { container } = renderComponent({ disabled: false, isCompareModeActive: true });
+ act(() => {
+ fireEvent.mouseEnter(container.querySelector('.timeline-dragger'));
+ });
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#a3a3a3');
+ });
+
+ it('disabled=false, hovered, isCompareModeActive=false → #8e8e8e', () => {
+ const { container } = renderComponent({ disabled: false, isCompareModeActive: false });
+ act(() => {
+ fireEvent.mouseEnter(container.querySelector('.timeline-dragger'));
+ });
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#8e8e8e');
+ });
+
+ it('disabled=true, hovered → #8e8e8e', () => {
+ const { container } = renderComponent({ disabled: true });
+ act(() => {
+ fireEvent.mouseEnter(container.querySelector('.timeline-dragger'));
+ });
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#8e8e8e');
+ });
+ });
+
+ describe('draggerStroke and draggerRectFill', () => {
+ it('not hovered → path stroke #333, rect fill #515151', () => {
+ const { container } = renderComponent({ isCompareModeActive: false });
+ expect(container.querySelector('path').getAttribute('stroke')).toBe('#333');
+ expect(container.querySelectorAll('rect[pointer-events="none"]')[0].getAttribute('fill')).toBe('#515151');
+ });
+
+ it('hovered → path stroke #ccc, rect fill #ccc', () => {
+ const { container } = renderComponent({ isCompareModeActive: false });
+ act(() => {
+ fireEvent.mouseEnter(container.querySelector('.timeline-dragger'));
+ });
+ expect(container.querySelector('path').getAttribute('stroke')).toBe('#ccc');
+ expect(container.querySelectorAll('rect[pointer-events="none"]')[0].getAttribute('fill')).toBe('#ccc');
+ });
+ });
+
+ describe('handleHoverMouseEnter / handleHoverMouseLeave', () => {
+ it('mouseEnter sets isHoveredDrag=true — fill shifts to hovered value', () => {
+ const { container } = renderComponent({ disabled: false, isCompareModeActive: false });
+ act(() => {
+ fireEvent.mouseEnter(container.querySelector('.timeline-dragger'));
+ });
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#8e8e8e');
+ });
+
+ it('mouseLeave after mouseEnter restores fill to non-hovered value', () => {
+ const { container } = renderComponent({ disabled: false });
+ const g = container.querySelector('.timeline-dragger');
+ act(() => { fireEvent.mouseEnter(g); });
+ act(() => { fireEvent.mouseLeave(g); });
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#ccc');
+ });
+ });
+
+ describe('selectDragger', () => {
+ it('calls props.selectDragger with draggerName "selected" and event on mouseDown', () => {
+ const selectDragger = jest.fn();
+ renderComponent({ selectDragger, draggerName: 'selected' });
+ const fakeEvent = { type: 'mousedown' };
+ act(() => { mockDraggableProps.onMouseDown(fakeEvent); });
+ expect(selectDragger).toHaveBeenCalledWith('selected', fakeEvent);
+ });
+
+ it('calls props.selectDragger with draggerName "selectedB" for dragger B', () => {
+ const selectDragger = jest.fn();
+ renderComponent({ selectDragger, draggerName: 'selectedB' });
+ const fakeEvent = {};
+ act(() => { mockDraggableProps.onMouseDown(fakeEvent); });
+ expect(selectDragger).toHaveBeenCalledWith('selectedB', fakeEvent);
+ });
+ });
+
+ describe('startShowDraggerTime / stopShowDraggerTime', () => {
+ it('onStart calls toggleShowDraggerTime(true)', () => {
+ const toggleShowDraggerTime = jest.fn();
+ renderComponent({ toggleShowDraggerTime });
+ act(() => { mockDraggableProps.onStart(); });
+ expect(toggleShowDraggerTime).toHaveBeenCalledWith(true);
+ });
+
+ it('onStop calls toggleShowDraggerTime(false)', () => {
+ const toggleShowDraggerTime = jest.fn();
+ renderComponent({ toggleShowDraggerTime });
+ act(() => { mockDraggableProps.onStop(); });
+ expect(toggleShowDraggerTime).toHaveBeenCalledWith(false);
+ });
+
+ it('onStop sets isHoveredDragging=false — fill returns to non-hovered value', () => {
+ const { container } = renderComponent({ disabled: false, isCompareModeActive: false });
+ // Set isHoveredDragging=true via onDrag
+ act(() => { mockDraggableProps.onDrag(null, { deltaX: 0, x: 50 }); });
+ // onStop clears it
+ act(() => { mockDraggableProps.onStop(); });
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#ccc');
+ });
+ });
+
+ describe('handleDragDragger', () => {
+ it('always sets isHoveredDragging=true when drag fires', () => {
+ const { container } = renderComponent({ disabled: false, isCompareModeActive: false });
+ act(() => { mockDraggableProps.onDrag(null, { deltaX: 0, x: 50 }); });
+ // isHoveredDragging=true → isHovered=true → fill shifts
+ expect(container.querySelector('path').getAttribute('fill')).toBe('#8e8e8e');
+ });
+
+ it('calls prop handleDragDragger when dragger is left of axis buffer (draggerPosition <= -15)', () => {
+ const handleDragDragger = jest.fn();
+ // -20 <= -15 → isDraggerLeftOfAxisBuffer=true
+ renderComponent({ draggerPosition: -20, handleDragDragger });
+ act(() => { mockDraggableProps.onDrag(null, { deltaX: 5, x: 0 }); });
+ expect(handleDragDragger).toHaveBeenCalled();
+ });
+
+ it('calls prop handleDragDragger when dragger is right of axis buffer (draggerPosition + 85 >= axisWidth)', () => {
+ const handleDragDragger = jest.fn();
+ // 715 + 85 = 800 >= 800 → isDraggerRightOfAxisBuffer=true
+ renderComponent({ draggerPosition: 715, axisWidth: 800, handleDragDragger });
+ act(() => { mockDraggableProps.onDrag(null, { deltaX: 5, x: 0 }); });
+ expect(handleDragDragger).toHaveBeenCalled();
+ });
+
+ it('returns false when deltaX<0 and dragger x is at axis start (x <= -15)', () => {
+ const handleDragDragger = jest.fn();
+ // draggerPosition=100 → not in any buffer zone
+ renderComponent({ draggerPosition: 100, handleDragDragger });
+ let result;
+ act(() => {
+ result = mockDraggableProps.onDrag(null, { deltaX: -5, x: -20 });
+ });
+ expect(result).toBe(false);
+ expect(handleDragDragger).not.toHaveBeenCalled();
+ });
+
+ it('returns false when deltaX>0 and dragger x is at axis end (x + 36 >= axisWidth)', () => {
+ const handleDragDragger = jest.fn();
+ renderComponent({ draggerPosition: 100, axisWidth: 800, handleDragDragger });
+ let result;
+ act(() => {
+ // 800 + 36 = 836 >= 800
+ result = mockDraggableProps.onDrag(null, { deltaX: 5, x: 800 });
+ });
+ expect(result).toBe(false);
+ expect(handleDragDragger).not.toHaveBeenCalled();
+ });
+
+ it('calls prop handleDragDragger once for normal rightward drag (no buffer, no edge)', () => {
+ const handleDragDragger = jest.fn();
+ renderComponent({ draggerPosition: 100, axisWidth: 800, handleDragDragger });
+ act(() => { mockDraggableProps.onDrag(null, { deltaX: 5, x: 50 }); });
+ expect(handleDragDragger).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls prop handleDragDragger once for normal leftward drag (not at start)', () => {
+ const handleDragDragger = jest.fn();
+ renderComponent({ draggerPosition: 100, axisWidth: 800, handleDragDragger });
+ act(() => { mockDraggableProps.onDrag(null, { deltaX: -5, x: 50 }); });
+ expect(handleDragDragger).toHaveBeenCalledTimes(1);
+ });
+ });
});
diff --git a/web/js/components/toolbar/share/tooltips.test.js b/web/js/components/toolbar/share/tooltips.test.js
index 2d54dbd00..31bd746de 100644
--- a/web/js/components/toolbar/share/tooltips.test.js
+++ b/web/js/components/toolbar/share/tooltips.test.js
@@ -1,3 +1,187 @@
-test('tooltips component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, act, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import ShareToolTips from './tooltips';
+jest.mock('reactstrap', () => ({
+ Tooltip: ({ children, isOpen }) => (isOpen ? <div data-testid="tooltip">{children}</div> : null),
+}));
+
+const defaultProps = {
+ activeTab: 'link',
+ tooltipToggleTime: 0,
+ tooltipErrorTime: 0,
+};
+
+const renderComponent = (props = {}) => render(
+ <ShareToolTips {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.useFakeTimers();
+});
+
+afterEach(() => {
+ jest.runAllTimers();
+ jest.useRealTimers();
+});
+
+describe('ShareToolTips', () => {
+ describe('initial render', () => {
+ it('renders without any tooltips visible', () => {
+ renderComponent();
+ expect(screen.queryByText('Copied!')).not.toBeInTheDocument();
+ expect(screen.queryByText('Link cannot be shortened at this time.')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('componentDidUpdate — tooltipToggleTime changes', () => {
+ it('shows the "Copied!" tooltip when tooltipToggleTime changes', () => {
+ const { rerender } = renderComponent({ tooltipToggleTime: 1 });
+ act(() => {
+ rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} />);
+ });
+ expect(screen.getByText('Copied!')).toBeInTheDocument();
+ expect(screen.queryByText('Link cannot be shortened at this time.')).not.toBeInTheDocument();
+ });
+
+ it('auto-dismisses "Copied!" after 2000ms', () => {
+ const { rerender } = renderComponent({ tooltipToggleTime: 1 });
+ act(() => {
+ rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} />);
+ });
+ expect(screen.getByText('Copied!')).toBeInTheDocument();
+ act(() => { jest.advanceTimersByTime(2000); });
+ expect(screen.queryByText('Copied!')).not.toBeInTheDocument();
+ });
+
+ it('resets the dismiss timer when tooltipToggleTime changes again while showing', () => {
+ const { rerender } = renderComponent({ tooltipToggleTime: 1 });
+ // First toggle — starts 2000ms timer
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} />); });
+ // Advance 1500ms (not yet dismissed)
+ act(() => { jest.advanceTimersByTime(1500); });
+ expect(screen.getByText('Copied!')).toBeInTheDocument();
+ // Second toggle — resets timer
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={3} />); });
+ // Advance 1500ms more (3000ms total, but only 1500ms from second toggle)
+ act(() => { jest.advanceTimersByTime(1500); });
+ expect(screen.getByText('Copied!')).toBeInTheDocument();
+ // Advance the remaining 500ms to complete the second 2000ms window
+ act(() => { jest.advanceTimersByTime(500); });
+ expect(screen.queryByText('Copied!')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('componentDidUpdate — tooltipErrorTime changes', () => {
+ it('shows the error tooltip when tooltipErrorTime changes', () => {
+ const { rerender } = renderComponent({ tooltipErrorTime: 1 });
+ act(() => {
+ rerender(<ShareToolTips {...defaultProps} tooltipErrorTime={2} />);
+ });
+ expect(screen.getByText('Link cannot be shortened at this time.')).toBeInTheDocument();
+ expect(screen.queryByText('Copied!')).not.toBeInTheDocument();
+ });
+
+ it('auto-dismisses the error tooltip after 2000ms', () => {
+ const { rerender } = renderComponent({ tooltipErrorTime: 1 });
+ act(() => {
+ rerender(<ShareToolTips {...defaultProps} tooltipErrorTime={2} />);
+ });
+ expect(screen.getByText('Link cannot be shortened at this time.')).toBeInTheDocument();
+ act(() => { jest.advanceTimersByTime(2000); });
+ expect(screen.queryByText('Link cannot be shortened at this time.')).not.toBeInTheDocument();
+ });
+
+ it('resets the error dismiss timer when tooltipErrorTime changes again while showing', () => {
+ const { rerender } = renderComponent({ tooltipErrorTime: 1 });
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipErrorTime={2} />); });
+ act(() => { jest.advanceTimersByTime(1500); });
+ // Still showing — not yet 2000ms
+ expect(screen.getByText('Link cannot be shortened at this time.')).toBeInTheDocument();
+ // Trigger again — resets timer
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipErrorTime={3} />); });
+ act(() => { jest.advanceTimersByTime(1500); });
+ // Only 1500ms since reset — still showing
+ expect(screen.getByText('Link cannot be shortened at this time.')).toBeInTheDocument();
+ act(() => { jest.advanceTimersByTime(500); });
+ expect(screen.queryByText('Link cannot be shortened at this time.')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('componentDidUpdate — both tooltipToggleTime and tooltipErrorTime change', () => {
+ it('shows both tooltips simultaneously when both props change', () => {
+ const { rerender } = renderComponent({ tooltipToggleTime: 1, tooltipErrorTime: 1 });
+ act(() => {
+ rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} tooltipErrorTime={2} />);
+ });
+ expect(screen.getByText('Copied!')).toBeInTheDocument();
+ expect(screen.getByText('Link cannot be shortened at this time.')).toBeInTheDocument();
+ });
+
+ it('dismisses both tooltips independently after 2000ms', () => {
+ const { rerender } = renderComponent({ tooltipToggleTime: 1, tooltipErrorTime: 1 });
+ act(() => {
+ rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} tooltipErrorTime={2} />);
+ });
+ act(() => { jest.advanceTimersByTime(2000); });
+ expect(screen.queryByText('Copied!')).not.toBeInTheDocument();
+ expect(screen.queryByText('Link cannot be shortened at this time.')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('componentDidUpdate — activeTab changes', () => {
+ it('hides the copied tooltip immediately when activeTab changes', () => {
+ const { rerender } = renderComponent({ tooltipToggleTime: 1 });
+ // Show the tooltip first
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} />); });
+ expect(screen.getByText('Copied!')).toBeInTheDocument();
+ // Change the active tab — should hide all tooltips
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} activeTab="short" />); });
+ expect(screen.queryByText('Copied!')).not.toBeInTheDocument();
+ });
+
+ it('hides the error tooltip immediately when activeTab changes', () => {
+ const { rerender } = renderComponent({ tooltipErrorTime: 1 });
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipErrorTime={2} />); });
+ expect(screen.getByText('Link cannot be shortened at this time.')).toBeInTheDocument();
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipErrorTime={2} activeTab="short" />); });
+ expect(screen.queryByText('Link cannot be shortened at this time.')).not.toBeInTheDocument();
+ });
+
+ it('cancels pending dismiss timers when activeTab changes', () => {
+ const { rerender } = renderComponent({ tooltipToggleTime: 1 });
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} />); });
+ // Tab change clears timers
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} activeTab="short" />); });
+ // Even after 2000ms, no spurious state updates (both already false)
+ act(() => { jest.advanceTimersByTime(2000); });
+ expect(screen.queryByText('Copied!')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('componentWillUnmount', () => {
+ it('clears pending timeouts on unmount without errors', () => {
+ const { rerender, unmount } = renderComponent({ tooltipToggleTime: 1 });
+ // Open tooltip — starts a 2000ms dismiss timer
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipToggleTime={2} />); });
+ expect(screen.getByText('Copied!')).toBeInTheDocument();
+ // Unmount before timer fires — should clear timeout, no setState on unmounted component
+ expect(() => {
+ act(() => { unmount(); });
+ act(() => { jest.runAllTimers(); });
+ }).not.toThrow();
+ });
+
+ it('clears error tooltip timeout on unmount', () => {
+ const { rerender, unmount } = renderComponent({ tooltipErrorTime: 1 });
+ act(() => { rerender(<ShareToolTips {...defaultProps} tooltipErrorTime={2} />); });
+ expect(screen.getByText('Link cannot be shortened at this time.')).toBeInTheDocument();
+ expect(() => {
+ act(() => { unmount(); });
+ act(() => { jest.runAllTimers(); });
+ }).not.toThrow();
+ });
+ });
});
diff --git a/web/js/components/tooltip/tooltip.test.js b/web/js/components/tooltip/tooltip.test.js
index dcf728a69..3a3fc2247 100644
--- a/web/js/components/tooltip/tooltip.test.js
+++ b/web/js/components/tooltip/tooltip.test.js
@@ -1,3 +1,129 @@
-test('tooltip component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, act, fireEvent, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Tooltip from './tooltip';
+const defaultProps = {
+ text: 'Hover me',
+ dataArray: ['Option A', 'Option B', 'Option C'],
+ onClick: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <Tooltip {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('Tooltip', () => {
+ describe('initial render', () => {
+ it('renders the text span', () => {
+ renderComponent();
+ expect(screen.getByText('Hover me')).toBeInTheDocument();
+ });
+
+ it('renders the wv-tooltip-case container', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.wv-tooltip-case')).toBeInTheDocument();
+ });
+
+ it('renders the wv-tooltip div', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.wv-tooltip')).toBeInTheDocument();
+ });
+
+ it('tooltip is not visible initially (no inline visibility style)', () => {
+ const { container } = renderComponent();
+ const tooltip = container.querySelector('.wv-tooltip');
+ expect(tooltip.style.visibility).toBe('');
+ });
+
+ it('renders a list item for each dataArray element', () => {
+ renderComponent();
+ expect(screen.getByText('Option A')).toBeInTheDocument();
+ expect(screen.getByText('Option B')).toBeInTheDocument();
+ expect(screen.getByText('Option C')).toBeInTheDocument();
+ });
+
+ it('renders the correct number of list items', () => {
+ const { container } = renderComponent();
+ expect(container.querySelectorAll('li')).toHaveLength(3);
+ });
+
+ it('each list item has the correct id from dataArray', () => {
+ const { container } = renderComponent();
+ const items = container.querySelectorAll('li');
+ expect(items[0].id).toBe('Option A');
+ expect(items[1].id).toBe('Option B');
+ expect(items[2].id).toBe('Option C');
+ });
+
+ it('each list item has a unique key derived from value and index', () => {
+ const { container } = renderComponent({ dataArray: ['X', 'X'] });
+ const items = container.querySelectorAll('li');
+ // Both items render — duplicate value is disambiguated by index in key
+ expect(items).toHaveLength(2);
+ });
+
+ it('renders an empty list when dataArray is empty', () => {
+ const { container } = renderComponent({ dataArray: [] });
+ expect(container.querySelectorAll('li')).toHaveLength(0);
+ });
+ });
+
+ describe('mouseOver / mouseOut — hover state', () => {
+ it('sets visibility:visible on the tooltip when mouse enters', () => {
+ const { container } = renderComponent();
+ act(() => {
+ fireEvent.mouseEnter(container.querySelector('.wv-tooltip-case'));
+ });
+ expect(container.querySelector('.wv-tooltip').style.visibility).toBe('visible');
+ });
+
+ it('clears visibility after mouse leaves', () => {
+ const { container } = renderComponent();
+ const wrapper = container.querySelector('.wv-tooltip-case');
+ act(() => { fireEvent.mouseEnter(wrapper); });
+ act(() => { fireEvent.mouseLeave(wrapper); });
+ expect(container.querySelector('.wv-tooltip').style.visibility).toBe('');
+ });
+
+ it('toggling hover on and off multiple times works correctly', () => {
+ const { container } = renderComponent();
+ const wrapper = container.querySelector('.wv-tooltip-case');
+ act(() => { fireEvent.mouseEnter(wrapper); });
+ expect(container.querySelector('.wv-tooltip').style.visibility).toBe('visible');
+ act(() => { fireEvent.mouseLeave(wrapper); });
+ expect(container.querySelector('.wv-tooltip').style.visibility).toBe('');
+ act(() => { fireEvent.mouseEnter(wrapper); });
+ expect(container.querySelector('.wv-tooltip').style.visibility).toBe('visible');
+ });
+ });
+
+ describe('onClick', () => {
+ it('calls the onClick prop when a list item is clicked', () => {
+ const onClick = jest.fn();
+ renderComponent({ onClick });
+ act(() => { fireEvent.click(screen.getByText('Option A')); });
+ expect(onClick).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls onClick for each clicked item', () => {
+ const onClick = jest.fn();
+ renderComponent({ onClick });
+ act(() => { fireEvent.click(screen.getByText('Option A')); });
+ act(() => { fireEvent.click(screen.getByText('Option B')); });
+ expect(onClick).toHaveBeenCalledTimes(2);
+ });
+
+ it('passes the synthetic event object to onClick', () => {
+ const onClick = jest.fn();
+ renderComponent({ onClick });
+ act(() => { fireEvent.click(screen.getByText('Option C')); });
+ // The onClick handler receives the SyntheticEvent (dataEl in the inline arrow)
+ expect(onClick).toHaveBeenCalledWith(expect.objectContaining({ type: 'click' }));
+ });
+ });
});
diff --git a/web/js/components/tour/content-intro.test.js b/web/js/components/tour/content-intro.test.js
index aa06469b4..f329fb8cc 100644
--- a/web/js/components/tour/content-intro.test.js
+++ b/web/js/components/tour/content-intro.test.js
@@ -1,3 +1,71 @@
-test('content-intro component test', () => {
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import TourIntro from './content-intro';
+jest.mock(
+ '@edsc/earthdata-react-icons/horizon-design-system/earthdata/ui',
+ () => ({ ArrowLineRightCircleFill: ({ className, size }) => <svg data-testid="arrow-icon" className={className} data-size={size} /> }),
+);
+
+const renderComponent = (toggleModalStart = jest.fn()) => render(
+ <TourIntro toggleModalStart={toggleModalStart} />,
+);
+
+describe('TourIntro', () => {
+ describe('structure', () => {
+ it('renders the tour-intro container', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.tour-intro')).toBeInTheDocument();
+ });
+
+ it('renders the intro paragraph', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('p.intro')).toBeInTheDocument();
+ });
+
+ it('renders the NASA Earthdata external link', () => {
+ const link = renderComponent().container.querySelector('a[href="https://earthdata.nasa.gov/"]');
+ expect(link).toBeInTheDocument();
+ expect(link).toHaveAttribute('target', '_blank');
+ expect(link).toHaveAttribute('rel', 'noreferrer');
+ expect(link).toHaveTextContent('NASA Earthdata');
+ });
+
+ it('renders the start link with correct attributes', () => {
+ const { container } = renderComponent();
+ const startLink = container.querySelector('a.start-link');
+ expect(startLink).toBeInTheDocument();
+ expect(startLink).toHaveAttribute('href', '#');
+ expect(startLink).toHaveAttribute('title', 'Start using @NAME@');
+ });
+
+ it('renders the ArrowLineRightCircleFill icon inside the start link', () => {
+ const { container } = renderComponent();
+ const startLink = container.querySelector('a.start-link');
+ expect(startLink.querySelector('[data-testid="arrow-icon"]')).toBeInTheDocument();
+ });
+
+ it('passes className="intro-arrow" and size="16px" to the arrow icon', () => {
+ const { container } = renderComponent();
+ const icon = container.querySelector('[data-testid="arrow-icon"]');
+ expect(icon).toHaveClass('intro-arrow');
+ expect(icon).toHaveAttribute('data-size', '16px');
+ });
+ });
+
+ describe('toggleModalStart', () => {
+ it('calls toggleModalStart when the start link is clicked', () => {
+ const toggleModalStart = jest.fn();
+ const { container } = renderComponent(toggleModalStart);
+ act(() => { fireEvent.click(container.querySelector('a.start-link')); });
+ expect(toggleModalStart).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call toggleModalStart when the NASA Earthdata link is clicked', () => {
+ const toggleModalStart = jest.fn();
+ const { container } = renderComponent(toggleModalStart);
+ act(() => { fireEvent.click(container.querySelector('a[href="https://earthdata.nasa.gov/"]')); });
+ expect(toggleModalStart).not.toHaveBeenCalled();
+ });
+ });
});
diff --git a/web/js/components/tour/joyride-wrapper.test.js b/web/js/components/tour/joyride-wrapper.test.js
index 939c7971a..ea1059bf9 100644
--- a/web/js/components/tour/joyride-wrapper.test.js
+++ b/web/js/components/tour/joyride-wrapper.test.js
@@ -1,3 +1,444 @@
-test('joyride-wrapper component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import JoyrideWrapper from './joyride-wrapper';
+import util from '../../util/util';
+// Capture latest props from the mocked Joyride so tests can inspect them
+// and call onEvent() to simulate joyride lifecycle events.
+let mockJoyrideProps = {};
+
+// react-joyride exports Joyride as a named export (not default).
+jest.mock('react-joyride', () => ({
+ Joyride: (props) => { mockJoyrideProps = props; return <div data-testid="joyride" />; },
+ STATUS: { FINISHED: 'finished', SKIPPED: 'skipped' },
+ ACTIONS: { PREV: 'prev', NEXT: 'next', RESET: 'reset' },
+ EVENTS: { STEP_AFTER: 'step:after', TARGET_NOT_FOUND: 'target:notFound' },
+ LIFECYCLE: { TOOLTIP: 'tooltip' },
+}));
+
+jest.mock('../../util/util', () => ({
+ __esModule: true,
+ default: { events: { on: jest.fn(), off: jest.fn() } },
+}));
+
+jest.mock('../../util/constants', () => ({
+ JOYRIDE_INCREMENT: 'joyride:increment',
+}));
+
+// ─── map mock ────────────────────────────────────────────────────────────────
+const mockViewOn = jest.fn();
+const mockViewUn = jest.fn();
+const mockGetPixelFromCoordinate = jest.fn(() => [100, 200]);
+const mockMap = {
+ getView: jest.fn(() => ({ on: mockViewOn, un: mockViewUn })),
+ getPixelFromCoordinate: mockGetPixelFromCoordinate,
+};
+
+// ─── MutationObserver mock ───────────────────────────────────────────────────
+let mockObserver;
+
+// ─── prop factories ──────────────────────────────────────────────────────────
+const makeJoyrideStep = (overrides = {}) => ({
+ target: '.some-target',
+ content: 'Step content',
+ ...overrides,
+});
+
+// A tour step with a targetCoordinates-aware joyride step at a given target.
+const makeCoordStep = (target = '#jt-tour-target') => makeJoyrideStep({
+ target,
+ targetCoordinates: { topLeft: [0, 0], bottomRight: [100, 100] },
+});
+
+const makeTourStep = (joyrideOverrides = {}, stepOverrides = {}) => ({
+ stepLink: 'https://worldview.earthdata.nasa.gov/?t=2020-01-01',
+ joyride: {
+ continuous: true,
+ disableOverlayClose: false,
+ spotlightClicks: false,
+ steps: [makeJoyrideStep()],
+ hideCloseButton: false,
+ eventTriggersIncrement: false,
+ ...joyrideOverrides,
+ },
+ ...stepOverrides,
+});
+
+const defaultProps = {
+ tourSteps: [makeTourStep()],
+ currentTourStep: 1,
+ map: mockMap,
+ proj: 'geographic',
+ tourComplete: false,
+ resetProductPicker: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <JoyrideWrapper {...defaultProps} {...props} />,
+);
+
+const fireJoyride = (data) => act(() => { mockJoyrideProps.onEvent(data); });
+
+// ─── setup / teardown ────────────────────────────────────────────────────────
+
+beforeEach(() => {
+ jest.clearAllMocks();
+
+ mockJoyrideProps = {};
+ mockObserver = { observe: jest.fn(), disconnect: jest.fn() };
+ global.MutationObserver = jest.fn(() => mockObserver);
+ global.requestAnimationFrame = jest.fn((cb) => cb());
+
+ // setPlaceholderLocation does `const element = { ...el }`. In jsdom the
+ // `style` getter lives on the prototype, so the spread produces a plain
+ // object with no `style` property, causing a crash. Patch createElement so
+ // every element has `style` as an own enumerable property that the spread
+ // will copy correctly.
+ const origCreate = document.createElement.bind(document);
+ jest.spyOn(document, 'createElement').mockImplementation((tag, opts) => {
+ const el = origCreate(tag, opts);
+ const ownStyle = el.style;
+ Object.defineProperty(el, 'style', {
+ value: ownStyle, enumerable: true, writable: true, configurable: true,
+ });
+ return el;
+ });
+});
+
+afterEach(() => {
+ jest.restoreAllMocks();
+ document.querySelectorAll('#jt-tour-target').forEach((el) => el.remove());
+ document.querySelectorAll('.react-joyride__overlay-fallback').forEach((el) => el.remove());
+});
+
+// ─── tests ───────────────────────────────────────────────────────────────────
+
+describe('JoyrideWrapper', () => {
+ describe('null guards', () => {
+ it('returns null when map is falsy', () => {
+ const { container } = renderComponent({ map: null });
+ expect(container.querySelector('[data-testid="joyride"]')).not.toBeInTheDocument();
+ });
+
+ it('returns null when proj does not match stepLink proj (no p= → "geographic")', () => {
+ const { container } = renderComponent({ proj: 'arctic' });
+ expect(container.querySelector('[data-testid="joyride"]')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('renders Joyride', () => {
+ it('renders Joyride when proj matches and steps exist', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('[data-testid="joyride"]')).toBeInTheDocument();
+ });
+
+ it('passes run=true when steps are provided', () => {
+ renderComponent();
+ expect(mockJoyrideProps.run).toBe(true);
+ });
+
+ it('passes run=false when joyride.steps is empty', () => {
+ const tourSteps = [makeTourStep({ steps: [] })];
+ renderComponent({ tourSteps });
+ expect(mockJoyrideProps.run).toBe(false);
+ });
+
+ it('passes steps array to Joyride', () => {
+ const step = makeJoyrideStep({ title: 'My Step' });
+ const tourSteps = [makeTourStep({ steps: [step] })];
+ renderComponent({ tourSteps });
+ expect(mockJoyrideProps.steps).toContainEqual(expect.objectContaining({ title: 'My Step' }));
+ });
+
+ it('passes the styles object including overlay and tooltip entries', () => {
+ renderComponent();
+ expect(mockJoyrideProps.styles).toMatchObject({
+ overlay: { transition: 'none' },
+ tooltip: { padding: 15 },
+ });
+ });
+ });
+
+ describe('stepLink proj parsing', () => {
+ it('extracts proj from p= param in stepLink and matches correctly', () => {
+ const tourSteps = [makeTourStep({}, {
+ stepLink: 'https://worldview.earthdata.nasa.gov/?t=2020-01-01&p=arctic',
+ })];
+ const { container } = renderComponent({ tourSteps, proj: 'arctic' });
+ expect(container.querySelector('[data-testid="joyride"]')).toBeInTheDocument();
+ });
+
+ it('defaults stepProj to "geographic" when no p= param present', () => {
+ // defaultProps has no p= in stepLink and proj="geographic" → matches → renders
+ const { container } = renderComponent({ proj: 'geographic' });
+ expect(container.querySelector('[data-testid="joyride"]')).toBeInTheDocument();
+ });
+
+ it('returns null when extracted proj does not match component proj', () => {
+ const tourSteps = [makeTourStep({}, {
+ stepLink: 'https://worldview.earthdata.nasa.gov/?p=arctic',
+ })];
+ const { container } = renderComponent({ tourSteps, proj: 'geographic' });
+ expect(container.querySelector('[data-testid="joyride"]')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('checkContinuous', () => {
+ it('passes continuous=true when no step after index 0 has targetCoordinates', () => {
+ const tourSteps = [makeTourStep({ continuous: true, steps: [makeJoyrideStep()] })];
+ renderComponent({ tourSteps });
+ expect(mockJoyrideProps.continuous).toBe(true);
+ });
+
+ it('passes continuous=false when a step after index 0 has targetCoordinates', () => {
+ const steps = [makeJoyrideStep(), makeCoordStep()];
+ const tourSteps = [makeTourStep({ continuous: true, steps })];
+ renderComponent({ tourSteps });
+ expect(mockJoyrideProps.continuous).toBe(false);
+ });
+ });
+
+ describe('styles — hideNextButton / hideCloseButton', () => {
+ it('hides next button when steps[stepIndex] has hideNextButton=true', () => {
+ // After effect, stepIndex=0; steps[0].hideNextButton=true → buttonNext hidden.
+ const steps = [makeJoyrideStep({ hideNextButton: true })];
+ const tourSteps = [makeTourStep({ steps })];
+ renderComponent({ tourSteps });
+ expect(mockJoyrideProps.styles.buttonNext).toEqual({ display: 'none' });
+ });
+
+ it('hides close button when joyride config has hideCloseButton=true', () => {
+ const steps = [makeJoyrideStep({ hideNextButton: true })];
+ const tourSteps = [makeTourStep({ steps, hideCloseButton: true })];
+ renderComponent({ tourSteps });
+ expect(mockJoyrideProps.styles.buttonClose).toEqual({ display: 'none' });
+ });
+ });
+
+ describe('Joyride options', () => {
+ it('sets overlayClickAction=false when disableOverlayClose=true', () => {
+ renderComponent({ tourSteps: [makeTourStep({ disableOverlayClose: true })] });
+ expect(mockJoyrideProps.options.overlayClickAction).toBe(false);
+ });
+
+ it('sets overlayClickAction="close" when disableOverlayClose=false', () => {
+ renderComponent();
+ expect(mockJoyrideProps.options.overlayClickAction).toBe('close');
+ });
+
+ it('sets blockTargetInteraction=true when spotlightClicks=false', () => {
+ renderComponent();
+ expect(mockJoyrideProps.options.blockTargetInteraction).toBe(true);
+ });
+
+ it('sets blockTargetInteraction=false when spotlightClicks=true', () => {
+ renderComponent({ tourSteps: [makeTourStep({ spotlightClicks: true })] });
+ expect(mockJoyrideProps.options.blockTargetInteraction).toBe(false);
+ });
+ });
+
+ describe('joyrideStateCallback (onEvent)', () => {
+ it('sets overlayStarted=true on LIFECYCLE.TOOLTIP — shows fallback overlay', () => {
+ renderComponent();
+ fireJoyride({
+ action: 'next', index: 0, type: 'beacon', status: 'running', lifecycle: 'tooltip',
+ });
+ expect(document.querySelector('.react-joyride__overlay-fallback')).toBeInTheDocument();
+ });
+
+ it('increments stepIndex on STEP_AFTER with NEXT action', () => {
+ const tourSteps = [makeTourStep({ steps: [makeJoyrideStep(), makeJoyrideStep()] })];
+ renderComponent({ tourSteps });
+ fireJoyride({
+ action: 'next', index: 0, type: 'step:after', status: 'running', lifecycle: 'ready',
+ });
+ expect(mockJoyrideProps.stepIndex).toBe(1);
+ });
+
+ it('decrements stepIndex on STEP_AFTER with PREV action', () => {
+ const tourSteps = [makeTourStep({ steps: [makeJoyrideStep(), makeJoyrideStep()] })];
+ renderComponent({ tourSteps });
+ fireJoyride({ action: 'next', index: 0, type: 'step:after', status: 'running', lifecycle: 'ready' });
+ fireJoyride({ action: 'prev', index: 1, type: 'step:after', status: 'running', lifecycle: 'ready' });
+ expect(mockJoyrideProps.stepIndex).toBe(0);
+ });
+
+ it('handles TARGET_NOT_FOUND by advancing stepIndex', () => {
+ const tourSteps = [makeTourStep({ steps: [makeJoyrideStep(), makeJoyrideStep()] })];
+ renderComponent({ tourSteps });
+ fireJoyride({
+ action: 'next', index: 0, type: 'target:notFound', status: 'running', lifecycle: 'init',
+ });
+ expect(mockJoyrideProps.stepIndex).toBe(1);
+ });
+
+ it('resets run=false and stepIndex=0 on STATUS.FINISHED', () => {
+ renderComponent();
+ fireJoyride({
+ action: 'close', index: 0, type: 'step:after', status: 'finished', lifecycle: 'complete',
+ });
+ expect(mockJoyrideProps.run).toBe(false);
+ expect(mockJoyrideProps.stepIndex).toBe(0);
+ });
+
+ it('resets run=false and stepIndex=0 on STATUS.SKIPPED', () => {
+ renderComponent();
+ fireJoyride({
+ action: 'close', index: 0, type: 'step:after', status: 'skipped', lifecycle: 'complete',
+ });
+ expect(mockJoyrideProps.run).toBe(false);
+ expect(mockJoyrideProps.stepIndex).toBe(0);
+ });
+ });
+
+ describe('useEffect — JOYRIDE_INCREMENT event listener', () => {
+ it('registers JOYRIDE_INCREMENT listener on mount', () => {
+ renderComponent();
+ expect(util.events.on).toHaveBeenCalledWith('joyride:increment', expect.any(Function));
+ });
+
+ it('de-registers listener on unmount', () => {
+ const { unmount } = renderComponent();
+ act(() => { unmount(); });
+ expect(util.events.off).toHaveBeenCalledWith('joyride:increment', expect.any(Function));
+ });
+ });
+
+ describe('useEffect — resetProductPicker', () => {
+ it('calls resetProductPicker when eventTriggersIncrement=true', () => {
+ const resetProductPicker = jest.fn();
+ const tourSteps = [makeTourStep({ eventTriggersIncrement: true })];
+ renderComponent({ tourSteps, resetProductPicker });
+ expect(resetProductPicker).toHaveBeenCalled();
+ });
+
+ it('does not call resetProductPicker when eventTriggersIncrement=false', () => {
+ const resetProductPicker = jest.fn();
+ renderComponent({ resetProductPicker });
+ expect(resetProductPicker).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('useEffect — map view change listener', () => {
+ it('registers map view "change" listener when hasTargetCoordinates=true', () => {
+ const tourSteps = [makeTourStep({ steps: [makeCoordStep()] })];
+ renderComponent({ tourSteps });
+ expect(mockViewOn).toHaveBeenCalledWith('change', expect.any(Function));
+ });
+
+ it('does not register map view listener when hasTargetCoordinates=false', () => {
+ renderComponent(); // default steps have no targetCoordinates
+ expect(mockViewOn).not.toHaveBeenCalled();
+ });
+
+ it('de-registers map view listener on unmount', () => {
+ const tourSteps = [makeTourStep({ steps: [makeCoordStep()] })];
+ const { unmount } = renderComponent({ tourSteps });
+ act(() => { unmount(); });
+ expect(mockViewUn).toHaveBeenCalledWith('change', expect.any(Function));
+ });
+ });
+
+ describe('useEffect — MutationObserver', () => {
+ it('creates MutationObserver and observes body when run && projMatches && !isInitializing', () => {
+ renderComponent(); // steps → run=true; proj matches; isInitializing→false via effect
+ expect(global.MutationObserver).toHaveBeenCalled();
+ expect(mockObserver.observe).toHaveBeenCalledWith(
+ document.body,
+ expect.objectContaining({ subtree: true, childList: true }),
+ );
+ });
+
+ it('disconnects MutationObserver on unmount', () => {
+ const { unmount } = renderComponent();
+ act(() => { unmount(); });
+ expect(mockObserver.disconnect).toHaveBeenCalled();
+ });
+
+ it('does not create MutationObserver when run=false (no steps)', () => {
+ const tourSteps = [makeTourStep({ steps: [] })];
+ renderComponent({ tourSteps });
+ expect(global.MutationObserver).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('addPlaceholderElements / setPlaceholderLocation', () => {
+ it('creates a placeholder span in body for steps with targetCoordinates', () => {
+ const tourSteps = [makeTourStep({ steps: [makeCoordStep()] })];
+ renderComponent({ tourSteps });
+ expect(document.getElementById('jt-tour-target')).toBeInTheDocument();
+ });
+
+ it('sets absolute positioning on the placeholder span', () => {
+ const tourSteps = [makeTourStep({ steps: [makeCoordStep()] })];
+ renderComponent({ tourSteps });
+ const span = document.getElementById('jt-tour-target');
+ expect(span.style.position).toBe('absolute');
+ });
+
+ it('calls map.getPixelFromCoordinate with topLeft and bottomRight', () => {
+ const tourSteps = [makeTourStep({ steps: [makeCoordStep()] })];
+ renderComponent({ tourSteps });
+ expect(mockGetPixelFromCoordinate).toHaveBeenCalledWith([0, 0]);
+ expect(mockGetPixelFromCoordinate).toHaveBeenCalledWith([100, 100]);
+ });
+
+ it('skips placeholder creation when the target element already exists in DOM', () => {
+ const existing = document.createElement('span');
+ existing.id = 'jt-tour-target';
+ document.body.appendChild(existing);
+
+ const tourSteps = [makeTourStep({ steps: [makeCoordStep()] })];
+ renderComponent({ tourSteps });
+
+ // No duplicate should have been created
+ expect(document.querySelectorAll('#jt-tour-target')).toHaveLength(1);
+ existing.remove();
+ });
+ });
+
+ describe('updateTargetsOnResize — triggered via joyrideStateCallback + requestAnimationFrame', () => {
+ it('calls requestAnimationFrame when STEP_AFTER advances to a step with targetCoordinates', () => {
+ const steps = [makeJoyrideStep(), makeCoordStep()];
+ const tourSteps = [makeTourStep({ steps })];
+ renderComponent({ tourSteps });
+ fireJoyride({
+ action: 'next', index: 0, type: 'step:after', status: 'running', lifecycle: 'ready',
+ });
+ expect(global.requestAnimationFrame).toHaveBeenCalled();
+ });
+
+ it('calls getPixelFromCoordinate again when updateTargetsOnResize fires', () => {
+ const steps = [makeJoyrideStep(), makeCoordStep()];
+ const tourSteps = [makeTourStep({ steps })];
+ renderComponent({ tourSteps });
+ // Clear the initial calls from mount
+ mockGetPixelFromCoordinate.mockClear();
+ fireJoyride({
+ action: 'next', index: 0, type: 'step:after', status: 'running', lifecycle: 'ready',
+ });
+ expect(mockGetPixelFromCoordinate).toHaveBeenCalled();
+ });
+ });
+
+ describe('fallback overlay portal', () => {
+ it('renders fallback overlay when run && overlayStarted && !hasJoyrideOverlay', () => {
+ renderComponent();
+ // LIFECYCLE.TOOLTIP sets overlayStarted=true; hasJoyrideOverlay stays false in jsdom
+ fireJoyride({ action: 'next', index: 0, type: 'beacon', status: 'running', lifecycle: 'tooltip' });
+ expect(document.querySelector('.react-joyride__overlay-fallback')).toBeInTheDocument();
+ });
+
+ it('does not render fallback overlay before overlayStarted=true', () => {
+ renderComponent();
+ expect(document.querySelector('.react-joyride__overlay-fallback')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('tourComplete cleanup', () => {
+ it('renders without error when tourComplete=true', () => {
+ expect(() => renderComponent({ tourComplete: true })).not.toThrow();
+ });
+ });
});
diff --git a/web/js/components/tour/modal-tour-complete.test.js b/web/js/components/tour/modal-tour-complete.test.js
index d9c0f72f8..7c1d44fa8 100644
--- a/web/js/components/tour/modal-tour-complete.test.js
+++ b/web/js/components/tour/modal-tour-complete.test.js
@@ -1,3 +1,215 @@
-test('modal-tour-complete component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import ModalComplete from './modal-tour-complete';
+jest.mock('reactstrap', () => ({
+ Modal: ({ children, isOpen, wrapClassName }) => (isOpen ? <div data-testid="modal" className={wrapClassName}>{children}</div> : null),
+ ModalHeader: ({ children, close }) => (
+ <div data-testid="modal-header">
+ {children}
+ {close}
+ </div>
+ ),
+ ModalBody: ({ children }) => <div data-testid="modal-body">{children}</div>,
+ ModalFooter: ({ children }) => <div data-testid="modal-footer">{children}</div>,
+}));
+
+jest.mock(
+ '@edsc/earthdata-react-icons/horizon-design-system/hds/ui',
+ () => ({ Close: ({ className, size }) => <svg data-testid="close-icon" className={className} data-size={size} /> }),
+);
+
+const defaultProps = {
+ currentStory: { readMoreLinks: [] },
+ modalComplete: true,
+ resetTour: jest.fn(),
+ endTour: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <ModalComplete {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('ModalComplete', () => {
+ describe('modal open/closed state', () => {
+ it('renders the modal when modalComplete=true', () => {
+ renderComponent();
+ expect(screen.getByTestId('modal')).toBeInTheDocument();
+ });
+
+ it('does not render the modal when modalComplete=false', () => {
+ renderComponent({ modalComplete: false });
+ expect(screen.queryByTestId('modal')).not.toBeInTheDocument();
+ });
+
+ it('renders with the correct wrapClassName', () => {
+ renderComponent();
+ expect(screen.getByTestId('modal')).toHaveClass('tour');
+ expect(screen.getByTestId('modal')).toHaveClass('tour-complete');
+ });
+ });
+
+ describe('ModalHeader', () => {
+ it('renders "Story Complete" heading text', () => {
+ renderComponent();
+ expect(screen.getByText('Story Complete')).toBeInTheDocument();
+ });
+
+ it('renders the close button inside the header', () => {
+ renderComponent();
+ const header = screen.getByTestId('modal-header');
+ expect(header.querySelector('.tour-close-btn')).toBeInTheDocument();
+ });
+
+ it('calls endTour when the close button is clicked', () => {
+ const endTour = jest.fn();
+ renderComponent({ endTour });
+ act(() => { fireEvent.click(screen.getByTestId('modal-header').querySelector('.tour-close-btn')); });
+ expect(endTour).toHaveBeenCalledTimes(1);
+ });
+
+ it('renders the Close icon inside the close button', () => {
+ renderComponent();
+ const closeBtn = screen.getByTestId('modal-header').querySelector('.tour-close-btn');
+ expect(closeBtn.querySelector('[data-testid="close-icon"]')).toBeInTheDocument();
+ });
+
+ it('passes className="add-plus" and size="14px" to the Close icon', () => {
+ renderComponent();
+ const icon = screen.getByTestId('close-icon');
+ expect(icon).toHaveClass('add-plus');
+ expect(icon).toHaveAttribute('data-size', '14px');
+ });
+ });
+
+ describe('ModalBody — static text', () => {
+ it('renders the completion paragraph', () => {
+ renderComponent();
+ expect(screen.getByText(/You have now completed a story/)).toBeInTheDocument();
+ });
+
+ it('mentions the "More Stories" action in the body text', () => {
+ renderComponent();
+ expect(screen.getAllByText(/More Stories/).length).toBeGreaterThan(0);
+ });
+
+ it('mentions the "Exit Tutorial" action in the body text', () => {
+ renderComponent();
+ expect(screen.getAllByText(/Exit Tutorial/).length).toBeGreaterThan(0);
+ });
+ });
+
+ describe('readMoreLinks list', () => {
+ it('does not render the read-more section when readMoreLinks is empty', () => {
+ renderComponent({ currentStory: { readMoreLinks: [] } });
+ expect(screen.queryByText(/Read more about this story/)).not.toBeInTheDocument();
+ });
+
+ it('does not render the read-more section when readMoreLinks is absent', () => {
+ renderComponent({ currentStory: {} });
+ expect(screen.queryByText(/Read more about this story/)).not.toBeInTheDocument();
+ });
+
+ it('does not render the read-more section when readMoreLinks is null', () => {
+ renderComponent({ currentStory: { readMoreLinks: null } });
+ expect(screen.queryByText(/Read more about this story/)).not.toBeInTheDocument();
+ });
+
+ it('renders the read-more intro text when readMoreLinks has entries', () => {
+ renderComponent({
+ currentStory: {
+ readMoreLinks: [{ link: 'https://example.com', title: 'Example Article' }],
+ },
+ });
+ expect(screen.getByText('Read more about this story at the links below:')).toBeInTheDocument();
+ });
+
+ it('renders a link for each entry in readMoreLinks', () => {
+ renderComponent({
+ currentStory: {
+ readMoreLinks: [
+ { link: 'https://example.com/a', title: 'Article A' },
+ { link: 'https://example.com/b', title: 'Article B' },
+ ],
+ },
+ });
+ expect(screen.getByText('Article A')).toBeInTheDocument();
+ expect(screen.getByText('Article B')).toBeInTheDocument();
+ });
+
+ it('each link has the correct href, target="_blank", and rel attributes', () => {
+ renderComponent({
+ currentStory: {
+ readMoreLinks: [{ link: 'https://nasa.gov/', title: 'NASA' }],
+ },
+ });
+ const link = screen.getByText('NASA').closest('a');
+ expect(link).toHaveAttribute('href', 'https://nasa.gov/');
+ expect(link).toHaveAttribute('target', '_blank');
+ expect(link).toHaveAttribute('rel', 'noopener noreferrer');
+ });
+
+ it('renders the correct number of list items', () => {
+ const { container } = renderComponent({
+ currentStory: {
+ readMoreLinks: [
+ { link: 'https://a.com', title: 'A' },
+ { link: 'https://b.com', title: 'B' },
+ { link: 'https://c.com', title: 'C' },
+ ],
+ },
+ });
+ expect(container.querySelectorAll('li')).toHaveLength(3);
+ });
+
+ it('uses fallback key parts when link or title are missing', () => {
+ expect(() => renderComponent({
+ currentStory: {
+ readMoreLinks: [{ link: undefined, title: undefined }],
+ },
+ })).not.toThrow();
+ });
+ });
+
+ describe('ModalFooter — buttons', () => {
+ it('renders the "More Stories" button', () => {
+ renderComponent();
+ expect(screen.getByRole('button', { name: 'More Stories' })).toBeInTheDocument();
+ });
+
+ it('renders the "Exit Tutorial" button', () => {
+ renderComponent();
+ expect(screen.getByRole('button', { name: 'Exit Tutorial' })).toBeInTheDocument();
+ });
+
+ it('calls resetTour when "More Stories" is clicked', () => {
+ const resetTour = jest.fn();
+ renderComponent({ resetTour });
+ act(() => { fireEvent.click(screen.getByRole('button', { name: 'More Stories' })); });
+ expect(resetTour).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls endTour when "Exit Tutorial" is clicked', () => {
+ const endTour = jest.fn();
+ renderComponent({ endTour });
+ act(() => { fireEvent.click(screen.getByRole('button', { name: 'Exit Tutorial' })); });
+ expect(endTour).toHaveBeenCalledTimes(1);
+ });
+
+ it('"More Stories" button has btn-primary class', () => {
+ renderComponent();
+ expect(screen.getByRole('button', { name: 'More Stories' })).toHaveClass('btn-primary');
+ });
+
+ it('"Exit Tutorial" button has btn-secondary class', () => {
+ renderComponent();
+ expect(screen.getByRole('button', { name: 'Exit Tutorial' })).toHaveClass('btn-secondary');
+ });
+ });
});
diff --git a/web/js/components/tour/modal-tour-in-progress.test.js b/web/js/components/tour/modal-tour-in-progress.test.js
index ce6117c55..3274e990f 100644
--- a/web/js/components/tour/modal-tour-in-progress.test.js
+++ b/web/js/components/tour/modal-tour-in-progress.test.js
@@ -1,3 +1,200 @@
-test('modal-tour-in-progress component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import ModalInProgress from './modal-tour-in-progress';
+jest.mock('reactstrap', () => ({
+ Modal: ({ children, isOpen, wrapClassName, className }) => (
+ isOpen
+ ? <div data-testid="modal" className={[wrapClassName, className].filter(Boolean).join(' ')}>{children}</div>
+ : null
+ ),
+ ModalHeader: ({ children, close }) => (
+ <div data-testid="modal-header">
+ {children}
+ {close}
+ </div>
+ ),
+ ModalBody: ({ children }) => <div data-testid="modal-body">{children}</div>,
+ ModalFooter: ({ children }) => <div data-testid="modal-footer">{children}</div>,
+}));
+
+jest.mock(
+ '@edsc/earthdata-react-icons/horizon-design-system/hds/ui',
+ () => ({ Close: ({ className, size }) => <svg data-testid="close-icon" className={className} data-size={size} /> }),
+);
+
+jest.mock('./widget-steps', () => function MockSteps({
+ currentStep, totalSteps, decreaseStep, incrementStep, isKioskModeActive,
+}) {
+ return (
+ <div data-testid="widget-steps">
+ <button type="button" data-testid="steps-decrease" onClick={decreaseStep}>Prev</button>
+ <span data-testid="steps-current">{currentStep}</span>
+ <span data-testid="steps-total">{totalSteps}</span>
+ <button type="button" data-testid="steps-increment" onClick={incrementStep}>Next</button>
+ <span data-testid="steps-kiosk">{String(isKioskModeActive)}</span>
+ </div>
+ );
+});
+
+const defaultProps = {
+ className: 'my-modal',
+ currentStory: { title: 'Test Story', type: 'story-type' },
+ description: '<p>Step description</p>',
+ modalInProgress: true,
+ endTour: jest.fn(),
+ currentStep: 1,
+ totalSteps: 3,
+ decreaseStep: jest.fn(),
+ incrementStep: jest.fn(),
+ isKioskModeActive: false,
+};
+
+const renderComponent = (props = {}) => render(
+ <ModalInProgress {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('ModalInProgress', () => {
+ describe('modal open/closed state', () => {
+ it('renders the modal when modalInProgress=true', () => {
+ renderComponent();
+ expect(screen.getByTestId('modal')).toBeInTheDocument();
+ });
+
+ it('does not render the modal when modalInProgress=false', () => {
+ renderComponent({ modalInProgress: false });
+ expect(screen.queryByTestId('modal')).not.toBeInTheDocument();
+ });
+
+ it('renders with the tour tour-in-progress wrapClassName', () => {
+ renderComponent();
+ const modal = screen.getByTestId('modal');
+ expect(modal).toHaveClass('tour');
+ expect(modal).toHaveClass('tour-in-progress');
+ });
+
+ it('applies className and currentStory.type to the modal className', () => {
+ renderComponent();
+ const modal = screen.getByTestId('modal');
+ expect(modal).toHaveClass('my-modal');
+ expect(modal).toHaveClass('story-type');
+ });
+ });
+
+ describe('ModalHeader', () => {
+ it('renders the story title in the header', () => {
+ renderComponent();
+ expect(screen.getByText('Test Story')).toBeInTheDocument();
+ });
+
+ it('renders the modal-icon element', () => {
+ renderComponent();
+ expect(screen.getByTestId('modal-header').querySelector('.modal-icon')).toBeInTheDocument();
+ });
+
+ it('renders the close button when isKioskModeActive=false', () => {
+ renderComponent({ isKioskModeActive: false });
+ const closeBtn = screen.getByTestId('modal-header').querySelector('.end-tour-close-btn');
+ expect(closeBtn).toBeInTheDocument();
+ });
+
+ it('hides the close button (d-none) when isKioskModeActive=true', () => {
+ renderComponent({ isKioskModeActive: true });
+ const header = screen.getByTestId('modal-header');
+ const btn = header.querySelector('button');
+ expect(btn).toHaveClass('d-none');
+ expect(btn).not.toHaveClass('end-tour-close-btn');
+ });
+
+ it('calls endTour when the close button is clicked', () => {
+ const endTour = jest.fn();
+ renderComponent({ endTour });
+ act(() => {
+ fireEvent.click(screen.getByTestId('modal-header').querySelector('.end-tour-close-btn'));
+ });
+ expect(endTour).toHaveBeenCalledTimes(1);
+ });
+
+ it('renders the Close icon inside the close button', () => {
+ renderComponent();
+ const btn = screen.getByTestId('modal-header').querySelector('.end-tour-close-btn');
+ expect(btn.querySelector('[data-testid="close-icon"]')).toBeInTheDocument();
+ });
+
+ it('passes className="add-plus" and size="14px" to the Close icon', () => {
+ renderComponent();
+ const icon = screen.getByTestId('close-icon');
+ expect(icon).toHaveClass('add-plus');
+ expect(icon).toHaveAttribute('data-size', '14px');
+ });
+ });
+
+ describe('ModalBody — description HTML', () => {
+ it('renders description HTML via dangerouslySetInnerHTML', () => {
+ renderComponent({ description: '<p>Hello World</p>' });
+ const body = screen.getByTestId('modal-body');
+ expect(body.querySelector('p')).toHaveTextContent('Hello World');
+ });
+
+ it('renders updated description when prop changes', () => {
+ const { rerender } = renderComponent({ description: '<p>First</p>' });
+ act(() => {
+ rerender(<ModalInProgress {...defaultProps} description="<p>Second</p>" />);
+ });
+ expect(screen.getByTestId('modal-body').querySelector('p')).toHaveTextContent('Second');
+ });
+
+ it('renders empty body when description is undefined', () => {
+ renderComponent({ description: undefined });
+ const body = screen.getByTestId('modal-body');
+ expect(body.querySelector('div')).toBeInTheDocument();
+ });
+ });
+
+ describe('ModalFooter — Steps widget', () => {
+ it('renders the Steps widget in the footer', () => {
+ renderComponent();
+ expect(screen.getByTestId('widget-steps')).toBeInTheDocument();
+ });
+
+ it('passes currentStep to Steps', () => {
+ renderComponent({ currentStep: 2 });
+ expect(screen.getByTestId('steps-current')).toHaveTextContent('2');
+ });
+
+ it('passes totalSteps to Steps', () => {
+ renderComponent({ totalSteps: 5 });
+ expect(screen.getByTestId('steps-total')).toHaveTextContent('5');
+ });
+
+ it('passes isKioskModeActive=false to Steps', () => {
+ renderComponent({ isKioskModeActive: false });
+ expect(screen.getByTestId('steps-kiosk')).toHaveTextContent('false');
+ });
+
+ it('passes isKioskModeActive=true to Steps', () => {
+ renderComponent({ isKioskModeActive: true });
+ expect(screen.getByTestId('steps-kiosk')).toHaveTextContent('true');
+ });
+
+ it('calls decreaseStep when Steps fires it', () => {
+ const decreaseStep = jest.fn();
+ renderComponent({ decreaseStep });
+ act(() => { fireEvent.click(screen.getByTestId('steps-decrease')); });
+ expect(decreaseStep).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls incrementStep when Steps fires it', () => {
+ const incrementStep = jest.fn();
+ renderComponent({ incrementStep });
+ act(() => { fireEvent.click(screen.getByTestId('steps-increment')); });
+ expect(incrementStep).toHaveBeenCalledTimes(1);
+ });
+ });
});
diff --git a/web/js/components/tour/modal-tour-start.test.js b/web/js/components/tour/modal-tour-start.test.js
index b395c8f5a..2a9d4c519 100644
--- a/web/js/components/tour/modal-tour-start.test.js
+++ b/web/js/components/tour/modal-tour-start.test.js
@@ -1,3 +1,270 @@
-test('modal-tour-start component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import ModalStart from './modal-tour-start';
+jest.mock('reactstrap', () => ({
+ Modal: ({ children, isOpen, wrapClassName, className }) => (
+ isOpen
+ ? <div data-testid="modal" className={[wrapClassName, className].filter(Boolean).join(' ')}>{children}</div>
+ : null
+ ),
+ ModalHeader: ({ children, close }) => (
+ <div data-testid="modal-header">
+ {children}
+ {close}
+ </div>
+ ),
+ ModalBody: ({ children }) => <div data-testid="modal-body">{children}</div>,
+ ModalFooter: ({ children }) => <div data-testid="modal-footer">{children}</div>,
+ InputGroup: ({ children }) => <div data-testid="input-group">{children}</div>,
+ InputGroupText: ({ children, className }) => <div data-testid="input-group-text" className={className}>{children}</div>,
+}));
+
+jest.mock(
+ '@edsc/earthdata-react-icons/horizon-design-system/hds/ui',
+ () => ({ Close: ({ className, size }) => <svg data-testid="close-icon" className={className} data-size={size} /> }),
+);
+
+jest.mock('./content-intro', () => function MockTourIntro({ toggleModalStart }) {
+ return <div data-testid="tour-intro"><button type="button" data-testid="tour-intro-btn" onClick={toggleModalStart}>Start</button></div>;
+});
+
+jest.mock('./tour-boxes', () => function MockTourBoxes({ stories, storyOrder, selectTour }) {
+ return (
+ <div data-testid="tour-boxes">
+ <button type="button" data-testid="tour-boxes-select" onClick={() => selectTour('story-1')}>Select</button>
+ <span data-testid="tour-boxes-order">{storyOrder ? storyOrder.join(',') : ''}</span>
+ </div>
+ );
+});
+
+jest.mock('../util/checkbox', () => function MockCheckbox({
+ id, checked, onCheck, label,
+}) {
+ return (
+ <div data-testid="checkbox-wrapper">
+ <button
+ type="button"
+ id={id}
+ data-testid="checkbox-input"
+ data-checked={String(checked)}
+ onClick={onCheck}
+ >
+ {label}
+ </button>
+ </div>
+ );
+});
+
+jest.mock('../util/scrollbar', () => function MockScrollbars({ children, style }) {
+ return <div data-testid="scrollbars" style={style}>{children}</div>;
+});
+
+// localStorageMock controls whether safeLocalStorage.enabled is truthy
+const localStorageMock = {
+ enabled: true,
+};
+jest.mock('../../util/local-storage', () => localStorageMock);
+
+const defaultProps = {
+ checked: false,
+ endTour: jest.fn(),
+ hideTour: jest.fn(),
+ showTour: jest.fn(),
+ modalStart: true,
+ selectTour: jest.fn(),
+ stories: { story1: {} },
+ storyOrder: ['story1'],
+ toggleModalStart: jest.fn(),
+ className: 'test-class',
+ height: 800,
+};
+
+const renderComponent = (props = {}) => render(
+ <ModalStart {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ localStorageMock.enabled = true;
+});
+
+describe('ModalStart', () => {
+ describe('modal open/closed state', () => {
+ it('renders the modal when modalStart=true', () => {
+ renderComponent();
+ expect(screen.getByTestId('modal')).toBeInTheDocument();
+ });
+
+ it('does not render the modal when modalStart=false', () => {
+ renderComponent({ modalStart: false });
+ expect(screen.queryByTestId('modal')).not.toBeInTheDocument();
+ });
+
+ it('applies wrapClassName "tour tour-start"', () => {
+ renderComponent();
+ const modal = screen.getByTestId('modal');
+ expect(modal).toHaveClass('tour');
+ expect(modal).toHaveClass('tour-start');
+ });
+
+ it('applies className prop to the modal', () => {
+ renderComponent({ className: 'custom-class' });
+ expect(screen.getByTestId('modal')).toHaveClass('custom-class');
+ });
+ });
+
+ describe('ModalHeader', () => {
+ it('renders the welcome heading text', () => {
+ renderComponent();
+ expect(screen.getByText(/Welcome to NASA/)).toBeInTheDocument();
+ });
+
+ it('renders the close button', () => {
+ renderComponent();
+ const header = screen.getByTestId('modal-header');
+ expect(header.querySelector('.tour-close-btn')).toBeInTheDocument();
+ });
+
+ it('calls endTour when the close button is clicked', () => {
+ const endTour = jest.fn();
+ renderComponent({ endTour });
+ act(() => {
+ fireEvent.click(screen.getByTestId('modal-header').querySelector('.tour-close-btn'));
+ });
+ expect(endTour).toHaveBeenCalledTimes(1);
+ });
+
+ it('renders the Close icon with correct props', () => {
+ renderComponent();
+ const icon = screen.getByTestId('close-icon');
+ expect(icon).toHaveClass('add-plus');
+ expect(icon).toHaveAttribute('data-size', '14px');
+ });
+ });
+
+ describe('Scrollbars', () => {
+ it('renders Scrollbars with height-based maxHeight style', () => {
+ renderComponent({ height: 600 });
+ const sb = screen.getByTestId('scrollbars');
+ expect(sb).toHaveStyle({ maxHeight: '400px' });
+ });
+
+ it('wraps ModalBody inside Scrollbars', () => {
+ renderComponent();
+ const sb = screen.getByTestId('scrollbars');
+ expect(sb.querySelector('[data-testid="modal-body"]')).toBeInTheDocument();
+ });
+ });
+
+ describe('ModalBody — child components', () => {
+ it('renders TourIntro inside the body', () => {
+ renderComponent();
+ expect(screen.getByTestId('tour-intro')).toBeInTheDocument();
+ });
+
+ it('passes toggleModalStart to TourIntro', () => {
+ const toggleModalStart = jest.fn();
+ renderComponent({ toggleModalStart });
+ act(() => { fireEvent.click(screen.getByTestId('tour-intro-btn')); });
+ expect(toggleModalStart).toHaveBeenCalledTimes(1);
+ });
+
+ it('renders TourBoxes inside the body', () => {
+ renderComponent();
+ expect(screen.getByTestId('tour-boxes')).toBeInTheDocument();
+ });
+
+ it('passes storyOrder to TourBoxes', () => {
+ renderComponent({ storyOrder: ['a', 'b'] });
+ expect(screen.getByTestId('tour-boxes-order')).toHaveTextContent('a,b');
+ });
+
+ it('passes selectTour to TourBoxes', () => {
+ const selectTour = jest.fn();
+ renderComponent({ selectTour });
+ act(() => { fireEvent.click(screen.getByTestId('tour-boxes-select')); });
+ expect(selectTour).toHaveBeenCalledWith('story-1');
+ });
+ });
+
+ describe('ModalFooter — localStorage enabled', () => {
+ it('renders the footer when safeLocalStorage.enabled is truthy', () => {
+ localStorageMock.enabled = true;
+ renderComponent();
+ expect(screen.getByTestId('modal-footer')).toBeInTheDocument();
+ });
+
+ it('does not render the footer when safeLocalStorage.enabled is falsy', () => {
+ localStorageMock.enabled = false;
+ renderComponent();
+ expect(screen.queryByTestId('modal-footer')).not.toBeInTheDocument();
+ });
+
+ it('renders the checkbox inside the footer', () => {
+ renderComponent();
+ expect(screen.getByTestId('checkbox-input')).toBeInTheDocument();
+ });
+
+ it('renders the checkbox label text', () => {
+ renderComponent();
+ expect(screen.getByText('Do not show until a new story has been added.')).toBeInTheDocument();
+ });
+
+ it('renders checkbox with data-checked="false" when checked prop is false', () => {
+ renderComponent({ checked: false });
+ expect(screen.getByTestId('checkbox-input')).toHaveAttribute('data-checked', 'false');
+ });
+
+ it('renders checkbox with data-checked="true" when checked prop is true', () => {
+ renderComponent({ checked: true });
+ expect(screen.getByTestId('checkbox-input')).toHaveAttribute('data-checked', 'true');
+ });
+ });
+
+ describe('handleCheck', () => {
+ it('calls hideTour when state.checked is false (unchecked → checked)', () => {
+ const hideTour = jest.fn();
+ renderComponent({ checked: false, hideTour });
+ act(() => { fireEvent.click(screen.getByTestId('checkbox-input')); });
+ expect(hideTour).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls showTour when state.checked is true (checked → unchecked)', () => {
+ const showTour = jest.fn();
+ renderComponent({ checked: true, showTour });
+ act(() => { fireEvent.click(screen.getByTestId('checkbox-input')); });
+ expect(showTour).toHaveBeenCalledTimes(1);
+ });
+
+ it('toggles data-checked from false to true after one click', () => {
+ renderComponent({ checked: false });
+ expect(screen.getByTestId('checkbox-input')).toHaveAttribute('data-checked', 'false');
+ act(() => { fireEvent.click(screen.getByTestId('checkbox-input')); });
+ expect(screen.getByTestId('checkbox-input')).toHaveAttribute('data-checked', 'true');
+ });
+
+ it('toggles back to false on second click', () => {
+ renderComponent({ checked: false });
+ act(() => { fireEvent.click(screen.getByTestId('checkbox-input')); });
+ act(() => { fireEvent.click(screen.getByTestId('checkbox-input')); });
+ expect(screen.getByTestId('checkbox-input')).toHaveAttribute('data-checked', 'false');
+ });
+
+ it('does not call showTour when state.checked is false', () => {
+ const showTour = jest.fn();
+ renderComponent({ checked: false, showTour });
+ act(() => { fireEvent.click(screen.getByTestId('checkbox-input')); });
+ expect(showTour).not.toHaveBeenCalled();
+ });
+
+ it('does not call hideTour when state.checked is true', () => {
+ const hideTour = jest.fn();
+ renderComponent({ checked: true, hideTour });
+ act(() => { fireEvent.click(screen.getByTestId('checkbox-input')); });
+ expect(hideTour).not.toHaveBeenCalled();
+ });
+ });
});
diff --git a/web/js/components/tour/tour-box.test.js b/web/js/components/tour/tour-box.test.js
index 0397c0cae..72f9614f1 100644
--- a/web/js/components/tour/tour-box.test.js
+++ b/web/js/components/tour/tour-box.test.js
@@ -1,3 +1,166 @@
-test('tour-box component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import TourBox from './tour-box';
+const defaultProps = {
+ index: 0,
+ story: { id: 'story-1', title: 'Test Story' },
+ storyId: 'story-1',
+ storyOrder: ['story-1', 'story-2', 'story-3'],
+ title: 'Test Story Title',
+ description: 'Test story description.',
+ backgroundImage: 'bg.jpg',
+ backgroundImageHover: 'bg-hover.jpg',
+ selectTour: jest.fn(),
+ className: 'tour-box story',
+};
+
+const renderComponent = (props = {}) => render(
+ <TourBox {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('TourBox', () => {
+ describe('initial render', () => {
+ it('renders the anchor element', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('a[href="#"]')).toBeInTheDocument();
+ });
+
+ it('renders the title', () => {
+ renderComponent();
+ expect(screen.getByText('Test Story Title')).toBeInTheDocument();
+ });
+
+ it('renders the description', () => {
+ renderComponent();
+ expect(screen.getByText('Test story description.')).toBeInTheDocument();
+ });
+
+ it('renders the tour-box-icon element', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.tour-box-icon')).toBeInTheDocument();
+ });
+
+ it('renders the tour-box-gradient element', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.tour-box-gradient')).toBeInTheDocument();
+ });
+
+ it('applies the className prop to the anchor', () => {
+ const { container } = renderComponent({ className: 'tour-box custom-type' });
+ const anchor = container.querySelector('a');
+ expect(anchor).toHaveClass('tour-box');
+ expect(anchor).toHaveClass('custom-type');
+ });
+ });
+
+ describe('backgroundImage — initial styles', () => {
+ it('sets backgroundImage style when backgroundImage prop is provided', () => {
+ const { container } = renderComponent({ backgroundImage: 'cover.jpg', storyId: 'story-1' });
+ const anchor = container.querySelector('a');
+ expect(anchor.style.backgroundImage).toContain(
+ 'config/metadata/stories/story-1/cover.jpg',
+ );
+ });
+
+ it('has empty style object when backgroundImage is not provided', () => {
+ const { container } = renderComponent({ backgroundImage: undefined });
+ const anchor = container.querySelector('a');
+ expect(anchor.style.backgroundImage).toBe('');
+ });
+ });
+
+ describe('floatBox class — storyOrder positioning', () => {
+ it('adds tour-box-float when index is the last item', () => {
+ // storyOrder.length=3, index=2: length-(index+1)=0 → float
+ const { container } = renderComponent({ index: 2, storyOrder: ['a', 'b', 'c'] });
+ expect(container.querySelector('a')).toHaveClass('tour-box-float');
+ });
+
+ it('adds tour-box-float when index is second-to-last', () => {
+ // storyOrder.length=3, index=1: length-(index+2)=0 → float
+ const { container } = renderComponent({ index: 1, storyOrder: ['a', 'b', 'c'] });
+ expect(container.querySelector('a')).toHaveClass('tour-box-float');
+ });
+
+ it('does not add tour-box-float for earlier items in a long list', () => {
+ // storyOrder.length=4, index=0: length-(0+1)=3, length-(0+2)=2 → no float
+ const { container } = renderComponent({ index: 0, storyOrder: ['a', 'b', 'c', 'd'] });
+ expect(container.querySelector('a')).not.toHaveClass('tour-box-float');
+ });
+ });
+
+ describe('onMouseOver', () => {
+ it('updates backgroundImage to hover image on mouse over', () => {
+ const { container } = renderComponent({
+ backgroundImageHover: 'hover.jpg',
+ storyId: 'story-1',
+ });
+ const anchor = container.querySelector('a');
+ act(() => { fireEvent.mouseOver(anchor); });
+ expect(anchor.style.backgroundImage).toContain(
+ 'config/metadata/stories/story-1/hover.jpg',
+ );
+ });
+
+ it('does not change style on mouse over when backgroundImageHover is absent', () => {
+ const { container } = renderComponent({
+ backgroundImage: 'cover.jpg',
+ backgroundImageHover: undefined,
+ storyId: 'story-1',
+ });
+ const anchor = container.querySelector('a');
+ const originalBg = anchor.style.backgroundImage;
+ act(() => { fireEvent.mouseOver(anchor); });
+ expect(anchor.style.backgroundImage).toBe(originalBg);
+ });
+ });
+
+ describe('onMouseOut', () => {
+ it('restores original backgroundImage on mouse out after hover', () => {
+ const { container } = renderComponent({
+ backgroundImage: 'cover.jpg',
+ backgroundImageHover: 'hover.jpg',
+ storyId: 'story-1',
+ });
+ const anchor = container.querySelector('a');
+ act(() => { fireEvent.mouseOver(anchor); });
+ expect(anchor.style.backgroundImage).toContain('hover.jpg');
+ act(() => { fireEvent.mouseOut(anchor); });
+ expect(anchor.style.backgroundImage).toContain(
+ 'config/metadata/stories/story-1/cover.jpg',
+ );
+ });
+
+ it('does not change style on mouse out when backgroundImage is absent', () => {
+ const { container } = renderComponent({
+ backgroundImage: undefined,
+ backgroundImageHover: undefined,
+ });
+ const anchor = container.querySelector('a');
+ act(() => { fireEvent.mouseOut(anchor); });
+ expect(anchor.style.backgroundImage).toBe('');
+ });
+ });
+
+ describe('onClick — selectTour', () => {
+ it('calls selectTour with event, story, index, storyId when clicked', () => {
+ const selectTour = jest.fn();
+ const story = { id: 'story-1', title: 'S' };
+ const { container } = renderComponent({ selectTour, story, index: 2, storyId: 'story-1' });
+ act(() => { fireEvent.click(container.querySelector('a')); });
+ expect(selectTour).toHaveBeenCalledTimes(1);
+ expect(selectTour).toHaveBeenCalledWith(
+ expect.objectContaining({ type: 'click' }),
+ story,
+ 2,
+ 'story-1',
+ );
+ });
+ });
});
diff --git a/web/js/components/tour/tour-boxes.test.js b/web/js/components/tour/tour-boxes.test.js
index 76987e957..b6b3a1fa5 100644
--- a/web/js/components/tour/tour-boxes.test.js
+++ b/web/js/components/tour/tour-boxes.test.js
@@ -1,3 +1,132 @@
-test('tour-boxes component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import TourBoxes from './tour-boxes';
+jest.mock('./tour-box', () => function MockTourBox({
+ index, storyId, title, description, selectTour, className,
+}) {
+ return (
+ <div
+ data-testid={`tour-box-${storyId}`}
+ data-index={index}
+ data-classname={className}
+ >
+ <span data-testid={`title-${storyId}`}>{title}</span>
+ <span data-testid={`desc-${storyId}`}>{description}</span>
+ <button
+ type="button"
+ data-testid={`select-${storyId}`}
+ onClick={() => selectTour({}, {}, index, storyId)}
+ >
+ Select
+ </button>
+ </div>
+ );
+});
+
+const makeStories = (...ids) => Object.fromEntries(
+ ids.map((id, i) => [id, {
+ id,
+ title: `Story ${i + 1}`,
+ description: `Desc ${i + 1}`,
+ type: `type-${i + 1}`,
+ backgroundImage: `bg${i + 1}.jpg`,
+ backgroundImageHover: `bg${i + 1}-hover.jpg`,
+ }]),
+);
+
+const defaultProps = {
+ stories: makeStories('s1', 's2', 's3'),
+ storyOrder: ['s1', 's2', 's3'],
+ selectTour: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <TourBoxes {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('TourBoxes', () => {
+ describe('container structure', () => {
+ it('renders the tour-box-container div', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.tour-box-container')).toBeInTheDocument();
+ });
+
+ it('renders the tour-box-row div inside the container', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.tour-box-row')).toBeInTheDocument();
+ });
+ });
+
+ describe('TourBox rendering', () => {
+ it('renders one TourBox per storyOrder entry', () => {
+ renderComponent();
+ expect(screen.getAllByTestId(/^tour-box-/)).toHaveLength(3);
+ });
+
+ it('renders each story by its storyId', () => {
+ renderComponent();
+ expect(screen.getByTestId('tour-box-s1')).toBeInTheDocument();
+ expect(screen.getByTestId('tour-box-s2')).toBeInTheDocument();
+ expect(screen.getByTestId('tour-box-s3')).toBeInTheDocument();
+ });
+
+ it('passes the correct index to each TourBox', () => {
+ renderComponent();
+ expect(screen.getByTestId('tour-box-s1')).toHaveAttribute('data-index', '0');
+ expect(screen.getByTestId('tour-box-s2')).toHaveAttribute('data-index', '1');
+ expect(screen.getByTestId('tour-box-s3')).toHaveAttribute('data-index', '2');
+ });
+
+ it('passes the story title to each TourBox', () => {
+ renderComponent();
+ expect(screen.getByTestId('title-s1')).toHaveTextContent('Story 1');
+ expect(screen.getByTestId('title-s2')).toHaveTextContent('Story 2');
+ });
+
+ it('passes the story description to each TourBox', () => {
+ renderComponent();
+ expect(screen.getByTestId('desc-s1')).toHaveTextContent('Desc 1');
+ });
+
+ it('passes className as "tour-box <story.type>" to each TourBox', () => {
+ renderComponent();
+ expect(screen.getByTestId('tour-box-s1')).toHaveAttribute('data-classname', 'tour-box type-1');
+ expect(screen.getByTestId('tour-box-s2')).toHaveAttribute('data-classname', 'tour-box type-2');
+ });
+
+ it('renders no TourBoxes when storyOrder is empty', () => {
+ renderComponent({ storyOrder: [] });
+ expect(screen.queryAllByTestId(/^tour-box-/)).toHaveLength(0);
+ });
+
+ it('renders a single TourBox when storyOrder has one entry', () => {
+ const stories = makeStories('only');
+ renderComponent({ stories, storyOrder: ['only'] });
+ expect(screen.getAllByTestId(/^tour-box-/)).toHaveLength(1);
+ });
+ });
+
+ describe('selectTour propagation', () => {
+ it('calls selectTour when a TourBox fires it', () => {
+ const selectTour = jest.fn();
+ renderComponent({ selectTour });
+ act(() => { fireEvent.click(screen.getByTestId('select-s1')); });
+ expect(selectTour).toHaveBeenCalledTimes(1);
+ expect(selectTour).toHaveBeenCalledWith({}, {}, 0, 's1');
+ });
+
+ it('passes the correct index when the second box is selected', () => {
+ const selectTour = jest.fn();
+ renderComponent({ selectTour });
+ act(() => { fireEvent.click(screen.getByTestId('select-s2')); });
+ expect(selectTour).toHaveBeenCalledWith({}, {}, 1, 's2');
+ });
+ });
});
diff --git a/web/js/components/tour/widget-steps.test.js b/web/js/components/tour/widget-steps.test.js
index 8eff9e582..2492ba7ff 100644
--- a/web/js/components/tour/widget-steps.test.js
+++ b/web/js/components/tour/widget-steps.test.js
@@ -1,3 +1,142 @@
-test('widget-steps component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Steps from './widget-steps';
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon }) => <span data-testid={`fa-${icon}`} />,
+}));
+
+const defaultProps = {
+ currentStep: 1,
+ totalSteps: 3,
+ decreaseStep: jest.fn(),
+ incrementStep: jest.fn(),
+ isKioskModeActive: false,
+};
+
+const renderComponent = (props = {}) => render(
+ <Steps {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('Steps (widget-steps)', () => {
+ describe('structure', () => {
+ it('renders the step-container div', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.step-container')).toBeInTheDocument();
+ });
+
+ it('renders the step counter', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.step-counter')).toBeInTheDocument();
+ });
+
+ it('displays the current step number', () => {
+ const { container } = renderComponent({ currentStep: 2 });
+ expect(container.querySelector('.step-current')).toHaveTextContent('2');
+ });
+
+ it('displays the total steps number', () => {
+ const { container } = renderComponent({ totalSteps: 5 });
+ expect(container.querySelector('.step-total')).toHaveTextContent('5');
+ });
+ });
+
+ describe('button classes — isKioskModeActive=false', () => {
+ it('Previous button has class "step-previous" when not in kiosk mode', () => {
+ renderComponent({ isKioskModeActive: false });
+ expect(screen.getByRole('button', { name: 'Previous' })).toHaveClass('step-previous');
+ });
+
+ it('Next button has class "step-next" when not in kiosk mode', () => {
+ renderComponent({ isKioskModeActive: false });
+ expect(screen.getByRole('button', { name: 'Next' })).toHaveClass('step-next');
+ });
+ });
+
+ describe('button classes — isKioskModeActive=true', () => {
+ it('Previous button has class "d-none" in kiosk mode', () => {
+ renderComponent({ isKioskModeActive: true });
+ expect(screen.getByRole('button', { name: 'Previous' })).toHaveClass('d-none');
+ });
+
+ it('Next button has class "d-none" in kiosk mode', () => {
+ renderComponent({ isKioskModeActive: true });
+ expect(screen.getByRole('button', { name: 'Next' })).toHaveClass('d-none');
+ });
+ });
+
+ describe('Next button icon — currentStep vs totalSteps', () => {
+ it('shows arrow-circle-right icon when currentStep < totalSteps', () => {
+ renderComponent({ currentStep: 1, totalSteps: 3 });
+ expect(screen.getByTestId('fa-arrow-circle-right')).toBeInTheDocument();
+ expect(screen.queryByTestId('fa-check-circle')).not.toBeInTheDocument();
+ });
+
+ it('shows check-circle icon when currentStep === totalSteps', () => {
+ renderComponent({ currentStep: 3, totalSteps: 3 });
+ expect(screen.getByTestId('fa-check-circle')).toBeInTheDocument();
+ expect(screen.queryByTestId('fa-arrow-circle-right')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('button clicks', () => {
+ it('calls decreaseStep when Previous is clicked', () => {
+ const decreaseStep = jest.fn();
+ renderComponent({ decreaseStep });
+ act(() => { fireEvent.click(screen.getByRole('button', { name: 'Previous' })); });
+ expect(decreaseStep).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls incrementStep when Next is clicked', () => {
+ const incrementStep = jest.fn();
+ renderComponent({ incrementStep });
+ act(() => { fireEvent.click(screen.getByRole('button', { name: 'Next' })); });
+ expect(incrementStep).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe('keyboard listener — isKioskModeActive=true', () => {
+ it('calls decreaseStep when "q" key is pressed in kiosk mode', () => {
+ const decreaseStep = jest.fn();
+ renderComponent({ isKioskModeActive: true, decreaseStep });
+ act(() => { fireEvent.keyDown(document, { key: 'q' }); });
+ expect(decreaseStep).toHaveBeenCalledTimes(1);
+ });
+
+ it('calls incrementStep when "w" key is pressed in kiosk mode', () => {
+ const incrementStep = jest.fn();
+ renderComponent({ isKioskModeActive: true, incrementStep });
+ act(() => { fireEvent.keyDown(document, { key: 'w' }); });
+ expect(incrementStep).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call decreaseStep or incrementStep for other keys in kiosk mode', () => {
+ const decreaseStep = jest.fn();
+ const incrementStep = jest.fn();
+ renderComponent({ isKioskModeActive: true, decreaseStep, incrementStep });
+ act(() => { fireEvent.keyDown(document, { key: 'Enter' }); });
+ expect(decreaseStep).not.toHaveBeenCalled();
+ expect(incrementStep).not.toHaveBeenCalled();
+ });
+
+ it('does not attach keyboard listener when isKioskModeActive=false', () => {
+ const decreaseStep = jest.fn();
+ renderComponent({ isKioskModeActive: false, decreaseStep });
+ act(() => { fireEvent.keyDown(document, { key: 'q' }); });
+ expect(decreaseStep).not.toHaveBeenCalled();
+ });
+
+ it('removes keyboard listener on unmount', () => {
+ const decreaseStep = jest.fn();
+ const { unmount } = renderComponent({ isKioskModeActive: true, decreaseStep });
+ act(() => { unmount(); });
+ act(() => { fireEvent.keyDown(document, { key: 'q' }); });
+ expect(decreaseStep).not.toHaveBeenCalled();
+ });
+ });
});
diff --git a/web/js/components/util/alert.test.js b/web/js/components/util/alert.test.js
index 893568600..3d53ee482 100644
--- a/web/js/components/util/alert.test.js
+++ b/web/js/components/util/alert.test.js
@@ -1,3 +1,244 @@
-test('alert component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import AlertUtil from './alert';
+jest.mock('reactstrap', () => ({
+ Alert: ({ children, isOpen, id, className }) => (
+ isOpen
+ ? <div data-testid="alert" id={id} className={className}>{children}</div>
+ : null
+ ),
+}));
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, className }) => (
+ <span data-testid={`fa-${icon}`} className={className} />
+ ),
+}));
+
+const defaultProps = {
+ id: 'test-alert',
+ isOpen: true,
+ message: 'Test message',
+ messageTitle: 'Test title',
+ noPortal: true,
+};
+
+const renderComponent = (props = {}) => render(
+ <AlertUtil {...defaultProps} {...props} />,
+);
+
+beforeEach(() => {
+ jest.useFakeTimers();
+ // Ensure no portal container exists unless the test creates one
+ const existing = document.getElementById('wv-alert-container');
+ if (existing) existing.remove();
+});
+
+afterEach(() => {
+ jest.runAllTimers();
+ jest.useRealTimers();
+ const container = document.getElementById('wv-alert-container');
+ if (container) container.remove();
+});
+
+describe('AlertUtil', () => {
+ describe('render — noPortal=true', () => {
+ it('renders the Alert when isOpen=true', () => {
+ renderComponent();
+ expect(screen.getByTestId('alert')).toBeInTheDocument();
+ });
+
+ it('does not render the Alert when isOpen=false', () => {
+ renderComponent({ isOpen: false });
+ expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+ });
+
+ it('renders the alert-content div', () => {
+ renderComponent();
+ expect(screen.getByRole('alertdialog')).toBeInTheDocument();
+ });
+
+ it('renders messageTitle', () => {
+ renderComponent({ messageTitle: 'Warning!' });
+ expect(screen.getByText('Warning!')).toBeInTheDocument();
+ });
+
+ it('renders message', () => {
+ renderComponent({ message: 'Something went wrong.' });
+ expect(screen.getByText('Something went wrong.')).toBeInTheDocument();
+ });
+
+ it('applies wv-alert className to the Alert', () => {
+ renderComponent();
+ expect(screen.getByTestId('alert')).toHaveClass('wv-alert');
+ });
+
+ it('passes the id prop to the Alert', () => {
+ renderComponent({ id: 'my-alert' });
+ expect(document.getElementById('my-alert')).toBeInTheDocument();
+ });
+
+ it('passes the title prop to the alert-content div', () => {
+ renderComponent({ title: 'Hover tip' });
+ expect(screen.getByRole('alertdialog')).toHaveAttribute('title', 'Hover tip');
+ });
+ });
+
+ describe('icon', () => {
+ it('renders the default exclamation-triangle icon when icon prop is empty', () => {
+ renderComponent({ icon: '' });
+ expect(screen.getByTestId('fa-exclamation-triangle')).toBeInTheDocument();
+ });
+
+ it('renders the supplied icon when icon prop is set', () => {
+ renderComponent({ icon: 'info-circle' });
+ expect(screen.getByTestId('fa-info-circle')).toBeInTheDocument();
+ expect(screen.queryByTestId('fa-exclamation-triangle')).not.toBeInTheDocument();
+ });
+
+ it('icon has wv-alert-icon class', () => {
+ renderComponent();
+ expect(screen.getByTestId('fa-exclamation-triangle')).toHaveClass('wv-alert-icon');
+ });
+ });
+
+ describe('paddingRight — onDismiss presence', () => {
+ it('sets paddingRight=8 when onDismiss is not provided', () => {
+ renderComponent({ onDismiss: undefined });
+ expect(screen.getByRole('alertdialog')).toHaveStyle({ paddingRight: '8px' });
+ });
+
+ it('sets paddingRight=5 when onDismiss is provided', () => {
+ renderComponent({ onDismiss: jest.fn() });
+ expect(screen.getByRole('alertdialog')).toHaveStyle({ paddingRight: '5px' });
+ });
+ });
+
+ describe('close button — onDismiss', () => {
+ it('does not render the close button when onDismiss is absent', () => {
+ renderComponent({ onDismiss: undefined });
+ expect(screen.queryByRole('button')).not.toBeInTheDocument();
+ });
+
+ it('renders the close button when onDismiss is provided', () => {
+ renderComponent({ onDismiss: jest.fn() });
+ expect(screen.getByRole('button')).toBeInTheDocument();
+ });
+
+ it('close button id is "<id>-close"', () => {
+ renderComponent({ id: 'my-alert', onDismiss: jest.fn() });
+ expect(document.getElementById('my-alert-close')).toBeInTheDocument();
+ });
+
+ it('close button has close-alert class', () => {
+ renderComponent({ onDismiss: jest.fn() });
+ expect(screen.getByRole('button')).toHaveClass('close-alert');
+ });
+
+ it('renders the times icon inside the close button', () => {
+ renderComponent({ onDismiss: jest.fn() });
+ expect(screen.getByTestId('fa-times')).toBeInTheDocument();
+ });
+ });
+
+ describe('closeAlert()', () => {
+ it('calls onDismiss when close button is clicked', () => {
+ const onDismiss = jest.fn();
+ renderComponent({ onDismiss });
+ act(() => { fireEvent.click(screen.getByRole('button')); });
+ expect(onDismiss).toHaveBeenCalledTimes(1);
+ });
+
+ it('hides the alert after close button is clicked', () => {
+ const onDismiss = jest.fn();
+ renderComponent({ onDismiss });
+ act(() => { fireEvent.click(screen.getByRole('button')); });
+ expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('onClick on alertdialog', () => {
+ it('calls onClick prop when the alert-content area is clicked', () => {
+ const onClick = jest.fn();
+ renderComponent({ onClick });
+ act(() => { fireEvent.click(screen.getByRole('alertdialog')); });
+ expect(onClick).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ describe('timeout auto-dismiss', () => {
+ it('calls onDismiss after the timeout elapses', () => {
+ const onDismiss = jest.fn();
+ renderComponent({ timeout: 3000, onDismiss });
+ expect(onDismiss).not.toHaveBeenCalled();
+ act(() => { jest.advanceTimersByTime(3000); });
+ expect(onDismiss).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call onDismiss before timeout elapses', () => {
+ const onDismiss = jest.fn();
+ renderComponent({ timeout: 3000, onDismiss });
+ act(() => { jest.advanceTimersByTime(2999); });
+ expect(onDismiss).not.toHaveBeenCalled();
+ });
+
+ it('does not set a timeout when timeout prop is absent', () => {
+ const onDismiss = jest.fn();
+ renderComponent({ onDismiss });
+ act(() => { jest.advanceTimersByTime(99999); });
+ expect(onDismiss).not.toHaveBeenCalled();
+ });
+
+ it('does not set a timeout when onDismiss is absent', () => {
+ // Should not throw even with a timeout value but no onDismiss
+ expect(() => renderComponent({ timeout: 1000 })).not.toThrow();
+ act(() => { jest.advanceTimersByTime(1000); });
+ });
+ });
+
+ describe('componentWillUnmount — clears timeout', () => {
+ it('clears pending timeout on unmount without errors', () => {
+ const onDismiss = jest.fn();
+ const { unmount } = renderComponent({ timeout: 5000, onDismiss });
+ act(() => { unmount(); });
+ act(() => { jest.runAllTimers(); });
+ expect(onDismiss).not.toHaveBeenCalled();
+ });
+
+ it('unmounts cleanly when no timeout was set', () => {
+ const { unmount } = renderComponent();
+ expect(() => act(() => { unmount(); })).not.toThrow();
+ });
+ });
+
+ describe('portal rendering', () => {
+ it('renders into the wv-alert-container portal when noPortal=false and container exists', () => {
+ const portalContainer = document.createElement('div');
+ portalContainer.id = 'wv-alert-container';
+ document.body.appendChild(portalContainer);
+
+ renderComponent({ noPortal: false });
+
+ expect(portalContainer.querySelector('[data-testid="alert"]')).toBeInTheDocument();
+ });
+
+ it('falls back to inline render when noPortal=false but container is absent', () => {
+ // No portal container in DOM
+ const { container } = renderComponent({ noPortal: false });
+ expect(container.querySelector('[data-testid="alert"]')).toBeInTheDocument();
+ });
+
+ it('renders inline (noPortal=true) regardless of portal container presence', () => {
+ const portalContainer = document.createElement('div');
+ portalContainer.id = 'wv-alert-container';
+ document.body.appendChild(portalContainer);
+
+ const { container } = renderComponent({ noPortal: true });
+ expect(container.querySelector('[data-testid="alert"]')).toBeInTheDocument();
+ expect(portalContainer.querySelector('[data-testid="alert"]')).not.toBeInTheDocument();
+ });
+ });
});
diff --git a/web/js/components/util/arrow.test.js b/web/js/components/util/arrow.test.js
index bc02bbb7e..cef36b6da 100644
--- a/web/js/components/util/arrow.test.js
+++ b/web/js/components/util/arrow.test.js
@@ -1,3 +1,122 @@
-test('arrow component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Arrow from './arrow';
+jest.mock('@edsc/earthdata-react-icons/horizon-design-system/hds/ui', () => ({
+ ArrowFilledUp: ({ className, size }) => (
+ <span data-testid="arrow-icon" className={className} data-size={size} />
+ ),
+}));
+
+const defaultProps = {
+ onClick: jest.fn(),
+ type: 'day',
+ direction: 'up',
+ isKioskModeActive: false,
+ arrowSize: '16px',
+};
+
+const renderComponent = (props = {}) => render(
+ <Arrow {...defaultProps} {...props} />,
+);
+
+describe('Arrow', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('button element', () => {
+ it('renders a button', () => {
+ renderComponent();
+ expect(screen.getByRole('button')).toBeInTheDocument();
+ });
+
+ it('button has type="button"', () => {
+ renderComponent();
+ expect(screen.getByRole('button')).toHaveAttribute('type', 'button');
+ });
+
+ it('sets data-interval to the type prop', () => {
+ renderComponent({ type: 'month' });
+ expect(screen.getByRole('button')).toHaveAttribute('data-interval', 'month');
+ });
+ });
+
+ describe('aria-label', () => {
+ it('sets aria-label to "Increment {type}" when direction is "up"', () => {
+ renderComponent({ direction: 'up', type: 'day' });
+ expect(screen.getByRole('button')).toHaveAttribute('aria-label', 'Increment day');
+ });
+
+ it('sets aria-label to "Decrement {type}" when direction is "down"', () => {
+ renderComponent({ direction: 'down', type: 'year' });
+ expect(screen.getByRole('button')).toHaveAttribute('aria-label', 'Decrement year');
+ });
+
+ it('sets aria-label to "Decrement {type}" for non-up direction', () => {
+ renderComponent({ direction: 'left', type: 'hour' });
+ expect(screen.getByRole('button')).toHaveAttribute('aria-label', 'Decrement hour');
+ });
+ });
+
+ describe('className — kiosk mode', () => {
+ it('applies "d-none" when isKioskModeActive is true', () => {
+ renderComponent({ isKioskModeActive: true, direction: 'up' });
+ expect(screen.getByRole('button')).toHaveClass('d-none');
+ });
+
+ it('does not apply "d-none" when isKioskModeActive is false', () => {
+ renderComponent({ isKioskModeActive: false, direction: 'up' });
+ expect(screen.getByRole('button')).not.toHaveClass('d-none');
+ });
+
+ it('applies "date-arrows date-arrow-up" when isKioskModeActive is false and direction is "up"', () => {
+ renderComponent({ isKioskModeActive: false, direction: 'up' });
+ expect(screen.getByRole('button')).toHaveClass('date-arrows', 'date-arrow-up');
+ });
+
+ it('applies "date-arrows date-arrow-down" when isKioskModeActive is false and direction is "down"', () => {
+ renderComponent({ isKioskModeActive: false, direction: 'down' });
+ expect(screen.getByRole('button')).toHaveClass('date-arrows', 'date-arrow-down');
+ });
+ });
+
+ describe('onClick handler', () => {
+ it('calls onClick when the button is clicked', () => {
+ const onClick = jest.fn();
+ renderComponent({ onClick });
+ fireEvent.click(screen.getByRole('button'));
+ expect(onClick).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call onClick before the button is clicked', () => {
+ const onClick = jest.fn();
+ renderComponent({ onClick });
+ expect(onClick).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('ArrowFilledUp icon', () => {
+ it('renders the icon', () => {
+ renderComponent();
+ expect(screen.getByTestId('arrow-icon')).toBeInTheDocument();
+ });
+
+ it('sets className to "{direction}arrow" on the icon', () => {
+ renderComponent({ direction: 'up' });
+ expect(screen.getByTestId('arrow-icon')).toHaveClass('uparrow');
+ });
+
+ it('sets className to "downarrow" when direction is "down"', () => {
+ renderComponent({ direction: 'down' });
+ expect(screen.getByTestId('arrow-icon')).toHaveClass('downarrow');
+ });
+
+ it('passes arrowSize as size to the icon', () => {
+ renderComponent({ arrowSize: '24px' });
+ expect(screen.getByTestId('arrow-icon')).toHaveAttribute('data-size', '24px');
+ });
+ });
});
diff --git a/web/js/components/util/button.test.js b/web/js/components/util/button.test.js
index 3968b2466..5380b5858 100644
--- a/web/js/components/util/button.test.js
+++ b/web/js/components/util/button.test.js
@@ -1,3 +1,137 @@
-test('button component test', () => {
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import Button from './button';
+const defaultProps = {
+ text: 'Click me',
+ onClick: jest.fn(),
+};
+
+const renderComponent = (props = {}) => render(
+ <Button {...defaultProps} {...props} />,
+);
+
+describe('Button', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('button element', () => {
+ it('renders a button', () => {
+ renderComponent();
+ expect(screen.getByRole('button')).toBeInTheDocument();
+ });
+
+ it('has type="button"', () => {
+ renderComponent();
+ expect(screen.getByRole('button')).toHaveAttribute('type', 'button');
+ });
+
+ it('renders the text inside a span with class "button-text"', () => {
+ renderComponent({ text: 'Save' });
+ const span = screen.getByText('Save');
+ expect(span).toHaveClass('button-text');
+ });
+
+ it('renders a React node as text', () => {
+ renderComponent({ text: <strong data-testid="node-text">Bold</strong> });
+ expect(screen.getByTestId('node-text')).toBeInTheDocument();
+ });
+ });
+
+ describe('id prop', () => {
+ it('sets id attribute when provided', () => {
+ renderComponent({ id: 'my-btn' });
+ expect(screen.getByRole('button')).toHaveAttribute('id', 'my-btn');
+ });
+
+ it('defaults id to empty string', () => {
+ renderComponent();
+ expect(screen.getByRole('button')).toHaveAttribute('id', '');
+ });
+ });
+
+ describe('style prop', () => {
+ it('applies inline style when provided', () => {
+ renderComponent({ style: { color: 'red' } });
+ expect(screen.getByRole('button')).toHaveStyle({ color: 'rgb(255, 0, 0)' });
+ });
+
+ it('defaults style to null (no inline style)', () => {
+ renderComponent();
+ expect(screen.getByRole('button').getAttribute('style')).toBeNull();
+ });
+ });
+
+ describe('valid prop — className and disabled', () => {
+ it('applies "wv-button gray" when valid is true and no className given', () => {
+ renderComponent({ valid: true });
+ expect(screen.getByRole('button')).toHaveClass('wv-button', 'gray');
+ expect(screen.getByRole('button')).not.toHaveClass('wv-disabled');
+ });
+
+ it('applies "wv-disabled wv-button gray" when valid is false', () => {
+ renderComponent({ valid: false });
+ expect(screen.getByRole('button')).toHaveClass('wv-disabled', 'wv-button', 'gray');
+ });
+
+ it('is not disabled when valid is true', () => {
+ renderComponent({ valid: true });
+ expect(screen.getByRole('button')).not.toBeDisabled();
+ });
+
+ it('is disabled when valid is false', () => {
+ renderComponent({ valid: false });
+ expect(screen.getByRole('button')).toBeDisabled();
+ });
+
+ it('defaults valid to true', () => {
+ renderComponent();
+ expect(screen.getByRole('button')).not.toBeDisabled();
+ });
+ });
+
+ describe('className prop', () => {
+ it('uses supplied className in the valid class string', () => {
+ renderComponent({ className: 'red', valid: true });
+ expect(screen.getByRole('button')).toHaveClass('wv-button', 'red');
+ });
+
+ it('uses supplied className in the disabled class string', () => {
+ renderComponent({ className: 'red', valid: false });
+ expect(screen.getByRole('button')).toHaveClass('wv-disabled', 'wv-button', 'red');
+ });
+
+ it('defaults className to "gray"', () => {
+ renderComponent();
+ expect(screen.getByRole('button')).toHaveClass('gray');
+ });
+ });
+
+ describe('onClick handler', () => {
+ it('calls onClick when clicked', () => {
+ const onClick = jest.fn();
+ renderComponent({ onClick });
+ fireEvent.click(screen.getByRole('button'));
+ expect(onClick).toHaveBeenCalledTimes(1);
+ });
+
+ it('does not call onClick before being clicked', () => {
+ const onClick = jest.fn();
+ renderComponent({ onClick });
+ expect(onClick).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('onMouseDown handler', () => {
+ it('calls stopPropagation on mousedown', () => {
+ renderComponent();
+ const btn = screen.getByRole('button');
+ const stopPropagation = jest.fn();
+ fireEvent.mouseDown(btn, { stopPropagation });
+ // stopPropagation is synthetic — verify the button still exists and no error thrown
+ expect(btn).toBeInTheDocument();
+ });
+ });
});