Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

44.0 KB
Raw Blame
/* eslint-disable react/jsx-props-no-spreading */
/* eslint-disable react/prop-types */
import { render, fireEvent, waitFor } from '@testing-library/react';
import '@testing-library/jest-dom';

// ─── Mocks ───────────────────────────────────────────────────────────────────

jest.mock('react-redux', () => {
  const actual = jest.requireActual('react-redux');
  const capture = {};
  const mockConnect = (msp, mdp) => {
    capture.msp = msp;
    capture.mdp = mdp;
    return (Component) => Component;
  };
  mockConnect.connectCapture = capture;
  return { ...actual, connect: mockConnect };
});

jest.mock('reactstrap', () => {
  const React = require('react');
  return {
    TabContent: ({ children, activeTab }) => React.createElement('div', { 'data-testid': 'tab-content', 'data-active-tab': activeTab }, children),
    TabPane: ({ children, tabId }) => React.createElement('div', { 'data-testid': `tab-pane-${tabId}` }, children),
  };
});

jest.mock('googleTagManager', () => ({ pushEvent: jest.fn() }));

jest.mock('./layers-container', () => function MockLayersContainer({ isActive, compareState, height }) {
  const React = require('react');
  return React.createElement('div', {
    'data-testid': 'layers-container',
    'data-is-active': String(isActive),
    'data-compare-state': compareState,
    'data-height': String(height),
  });
});

jest.mock('./charting', () => function MockChartingLayerMenu({ isActive, height, compareState, chartState, chartingModeAccessible }) {
  const React = require('react');
  return React.createElement('div', {
    'data-testid': 'charting-layer-menu',
    'data-is-active': String(isActive),
    'data-height': String(height),
  });
});

jest.mock('./events', () => function MockEvents({ height, isLoading, hasRequestError }) {
  const React = require('react');
  return React.createElement('div', {
    'data-testid': 'events',
    'data-height': String(height),
    'data-is-loading': String(isLoading),
  });
});

jest.mock('./smart-handoff', () => function MockSmartHandoff({ isActive }) {
  const React = require('react');
  return React.createElement('div', { 'data-testid': 'smart-handoff', 'data-is-active': String(isActive) });
});

jest.mock('./compare', () => function MockCompareCase({ isActive, height }) {
  const React = require('react');
  return React.createElement('div', {
    'data-testid': 'compare-case',
    'data-is-active': String(isActive),
    'data-height': String(height),
  });
});

jest.mock('./footer-content', () => {
  const React = require('react');
  return React.forwardRef(function MockFooterContent({
    activeTab, tabTypes, chartingModeAccessible, sidebarHeight,
  }, ref) {
    return React.createElement('div', { 'data-testid': 'footer-content', ref });
  });
});

jest.mock('./add-layers-content', () => {
  const React = require('react');
  return React.forwardRef(function MockAddLayersContent({ isActive, compareState }, ref) {
    return React.createElement('div', {
      'data-testid': 'add-layers-content',
      'data-is-active': String(isActive),
      ref,
    });
  });
});

jest.mock('../../components/sidebar/collapsed-button', () => function MockCollapsedButton({ onclick, numberOfLayers, isMobile, isEmbed }) {
  const React = require('react');
  return React.createElement('button', {
    'data-testid': 'collapsed-button',
    'data-num-layers': String(numberOfLayers),
    onClick: onclick,
  }, String(numberOfLayers));
});

jest.mock('../../components/sidebar/nav/nav-case', () => function MockNavCase({
  activeTab, toggleSidebar, isEventsTabDisabledEmbed, isCompareMode, isChartMode,
}) {
  const React = require('react');
  return React.createElement('div', {
    'data-testid': 'nav-case',
    'data-active-tab': activeTab,
    'data-events-tab-disabled': String(isEventsTabDisabledEmbed),
  }, React.createElement('button', { 'data-testid': 'toggle-sidebar', onClick: toggleSidebar }, 'toggle'));
});

jest.mock('../../modules/palettes/util', () => ({
  loadCustom: jest.fn(() => Promise.resolve([])),
}));

jest.mock('../../modules/palettes/actions', () => ({
  loadedCustomPalettes: jest.fn(() => ({ type: 'LOADED_CUSTOM_PALETTES' })),
}));

jest.mock('../../modules/date/selectors', () => ({
  getSelectedDate: jest.fn(() => new Date('2023-01-01')),
}));

jest.mock('../../modules/link/util', () => ({
  getPermalink: jest.fn(() => 'https://worldview.earthdata.nasa.gov?permalink=test'),
}));

jest.mock('../../modules/natural-events/actions', () => ({
  requestEvents: jest.fn(() => ({ type: 'REQUEST_EVENTS' })),
  requestSources: jest.fn(() => ({ type: 'REQUEST_SOURCES' })),
}));

jest.mock('../../modules/layers/selectors', () => ({
  getAllActiveLayers: jest.fn(() => []),
}));

jest.mock('../../modules/natural-events/selectors', () => ({
  getFilteredEvents: jest.fn(() => []),
}));

jest.mock('../error-boundary', () => function MockErrorBoundary({ children }) {
  return children;
});

jest.mock('../../modules/sidebar/actions', () => ({
  changeTab: jest.fn((str) => ({ type: 'CHANGE_TAB', str })),
  toggleSidebarCollapse: jest.fn(() => ({ type: 'TOGGLE_SIDEBAR_COLLAPSE' })),
  expandSidebar: jest.fn(() => ({ type: 'EXPAND_SIDEBAR' })),
}));

jest.mock('../../main', () => ({
  __esModule: true,
  default: { location: { search: '' } },
}));

jest.mock('../../util/local-storage', () => ({
  __esModule: true,
  default: {
    keys: { SIDEBAR_COLLAPSED: 'SIDEBAR_COLLAPSED' },
    setItem: jest.fn(),
    getItem: jest.fn(),
  },
}));

jest.mock('../../util/customHooks', () => ({
  __esModule: true,
  default: jest.fn(() => undefined),
}));

// ─── Imports after mocks ──────────────────────────────────────────────────────

import Sidebar from './sidebar';
import googleTagManager from 'googleTagManager';
import { loadCustom as loadCustomPalette } from '../../modules/palettes/util';
import { loadedCustomPalettes as loadedCustomPalettesAction } from '../../modules/palettes/actions';
import { getFilteredEvents } from '../../modules/natural-events/selectors';
import { getAllActiveLayers } from '../../modules/layers/selectors';
import { getSelectedDate } from '../../modules/date/selectors';
import {
  requestEvents as requestEventsActionCreator,
  requestSources as requestSourcesActionCreator,
} from '../../modules/natural-events/actions';
import {
  changeTab as changeTabAction,
  toggleSidebarCollapse as toggleSidebarCollapseAction,
  expandSidebar as expandSidebarAction,
} from '../../modules/sidebar/actions';
import safeLocalStorage from '../../util/local-storage';

// ─── Shared captured connect ──────────────────────────────────────────────────

let capturedMapStateToProps;
let capturedMapDispatchToProps;

beforeAll(() => {
  const { connect } = jest.requireMock('react-redux');
  capturedMapStateToProps = connect.connectCapture.msp;
  capturedMapDispatchToProps = connect.connectCapture.mdp;
});

beforeEach(() => {
  jest.clearAllMocks();
  window.history.pushState({}, '', '/');
});

// ─── Fixtures ─────────────────────────────────────────────────────────────────

const defaultConfig = {
  features: { naturalEvents: true, smartHandoffs: true },
  layers: {},
};

const defaultProps = {
  activeTab: 'layers',
  activeString: 'active',
  changeTab: jest.fn(),
  chartingModeAccessible: false,
  collapseExpandToggle: jest.fn(),
  config: defaultConfig,
  displayStaticMap: false,
  eventsData: [],
  eventsSources: [],
  hasEventRequestError: false,
  isCollapsed: false,
  isCompareMode: false,
  isChartMode: false,
  isDataDisabled: false,
  isDistractionFreeModeActive: false,
  isEmbedModeActive: false,
  isKioskModeActive: false,
  isLoadingEvents: false,
  isMobile: false,
  loadedCustomPalettes: jest.fn(),
  mapIsRendered: false,
  numberOfLayers: 3,
  onTabClick: jest.fn(),
  requestEvents: jest.fn(),
  requestSources: jest.fn(),
  screenHeight: 800,
  selectedDate: new Date('2023-01-01'),
  selectedMap: null,
  tabTypes: { layers: true, events: true, download: true },
};

const renderComponent = (propOverrides = {}) => render(
  <Sidebar {...defaultProps} {...propOverrides} />,
);

// ─── Sidebar structure ────────────────────────────────────────────────────────

describe('Sidebar structure', () => {
  it('renders #wv-sidebar section', () => {
    const { container } = renderComponent();
    expect(container.querySelector('#wv-sidebar')).toBeInTheDocument();
  });

  it('renders #products-holder div', () => {
    const { container } = renderComponent();
    expect(container.querySelector('#products-holder')).toBeInTheDocument();
  });

  it('renders NavCase', () => {
    const { getByTestId } = renderComponent();
    expect(getByTestId('nav-case')).toBeInTheDocument();
  });

  it('renders AddLayersContent with isActive=true when activeTab is layers', () => {
    const { getByTestId } = renderComponent({ activeTab: 'layers' });
    expect(getByTestId('add-layers-content')).toHaveAttribute('data-is-active', 'true');
  });

  it('renders AddLayersContent with isActive=false when activeTab is not layers', () => {
    const { getByTestId } = renderComponent({ activeTab: 'events' });
    expect(getByTestId('add-layers-content')).toHaveAttribute('data-is-active', 'false');
  });

  it('renders FooterContent when not kiosk mode', () => {
    const { getByTestId } = renderComponent({ isKioskModeActive: false });
    expect(getByTestId('footer-content')).toBeInTheDocument();
  });

  it('does not render FooterContent in kiosk mode', () => {
    const { queryByTestId } = renderComponent({ isKioskModeActive: true });
    expect(queryByTestId('footer-content')).not.toBeInTheDocument();
  });
});

// ─── Logo rendering ───────────────────────────────────────────────────────────

describe('Logo rendering', () => {
  it('renders logo anchor element when not in kiosk mode', () => {
    const { container } = renderComponent();
    expect(container.querySelector('#wv-logo').tagName).toBe('A');
  });

  it('renders logo span element in kiosk mode', () => {
    const { container } = renderComponent({ isKioskModeActive: true });
    expect(container.querySelector('#wv-logo').tagName).toBe('SPAN');
  });

  it('does not render logo when displayStaticMap is true', () => {
    const { container } = renderComponent({ displayStaticMap: true });
    expect(container.querySelector('#wv-logo')).not.toBeInTheDocument();
  });

  it('logo href is permalink in embed mode', () => {
    const { container } = renderComponent({ isEmbedModeActive: true });
    expect(container.querySelector('#wv-logo').getAttribute('href')).toBe('https://worldview.earthdata.nasa.gov?permalink=test');
  });

  it('logo href is / in non-embed mode', () => {
    const { container } = renderComponent({ isEmbedModeActive: false });
    expect(container.querySelector('#wv-logo').getAttribute('href')).toBe('/');
  });

  it('logo title mentions New Tab in embed mode', () => {
    const { container } = renderComponent({ isEmbedModeActive: true });
    expect(container.querySelector('#wv-logo').getAttribute('title')).toContain('New Tab');
  });

  it('logo title mentions Reset in non-embed mode', () => {
    const { container } = renderComponent({ isEmbedModeActive: false });
    expect(container.querySelector('#wv-logo').getAttribute('title')).toContain('Reset');
  });

  it('logo has distraction-free class when isDistractionFreeModeActive', () => {
    const { container } = renderComponent({ isDistractionFreeModeActive: true });
    expect(container.querySelector('#wv-logo').className).toContain('wv-logo-distraction-free-mode');
  });

  it('logo span has distraction-free class in kiosk mode when distraction free', () => {
    const { container } = renderComponent({
      isKioskModeActive: true, isDistractionFreeModeActive: true,
    });
    expect(container.querySelector('#wv-logo').className).toContain('wv-logo-distraction-free-mode');
  });

  it('renders Worldview text on desktop', () => {
    const { container } = renderComponent({ isMobile: false });
    expect(container.querySelector('#wv-logo').textContent).toBe('Worldview');
  });

  it('renders empty logo text on mobile', () => {
    const { container } = renderComponent({ isMobile: true });
    expect(container.querySelector('#wv-logo').textContent).toBe('');
  });
});

// ─── CollapsedButton ──────────────────────────────────────────────────────────

describe('CollapsedButton', () => {
  it('renders when isCollapsed is true and not distraction free', () => {
    const { getByTestId } = renderComponent({ isCollapsed: true });
    expect(getByTestId('collapsed-button')).toBeInTheDocument();
  });

  it('does not render when isCollapsed is false', () => {
    const { queryByTestId } = renderComponent({ isCollapsed: false });
    expect(queryByTestId('collapsed-button')).not.toBeInTheDocument();
  });

  it('does not render when isDistractionFreeModeActive is true', () => {
    const { queryByTestId } = renderComponent({
      isCollapsed: true, isDistractionFreeModeActive: true,
    });
    expect(queryByTestId('collapsed-button')).not.toBeInTheDocument();
  });

  it('passes numberOfLayers to CollapsedButton', () => {
    const { getByTestId } = renderComponent({ isCollapsed: true, numberOfLayers: 7 });
    expect(getByTestId('collapsed-button')).toHaveAttribute('data-num-layers', '7');
  });
});

// ─── getProductsToRender ──────────────────────────────────────────────────────

describe('getProductsToRender', () => {
  it('renders LayersContainer in normal mode', () => {
    const { getByTestId } = renderComponent({ activeTab: 'layers' });
    expect(getByTestId('layers-container')).toBeInTheDocument();
  });

  it('passes compareState to LayersContainer', () => {
    const { getByTestId } = renderComponent({ activeTab: 'layers', activeString: 'activeB' });
    expect(getByTestId('layers-container')).toHaveAttribute('data-compare-state', 'activeB');
  });

  it('renders CompareCase when isCompareMode is true', () => {
    const { getByTestId } = renderComponent({ isCompareMode: true });
    expect(getByTestId('compare-case')).toBeInTheDocument();
  });

  it('does not render LayersContainer when isCompareMode is true', () => {
    const { queryByTestId } = renderComponent({ isCompareMode: true });
    expect(queryByTestId('layers-container')).not.toBeInTheDocument();
  });

  it('renders ChartingLayerMenu when isChartMode is true', () => {
    const { getByTestId } = renderComponent({ isChartMode: true });
    expect(getByTestId('charting-layer-menu')).toBeInTheDocument();
  });

  it('does not render LayersContainer when isChartMode is true', () => {
    const { queryByTestId } = renderComponent({ isChartMode: true });
    expect(queryByTestId('layers-container')).not.toBeInTheDocument();
  });

  it('compare mode takes precedence over chart mode', () => {
    const { getByTestId, queryByTestId } = renderComponent({
      isCompareMode: true, isChartMode: true,
    });
    expect(getByTestId('compare-case')).toBeInTheDocument();
    expect(queryByTestId('charting-layer-menu')).not.toBeInTheDocument();
  });
});

// ─── Events TabPane ───────────────────────────────────────────────────────────

describe('Events TabPane', () => {
  it('renders Events when activeTab is events and naturalEvents enabled', () => {
    const { getByTestId } = renderComponent({ activeTab: 'events' });
    expect(getByTestId('events')).toBeInTheDocument();
  });

  it('does not render Events when naturalEvents feature is false', () => {
    const config = { features: { naturalEvents: false, smartHandoffs: true }, layers: {} };
    const { queryByTestId } = renderComponent({ activeTab: 'events', config });
    expect(queryByTestId('events')).not.toBeInTheDocument();
  });

  it('does not render Events when activeTab is not events', () => {
    const { queryByTestId } = renderComponent({ activeTab: 'layers' });
    expect(queryByTestId('events')).not.toBeInTheDocument();
  });

  it('passes height to Events component', () => {
    const { getByTestId } = renderComponent({ activeTab: 'events', screenHeight: 800 });
    const height = parseInt(getByTestId('events').getAttribute('data-height'), 10);
    expect(height).toBeGreaterThan(0);
  });
});

// ─── Download TabPane ─────────────────────────────────────────────────────────

describe('Download TabPane', () => {
  it('renders SmartHandoff when activeTab is download and smartHandoffs enabled', () => {
    const { getByTestId } = renderComponent({ activeTab: 'download' });
    expect(getByTestId('smart-handoff')).toBeInTheDocument();
  });

  it('does not render SmartHandoff when smartHandoffs feature is false', () => {
    const config = { features: { naturalEvents: true, smartHandoffs: false }, layers: {} };
    const { queryByTestId } = renderComponent({ activeTab: 'download', config });
    expect(queryByTestId('smart-handoff')).not.toBeInTheDocument();
  });

  it('does not render SmartHandoff when activeTab is not download', () => {
    const { queryByTestId } = renderComponent({ activeTab: 'layers' });
    expect(queryByTestId('smart-handoff')).not.toBeInTheDocument();
  });
});

// ─── Tab redirect (download → layers) ────────────────────────────────────────

describe('Tab redirect', () => {
  it('calls changeTab("layers") when isMobile and activeTab is download', () => {
    const changeTab = jest.fn();
    renderComponent({ isMobile: true, activeTab: 'download', changeTab });
    expect(changeTab).toHaveBeenCalledWith('layers');
  });

  it('calls changeTab("layers") when isEmbedModeActive and activeTab is download', () => {
    const changeTab = jest.fn();
    renderComponent({ isEmbedModeActive: true, activeTab: 'download', changeTab });
    expect(changeTab).toHaveBeenCalledWith('layers');
  });

  it('does not call changeTab when desktop non-embed with layers tab', () => {
    const changeTab = jest.fn();
    renderComponent({ activeTab: 'layers', changeTab });
    expect(changeTab).not.toHaveBeenCalled();
  });

  it('does not call changeTab when desktop non-embed with download tab', () => {
    const changeTab = jest.fn();
    renderComponent({ isMobile: false, isEmbedModeActive: false, activeTab: 'download', changeTab });
    expect(changeTab).not.toHaveBeenCalled();
  });
});

// ─── Sidebar styles ───────────────────────────────────────────────────────────

describe('Sidebar styles', () => {
  it('products-holder maxHeight is screenHeight px when not collapsed and not embed', () => {
    const { container } = renderComponent({
      isCollapsed: false, isEmbedModeActive: false, screenHeight: 800,
    });
    expect(container.querySelector('#products-holder').style.maxHeight).toBe('800px');
  });

  it('products-holder maxHeight is 0 when collapsed', () => {
    const { container } = renderComponent({ isCollapsed: true });
    expect(container.querySelector('#products-holder').style.maxHeight).toBe('0');
  });

  it('products-holder maxHeight is 95vh in embed mode when not collapsed', () => {
    const { container } = renderComponent({ isEmbedModeActive: true, isCollapsed: false });
    expect(container.querySelector('#products-holder').style.maxHeight).toBe('95vh');
  });

  it('products-holder has display:none when distraction free and not mobile', () => {
    const { container } = renderComponent({ isDistractionFreeModeActive: true, isMobile: false });
    expect(container.querySelector('#products-holder').style.display).toBe('none');
  });

  it('sets #wv-sidebar position:static in mobile non-distraction-free mode', () => {
    const { container } = renderComponent({ isMobile: true, isDistractionFreeModeActive: false });
    expect(container.querySelector('#wv-sidebar').style.position).toBe('static');
  });

  it('does not set #wv-sidebar position in desktop mode', () => {
    const { container } = renderComponent({ isMobile: false });
    expect(container.querySelector('#wv-sidebar').style.position).toBe('');
  });
});

// ─── toggleSidebar ────────────────────────────────────────────────────────────

describe('toggleSidebar', () => {
  it('calls collapseExpandToggle in mobile mode', () => {
    const collapseExpandToggle = jest.fn();
    const { getByTestId } = renderComponent({ isMobile: true, collapseExpandToggle });
    fireEvent.click(getByTestId('toggle-sidebar'));
    expect(collapseExpandToggle).toHaveBeenCalled();
  });

  it('does not fire googleTagManager event in mobile mode', () => {
    const { getByTestId } = renderComponent({ isMobile: true });
    fireEvent.click(getByTestId('toggle-sidebar'));
    expect(googleTagManager.pushEvent).not.toHaveBeenCalled();
  });

  it('calls collapseExpandToggle in desktop mode', () => {
    const collapseExpandToggle = jest.fn();
    const { getByTestId } = renderComponent({ isMobile: false, collapseExpandToggle });
    fireEvent.click(getByTestId('toggle-sidebar'));
    expect(collapseExpandToggle).toHaveBeenCalled();
  });

  it('fires sidebar_chevron gtm event in desktop mode', () => {
    const { getByTestId } = renderComponent({ isMobile: false });
    fireEvent.click(getByTestId('toggle-sidebar'));
    expect(googleTagManager.pushEvent).toHaveBeenCalledWith({ event: 'sidebar_chevron' });
  });

  it('saves collapsed to localStorage when sidebar is currently expanded (desktop)', () => {
    const { getByTestId } = renderComponent({ isMobile: false, isCollapsed: false });
    fireEvent.click(getByTestId('toggle-sidebar'));
    expect(safeLocalStorage.setItem).toHaveBeenCalledWith('SIDEBAR_COLLAPSED', 'collapsed');
  });

  it('saves expanded to localStorage when sidebar is currently collapsed (desktop)', () => {
    const { getByTestId } = renderComponent({ isMobile: false, isCollapsed: true });
    fireEvent.click(getByTestId('toggle-sidebar'));
    expect(safeLocalStorage.setItem).toHaveBeenCalledWith('SIDEBAR_COLLAPSED', 'expanded');
  });

  it('CollapsedButton onclick also calls toggleSidebar in desktop mode', () => {
    const collapseExpandToggle = jest.fn();
    const { getByTestId } = renderComponent({
      isMobile: false, isCollapsed: true, collapseExpandToggle,
    });
    fireEvent.click(getByTestId('collapsed-button'));
    expect(collapseExpandToggle).toHaveBeenCalled();
  });
});

// ─── handleWorldviewLogoClick ─────────────────────────────────────────────────

describe('handleWorldviewLogoClick', () => {
  beforeEach(() => {
    window.confirm = jest.fn();
    window.open = jest.fn();
  });

  it('does nothing when window.location.search is empty', () => {
    // default URL is '/' with empty search
    const { container } = renderComponent();
    fireEvent.click(container.querySelector('#wv-logo'));
    expect(window.confirm).not.toHaveBeenCalled();
  });

  it('calls window.open with permalink in embed mode when confirmed', () => {
    window.history.pushState({}, '', '/?state=test');
    window.confirm = jest.fn(() => true);
    const { container } = renderComponent({ isEmbedModeActive: true });
    fireEvent.click(container.querySelector('#wv-logo'));
    expect(window.open).toHaveBeenCalledWith(
      'https://worldview.earthdata.nasa.gov?permalink=test',
      '_blank',
    );
  });

  it('does not call window.open when confirm cancelled in embed mode', () => {
    window.history.pushState({}, '', '/?state=test');
    window.confirm = jest.fn(() => false);
    const { container } = renderComponent({ isEmbedModeActive: true });
    fireEvent.click(container.querySelector('#wv-logo'));
    expect(window.open).not.toHaveBeenCalled();
  });

  it('calls gtm logo_page_reset in non-embed mode when confirmed', () => {
    window.history.pushState({}, '', '/?state=test');
    window.confirm = jest.fn(() => true);
    // jsdom logs a navigation error when document.location.href is set; suppress it
    jest.spyOn(console, 'error').mockImplementation(() => {});
    const { container } = renderComponent({ isEmbedModeActive: false });
    fireEvent.click(container.querySelector('#wv-logo'));
    expect(googleTagManager.pushEvent).toHaveBeenCalledWith({ event: 'logo_page_reset' });
  });

  it('does not call gtm when confirm cancelled in non-embed mode', () => {
    window.history.pushState({}, '', '/?state=test');
    window.confirm = jest.fn(() => false);
    const { container } = renderComponent({ isEmbedModeActive: false });
    fireEvent.click(container.querySelector('#wv-logo'));
    expect(googleTagManager.pushEvent).not.toHaveBeenCalled();
  });

  it('embed confirm prompt contains @NAME@ placeholder', () => {
    window.history.pushState({}, '', '/?state=test');
    window.confirm = jest.fn(() => false);
    const { container } = renderComponent({ isEmbedModeActive: true });
    fireEvent.click(container.querySelector('#wv-logo'));
    expect(window.confirm.mock.calls[0][0]).toContain('@NAME@');
  });

  it('non-embed confirm prompt mentions reset', () => {
    window.history.pushState({}, '', '/?state=test');
    window.confirm = jest.fn(() => false);
    const { container } = renderComponent({ isEmbedModeActive: false });
    fireEvent.click(container.querySelector('#wv-logo'));
    expect(window.confirm.mock.calls[0][0]).toContain('reset');
  });
});

// ─── useEffect on mount ───────────────────────────────────────────────────────

describe('useEffect on mount', () => {
  it('calls loadCustomPalette with config', () => {
    renderComponent();
    expect(loadCustomPalette).toHaveBeenCalledWith(defaultConfig);
  });

  it('calls loadedCustomPalettes with resolved palettes', async () => {
    const palettes = [{ id: 'custom1' }];
    loadCustomPalette.mockResolvedValueOnce(palettes);
    const loadedCustomPalettes = jest.fn();
    renderComponent({ loadedCustomPalettes });
    await waitFor(() => expect(loadedCustomPalettes).toHaveBeenCalledWith(palettes));
  });

  it('calls requestSources on mount', () => {
    const requestSources = jest.fn();
    renderComponent({ requestSources });
    expect(requestSources).toHaveBeenCalled();
  });

  it('sets isEventsTabDisabledEmbed in NavCase when embed mode and layers tab', async () => {
    const { getByTestId } = renderComponent({ isEmbedModeActive: true, activeTab: 'layers' });
    await waitFor(() => {
      expect(getByTestId('nav-case')).toHaveAttribute('data-events-tab-disabled', 'true');
    });
  });

  it('does not set isEventsTabDisabledEmbed when not embed mode', () => {
    const { getByTestId } = renderComponent({ isEmbedModeActive: false, activeTab: 'layers' });
    expect(getByTestId('nav-case')).toHaveAttribute('data-events-tab-disabled', 'false');
  });

  it('does not set isEventsTabDisabledEmbed when embed mode but not layers tab', () => {
    const { getByTestId } = renderComponent({ isEmbedModeActive: true, activeTab: 'events' });
    expect(getByTestId('nav-case')).toHaveAttribute('data-events-tab-disabled', 'false');
  });
});

// ─── useEffect update – requestEvents ────────────────────────────────────────

describe('useEffect update – requestEvents', () => {
  it('calls requestEvents when activeTab is events with no existing data', () => {
    const requestEvents = jest.fn();
    renderComponent({ activeTab: 'events', eventsData: [], isLoadingEvents: false, requestEvents });
    expect(requestEvents).toHaveBeenCalled();
  });

  it('does not call requestEvents when activeTab is not events', () => {
    const requestEvents = jest.fn();
    renderComponent({ activeTab: 'layers', requestEvents });
    expect(requestEvents).not.toHaveBeenCalled();
  });

  it('does not call requestEvents when isLoadingEvents is true', () => {
    const requestEvents = jest.fn();
    renderComponent({ activeTab: 'events', isLoadingEvents: true, requestEvents });
    expect(requestEvents).not.toHaveBeenCalled();
  });

  it('does not call requestEvents when eventsData is non-empty', () => {
    const requestEvents = jest.fn();
    renderComponent({ activeTab: 'events', eventsData: [{ id: '1' }], requestEvents });
    expect(requestEvents).not.toHaveBeenCalled();
  });

  it('calls requestEvents when mapIsRendered is true and activeTab is events', () => {
    const requestEvents = jest.fn();
    renderComponent({ activeTab: 'events', mapIsRendered: true, requestEvents });
    expect(requestEvents).toHaveBeenCalled();
  });
});

// ─── updateDimensions ─────────────────────────────────────────────────────────

describe('updateDimensions', () => {
  it('calculates height for non-mobile desktop (fallback footer/addLayers heights)', async () => {
    // footerHeight=20, addLayersHeight=30, tabHeight=32, groupCheckboxHeight=35
    // iconHeight=53, topOffset=10, basePadding=130
    // newHeight = 800 - (53+10+32+35+130+20+30) - 10 = 480
    const { getByTestId } = renderComponent({ screenHeight: 800, isMobile: false });
    await waitFor(() => {
      expect(getByTestId('layers-container')).toHaveAttribute('data-height', '480');
    });
  });

  it('calculates height for mobile without compare mode', async () => {
    // tabHeight = compareModeHeight = 40 (no compare), groupCheckboxHeight=35
    // newHeight = 800 - (40 + 35 + 20 + 30) = 675
    const { getByTestId } = renderComponent({
      screenHeight: 800, isMobile: true, isCompareMode: false,
    });
    await waitFor(() => {
      expect(getByTestId('layers-container')).toHaveAttribute('data-height', '675');
    });
  });

  it('subtracts 130 from height when isChartMode is true and height > 300', async () => {
    // non-mobile: 480 base height; isChartMode=true → 480-130=350
    const { getByTestId } = renderComponent({
      screenHeight: 800, isMobile: false, isChartMode: true,
    });
    await waitFor(() => {
      expect(getByTestId('charting-layer-menu')).toHaveAttribute('data-height', '350');
    });
  });

  it('uses larger compareModeHeight for mobile in compare mode', async () => {
    // mobile + compare: tabHeight = 80
    // newHeight = 800 - (80 + 35 + 20 + 30) = 635
    const { getByTestId } = renderComponent({
      screenHeight: 800, isMobile: true, isCompareMode: true,
    });
    await waitFor(() => {
      expect(getByTestId('compare-case')).toHaveAttribute('data-height', '635');
    });
  });
});

// ─── mapStateToProps ──────────────────────────────────────────────────────────

describe('mapStateToProps', () => {
  const makeState = (overrides = {}) => ({
    animation: { gifActive: false },
    compare: { active: false, activeString: 'active' },
    charting: { active: false },
    config: {
      features: { naturalEvents: true, smartHandoffs: true },
      layers: {},
    },
    embed: { isEmbedModeActive: false },
    events: { isAnimatingToEvent: false },
    layers: { active: { layers: [] } },
    measure: { isActive: false },
    modal: { isOpen: false, id: null },
    map: { ui: { selected: null } },
    palettes: { rendered: {}, custom: {} },
    requestedEvents: { isLoading: false, error: null },
    requestedEventSources: { isLoading: false, error: null, response: [] },
    screenSize: { screenHeight: 800, isMobileDevice: false },
    sidebar: { activeTab: 'layers', isCollapsed: false, mobileCollapsed: false },
    ui: { isDistractionFreeModeActive: false, isKioskModeActive: false, displayStaticMap: false },
    ...overrides,
  });

  it('maps activeTab from sidebar.activeTab', () => {
    const state = makeState({ sidebar: { activeTab: 'events', isCollapsed: false, mobileCollapsed: false } });
    expect(capturedMapStateToProps(state).activeTab).toBe('events');
  });

  it('maps activeString from compare.activeString', () => {
    const state = makeState({ compare: { active: false, activeString: 'activeB' } });
    expect(capturedMapStateToProps(state).activeString).toBe('activeB');
  });

  it('maps isCompareMode from compare.active', () => {
    const state = makeState({ compare: { active: true, activeString: 'active' } });
    expect(capturedMapStateToProps(state).isCompareMode).toBe(true);
  });

  it('maps isChartMode from charting.active', () => {
    const state = makeState({ charting: { active: true } });
    expect(capturedMapStateToProps(state).isChartMode).toBe(true);
  });

  it('maps isEmbedModeActive from embed.isEmbedModeActive', () => {
    const state = makeState({ embed: { isEmbedModeActive: true } });
    expect(capturedMapStateToProps(state).isEmbedModeActive).toBe(true);
  });

  it('maps isMobile from screenSize.isMobileDevice', () => {
    const state = makeState({ screenSize: { screenHeight: 800, isMobileDevice: true } });
    expect(capturedMapStateToProps(state).isMobile).toBe(true);
  });

  it('maps isKioskModeActive from ui', () => {
    const state = makeState({
      ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, displayStaticMap: false },
    });
    expect(capturedMapStateToProps(state).isKioskModeActive).toBe(true);
  });

  it('maps isDistractionFreeModeActive from ui', () => {
    const state = makeState({
      ui: { isDistractionFreeModeActive: true, isKioskModeActive: false, displayStaticMap: false },
    });
    expect(capturedMapStateToProps(state).isDistractionFreeModeActive).toBe(true);
  });

  it('maps displayStaticMap from ui.displayStaticMap', () => {
    const state = makeState({
      ui: { isDistractionFreeModeActive: false, isKioskModeActive: false, displayStaticMap: true },
    });
    expect(capturedMapStateToProps(state).displayStaticMap).toBe(true);
  });

  it('maps screenHeight from screenSize.screenHeight', () => {
    const state = makeState({ screenSize: { screenHeight: 1200, isMobileDevice: false } });
    expect(capturedMapStateToProps(state).screenHeight).toBe(1200);
  });

  it('maps isLoadingEvents true when requestedEvents.isLoading is true', () => {
    const state = makeState({ requestedEvents: { isLoading: true, error: null } });
    expect(capturedMapStateToProps(state).isLoadingEvents).toBe(true);
  });

  it('maps isLoadingEvents true when requestedEventSources.isLoading is true', () => {
    const state = makeState({
      requestedEventSources: { isLoading: true, error: null, response: [] },
    });
    expect(capturedMapStateToProps(state).isLoadingEvents).toBe(true);
  });

  it('maps hasEventRequestError true when requestedEvents has error', () => {
    const state = makeState({ requestedEvents: { isLoading: false, error: 'network error' } });
    expect(capturedMapStateToProps(state).hasEventRequestError).toBe(true);
  });

  it('maps hasEventRequestError true when requestedEventSources has error', () => {
    const state = makeState({ requestedEventSources: { isLoading: false, error: 'fail', response: [] } });
    expect(capturedMapStateToProps(state).hasEventRequestError).toBe(true);
  });

  it('maps isDataDisabled from events.isAnimatingToEvent', () => {
    const state = makeState({ events: { isAnimatingToEvent: true } });
    expect(capturedMapStateToProps(state).isDataDisabled).toBe(true);
  });

  it('isCollapsed uses mobileCollapsed for mobile', () => {
    const state = makeState({
      screenSize: { screenHeight: 800, isMobileDevice: true },
      sidebar: { activeTab: 'layers', isCollapsed: false, mobileCollapsed: true },
    });
    expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
  });

  it('isCollapsed uses sidebar.isCollapsed for desktop', () => {
    const state = makeState({ sidebar: { activeTab: 'layers', isCollapsed: true, mobileCollapsed: false } });
    expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
  });

  it('isCollapsed true via snapshotModalOpen', () => {
    const state = makeState({ modal: { isOpen: true, id: 'TOOLBAR_SNAPSHOT' } });
    expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
  });

  it('isCollapsed false when modal is open but not snapshot id', () => {
    const state = makeState({ modal: { isOpen: true, id: 'OTHER_MODAL' } });
    expect(capturedMapStateToProps(state).isCollapsed).toBe(false);
  });

  it('isCollapsed true via measure.isActive', () => {
    const state = makeState({ measure: { isActive: true } });
    expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
  });

  it('isCollapsed true via animation.gifActive', () => {
    const state = makeState({ animation: { gifActive: true } });
    expect(capturedMapStateToProps(state).isCollapsed).toBe(true);
  });

  it('numberOfLayers counts all active layers when not embed mode', () => {
    getAllActiveLayers.mockReturnValueOnce([{ id: 'l1', visible: true }, { id: 'l2', visible: false }]);
    const state = makeState();
    expect(capturedMapStateToProps(state).numberOfLayers).toBe(2);
  });

  it('numberOfLayers counts only visible non-Reference layers in embed mode', () => {
    getAllActiveLayers.mockReturnValueOnce([
      { id: 'l1', visible: true, layergroup: 'Overlays' },
      { id: 'l2', visible: false, layergroup: 'Overlays' },
      { id: 'l3', visible: true, layergroup: 'Reference' },
    ]);
    const state = makeState({ embed: { isEmbedModeActive: true } });
    expect(capturedMapStateToProps(state).numberOfLayers).toBe(1);
  });

  it('mapIsRendered is true when selectedMap.isRendered() returns true', () => {
    const mockMap = { isRendered: jest.fn(() => true) };
    const state = makeState({ map: { ui: { selected: mockMap } } });
    expect(capturedMapStateToProps(state).mapIsRendered).toBe(true);
  });

  it('mapIsRendered is falsy when selectedMap is null', () => {
    const state = makeState({ map: { ui: { selected: null } } });
    expect(capturedMapStateToProps(state).mapIsRendered).toBeFalsy();
  });

  it('selectedMap comes from map.ui.selected', () => {
    const mockMap = { isRendered: jest.fn(() => false) };
    const state = makeState({ map: { ui: { selected: mockMap } } });
    expect(capturedMapStateToProps(state).selectedMap).toBe(mockMap);
  });

  it('chartingModeAccessible true for qualifying layer', () => {
    const state = makeState({
      palettes: { rendered: { pal1: { maps: [{ type: 'continuous' }] } }, custom: {} },
      layers: {
        active: {
          layers: [{
            id: 'layer1', palette: { id: 'pal1' }, layerPeriod: 'Daily', disableCharting: false,
          }],
        },
      },
    });
    expect(capturedMapStateToProps(state).chartingModeAccessible).toBe(true);
  });

  it('chartingModeAccessible false when no qualifying layers', () => {
    expect(capturedMapStateToProps(makeState()).chartingModeAccessible).toBe(false);
  });

  it('chartingModeAccessible false when layer has disableCharting=true', () => {
    const state = makeState({
      palettes: { rendered: { pal1: { maps: [{ type: 'continuous' }] } }, custom: {} },
      layers: {
        active: {
          layers: [{
            id: 'layer1', palette: { id: 'pal1' }, layerPeriod: 'Daily', disableCharting: true,
          }],
        },
      },
    });
    expect(capturedMapStateToProps(state).chartingModeAccessible).toBe(false);
  });

  it('chartingModeAccessible false when palette type is not continuous', () => {
    const state = makeState({
      palettes: { rendered: { pal1: { maps: [{ type: 'classification' }] } }, custom: {} },
      layers: {
        active: {
          layers: [{
            id: 'layer1', palette: { id: 'pal1' }, layerPeriod: 'Daily', disableCharting: false,
          }],
        },
      },
    });
    expect(capturedMapStateToProps(state).chartingModeAccessible).toBe(false);
  });

  it('tabTypes.layers is always true', () => {
    expect(capturedMapStateToProps(makeState()).tabTypes.layers).toBe(true);
  });

  it('tabTypes.events reflects features.naturalEvents', () => {
    const state = makeState({
      config: { features: { naturalEvents: false, smartHandoffs: true }, layers: {} },
    });
    expect(capturedMapStateToProps(state).tabTypes.events).toBe(false);
  });

  it('tabTypes.download reflects features.smartHandoffs', () => {
    const state = makeState({
      config: { features: { naturalEvents: true, smartHandoffs: false }, layers: {} },
    });
    expect(capturedMapStateToProps(state).tabTypes.download).toBe(false);
  });

  it('eventsSources maps from requestedEventSources.response', () => {
    const sources = [{ id: 'VIIRS' }];
    const state = makeState({
      requestedEventSources: { isLoading: false, error: null, response: sources },
    });
    expect(capturedMapStateToProps(state).eventsSources).toBe(sources);
  });

  it('calls getSelectedDate with state', () => {
    const state = makeState();
    capturedMapStateToProps(state);
    expect(getSelectedDate).toHaveBeenCalledWith(state);
  });

  it('calls getFilteredEvents with state', () => {
    const state = makeState();
    capturedMapStateToProps(state);
    expect(getFilteredEvents).toHaveBeenCalledWith(state);
  });
});

// ─── mapDispatchToProps ───────────────────────────────────────────────────────

describe('mapDispatchToProps', () => {
  let dispatch;
  let mapped;

  beforeEach(() => {
    dispatch = jest.fn();
    mapped = capturedMapDispatchToProps(dispatch);
  });

  it('changeTab dispatches changeTabAction', () => {
    mapped.changeTab('events');
    expect(changeTabAction).toHaveBeenCalledWith('events');
    expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_TAB', str: 'events' });
  });

  it('onTabClick does nothing when str equals activeStr', () => {
    mapped.onTabClick('events', 'events');
    expect(dispatch).not.toHaveBeenCalled();
    expect(googleTagManager.pushEvent).not.toHaveBeenCalled();
  });

  it('onTabClick dispatches changeTabAction and fires gtm when tab changes', () => {
    mapped.onTabClick('events', 'layers');
    expect(googleTagManager.pushEvent).toHaveBeenCalledWith({ event: 'events_tab' });
    expect(changeTabAction).toHaveBeenCalledWith('events');
  });

  it('collapseExpandToggle dispatches toggleSidebarCollapseAction', () => {
    mapped.collapseExpandToggle();
    expect(toggleSidebarCollapseAction).toHaveBeenCalled();
    expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_SIDEBAR_COLLAPSE' });
  });

  it('expandSidebar dispatches expandSidebarAction', () => {
    mapped.expandSidebar();
    expect(expandSidebarAction).toHaveBeenCalled();
    expect(dispatch).toHaveBeenCalledWith({ type: 'EXPAND_SIDEBAR' });
  });

  it('loadedCustomPalettes dispatches loadedCustomPalettesAction', () => {
    const customs = [{ id: 'custom1' }];
    mapped.loadedCustomPalettes(customs);
    expect(loadedCustomPalettesAction).toHaveBeenCalledWith(customs);
    expect(dispatch).toHaveBeenCalledWith({ type: 'LOADED_CUSTOM_PALETTES' });
  });

  it('requestEvents dispatches requestEventsActionCreator', () => {
    mapped.requestEvents();
    expect(requestEventsActionCreator).toHaveBeenCalled();
    expect(dispatch).toHaveBeenCalledWith({ type: 'REQUEST_EVENTS' });
  });

  it('requestSources dispatches requestSourcesActionCreator', () => {
    mapped.requestSources();
    expect(requestSourcesActionCreator).toHaveBeenCalled();
    expect(dispatch).toHaveBeenCalledWith({ type: 'REQUEST_SOURCES' });
  });
});