Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

14.2 KB
Raw Blame
import { assign, cloneDeep } from 'lodash';
import update from 'immutability-helper';
import fixtures from '../../fixtures';
import { addLayer } from '../layers/selectors';
import {
  getRenderedPalette,
  getPalette,
  getPaletteLegend,
  getPaletteLegends,
  getDefaultLegend,
  getCustomPalette,
  getCount,
  getLookup,
  getKey,
  getActivePalettes,
  isPaletteAllowed,
  isActive,
  findIndex,
  setCustomSelector,
  setRange,
  clearCustomSelector,
  initDisabledSelector,
  setDisabledSelector,
  refreshDisabledSelector,
} from './selectors';

const config = fixtures.config();
const baseState = fixtures.getState();

let layers = addLayer('terra-aod', [], config.layers, {}, 0);
layers = addLayer('aqua-cr', layers, config.layers, {}, 1);
const stateWithLayers = update(baseState, {
  layers: { active: { $set: layers } },
});

const buildState = (activePalettes = {}) => update(stateWithLayers, {
  palettes: { active: { $set: activePalettes } },
});

describe('getRenderedPalette', () => {
  test('returns the full rendered palette object when index is undefined', () => {
    const palette = getRenderedPalette('terra-aod', undefined, buildState());
    expect(palette).toBeDefined();
    expect(palette.maps).toBeDefined();
  });

  test('returns the palette map at the given index', () => {
    const palette = getRenderedPalette('terra-aod', 0, buildState());
    expect(palette).toBeDefined();
    expect(palette.entries).toBeDefined();
  });

  test('throws an error when the palette does not exist', () => {
    expect(() => getRenderedPalette('non-existent-layer', 0, buildState())).toThrow();
  });
});

describe('getPalette', () => {
  test('returns rendered palette map when no active palette exists', () => {
    const palette = getPalette('terra-aod', 0, 'active', buildState());
    expect(palette).toBeDefined();
    expect(palette.entries).toBeDefined();
  });

  test('returns custom active palette when it exists', () => {
    const result = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const testState = buildState(result);
    const palette = getPalette('terra-aod', 0, 'active', testState);
    expect(palette).toBeDefined();
  });

  test('defaults index to 0 when index is undefined', () => {
    const palette = getPalette('terra-aod', undefined, 'active', buildState());
    expect(palette).toBeDefined();
  });

  test('uses compare.activeString when group is not provided', () => {
    const palette = getPalette('terra-aod', 0, undefined, buildState());
    expect(palette).toBeDefined();
  });
});

describe('getPaletteLegend', () => {
  test('returns the legend of a palette', () => {
    const legend = getPaletteLegend('terra-aod', 0, 'active', buildState());
    expect(legend).toBeDefined();
  });
});

describe('getPaletteLegends', () => {
  test('returns an array of legends for all colormaps', () => {
    const legends = getPaletteLegends('terra-aod', 'active', buildState());
    expect(Array.isArray(legends)).toBe(true);
    expect(legends.length).toBeGreaterThan(0);
  });
});

describe('getDefaultLegend', () => {
  test('returns the legend from the rendered palette at the given index', () => {
    const legend = getDefaultLegend('terra-aod', 0, buildState());
    expect(legend).toBeDefined();
  });
});

describe('getCustomPalette', () => {
  test('returns the custom palette by id', () => {
    const palette = getCustomPalette('red-1', config.palettes.custom);
    expect(palette).toBeDefined();
    expect(palette.colors).toBeDefined();
  });

  test('throws an error when the custom palette does not exist', () => {
    expect(() => getCustomPalette('non-existent', config.palettes.custom)).toThrow('Invalid palette: non-existent');
  });
});

describe('getCount', () => {
  test('returns the number of colormaps for a layer', () => {
    const count = getCount('terra-aod', buildState());
    expect(count).toBeGreaterThan(0);
  });
});

describe('getLookup', () => {
  test('returns lookup from active palette using provided group', () => {
    const result = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const testState = buildState(result);
    const lookup = getLookup('terra-aod', 'active', testState);
    expect(lookup).toBeDefined();
  });

  test('returns lookup using compare.activeString when group is not provided', () => {
    const result = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const testState = buildState(result);
    const lookup = getLookup('terra-aod', undefined, testState);
    expect(lookup).toBeDefined();
  });
});

describe('isActive', () => {
  test('returns the active palette entry when it exists', () => {
    const result = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const testState = buildState(result);
    const active = isActive('terra-aod', 'active', testState);
    expect(active).toBeDefined();
  });

  test('returns undefined when no active palette entry exists', () => {
    const result = isActive('terra-aod', 'active', buildState());
    expect(result).toBeUndefined();
  });

  test('uses compare.activeString when group is not provided', () => {
    const result = isActive('terra-aod', undefined, buildState());
    expect(result).toBeUndefined();
  });
});

describe('getKey', () => {
  test('returns empty string when palette is not active', () => {
    const key = getKey('terra-aod', 'active', buildState());
    expect(key).toEqual('');
  });

  test('returns palette key when custom palette is active', () => {
    const result = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const testState = buildState(result);
    const key = getKey('terra-aod', 'active', testState);
    expect(key).toContain('palette=red-1');
  });

  test('returns key with min when min is set', () => {
    const result = setRange('terra-aod', { min: 1 }, 0, {}, buildState());
    const testState = buildState(result);
    const key = getKey('terra-aod', 'active', testState);
    expect(key).toContain('min=');
  });

  test('returns key with max when max is set', () => {
    const result = setRange('terra-aod', { max: 1 }, 0, {}, buildState());
    const testState = buildState(result);
    const key = getKey('terra-aod', 'active', testState);
    expect(key).toContain('max=');
  });

  test('returns key with squash when squash is set', () => {
    const result = setRange('terra-aod', { max: 1, squash: true }, 0, {}, buildState());
    const testState = buildState(result);
    const key = getKey('terra-aod', 'active', testState);
    expect(key).toContain('squash');
  });

  test('returns key with noclip when noclip is set', () => {
    const result = setRange('terra-aod', { max: 1, noclip: true }, 0, {}, buildState());
    const testState = buildState(result);
    const key = getKey('terra-aod', 'active', testState);
    expect(key).toContain('noclip');
  });

  test('uses compare.activeString when groupStr is not provided', () => {
    const key = getKey('terra-aod', undefined, buildState());
    expect(key).toEqual('');
  });
});

describe('getActivePalettes', () => {
  test('returns the active palettes for the given activeString', () => {
    const result = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const testState = buildState(result);
    const active = getActivePalettes(testState, 'active');
    expect(active['terra-aod']).toBeDefined();
  });
});

describe('isPaletteAllowed', () => {
  test('returns true for a layer with a non-immutable palette', () => {
    const result = isPaletteAllowed('terra-aod', config);
    expect(result).toBe(true);
  });
});

describe('findIndex', () => {
  test('returns the index of a matching value in the palette entries', () => {
    const { values } = config.palettes.rendered['terra-aod'].maps[0].entries;
    const firstValue = values[0];
    const result = findIndex('terra-aod', firstValue, 0, 'active', buildState());
    expect(result).toEqual(0);
  });

  test('returns undefined when value is not found', () => {
    const result = findIndex('terra-aod', 'non-existent-value', 0, 'active', buildState());
    expect(result).toBeUndefined();
  });
});

describe('setCustomSelector', () => {
  test('sets a custom palette and returns a lookup', () => {
    const result = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    expect(result['terra-aod']).toBeDefined();
    expect(result['terra-aod'].lookup).toBeDefined();
    expect(result['terra-aod'].maps[0].custom).toEqual('red-1');
  });

  test('throws an error for an invalid layer', () => {
    expect(() => setCustomSelector('non-existent', 'red-1', 0, 'active', buildState())).toThrow('Invalid layer: non-existent');
  });

  test('returns early when palette and lookup are already set to the same custom id', () => {
    const firstResult = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const secondState = buildState(firstResult);
    const secondResult = setCustomSelector('terra-aod', 'red-1', 0, 'active', secondState);
    expect(secondResult['terra-aod'].maps[0].custom).toEqual('red-1');
  });

  test('defaults index to 0 when index is undefined', () => {
    const result = setCustomSelector('terra-aod', 'red-1', undefined, 'active', buildState());
    expect(result['terra-aod'].maps[0].custom).toEqual('red-1');
  });
});

describe('setRange', () => {
  test('sets min value and produces a lookup', () => {
    const result = setRange('terra-aod', { min: 1 }, 0, {}, buildState());
    expect(result['terra-aod']).toBeDefined();
    expect(result['terra-aod'].maps[0].min).toEqual(1);
    expect(result['terra-aod'].lookup).toBeDefined();
  });

  test('sets max value and produces a lookup', () => {
    const result = setRange('terra-aod', { max: 1 }, 0, {}, buildState());
    expect(result['terra-aod'].maps[0].max).toEqual(1);
    expect(result['terra-aod'].lookup).toBeDefined();
  });

  test('sets squash and max and produces a lookup', () => {
    const result = setRange('terra-aod', { max: 1, squash: true }, 0, {}, buildState());
    expect(result['terra-aod'].maps[0].squash).toEqual(true);
    expect(result['terra-aod'].lookup).toBeDefined();
  });

  test('sets noclip and max and produces a lookup', () => {
    const result = setRange('terra-aod', { max: 1, noclip: true }, 0, {}, buildState());
    expect(result['terra-aod'].maps[0].noclip).toEqual(true);
    expect(result['terra-aod'].lookup).toBeDefined();
  });

  test('converts min of 0 to undefined and does not produce a lookup', () => {
    const result = setRange('terra-aod', { min: 0 }, 0, {}, buildState());
    expect(result['terra-aod']).toBeUndefined();
  });

  test('converts max at last value index to undefined and does not produce a lookup', () => {
    const lastIndex = config.palettes.rendered['terra-aod'].maps[0].entries.values.length - 1;
    const result = setRange('terra-aod', { max: lastIndex }, 0, {}, buildState());
    expect(result['terra-aod']).toBeUndefined();
  });

  test('defaults index to 0 when index is undefined', () => {
    const result = setRange('terra-aod', { min: 1 }, undefined, {}, buildState());
    expect(result['terra-aod'].maps[0].min).toEqual(1);
  });
});

describe('clearCustomSelector', () => {
  test('clears custom palette and returns palettes without layerId when no threshold', () => {
    const withCustom = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const result = clearCustomSelector('terra-aod', 0, withCustom, buildState());
    expect(result['terra-aod']).toBeUndefined();
  });

  test('returns original palettes when layer has no active entry', () => {
    const palettes = {};
    const result = clearCustomSelector('terra-aod', 0, palettes, buildState());
    expect(result).toEqual(palettes);
  });

  test('returns original palettes when no custom is set', () => {
    const terraAOD = assign({}, config.palettes.rendered['terra-aod']);
    const palettes = { 'terra-aod': terraAOD };
    const result = clearCustomSelector('terra-aod', 0, palettes, buildState());
    expect(result).toEqual(palettes);
  });

  test('defaults index to 0 when index is undefined', () => {
    const withCustom = setCustomSelector('terra-aod', 'red-1', 0, 'active', buildState());
    const result = clearCustomSelector('terra-aod', undefined, withCustom, buildState());
    expect(result['terra-aod']).toBeUndefined();
  });
});

describe('initDisabledSelector', () => {
  test('sets disabled array from hyphen-separated string', () => {
    const result = initDisabledSelector('terra-aod', '0-1', 0, {}, buildState());
    expect(result).toBeDefined();
  });

  test('sets empty disabled array when disabledStr is empty string', () => {
    const result = initDisabledSelector('terra-aod', '', 0, {}, buildState());
    expect(result).toBeDefined();
  });

  test('sets empty disabled array when disabledStr is null', () => {
    const result = initDisabledSelector('terra-aod', null, 0, {}, buildState());
    expect(result).toBeDefined();
  });
});

describe('setDisabledSelector', () => {
  test('adds a classIndex to the disabled array when not already present', () => {
    const result = setDisabledSelector('terra-aod', 0, 0, {}, buildState());
    expect(result).toBeDefined();
  });

  test('removes a classIndex from the disabled array when already present', () => {
    const firstResult = setDisabledSelector('terra-aod', 0, 0, {}, buildState());
    const firstState = buildState(firstResult);
    const secondResult = setDisabledSelector('terra-aod', 0, 0, firstResult, firstState);
    expect(secondResult).toBeDefined();
  });

  test('sets disabled to empty array when classIndex is NaN', () => {
    const result = setDisabledSelector('terra-aod', NaN, 0, {}, buildState());
    expect(result).toBeDefined();
  });
});

describe('refreshDisabledSelector', () => {
  test('returns palettes with layerId when min is set and disabled array is non-empty', () => {
    const withMin = setRange('terra-aod', { min: 1 }, 0, {}, buildState());
    const testState = buildState(withMin);
    const result = refreshDisabledSelector('terra-aod', [0], 0, cloneDeep(withMin), testState);
    expect(result['terra-aod']).toBeDefined();
    expect(result['terra-aod'].lookup).toBeDefined();
  });

  test('returns palettes without layerId when no lookup condition is met', () => {
    const result = refreshDisabledSelector('terra-aod', [], 0, {}, buildState());
    expect(result['terra-aod']).toBeUndefined();
  });
});