Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

15.2 KB
Raw Blame
/* eslint-disable react/jsx-props-no-spreading */
import { render, fireEvent } from '@testing-library/react';
import MenuItem from './MenuItem'; // Update path as needed
import { hideMenu } from './actions';
import { callIfExists, cssClasses, store } from './helpers';

// ---------------------------------------------------------------------------
// Mocks
// ---------------------------------------------------------------------------

jest.mock('./actions', () => ({
  hideMenu: jest.fn(),
}));

jest.mock('./helpers', () => ({
  callIfExists: jest.fn((fn, ...args) => fn && fn(...args)),
  cssClasses: {
    menuItem: 'react-contextmenu-item',
    menuItemDisabled: 'react-contextmenu-item--disabled',
    menuItemDivider: 'react-contextmenu-item--divider',
    menuItemSelected: 'react-contextmenu-item--selected',
  },
  store: { data: {}, target: null },
}));

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

function renderItem(props = {}) {
  return render(
    <MenuItem {...props}>
      {props.children ?? <span data-testid="child">Item Label</span>}
    </MenuItem>,
  );
}

function clickItem(element, button = 0) {
  fireEvent.click(element, { button });
}

// ---------------------------------------------------------------------------
// Rendering
// ---------------------------------------------------------------------------

describe('MenuItem rendering', () => {
  beforeEach(() => jest.clearAllMocks());

  it('renders a div with role="menuitem"', () => {
    const { getByRole } = renderItem();
    expect(getByRole('menuitem')).toBeTruthy();
  });

  it('renders children by default', () => {
    const { getByTestId } = renderItem();
    expect(getByTestId('child')).toBeTruthy();
  });

  it('does not render children when divider is true', () => {
    const { queryByTestId } = renderItem({ divider: true });
    expect(queryByTestId('child')).toBeNull();
  });

  it('applies the base menuItem cssClass', () => {
    const { getByRole } = renderItem();
    expect(getByRole('menuitem').className).toContain(cssClasses.menuItem);
  });

  it('applies a custom className prop', () => {
    const { getByRole } = renderItem({ className: 'my-custom-class' });
    expect(getByRole('menuitem').className).toContain('my-custom-class');
  });

  it('applies attributes.className', () => {
    const { getByRole } = renderItem({ attributes: { className: 'attr-class' } });
    expect(getByRole('menuitem').className).toContain('attr-class');
  });

  it('applies disabled class when disabled is true', () => {
    const { getByRole } = renderItem({ disabled: true });
    expect(getByRole('menuitem').className).toContain(cssClasses.menuItemDisabled);
  });

  it('applies attributes.disabledClassName when disabled', () => {
    const { getByRole } = renderItem({
      disabled: true,
      attributes: { disabledClassName: 'custom-disabled' },
    });
    expect(getByRole('menuitem').className).toContain('custom-disabled');
  });

  it('does not apply disabled class when disabled is false', () => {
    const { getByRole } = renderItem({ disabled: false });
    expect(getByRole('menuitem').className).not.toContain(cssClasses.menuItemDisabled);
  });

  it('applies divider class when divider is true', () => {
    const { getByRole } = renderItem({ divider: true });
    expect(getByRole('menuitem').className).toContain(cssClasses.menuItemDivider);
  });

  it('applies attributes.dividerClassName when divider', () => {
    const { getByRole } = renderItem({
      divider: true,
      attributes: { dividerClassName: 'custom-divider' },
    });
    expect(getByRole('menuitem').className).toContain('custom-divider');
  });

  it('does not apply divider class when divider is false', () => {
    const { getByRole } = renderItem({ divider: false });
    expect(getByRole('menuitem').className).not.toContain(cssClasses.menuItemDivider);
  });

  it('applies selected class when selected is true', () => {
    const { getByRole } = renderItem({ selected: true });
    expect(getByRole('menuitem').className).toContain(cssClasses.menuItemSelected);
  });

  it('applies attributes.selectedClassName when selected', () => {
    const { getByRole } = renderItem({
      selected: true,
      attributes: { selectedClassName: 'custom-selected' },
    });
    expect(getByRole('menuitem').className).toContain('custom-selected');
  });

  it('does not apply selected class when selected is false', () => {
    const { getByRole } = renderItem({ selected: false });
    expect(getByRole('menuitem').className).not.toContain(cssClasses.menuItemSelected);
  });

  it('sets aria-disabled to "true" when disabled', () => {
    const { getByRole } = renderItem({ disabled: true });
    expect(getByRole('menuitem').getAttribute('aria-disabled')).toBe('true');
  });

  it('sets aria-disabled to "false" when not disabled', () => {
    const { getByRole } = renderItem({ disabled: false });
    expect(getByRole('menuitem').getAttribute('aria-disabled')).toBe('false');
  });

  it('sets aria-orientation to "horizontal" when divider', () => {
    const { getByRole } = renderItem({ divider: true });
    expect(getByRole('menuitem').getAttribute('aria-orientation')).toBe('horizontal');
  });

  it('does not set aria-orientation when not a divider', () => {
    const { getByRole } = renderItem({ divider: false });
    expect(getByRole('menuitem').getAttribute('aria-orientation')).toBeNull();
  });

  it('passes through extra attributes to the div', () => {
    const { getByRole } = renderItem({ attributes: { 'data-custom': 'value' } });
    expect(getByRole('menuitem').getAttribute('data-custom')).toBe('value');
  });

  it('renders null children when children prop is null', () => {
    const { getByRole } = renderItem({ children: null });
    expect(getByRole('menuitem')).toBeTruthy();
  });
});

// ---------------------------------------------------------------------------
// handleClick — button guard
// ---------------------------------------------------------------------------

describe('handleClick() button guard', () => {
  beforeEach(() => jest.clearAllMocks());

  it('does not prevent default for left click (button 0)', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ onClick });
    fireEvent.click(getByRole('menuitem'), { button: 0 });
    expect(onClick).toHaveBeenCalled();
    expect(hideMenu).toHaveBeenCalled();
  });

  it('calls onClick for middle click (button 1)', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ onClick });
    fireEvent.click(getByRole('menuitem'), { button: 1 });
    expect(onClick).toHaveBeenCalled();
  });

  it('calls hideMenu for middle click (button 1)', () => {
    const { getByRole } = renderItem();
    fireEvent.click(getByRole('menuitem'), { button: 1 });
    expect(hideMenu).toHaveBeenCalled();
  });

  it('does not call onClick or hideMenu for button > 1 when disabled', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ disabled: true, onClick });
    fireEvent.click(getByRole('menuitem'), { button: 2 });
    expect(onClick).not.toHaveBeenCalled();
    expect(hideMenu).not.toHaveBeenCalled();
  });
});

// ---------------------------------------------------------------------------
// handleClick — disabled / divider guards
// ---------------------------------------------------------------------------

describe('handleClick() disabled and divider guards', () => {
  beforeEach(() => jest.clearAllMocks());

  it('does not call onClick when disabled', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ disabled: true, onClick });
    clickItem(getByRole('menuitem'));
    expect(onClick).not.toHaveBeenCalled();
  });

  it('does not call hideMenu when disabled', () => {
    const { getByRole } = renderItem({ disabled: true });
    clickItem(getByRole('menuitem'));
    expect(hideMenu).not.toHaveBeenCalled();
  });

  it('does not call onClick when divider is true', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ divider: true, onClick });
    clickItem(getByRole('menuitem'));
    expect(onClick).not.toHaveBeenCalled();
  });

  it('does not call hideMenu when divider is true', () => {
    const { getByRole } = renderItem({ divider: true });
    clickItem(getByRole('menuitem'));
    expect(hideMenu).not.toHaveBeenCalled();
  });
});

// ---------------------------------------------------------------------------
// handleClick — preventClose
// ---------------------------------------------------------------------------

describe('handleClick() preventClose', () => {
  beforeEach(() => jest.clearAllMocks());

  it('does not call hideMenu when preventClose is true', () => {
    const { getByRole } = renderItem({ preventClose: true });
    clickItem(getByRole('menuitem'));
    expect(hideMenu).not.toHaveBeenCalled();
  });

  it('still calls onClick when preventClose is true', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ preventClose: true, onClick });
    clickItem(getByRole('menuitem'));
    expect(onClick).toHaveBeenCalled();
  });

  it('calls hideMenu when preventClose is false', () => {
    const { getByRole } = renderItem({ preventClose: false });
    clickItem(getByRole('menuitem'));
    expect(hideMenu).toHaveBeenCalled();
  });
});

// ---------------------------------------------------------------------------
// handleClick — data merging
// ---------------------------------------------------------------------------

describe('handleClick() data merging', () => {
  beforeEach(() => {
    jest.clearAllMocks();
    store.data = {};
    store.target = null;
  });

  it('passes merged data and store.data to onClick', () => {
    const onClick = jest.fn();
    store.data = { storeKey: 'storeValue' };

    const { getByRole } = renderItem({ onClick, data: { itemKey: 'itemValue' } });
    clickItem(getByRole('menuitem'));

    const dataArg = onClick.mock.calls[0][1];
    expect(dataArg.itemKey).toBe('itemValue');
    expect(dataArg.storeKey).toBe('storeValue');
  });

  it('store.data properties override item data properties with same key', () => {
    const onClick = jest.fn();
    store.data = { key: 'fromStore' };

    const { getByRole } = renderItem({ onClick, data: { key: 'fromItem' } });
    clickItem(getByRole('menuitem'));

    const dataArg = onClick.mock.calls[0][1];
    expect(dataArg.key).toBe('fromStore');
  });

  it('passes store.target as the third argument to onClick', () => {
    const onClick = jest.fn();
    const mockTarget = document.createElement('div');
    store.target = mockTarget;

    const { getByRole } = renderItem({ onClick });
    clickItem(getByRole('menuitem'));

    expect(onClick.mock.calls[0][2]).toBe(mockTarget);
  });

  it('passes the click event as the first argument to onClick', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ onClick });
    clickItem(getByRole('menuitem'));

    const eventArg = onClick.mock.calls[0][0];
    expect(eventArg).toBeTruthy();
    expect(typeof eventArg.preventDefault).toBe('function');
  });

  it('works when data prop is an empty object', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ onClick, data: {} });
    clickItem(getByRole('menuitem'));
    expect(onClick).toHaveBeenCalled();
  });

  it('works when store.data is empty', () => {
    const onClick = jest.fn();
    store.data = {};
    const { getByRole } = renderItem({ onClick, data: { key: 'value' } });
    clickItem(getByRole('menuitem'));
    const dataArg = onClick.mock.calls[0][1];
    expect(dataArg.key).toBe('value');
  });
});

// ---------------------------------------------------------------------------
// Mouse event handlers
// ---------------------------------------------------------------------------

describe('mouse event handlers', () => {
  beforeEach(() => jest.clearAllMocks());

  it('calls onMouseMove prop when mouse moves over item', () => {
    const onMouseMove = jest.fn();
    const { getByRole } = renderItem({ onMouseMove });
    fireEvent.mouseMove(getByRole('menuitem'));
    expect(onMouseMove).toHaveBeenCalled();
  });

  it('calls onMouseLeave prop when mouse leaves item', () => {
    const onMouseLeave = jest.fn();
    const { getByRole } = renderItem({ onMouseLeave });
    fireEvent.mouseLeave(getByRole('menuitem'));
    expect(onMouseLeave).toHaveBeenCalled();
  });

  it('does not throw when default onMouseMove is used', () => {
    const { getByRole } = renderItem();
    expect(() => fireEvent.mouseMove(getByRole('menuitem'))).not.toThrow();
  });

  it('does not throw when default onMouseLeave is used', () => {
    const { getByRole } = renderItem();
    expect(() => fireEvent.mouseLeave(getByRole('menuitem'))).not.toThrow();
  });
});

// ---------------------------------------------------------------------------
// Touch handler
// ---------------------------------------------------------------------------

describe('touch handler (onTouchEnd)', () => {
  beforeEach(() => jest.clearAllMocks());

  it('calls onClick on touch end with button 0', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ onClick });
    fireEvent.touchEnd(getByRole('menuitem'), { button: 0 });
    expect(onClick).toHaveBeenCalled();
  });

  it('calls hideMenu on touch end by default', () => {
    const { getByRole } = renderItem();
    fireEvent.touchEnd(getByRole('menuitem'), { button: 0 });
    expect(hideMenu).toHaveBeenCalled();
  });

  it('does not call onClick on touch end when disabled', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ disabled: true, onClick });
    fireEvent.touchEnd(getByRole('menuitem'), { button: 0 });
    expect(onClick).not.toHaveBeenCalled();
  });

  it('does not call hideMenu on touch end when divider is true', () => {
    const { getByRole } = renderItem({ divider: true });
    fireEvent.touchEnd(getByRole('menuitem'), { button: 0 });
    expect(hideMenu).not.toHaveBeenCalled();
  });

  it('does not call hideMenu on touch end when preventClose is true', () => {
    const { getByRole } = renderItem({ preventClose: true });
    fireEvent.touchEnd(getByRole('menuitem'), { button: 0 });
    expect(hideMenu).not.toHaveBeenCalled();
  });

  it('calls preventDefault for touch end with button > 1', () => {
    const { getByRole } = renderItem();
    // button 2 triggers the preventDefault branch
    expect(() =>
      fireEvent.touchEnd(getByRole('menuitem'), { button: 2 }),
    ).not.toThrow();
  });
});

// ---------------------------------------------------------------------------
// callIfExists integration
// ---------------------------------------------------------------------------

describe('callIfExists integration', () => {
  beforeEach(() => jest.clearAllMocks());

  it('calls callIfExists with the onClick prop', () => {
    const onClick = jest.fn();
    const { getByRole } = renderItem({ onClick });
    clickItem(getByRole('menuitem'));
    expect(callIfExists).toHaveBeenCalledWith(
      onClick,
      expect.anything(), // event
      expect.anything(), // merged data
      store.target,
    );
  });

  it('does not throw when onClick prop is not provided (uses default)', () => {
    const { getByRole } = renderItem();
    expect(() => clickItem(getByRole('menuitem'))).not.toThrow();
  });
});