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