Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

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

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('../../util/util', () => ({
  clearTimeUTC: jest.fn((date) => {
    const d = new Date(date);
    d.setUTCHours(0, 0, 0, 0);
    return d;
  }),
}));

jest.mock('../error-boundary', () => ({ children }) => <div data-testid="error-boundary">{children}</div>);

jest.mock('../../components/animation-widget/play-queue', () => () => (
  <div data-testid="play-queue" />
));

jest.mock('../../modules/map/util', () => ({
  promiseImageryForTime: jest.fn(() => Promise.resolve()),
}));

jest.mock('../../modules/date/actions', () => ({
  selectDate: jest.fn(() => ({ type: 'SELECT_DATE' })),
  selectInterval: jest.fn(() => ({ type: 'SELECT_INTERVAL' })),
  toggleCustomModal: jest.fn(() => ({ type: 'TOGGLE_CUSTOM_MODAL' })),
}));

jest.mock('../../modules/date/constants', () => ({
  TIME_SCALE_FROM_NUMBER: {
    1: 'year',
    2: 'month',
    3: 'day',
    4: 'hour',
    5: 'minute',
  },
  customModalType: { ANIMATION: 'ANIMATION' },
}));

jest.mock('../../modules/animation/util', () => ({
  snapToIntervalDelta: jest.fn((date) => date),
  getNumberOfSteps: jest.fn(() => 10),
}));

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

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

jest.mock('../../modules/animation/actions', () => ({
  play: jest.fn(() => ({ type: 'PLAY' })),
  onClose: jest.fn(() => ({ type: 'CLOSE' })),
  stop: jest.fn(() => ({ type: 'STOP' })),
  toggleLooping: jest.fn(() => ({ type: 'TOGGLE_LOOPING' })),
  changeFrameRate: jest.fn(() => ({ type: 'CHANGE_FRAME_RATE' })),
  changeStartDate: jest.fn(() => ({ type: 'CHANGE_START_DATE' })),
  changeEndDate: jest.fn(() => ({ type: 'CHANGE_END_DATE' })),
  changeStartAndEndDate: jest.fn(() => ({ type: 'CHANGE_START_AND_END_DATE' })),
  toggleAnimationCollapse: jest.fn(() => ({ type: 'TOGGLE_ANIMATION_COLLAPSE' })),
}));

jest.mock('../../util/customHooks', () => jest.fn(() => undefined));

const desktopCapture = {};
const mobileCapture = {};
const collapsedCapture = {};

jest.mock('./desktop-animation-widget', () => function MockDesktopWidget(props) {
  Object.assign(desktopCapture, props);
  return <div data-testid="desktop-animation-widget" />;
});

jest.mock('./mobile-animation-widget', () => function MockMobileWidget(props) {
  Object.assign(mobileCapture, props);
  return <div data-testid="mobile-animation-widget" />;
});

jest.mock('./collapsed-animation-widget', () => function MockCollapsedWidget(props) {
  Object.assign(collapsedCapture, props);
  return <div data-testid="collapsed-animation-widget" />;
});

jest.mock('../../components/kiosk/animation-tile-check/animation-tile-check', () => () => (
  <div data-testid="animation-tile-check" />
));

import usePrevious from '../../util/customHooks';
import util from '../../util/util';
import AnimationWidget from './animation-widget';

let capturedMapStateToProps;
let capturedMapDispatchToProps;

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

const appNow = new Date('2021-06-01T00:00:00Z');
const startDate = new Date('2021-01-01T00:00:00Z');
const endDate = new Date('2021-03-01T00:00:00Z');

const defaultProps = {
  appNow,
  animationCustomModalOpen: false,
  autoplay: false,
  breakpoints: {},
  checkAnimationAvailability: false,
  currentDate: new Date('2021-01-15'),
  delta: 1,
  endDate,
  hasFutureLayers: false,
  hasSubdailyLayers: false,
  interval: 'day',
  isActive: true,
  isCollapsed: false,
  isDistractionFreeModeActive: false,
  isEmbedModeActive: false,
  isKioskModeActive: false,
  isLandscape: false,
  isMobile: false,
  isMobilePhone: false,
  isMobileTablet: false,
  isPlaying: false,
  isPortrait: true,
  looping: false,
  map: null,
  maxDate: new Date('2021-06-01'),
  minDate: new Date('2020-01-01'),
  numberOfFrames: 10,
  onClose: jest.fn(),
  onPushLoop: jest.fn(),
  onPushPause: jest.fn(),
  onPushPlay: jest.fn(),
  onSlide: jest.fn(),
  onToggleAnimationCollapse: jest.fn(),
  onUpdateEndDate: jest.fn(),
  onUpdateStartDate: jest.fn(),
  onUpdateStartAndEndDate: jest.fn(),
  playDisabled: false,
  promiseImageryForTime: jest.fn(),
  screenHeight: 768,
  screenWidth: 1024,
  selectDate: jest.fn(),
  sliderLabel: 'Frames Per Second',
  speedRedux: 3,
  snappedCurrentDate: new Date('2021-01-15'),
  startDate,
  subDailyMode: false,
  autoSelected: false,
  layers: [],
};

const renderWidget = (propOverrides = {}) => render(
  <AnimationWidget {...defaultProps} {...propOverrides} />,
);

beforeEach(() => {
  jest.clearAllMocks();
  usePrevious.mockReturnValue(undefined);
  Object.keys(desktopCapture).forEach((k) => delete desktopCapture[k]);
  Object.keys(mobileCapture).forEach((k) => delete mobileCapture[k]);
  Object.keys(collapsedCapture).forEach((k) => delete collapsedCapture[k]);
});

describe('AnimationWidget rendering', () => {
  it('returns null when isActive is false', () => {
    const { container } = renderWidget({ isActive: false });
    expect(container.firstChild).toBeNull();
  });

  it('renders the error boundary when active', () => {
    const { getByTestId } = renderWidget();
    expect(getByTestId('error-boundary')).toBeInTheDocument();
  });

  it('renders DesktopAnimationWidget when not mobile and not collapsed', () => {
    const { getByTestId } = renderWidget({ isMobile: false, isCollapsed: false });
    expect(getByTestId('desktop-animation-widget')).toBeInTheDocument();
  });

  it('renders MobileAnimationWidget when isMobile is true and not collapsed', () => {
    const { getByTestId } = renderWidget({ isMobile: true, isCollapsed: false });
    expect(getByTestId('mobile-animation-widget')).toBeInTheDocument();
  });

  it('does not render DesktopAnimationWidget when isMobile is true', () => {
    const { queryByTestId } = renderWidget({ isMobile: true, isCollapsed: false });
    expect(queryByTestId('desktop-animation-widget')).not.toBeInTheDocument();
  });

  it('renders CollapsedAnimationWidget when isCollapsed is true', () => {
    const { getByTestId } = renderWidget({ isCollapsed: true });
    expect(getByTestId('collapsed-animation-widget')).toBeInTheDocument();
  });

  it('does not render DesktopAnimationWidget when isCollapsed', () => {
    const { queryByTestId } = renderWidget({ isCollapsed: true });
    expect(queryByTestId('desktop-animation-widget')).not.toBeInTheDocument();
  });

  it('renders PlayQueue when isPlaying and checkAnimationAvailability is false', () => {
    const { getByTestId } = renderWidget({ isPlaying: true, checkAnimationAvailability: false });
    expect(getByTestId('play-queue')).toBeInTheDocument();
  });

  it('does not render PlayQueue when not isPlaying', () => {
    const { queryByTestId } = renderWidget({ isPlaying: false });
    expect(queryByTestId('play-queue')).not.toBeInTheDocument();
  });

  it('renders AnimationTileCheck when checkAnimationAvailability is true', () => {
    const { getByTestId } = renderWidget({ checkAnimationAvailability: true });
    expect(getByTestId('animation-tile-check')).toBeInTheDocument();
  });

  it('does not render PlayQueue when checkAnimationAvailability is true (even if playing)', () => {
    const { queryByTestId } = renderWidget({
      isPlaying: true,
      checkAnimationAvailability: true,
    });
    expect(queryByTestId('play-queue')).not.toBeInTheDocument();
  });
});

describe('AnimationWidget mount effect', () => {
  it('calls onPushPlay when autoplay is true and not playing', () => {
    const onPushPlay = jest.fn();
    renderWidget({ autoplay: true, isPlaying: false, onPushPlay });
    expect(onPushPlay).toHaveBeenCalledTimes(1);
  });

  it('does not call onPushPlay when autoplay is true but already playing', () => {
    const onPushPlay = jest.fn();
    renderWidget({ autoplay: true, isPlaying: true, onPushPlay });
    expect(onPushPlay).not.toHaveBeenCalled();
  });

  it('does not call onPushPlay when autoplay is false', () => {
    const onPushPlay = jest.fn();
    renderWidget({ autoplay: false, isPlaying: false, onPushPlay });
    expect(onPushPlay).not.toHaveBeenCalled();
  });

  it('calls onToggleAnimationCollapse when isEmbedModeActive is true', () => {
    const onToggleAnimationCollapse = jest.fn();
    renderWidget({ isEmbedModeActive: true, onToggleAnimationCollapse });
    expect(onToggleAnimationCollapse).toHaveBeenCalledTimes(1);
  });

  it('does not call onToggleAnimationCollapse when isEmbedModeActive is false', () => {
    const onToggleAnimationCollapse = jest.fn();
    renderWidget({ isEmbedModeActive: false, onToggleAnimationCollapse });
    expect(onToggleAnimationCollapse).not.toHaveBeenCalled();
  });
});

describe('AnimationWidget update effect', () => {
  it('calls onUpdateEndDate with appNow when hasFutureLayers changes from true to false', () => {
    const onUpdateEndDate = jest.fn();
    // First call to usePrevious (prevSubDailyMode) returns undefined
    // Second call to usePrevious (prevHasFutureLayers) returns true
    usePrevious
      .mockReturnValueOnce(undefined)
      .mockReturnValueOnce(true);
    renderWidget({ hasFutureLayers: false, onUpdateEndDate });
    expect(onUpdateEndDate).toHaveBeenCalledWith(appNow);
  });

  it('does not call onUpdateEndDate when hasFutureLayers stays false', () => {
    const onUpdateEndDate = jest.fn();
    usePrevious
      .mockReturnValueOnce(undefined)
      .mockReturnValueOnce(false);
    renderWidget({ hasFutureLayers: false, onUpdateEndDate });
    expect(onUpdateEndDate).not.toHaveBeenCalled();
  });

  it('does not call onUpdateEndDate when hasFutureLayers stays true', () => {
    const onUpdateEndDate = jest.fn();
    usePrevious
      .mockReturnValueOnce(undefined)
      .mockReturnValueOnce(true);
    renderWidget({ hasFutureLayers: true, onUpdateEndDate });
    expect(onUpdateEndDate).not.toHaveBeenCalled();
  });

  it('does not update widget position on subDailyMode change when widget was manually moved', () => {
    usePrevious
      .mockReturnValueOnce(false)
      .mockReturnValueOnce(false);
    renderWidget({ subDailyMode: true });
    act(() => {
      desktopCapture.onExpandedDrag({}, { x: 50, y: 50 });
    });
    expect(desktopCapture.widgetPosition).toEqual({ x: 50, y: 50 });
  });
});

describe('handleDragStart', () => {
  const makeEvent = (className) => ({
    target: {
      classList: {
        contains: (c) => c === className,
      },
    },
  });

  beforeEach(() => {
    renderWidget();
  });

  it('returns true when target has class wv-animation-widget', () => {
    expect(desktopCapture.handleDragStart(makeEvent('wv-animation-widget'), {})).toBe(true);
  });

  it('returns true when target has class wv-animation-widget-header', () => {
    expect(desktopCapture.handleDragStart(makeEvent('wv-animation-widget-header'), {})).toBe(true);
  });

  it('returns true when target has class wv-anim-dates-case', () => {
    expect(desktopCapture.handleDragStart(makeEvent('wv-anim-dates-case'), {})).toBe(true);
  });

  it('returns true when target has class thru-label', () => {
    expect(desktopCapture.handleDragStart(makeEvent('thru-label'), {})).toBe(true);
  });

  it('returns false when target has an unrecognized class', () => {
    expect(desktopCapture.handleDragStart(makeEvent('some-other-class'), {})).toBe(false);
  });

  it('handleDragStart is also passed to CollapsedAnimationWidget', () => {
    renderWidget({ isCollapsed: true });
    expect(typeof collapsedCapture.handleDragStart).toBe('function');
    expect(collapsedCapture.handleDragStart(makeEvent('wv-animation-widget'), {})).toBe(true);
  });
});

describe('drag handlers', () => {
  it('onExpandedDrag updates widgetPosition and marks widget as moved', () => {
    renderWidget();
    act(() => {
      desktopCapture.onExpandedDrag({}, { x: 200, y: 100 });
    });
    expect(desktopCapture.widgetPosition).toEqual({ x: 200, y: 100 });
  });

  it('onCollapsedDrag updates collapsedWidgetPosition', () => {
    renderWidget({ isCollapsed: true });
    act(() => {
      collapsedCapture.onCollapsedDrag({}, { x: 50, y: 75 });
    });
    expect(collapsedCapture.collapsedWidgetPosition).toEqual({ x: 50, y: 75 });
  });
});

describe('onLoop', () => {
  it('calls onPushLoop when onLoop is triggered', () => {
    const onPushLoop = jest.fn();
    renderWidget({ onPushLoop, looping: false });
    act(() => {
      desktopCapture.onLoop();
    });
    expect(onPushLoop).toHaveBeenCalledWith(false);
  });

  it('passes current looping value to onPushLoop', () => {
    const onPushLoop = jest.fn();
    renderWidget({ onPushLoop, looping: true });
    act(() => {
      desktopCapture.onLoop();
    });
    expect(onPushLoop).toHaveBeenCalledWith(true);
  });
});

describe('onDateChange', () => {
  it('calls onUpdateStartDate when start date changes', () => {
    const onUpdateStartDate = jest.fn();
    const onUpdateEndDate = jest.fn();
    renderWidget({ onUpdateStartDate, onUpdateEndDate });
    const newStart = new Date('2021-02-01');
    act(() => {
      desktopCapture.onDateChange([newStart, endDate]);
    });
    expect(onUpdateStartDate).toHaveBeenCalledWith(newStart);
    expect(onUpdateEndDate).not.toHaveBeenCalled();
  });

  it('calls onUpdateEndDate when end date changes', () => {
    const onUpdateStartDate = jest.fn();
    const onUpdateEndDate = jest.fn();
    renderWidget({ onUpdateStartDate, onUpdateEndDate });
    const newEnd = new Date('2021-04-01');
    act(() => {
      desktopCapture.onDateChange([startDate, newEnd]);
    });
    expect(onUpdateEndDate).toHaveBeenCalledWith(newEnd);
    expect(onUpdateStartDate).not.toHaveBeenCalled();
  });

  it('calls both update functions when both dates change', () => {
    const onUpdateStartDate = jest.fn();
    const onUpdateEndDate = jest.fn();
    renderWidget({ onUpdateStartDate, onUpdateEndDate });
    const newStart = new Date('2021-02-01');
    const newEnd = new Date('2021-04-01');
    act(() => {
      desktopCapture.onDateChange([newStart, newEnd]);
    });
    expect(onUpdateStartDate).toHaveBeenCalledWith(newStart);
    expect(onUpdateEndDate).toHaveBeenCalledWith(newEnd);
  });

  it('calls neither update function when dates are unchanged', () => {
    const onUpdateStartDate = jest.fn();
    const onUpdateEndDate = jest.fn();
    renderWidget({ onUpdateStartDate, onUpdateEndDate });
    act(() => {
      desktopCapture.onDateChange([startDate, endDate]);
    });
    expect(onUpdateStartDate).not.toHaveBeenCalled();
    expect(onUpdateEndDate).not.toHaveBeenCalled();
  });
});

describe('zeroDates', () => {
  it('calls clearTimeUTC for non-subdaily mode', () => {
    renderWidget({ subDailyMode: false });
    desktopCapture.zeroDates();
    expect(util.clearTimeUTC).toHaveBeenCalledWith(startDate);
    expect(util.clearTimeUTC).toHaveBeenCalledWith(endDate);
  });

  it('returns objects with startDate and endDate for non-subdaily mode', () => {
    renderWidget({ subDailyMode: false });
    const result = desktopCapture.zeroDates();
    expect(result).toHaveProperty('startDate');
    expect(result).toHaveProperty('endDate');
    expect(result.startDate.getUTCHours()).toBe(0);
    expect(result.startDate.getUTCSeconds()).toBe(0);
    expect(result.startDate.getUTCMilliseconds()).toBe(0);
  });

  it('zeroes seconds and milliseconds in subdaily mode', () => {
    const subdailyStart = new Date('2021-01-01T10:35:45.500Z');
    const subdailyEnd = new Date('2021-03-01T14:55:30.200Z');
    renderWidget({
      subDailyMode: true,
      startDate: subdailyStart,
      endDate: subdailyEnd,
      autoSelected: false,
    });
    const result = desktopCapture.zeroDates();
    expect(result.startDate.getUTCSeconds()).toBe(0);
    expect(result.startDate.getUTCMilliseconds()).toBe(0);
    expect(result.endDate.getUTCSeconds()).toBe(0);
    expect(result.endDate.getUTCMilliseconds()).toBe(0);
  });

  it('floors minutes to nearest 10 in subdaily mode when not autoSelected', () => {
    const subdailyStart = new Date('2021-01-01T10:35:00.000Z');
    const subdailyEnd = new Date('2021-03-01T14:55:00.000Z');
    renderWidget({
      subDailyMode: true,
      startDate: subdailyStart,
      endDate: subdailyEnd,
      autoSelected: false,
    });
    const result = desktopCapture.zeroDates();
    expect(result.startDate.getUTCMinutes()).toBe(30);
    expect(result.endDate.getUTCMinutes()).toBe(50);
  });

  it('does not floor minutes in subdaily mode when autoSelected', () => {
    const subdailyStart = new Date('2021-01-01T10:35:00.000Z');
    renderWidget({
      subDailyMode: true,
      startDate: subdailyStart,
      endDate: new Date('2021-03-01T14:55:00.000Z'),
      autoSelected: true,
    });
    const result = desktopCapture.zeroDates();
    expect(result.startDate.getUTCMinutes()).toBe(35);
  });

  it('does not call clearTimeUTC in subdaily mode', () => {
    renderWidget({ subDailyMode: true });
    desktopCapture.zeroDates();
    expect(util.clearTimeUTC).not.toHaveBeenCalled();
  });
});

describe('onPushPlayFunc', () => {
  it('calls onUpdateStartAndEndDate with zeroed dates then calls onPushPlay', () => {
    const onUpdateStartAndEndDate = jest.fn();
    const onPushPlay = jest.fn();
    renderWidget({ onUpdateStartAndEndDate, onPushPlay, subDailyMode: false });
    act(() => {
      desktopCapture.onPushPlay();
    });
    expect(onUpdateStartAndEndDate).toHaveBeenCalledTimes(1);
    expect(onPushPlay).toHaveBeenCalledTimes(1);
    const [calledStart, calledEnd] = onUpdateStartAndEndDate.mock.calls[0];
    expect(calledStart.getUTCHours()).toBe(0);
    expect(calledEnd.getUTCHours()).toBe(0);
  });

  it('onPushPlay in CollapsedAnimationWidget also calls onUpdateStartAndEndDate', () => {
    const onUpdateStartAndEndDate = jest.fn();
    const onPushPlay = jest.fn();
    renderWidget({ isCollapsed: true, onUpdateStartAndEndDate, onPushPlay });
    act(() => {
      collapsedCapture.onPushPlay();
    });
    expect(onUpdateStartAndEndDate).toHaveBeenCalledTimes(1);
    expect(onPushPlay).toHaveBeenCalledTimes(1);
  });
});

describe('widget initial position', () => {
  it('sets initial widget x position centered based on screenWidth', () => {
    renderWidget({ screenWidth: 1000, subDailyMode: false });
    // widgetWidth = 334, halfWidgetWidth = 167, x = 500 - 167 = 333
    expect(desktopCapture.widgetPosition.x).toBe(500 - 167);
  });

  it('uses subdailyWidgetWidth when subDailyMode is true', () => {
    renderWidget({ screenWidth: 1000, subDailyMode: true });
    // subdailyWidgetWidth = 460, halfWidgetWidth = 230, x = 500 - 230 = 270
    expect(desktopCapture.widgetPosition.x).toBe(500 - 230);
  });

  it('sets embed mode widget position to x:10, y:0', () => {
    renderWidget({ isEmbedModeActive: true, isCollapsed: false });
    expect(desktopCapture.widgetPosition).toEqual({ x: 10, y: 0 });
  });
});

describe('props forwarded to child widgets', () => {
  it('passes expected props to DesktopAnimationWidget', () => {
    renderWidget();
    expect(desktopCapture).toMatchObject({
      endDate,
      hasSubdailyLayers: false,
      interval: 'day',
      isPlaying: false,
      looping: false,
      minDate: defaultProps.minDate,
      maxDate: defaultProps.maxDate,
      numberOfFrames: 10,
      playDisabled: false,
      sliderLabel: 'Frames Per Second',
      startDate,
      subDailyMode: false,
    });
  });

  it('passes expected props to MobileAnimationWidget', () => {
    renderWidget({ isMobile: true });
    expect(mobileCapture).toMatchObject({
      endDate,
      hasSubdailyLayers: false,
      isPlaying: false,
      looping: false,
      playDisabled: false,
      startDate,
      subDailyMode: false,
    });
  });

  it('passes expected props to CollapsedAnimationWidget', () => {
    renderWidget({ isCollapsed: true });
    expect(collapsedCapture).toMatchObject({
      isPlaying: false,
      playDisabled: false,
      isMobile: false,
    });
  });
});

describe('mapStateToProps', () => {
  const buildMockState = (overrides = {}) => ({
    compare: { active: false, activeString: 'active', ...(overrides.compare || {}) },
    animation: {
      startDate: new Date('2021-01-01'),
      endDate: new Date('2021-03-01'),
      speed: 3,
      loop: false,
      isPlaying: false,
      isActive: true,
      isCollapsed: false,
      autoplay: false,
      ...(overrides.animation || {}),
    },
    date: {
      customSelected: false,
      autoSelected: false,
      delta: 1,
      customDelta: null,
      appNow: new Date('2021-06-01'),
      animationCustomModalOpen: false,
      interval: 1,
      customInterval: 3,
      ...(overrides.date || {}),
    },
    embed: { isEmbedModeActive: false, ...(overrides.embed || {}) },
    sidebar: { activeTab: 'layers', ...(overrides.sidebar || {}) },
    modal: { isOpen: false, id: '', ...(overrides.modal || {}) },
    config: { startDate: '2020-01-01', ...(overrides.config || {}) },
    map: { ui: { selected: { frameState_: true } }, ...(overrides.map || {}) },
    screenSize: {
      isMobileDevice: false,
      isMobilePhone: false,
      isMobileTablet: false,
      breakpoints: {},
      screenWidth: 1024,
      screenHeight: 768,
      orientation: 'landscape',
      ...(overrides.screenSize || {}),
    },
    ui: {
      isDistractionFreeModeActive: false,
      isKioskModeActive: false,
      animationAvailabilityChecked: false,
      eic: null,
      ...(overrides.ui || {}),
    },
    proj: {},
    layers: {
      active: { layers: [] },
      ...(overrides.layers || {}),
    },
  });

  const callMSP = (stateOverrides = {}) => capturedMapStateToProps(buildMockState(stateOverrides));

  beforeEach(() => {
    const { subdailyLayersActive, getAllActiveLayers, dateRange } = require('../../modules/layers/selectors');
    const { getNumberOfSteps, snapToIntervalDelta } = require('../../modules/animation/util');
    const { getSelectedDate } = require('../../modules/date/selectors');
    subdailyLayersActive.mockReturnValue(false);
    getAllActiveLayers.mockReturnValue([]);
    dateRange.mockReturnValue(null);
    getNumberOfSteps.mockReturnValue(10);
    getSelectedDate.mockReturnValue(new Date('2021-01-15'));
    snapToIntervalDelta.mockReturnValue(new Date('2021-01-15'));
  });

  it('returns isActive true when all conditions met', () => {
    expect(callMSP().isActive).toBe(true);
  });

  it('returns isActive false when compare is active', () => {
    expect(callMSP({ compare: { active: true } }).isActive).toBe(false);
  });

  it('returns isActive false when sidebar tab is download', () => {
    expect(callMSP({ sidebar: { activeTab: 'download' } }).isActive).toBe(false);
  });

  it('returns isActive false when TOOLBAR_SNAPSHOT modal is open', () => {
    expect(callMSP({ modal: { isOpen: true, id: 'TOOLBAR_SNAPSHOT' } }).isActive).toBe(false);
  });

  it('returns isActive false when map frameState_ is falsy', () => {
    expect(callMSP({ map: { ui: { selected: {} } } }).isActive).toBeFalsy();
  });

  it('returns isActive false when animation.isActive is false', () => {
    expect(callMSP({ animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: false, isActive: false, isCollapsed: false, autoplay: false } }).isActive).toBe(false);
  });

  it('maps startDate, endDate, speedRedux, looping, isPlaying from animation state', () => {
    const result = callMSP();
    expect(result.startDate).toEqual(new Date('2021-01-01'));
    expect(result.endDate).toEqual(new Date('2021-03-01'));
    expect(result.speedRedux).toBe(3);
    expect(result.looping).toBe(false);
    expect(result.isPlaying).toBe(false);
  });

  it('maps appNow, animationCustomModalOpen, autoplay from date state', () => {
    const result = callMSP();
    expect(result.appNow).toEqual(new Date('2021-06-01'));
    expect(result.animationCustomModalOpen).toBe(false);
    expect(result.autoplay).toBe(false);
  });

  it('checkAnimationAvailability is true when eic=sa, kiosk, not checked, playing', () => {
    const result = callMSP({
      ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, animationAvailabilityChecked: false, eic: 'sa' },
      animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: true, isActive: true, isCollapsed: false, autoplay: false },
    });
    expect(result.checkAnimationAvailability).toBe(true);
  });

  it('checkAnimationAvailability is true when eic=da', () => {
    const result = callMSP({
      ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, animationAvailabilityChecked: false, eic: 'da' },
      animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: true, isActive: true, isCollapsed: false, autoplay: false },
    });
    expect(result.checkAnimationAvailability).toBe(true);
  });

  it('checkAnimationAvailability is false when already checked', () => {
    const result = callMSP({
      ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, animationAvailabilityChecked: true, eic: 'sa' },
      animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: true, isActive: true, isCollapsed: false, autoplay: false },
    });
    expect(result.checkAnimationAvailability).toBe(false);
  });

  it('checkAnimationAvailability is false when not playing', () => {
    const result = callMSP({
      ui: { isDistractionFreeModeActive: false, isKioskModeActive: true, animationAvailabilityChecked: false, eic: 'sa' },
    });
    expect(result.checkAnimationAvailability).toBe(false);
  });

  it('caps interval to day when no subdaily layers and interval > 3', () => {
    // interval 4 capped to 3, TIME_SCALE_FROM_NUMBER[3] = 'day'
    const result = callMSP({ date: { customSelected: false, autoSelected: false, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 4, customInterval: 3 } });
    expect(result.interval).toBe('day');
  });

  it('does not cap interval when subdaily layers are active', () => {
    const { subdailyLayersActive } = require('../../modules/layers/selectors');
    subdailyLayersActive.mockReturnValue(true);
    const result = callMSP({ date: { customSelected: false, autoSelected: false, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 4, customInterval: 4 } });
    expect(result.interval).toBe('hour');
    expect(result.subDailyMode).toBe(true);
  });

  it('uses customDelta when customSelected is true and customDelta is set', () => {
    const result = callMSP({ date: { customSelected: true, autoSelected: false, delta: 1, customDelta: 5, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 1, customInterval: 4 } });
    expect(result.delta).toBe(5);
  });

  it('falls back to delta when customSelected but customDelta is null', () => {
    const result = callMSP({ date: { customSelected: true, autoSelected: false, delta: 2, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 1, customInterval: 3 } });
    expect(result.delta).toBe(2);
  });

  it('sets maxDate to layerDateRange.end when it exceeds appNow', () => {
    const { dateRange } = require('../../modules/layers/selectors');
    const futureEnd = new Date('2030-01-01');
    dateRange.mockReturnValue({ end: futureEnd });
    expect(callMSP().maxDate).toBe(futureEnd);
  });

  it('sets maxDate to appNow when no layer date range', () => {
    expect(callMSP().maxDate).toEqual(new Date('2021-06-01'));
  });

  it('hasFutureLayers is true when a layer has futureTime', () => {
    const { getAllActiveLayers } = require('../../modules/layers/selectors');
    getAllActiveLayers.mockReturnValue([{ futureTime: '2030-01-01' }]);
    expect(callMSP().hasFutureLayers).toBe(true);
  });

  it('hasFutureLayers is false when no layer has futureTime', () => {
    expect(callMSP().hasFutureLayers).toBe(false);
  });

  it('playDisabled is true when numberOfFrames >= 300 on desktop', () => {
    const { getNumberOfSteps } = require('../../modules/animation/util');
    getNumberOfSteps.mockReturnValue(300);
    expect(callMSP().playDisabled).toBe(true);
  });

  it('playDisabled is true when numberOfFrames >= 50 on mobile', () => {
    const { getNumberOfSteps } = require('../../modules/animation/util');
    getNumberOfSteps.mockReturnValue(50);
    const result = callMSP({ screenSize: { isMobileDevice: true, isMobilePhone: true, isMobileTablet: false, breakpoints: {}, screenWidth: 375, screenHeight: 667, orientation: 'portrait' } });
    expect(result.playDisabled).toBe(true);
  });

  it('playDisabled is true when numberOfFrames === 1', () => {
    const { getNumberOfSteps } = require('../../modules/animation/util');
    getNumberOfSteps.mockReturnValue(1);
    expect(callMSP().playDisabled).toBe(true);
  });

  it('playDisabled is false for valid frame count', () => {
    expect(callMSP().playDisabled).toBe(false);
  });

  it('subDailyMode is true when interval > 3 and hasSubdailyLayers', () => {
    const { subdailyLayersActive } = require('../../modules/layers/selectors');
    subdailyLayersActive.mockReturnValue(true);
    const result = callMSP({ date: { customSelected: false, autoSelected: false, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 4, customInterval: 4 } });
    expect(result.subDailyMode).toBe(true);
  });

  it('subDailyMode is false when interval <= 3', () => {
    expect(callMSP().subDailyMode).toBe(false);
  });

  it('snappedCurrentDate is currentDate when numberOfFrames >= frameLimit', () => {
    const { getNumberOfSteps, snapToIntervalDelta } = require('../../modules/animation/util');
    const { getSelectedDate } = require('../../modules/date/selectors');
    const currentDate = new Date('2021-01-15');
    getNumberOfSteps.mockReturnValue(300);
    getSelectedDate.mockReturnValue(currentDate);
    const result = callMSP();
    expect(result.snappedCurrentDate).toBe(currentDate);
    expect(snapToIntervalDelta).not.toHaveBeenCalled();
  });

  it('snappedCurrentDate uses snapToIntervalDelta when numberOfFrames < frameLimit', () => {
    const { snapToIntervalDelta } = require('../../modules/animation/util');
    const snapped = new Date('2021-01-10');
    snapToIntervalDelta.mockReturnValue(snapped);
    const result = callMSP();
    expect(result.snappedCurrentDate).toBe(snapped);
    expect(snapToIntervalDelta).toHaveBeenCalled();
  });

  it('maps screenSize fields correctly', () => {
    const result = callMSP();
    expect(result.isMobile).toBe(false);
    expect(result.screenWidth).toBe(1024);
    expect(result.screenHeight).toBe(768);
    expect(result.isLandscape).toBe(true);
    expect(result.isPortrait).toBe(false);
  });

  it('maps portrait mobile screenSize correctly', () => {
    const result = callMSP({ screenSize: { isMobileDevice: true, isMobilePhone: true, isMobileTablet: false, breakpoints: {}, screenWidth: 812, screenHeight: 375, orientation: 'portrait' } });
    expect(result.isMobile).toBe(true);
    expect(result.isPortrait).toBe(true);
    expect(result.isLandscape).toBe(false);
  });

  it('promiseImageryForTime calls the util function when invoked', () => {
    const result = callMSP();
    expect(typeof result.promiseImageryForTime).toBe('function');
    result.promiseImageryForTime(new Date('2021-01-01'));
    const { promiseImageryForTime: promiseUtil } = require('../../modules/map/util');
    expect(promiseUtil).toHaveBeenCalled();
  });

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

  it('maps autoSelected from date state', () => {
    const result = callMSP({ date: { customSelected: false, autoSelected: true, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 1, customInterval: 3 } });
    expect(result.autoSelected).toBe(true);
  });

  it('customInterval defaults to 3 when null', () => {
    const result = callMSP({ date: { customSelected: false, autoSelected: false, delta: 1, customDelta: null, appNow: new Date('2021-06-01'), animationCustomModalOpen: false, interval: 1, customInterval: null } });
    expect(result.customInterval).toBe(3);
  });

  it('customDelta defaults to 1 when null', () => {
    expect(callMSP().customDelta).toBe(1);
  });

  it('maps isCollapsed, isKioskModeActive, isDistractionFreeModeActive', () => {
    const result = callMSP({
      animation: { startDate: new Date('2021-01-01'), endDate: new Date('2021-03-01'), speed: 3, loop: false, isPlaying: false, isActive: true, isCollapsed: true, autoplay: false },
      ui: {
        isDistractionFreeModeActive: true,
        isKioskModeActive: true,
        animationAvailabilityChecked: false,
        eic: null,
      },
    });
    expect(result.isCollapsed).toBe(true);
    expect(result.isKioskModeActive).toBe(true);
    expect(result.isDistractionFreeModeActive).toBe(true);
  });

  it('maps sliderLabel as Frames Per Second', () => {
    expect(callMSP().sliderLabel).toBe('Frames Per Second');
  });

  it('maps layers from layers.active.layers', () => {
    const myLayers = [{ id: 'layer1' }];
    expect(callMSP({ layers: { active: { layers: myLayers } } }).layers).toBe(myLayers);
  });
});

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

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

  const callMDP = () => capturedMapDispatchToProps(dispatch);

  it('selectDate dispatches selectDateAction', () => {
    callMDP().selectDate(new Date('2021-01-01'));
    expect(dispatch).toHaveBeenCalledWith({ type: 'SELECT_DATE' });
  });

  it('onClose dispatches onCloseAction', () => {
    callMDP().onClose();
    expect(dispatch).toHaveBeenCalledWith({ type: 'CLOSE' });
  });

  it('onPushPlay dispatches play action', () => {
    callMDP().onPushPlay();
    expect(dispatch).toHaveBeenCalledWith({ type: 'PLAY' });
  });

  it('onPushPause dispatches stop action', () => {
    callMDP().onPushPause();
    expect(dispatch).toHaveBeenCalledWith({ type: 'STOP' });
  });

  it('onPushLoop dispatches toggleLooping action', () => {
    callMDP().onPushLoop();
    expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_LOOPING' });
  });

  it('toggleCustomModal dispatches toggleCustomModal action', () => {
    callMDP().toggleCustomModal(true, 'INTERVAL');
    expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_CUSTOM_MODAL' });
  });

  it('onSlide dispatches changeFrameRate action', () => {
    callMDP().onSlide(5);
    expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_FRAME_RATE' });
  });

  it('onIntervalSelect dispatches selectInterval action', () => {
    callMDP().onIntervalSelect(1, 'day', false);
    expect(dispatch).toHaveBeenCalledWith({ type: 'SELECT_INTERVAL' });
  });

  it('onUpdateStartDate dispatches changeStartDate action', () => {
    callMDP().onUpdateStartDate(new Date('2021-01-01'));
    expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_START_DATE' });
  });

  it('onUpdateEndDate dispatches changeEndDate action', () => {
    callMDP().onUpdateEndDate(new Date('2021-03-01'));
    expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_END_DATE' });
  });

  it('onUpdateStartAndEndDate dispatches changeStartAndEndDate action', () => {
    callMDP().onUpdateStartAndEndDate(new Date('2021-01-01'), new Date('2021-03-01'));
    expect(dispatch).toHaveBeenCalledWith({ type: 'CHANGE_START_AND_END_DATE' });
  });

  it('onToggleAnimationCollapse dispatches toggleAnimationCollapse action', () => {
    callMDP().onToggleAnimationCollapse();
    expect(dispatch).toHaveBeenCalledWith({ type: 'TOGGLE_ANIMATION_COLLAPSE' });
  });
});