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