Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

Added more unit tests for web/js/components/ dir

Jason Hurley842e082bbbed
diff --git a/web/js/components/layer/product-picker/search/facets.test.js b/web/js/components/layer/product-picker/search/facets.test.js
index 663525181..0b4dd0b28 100644
--- a/web/js/components/layer/product-picker/search/facets.test.js
+++ b/web/js/components/layer/product-picker/search/facets.test.js
@@ -1,3 +1,246 @@
-test('facets component test', () => {
+/* eslint-disable react/prop-types */
+/* eslint-disable react/jsx-props-no-spreading */
+import { render, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import Facets from './facets';
+import {
+ toggleMobileFacets as toggleMobileFacetsAction,
+ collapseFacet as collapseFacetAction,
+} from '../../../../modules/product-picker/actions';
+import facetConfig from '../../../../modules/product-picker/facet-config';
+jest.mock('@elastic/react-search-ui', () => ({
+ withSearch: () => (Component) => Component,
+}));
+
+jest.mock('./filter-chips', () => ({ filters, facetConfig: fc }) => (
+ <div
+ data-testid="filter-chips"
+ data-filter-count={filters ? filters.length : 0}
+ data-facet-config-length={fc ? fc.length : 0}
+ />
+));
+
+jest.mock('./product-facet', () => ({ config, data, collapsed, toggleCollapse }) => (
+ <div data-testid={`product-facet-${config.field}`} data-collapsed={String(!!collapsed)}>
+ <button
+ data-testid={`collapse-btn-${config.field}`}
+ onClick={() => toggleCollapse(config.field)}
+ >
+ toggle
+ </button>
+ <span data-testid={`data-count-${config.field}`}>{data.length}</span>
+ </div>
+));
+
+jest.mock('../../../../modules/product-picker/actions', () => ({
+ toggleMobileFacets: jest.fn(() => ({ type: 'TOGGLE_MOBILE_FACETS' })),
+ collapseFacet: jest.fn(() => ({ type: 'COLLAPSE_FACET' })),
+}));
+
+jest.mock('../../../../modules/date/selectors', () => ({
+ getSelectedDate: jest.fn(() => '2023-05-01'),
+}));
+
+const mockConfigureStore = configureStore([]);
+
+const baseState = {
+ screenSize: {
+ isMobileDevice: false,
+ screenWidth: 1200,
+ breakpoints: { small: 768 },
+ },
+ productPicker: {
+ showMobileFacets: false,
+ collapsedFacets: {},
+ },
+};
+
+const baseSearchProps = {
+ facets: {},
+ filters: [],
+ removeFilter: jest.fn(),
+ results: [{ id: 'layer1' }],
+};
+
+const renderFacets = (searchProps = {}, stateOverrides = {}) => {
+ const state = {
+ ...baseState,
+ ...stateOverrides,
+ screenSize: { ...baseState.screenSize, ...(stateOverrides.screenSize || {}) },
+ productPicker: { ...baseState.productPicker, ...(stateOverrides.productPicker || {}) },
+ };
+ const store = mockConfigureStore(state);
+ store.dispatch = jest.fn();
+
+ const result = render(
+ <Provider store={store}>
+ <Facets {...baseSearchProps} {...searchProps} />
+ </Provider>,
+ );
+ return { ...result, store };
+};
+
+describe('Facets', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('showFacets visibility', () => {
+ it('renders null when desktop, no results, and showMobileFacets is false', () => {
+ const { container } = renderFacets({ results: [] });
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders null when mobile with results but showMobileFacets is false', () => {
+ const { container } = renderFacets(
+ { results: [{ id: 'layer1' }] },
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 400, breakpoints: { small: 768 } },
+ productPicker: { showMobileFacets: false, collapsedFacets: {} },
+ },
+ );
+ expect(container.firstChild).toBeNull();
+ });
+
+ it('renders content when desktop with results', () => {
+ const { getByTestId } = renderFacets({ results: [{ id: 'layer1' }] });
+ expect(getByTestId('filter-chips')).toBeTruthy();
+ });
+
+ it('renders content when mobile and showMobileFacets is true even with no results', () => {
+ const { getByTestId } = renderFacets(
+ { results: [] },
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 400, breakpoints: { small: 768 } },
+ productPicker: { showMobileFacets: true, collapsedFacets: {} },
+ },
+ );
+ expect(getByTestId('filter-chips')).toBeTruthy();
+ });
+ });
+
+ describe('CSS class names', () => {
+ it('uses facet-container class on desktop', () => {
+ const { container } = renderFacets();
+ expect(container.firstChild.className).toBe('facet-container');
+ });
+
+ it('uses mobile class when isMobile is true', () => {
+ const { container } = renderFacets(
+ {},
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 1200, breakpoints: { small: 768 } },
+ productPicker: { showMobileFacets: true, collapsedFacets: {} },
+ },
+ );
+ expect(container.firstChild.className).toBe('facet-container-mobile facet-container');
+ });
+
+ it('uses mobile class when screenWidth is less than breakpoints.small', () => {
+ const { container } = renderFacets(
+ {},
+ {
+ screenSize: { isMobileDevice: false, screenWidth: 500, breakpoints: { small: 768 } },
+ },
+ );
+ expect(container.firstChild.className).toBe('facet-container-mobile facet-container');
+ });
+ });
+
+ describe('FilterChips', () => {
+ it('renders FilterChips with the filters prop', () => {
+ const filters = [{ field: 'categories', values: ['Fires'] }];
+ const { getByTestId } = renderFacets({ filters });
+ expect(getByTestId('filter-chips').dataset.filterCount).toBe('1');
+ });
+
+ it('passes facetConfig to FilterChips', () => {
+ const { getByTestId } = renderFacets();
+ expect(getByTestId('filter-chips').dataset.facetConfigLength).toBe(String(facetConfig.length));
+ });
+ });
+
+ describe('ProductFacet rendering', () => {
+ it('renders a ProductFacet for each entry in facetConfig', () => {
+ renderFacets();
+ facetConfig.forEach((config) => {
+ expect(document.querySelector(`[data-testid="product-facet-${config.field}"]`)).toBeTruthy();
+ });
+ });
+
+ it('passes facet data when available for a field', () => {
+ const data = [{ value: 'Always', count: 10 }];
+ const facets = { coverage: [{ data }] };
+ const { getByTestId } = renderFacets({ facets });
+ expect(getByTestId('data-count-coverage').textContent).toBe(String(data.length));
+ });
+
+ it('passes empty array when facet field is absent from facets', () => {
+ const { getByTestId } = renderFacets({ facets: {} });
+ expect(getByTestId('data-count-coverage').textContent).toBe('0');
+ });
+
+ it('passes empty array when facet entry exists but has no items', () => {
+ const { getByTestId } = renderFacets({ facets: { coverage: [] } });
+ expect(getByTestId('data-count-coverage').textContent).toBe('0');
+ });
+
+ it('passes collapsed=true when field is collapsed in collapsedFacets', () => {
+ const { getByTestId } = renderFacets(
+ {},
+ { productPicker: { showMobileFacets: false, collapsedFacets: { coverage: true } } },
+ );
+ expect(getByTestId('product-facet-coverage').dataset.collapsed).toBe('true');
+ });
+
+ it('passes collapsed=false when field is not in collapsedFacets', () => {
+ const { getByTestId } = renderFacets(
+ {},
+ { productPicker: { showMobileFacets: false, collapsedFacets: {} } },
+ );
+ expect(getByTestId('product-facet-coverage').dataset.collapsed).toBe('false');
+ });
+ });
+
+ describe('Apply button', () => {
+ it('does not render Apply button on desktop', () => {
+ const { queryByText } = renderFacets();
+ expect(queryByText('Apply')).toBeNull();
+ });
+
+ it('renders Apply button when mobile and showMobileFacets is true', () => {
+ const { getByText } = renderFacets(
+ { results: [] },
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 400, breakpoints: { small: 768 } },
+ productPicker: { showMobileFacets: true, collapsedFacets: {} },
+ },
+ );
+ expect(getByText('Apply')).toBeTruthy();
+ });
+
+ it('dispatches toggleMobileFacets when Apply button is clicked', () => {
+ const { getByText, store } = renderFacets(
+ { results: [] },
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 400, breakpoints: { small: 768 } },
+ productPicker: { showMobileFacets: true, collapsedFacets: {} },
+ },
+ );
+ fireEvent.click(getByText('Apply'));
+ expect(toggleMobileFacetsAction).toHaveBeenCalled();
+ expect(store.dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_MOBILE_FACETS' });
+ });
+ });
+
+ describe('toggleCollapseFacet dispatch', () => {
+ it('dispatches collapseFacet with the correct field when a facet collapse is toggled', () => {
+ const { getByTestId, store } = renderFacets();
+ fireEvent.click(getByTestId('collapse-btn-coverage'));
+ expect(collapseFacetAction).toHaveBeenCalledWith('coverage');
+ expect(store.dispatch).toHaveBeenCalledWith({ type: 'COLLAPSE_FACET' });
+ });
+ });
});
diff --git a/web/js/components/layer/product-picker/search/filter-chips.test.js b/web/js/components/layer/product-picker/search/filter-chips.test.js
index 2148f745d..e687a2850 100644
--- a/web/js/components/layer/product-picker/search/filter-chips.test.js
+++ b/web/js/components/layer/product-picker/search/filter-chips.test.js
@@ -1,3 +1,121 @@
-test('filter-chips component test', () => {
+import { render, fireEvent } from '@testing-library/react';
+import FilterChips from './filter-chips';
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: () => <svg data-testid="fa-icon" />,
+}));
+
+const baseFacetConfig = [
+ { field: 'categories', label: 'Category', filterType: 'any' },
+ { field: 'sources', label: 'Source', filterType: 'any' },
+ { field: 'coverage', label: 'Coverage', filterType: 'any', useLabelForValue: true },
+];
+
+const renderChips = (overrides = {}) => {
+ const props = {
+ filters: [],
+ removeFilter: jest.fn(),
+ facetConfig: baseFacetConfig,
+ ...overrides,
+ };
+ return render(
+ <FilterChips
+ filters={props.filters}
+ removeFilter={props.removeFilter}
+ facetConfig={props.facetConfig}
+ />,
+ );
+};
+
+describe('FilterChips', () => {
+ describe('empty / no filters', () => {
+ it('renders null when filters array is empty', () => {
+ const { container } = renderChips({ filters: [] });
+ expect(container.firstChild).toBeNull();
+ });
+ });
+
+ describe('rendering chips', () => {
+ it('renders a chip for each filter value', () => {
+ const filters = [{ field: 'categories', values: ['Fires', 'Floods'] }];
+ const { getAllByRole } = renderChips({ filters });
+ expect(getAllByRole('button')).toHaveLength(2);
+ });
+
+ it('renders chips for multiple filter fields', () => {
+ const filters = [
+ { field: 'categories', values: ['Fires'] },
+ { field: 'sources', values: ['MODIS', 'VIIRS'] },
+ ];
+ const { getAllByRole } = renderChips({ filters });
+ expect(getAllByRole('button')).toHaveLength(3);
+ });
+
+ it('wraps chips in a div with class bag-o-chips', () => {
+ const filters = [{ field: 'categories', values: ['Fires'] }];
+ const { container } = renderChips({ filters });
+ expect(container.firstChild.className).toBe('bag-o-chips');
+ });
+
+ it('renders each chip with class filter-chip', () => {
+ const filters = [{ field: 'categories', values: ['Fires'] }];
+ const { getByRole } = renderChips({ filters });
+ expect(getByRole('button').className).toBe('filter-chip');
+ });
+
+ it('displays the filter value as the chip label', () => {
+ const filters = [{ field: 'categories', values: ['Fires'] }];
+ const { getByRole } = renderChips({ filters });
+ expect(getByRole('button').querySelector('span').innerHTML).toBe('Fires');
+ });
+
+ it('renders a FontAwesomeIcon icon inside each chip', () => {
+ const filters = [{ field: 'categories', values: ['Fires'] }];
+ const { getAllByTestId } = renderChips({ filters });
+ expect(getAllByTestId('fa-icon')).toHaveLength(1);
+ });
+ });
+
+ describe('useLabelForValue', () => {
+ it('uses the config label as displayValue when useLabelForValue is true', () => {
+ const filters = [{ field: 'coverage', values: ['true'] }];
+ const { getByRole } = renderChips({ filters });
+ expect(getByRole('button').querySelector('span').innerHTML).toBe('Coverage');
+ });
+
+ it('uses the raw value as displayValue when useLabelForValue is falsy', () => {
+ const filters = [{ field: 'categories', values: ['Fires'] }];
+ const { getByRole } = renderChips({ filters });
+ expect(getByRole('button').querySelector('span').innerHTML).toBe('Fires');
+ });
+ });
+
+ describe('removeFilter callback', () => {
+ it('calls removeFilter with field and value when a chip is clicked', () => {
+ const removeFilter = jest.fn();
+ const filters = [{ field: 'categories', values: ['Fires'] }];
+ const { getByRole } = renderChips({ filters, removeFilter });
+ fireEvent.click(getByRole('button'));
+ expect(removeFilter).toHaveBeenCalledWith('categories', 'Fires');
+ });
+
+ it('calls removeFilter with the correct value for each chip', () => {
+ const removeFilter = jest.fn();
+ const filters = [{ field: 'categories', values: ['Fires', 'Floods'] }];
+ const { getAllByRole } = renderChips({ filters, removeFilter });
+ fireEvent.click(getAllByRole('button')[1]);
+ expect(removeFilter).toHaveBeenCalledWith('categories', 'Floods');
+ });
+
+ it('calls removeFilter with the correct field when multiple fields are active', () => {
+ const removeFilter = jest.fn();
+ const filters = [
+ { field: 'categories', values: ['Fires'] },
+ { field: 'sources', values: ['MODIS'] },
+ ];
+ const { getAllByRole } = renderChips({ filters, removeFilter });
+ fireEvent.click(getAllByRole('button')[1]);
+ expect(removeFilter).toHaveBeenCalledWith('sources', 'MODIS');
+ });
+ });
});
diff --git a/web/js/components/layer/product-picker/search/layer-metadata-detail.test.js b/web/js/components/layer/product-picker/search/layer-metadata-detail.test.js
index 26084f87b..069ad71b1 100644
--- a/web/js/components/layer/product-picker/search/layer-metadata-detail.test.js
+++ b/web/js/components/layer/product-picker/search/layer-metadata-detail.test.js
@@ -1,3 +1,255 @@
-test('layer-metadata-detail component test', () => {
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import LayerMetadataDetail from './layer-metadata-detail';
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon }) => <span data-testid={`fa-${icon}`} />,
+}));
+
+jest.mock('../renderSplitTitle', () => ({ layer }) => (
+ <div data-testid="split-title">{layer.title}</div>
+));
+
+jest.mock('../browse/recent-layers-info', () => () => (
+ <div data-testid="recent-layers-info" />
+));
+
+jest.mock('../../info/info', () => () => (
+ <div data-testid="layer-info" />
+));
+
+jest.mock('../../../../modules/layers/actions', () => ({
+ addLayer: jest.fn(() => ({ type: 'ADD_LAYER' })),
+ removeLayer: jest.fn(() => ({ type: 'REMOVE_LAYER' })),
+}));
+
+jest.mock('../../../../modules/product-picker/actions', () => ({
+ selectLayer: jest.fn(() => ({ type: 'SELECT_LAYER' })),
+}));
+
+jest.mock('../../../../modules/layers/selectors', () => ({
+ getActiveLayersMap: jest.fn(() => ({})),
+ makeGetDescription: jest.fn(() => jest.fn(() => '/path/to/desc')),
+}));
+
+const mockConfigureStore = configureStore([]);
+
+const baseState = {
+ productPicker: { selectedLayer: null, categoryType: 'search' },
+ proj: { id: 'geographic' },
+ config: {
+ features: {
+ previewSnapshots: true,
+ describeDomains: { url: 'https://example.com' },
+ },
+ },
+ layers: { active: { layers: [] } },
+};
+
+const sampleLayer = {
+ id: 'MODIS_Terra_CorrectedReflectance_TrueColor',
+ title: 'Corrected Reflectance (True Color)',
+};
+
+function renderComponent(ownProps = {}, stateOverrides = {}) {
+ const state = {
+ ...baseState,
+ ...stateOverrides,
+ productPicker: {
+ ...baseState.productPicker,
+ ...(stateOverrides.productPicker || {}),
+ },
+ config: {
+ ...baseState.config,
+ ...(stateOverrides.config || {}),
+ features: {
+ ...baseState.config.features,
+ ...((stateOverrides.config || {}).features || {}),
+ },
+ },
+ };
+ const store = mockConfigureStore(state);
+ store.dispatch = jest.fn();
+ const result = render(
+ <Provider store={store}>
+ <LayerMetadataDetail layer={ownProps.layer} />
+ </Provider>,
+ );
+ return { ...result, store };
+}
+
+describe('LayerMetadataDetail', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('No layer selected — categoryType !== "recent"', () => {
+ it('renders the no-results div with correct text', () => {
+ const { container, getByText } = renderComponent();
+ expect(container.querySelector('.no-results')).toBeTruthy();
+ expect(getByText('No layer selected.')).toBeTruthy();
+ expect(getByText('Select a layer to view details here!')).toBeTruthy();
+ });
+
+ it('renders the globe-americas icon', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('fa-globe-americas')).toBeTruthy();
+ });
+
+ it('does not render the layer card', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.layers-all-layer')).toBeNull();
+ });
+ });
+
+ describe('No layer selected — categoryType === "recent"', () => {
+ it('renders RecentLayersInfo', () => {
+ const { getByTestId } = renderComponent(
+ {},
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ expect(getByTestId('recent-layers-info')).toBeTruthy();
+ });
+
+ it('does not render the no-results div', () => {
+ const { container } = renderComponent(
+ {},
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ expect(container.querySelector('.no-results')).toBeNull();
+ });
+ });
+
+ describe('Layer provided — isActive=false', () => {
+ it('renders Add Layer button with plus icon', () => {
+ const { getByText, getByTestId } = renderComponent({ layer: sampleLayer });
+ expect(getByText('Add Layer')).toBeTruthy();
+ expect(getByTestId('fa-plus')).toBeTruthy();
+ });
+
+ it('button does not have is-active class', () => {
+ const { getByText } = renderComponent({ layer: sampleLayer });
+ const btn = getByText('Add Layer').closest('button');
+ expect(btn.className).not.toContain('is-active');
+ });
+
+ it('renders RenderSplitLayerTitle with the layer', () => {
+ const { getByTestId } = renderComponent({ layer: sampleLayer });
+ expect(getByTestId('split-title').textContent).toBe(sampleLayer.title);
+ });
+
+ it('renders LayerInfo', () => {
+ const { getByTestId } = renderComponent({ layer: sampleLayer });
+ expect(getByTestId('layer-info')).toBeTruthy();
+ });
+ });
+
+ describe('Layer provided — isActive=true', () => {
+ const activeState = {
+ productPicker: {
+ selectedLayer: sampleLayer,
+ categoryType: 'search',
+ },
+ };
+
+ beforeEach(() => {
+ const { getActiveLayersMap } = require('../../../../modules/layers/selectors');
+ getActiveLayersMap.mockReturnValue({ [sampleLayer.id]: true });
+ });
+
+ it('renders Remove Layer button with minus icon', () => {
+ const { getByText, getByTestId } = renderComponent(
+ { layer: sampleLayer },
+ activeState,
+ );
+ expect(getByText('Remove Layer')).toBeTruthy();
+ expect(getByTestId('fa-minus')).toBeTruthy();
+ });
+
+ it('button has is-active class', () => {
+ const { getByText } = renderComponent(
+ { layer: sampleLayer },
+ activeState,
+ );
+ const btn = getByText('Remove Layer').closest('button');
+ expect(btn.className).toContain('is-active');
+ });
+ });
+
+ describe('Preview image', () => {
+ it('renders preview image link when showPreviewImage=true', () => {
+ const { container } = renderComponent({ layer: sampleLayer });
+ const img = container.querySelector('img.layer-preview');
+ expect(img).toBeTruthy();
+ const expectedUrl = `images/layers/previews/geographic/${sampleLayer.id}.jpg`;
+ expect(img.getAttribute('src')).toBe(expectedUrl);
+ });
+
+ it('does not render preview image when showPreviewImage=false', () => {
+ const { container } = renderComponent(
+ { layer: sampleLayer },
+ {
+ config: {
+ features: {
+ previewSnapshots: false,
+ describeDomains: { url: 'https://example.com' },
+ },
+ },
+ },
+ );
+ expect(container.querySelector('img.layer-preview')).toBeNull();
+ });
+
+ it('preview image link has correct href and target', () => {
+ const { container } = renderComponent({ layer: sampleLayer });
+ const anchor = container.querySelector('a[rel="noopener noreferrer"]');
+ expect(anchor).toBeTruthy();
+ expect(anchor.getAttribute('target')).toBe('_blank');
+ const expectedUrl = `images/layers/previews/geographic/${sampleLayer.id}.jpg`;
+ expect(anchor.getAttribute('href')).toBe(expectedUrl);
+ });
+ });
+
+ describe('toggleLayer — dispatches actions', () => {
+ it('dispatches addLayer when isActive=false and button is clicked', () => {
+ const { addLayer } = require('../../../../modules/layers/actions');
+ const { getByText, store } = renderComponent({ layer: sampleLayer });
+ fireEvent.click(getByText('Add Layer').closest('button'));
+ expect(addLayer).toHaveBeenCalledWith(sampleLayer.id);
+ expect(store.dispatch).toHaveBeenCalledWith({ type: 'ADD_LAYER' });
+ });
+
+ it('dispatches removeLayer when isActive=true and button is clicked', () => {
+ const { removeLayer } = require('../../../../modules/layers/actions');
+ const { getActiveLayersMap } = require('../../../../modules/layers/selectors');
+ getActiveLayersMap.mockReturnValue({ [sampleLayer.id]: true });
+
+ const { getByText, store } = renderComponent(
+ { layer: sampleLayer },
+ { productPicker: { selectedLayer: sampleLayer, categoryType: 'search' } },
+ );
+ fireEvent.click(getByText('Remove Layer').closest('button'));
+ expect(removeLayer).toHaveBeenCalledWith(sampleLayer.id);
+ expect(store.dispatch).toHaveBeenCalledWith({ type: 'REMOVE_LAYER' });
+ });
+ });
+
+ describe('describeDomainsUrl fallback', () => {
+ it('uses fallback URL when describeDomains is not configured', () => {
+ // Should render without error; the fallback logic is in mapStateToProps
+ const { container } = renderComponent(
+ { layer: sampleLayer },
+ {
+ config: {
+ features: {
+ previewSnapshots: true,
+ },
+ },
+ },
+ );
+ expect(container.querySelector('.layers-all-layer')).toBeTruthy();
+ });
+ });
});
diff --git a/web/js/components/layer/product-picker/search/product-facet.test.js b/web/js/components/layer/product-picker/search/product-facet.test.js
index 5b512a216..34ec6e32b 100644
--- a/web/js/components/layer/product-picker/search/product-facet.test.js
+++ b/web/js/components/layer/product-picker/search/product-facet.test.js
@@ -1,3 +1,245 @@
-test('product-facet component test', () => {
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import ProductFacet from './product-facet';
+jest.mock('@elastic/react-search-ui', () => ({
+ Facet: ({ field, label }) => (
+ <div data-testid="facet" data-field={field} data-label={label} />
+ ),
+}));
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({
+ icon, className, onClick, id,
+ }) => (
+ <span
+ data-testid={`fa-${icon}`}
+ className={className}
+ id={id}
+ onClick={onClick}
+ />
+ ),
+}));
+
+jest.mock('reactstrap', () => ({
+ Tooltip: ({ children, isOpen, toggle }) => (
+ <div data-testid="tooltip" data-open={String(isOpen)} onClick={toggle}>
+ {children}
+ </div>
+ ),
+}));
+
+const baseConfig = {
+ field: 'categories',
+ label: 'Categories',
+ booleanOptionLabel: '',
+ filterType: 'any',
+ tooltip: '<b>Category info</b>',
+ show: 10,
+ view: undefined,
+};
+
+const defaultData = [{ value: 'Fires', count: 5 }];
+
+const renderFacet = ({
+ config = baseConfig,
+ data = defaultData,
+ collapsed = false,
+ toggleCollapse = jest.fn(),
+} = {}) => render(
+ <ProductFacet
+ config={config}
+ data={data}
+ collapsed={collapsed}
+ toggleCollapse={toggleCollapse}
+ />,
+);
+
+describe('ProductFacet', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('collapsed=true branch', () => {
+ it('renders the collapsed branch with fieldset and no Facet component', () => {
+ const { getByText, queryByTestId } = renderFacet({ collapsed: true });
+ expect(getByText('Categories')).toBeTruthy();
+ expect(queryByTestId('facet')).toBeNull();
+ });
+
+ it('renders the correct wrapper id when collapsed', () => {
+ const { container } = renderFacet({ collapsed: true });
+ expect(container.querySelector('#categories-facet')).toBeTruthy();
+ });
+
+ it('does not render "No matches." when collapsed with non-empty data', () => {
+ const { queryByText } = renderFacet({ collapsed: true });
+ expect(queryByText('No matches.')).toBeNull();
+ });
+
+ it('does not render "No matches." when collapsed with empty data', () => {
+ const { queryByText } = renderFacet({ collapsed: true, data: [] });
+ expect(queryByText('No matches.')).toBeNull();
+ });
+ });
+
+ describe('noResults branch (data=[], collapsed=false)', () => {
+ it('renders "No matches." when data is empty and not collapsed', () => {
+ const { getByText } = renderFacet({ data: [] });
+ expect(getByText('No matches.')).toBeTruthy();
+ });
+
+ it('renders fieldset label when no results and not collapsed', () => {
+ const { getByText } = renderFacet({ data: [] });
+ expect(getByText('Categories')).toBeTruthy();
+ });
+
+ it('does not render Facet component when no results', () => {
+ const { queryByTestId } = renderFacet({ data: [] });
+ expect(queryByTestId('facet')).toBeNull();
+ });
+
+ it('renders wrapper with correct id', () => {
+ const { container } = renderFacet({ data: [] });
+ expect(container.querySelector('#categories-facet')).toBeTruthy();
+ });
+ });
+
+ describe('normal branch (data non-empty, collapsed=false)', () => {
+ it('renders the Facet component', () => {
+ const { getByTestId } = renderFacet();
+ expect(getByTestId('facet')).toBeTruthy();
+ });
+
+ it('passes field to Facet', () => {
+ const { getByTestId } = renderFacet();
+ expect(getByTestId('facet').dataset.field).toBe('categories');
+ });
+
+ it('uses label when booleanOptionLabel is empty string', () => {
+ const config = {
+ ...baseConfig,
+ booleanOptionLabel: '',
+ };
+ const { getByTestId } = renderFacet({ config });
+ expect(getByTestId('facet').dataset.label).toBe('Categories');
+ });
+
+ it('uses booleanOptionLabel when present', () => {
+ const config = {
+ ...baseConfig,
+ booleanOptionLabel: 'Boolean Label',
+ };
+ const { getByTestId } = renderFacet({ config });
+ expect(getByTestId('facet').dataset.label).toBe('Boolean Label');
+ });
+
+ it('does not render fieldset in normal branch', () => {
+ const { container } = renderFacet();
+ expect(container.querySelector('fieldset')).toBeNull();
+ });
+
+ it('does not render "No matches." in normal branch', () => {
+ const { queryByText } = renderFacet();
+ expect(queryByText('No matches.')).toBeNull();
+ });
+
+ it('renders wrapper with correct id', () => {
+ const { container } = renderFacet();
+ expect(container.querySelector('#categories-facet')).toBeTruthy();
+ });
+ });
+
+ describe('collapse icon behavior', () => {
+ it('renders caret-down icon when not collapsed', () => {
+ const { getByTestId } = renderFacet({ collapsed: false });
+ expect(getByTestId('fa-caret-down')).toBeTruthy();
+ });
+
+ it('renders caret-left icon when collapsed', () => {
+ const { getByTestId } = renderFacet({ collapsed: true });
+ expect(getByTestId('fa-caret-left')).toBeTruthy();
+ });
+
+ it('calls toggleCollapse with field when caret-down is clicked', () => {
+ const toggleCollapse = jest.fn();
+ const { getByTestId } = renderFacet({ collapsed: false, toggleCollapse });
+ fireEvent.click(getByTestId('fa-caret-down'));
+ expect(toggleCollapse).toHaveBeenCalledWith('categories');
+ });
+
+ it('calls toggleCollapse with field when caret-left is clicked (collapsed state)', () => {
+ const toggleCollapse = jest.fn();
+ const { getByTestId } = renderFacet({ collapsed: true, toggleCollapse });
+ fireEvent.click(getByTestId('fa-caret-left'));
+ expect(toggleCollapse).toHaveBeenCalledWith('categories');
+ });
+ });
+
+ describe('collapse toggle icon hidden class', () => {
+ it('adds "hidden" class to collapse icon when data is empty', () => {
+ const { getByTestId } = renderFacet({ data: [] });
+ expect(getByTestId('fa-caret-down').className).toContain('hidden');
+ });
+
+ it('does not add "hidden" class to collapse icon when data is non-empty', () => {
+ const { getByTestId } = renderFacet();
+ expect(getByTestId('fa-caret-down').className).not.toContain('hidden');
+ });
+ });
+
+ describe('tooltip behavior', () => {
+ it('renders tooltip with isOpen=false initially', () => {
+ const { getByTestId } = renderFacet();
+ expect(getByTestId('tooltip').dataset.open).toBe('false');
+ });
+
+ it('toggles tooltip open when clicked', () => {
+ const { getByTestId } = renderFacet();
+ const tooltip = getByTestId('tooltip');
+ fireEvent.click(tooltip);
+ expect(tooltip.dataset.open).toBe('true');
+ });
+
+ it('toggles tooltip closed on second click', () => {
+ const { getByTestId } = renderFacet();
+ const tooltip = getByTestId('tooltip');
+ fireEvent.click(tooltip);
+ fireEvent.click(tooltip);
+ expect(tooltip.dataset.open).toBe('false');
+ });
+
+ it('renders info-circle icon with correct id for tooltip target', () => {
+ const { getByTestId } = renderFacet();
+ expect(getByTestId('fa-info-circle').id).toBe('categories-tooltip-target');
+ });
+
+ it('renders tooltip in collapsed state', () => {
+ const { getByTestId } = renderFacet({ collapsed: true });
+ expect(getByTestId('tooltip').dataset.open).toBe('false');
+ });
+ });
+
+ describe('header icons always rendered', () => {
+ it('renders tooltip and both icons in collapsed state', () => {
+ const { getByTestId } = renderFacet({ collapsed: true });
+ expect(getByTestId('tooltip')).toBeTruthy();
+ expect(getByTestId('fa-info-circle')).toBeTruthy();
+ expect(getByTestId('fa-caret-left')).toBeTruthy();
+ });
+
+ it('renders tooltip and both icons in normal state', () => {
+ const { getByTestId } = renderFacet();
+ expect(getByTestId('tooltip')).toBeTruthy();
+ expect(getByTestId('fa-info-circle')).toBeTruthy();
+ expect(getByTestId('fa-caret-down')).toBeTruthy();
+ });
+
+ it('renders tooltip and both icons in no-results state', () => {
+ const { getByTestId } = renderFacet({ data: [] });
+ expect(getByTestId('tooltip')).toBeTruthy();
+ expect(getByTestId('fa-info-circle')).toBeTruthy();
+ expect(getByTestId('fa-caret-down')).toBeTruthy();
+ });
+ });
});
diff --git a/web/js/components/layer/product-picker/search/search-layer-row.test.js b/web/js/components/layer/product-picker/search/search-layer-row.test.js
index b02faba6c..5cce7ec7d 100644
--- a/web/js/components/layer/product-picker/search/search-layer-row.test.js
+++ b/web/js/components/layer/product-picker/search/search-layer-row.test.js
@@ -1,3 +1,526 @@
-test('search-layer-row component test', () => {
+/* eslint-disable react/prop-types */
+import { render, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import SearchLayerRow from './search-layer-row';
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: ({ icon, id, className }) => (
+ <span data-testid={`fa-${icon}`} id={id} className={className} />
+ ),
+}));
+
+jest.mock('../renderSplitTitle', () => ({ layer }) => (
+ <span data-testid="layer-title">{layer.id}</span>
+));
+
+jest.mock('../../../../modules/layers/actions', () => ({
+ addLayer: jest.fn(() => ({ type: 'ADD_LAYER' })),
+ removeLayer: jest.fn(() => ({ type: 'REMOVE_LAYER' })),
+}));
+
+jest.mock('../../../../modules/product-picker/actions', () => ({
+ clearSingleRecentLayer: jest.fn(() => ({ type: 'CLEAR_RECENT' })),
+}));
+
+jest.mock('../../../../modules/layers/selectors', () => ({
+ getActiveLayersMap: jest.fn(() => ({})),
+}));
+
+jest.mock('../../../../modules/date/selectors', () => ({
+ getSelectedDate: jest.fn(() => '2023-05-01'),
+}));
+
+jest.mock('../../../../modules/notifications/util', () => ({
+ getLayerNoticesForLayer: jest.fn(() => null),
+}));
+
+jest.mock('../../../../util/util', () => ({
+ __esModule: true,
+ default: {
+ encodeId: jest.fn((id) => id),
+ events: { trigger: jest.fn() },
+ },
+}));
+
+jest.mock('../../../../util/constants', () => ({
+ JOYRIDE_INCREMENT: 'joyride:increment',
+}));
+
+// Mock reactstrap so that UncontrolledTooltip doesn't try to find DOM targets
+jest.mock('reactstrap', () => ({
+ UncontrolledTooltip: ({ children }) => <div>{children}</div>,
+ Button: ({ children, onClick, className, color, title }) => (
+ <div
+ role="button"
+ className={className}
+ data-color={color}
+ title={title}
+ onClick={onClick}
+ >
+ {children}
+ </div>
+ ),
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const mockConfigureStore = configureStore([]);
+
+const baseState = {
+ productPicker: { selectedLayer: null, categoryType: 'search' },
+ screenSize: { isMobileDevice: false, screenWidth: 1200 },
+ notifications: {},
+ date: { selected: '2023-05-01' },
+ compare: { isCompareA: true },
+};
+
+const layer = {
+ id: 'MODIS_Terra_CorrectedReflectance_TrueColor',
+ title: 'MODIS Terra CorrectedReflectance',
+};
+
+function renderRow(ownProps = {}, stateOverrides = {}) {
+ const state = {
+ ...baseState,
+ ...stateOverrides,
+ productPicker: {
+ ...baseState.productPicker,
+ ...(stateOverrides.productPicker || {}),
+ },
+ screenSize: {
+ ...baseState.screenSize,
+ ...(stateOverrides.screenSize || {}),
+ },
+ };
+ const store = mockConfigureStore(state);
+ const showLayerMetadata = ownProps.showLayerMetadata || jest.fn();
+ const rowLayer = ownProps.layer || layer;
+ const result = render(
+ <Provider store={store}>
+ <SearchLayerRow
+ layer={rowLayer}
+ showLayerMetadata={showLayerMetadata}
+ />
+ </Provider>,
+ );
+ return { ...result, store, showLayerMetadata };
+}
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+beforeAll(() => {
+ Element.prototype.scrollIntoView = jest.fn();
+});
+
+beforeEach(() => {
+ // Clear call history on all mocks without wiping implementations.
+ // (jest.clearAllMocks() in Jest 30 can wipe implementations set in
+ // jest.mock() factories, so we clear selectively instead.)
+ Element.prototype.scrollIntoView.mockClear();
+
+ const util = require('../../../../util/util').default;
+ util.encodeId.mockClear();
+ util.events.trigger.mockClear();
+
+ const { addLayer } = require('../../../../modules/layers/actions');
+ addLayer.mockClear();
+
+ const { removeLayer } = require('../../../../modules/layers/actions');
+ removeLayer.mockClear();
+
+ const { clearSingleRecentLayer } = require('../../../../modules/product-picker/actions');
+ clearSingleRecentLayer.mockClear();
+
+ // Reset selectors that individual tests may override.
+ const { getActiveLayersMap } = require('../../../../modules/layers/selectors');
+ getActiveLayersMap.mockReturnValue({});
+
+ const { getLayerNoticesForLayer } = require('../../../../modules/notifications/util');
+ getLayerNoticesForLayer.mockReturnValue(null);
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('SearchLayerRow', () => {
+ // -------------------------------------------------------------------------
+ // Row classes
+ // -------------------------------------------------------------------------
+ describe('row CSS classes', () => {
+ it('renders base row class when layer is not selected', () => {
+ const { container } = renderRow();
+ const row = container.querySelector(`#${layer.id}-search-row`);
+ expect(row).toBeTruthy();
+ expect(row.className).toBe('search-row layers-all-layer');
+ });
+
+ it('adds "selected" class when selectedLayer matches layer', () => {
+ const { container } = renderRow(
+ {},
+ { productPicker: { selectedLayer: layer, categoryType: 'search' } },
+ );
+ const row = container.querySelector(`#${layer.id}-search-row`);
+ expect(row.className).toContain('selected');
+ });
+
+ it('does not add "selected" class when a different layer is selected', () => {
+ const { container } = renderRow(
+ {},
+ {
+ productPicker: {
+ selectedLayer: { id: 'OTHER_LAYER' },
+ categoryType: 'search',
+ },
+ },
+ );
+ const row = container.querySelector(`#${layer.id}-search-row`);
+ expect(row.className).not.toContain('selected');
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // Checkbox classes and SVG
+ // -------------------------------------------------------------------------
+ describe('checkbox state', () => {
+ it('renders unchecked checkbox class without "checked" when layer is not active', () => {
+ const { container } = renderRow();
+ const checkboxDiv = container.querySelector('.wv-checkbox');
+ expect(checkboxDiv.className).toContain('gray');
+ expect(checkboxDiv.className).not.toContain('checked');
+ });
+
+ it('renders "checked" class when layer is enabled', () => {
+ const { getActiveLayersMap } = require('../../../../modules/layers/selectors');
+ getActiveLayersMap.mockReturnValue({ [layer.id]: true });
+
+ const { container } = renderRow();
+ const checkboxDiv = container.querySelector('.wv-checkbox');
+ expect(checkboxDiv.className).toContain('checked');
+ });
+
+ it('does not render check SVG when layer is not enabled', () => {
+ const { container } = renderRow();
+ expect(container.querySelector('svg.check')).toBeNull();
+ });
+
+ it('renders check SVG when layer is enabled', () => {
+ const { getActiveLayersMap } = require('../../../../modules/layers/selectors');
+ getActiveLayersMap.mockReturnValue({ [layer.id]: true });
+
+ const { container } = renderRow();
+ expect(container.querySelector('svg.check')).toBeTruthy();
+ });
+
+ it('checkbox does not have "gray" when metadata is showing (layer selected)', () => {
+ const { getActiveLayersMap } = require('../../../../modules/layers/selectors');
+ getActiveLayersMap.mockReturnValue({ [layer.id]: true });
+
+ const { container } = renderRow(
+ {},
+ { productPicker: { selectedLayer: layer, categoryType: 'search' } },
+ );
+ const checkboxDiv = container.querySelector('.wv-checkbox');
+ expect(checkboxDiv.className).not.toContain('gray');
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // Chartable layer notice
+ // -------------------------------------------------------------------------
+ describe('chartable layer notice', () => {
+ it('does not show layer-notices when no analysis and no layerNotices', () => {
+ const { container } = renderRow();
+ expect(container.querySelector('.layer-notices')).toBeNull();
+ });
+
+ it('shows chartable notice when analysis includes Chartable (Raster-based)', () => {
+ const chartableLayer = { ...layer, analysis: ['Chartable (Raster-based)'] };
+ const { container } = renderRow({ layer: chartableLayer });
+ expect(container.querySelector('.chartable-icon')).toBeTruthy();
+ });
+
+ it('does not show chartable notice when analysis does not include Chartable', () => {
+ const nonChartableLayer = { ...layer, analysis: ['Something else'] };
+ const { container } = renderRow({ layer: nonChartableLayer });
+ expect(container.querySelector('.chartable-icon')).toBeNull();
+ });
+
+ it('sets header class to include "notice" when chartable', () => {
+ const chartableLayer = { ...layer, analysis: ['Chartable (Raster-based)'] };
+ const { container } = renderRow({ layer: chartableLayer });
+ const header = container.querySelector('button.layers-all-header');
+ expect(header.className).toContain('notice');
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // layerNotices
+ // -------------------------------------------------------------------------
+ describe('layerNotices', () => {
+ it('shows exclamation-triangle icon when layerNotices is set', () => {
+ const { getLayerNoticesForLayer } = require('../../../../modules/notifications/util');
+ getLayerNoticesForLayer.mockReturnValue('<b>Notice!</b>');
+
+ const { getByTestId } = renderRow();
+ expect(getByTestId('fa-exclamation-triangle')).toBeTruthy();
+ });
+
+ it('does not show exclamation-triangle when layerNotices is null', () => {
+ const { queryByTestId } = renderRow();
+ expect(queryByTestId('fa-exclamation-triangle')).toBeNull();
+ });
+
+ it('sets header class to include "notice" when layerNotices present', () => {
+ const { getLayerNoticesForLayer } = require('../../../../modules/notifications/util');
+ getLayerNoticesForLayer.mockReturnValue('Some notice');
+
+ const { container } = renderRow();
+ const header = container.querySelector('button.layers-all-header');
+ expect(header.className).toContain('notice');
+ });
+
+ it('header class does not include "notice" when no notices and not chartable', () => {
+ const { container } = renderRow();
+ const header = container.querySelector('button.layers-all-header');
+ expect(header.className).not.toContain('notice');
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // Delete button (recent layer mode)
+ // -------------------------------------------------------------------------
+ describe('delete button', () => {
+ it('does not render delete button in search mode', () => {
+ const { container } = renderRow();
+ expect(container.querySelector('.recent-layer-delete')).toBeNull();
+ });
+
+ it('does not render delete button in recent mode before hover', () => {
+ const { container } = renderRow(
+ {},
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ expect(container.querySelector('.recent-layer-delete')).toBeNull();
+ });
+
+ it('shows delete button in recent mode after mouseEnter on non-mobile', () => {
+ const { container } = renderRow(
+ {},
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ const row = container.querySelector(`#${layer.id}-search-row`);
+ fireEvent.mouseEnter(row);
+ expect(container.querySelector('.recent-layer-delete')).toBeTruthy();
+ });
+
+ it('hides delete button after mouseLeave', () => {
+ const { container } = renderRow(
+ {},
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ const row = container.querySelector(`#${layer.id}-search-row`);
+ fireEvent.mouseEnter(row);
+ fireEvent.mouseLeave(row);
+ expect(container.querySelector('.recent-layer-delete')).toBeNull();
+ });
+
+ it('does not show delete button on mobile even after hover', () => {
+ const { container } = renderRow(
+ {},
+ {
+ productPicker: { selectedLayer: null, categoryType: 'recent' },
+ screenSize: { isMobileDevice: true, screenWidth: 375 },
+ },
+ );
+ const row = container.querySelector(`#${layer.id}-search-row`);
+ fireEvent.mouseEnter(row);
+ expect(container.querySelector('.recent-layer-delete')).toBeNull();
+ });
+
+ it('calls clearSingleRecentLayer with event and layer when delete button clicked', () => {
+ const { clearSingleRecentLayer } = require('../../../../modules/product-picker/actions');
+ const { container, store } = renderRow(
+ {},
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ const row = container.querySelector(`#${layer.id}-search-row`);
+ fireEvent.mouseEnter(row);
+ const deleteBtn = container.querySelector('.recent-layer-delete');
+ fireEvent.click(deleteBtn);
+ expect(clearSingleRecentLayer).toHaveBeenCalled();
+ expect(store.getActions()).toContainEqual({ type: 'CLEAR_RECENT' });
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // toggleEnabled (checkbox onChange)
+ // -------------------------------------------------------------------------
+ describe('toggleEnabled', () => {
+ it('dispatches addLayer when layer is not enabled and checkbox is changed', () => {
+ const { addLayer } = require('../../../../modules/layers/actions');
+ const { container, store } = renderRow();
+ const checkbox = container.querySelector(`#${layer.id}-checkbox`);
+ fireEvent.click(checkbox);
+ expect(addLayer).toHaveBeenCalledWith(layer.id);
+ expect(store.getActions()).toContainEqual({ type: 'ADD_LAYER' });
+ });
+
+ it('dispatches removeLayer when layer is enabled and checkbox is changed', () => {
+ const { getActiveLayersMap } = require('../../../../modules/layers/selectors');
+ getActiveLayersMap.mockReturnValue({ [layer.id]: true });
+ const { removeLayer } = require('../../../../modules/layers/actions');
+
+ const { container, store } = renderRow();
+ const checkbox = container.querySelector(`#${layer.id}-checkbox`);
+ fireEvent.click(checkbox);
+ expect(removeLayer).toHaveBeenCalledWith(layer.id);
+ expect(store.getActions()).toContainEqual({ type: 'REMOVE_LAYER' });
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // onRowClick / toggleShowMetadata
+ // -------------------------------------------------------------------------
+ describe('onRowClick and toggleShowMetadata', () => {
+ it('calls showLayerMetadata with layer.id when no layer is selected', () => {
+ const showLayerMetadata = jest.fn();
+ const { container } = renderRow({ showLayerMetadata });
+ const header = container.querySelector('button.layers-all-header');
+ fireEvent.click(header);
+ expect(showLayerMetadata).toHaveBeenCalledWith(layer.id);
+ });
+
+ it('calls showLayerMetadata(null) when the same layer is already selected', () => {
+ const showLayerMetadata = jest.fn();
+ const { container } = renderRow(
+ { showLayerMetadata },
+ { productPicker: { selectedLayer: layer, categoryType: 'search' } },
+ );
+ const header = container.querySelector('button.layers-all-header');
+ fireEvent.click(header);
+ expect(showLayerMetadata).toHaveBeenCalledWith(null);
+ });
+
+ it('calls showLayerMetadata with layer.id when a different layer is selected', () => {
+ const showLayerMetadata = jest.fn();
+ const { container } = renderRow(
+ { showLayerMetadata },
+ {
+ productPicker: {
+ selectedLayer: { id: 'OTHER_LAYER' },
+ categoryType: 'search',
+ },
+ },
+ );
+ const header = container.querySelector('button.layers-all-header');
+ fireEvent.click(header);
+ expect(showLayerMetadata).toHaveBeenCalledWith(layer.id);
+ });
+
+ it('triggers JOYRIDE_INCREMENT event via util.events.trigger after click', async () => {
+ jest.useFakeTimers();
+ const util = require('../../../../util/util').default;
+ const showLayerMetadata = jest.fn();
+ const { container } = renderRow({ showLayerMetadata });
+ const header = container.querySelector('button.layers-all-header');
+ fireEvent.click(header);
+ jest.runAllTimers();
+ expect(util.events.trigger).toHaveBeenCalledWith('joyride:increment');
+ jest.useRealTimers();
+ });
+
+ it('calls scrollIntoView via setTimeout when no selectedLayer and scrollIntoView is true', async () => {
+ jest.useFakeTimers();
+ const showLayerMetadata = jest.fn();
+ // screenWidth < 1024 → scrollIntoView prop = true
+ const { container } = renderRow(
+ { showLayerMetadata },
+ { screenSize: { isMobileDevice: false, screenWidth: 800 } },
+ );
+ const header = container.querySelector('button.layers-all-header');
+ fireEvent.click(header);
+ jest.runAllTimers();
+ expect(Element.prototype.scrollIntoView).toHaveBeenCalled();
+ jest.useRealTimers();
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // componentDidMount: scrollIntoView
+ // -------------------------------------------------------------------------
+ describe('componentDidMount', () => {
+ it('calls scrollIntoView on mount when selectedLayer matches layer', () => {
+ renderRow(
+ {},
+ { productPicker: { selectedLayer: layer, categoryType: 'search' } },
+ );
+ expect(Element.prototype.scrollIntoView).toHaveBeenCalledWith(true);
+ });
+
+ it('does not call scrollIntoView on mount when no selectedLayer', () => {
+ renderRow();
+ expect(Element.prototype.scrollIntoView).not.toHaveBeenCalled();
+ });
+
+ it('does not call scrollIntoView on mount when a different layer is selected', () => {
+ renderRow(
+ {},
+ {
+ productPicker: {
+ selectedLayer: { id: 'OTHER_LAYER' },
+ categoryType: 'search',
+ },
+ },
+ );
+ expect(Element.prototype.scrollIntoView).not.toHaveBeenCalled();
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // Layer title rendered
+ // -------------------------------------------------------------------------
+ describe('layer title rendering', () => {
+ it('renders RenderSplitLayerTitle with the layer', () => {
+ const { getByTestId } = renderRow();
+ expect(getByTestId('layer-title').textContent).toBe(layer.id);
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // Encoded ID usage
+ // -------------------------------------------------------------------------
+ describe('encodedId usage', () => {
+ it('uses encodedId for the row id attribute', () => {
+ const util = require('../../../../util/util').default;
+ util.encodeId.mockReturnValue('encoded-layer-id');
+
+ const { container } = renderRow();
+ expect(container.querySelector('#encoded-layer-id-search-row')).toBeTruthy();
+ });
+ });
+
+ // -------------------------------------------------------------------------
+ // Both chartable + layerNotices simultaneously
+ // -------------------------------------------------------------------------
+ describe('chartable + layerNotices together', () => {
+ it('shows both chartable icon and exclamation-triangle when both present', () => {
+ const { getLayerNoticesForLayer } = require('../../../../modules/notifications/util');
+ getLayerNoticesForLayer.mockReturnValue('Important notice');
+
+ const chartableLayer = { ...layer, analysis: ['Chartable (Raster-based)'] };
+ const { container, getByTestId } = renderRow({ layer: chartableLayer });
+ expect(container.querySelector('.chartable-icon')).toBeTruthy();
+ expect(getByTestId('fa-exclamation-triangle')).toBeTruthy();
+ });
+ });
});
diff --git a/web/js/components/layer/product-picker/search/search-layers-list.test.js b/web/js/components/layer/product-picker/search/search-layers-list.test.js
index 7d6cabad5..1110bbfd5 100644
--- a/web/js/components/layer/product-picker/search/search-layers-list.test.js
+++ b/web/js/components/layer/product-picker/search/search-layers-list.test.js
@@ -1,3 +1,271 @@
-test('search-layers-list component test', () => {
+/* eslint-disable react/prop-types */
+import { render, act, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import SearchLayerList from './search-layers-list';
+import {
+ selectLayer as selectLayerAction,
+ clearSingleRecentLayer as clearSingleRecentLayerAction,
+} from '../../../../modules/product-picker/actions';
+jest.mock('@elastic/react-search-ui', () => ({
+ withSearch: () => (Component) => Component,
+}));
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+ FontAwesomeIcon: () => <span data-testid="fa-icon" />,
+}));
+
+jest.mock('./search-layer-row', () => ({ layer }) => (
+ <div data-testid={`row-${layer.id}`} />
+));
+
+jest.mock('../browse/recent-layers-info', () => () => (
+ <div data-testid="recent-layers-info" />
+));
+
+jest.mock('../../../util/swipe-to-delete', () => ({ children, onDelete }) => (
+ <div data-testid="swipe-delete" onClick={onDelete}>{children}</div>
+));
+
+jest.mock('../../../../modules/product-picker/actions', () => ({
+ selectLayer: jest.fn(() => ({ type: 'SELECT_LAYER' })),
+ clearSingleRecentLayer: jest.fn(() => ({ type: 'CLEAR_RECENT' })),
+}));
+
+jest.mock('react-infinite-scroller', () => ({ children }) => (
+ <div data-testid="infinite-scroll">{children}</div>
+));
+
+const mockConfigureStore = configureStore([]);
+
+const baseState = {
+ productPicker: { selectedLayer: null, categoryType: 'search' },
+ screenSize: { isMobileDevice: false },
+};
+
+/**
+ * Build a store + render helper.
+ * Pass `results` as a direct prop since withSearch is a passthrough mock.
+ * The component only populates visibleItems after componentDidUpdate fires
+ * (when prevProps.results !== results), so we render with [] first then
+ * rerender with the real results to trigger the update cycle.
+ */
+function renderComponent(ownProps = {}, stateOverrides = {}) {
+ const state = {
+ ...baseState,
+ ...stateOverrides,
+ productPicker: {
+ ...baseState.productPicker,
+ ...(stateOverrides.productPicker || {}),
+ },
+ screenSize: {
+ ...baseState.screenSize,
+ ...(stateOverrides.screenSize || {}),
+ },
+ };
+ const store = mockConfigureStore(state);
+ store.dispatch = jest.fn();
+
+ const { results = [], selectedLayer, isMobile, recentLayerMode } = ownProps;
+
+ const makeJsx = (r) => (
+ <Provider store={store}>
+ <SearchLayerList
+ results={r}
+ selectedLayer={selectedLayer}
+ isMobile={isMobile}
+ recentLayerMode={recentLayerMode}
+ />
+ </Provider>
+ );
+
+ // Initial render with empty results so state starts clean
+ const renderResult = render(makeJsx([]));
+
+ // Rerender with actual results → triggers componentDidUpdate which loads items
+ act(() => {
+ renderResult.rerender(makeJsx(results));
+ });
+
+ return { ...renderResult, store };
+}
+
+describe('SearchLayerList', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ // ─── renderNoResults ──────────────────────────────────────────────────────
+
+ describe('renderNoResults — non-recentLayerMode', () => {
+ it('shows the no-results div with "No layers found!" when results are empty', () => {
+ const { container, getByText } = renderComponent({ results: [] });
+ expect(container.querySelector('.no-results')).toBeTruthy();
+ expect(getByText(/No layers found!/)).toBeTruthy();
+ });
+
+ it('renders the FontAwesome icon in the no-results view', () => {
+ const { getByTestId } = renderComponent({ results: [] });
+ expect(getByTestId('fa-icon')).toBeTruthy();
+ });
+
+ it('does not render InfiniteScroll when there are no results', () => {
+ const { queryByTestId } = renderComponent({ results: [] });
+ expect(queryByTestId('infinite-scroll')).toBeNull();
+ });
+ });
+
+ describe('renderNoResults — recentLayerMode', () => {
+ it('shows RecentLayersInfo when results are empty and recentLayerMode is true', () => {
+ const { getByTestId } = renderComponent(
+ { results: [] },
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ expect(getByTestId('recent-layers-info')).toBeTruthy();
+ });
+
+ it('does not show the no-results div in recentLayerMode', () => {
+ const { container } = renderComponent(
+ { results: [] },
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ expect(container.querySelector('.no-results')).toBeNull();
+ });
+ });
+
+ // ─── render with results ─────────────────────────────────────────────────
+
+ describe('render with results', () => {
+ it('renders InfiniteScroll when results are present', () => {
+ const results = [{ id: 'layer1' }, { id: 'layer2' }];
+ const { getByTestId } = renderComponent({ results });
+ expect(getByTestId('infinite-scroll')).toBeTruthy();
+ });
+
+ it('renders a SearchLayerRow for each visible item on desktop (non-recentLayerMode)', () => {
+ const results = [{ id: 'layer1' }, { id: 'layer2' }];
+ const { getByTestId } = renderComponent({ results });
+ expect(getByTestId('row-layer1')).toBeTruthy();
+ expect(getByTestId('row-layer2')).toBeTruthy();
+ });
+
+ it('does not render SwipeToDelete on desktop regardless of recentLayerMode', () => {
+ const results = [{ id: 'layer1' }];
+ const { queryByTestId } = renderComponent(
+ { results },
+ { productPicker: { selectedLayer: null, categoryType: 'recent' } },
+ );
+ expect(queryByTestId('swipe-delete')).toBeNull();
+ });
+ });
+
+ // ─── mobile + recentLayerMode ─────────────────────────────────────────────
+
+ describe('mobile + recentLayerMode — SwipeToDelete', () => {
+ it('wraps rows in SwipeToDelete when mobile and recentLayerMode', () => {
+ const results = [{ id: 'layer1' }];
+ const { getByTestId } = renderComponent(
+ { results },
+ {
+ productPicker: { selectedLayer: null, categoryType: 'recent' },
+ screenSize: { isMobileDevice: true },
+ },
+ );
+ expect(getByTestId('swipe-delete')).toBeTruthy();
+ expect(getByTestId('row-layer1')).toBeTruthy();
+ });
+
+ it('dispatches clearSingleRecentLayer when SwipeToDelete onDelete fires', () => {
+ const layer = { id: 'layer1' };
+ const { getByTestId, store } = renderComponent(
+ { results: [layer] },
+ {
+ productPicker: { selectedLayer: null, categoryType: 'recent' },
+ screenSize: { isMobileDevice: true },
+ },
+ );
+ fireEvent.click(getByTestId('swipe-delete'));
+ expect(clearSingleRecentLayerAction).toHaveBeenCalledWith(layer);
+ expect(store.dispatch).toHaveBeenCalledWith({ type: 'CLEAR_RECENT' });
+ });
+ });
+
+ // ─── loadMoreItems ────────────────────────────────────────────────────────
+
+ describe('loadMoreItems', () => {
+ it('loads up to 50 items from results into visibleItems on first render', () => {
+ const results = Array.from({ length: 60 }, (_, i) => ({ id: `layer${i}` }));
+ const { getAllByTestId } = renderComponent({ results });
+ const rows = getAllByTestId(/^row-layer/);
+ expect(rows).toHaveLength(50);
+ });
+
+ it('sets hasMoreItems=false when all results fit within the first 50', () => {
+ const results = Array.from({ length: 10 }, (_, i) => ({ id: `layer${i}` }));
+ const { getAllByTestId } = renderComponent({ results });
+ expect(getAllByTestId(/^row-layer/)).toHaveLength(10);
+ });
+ });
+
+ // ─── showLayerMetadata ────────────────────────────────────────────────────
+
+ describe('showLayerMetadata', () => {
+ it('calls selectLayer(null) when selectedLayer is not in the results list', () => {
+ // selectedLayer exists but is absent from results → showLayerMetadata(null)
+ const selectedLayer = { id: 'missing-layer' };
+ renderComponent(
+ { results: [{ id: 'other-layer' }], selectedLayer },
+ { productPicker: { selectedLayer, categoryType: 'search' } },
+ );
+ expect(selectLayerAction).toHaveBeenCalledWith(null);
+ });
+
+ it('calls selectLayer(layer) when no selectedLayer and result is available', () => {
+ // componentDidUpdate auto-selects first result when firstLoadAutoSelect is false
+ const layer = { id: 'layer1' };
+ renderComponent({ results: [layer] });
+ expect(selectLayerAction).toHaveBeenCalledWith(layer);
+ });
+
+ it('does NOT re-call selectLayer when layer already selected and has metadata', () => {
+ const layer = { id: 'layer1', metadata: '<p>info</p>' };
+ renderComponent(
+ { results: [layer], selectedLayer: layer },
+ { productPicker: { selectedLayer: layer, categoryType: 'search' } },
+ );
+ // selectedLayer in results and has metadata → no re-select
+ expect(selectLayerAction).not.toHaveBeenCalled();
+ });
+ });
+
+ // ─── getDerivedStateFromProps ─────────────────────────────────────────────
+
+ describe('getDerivedStateFromProps', () => {
+ it('sets firstLoadAutoSelect=true when selectedLayer prop is present', () => {
+ const layer = { id: 'layer1', metadata: '<p>info</p>' };
+ // selectedLayer already set → getDerivedStateFromProps returns {firstLoadAutoSelect:true}
+ // so componentDidUpdate does NOT auto-select; selectLayer is never called
+ renderComponent(
+ { results: [layer], selectedLayer: layer },
+ { productPicker: { selectedLayer: layer, categoryType: 'search' } },
+ );
+ expect(selectLayerAction).not.toHaveBeenCalled();
+ });
+ });
+
+ // ─── componentDidUpdate — auto-select first result ────────────────────────
+
+ describe('componentDidUpdate — auto-select first result', () => {
+ it('auto-selects the first result when no selectedLayer and results are present', () => {
+ const layer = { id: 'layer1' };
+ renderComponent({ results: [layer] });
+ expect(selectLayerAction).toHaveBeenCalledWith(layer);
+ });
+
+ it('does not auto-select when results array is empty', () => {
+ renderComponent({ results: [] });
+ expect(selectLayerAction).not.toHaveBeenCalled();
+ });
+ });
});
diff --git a/web/js/components/layer/product-picker/search/search-layers.test.js b/web/js/components/layer/product-picker/search/search-layers.test.js
index df0de05f3..02e0b04e2 100644
--- a/web/js/components/layer/product-picker/search/search-layers.test.js
+++ b/web/js/components/layer/product-picker/search/search-layers.test.js
@@ -1,3 +1,280 @@
-test('search-layers component test', () => {
+/* eslint-disable react/prop-types */
+import { render } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureStore from 'redux-mock-store';
+import SearchLayers from './search-layers';
+jest.mock('@elastic/react-search-ui', () => ({
+ withSearch: () => (Component) => Component,
+}));
+
+jest.mock('./search-layers-list', () => () => (
+ <div data-testid="search-layer-list" />
+));
+
+jest.mock('./facets', () => () => (
+ <div data-testid="facets" />
+));
+
+jest.mock('./layer-metadata-detail', () => ({ layer }) => (
+ <div data-testid="layer-metadata-detail" data-layer-id={layer && layer.id} />
+));
+
+const mockConfigureStore = configureStore([]);
+
+const BP = { small: 768, medium: 960 };
+
+const baseState = {
+ screenSize: {
+ isMobileDevice: false,
+ screenWidth: 1200,
+ breakpoints: BP,
+ },
+ productPicker: { selectedLayer: null, showMobileFacets: false },
+};
+
+function renderComponent(ownProps = {}, stateOverrides = {}) {
+ const state = {
+ ...baseState,
+ ...stateOverrides,
+ screenSize: {
+ ...baseState.screenSize,
+ ...(stateOverrides.screenSize || {}),
+ breakpoints: {
+ ...baseState.screenSize.breakpoints,
+ ...((stateOverrides.screenSize || {}).breakpoints || {}),
+ },
+ },
+ productPicker: {
+ ...baseState.productPicker,
+ ...(stateOverrides.productPicker || {}),
+ },
+ };
+ const store = mockConfigureStore(state);
+ store.dispatch = jest.fn();
+
+ const { results = [], facets = {} } = ownProps;
+
+ const result = render(
+ <Provider store={store}>
+ <SearchLayers results={results} facets={facets} />
+ </Provider>,
+ );
+ return { ...result, store };
+}
+
+describe('SearchLayers', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ });
+
+ // ─── Facets — always rendered ─────────────────────────────────────────────
+
+ describe('Facets visibility', () => {
+ it('always renders Facets regardless of other props', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('facets')).toBeTruthy();
+ });
+
+ it('renders Facets even when mobile and showFacets is false', () => {
+ const { getByTestId } = renderComponent(
+ {},
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 400, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: false },
+ },
+ );
+ expect(getByTestId('facets')).toBeTruthy();
+ });
+ });
+
+ // ─── showListAndDetails logic ─────────────────────────────────────────────
+
+ describe('showListAndDetails — desktop always shows list', () => {
+ it('renders the layer list on desktop (isMobile=false)', () => {
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('search-layer-list')).toBeTruthy();
+ });
+
+ it('renders .layer-list-detail-container on desktop', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.layer-list-detail-container')).toBeTruthy();
+ });
+ });
+
+ describe('showListAndDetails — mobile + showFacets hides list', () => {
+ it('hides list and details when mobile and showFacets is true (showMobileFacets)', () => {
+ // isMobile=true, showMobileFacets=true → showFacets=true → showListAndDetails=false
+ const { queryByTestId } = renderComponent(
+ {},
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 400, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: true },
+ },
+ );
+ expect(queryByTestId('search-layer-list')).toBeNull();
+ });
+
+ it('shows list when mobile but showMobileFacets is false', () => {
+ // isMobile=true, showMobileFacets=false, width(400) < medium(960) → showFacets=false
+ const { getByTestId } = renderComponent(
+ {},
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 400, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: false },
+ },
+ );
+ expect(getByTestId('search-layer-list')).toBeTruthy();
+ });
+
+ it('hides list when mobile and width > medium (desktop-width but isMobile=true)', () => {
+ // isMobile=true, width(1200) > medium(960), showMobileFacets=false
+ // showFacets = (1200>960 && !true) || false = false
+ // showListAndDetails = isMobile ? !showFacets : true = !false = true
+ const { getByTestId } = renderComponent(
+ {},
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 1200, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: false },
+ },
+ );
+ // showFacets=(1200>960 && !true)||false = false, showListAndDetails=!false=true
+ expect(getByTestId('search-layer-list')).toBeTruthy();
+ });
+ });
+
+ // ─── detail panel — !selectedLayer && smallView → null ───────────────────
+
+ describe('detail panel — no selectedLayer and smallView', () => {
+ it('does not render detail panel when no selectedLayer and smallView is true', () => {
+ // smallView = screenWidth(400) < breakpoints.small(768)
+ const { queryByTestId } = renderComponent(
+ { results: [{ id: 'layer1' }] },
+ {
+ screenSize: { isMobileDevice: false, screenWidth: 400, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: false },
+ },
+ );
+ expect(queryByTestId('layer-metadata-detail')).toBeNull();
+ });
+
+ it('does not render detail panel even with results when no selectedLayer and smallView', () => {
+ const { container } = renderComponent(
+ { results: [{ id: 'layer1' }] },
+ {
+ screenSize: { isMobileDevice: false, screenWidth: 400, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: false },
+ },
+ );
+ expect(container.querySelector('.layer-detail-container')).toBeNull();
+ });
+ });
+
+ // ─── detail panel — selectedLayer with results ────────────────────────────
+
+ describe('detail panel — selectedLayer present with results', () => {
+ it('renders LayerMetadataDetail when selectedLayer is set and results are present', () => {
+ const selectedLayer = { id: 'layer1', title: 'Layer 1' };
+ const { getByTestId } = renderComponent(
+ { results: [selectedLayer] },
+ { productPicker: { selectedLayer, showMobileFacets: false } },
+ );
+ expect(getByTestId('layer-metadata-detail')).toBeTruthy();
+ });
+
+ it('passes the selectedLayer to LayerMetadataDetail', () => {
+ const selectedLayer = { id: 'my-layer', title: 'My Layer' };
+ const { getByTestId } = renderComponent(
+ { results: [selectedLayer] },
+ { productPicker: { selectedLayer, showMobileFacets: false } },
+ );
+ expect(getByTestId('layer-metadata-detail').dataset.layerId).toBe('my-layer');
+ });
+ });
+
+ // ─── detail panel — results.length === 0 ─────────────────────────────────
+
+ describe('detail panel — no results', () => {
+ it('does not render detail panel when results are empty, even with selectedLayer', () => {
+ const selectedLayer = { id: 'layer1' };
+ const { queryByTestId } = renderComponent(
+ { results: [] },
+ { productPicker: { selectedLayer, showMobileFacets: false } },
+ );
+ expect(queryByTestId('layer-metadata-detail')).toBeNull();
+ });
+
+ it('does not render detail panel when results empty and no selectedLayer', () => {
+ const { queryByTestId } = renderComponent({ results: [] });
+ expect(queryByTestId('layer-metadata-detail')).toBeNull();
+ });
+ });
+
+ // ─── detail panel — not smallView, no selectedLayer ──────────────────────
+
+ describe('detail panel — not smallView, no selectedLayer, with results', () => {
+ it('renders detail panel when not smallView, no selectedLayer, and results present', () => {
+ // !selectedLayer && smallView → null; else !!results.length && <detail>
+ // not smallView (1200 > 768 → smallView=false), no selectedLayer
+ // condition: !null && false → false → go to else branch → !!results.length
+ const { getByTestId } = renderComponent(
+ { results: [{ id: 'layer1' }] },
+ {
+ screenSize: { isMobileDevice: false, screenWidth: 1200, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: false },
+ },
+ );
+ expect(getByTestId('layer-metadata-detail')).toBeTruthy();
+ });
+ });
+
+ // ─── showFacets calculation ───────────────────────────────────────────────
+
+ describe('showFacets = (width > mediumBreakpoint && !isMobile) || showMobileFacets', () => {
+ it('showFacets=true on desktop: width>medium and not mobile', () => {
+ // width=1200, medium=960, isMobile=false → showFacets=true
+ // desktop → showListAndDetails=true (always)
+ const { getByTestId } = renderComponent();
+ expect(getByTestId('search-layer-list')).toBeTruthy();
+ });
+
+ it('showFacets=false when width <= medium and not mobile and showMobileFacets=false', () => {
+ // width=800, medium=960, isMobile=false → showFacets=(800>960&&true)||false=false
+ // showListAndDetails = isMobile ? !showFacets : true = true
+ const { getByTestId } = renderComponent(
+ {},
+ {
+ screenSize: { isMobileDevice: false, screenWidth: 800, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: false },
+ },
+ );
+ expect(getByTestId('search-layer-list')).toBeTruthy();
+ });
+
+ it('showFacets=true via showMobileFacets even when mobile and width<medium', () => {
+ // isMobile=true, showMobileFacets=true → showFacets=true → showListAndDetails=false
+ const { queryByTestId } = renderComponent(
+ {},
+ {
+ screenSize: { isMobileDevice: true, screenWidth: 400, breakpoints: BP },
+ productPicker: { selectedLayer: null, showMobileFacets: true },
+ },
+ );
+ expect(queryByTestId('search-layer-list')).toBeNull();
+ });
+ });
+
+ // ─── overall container ────────────────────────────────────────────────────
+
+ describe('container structure', () => {
+ it('renders the search-layers-container div', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.search-layers-container')).toBeTruthy();
+ });
+
+ it('renders .layer-list-container.search inside the detail container', () => {
+ const { container } = renderComponent();
+ expect(container.querySelector('.layer-list-container.search')).toBeTruthy();
+ });
+ });
});