Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

13.0 KB
Raw Blame
import { render, screen, fireEvent, act } from '@testing-library/react';
import '@testing-library/jest-dom';
import { Provider } from 'react-redux';
import configureStore from 'redux-mock-store';

jest.mock('../../../modules/date/actions', () => ({
  selectDate: jest.fn((d) => ({ type: 'SELECT_DATE', date: d })),
}));
jest.mock('../../../modules/smart-handoff/selectors', () => ({
  getBaseCmrUrl: jest.fn((state) => state.smartHandoff.baseUrl),
}));
jest.mock('../../../util/cmr', () => ({
  buildGranulesUrl: jest.fn(() => 'https://cmr.example.com/granules'),
  cmrFetch: jest.fn(() => Promise.resolve({
    json: () => Promise.resolve({ feed: { entry: [] } }),
  })),
}));

import ImagerySearch from './imagery-search';
import { cmrFetch } from '../../../util/cmr';

// jsdom always returns 0 for scrollHeight/clientHeight; the component's useEffect
// loops endlessly when scrollHeight <= clientHeight.  Override both on the prototype
// so every ul rendered by the component sees scrollHeight > clientHeight and the
// effect takes the stable else-branch (sets scrollTop once and stops).
Object.defineProperty(HTMLElement.prototype, 'scrollHeight', {
  configurable: true,
  get() { return 1000; },
});
Object.defineProperty(HTMLElement.prototype, 'clientHeight', {
  configurable: true,
  get() { return 200; },
});

const mockStore = configureStore([]);
const selectedDate = new Date('2023-06-15T00:00:00.000Z');

const buildStore = (overrides = {}) => mockStore({
  date: { selected: selectedDate, selectedB: selectedDate, ...overrides.date },
  compare: { active: false, isCompareA: true, ...overrides.compare },
  map: { extent: [-180, -90, 180, 90], ...overrides.map },
  smartHandoff: { baseUrl: 'https://cmr.earthdata.nasa.gov' },
});

const layer = {
  id: 'HLSS30_Customizable',
  conceptIds: [{ value: 'C12345-PROVIDER' }],
};

const renderSearch = async (layerOverride = layer, storeOverride = {}) => {
  let result;
  await act(async () => {
    result = render(
      <Provider store={buildStore(storeOverride)}>
        <ImagerySearch layer={layerOverride} />
      </Provider>,
    );
  });
  return result;
};

beforeEach(() => {
  jest.clearAllMocks();
  cmrFetch.mockResolvedValue({
    json: () => Promise.resolve({ feed: { entry: [] } }),
  });
});

describe('ImagerySearch', () => {
  describe('layout', () => {
    it('renders the "Available Imagery Dates" title', async () => {
      await renderSearch();
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });

    it('renders the scrollable list', async () => {
      await renderSearch();
      expect(screen.getByRole('list')).toBeInTheDocument();
    });

    it('renders start and end spinner list items', async () => {
      const { container } = await renderSearch();
      expect(container.querySelectorAll('.imagery-search-spinner')).toHaveLength(2);
    });

    it('renders an hr divider below the list', async () => {
      const { container } = await renderSearch();
      expect(container.querySelector('hr')).toBeInTheDocument();
    });
  });

  describe('granule date rendering', () => {
    it('renders returned granule dates as list items', async () => {
      cmrFetch.mockResolvedValue({
        json: () => Promise.resolve({
          feed: {
            entry: [
              { time_start: '2023-06-14T00:00:00.000Z' },
              { time_start: '2023-06-13T00:00:00.000Z' },
            ],
          },
        }),
      });
      await renderSearch();
      expect(screen.getAllByRole('listitem').length).toBeGreaterThan(0);
    });

    it('shows no date list items when cmrFetch returns empty entries', async () => {
      await renderSearch();
      const dateItems = screen.queryAllByRole('listitem').filter((el) => el.classList.contains('lazyload-list-item'));
      expect(dateItems).toHaveLength(0);
    });

    it('deduplicates granule dates that fall on the same calendar day', async () => {
      // The useEffect takes the else-branch (scrollHeight > clientHeight), so data
      // only loads on a scroll near the bottom.  Set up the mock before scrolling.
      cmrFetch
        .mockResolvedValueOnce({
          json: () => Promise.resolve({
            feed: {
              entry: [
                { time_start: '2023-06-14T01:00:00.000Z' },
                { time_start: '2023-06-14T12:00:00.000Z' },
              ],
            },
          }),
        })
        .mockResolvedValue({ json: () => Promise.resolve({ feed: { entry: [] } }) });

      await renderSearch();
      const list = screen.getByRole('list');

      // Scroll near the bottom to trigger loadOlderDates
      await act(async () => {
        Object.defineProperty(list, 'scrollTop', { value: 900, configurable: true });
        Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
        Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
        fireEvent.scroll(list, { target: list });
      });

      const dateItems = screen.queryAllByRole('listitem').filter((el) => el.classList.contains('lazyload-list-item'));
      // Two timestamps on the same day should collapse to one date entry
      expect(dateItems).toHaveLength(1);
    });

    it('renders dates sorted newest-first', async () => {
      cmrFetch
        .mockResolvedValueOnce({
          json: () => Promise.resolve({
            feed: {
              entry: [
                { time_start: '2023-06-13T00:00:00.000Z' },
                { time_start: '2023-06-14T00:00:00.000Z' },
                { time_start: '2023-06-15T00:00:00.000Z' },
              ],
            },
          }),
        })
        .mockResolvedValue({ json: () => Promise.resolve({ feed: { entry: [] } }) });

      await renderSearch();
      const list = screen.getByRole('list');

      // Scroll near the bottom to trigger loadOlderDates
      await act(async () => {
        Object.defineProperty(list, 'scrollTop', { value: 900, configurable: true });
        Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
        Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
        fireEvent.scroll(list, { target: list });
      });

      const dateItems = screen.queryAllByRole('listitem').filter((el) => el.classList.contains('lazyload-list-item'));
      expect(dateItems.length).toBeGreaterThanOrEqual(1);
      // First item should be the newest date (June 15)
      expect(dateItems[0].textContent).toContain('June 15');
    });
  });

  describe('conceptId resolution', () => {
    it('renders without error when using collectionConceptID fallback', async () => {
      const layerWithFallback = { id: 'fallback-layer', collectionConceptID: 'C99999-PROVIDER' };
      await renderSearch(layerWithFallback);
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });

    it('renders without error when layer has no conceptId or collectionConceptID', async () => {
      const layerNoIds = { id: 'no-ids-layer' };
      await renderSearch(layerNoIds);
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });
  });

  describe('compare mode', () => {
    it('renders without error when compare is active and isCompareA is false', async () => {
      const selectedB = new Date('2023-01-01T00:00:00.000Z');
      await renderSearch(layer, {
        date: { selected: selectedDate, selectedB },
        compare: { active: true, isCompareA: false },
      });
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });

    it('uses date.selected when compare is active and isCompareA is true', async () => {
      const selectedB = new Date('2023-01-01T00:00:00.000Z');
      await renderSearch(layer, {
        date: { selected: selectedDate, selectedB },
        compare: { active: true, isCompareA: true },
      });
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });
  });

  describe('map extent clamping', () => {
    it('renders without error when map extent exceeds maxExtent bounds', async () => {
      // Extent larger than [-180,-90,180,90] — triggers the clamping branches
      await renderSearch(layer, {
        map: { extent: [-200, -100, 200, 100] },
      });
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });

    it('renders without error when map extent is within maxExtent bounds', async () => {
      await renderSearch(layer, {
        map: { extent: [-90, -45, 90, 45] },
      });
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });
  });

  describe('cmrFetch error handling', () => {
    it('renders without error when cmrFetch rejects (older granules)', async () => {
      cmrFetch.mockRejectedValue(new Error('network error'));
      await renderSearch();
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });

    it('renders without error when cmrFetch response.json() rejects', async () => {
      cmrFetch.mockResolvedValue({
        json: () => Promise.reject(new Error('bad json')),
      });
      await renderSearch();
      expect(screen.getByText('Available Imagery Dates')).toBeInTheDocument();
    });
  });

  describe('date selection', () => {
    it('dispatches selectDate action when a date list item is clicked', async () => {
      const { selectDate } = require('../../../modules/date/actions');
      cmrFetch
        .mockResolvedValueOnce({
          json: () => Promise.resolve({
            feed: { entry: [{ time_start: '2023-06-14T00:00:00.000Z' }] },
          }),
        })
        .mockResolvedValue({ json: () => Promise.resolve({ feed: { entry: [] } }) });

      await renderSearch();
      const list = screen.getByRole('list');

      // Trigger loadOlderDates via bottom-scroll to populate date list items
      await act(async () => {
        Object.defineProperty(list, 'scrollTop', { value: 900, configurable: true });
        Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
        Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
        fireEvent.scroll(list, { target: list });
      });

      const dateItems = screen.queryAllByRole('listitem').filter((el) => el.classList.contains('lazyload-list-item'));
      expect(dateItems.length).toBeGreaterThan(0);
      await act(async () => {
        fireEvent.click(dateItems[0]);
      });
      expect(selectDate).toHaveBeenCalled();
    });
  });

  describe('scroll handling', () => {
    it('does not throw when scroll event fires', async () => {
      await renderSearch();
      const list = screen.getByRole('list');
      // scrollHeight/clientHeight are already stubbed on the prototype; just fire the event
      expect(() => { fireEvent.scroll(list); }).not.toThrow();
    });

    it('calls loadNewerDates when scrolled near the top (scrollPercentage <= 0.1)', async () => {
      cmrFetch.mockResolvedValue({
        json: () => Promise.resolve({ feed: { entry: [] } }),
      });
      await renderSearch();
      const list = screen.getByRole('list');

      await act(async () => {
        Object.defineProperty(list, 'scrollTop', { value: 0, configurable: true });
        Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
        Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
        fireEvent.scroll(list, { target: list });
      });
      // cmrFetch should have been called again for newer granules
      expect(cmrFetch).toHaveBeenCalled();
    });

    it('calls loadOlderDates when scrolled near the bottom (scrollPercentage >= 0.9)', async () => {
      cmrFetch.mockResolvedValue({
        json: () => Promise.resolve({ feed: { entry: [] } }),
      });
      await renderSearch();
      const list = screen.getByRole('list');
      const callsBefore = cmrFetch.mock.calls.length;

      await act(async () => {
        Object.defineProperty(list, 'scrollTop', { value: 800, configurable: true });
        Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
        Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
        fireEvent.scroll(list, { target: list });
      });
      expect(cmrFetch.mock.calls.length).toBeGreaterThan(callsBefore);
    });

    it('does not load more granules when scrolled to the middle', async () => {
      cmrFetch.mockResolvedValue({
        json: () => Promise.resolve({ feed: { entry: [] } }),
      });
      await renderSearch();
      const list = screen.getByRole('list');
      const callsBefore = cmrFetch.mock.calls.length;

      // Scroll to 50%: scrollTop=400, scrollHeight=1000, clientHeight=200 => 400/800=0.5
      await act(async () => {
        Object.defineProperty(list, 'scrollTop', { value: 400, configurable: true });
        Object.defineProperty(list, 'scrollHeight', { value: 1000, configurable: true });
        Object.defineProperty(list, 'clientHeight', { value: 200, configurable: true });
        fireEvent.scroll(list, { target: list });
      });
      expect(cmrFetch.mock.calls.length).toBe(callsBefore);
    });
  });
});