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