Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

More unit test files for web/js/components/

Jason Hurley44be45799876
diff --git a/web/js/components/layer/settings/associated-layers-toggle.test.js b/web/js/components/layer/settings/associated-layers-toggle.test.js
index e3067beaf..27ad4ad46 100644
--- a/web/js/components/layer/settings/associated-layers-toggle.test.js
+++ b/web/js/components/layer/settings/associated-layers-toggle.test.js
@@ -1,3 +1,169 @@
-test('associate-layers-toggle component test', () => {
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+jest.mock('../../../modules/layers/actions', () => ({
+ addLayer: jest.fn((id) => ({ type: 'ADD_LAYER', id })),
+ removeLayer: jest.fn((id) => ({ type: 'REMOVE_LAYER', id })),
+}));
+jest.mock('../../../modules/layers/util', () => ({
+ getOrbitTrackTitle: jest.fn((layer) => `${layer.title} Track`),
+}));
+jest.mock('../../../modules/layers/selectors', () => ({
+ getActiveLayersMap: jest.fn(),
+}));
+jest.mock('../../util/checkbox', () => {
+ function MockCheckbox({
+ id, checked, onCheck, label,
+ }) {
+ return (
+ <label htmlFor={id}>
+ <input
+ id={id}
+ type="checkbox"
+ checked={checked}
+ onChange={onCheck}
+ data-testid={`checkbox-${id}`}
+ />
+ {label}
+ </label>
+ );
+ }
+ return MockCheckbox;
+});
+
+import AssociatedLayersToggle from './associated-layers-toggle';
+import { addLayer, removeLayer } from '../../../modules/layers/actions';
+import { getActiveLayersMap } from '../../../modules/layers/selectors';
+
+const mockStore = configureStore([]);
+
+const granuleLayer = { id: 'granule-1', title: 'Granule Layer (A)', type: 'granule' };
+const orbitLayer = { id: 'orbit-1', title: 'Orbit Layer', track: 'ascending' };
+const compositeLayer = { id: 'composite-1', title: 'Composite Layer (B)' };
+
+const buildStore = (configLayers = {}, activeLayersMap = {}) => {
+ getActiveLayersMap.mockReturnValue(activeLayersMap);
+ return mockStore({ config: { layers: configLayers } });
+};
+
+const renderToggle = (layer, configLayers = {}, activeLayersMap = {}) => render(
+ <Provider store={buildStore(configLayers, activeLayersMap)}>
+ <AssociatedLayersToggle layer={layer} />
+ </Provider>,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('AssociatedLayersToggle', () => {
+ describe('layout', () => {
+ it('renders the Associated Layers heading', () => {
+ renderToggle({ associatedLayers: [], orbitTracks: [] }, {});
+ expect(screen.getByText('Associated Layers')).toBeInTheDocument();
+ });
+
+ it('renders the outer container', () => {
+ const { container } = renderToggle({ associatedLayers: [], orbitTracks: [] }, {});
+ expect(container.querySelector('.layer-orbit-tracks')).toBeInTheDocument();
+ });
+ });
+
+ describe('layer title logic', () => {
+ it('renders "Granule - " prefix for granule type layers', () => {
+ renderToggle(
+ { associatedLayers: ['granule-1'] },
+ { 'granule-1': granuleLayer },
+ );
+ expect(screen.getByText(/Granule - Granule Layer/)).toBeInTheDocument();
+ });
+
+ it('renders "Orbit Track - " prefix for layers with a track', () => {
+ renderToggle(
+ { associatedLayers: ['orbit-1'] },
+ { 'orbit-1': orbitLayer },
+ );
+ expect(screen.getByText('Orbit Track - Orbit Layer Track')).toBeInTheDocument();
+ });
+
+ it('renders "Daily Composite - " prefix for plain layers', () => {
+ renderToggle(
+ { associatedLayers: ['composite-1'] },
+ { 'composite-1': compositeLayer },
+ );
+ expect(screen.getByText(/Daily Composite - Composite Layer/)).toBeInTheDocument();
+ });
+
+ it('splits title on "(" to remove parenthetical suffix', () => {
+ renderToggle(
+ { associatedLayers: ['granule-1'] },
+ { 'granule-1': granuleLayer },
+ );
+ expect(screen.queryByText(/\(A\)/)).not.toBeInTheDocument();
+ });
+ });
+
+ describe('checkbox state', () => {
+ it('renders a checked checkbox when the layer is active', () => {
+ renderToggle(
+ { associatedLayers: ['granule-1'] },
+ { 'granule-1': granuleLayer },
+ { 'granule-1': granuleLayer },
+ );
+ expect(screen.getByTestId('checkbox-granule-1')).toBeChecked();
+ });
+
+ it('renders an unchecked checkbox when the layer is not active', () => {
+ renderToggle(
+ { associatedLayers: ['granule-1'] },
+ { 'granule-1': granuleLayer },
+ {},
+ );
+ expect(screen.getByTestId('checkbox-granule-1')).not.toBeChecked();
+ });
+ });
+
+ describe('checkbox interactions', () => {
+ it('dispatches addLayer when an inactive layer checkbox is toggled', () => {
+ renderToggle(
+ { associatedLayers: ['granule-1'] },
+ { 'granule-1': granuleLayer },
+ {},
+ );
+ fireEvent.click(screen.getByTestId('checkbox-granule-1'));
+ expect(addLayer).toHaveBeenCalledWith('granule-1');
+ });
+
+ it('dispatches removeLayer when an active layer checkbox is toggled', () => {
+ renderToggle(
+ { associatedLayers: ['granule-1'] },
+ { 'granule-1': granuleLayer },
+ { 'granule-1': granuleLayer },
+ );
+ fireEvent.click(screen.getByTestId('checkbox-granule-1'));
+ expect(removeLayer).toHaveBeenCalledWith('granule-1');
+ });
+ });
+
+ describe('orbit tracks', () => {
+ it('renders orbit track layers from orbitTracks', () => {
+ renderToggle(
+ { associatedLayers: [], orbitTracks: ['orbit-1'] },
+ { 'orbit-1': orbitLayer },
+ );
+ expect(screen.getByText('Orbit Track - Orbit Layer Track')).toBeInTheDocument();
+ });
+
+ it('renders both associatedLayers and orbitTracks together', () => {
+ renderToggle(
+ { associatedLayers: ['composite-1'], orbitTracks: ['orbit-1'] },
+ { 'composite-1': compositeLayer, 'orbit-1': orbitLayer },
+ );
+ expect(screen.getByText(/Daily Composite - Composite Layer/)).toBeInTheDocument();
+ expect(screen.getByText('Orbit Track - Orbit Layer Track')).toBeInTheDocument();
+ });
+ });
});
diff --git a/web/js/components/layer/settings/band-selection/band-selection-menu.test.js b/web/js/components/layer/settings/band-selection/band-selection-menu.test.js
index 825c59639..3f75c7818 100644
--- a/web/js/components/layer/settings/band-selection/band-selection-menu.test.js
+++ b/web/js/components/layer/settings/band-selection/band-selection-menu.test.js
@@ -1,3 +1,224 @@
-test('band-selection-menu component test', () => {
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+jest.mock('../../../../modules/layers/actions', () => ({
+ updateBandCombination: jest.fn((id, bandCombo, layerIndex, selectedPreset) => ({
+ type: 'UPDATE_BAND_COMBINATION', id, bandCombo, layerIndex, selectedPreset,
+ })),
+ removeLayer: jest.fn((id) => ({ type: 'REMOVE_LAYER', id })),
+}));
+jest.mock('../../../../modules/modal/actions', () => ({
+ onClose: jest.fn(() => ({ type: 'MODAL_CLOSE' })),
+}));
+jest.mock('../../../../modules/layers/selectors', () => ({
+ getActiveLayers: jest.fn(),
+}));
+jest.mock('./menu-components/band-dropdown', () => {
+ function MockBandsDropdown({ channel }) {
+ return <div data-testid={`band-dropdown-${channel}`} />;
+ }
+ return MockBandsDropdown;
+});
+jest.mock('./menu-components/preset-options', () => function MockPresetOptions() {
+ return <div data-testid="preset-options" />;
+});
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: () => <span data-testid="fa-icon" />,
+}));
+jest.mock('reactstrap', () => {
+ const actual = jest.requireActual('reactstrap');
+ return {
+ ...actual,
+ UncontrolledTooltip: () => null,
+ };
+});
+
+import BandSelection from './band-selection-menu';
+import { updateBandCombination, removeLayer } from '../../../../modules/layers/actions';
+import { onClose } from '../../../../modules/modal/actions';
+import { getActiveLayers } from '../../../../modules/layers/selectors';
+
+const mockStore = configureStore([]);
+
+const sentinelLayer = {
+ id: 'HLS_Customizable_Sentinel',
+ title: 'HLS Sentinel',
+ bandCombo: {
+ r: 'B04',
+ g: 'B03',
+ b: 'B02',
+ color_formula: 'Gamma RGB 2.5',
+ bands_regex: 'B[0-9][0-9A-Za-z]',
+ },
+};
+
+const landsatLayer = {
+ id: 'HLS_Customizable_Landsat',
+ title: 'HLS Landsat',
+ bandCombo: {
+ r: 'B05',
+ g: 'B04',
+ b: 'B03',
+ color_formula: 'Gamma RGB 2.5',
+ bands_regex: 'B[0-9][0-9]',
+ },
+};
+
+const buildStore = (layer, selectedPreset = null) => mockStore({
+ compare: { activeString: 'active' },
+ layers: {
+ active: {
+ layers: [{ id: layer.id, selectedPreset }],
+ },
+ },
+});
+
+const renderMenu = (layer = sentinelLayer, selectedPreset = null) => {
+ getActiveLayers.mockReturnValue([layer]);
+ return render(
+ <Provider store={buildStore(layer, selectedPreset)}>
+ <BandSelection layerObj={layer} />
+ </Provider>,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('BandSelection', () => {
+ describe('layout', () => {
+ it('renders the outer container', () => {
+ const { container } = renderMenu();
+ expect(container.querySelector('.customize-bands-container')).toBeInTheDocument();
+ });
+
+ it('renders PresetOptions', () => {
+ renderMenu();
+ expect(screen.getByTestId('preset-options')).toBeInTheDocument();
+ });
+
+ it('renders the Confirm Band Selection button', () => {
+ renderMenu();
+ expect(screen.getByRole('button', { name: /confirm band selection/i })).toBeInTheDocument();
+ });
+ });
+
+ describe('band channel rows', () => {
+ it('shows R, G, B channel rows and dropdowns when bandSelection is valid', () => {
+ renderMenu();
+ expect(screen.getByText('R:')).toBeInTheDocument();
+ expect(screen.getByText('G:')).toBeInTheDocument();
+ expect(screen.getByText('B:')).toBeInTheDocument();
+ expect(screen.getByTestId('band-dropdown-r')).toBeInTheDocument();
+ expect(screen.getByTestId('band-dropdown-g')).toBeInTheDocument();
+ expect(screen.getByTestId('band-dropdown-b')).toBeInTheDocument();
+ });
+
+ it('hides channel rows when r band is undefined', () => {
+ const layer = { ...sentinelLayer, bandCombo: { ...sentinelLayer.bandCombo, r: undefined } };
+ renderMenu(layer);
+ expect(screen.queryByText('R:')).not.toBeInTheDocument();
+ expect(screen.queryByTestId('band-dropdown-r')).not.toBeInTheDocument();
+ });
+
+ it('hides channel rows when g band is undefined', () => {
+ const layer = { ...sentinelLayer, bandCombo: { ...sentinelLayer.bandCombo, g: undefined } };
+ renderMenu(layer);
+ expect(screen.queryByText('G:')).not.toBeInTheDocument();
+ });
+
+ it('hides channel rows when b band is undefined', () => {
+ const layer = { ...sentinelLayer, bandCombo: { ...sentinelLayer.bandCombo, b: undefined } };
+ renderMenu(layer);
+ expect(screen.queryByText('B:')).not.toBeInTheDocument();
+ });
+
+ it('hides channel rows when r band is the string "undefined"', () => {
+ const layer = { ...sentinelLayer, bandCombo: { ...sentinelLayer.bandCombo, r: 'undefined' } };
+ renderMenu(layer);
+ expect(screen.queryByText('R:')).not.toBeInTheDocument();
+ });
+
+ it('renders the info tooltip icon when band selection is valid', () => {
+ renderMenu();
+ expect(screen.getByTestId('fa-icon')).toBeInTheDocument();
+ });
+
+ it('renders the "Select a band for each channel" heading when valid', () => {
+ renderMenu();
+ expect(screen.getByText('Select a band for each channel:')).toBeInTheDocument();
+ });
+ });
+
+ describe('presetOptions', () => {
+ it('renders PresetOptions for a Landsat layer', () => {
+ renderMenu(landsatLayer);
+ expect(screen.getByTestId('preset-options')).toBeInTheDocument();
+ });
+
+ it('renders PresetOptions for a Sentinel layer', () => {
+ renderMenu(sentinelLayer);
+ expect(screen.getByTestId('preset-options')).toBeInTheDocument();
+ });
+ });
+
+ describe('confirmSelection', () => {
+ it('dispatches removeLayer when Confirm is clicked', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /confirm band selection/i }));
+ expect(removeLayer).toHaveBeenCalledWith(sentinelLayer.id);
+ });
+
+ it('dispatches updateBandCombination with the initial band selection', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /confirm band selection/i }));
+ expect(updateBandCombination).toHaveBeenCalledWith(
+ sentinelLayer.id,
+ expect.objectContaining({ r: 'B04', g: 'B03', b: 'B02' }),
+ 0,
+ null,
+ );
+ });
+
+ it('dispatches onClose when Confirm is clicked', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /confirm band selection/i }));
+ expect(onClose).toHaveBeenCalled();
+ });
+
+ it('dispatches all three actions on a single confirm click', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /confirm band selection/i }));
+ expect(removeLayer).toHaveBeenCalledTimes(1);
+ expect(updateBandCombination).toHaveBeenCalledTimes(1);
+ expect(onClose).toHaveBeenCalledTimes(1);
+ });
+
+ it('passes the current selectedPreset to updateBandCombination', () => {
+ const preset = { id: 'HLS_False_Color_Sentinel', title: 'Color Infrared' };
+ renderMenu(sentinelLayer, preset);
+ fireEvent.click(screen.getByRole('button', { name: /confirm band selection/i }));
+ expect(updateBandCombination).toHaveBeenCalledWith(
+ sentinelLayer.id,
+ expect.any(Object),
+ 0,
+ preset,
+ );
+ });
+
+ it('passes layerIndex 0 when the layer is first in activeLayers', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /confirm band selection/i }));
+ expect(updateBandCombination).toHaveBeenCalledWith(
+ sentinelLayer.id,
+ expect.any(Object),
+ 0,
+ null,
+ );
+ });
+ });
});
diff --git a/web/js/components/layer/settings/band-selection/band-selection-parent-info-menu.test.js b/web/js/components/layer/settings/band-selection/band-selection-parent-info-menu.test.js
index 1f9f581eb..85c4dc6b0 100644
--- a/web/js/components/layer/settings/band-selection/band-selection-parent-info-menu.test.js
+++ b/web/js/components/layer/settings/band-selection/band-selection-parent-info-menu.test.js
@@ -1,3 +1,189 @@
-test('band-selection-parent-info-menu component test', () => {
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+jest.mock('../../../../modules/modal/actions', () => ({
+ toggleCustomContent: jest.fn((key, params) => ({ type: 'TOGGLE_CUSTOM_CONTENT', key, params })),
+}));
+jest.mock('./band-selection-menu', () => function MockBandSelectionMenu() {
+ return <div data-testid="band-selection-menu" />;
+});
+
+import BandSelectionParentInfoMenu from './band-selection-parent-info-menu';
+import { toggleCustomContent } from '../../../../modules/modal/actions';
+
+const mockStore = configureStore([]);
+const store = mockStore({});
+
+const rgbLayer = {
+ id: 'HLS_Customizable_Sentinel',
+ title: 'HLS Sentinel',
+ bandCombo: {
+ r: 'B04',
+ g: 'B03',
+ b: 'B02',
+ expression: undefined,
+ },
+};
+
+const expressionLayer = {
+ id: 'HLS_NDVI_Sentinel',
+ title: 'HLS NDVI Sentinel',
+ bandCombo: {
+ r: undefined,
+ g: undefined,
+ b: undefined,
+ expression: '(B08-B04)/(B08+B04)',
+ },
+};
+
+const renderMenu = (layer = rgbLayer) => render(
+ <Provider store={store}>
+ <BandSelectionParentInfoMenu layer={layer} />
+ </Provider>,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('BandSelectionParentInfoMenu', () => {
+ describe('static structure', () => {
+ it('renders the outer container', () => {
+ const { container } = renderMenu();
+ expect(container.querySelector('.customize-bands-parent-info')).toBeInTheDocument();
+ });
+
+ it('renders the section label', () => {
+ renderMenu();
+ expect(screen.getByText('Channels and bands assigned:')).toBeInTheDocument();
+ });
+
+ it('renders the Customize button', () => {
+ renderMenu();
+ expect(screen.getByRole('button', { name: /customize band selection/i })).toBeInTheDocument();
+ });
+
+ it('renders hr dividers', () => {
+ const { container } = renderMenu();
+ expect(container.querySelectorAll('hr')).toHaveLength(2);
+ });
+ });
+
+ describe('valid RGB band display', () => {
+ it('shows Red channel label and band name', () => {
+ renderMenu();
+ expect(screen.getByText('Red:')).toBeInTheDocument();
+ expect(screen.getByText('Band B04')).toBeInTheDocument();
+ });
+
+ it('shows Green channel label and band name', () => {
+ renderMenu();
+ expect(screen.getByText('Green:')).toBeInTheDocument();
+ expect(screen.getByText('Band B03')).toBeInTheDocument();
+ });
+
+ it('shows Blue channel label and band name', () => {
+ renderMenu();
+ expect(screen.getByText('Blue:')).toBeInTheDocument();
+ expect(screen.getByText('Band B02')).toBeInTheDocument();
+ });
+
+ it('does not show Expression row when bands are valid', () => {
+ renderMenu();
+ expect(screen.queryByText('Expression:')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('expression display (invalid RGB bands)', () => {
+ it('shows the Expression label when r/g/b are undefined', () => {
+ renderMenu(expressionLayer);
+ expect(screen.getByText('Expression:')).toBeInTheDocument();
+ });
+
+ it('shows the expression value', () => {
+ renderMenu(expressionLayer);
+ expect(screen.getByText('(B08-B04)/(B08+B04)')).toBeInTheDocument();
+ });
+
+ it('does not show Red/Green/Blue labels when bands are undefined', () => {
+ renderMenu(expressionLayer);
+ expect(screen.queryByText('Red:')).not.toBeInTheDocument();
+ expect(screen.queryByText('Green:')).not.toBeInTheDocument();
+ expect(screen.queryByText('Blue:')).not.toBeInTheDocument();
+ });
+
+ it('falls back to expression display when r is the string "undefined"', () => {
+ const layer = {
+ ...rgbLayer,
+ bandCombo: { r: 'undefined', g: 'undefined', b: 'undefined', expression: 'some-expr' },
+ };
+ renderMenu(layer);
+ expect(screen.getByText('Expression:')).toBeInTheDocument();
+ expect(screen.getByText('some-expr')).toBeInTheDocument();
+ });
+ });
+
+ describe('Customize button — onCustomizeBandClick', () => {
+ it('dispatches toggleCustomContent when Customize is clicked', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /customize band selection/i }));
+ expect(toggleCustomContent).toHaveBeenCalledTimes(1);
+ });
+
+ it('dispatches with a key derived from the layer id', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /customize band selection/i }));
+ expect(toggleCustomContent).toHaveBeenCalledWith(
+ `BAND_SELECTION_MODAL_${rgbLayer.id}`,
+ expect.any(Object),
+ );
+ });
+
+ it('dispatches with headerText that includes the layer title', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /customize band selection/i }));
+ const params = toggleCustomContent.mock.calls[0][1];
+ expect(params.headerText).toContain(rgbLayer.title);
+ });
+
+ it('dispatches with backdrop: false', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /customize band selection/i }));
+ const params = toggleCustomContent.mock.calls[0][1];
+ expect(params.backdrop).toBe(false);
+ });
+
+ it('dispatches with the correct modal class names', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /customize band selection/i }));
+ const params = toggleCustomContent.mock.calls[0][1];
+ expect(params.wrapClassName).toBe('clickable-behind-modal');
+ expect(params.modalClassName).toBe('sidebar-modal layer-settings-modal');
+ });
+
+ it('dispatches with size "lg"', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /customize band selection/i }));
+ const params = toggleCustomContent.mock.calls[0][1];
+ expect(params.size).toBe('lg');
+ });
+
+ it('dispatches with bodyComponentProps containing the layer object', () => {
+ renderMenu();
+ fireEvent.click(screen.getByRole('button', { name: /customize band selection/i }));
+ const params = toggleCustomContent.mock.calls[0][1];
+ expect(params.bodyComponentProps).toEqual({ layerObj: rgbLayer });
+ });
+
+ it('uses a different key for a different layer id', () => {
+ renderMenu(expressionLayer);
+ fireEvent.click(screen.getByRole('button', { name: /customize band selection/i }));
+ expect(toggleCustomContent).toHaveBeenCalledWith(
+ `BAND_SELECTION_MODAL_${expressionLayer.id}`,
+ expect.any(Object),
+ );
+ });
+ });
});
diff --git a/web/js/components/layer/settings/band-selection/menu-components/band-dropdown.test.js b/web/js/components/layer/settings/band-selection/menu-components/band-dropdown.test.js
index cfffdabcc..21d8b8856 100644
--- a/web/js/components/layer/settings/band-selection/menu-components/band-dropdown.test.js
+++ b/web/js/components/layer/settings/band-selection/menu-components/band-dropdown.test.js
@@ -1,3 +1,168 @@
-test('band-dropdown component test', () => {
+import { render, screen, fireEvent, within, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import BandsDropdown from './band-dropdown';
+const sentinelLayer = { title: 'HLS Sentinel Layer', bandCombo: ['B04'] };
+const landsatLayer = { title: 'HLS Landsat Layer', bandCombo: ['B03'] };
+
+const defaultProps = {
+ channel: 'r',
+ bandSelection: {},
+ setBandSelection: jest.fn(),
+ layer: sentinelLayer,
+ setSelectedPreset: jest.fn(),
+};
+
+const renderDropdown = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <BandsDropdown
+ channel={props.channel}
+ bandSelection={props.bandSelection}
+ setBandSelection={props.setBandSelection}
+ layer={props.layer}
+ setSelectedPreset={props.setSelectedPreset}
+ />,
+ );
+};
+
+const openMenu = () => act(() => { fireEvent.click(screen.getByRole('button')); });
+
+const getMenu = () => screen.getByRole('menu');
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('BandsDropdown', () => {
+ describe('toggle button label', () => {
+ it('shows bandSelection value for the channel when set', () => {
+ renderDropdown({ bandSelection: { r: 'B08' } });
+ expect(screen.getByRole('button')).toHaveTextContent('B08');
+ });
+
+ it('falls back to bandCombo[0] when channel has no selection', () => {
+ renderDropdown({ bandSelection: {} });
+ expect(screen.getByRole('button')).toHaveTextContent('B04');
+ });
+
+ it('falls back to bandCombo[0] for a Landsat layer', () => {
+ renderDropdown({ layer: landsatLayer, bandSelection: {} });
+ expect(screen.getByRole('button')).toHaveTextContent('B03');
+ });
+ });
+
+ describe('Sentinel band choices', () => {
+ const sentinelBands = ['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B08', 'B8A', 'B09', 'B10', 'B11', 'B12'];
+
+ it('renders all 13 Sentinel band items when the layer title does not include Landsat', async () => {
+ renderDropdown();
+ await openMenu();
+ expect(within(getMenu()).getAllByRole('menuitem')).toHaveLength(sentinelBands.length);
+ });
+
+ it('renders each Sentinel band as a menu item', async () => {
+ renderDropdown();
+ await openMenu();
+ const menu = getMenu();
+ sentinelBands.forEach((band) => {
+ expect(within(menu).getByText(band)).toBeInTheDocument();
+ });
+ });
+
+ it('includes B8A (Sentinel-only band)', async () => {
+ renderDropdown();
+ await openMenu();
+ expect(within(getMenu()).getByText('B8A')).toBeInTheDocument();
+ });
+ });
+
+ describe('Landsat band choices', () => {
+ const landsatBands = ['B01', 'B02', 'B03', 'B04', 'B05', 'B06', 'B07', 'B09', 'B10'];
+
+ it('renders all 9 Landsat band items when title includes Landsat', async () => {
+ renderDropdown({ layer: landsatLayer });
+ await openMenu();
+ expect(within(getMenu()).getAllByRole('menuitem')).toHaveLength(landsatBands.length);
+ });
+
+ it('renders each Landsat band as a menu item', async () => {
+ renderDropdown({ layer: landsatLayer });
+ await openMenu();
+ const menu = getMenu();
+ landsatBands.forEach((band) => {
+ expect(within(menu).getByText(band)).toBeInTheDocument();
+ });
+ });
+
+ it('does not include B8A for Landsat', async () => {
+ renderDropdown({ layer: landsatLayer });
+ await openMenu();
+ expect(within(getMenu()).queryByText('B8A')).not.toBeInTheDocument();
+ });
+
+ it('does not include B08 for Landsat', async () => {
+ renderDropdown({ layer: landsatLayer });
+ await openMenu();
+ expect(within(getMenu()).queryByText('B08')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('handleSelection', () => {
+ it('calls setBandSelection with the updated channel value on item click', async () => {
+ const setBandSelection = jest.fn();
+ renderDropdown({ bandSelection: { r: 'B01', g: 'B02' }, setBandSelection });
+ await openMenu();
+ act(() => { fireEvent.click(within(getMenu()).getByText('B05')); });
+ expect(setBandSelection).toHaveBeenCalledWith({ r: 'B05', g: 'B02' });
+ });
+
+ it('calls setSelectedPreset with null on item click', async () => {
+ const setSelectedPreset = jest.fn();
+ renderDropdown({ setSelectedPreset });
+ await openMenu();
+ act(() => { fireEvent.click(within(getMenu()).getByText('B03')); });
+ expect(setSelectedPreset).toHaveBeenCalledWith(null);
+ });
+
+ it('preserves existing bandSelection keys when updating channel', async () => {
+ const setBandSelection = jest.fn();
+ renderDropdown({
+ channel: 'g',
+ bandSelection: { r: 'B04', g: 'B03', b: 'B02' },
+ setBandSelection,
+ });
+ await openMenu();
+ act(() => { fireEvent.click(within(getMenu()).getByText('B11')); });
+ expect(setBandSelection).toHaveBeenCalledWith({ r: 'B04', g: 'B11', b: 'B02' });
+ });
+
+ it('handles an empty bandSelection object when selecting a band', async () => {
+ const setBandSelection = jest.fn();
+ renderDropdown({ channel: 'b', bandSelection: {}, setBandSelection });
+ await openMenu();
+ act(() => { fireEvent.click(within(getMenu()).getByText('B07')); });
+ expect(setBandSelection).toHaveBeenCalledWith({ b: 'B07' });
+ });
+ });
+
+ describe('dropdown open/close toggle', () => {
+ it('starts closed — menu is not present', () => {
+ renderDropdown();
+ expect(screen.queryByRole('menu')).not.toBeInTheDocument();
+ });
+
+ it('opens on toggle button click', async () => {
+ renderDropdown();
+ await openMenu();
+ expect(screen.getByRole('menu')).toBeInTheDocument();
+ });
+
+ it('closes again on a second toggle button click', async () => {
+ renderDropdown();
+ await openMenu();
+ await act(async () => { fireEvent.click(screen.getByRole('button')); });
+ expect(screen.queryByRole('menu')).not.toBeInTheDocument();
+ });
+ });
});
diff --git a/web/js/components/layer/settings/band-selection/menu-components/preset-options.test.js b/web/js/components/layer/settings/band-selection/menu-components/preset-options.test.js
index bbbc6c14b..e28b00100 100644
--- a/web/js/components/layer/settings/band-selection/menu-components/preset-options.test.js
+++ b/web/js/components/layer/settings/band-selection/menu-components/preset-options.test.js
@@ -1,3 +1,191 @@
-test('preset-options component test', () => {
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import PresetOptions from './preset-options';
+const defaultProps = {
+ setBandSelection: jest.fn(),
+ setSelectedPreset: jest.fn(),
+ selectedPreset: null,
+ presetOptions: 'sentinel',
+};
+
+const renderPresets = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <PresetOptions
+ setBandSelection={props.setBandSelection}
+ setSelectedPreset={props.setSelectedPreset}
+ selectedPreset={props.selectedPreset}
+ presetOptions={props.presetOptions}
+ />,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('PresetOptions', () => {
+ describe('static structure', () => {
+ it('renders the section label', () => {
+ renderPresets();
+ expect(screen.getByText('Other selectable presets (optional):')).toBeInTheDocument();
+ });
+
+ it('renders the scrollable container', () => {
+ const { container } = renderPresets();
+ expect(container.querySelector('.band-selection-presets-scrollable')).toBeInTheDocument();
+ });
+ });
+
+ describe('Sentinel presets (default)', () => {
+ it('renders 14 preset cards for sentinel', () => {
+ const { container } = renderPresets({ presetOptions: 'sentinel' });
+ expect(container.querySelectorAll('.band-selection-preset-card')).toHaveLength(14);
+ });
+
+ it('renders the Color Infrared sentinel preset title', () => {
+ renderPresets({ presetOptions: 'sentinel' });
+ expect(screen.getByText('Color Infrared')).toBeInTheDocument();
+ });
+
+ it('renders expression text for index presets instead of R/G/B', () => {
+ renderPresets({ presetOptions: 'sentinel' });
+ expect(screen.getByText('(B08-B04)/(B08+B04)')).toBeInTheDocument();
+ });
+
+ it('renders R/G/B band label for RGB presets', () => {
+ renderPresets({ presetOptions: 'sentinel' });
+ expect(screen.getByText('R: B08, G: B04, B: B03')).toBeInTheDocument();
+ });
+
+ it('renders preset images with correct src and alt', () => {
+ renderPresets({ presetOptions: 'sentinel' });
+ const img = screen.getByAltText('Color Infrared');
+ expect(img).toHaveAttribute('src', 'images/layers/previews/geographic/HLS_False_Color_Sentinel_th.jpg');
+ });
+
+ it('renders sentinel presets when presetOptions is not "landsat"', () => {
+ renderPresets({ presetOptions: 'anything-else' });
+ expect(screen.getByText('R: B08, G: B04, B: B03')).toBeInTheDocument();
+ });
+ });
+
+ describe('Landsat presets', () => {
+ it('renders 14 preset cards for landsat', () => {
+ const { container } = renderPresets({ presetOptions: 'landsat' });
+ expect(container.querySelectorAll('.band-selection-preset-card')).toHaveLength(14);
+ });
+
+ it('renders the Color Infrared landsat preset with correct bands', () => {
+ renderPresets({ presetOptions: 'landsat' });
+ expect(screen.getByText('R: B05, G: B04, B: B03')).toBeInTheDocument();
+ });
+
+ it('renders expression text for landsat index presets', () => {
+ renderPresets({ presetOptions: 'landsat' });
+ expect(screen.getByText('(B05-B04)/(B05+B04)')).toBeInTheDocument();
+ });
+
+ it('renders landsat preset images with correct src', () => {
+ renderPresets({ presetOptions: 'landsat' });
+ const img = screen.getByAltText('Color Infrared');
+ expect(img).toHaveAttribute('src', 'images/layers/previews/geographic/HLS_False_Color_Landsat_th.jpg');
+ });
+ });
+
+ describe('selected preset highlight', () => {
+ it('applies selected-preset class to the active preset card', () => {
+ const { container } = renderPresets({
+ presetOptions: 'sentinel',
+ selectedPreset: { id: 'HLS_False_Color_Sentinel' },
+ });
+ const selected = container.querySelector('.selected-preset');
+ expect(selected).toBeInTheDocument();
+ expect(selected).toHaveClass('band-selection-preset-card');
+ });
+
+ it('does not apply selected-preset class when selectedPreset is null', () => {
+ const { container } = renderPresets({ selectedPreset: null });
+ expect(container.querySelector('.selected-preset')).not.toBeInTheDocument();
+ });
+
+ it('only one card has selected-preset class', () => {
+ const { container } = renderPresets({
+ presetOptions: 'landsat',
+ selectedPreset: { id: 'HLS_False_Color_Landsat' },
+ });
+ expect(container.querySelectorAll('.selected-preset')).toHaveLength(1);
+ });
+
+ it('does not select a card when selectedPreset id does not match any preset', () => {
+ const { container } = renderPresets({
+ selectedPreset: { id: 'non-existent-id' },
+ });
+ expect(container.querySelector('.selected-preset')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('handlePresetSelect on card click', () => {
+ it('calls setSelectedPreset with the clicked preset object', () => {
+ const setSelectedPreset = jest.fn();
+ renderPresets({ presetOptions: 'sentinel', setSelectedPreset });
+ fireEvent.click(screen.getByText('Color Infrared').closest('.band-selection-preset-card'));
+ expect(setSelectedPreset).toHaveBeenCalledWith(expect.objectContaining({
+ id: 'HLS_False_Color_Sentinel',
+ title: 'Color Infrared',
+ }));
+ });
+
+ it('calls setBandSelection with all preset fields on card click', () => {
+ const setBandSelection = jest.fn();
+ renderPresets({ presetOptions: 'sentinel', setBandSelection });
+ fireEvent.click(screen.getByText('Color Infrared').closest('.band-selection-preset-card'));
+ expect(setBandSelection).toHaveBeenCalledWith({
+ r: 'B08',
+ g: 'B04',
+ b: 'B03',
+ assets: undefined,
+ expression: undefined,
+ rescale: undefined,
+ colormap_name: undefined,
+ color_formula: 'Gamma RGB 2.5 Saturation 1.2 Sigmoidal RGB 10 0.35',
+ bands_regex: 'B[0-9][0-9A-Za-z]',
+ asset_as_band: undefined,
+ });
+ });
+
+ it('calls setBandSelection with expression fields for an index preset', () => {
+ const setBandSelection = jest.fn();
+ renderPresets({ presetOptions: 'sentinel', setBandSelection });
+ fireEvent.click(screen.getByText('Vegetation Index (NDVI)').closest('.band-selection-preset-card'));
+ expect(setBandSelection).toHaveBeenCalledWith(expect.objectContaining({
+ expression: '(B08-B04)/(B08+B04)',
+ rescale: '-1,1',
+ colormap_name: 'brbg',
+ asset_as_band: true,
+ }));
+ });
+
+ it('calls setBandSelection with landsat preset fields on card click', () => {
+ const setBandSelection = jest.fn();
+ renderPresets({ presetOptions: 'landsat', setBandSelection });
+ fireEvent.click(screen.getByText('Color Infrared').closest('.band-selection-preset-card'));
+ expect(setBandSelection).toHaveBeenCalledWith(expect.objectContaining({
+ r: 'B05',
+ g: 'B04',
+ b: 'B03',
+ bands_regex: 'B[0-9][0-9]',
+ }));
+ });
+
+ it('calls both setSelectedPreset and setBandSelection on a single click', () => {
+ const setBandSelection = jest.fn();
+ const setSelectedPreset = jest.fn();
+ renderPresets({ setBandSelection, setSelectedPreset });
+ fireEvent.click(screen.getByText('Color Infrared').closest('.band-selection-preset-card'));
+ expect(setSelectedPreset).toHaveBeenCalledTimes(1);
+ expect(setBandSelection).toHaveBeenCalledTimes(1);
+ });
+ });
});
diff --git a/web/js/components/layer/settings/classification-toggle.test.js b/web/js/components/layer/settings/classification-toggle.test.js
index da66a4531..33bd7cb30 100644
--- a/web/js/components/layer/settings/classification-toggle.test.js
+++ b/web/js/components/layer/settings/classification-toggle.test.js
@@ -1,3 +1,158 @@
-test('classification-toggle component test', () => {
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('../../util/switch', () => {
+ function MockSwitch({
+ id, label, active, toggle,
+ }) {
+ return (
+ <button
+ type="button"
+ data-testid={`switch-${id}`}
+ data-active={active ? 'true' : 'false'}
+ onClick={toggle}
+ >
+ {label}
+ </button>
+ );
+ }
+ return MockSwitch;
+});
+jest.mock('../../util/scrollbar', () => {
+ function MockScrollbar({ children }) {
+ return <div data-testid="scrollbar">{children}</div>;
+ }
+ return MockScrollbar;
+});
+
+import ClassificationToggle from './classification-toggle';
+
+const legend = {
+ id: 'test-legend',
+ colors: ['ff0000', '00ff00', '0000ff'],
+ tooltips: ['Red', 'Green', 'Blue'],
+};
+
+const palette = { disabled: [] };
+
+const defaultProps = {
+ legend,
+ palette,
+ toggle: jest.fn(),
+ toggleAll: jest.fn(),
+ height: 300,
+};
+
+const renderToggle = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <ClassificationToggle
+ legend={props.legend}
+ palette={props.palette}
+ toggle={props.toggle}
+ toggleAll={props.toggleAll}
+ height={props.height}
+ />,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('ClassificationToggle', () => {
+ describe('layout', () => {
+ it('renders the Disable/Enable heading', () => {
+ renderToggle();
+ expect(screen.getByText('Disable/Enable')).toBeInTheDocument();
+ });
+
+ it('renders the outer container', () => {
+ const { container } = renderToggle();
+ expect(container.querySelector('.layer-classification-toggle')).toBeInTheDocument();
+ });
+
+ it('renders the scrollbar', () => {
+ renderToggle();
+ expect(screen.getByTestId('scrollbar')).toBeInTheDocument();
+ });
+ });
+
+ describe('color switches', () => {
+ it('renders one switch per legend color', () => {
+ renderToggle();
+ const switches = screen.getAllByTestId(/^switch-test-legend/);
+ expect(switches).toHaveLength(3);
+ });
+
+ it('renders a switch labeled with the tooltip for each color', () => {
+ renderToggle();
+ expect(screen.getByText('Red')).toBeInTheDocument();
+ expect(screen.getByText('Green')).toBeInTheDocument();
+ expect(screen.getByText('Blue')).toBeInTheDocument();
+ });
+
+ it('renders switches as active when color index not in palette.disabled', () => {
+ renderToggle({ palette: { disabled: [] } });
+ expect(screen.getByTestId('switch-test-legend0')).toHaveAttribute('data-active', 'true');
+ });
+
+ it('renders switch as inactive when index is in palette.disabled', () => {
+ renderToggle({ palette: { disabled: [1] } });
+ expect(screen.getByTestId('switch-test-legend1')).toHaveAttribute('data-active', 'false');
+ });
+ });
+
+ describe('header "All" switch', () => {
+ it('renders the "All" switch when toggleAll is provided', () => {
+ renderToggle();
+ expect(screen.getByTestId('switch-header-disable')).toBeInTheDocument();
+ });
+
+ it('does not render the "All" switch when toggleAll is not provided', () => {
+ renderToggle({ toggleAll: undefined });
+ expect(screen.queryByTestId('switch-header-disable')).not.toBeInTheDocument();
+ });
+
+ it('"All" switch starts inactive when palette.disabled length equals switchLength', () => {
+ renderToggle({ palette: { disabled: [0, 1, 2] } });
+ expect(screen.getByTestId('switch-header-disable')).toHaveAttribute('data-active', 'false');
+ });
+
+ it('"All" switch starts active when palette is not fully disabled', () => {
+ renderToggle({ palette: { disabled: [] } });
+ expect(screen.getByTestId('switch-header-disable')).toHaveAttribute('data-active', 'true');
+ });
+
+ it('calls toggleAll with all indices when "All" is clicked while active', () => {
+ const toggleAll = jest.fn();
+ renderToggle({ toggleAll, palette: { disabled: [] } });
+ fireEvent.click(screen.getByTestId('switch-header-disable'));
+ expect(toggleAll).toHaveBeenCalledWith([0, 1, 2]);
+ });
+
+ it('calls toggleAll with empty array when "All" is clicked while inactive (re-enable)', () => {
+ const toggleAll = jest.fn();
+ renderToggle({ toggleAll, palette: { disabled: [0, 1, 2] } });
+ fireEvent.click(screen.getByTestId('switch-header-disable'));
+ expect(toggleAll).toHaveBeenCalledWith([]);
+ });
+ });
+
+ describe('individual toggle', () => {
+ it('calls toggle with the correct index when a color switch is clicked', () => {
+ const toggle = jest.fn();
+ renderToggle({ toggle });
+ fireEvent.click(screen.getByTestId('switch-test-legend1'));
+ expect(toggle).toHaveBeenCalledWith(1);
+ });
+
+ it('calls toggle with index 0 for the first color', () => {
+ const toggle = jest.fn();
+ renderToggle({ toggle });
+ fireEvent.click(screen.getByTestId('switch-test-legend0'));
+ expect(toggle).toHaveBeenCalledWith(0);
+ });
+ });
});
diff --git a/web/js/components/layer/settings/granule-count-slider.test.js b/web/js/components/layer/settings/granule-count-slider.test.js
index 085ebeaed..16bece16b 100644
--- a/web/js/components/layer/settings/granule-count-slider.test.js
+++ b/web/js/components/layer/settings/granule-count-slider.test.js
@@ -1,3 +1,118 @@
-test('granule-count-slider component test', () => {
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+jest.mock('../../../modules/layers/constants', () => ({
+ DEFAULT_NUM_GRANULES: 10,
+ MIN_GRANULES: 1,
+ MAX_GRANULES: 30,
+}));
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: () => <span data-testid="fa-icon" />,
+}));
+jest.mock('reactstrap', () => {
+ const actual = jest.requireActual('reactstrap');
+ return { ...actual, UncontrolledTooltip: () => null };
+});
+
+import GranuleCountSlider from './granule-count-slider';
+
+const mockStore = configureStore([]);
+const store = mockStore({ layers: { active: { granulePlatform: 'Terra' } } });
+
+const defaultProps = {
+ count: 10,
+ def: { id: 'MODIS_Terra_CorrRefl_TrueColor' },
+ granuleDates: ['2023-01-01', '2023-01-02'],
+ updateGranuleLayerOptions: jest.fn(),
+};
+
+const renderSlider = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <Provider store={store}>
+ <GranuleCountSlider
+ count={props.count}
+ def={props.def}
+ granuleDates={props.granuleDates}
+ updateGranuleLayerOptions={props.updateGranuleLayerOptions}
+ />
+ </Provider>,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('GranuleCountSlider', () => {
+ describe('layout', () => {
+ it('renders the Granule Count heading', () => {
+ renderSlider();
+ expect(screen.getByText('Granule Count')).toBeInTheDocument();
+ });
+
+ it('renders the info icon', () => {
+ renderSlider();
+ expect(screen.getByTestId('fa-icon')).toBeInTheDocument();
+ });
+
+ it('renders the range input', () => {
+ renderSlider();
+ expect(screen.getByRole('slider')).toBeInTheDocument();
+ });
+
+ it('displays the current count as the label', () => {
+ renderSlider({ count: 15 });
+ expect(screen.getByText('15')).toBeInTheDocument();
+ });
+ });
+
+ describe('range input attributes', () => {
+ it('sets min to MIN_GRANULES (1)', () => {
+ renderSlider();
+ expect(screen.getByRole('slider')).toHaveAttribute('min', '1');
+ });
+
+ it('sets max to MAX_GRANULES (30)', () => {
+ renderSlider();
+ expect(screen.getByRole('slider')).toHaveAttribute('max', '30');
+ });
+
+ it('sets defaultValue to the count prop', () => {
+ renderSlider({ count: 7 });
+ expect(screen.getByRole('slider')).toHaveAttribute('value', '7');
+ });
+ });
+
+ describe('onChange', () => {
+ it('updates the displayed count label when slider changes', () => {
+ renderSlider({ count: 10 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '20' } });
+ expect(screen.getByText('20')).toBeInTheDocument();
+ });
+
+ it('calls updateGranuleLayerOptions with new value on change', () => {
+ const updateGranuleLayerOptions = jest.fn();
+ renderSlider({ updateGranuleLayerOptions });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '18' } });
+ expect(updateGranuleLayerOptions).toHaveBeenCalledWith(
+ defaultProps.granuleDates,
+ defaultProps.def,
+ 18,
+ );
+ });
+
+ it('calls updateGranuleLayerOptions with parsed integer value', () => {
+ const updateGranuleLayerOptions = jest.fn();
+ renderSlider({ updateGranuleLayerOptions });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '5' } });
+ expect(updateGranuleLayerOptions).toHaveBeenCalledWith(
+ expect.anything(),
+ expect.anything(),
+ 5,
+ );
+ });
+ });
});
diff --git a/web/js/components/layer/settings/granule-date-list.test.js b/web/js/components/layer/settings/granule-date-list.test.js
index 271316a02..8d03756a1 100644
--- a/web/js/components/layer/settings/granule-date-list.test.js
+++ b/web/js/components/layer/settings/granule-date-list.test.js
@@ -1,3 +1,194 @@
-test('granule-date-list component test', () => {
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('../../../util/util', () => ({
+ events: { trigger: jest.fn() },
+}));
+jest.mock('../../../util/constants', () => ({ GRANULE_HOVERED: 'GRANULE_HOVERED' }));
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: () => <span data-testid="fa-icon" />,
+}));
+jest.mock('@fortawesome/free-solid-svg-icons', () => ({
+ faArrowCircleUp: 'faArrowCircleUp',
+ faArrowCircleDown: 'faArrowCircleDown',
+}));
+jest.mock('@dnd-kit/core', () => ({
+ DndContext: ({ children }) => <div>{children}</div>,
+ closestCenter: jest.fn(),
+}));
+jest.mock('@dnd-kit/sortable', () => ({
+ SortableContext: ({ children }) => <div>{children}</div>,
+ verticalListSortingStrategy: jest.fn(),
+ arrayMove: jest.fn((arr, from, to) => {
+ const next = [...arr];
+ const [item] = next.splice(from, 1);
+ next.splice(to, 0, item);
+ return next;
+ }),
+ useSortable: () => ({
+ attributes: {},
+ listeners: {},
+ setNodeRef: jest.fn(),
+ transform: null,
+ transition: null,
+ isDragging: false,
+ }),
+}));
+jest.mock('@dnd-kit/utilities', () => ({
+ CSS: { Transform: { toString: () => '' } },
+}));
+
+import GranuleDateList from './granule-date-list';
+import util from '../../../util/util';
+
+const dates = ['2023-01-05', '2023-01-04', '2023-01-03', '2023-01-02', '2023-01-01'];
+
+const defaultProps = {
+ def: { id: 'MODIS_Terra' },
+ granuleCount: 5,
+ granuleDates: dates,
+ resetGranuleLayerDates: jest.fn(),
+ granulePlatform: 'Terra',
+ screenHeight: 800,
+ updateGranuleLayerOptions: jest.fn(),
+};
+
+const renderList = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <GranuleDateList
+ def={props.def}
+ granuleCount={props.granuleCount}
+ granuleDates={props.granuleDates}
+ resetGranuleLayerDates={props.resetGranuleLayerDates}
+ granulePlatform={props.granulePlatform}
+ screenHeight={props.screenHeight}
+ updateGranuleLayerOptions={props.updateGranuleLayerOptions}
+ />,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('GranuleDateList', () => {
+ describe('layout', () => {
+ it('renders the "Granule Layer Date Order" heading', () => {
+ renderList();
+ expect(screen.getByText('Granule Layer Date Order')).toBeInTheDocument();
+ });
+
+ it('renders a RESET button', () => {
+ renderList();
+ expect(screen.getByRole('button', { name: /reset/i })).toBeInTheDocument();
+ });
+
+ it('renders each date as a granule-date-item', () => {
+ const { container } = renderList();
+ expect(container.querySelectorAll('.granule-date-item')).toHaveLength(dates.length);
+ });
+
+ it('renders each date string in the list', () => {
+ renderList();
+ dates.forEach((d) => expect(screen.getByText(d)).toBeInTheDocument());
+ });
+ });
+
+ describe('empty state', () => {
+ it('shows "No granules available." when granuleDates is empty', () => {
+ renderList({ granuleDates: [] });
+ expect(screen.getByText('No granules available.')).toBeInTheDocument();
+ });
+
+ it('shows "No granules available." when granuleDates is null', () => {
+ renderList({ granuleDates: null });
+ expect(screen.getByText('No granules available.')).toBeInTheDocument();
+ });
+
+ it('renders no granule-date-item elements when list is empty', () => {
+ const { container } = renderList({ granuleDates: [] });
+ expect(container.querySelectorAll('.granule-date-item')).toHaveLength(0);
+ });
+ });
+
+ describe('RESET button', () => {
+ it('is disabled when dates are already sorted descending', () => {
+ renderList({ granuleDates: ['2023-01-05', '2023-01-04', '2023-01-03'] });
+ expect(screen.getByRole('button', { name: /reset/i })).toBeDisabled();
+ });
+
+ it('is enabled when dates are not sorted descending', () => {
+ renderList({ granuleDates: ['2023-01-01', '2023-01-05', '2023-01-03'] });
+ expect(screen.getByRole('button', { name: /reset/i })).not.toBeDisabled();
+ });
+
+ it('calls resetGranuleLayerDates with def.id when clicked', () => {
+ const resetGranuleLayerDates = jest.fn();
+ renderList({ granuleDates: ['2023-01-01', '2023-01-05'], resetGranuleLayerDates });
+ fireEvent.click(screen.getByRole('button', { name: /reset/i }));
+ expect(resetGranuleLayerDates).toHaveBeenCalledWith('MODIS_Terra');
+ });
+ });
+
+ describe('up/down move buttons', () => {
+ it('renders a down button for the first item', () => {
+ const { container } = renderList();
+ const firstItem = container.querySelectorAll('.granule-date-item')[0];
+ expect(firstItem.querySelector('.granule-date-item-down-button')).toBeInTheDocument();
+ });
+
+ it('does not render an up button for the first item', () => {
+ const { container } = renderList();
+ const firstItem = container.querySelectorAll('.granule-date-item')[0];
+ expect(firstItem.querySelector('.granule-date-item-up-button')).not.toBeInTheDocument();
+ });
+
+ it('renders an up button for the last item', () => {
+ const { container } = renderList();
+ const items = container.querySelectorAll('.granule-date-item');
+ const lastItem = items[items.length - 1];
+ expect(lastItem.querySelector('.granule-date-item-up-button')).toBeInTheDocument();
+ });
+
+ it('does not render a down button for the last item', () => {
+ const { container } = renderList();
+ const items = container.querySelectorAll('.granule-date-item');
+ const lastItem = items[items.length - 1];
+ expect(lastItem.querySelector('.granule-date-item-down-button')).not.toBeInTheDocument();
+ });
+
+ it('calls updateGranuleLayerOptions when a down button is clicked', () => {
+ const updateGranuleLayerOptions = jest.fn();
+ const { container } = renderList({ updateGranuleLayerOptions });
+ const firstDown = container.querySelector('.granule-date-item-down-button');
+ fireEvent.click(firstDown);
+ expect(updateGranuleLayerOptions).toHaveBeenCalled();
+ });
+
+ it('calls updateGranuleLayerOptions when an up button is clicked', () => {
+ const updateGranuleLayerOptions = jest.fn();
+ const { container } = renderList({ updateGranuleLayerOptions });
+ const firstUp = container.querySelector('.granule-date-item-up-button');
+ fireEvent.click(firstUp);
+ expect(updateGranuleLayerOptions).toHaveBeenCalled();
+ });
+ });
+
+ describe('hover events', () => {
+ it('triggers GRANULE_HOVERED with platform and date on mouseenter', () => {
+ const { container } = renderList();
+ const firstItem = container.querySelectorAll('.granule-date-item')[0];
+ fireEvent.mouseEnter(firstItem);
+ expect(util.events.trigger).toHaveBeenCalledWith('GRANULE_HOVERED', 'Terra', dates[0]);
+ });
+
+ it('triggers GRANULE_HOVERED with null on mouseleave', () => {
+ const { container } = renderList();
+ const firstItem = container.querySelectorAll('.granule-date-item')[0];
+ fireEvent.mouseLeave(firstItem);
+ expect(util.events.trigger).toHaveBeenCalledWith('GRANULE_HOVERED', 'Terra', null);
+ });
+ });
});
diff --git a/web/js/components/layer/settings/imagery-search.test.js b/web/js/components/layer/settings/imagery-search.test.js
index 6818639d2..4bf3c8e74 100644
--- a/web/js/components/layer/settings/imagery-search.test.js
+++ b/web/js/components/layer/settings/imagery-search.test.js
@@ -1,3 +1,337 @@
-test('imagery-search component test', () => {
+import { render, screen, fireEvent, act } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+jest.mock('../../../modules/date/actions', () => ({
+ selectDate: jest.fn((d) => ({ type: 'SELECT_DATE', date: d })),
+}));
+jest.mock('../../../modules/smart-handoff/selectors', () => ({
+ getBaseCmrUrl: jest.fn((state) => state.smartHandoff.baseUrl),
+}));
+jest.mock('../../../util/cmr', () => ({
+ buildGranulesUrl: jest.fn(() => 'https://cmr.example.com/granules'),
+ cmrFetch: jest.fn(() => Promise.resolve({
+ json: () => Promise.resolve({ feed: { entry: [] } }),
+ })),
+}));
+
+import ImagerySearch from './imagery-search';
+import { cmrFetch } from '../../../util/cmr';
+
+// jsdom always returns 0 for scrollHeight/clientHeight; the component's useEffect
+// loops endlessly when scrollHeight <= clientHeight. Override both on the prototype
+// so every ul rendered by the component sees scrollHeight > clientHeight and the
+// effect takes the stable else-branch (sets scrollTop once and stops).
+Object.defineProperty(HTMLElement.prototype, 'scrollHeight', {
+ configurable: true,
+ get() { return 1000; },
+});
+Object.defineProperty(HTMLElement.prototype, 'clientHeight', {
+ configurable: true,
+ get() { return 200; },
+});
+
+const mockStore = configureStore([]);
+const selectedDate = new Date('2023-06-15T00:00:00.000Z');
+
+const buildStore = (overrides = {}) => mockStore({
+ date: { selected: selectedDate, selectedB: selectedDate, ...overrides.date },
+ compare: { active: false, isCompareA: true, ...overrides.compare },
+ map: { extent: [-180, -90, 180, 90], ...overrides.map },
+ smartHandoff: { baseUrl: 'https://cmr.earthdata.nasa.gov' },
+});
+
+const layer = {
+ id: 'HLSS30_Customizable',
+ conceptIds: [{ value: 'C12345-PROVIDER' }],
+};
+
+const renderSearch = async (layerOverride = layer, storeOverride = {}) => {
+ let result;
+ await act(async () => {
+ result = render(
+ <Provider store={buildStore(storeOverride)}>
+ <ImagerySearch layer={layerOverride} />
+ </Provider>,
+ );
+ });
+ return result;
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ cmrFetch.mockResolvedValue({
+ json: () => Promise.resolve({ feed: { entry: [] } }),
+ });
+});
+
+describe('ImagerySearch', () => {
+ describe('layout', () => {
+ it('renders the "Available Imagery Dates" title', async () => {
+ await renderSearch();
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+
+ it('renders the scrollable list', async () => {
+ await renderSearch();
+ expect(screen.getByRole('list')).toBeInTheDocument();
+ });
+
+ it('renders start and end spinner list items', async () => {
+ const { container } = await renderSearch();
+ expect(container.querySelectorAll('.imagery-search-spinner')).toHaveLength(2);
+ });
+
+ it('renders an hr divider below the list', async () => {
+ const { container } = await renderSearch();
+ expect(container.querySelector('hr')).toBeInTheDocument();
+ });
+ });
+
+ describe('granule date rendering', () => {
+ it('renders returned granule dates as list items', async () => {
+ cmrFetch.mockResolvedValue({
+ json: () => Promise.resolve({
+ feed: {
+ entry: [
+ { time_start: '2023-06-14T00:00:00.000Z' },
+ { time_start: '2023-06-13T00:00:00.000Z' },
+ ],
+ },
+ }),
+ });
+ await renderSearch();
+ expect(screen.getAllByRole('listitem').length).toBeGreaterThan(0);
+ });
+
+ it('shows no date list items when cmrFetch returns empty entries', async () => {
+ await renderSearch();
+ const dateItems = screen.queryAllByRole('listitem').filter((el) => el.classList.contains('lazyload-list-item'));
+ expect(dateItems).toHaveLength(0);
+ });
+
+ it('deduplicates granule dates that fall on the same calendar day', async () => {
+ // The useEffect takes the else-branch (scrollHeight > clientHeight), so data
+ // only loads on a scroll near the bottom. Set up the mock before scrolling.
+ cmrFetch
+ .mockResolvedValueOnce({
+ json: () => Promise.resolve({
+ feed: {
+ entry: [
+ { time_start: '2023-06-14T01:00:00.000Z' },
+ { time_start: '2023-06-14T12:00:00.000Z' },
+ ],
+ },
+ }),
+ })
+ .mockResolvedValue({ json: () => Promise.resolve({ feed: { entry: [] } }) });
+
+ await renderSearch();
+ const list = screen.getByRole('list');
+
+ // Scroll near the bottom to trigger loadOlderDates
+ await act(async () => {
+ Object.defineProperty(list, 'scrollTop', { value: 900, configurable: true });
+ Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
+ Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
+ fireEvent.scroll(list, { target: list });
+ });
+
+ const dateItems = screen.queryAllByRole('listitem').filter((el) => el.classList.contains('lazyload-list-item'));
+ // Two timestamps on the same day should collapse to one date entry
+ expect(dateItems).toHaveLength(1);
+ });
+
+ it('renders dates sorted newest-first', async () => {
+ cmrFetch
+ .mockResolvedValueOnce({
+ json: () => Promise.resolve({
+ feed: {
+ entry: [
+ { time_start: '2023-06-13T00:00:00.000Z' },
+ { time_start: '2023-06-14T00:00:00.000Z' },
+ { time_start: '2023-06-15T00:00:00.000Z' },
+ ],
+ },
+ }),
+ })
+ .mockResolvedValue({ json: () => Promise.resolve({ feed: { entry: [] } }) });
+
+ await renderSearch();
+ const list = screen.getByRole('list');
+
+ // Scroll near the bottom to trigger loadOlderDates
+ await act(async () => {
+ Object.defineProperty(list, 'scrollTop', { value: 900, configurable: true });
+ Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
+ Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
+ fireEvent.scroll(list, { target: list });
+ });
+
+ const dateItems = screen.queryAllByRole('listitem').filter((el) => el.classList.contains('lazyload-list-item'));
+ expect(dateItems.length).toBeGreaterThanOrEqual(1);
+ // First item should be the newest date (June 15)
+ expect(dateItems[0].textContent).toContain('June 15');
+ });
+ });
+
+ describe('conceptId resolution', () => {
+ it('renders without error when using collectionConceptID fallback', async () => {
+ const layerWithFallback = { id: 'fallback-layer', collectionConceptID: 'C99999-PROVIDER' };
+ await renderSearch(layerWithFallback);
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+
+ it('renders without error when layer has no conceptId or collectionConceptID', async () => {
+ const layerNoIds = { id: 'no-ids-layer' };
+ await renderSearch(layerNoIds);
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+ });
+
+ describe('compare mode', () => {
+ it('renders without error when compare is active and isCompareA is false', async () => {
+ const selectedB = new Date('2023-01-01T00:00:00.000Z');
+ await renderSearch(layer, {
+ date: { selected: selectedDate, selectedB },
+ compare: { active: true, isCompareA: false },
+ });
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+
+ it('uses date.selected when compare is active and isCompareA is true', async () => {
+ const selectedB = new Date('2023-01-01T00:00:00.000Z');
+ await renderSearch(layer, {
+ date: { selected: selectedDate, selectedB },
+ compare: { active: true, isCompareA: true },
+ });
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+ });
+
+ describe('map extent clamping', () => {
+ it('renders without error when map extent exceeds maxExtent bounds', async () => {
+ // Extent larger than [-180,-90,180,90] — triggers the clamping branches
+ await renderSearch(layer, {
+ map: { extent: [-200, -100, 200, 100] },
+ });
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+
+ it('renders without error when map extent is within maxExtent bounds', async () => {
+ await renderSearch(layer, {
+ map: { extent: [-90, -45, 90, 45] },
+ });
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+ });
+
+ describe('cmrFetch error handling', () => {
+ it('renders without error when cmrFetch rejects (older granules)', async () => {
+ cmrFetch.mockRejectedValue(new Error('network error'));
+ await renderSearch();
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+
+ it('renders without error when cmrFetch response.json() rejects', async () => {
+ cmrFetch.mockResolvedValue({
+ json: () => Promise.reject(new Error('bad json')),
+ });
+ await renderSearch();
+ expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
+ });
+ });
+
+ describe('date selection', () => {
+ it('dispatches selectDate action when a date list item is clicked', async () => {
+ const { selectDate } = require('../../../modules/date/actions');
+ cmrFetch
+ .mockResolvedValueOnce({
+ json: () => Promise.resolve({
+ feed: { entry: [{ time_start: '2023-06-14T00:00:00.000Z' }] },
+ }),
+ })
+ .mockResolvedValue({ json: () => Promise.resolve({ feed: { entry: [] } }) });
+
+ await renderSearch();
+ const list = screen.getByRole('list');
+
+ // Trigger loadOlderDates via bottom-scroll to populate date list items
+ await act(async () => {
+ Object.defineProperty(list, 'scrollTop', { value: 900, configurable: true });
+ Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
+ Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
+ fireEvent.scroll(list, { target: list });
+ });
+
+ const dateItems = screen.queryAllByRole('listitem').filter((el) => el.classList.contains('lazyload-list-item'));
+ expect(dateItems.length).toBeGreaterThan(0);
+ await act(async () => {
+ fireEvent.click(dateItems[0]);
+ });
+ expect(selectDate).toHaveBeenCalled();
+ });
+ });
+
+ describe('scroll handling', () => {
+ it('does not throw when scroll event fires', async () => {
+ await renderSearch();
+ const list = screen.getByRole('list');
+ // scrollHeight/clientHeight are already stubbed on the prototype; just fire the event
+ expect(() => { fireEvent.scroll(list); }).not.toThrow();
+ });
+
+ it('calls loadNewerDates when scrolled near the top (scrollPercentage <= 0.1)', async () => {
+ cmrFetch.mockResolvedValue({
+ json: () => Promise.resolve({ feed: { entry: [] } }),
+ });
+ await renderSearch();
+ const list = screen.getByRole('list');
+
+ await act(async () => {
+ Object.defineProperty(list, 'scrollTop', { value: 0, configurable: true });
+ Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
+ Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
+ fireEvent.scroll(list, { target: list });
+ });
+ // cmrFetch should have been called again for newer granules
+ expect(cmrFetch).toHaveBeenCalled();
+ });
+
+ it('calls loadOlderDates when scrolled near the bottom (scrollPercentage >= 0.9)', async () => {
+ cmrFetch.mockResolvedValue({
+ json: () => Promise.resolve({ feed: { entry: [] } }),
+ });
+ await renderSearch();
+ const list = screen.getByRole('list');
+ const callsBefore = cmrFetch.mock.calls.length;
+
+ await act(async () => {
+ Object.defineProperty(list, 'scrollTop', { value: 800, configurable: true });
+ Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
+ Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
+ fireEvent.scroll(list, { target: list });
+ });
+ expect(cmrFetch.mock.calls.length).toBeGreaterThan(callsBefore);
+ });
+
+ it('does not load more granules when scrolled to the middle', async () => {
+ cmrFetch.mockResolvedValue({
+ json: () => Promise.resolve({ feed: { entry: [] } }),
+ });
+ await renderSearch();
+ const list = screen.getByRole('list');
+ const callsBefore = cmrFetch.mock.calls.length;
+
+ // Scroll to 50%: scrollTop=400, scrollHeight=1000, clientHeight=200 => 400/800=0.5
+ await act(async () => {
+ Object.defineProperty(list, 'scrollTop', { value: 400, configurable: true });
+ Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
+ Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
+ fireEvent.scroll(list, { target: list });
+ });
+ expect(cmrFetch.mock.calls.length).toBe(callsBefore);
+ });
+ });
});
diff --git a/web/js/components/layer/settings/layer-settings.test.js b/web/js/components/layer/settings/layer-settings.test.js
index 19f7255e2..794c891b9 100644
--- a/web/js/components/layer/settings/layer-settings.test.js
+++ b/web/js/components/layer/settings/layer-settings.test.js
@@ -1,3 +1,241 @@
-test('layer-settings component test', () => {
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+jest.mock('./opacity', () => function MockOpacity() { return <div data-testid="opacity" />; });
+jest.mock('./palette', () => function MockPalette() { return <div data-testid="palette" />; });
+jest.mock('./palette-threshold', () => function MockPaletteThreshold() { return <div data-testid="palette-threshold" />; });
+jest.mock('./classification-toggle', () => function MockClassificationToggle() { return <div data-testid="classification-toggle" />; });
+jest.mock('./granule-date-list', () => function MockGranuleDateList() { return <div data-testid="granule-date-list" />; });
+jest.mock('./granule-count-slider', () => function MockGranuleCountSlider() { return <div data-testid="granule-count-slider" />; });
+jest.mock('./imagery-search', () => function MockImagerySearch() { return <div data-testid="imagery-search" />; });
+jest.mock('./associated-layers-toggle', () => function MockAssociatedLayers() { return <div data-testid="associated-layers" />; });
+jest.mock('./band-selection/band-selection-parent-info-menu', () => function MockBandSelection() { return <div data-testid="band-selection" />; });
+jest.mock('../../../util/local-storage', () => ({
+ keys: { ALLOW_GRANULE_REORDER: 'ALLOW_GRANULE_REORDER' },
+ getItem: jest.fn(() => null),
+}));
+jest.mock('../../../modules/palettes/util', () => ({ palettesTranslate: jest.fn() }));
+jest.mock('../../../modules/palettes/selectors', () => ({
+ getDefaultLegend: jest.fn(),
+ getCustomPalette: jest.fn(),
+ getPaletteLegends: jest.fn(() => null),
+ getPalette: jest.fn(() => ({ legend: { colors: [] }, squash: false, noclip: false })),
+ getPaletteLegend: jest.fn(),
+ isPaletteAllowed: jest.fn(() => true),
+}));
+jest.mock('../../../modules/layers/selectors', () => ({
+ getGranuleLayer: jest.fn(() => null),
+ getGranulePlatform: jest.fn(() => 'Terra'),
+ getActiveLayersMap: jest.fn(() => ({})),
+}));
+jest.mock('../../../modules/vector-styles/selectors', () => ({ getVectorStyle: jest.fn() }));
+jest.mock('../../../modules/palettes/actions', () => ({
+ setThresholdRangeSquashAndNoClip: jest.fn(() => ({ type: 'SET_THRESHOLD' })),
+ setCustomPalette: jest.fn(() => ({ type: 'SET_CUSTOM_PALETTE' })),
+ clearCustomPalette: jest.fn(() => ({ type: 'CLEAR_CUSTOM_PALETTE' })),
+ setToggledClassification: jest.fn(() => ({ type: 'SET_TOGGLED' })),
+ refreshDisabledClassification: jest.fn(() => ({ type: 'REFRESH_DISABLED' })),
+}));
+jest.mock('../../../modules/vector-styles/actions', () => ({
+ setFilterRange: jest.fn(() => ({ type: 'SET_FILTER_RANGE' })),
+ setStyle: jest.fn(() => ({ type: 'SET_STYLE' })),
+ clearStyle: jest.fn(() => ({ type: 'CLEAR_STYLE' })),
+}));
+jest.mock('../../../modules/layers/actions', () => ({
+ updateGranuleLayerOptions: jest.fn(() => ({ type: 'UPDATE_GRANULE' })),
+ resetGranuleLayerDates: jest.fn(() => ({ type: 'RESET_GRANULE' })),
+ setOpacity: jest.fn(() => ({ type: 'SET_OPACITY' })),
+}));
+
+import LayerSettings from './layer-settings';
+
+const mockStore = configureStore([]);
+
+const baseState = {
+ config: {
+ features: { customPalettes: true },
+ paletteOrder: [],
+ layers: {},
+ vectorStyles: {},
+ },
+ palettes: { custom: {} },
+ compare: { activeString: 'active' },
+ screenSize: { screenHeight: 800 },
+ settings: { globalTemperatureUnit: '' },
+ layers: { active: { granulePlatform: 'Terra' } },
+};
+
+const store = mockStore(baseState);
+
+const standardLayer = {
+ id: 'MODIS_Terra_CorrRefl_TrueColor',
+ opacity: 1,
+ type: 'wms',
+ palette: { id: 'blue-1', recommended: [] },
+};
+
+const sharedProps = {
+ setOpacity: jest.fn(),
+ customPalettesIsActive: true,
+ palettedAllowed: true,
+ getPaletteLegends: jest.fn(() => null),
+ getPalette: jest.fn(() => ({ legend: { colors: [] }, squash: false, noclip: false })),
+ getPaletteLegend: jest.fn(),
+ getDefaultLegend: jest.fn(),
+ getCustomPalette: jest.fn(),
+ palettesTranslate: jest.fn(),
+ paletteOrder: [],
+ groupName: 'active',
+ screenHeight: 800,
+ granuleOptions: {},
+ globalTemperatureUnit: '',
+ toggleClassification: jest.fn(),
+ toggleAllClassifications: jest.fn(),
+ setThresholdRange: jest.fn(),
+ setCustomPalette: jest.fn(),
+ clearCustomPalette: jest.fn(),
+ setStyle: jest.fn(),
+ clearStyle: jest.fn(),
+ updateGranuleLayerOptions: jest.fn(),
+ resetGranuleLayerDates: jest.fn(),
+};
+
+const renderSettings = (layer = standardLayer, propOverrides = {}) => render(
+ <Provider store={store}>
+ <LayerSettings
+ layer={layer}
+ zot={propOverrides.zot}
+ granuleOptions={propOverrides.granuleOptions || {}}
+ setOpacity={sharedProps.setOpacity}
+ customPalettesIsActive={sharedProps.customPalettesIsActive}
+ palettedAllowed={sharedProps.palettedAllowed}
+ getPaletteLegends={sharedProps.getPaletteLegends}
+ getPalette={sharedProps.getPalette}
+ getPaletteLegend={sharedProps.getPaletteLegend}
+ getDefaultLegend={sharedProps.getDefaultLegend}
+ getCustomPalette={sharedProps.getCustomPalette}
+ palettesTranslate={sharedProps.palettesTranslate}
+ paletteOrder={sharedProps.paletteOrder}
+ groupName={sharedProps.groupName}
+ screenHeight={sharedProps.screenHeight}
+ globalTemperatureUnit={sharedProps.globalTemperatureUnit}
+ toggleClassification={sharedProps.toggleClassification}
+ toggleAllClassifications={sharedProps.toggleAllClassifications}
+ setThresholdRange={sharedProps.setThresholdRange}
+ setCustomPalette={sharedProps.setCustomPalette}
+ clearCustomPalette={sharedProps.clearCustomPalette}
+ setStyle={sharedProps.setStyle}
+ clearStyle={sharedProps.clearStyle}
+ updateGranuleLayerOptions={sharedProps.updateGranuleLayerOptions}
+ resetGranuleLayerDates={sharedProps.resetGranuleLayerDates}
+ />
+ </Provider>,
+);
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('LayerSettings', () => {
+ describe('returns nothing when layer has no id', () => {
+ it('renders nothing when layer.id is null', () => {
+ const { container } = renderSettings({ id: null, opacity: 1, type: 'wms' });
+ expect(container.firstChild).toBeNull();
+ });
+ });
+
+ describe('always rendered', () => {
+ it('renders the Opacity component', () => {
+ renderSettings();
+ expect(screen.getByTestId('opacity')).toBeInTheDocument();
+ });
+ });
+
+ describe('BandSelection (titiler layers)', () => {
+ it('renders BandSelection for HLS_Customizable_Sentinel', () => {
+ renderSettings({ ...standardLayer, id: 'HLS_Customizable_Sentinel' });
+ expect(screen.getByTestId('band-selection')).toBeInTheDocument();
+ });
+
+ it('renders BandSelection for HLS_Customizable_Landsat', () => {
+ renderSettings({ ...standardLayer, id: 'HLS_Customizable_Landsat' });
+ expect(screen.getByTestId('band-selection')).toBeInTheDocument();
+ });
+
+ it('does not render BandSelection for non-titiler layers', () => {
+ renderSettings(standardLayer);
+ expect(screen.queryByTestId('band-selection')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('AssociatedLayers', () => {
+ it('renders AssociatedLayers when layer has associatedLayers', () => {
+ renderSettings({ ...standardLayer, associatedLayers: ['layer-1'] });
+ expect(screen.getByTestId('associated-layers')).toBeInTheDocument();
+ });
+
+ it('renders AssociatedLayers when layer has orbitTracks', () => {
+ renderSettings({ ...standardLayer, orbitTracks: ['track-1'] });
+ expect(screen.getByTestId('associated-layers')).toBeInTheDocument();
+ });
+
+ it('does not render AssociatedLayers when no associatedLayers or orbitTracks', () => {
+ renderSettings(standardLayer);
+ expect(screen.queryByTestId('associated-layers')).not.toBeInTheDocument();
+ });
+ });
+
+ describe('ImagerySearch (granule metadata)', () => {
+ it('renders ImagerySearch when enableCMRDataFinder is true and no zot', () => {
+ renderSettings({ ...standardLayer, enableCMRDataFinder: true });
+ expect(screen.getByTestId('imagery-search')).toBeInTheDocument();
+ });
+
+ it('does not render ImagerySearch when enableCMRDataFinder is false', () => {
+ renderSettings({ ...standardLayer, enableCMRDataFinder: false });
+ expect(screen.queryByTestId('imagery-search')).not.toBeInTheDocument();
+ });
+
+ it('does not render ImagerySearch when zot.underZoomValue > 0', () => {
+ renderSettings({
+ ...standardLayer,
+ enableCMRDataFinder: true,
+ }, { zot: { underZoomValue: 1 } });
+ expect(screen.queryByTestId('imagery-search')).not.toBeInTheDocument();
+ });
+
+ it('renders ImagerySearch when zot.underZoomValue is 0', () => {
+ renderSettings({
+ ...standardLayer,
+ enableCMRDataFinder: true,
+ },
+ { zot: { underZoomValue: 0 }});
+ expect(screen.getByTestId('imagery-search')).toBeInTheDocument();
+ });
+ });
+
+ describe('granule settings', () => {
+ it('renders GranuleCountSlider when granuleOptions has dates', () => {
+ const { getGranuleLayer } = require('../../../modules/layers/selectors');
+ getGranuleLayer.mockReturnValue({ dates: ['2023-01-01'], count: 5 });
+ renderSettings(standardLayer);
+ expect(screen.getByTestId('granule-count-slider')).toBeInTheDocument();
+ });
+
+ it('does not render GranuleCountSlider when getGranuleLayer returns null', () => {
+ const { getGranuleLayer } = require('../../../modules/layers/selectors');
+ getGranuleLayer.mockReturnValue(null);
+ renderSettings();
+ expect(screen.queryByTestId('granule-count-slider')).not.toBeInTheDocument();
+ });
+
+ it('does not render GranuleCountSlider when granule dates are null', () => {
+ const { getGranuleLayer } = require('../../../modules/layers/selectors');
+ getGranuleLayer.mockReturnValue({ dates: null, count: 5 });
+ renderSettings(standardLayer);
+ expect(screen.queryByTestId('granule-count-slider')).not.toBeInTheDocument();
+ });
+ });
});
diff --git a/web/js/components/layer/settings/opacity.test.js b/web/js/components/layer/settings/opacity.test.js
index e9da06ab2..989705208 100644
--- a/web/js/components/layer/settings/opacity.test.js
+++ b/web/js/components/layer/settings/opacity.test.js
@@ -1,3 +1,79 @@
-test('opacity component test', () => {
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import OpacitySelect from './opacity';
+const layer = { id: 'test-layer' };
+
+const renderOpacity = (overrides = {}) => {
+ const props = { layer, start: 100, setOpacity: jest.fn(), ...overrides };
+ return render(
+ <OpacitySelect
+ layer={props.layer}
+ start={props.start}
+ setOpacity={props.setOpacity}
+ />,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('OpacitySelect', () => {
+ describe('layout', () => {
+ it('renders the Opacity heading', () => {
+ renderOpacity();
+ expect(screen.getByText('Opacity')).toBeInTheDocument();
+ });
+
+ it('renders the range slider', () => {
+ renderOpacity();
+ expect(screen.getByRole('slider')).toBeInTheDocument();
+ });
+
+ it('renders the opacity label', () => {
+ renderOpacity({ start: 75 });
+ expect(screen.getByText('75%')).toBeInTheDocument();
+ });
+
+ it('defaults to 100% when start is not provided', () => {
+ render(<OpacitySelect layer={layer} setOpacity={jest.fn()} />);
+ expect(screen.getByText('100%')).toBeInTheDocument();
+ });
+ });
+
+ describe('slider attributes', () => {
+ it('sets slider defaultValue to the start prop', () => {
+ renderOpacity({ start: 60 });
+ expect(screen.getByRole('slider')).toHaveAttribute('value', '60');
+ });
+ });
+
+ describe('onChange', () => {
+ it('updates the displayed percentage when slider changes', () => {
+ renderOpacity({ start: 100 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '50' } });
+ expect(screen.getByText('50%')).toBeInTheDocument();
+ });
+
+ it('calls setOpacity with layer id and normalized value', () => {
+ const setOpacity = jest.fn();
+ jest.useFakeTimers();
+ renderOpacity({ start: 100, setOpacity });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '80' } });
+ jest.runAllTimers();
+ expect(setOpacity).toHaveBeenCalledWith('test-layer', '0.80');
+ jest.useRealTimers();
+ });
+
+ it('passes opacity as 2 decimal string to setOpacity', () => {
+ const setOpacity = jest.fn();
+ jest.useFakeTimers();
+ renderOpacity({ start: 100, setOpacity });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '33' } });
+ jest.runAllTimers();
+ expect(setOpacity).toHaveBeenCalledWith('test-layer', '0.33');
+ jest.useRealTimers();
+ });
+ });
});
diff --git a/web/js/components/layer/settings/palette-threshold.test.js b/web/js/components/layer/settings/palette-threshold.test.js
index 726a63e66..29070b951 100644
--- a/web/js/components/layer/settings/palette-threshold.test.js
+++ b/web/js/components/layer/settings/palette-threshold.test.js
@@ -1,3 +1,202 @@
-test('palette-threshold component test', () => {
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('../../util/checkbox', () => {
+ function MockCheckbox({
+ id, checked, onCheck, label,
+ }) {
+ return (
+ <label htmlFor={id}>
+ <input
+ id={id}
+ type="checkbox"
+ checked={checked}
+ onChange={onCheck}
+ data-testid={`checkbox-${id}`}
+ />
+ {label}
+ </label>
+ );
+ }
+ return MockCheckbox;
+});
+jest.mock('../../../modules/settings/util', () => ({
+ checkTemperatureUnitConversion: jest.fn(() => ({
+ needsConversion: false,
+ legendTempUnit: null,
+ })),
+ convertPaletteValue: jest.fn((v) => v),
+}));
+
+import PaletteThreshold from './palette-threshold';
+
+const legend = {
+ refs: ['ref0', 'ref1', 'ref2', 'ref3', 'ref4'],
+ tooltips: ['0°C', '25°C', '50°C', '75°C', '100°C'],
+ units: 'K',
+ minLabel: null,
+ maxLabel: null,
+};
+
+const palette = {
+ entries: { refs: ['ref0', 'ref1', 'ref2', 'ref3', 'ref4'] },
+ squash: false,
+ noclip: false,
+};
+
+const defaultProps = {
+ legend,
+ palette,
+ setRange: jest.fn(),
+ min: 0,
+ max: 4,
+ start: 0,
+ end: 4,
+ squashed: false,
+ noclipped: false,
+ index: 0,
+ groupName: 'active',
+ layerId: 'test-layer',
+ globalTemperatureUnit: '',
+};
+
+const renderThreshold = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <PaletteThreshold
+ legend={props.legend}
+ palette={props.palette}
+ setRange={props.setRange}
+ min={props.min}
+ max={props.max}
+ start={props.start}
+ end={props.end}
+ squashed={props.squashed}
+ noclipped={props.noclipped}
+ index={props.index}
+ groupName={props.groupName}
+ layerId={props.layerId}
+ globalTemperatureUnit={props.globalTemperatureUnit}
+ />,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('PaletteThreshold', () => {
+ describe('layout', () => {
+ it('renders the Thresholds heading', () => {
+ renderThreshold();
+ expect(screen.getByText('Thresholds')).toBeInTheDocument();
+ });
+
+ it('renders Squash Palette checkbox', () => {
+ renderThreshold();
+ expect(screen.getByText('Squash Palette')).toBeInTheDocument();
+ });
+
+ it('renders Clip Palette checkbox', () => {
+ renderThreshold();
+ expect(screen.getByText('Clip Palette')).toBeInTheDocument();
+ });
+
+ it('renders two range inputs (min and max sliders)', () => {
+ renderThreshold();
+ expect(screen.getAllByRole('slider')).toHaveLength(2);
+ });
+ });
+
+ describe('squash checkbox', () => {
+ it('renders unchecked when squashed is false', () => {
+ renderThreshold({ squashed: false });
+ expect(screen.getByTestId('checkbox-wv-squash-button-check0')).not.toBeChecked();
+ });
+
+ it('renders checked when squashed is true', () => {
+ renderThreshold({ squashed: true });
+ expect(screen.getByTestId('checkbox-wv-squash-button-check0')).toBeChecked();
+ });
+
+ it('calls setRange when squash checkbox is toggled', () => {
+ const setRange = jest.fn();
+ renderThreshold({ setRange });
+ fireEvent.click(screen.getByTestId('checkbox-wv-squash-button-check0'));
+ expect(setRange).toHaveBeenCalled();
+ });
+ });
+
+ describe('clip (noclip) checkbox', () => {
+ it('renders checked (Clip active) when noclipped is false', () => {
+ renderThreshold({ noclipped: false });
+ expect(screen.getByTestId('checkbox-wv-clip-button-check0')).toBeChecked();
+ });
+
+ it('renders unchecked when noclipped is true', () => {
+ renderThreshold({ noclipped: true });
+ expect(screen.getByTestId('checkbox-wv-clip-button-check0')).not.toBeChecked();
+ });
+
+ it('calls setRange when clip checkbox is toggled', () => {
+ const setRange = jest.fn();
+ renderThreshold({ setRange });
+ fireEvent.click(screen.getByTestId('checkbox-wv-clip-button-check0'));
+ expect(setRange).toHaveBeenCalled();
+ });
+ });
+
+ describe('threshold sliders', () => {
+ it('start slider has name="min"', () => {
+ renderThreshold();
+ const sliders = screen.getAllByRole('slider');
+ expect(sliders[0]).toHaveAttribute('name', 'min');
+ });
+
+ it('end slider has name="max"', () => {
+ renderThreshold();
+ const sliders = screen.getAllByRole('slider');
+ expect(sliders[1]).toHaveAttribute('name', 'max');
+ });
+
+ it('calls debounced setRange when start slider changes to a new value', () => {
+ jest.useFakeTimers();
+ const setRange = jest.fn();
+ renderThreshold({ setRange, start: 0, end: 4 });
+ const sliders = screen.getAllByRole('slider');
+ fireEvent.change(sliders[0], { target: { value: '1' } });
+ jest.runAllTimers();
+ expect(setRange).toHaveBeenCalled();
+ jest.useRealTimers();
+ });
+
+ it('calls debounced setRange when end slider changes to a new value', () => {
+ jest.useFakeTimers();
+ const setRange = jest.fn();
+ renderThreshold({ setRange, start: 0, end: 4 });
+ const sliders = screen.getAllByRole('slider');
+ fireEvent.change(sliders[1], { target: { value: '3' } });
+ jest.runAllTimers();
+ expect(setRange).toHaveBeenCalled();
+ jest.useRealTimers();
+ });
+ });
+
+ describe('label display', () => {
+ it('renders the start tooltip label with units appended', () => {
+ renderThreshold({ start: 0, end: 4 });
+ expect(screen.getByText('0°C K')).toBeInTheDocument();
+ });
+
+ it('renders the end tooltip label with units appended', () => {
+ renderThreshold({ start: 0, end: 4 });
+ expect(screen.getByText('100°C K')).toBeInTheDocument();
+ });
+
+ it('appends units to non-zero start label', () => {
+ renderThreshold({ start: 1, end: 4 });
+ expect(screen.getByText('25°C K')).toBeInTheDocument();
+ });
+ });
});
diff --git a/web/js/components/layer/settings/palette.test.js b/web/js/components/layer/settings/palette.test.js
index 76fccff2e..ebf33d5e1 100644
--- a/web/js/components/layer/settings/palette.test.js
+++ b/web/js/components/layer/settings/palette.test.js
@@ -1,3 +1,166 @@
-test('palette component test', () => {
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('../../../modules/palettes/util', () => ({
+ drawPaletteOnCanvas: jest.fn(),
+}));
+jest.mock('../../../util/util', () => ({
+ hexToRGBA: jest.fn((hex) => `rgba(${hex})`),
+}));
+jest.mock('../../util/scrollbar', () => {
+ function MockScrollbar({ children }) {
+ return <div data-testid="scrollbar">{children}</div>;
+ }
+ return MockScrollbar;
+});
+
+import PaletteSelect from './palette';
+
+const canvas = document.createElement('canvas');
+canvas.width = 120;
+canvas.height = 10;
+
+const continuousLegend = {
+ type: 'continuous',
+ colors: ['ff0000', '00ff00', '0000ff'],
+ name: 'My Palette',
+};
+
+const classificationLegend = {
+ type: 'classification',
+ colors: ['ff0000'],
+};
+
+const layer = {
+ id: 'test-layer',
+ palette: { recommended: [] },
+};
+
+const defaultProps = {
+ activePalette: '__default',
+ canvas,
+ clearCustomPalette: jest.fn(),
+ getCustomPalette: jest.fn(),
+ getDefaultLegend: jest.fn(() => continuousLegend),
+ groupName: 'active',
+ index: 0,
+ layer,
+ paletteOrder: [],
+ palettesTranslate: jest.fn((src, tgt) => tgt),
+ setCustomPalette: jest.fn(),
+};
+
+const renderPalette = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <PaletteSelect
+ activePalette={props.activePalette}
+ canvas={props.canvas}
+ clearCustomPalette={props.clearCustomPalette}
+ getCustomPalette={props.getCustomPalette}
+ getDefaultLegend={props.getDefaultLegend}
+ groupName={props.groupName}
+ index={props.index}
+ layer={props.layer}
+ paletteOrder={props.paletteOrder}
+ palettesTranslate={props.palettesTranslate}
+ setCustomPalette={props.setCustomPalette}
+ />,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ defaultProps.getDefaultLegend.mockReturnValue(continuousLegend);
+});
+
+describe('PaletteSelect', () => {
+ describe('layout', () => {
+ it('renders the Color Palette heading', () => {
+ renderPalette();
+ expect(screen.getByText('Color Palette')).toBeInTheDocument();
+ });
+
+ it('renders the scrollbar', () => {
+ renderPalette();
+ expect(screen.getByTestId('scrollbar')).toBeInTheDocument();
+ });
+
+ it('renders the default palette radio input', () => {
+ renderPalette();
+ // Continuous legend uses legend.name as label
+ expect(screen.getByRole('radio', { name: /My Palette/i })).toBeInTheDocument();
+ });
+ });
+
+ describe('default palette selection', () => {
+ it('renders default palette as selected when activePalette is "__default"', () => {
+ renderPalette({ activePalette: '__default' });
+ expect(screen.getByRole('radio', { name: /My Palette/i }).closest('.wv-palette-selector-row')).toHaveClass('checked');
+ });
+
+ it('renders default palette as unselected when activePalette is something else', () => {
+ renderPalette({ activePalette: 'custom-id' });
+ expect(screen.getByRole('radio', { name: /My Palette/i }).closest('.wv-palette-selector-row')).not.toHaveClass('checked');
+ });
+
+ it('calls clearCustomPalette when default radio is clicked', () => {
+ const clearCustomPalette = jest.fn();
+ renderPalette({ clearCustomPalette });
+ fireEvent.click(screen.getByRole('radio', { name: /My Palette/i }));
+ expect(clearCustomPalette).toHaveBeenCalledWith('test-layer', 0, 'active');
+ });
+ });
+
+ describe('classification single-color default', () => {
+ it('renders single-color item for classification legend', () => {
+ defaultProps.getDefaultLegend.mockReturnValue(classificationLegend);
+ renderPalette();
+ expect(screen.getByText('Default')).toBeInTheDocument();
+ });
+ });
+
+ describe('custom palettes from paletteOrder', () => {
+ it('renders a custom palette entry from paletteOrder', () => {
+ const customPalette = {
+ id: 'custom-blue',
+ name: 'Blue Palette',
+ colors: ['0000ff', '0000aa'],
+ };
+ renderPalette({
+ paletteOrder: ['custom-blue'],
+ getCustomPalette: jest.fn(() => customPalette),
+ palettesTranslate: jest.fn(() => ['0000ff', '0000aa']),
+ });
+ expect(screen.getByText('Blue Palette')).toBeInTheDocument();
+ });
+
+ it('calls setCustomPalette when a custom palette radio is clicked', () => {
+ const customPalette = {
+ id: 'custom-blue',
+ name: 'Blue Palette',
+ colors: ['0000ff', '0000aa'],
+ };
+ const setCustomPalette = jest.fn();
+ renderPalette({
+ paletteOrder: ['custom-blue'],
+ getCustomPalette: jest.fn(() => customPalette),
+ setCustomPalette,
+ palettesTranslate: jest.fn(() => ['0000ff']),
+ });
+ fireEvent.click(screen.getByRole('radio', { name: /Blue Palette/i }));
+ expect(setCustomPalette).toHaveBeenCalledWith('test-layer', 'custom-blue', 0, 'active');
+ });
+
+ it('skips palettes listed in layer.palette.recommended', () => {
+ const layerWithRecommended = { ...layer, palette: { recommended: ['custom-blue'] } };
+ renderPalette({
+ layer: layerWithRecommended,
+ paletteOrder: ['custom-blue'],
+ getCustomPalette: jest.fn(() => ({ id: 'custom-blue', name: 'Blue', colors: ['0000ff'] })),
+ });
+ expect(screen.queryByText('Blue')).not.toBeInTheDocument();
+ });
+ });
});
diff --git a/web/js/components/layer/settings/vector-filter.test.js b/web/js/components/layer/settings/vector-filter.test.js
index 1e63cf219..6ab9429a5 100644
--- a/web/js/components/layer/settings/vector-filter.test.js
+++ b/web/js/components/layer/settings/vector-filter.test.js
@@ -1,3 +1,108 @@
-test('vector-filter component test', () => {
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import VectorFilter from './vector-filter';
+const defaultProps = {
+ start: 0,
+ end: 100,
+ min: 0,
+ max: 100,
+ index: 0,
+ layerId: 'test-vector-layer',
+ groupName: 'active',
+ setFilterRange: jest.fn(),
+};
+
+const renderFilter = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <VectorFilter
+ start={props.start}
+ end={props.end}
+ min={props.min}
+ max={props.max}
+ index={props.index}
+ layerId={props.layerId}
+ groupName={props.groupName}
+ setFilterRange={props.setFilterRange}
+ />,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+});
+
+describe('VectorFilter', () => {
+ describe('layout', () => {
+ it('renders the Filters heading', () => {
+ renderFilter();
+ expect(screen.getByText('Filters')).toBeInTheDocument();
+ });
+
+ it('renders the range slider', () => {
+ renderFilter();
+ expect(screen.getByRole('slider')).toBeInTheDocument();
+ });
+
+ it('renders min and max placeholder labels', () => {
+ renderFilter();
+ expect(screen.getByText('0')).toBeInTheDocument();
+ expect(screen.getByText('100')).toBeInTheDocument();
+ });
+
+ it('renders the outer container with correct class', () => {
+ const { container } = renderFilter();
+ expect(container.querySelector('.layer-threshold-select')).toBeInTheDocument();
+ });
+ });
+
+ describe('slider attributes', () => {
+ it('sets slider min attribute', () => {
+ renderFilter({ min: 10 });
+ expect(screen.getByRole('slider')).toHaveAttribute('min', '10');
+ });
+
+ it('sets slider max attribute', () => {
+ renderFilter({ max: 200 });
+ expect(screen.getByRole('slider')).toHaveAttribute('max', '200');
+ });
+
+ it('sets slider defaultValue to end prop', () => {
+ renderFilter({ end: 75 });
+ expect(screen.getByRole('slider')).toHaveAttribute('value', '75');
+ });
+ });
+
+ describe('onChange / updateFilter', () => {
+ it('calls debounced setFilterRange when end slider changes', () => {
+ jest.useFakeTimers();
+ const setFilterRange = jest.fn();
+ renderFilter({ setFilterRange, start: 10, end: 90 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '60' } });
+ jest.runAllTimers();
+ expect(setFilterRange).toHaveBeenCalledWith('test-vector-layer', 10, 60, 0, 'active');
+ jest.useRealTimers();
+ });
+
+ it('does not call setFilterRange when value is unchanged from current end', () => {
+ jest.useFakeTimers();
+ const setFilterRange = jest.fn();
+ renderFilter({ setFilterRange, start: 0, end: 100 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '100' } });
+ jest.runAllTimers();
+ expect(setFilterRange).not.toHaveBeenCalled();
+ jest.useRealTimers();
+ });
+
+ it('passes parsed integer values to setFilterRange', () => {
+ jest.useFakeTimers();
+ const setFilterRange = jest.fn();
+ renderFilter({ setFilterRange, start: 0, end: 100 });
+ fireEvent.change(screen.getByRole('slider'), { target: { value: '50' } });
+ jest.runAllTimers();
+ expect(setFilterRange).toHaveBeenCalledWith('test-vector-layer', 0, 50, 0, 'active');
+ jest.useRealTimers();
+ });
+ });
});
diff --git a/web/js/components/layer/settings/vector-style.test.js b/web/js/components/layer/settings/vector-style.test.js
index bb7eee850..7d3d67032 100644
--- a/web/js/components/layer/settings/vector-style.test.js
+++ b/web/js/components/layer/settings/vector-style.test.js
@@ -1,3 +1,163 @@
-test('vector-style component test', () => {
+/* eslint-disable react/prop-types */
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+jest.mock('../../../modules/vector-styles/util', () => ({
+ isConditional: jest.fn(() => false),
+}));
+jest.mock('../../util/scrollbar', () => {
+ function MockScrollbar({ children }) {
+ return <div data-testid="scrollbar">{children}</div>;
+ }
+ return MockScrollbar;
+});
+
+import VectorStyleSelect from './vector-style';
+import { isConditional } from '../../../modules/vector-styles/util';
+
+const makeLayer = (id = 'fire-layer') => ({
+ id,
+ vectorStyle: { id: 'fire-style' },
+});
+
+const makeVectorStyles = (layers) => ({
+ 'fire-style': { layers },
+});
+
+const plainLayer = {
+ id: 'fire-layer-plain',
+ 'source-description': 'Fire Points',
+ paint: { 'circle-color': '#ff0000' },
+};
+const lineLayer = {
+ id: 'fire-layer-line',
+ paint: { 'line-color': '#00ff00' },
+};
+const fillLayer = {
+ id: 'fire-layer-fill',
+ paint: { 'fill-color': '#0000ff' },
+};
+
+const defaultProps = {
+ activeVectorStyle: 'fire-layer-plain',
+ clearStyle: jest.fn(),
+ setStyle: jest.fn(),
+ groupName: 'active',
+ index: 0,
+ layer: makeLayer(),
+ vectorStyles: makeVectorStyles([plainLayer]),
+};
+
+const renderStyle = (overrides = {}) => {
+ const props = { ...defaultProps, ...overrides };
+ return render(
+ <VectorStyleSelect
+ activeVectorStyle={props.activeVectorStyle}
+ clearStyle={props.clearStyle}
+ setStyle={props.setStyle}
+ groupName={props.groupName}
+ index={props.index}
+ layer={props.layer}
+ vectorStyles={props.vectorStyles}
+ />,
+ );
+};
+
+beforeEach(() => {
+ jest.clearAllMocks();
+ isConditional.mockReturnValue(false);
+});
+
+describe('VectorStyleSelect', () => {
+ describe('layout', () => {
+ it('renders the Vector Styles heading', () => {
+ renderStyle();
+ expect(screen.getByText('Vector Styles')).toBeInTheDocument();
+ });
+
+ it('renders the scrollbar', () => {
+ renderStyle();
+ expect(screen.getByTestId('scrollbar')).toBeInTheDocument();
+ });
+
+ it('renders a radio input for each unique style layer', () => {
+ renderStyle();
+ expect(screen.getAllByRole('radio')).toHaveLength(1);
+ });
+ });
+
+ describe('single-style item rendering', () => {
+ it('renders the source-description as the label when present', () => {
+ renderStyle();
+ expect(screen.getByText('Fire Points')).toBeInTheDocument();
+ });
+
+ it('falls back to layer id as label when source-description is absent', () => {
+ renderStyle({ vectorStyles: makeVectorStyles([lineLayer]), activeVectorStyle: 'fire-layer-line' });
+ expect(screen.getByText('fire-layer-line')).toBeInTheDocument();
+ });
+
+ it('renders the item with "checked" class when it matches activeVectorStyle', () => {
+ renderStyle({ activeVectorStyle: 'fire-layer-plain' });
+ expect(screen.getByRole('radio').closest('.wv-palette-selector-row')).toHaveClass('checked');
+ });
+
+ it('renders item without "checked" class when id does not match activeVectorStyle', () => {
+ renderStyle({ activeVectorStyle: 'other-id' });
+ expect(screen.getByRole('radio').closest('.wv-palette-selector-row')).not.toHaveClass('checked');
+ });
+
+ it('renders using fill-color paint when present', () => {
+ renderStyle({ vectorStyles: makeVectorStyles([fillLayer]), activeVectorStyle: 'fire-layer-fill' });
+ expect(screen.getByText('fire-layer-fill')).toBeInTheDocument();
+ });
+ });
+
+ describe('onChangeVectorStyle', () => {
+ it('calls setStyle when a non-matching style is selected', () => {
+ jest.useFakeTimers();
+ const setStyle = jest.fn();
+ renderStyle({ setStyle, activeVectorStyle: 'other-id' });
+ fireEvent.click(screen.getByRole('radio'));
+ jest.runAllTimers();
+ expect(setStyle).toHaveBeenCalledWith(defaultProps.layer, 'fire-layer-plain', 'active');
+ jest.useRealTimers();
+ });
+
+ it('calls clearStyle when selected vectorStyleId matches the layer id', () => {
+ jest.useFakeTimers();
+ const clearStyle = jest.fn();
+ const layer = makeLayer('fire-layer-plain');
+ renderStyle({ clearStyle, layer, activeVectorStyle: 'other' });
+ fireEvent.click(screen.getByRole('radio'));
+ jest.runAllTimers();
+ expect(clearStyle).toHaveBeenCalledWith(layer, 'fire-layer-plain', 'active');
+ jest.useRealTimers();
+ });
+ });
+
+ describe('duplicate style deduplication', () => {
+ it('renders only unique style layers when duplicates exist', () => {
+ renderStyle({ vectorStyles: makeVectorStyles([plainLayer, plainLayer]) });
+ expect(screen.getAllByRole('radio')).toHaveLength(1);
+ });
+ });
+
+ describe('conditional (multi-item) rendering', () => {
+ it('renders no radio inputs for conditional styles', () => {
+ isConditional.mockReturnValue(true);
+ const conditionalLayer = {
+ id: 'cond-layer',
+ paint: {
+ 'line-color': [
+ 'case',
+ ['==', ['get', 'type'], 'fire'], '#ff0000',
+ '#ffffff',
+ ],
+ },
+ };
+ renderStyle({ vectorStyles: makeVectorStyles([conditionalLayer]), activeVectorStyle: 'cond-layer' });
+ expect(screen.queryByRole('radio')).not.toBeInTheDocument();
+ });
+ });
});