Interactive interface for browsing global, full-resolution satellite imagery
import update from 'immutability-helper';
import { layerReducer, getInitialState } from './reducers';
import fixtures from '../../fixtures';
import {
ADD_LAYER,
INIT_SECOND_LAYER_GROUP,
REORDER_LAYERS,
TOGGLE_LAYER_VISIBILITY,
TOGGLE_COLLAPSE_OVERLAY_GROUP,
TOGGLE_OVERLAY_GROUP_VISIBILITY,
TOGGLE_OVERLAY_GROUPS,
REMOVE_LAYER,
UPDATE_OPACITY,
ADD_LAYERS_FOR_EVENT,
REORDER_OVERLAY_GROUPS,
REMOVE_GROUP,
SYNC_SECOND_LAYER_GROUP,
SET_FILTER_RANGE,
CLEAR_VECTORSTYLE,
ADD_GRANULE_LAYER_DATES,
UPDATE_GRANULE_LAYER_OPTIONS,
UPDATE_GRANULE_LAYER_GEOMETRY,
CHANGE_GRANULE_SATELLITE_INSTRUMENT_GROUP,
UPDATE_DDV_LAYER,
UPDATE_COLLECTION,
ADD_GRANULE_DATE_RANGES,
ADD_TEMPO_DATE_RANGES,
UPDATE_DAY_COUNT,
} from './constants';
import {
SET_VECTORSTYLE,
} from '../vector-styles/constants';
import {
SET_CUSTOM as SET_CUSTOM_PALETTE,
CLEAR_CUSTOM as CLEAR_CUSTOM_PALETTE,
SET_THRESHOLD_RANGE_SQUASH_AND_NOCLIP,
SET_DISABLED_CLASSIFICATION,
} from '../palettes/constants';
const config = fixtures.config();
const newLayer = {
id: 'modis-fires',
layergroup: 'Fires',
group: 'overlays',
};
const newGroup = {
collapsed: false,
groupName: 'Fires',
layers: ['modis-fires'],
};
const getTestLayer = (layers) => layers.find((l) => l.id === 'terra-cr');
const getTestGroup = (groups) => groups.find((g) => g.groupName === 'AOD');
describe('layer Reducer tests', () => {
let initialState;
let initialLayers;
let initialGroups;
let initialEventLayers;
beforeEach(() => {
initialState = getInitialState(config);
initialLayers = initialState.active.layers;
initialGroups = initialState.active.overlayGroups;
initialEventLayers = [];
});
test('initial state has layers and overlayGroups as expected [layers-reducer-initial-state]', () => {
expect(initialLayers.length).toEqual(3);
expect(initialLayers[0].id).toEqual('terra-aod');
expect(initialLayers[1].id).toEqual('aqua-cr');
expect(initialLayers[2].id).toEqual('terra-cr');
expect(initialState.active.groupOverlays).toEqual(true);
expect(initialState.active.overlayGroups).toEqual([
{
collapsed: false,
groupName: 'AOD',
layers: [
'terra-aod',
],
},
]);
expect(initialState.active.prevLayers.length).toEqual(0);
});
test('Common actions update active layer array and groups [layers-reducer-common-actions]', () => {
const actions = [
ADD_LAYER,
REORDER_LAYERS,
TOGGLE_OVERLAY_GROUP_VISIBILITY,
];
actions.forEach((ACTION) => {
const expectedState = update(initialState, {
active: {
layers: { $push: [newLayer] },
overlayGroups: { $push: [newGroup] },
},
});
const resultState = layerReducer(initialState, {
type: ACTION,
activeString: 'active',
layers: [...initialLayers, newLayer],
});
expect(resultState).toEqual(expectedState);
});
});
test('Remove layer and group [layers-reducer-remove-layer]', () => {
const actions = [
REMOVE_LAYER,
REMOVE_GROUP,
];
actions.forEach((ACTION) => {
const expectedState = update(initialState, {
active: {
layers: { $push: [newLayer] },
overlayGroups: { $push: [newGroup] },
},
});
const resultState = layerReducer(initialState, {
type: ACTION,
activeString: 'active',
layers: [...initialLayers, newLayer],
granuleLayers: {},
});
expect(resultState).toEqual(expectedState);
});
});
test('ADD_LAYERS_FOR_EVENT sets new groups, layers, and clears prevLayeers [layers-reducer-add-layer-for-event]', () => {
const response = layerReducer(initialState, {
type: ADD_LAYERS_FOR_EVENT,
activeString: 'active',
layers: initialLayers,
overlayGroups: initialGroups,
eventLayers: initialEventLayers,
});
expect(response.active.layers).toEqual(initialLayers);
expect(response.active.overlayGroups).toEqual(initialGroups);
expect(response.active.prevLayers).toEqual([]);
});
test('REORDER_OVERLAY_GROUPS sets new groups, layers, and clears prevLayers [layers-reducer-reorder-overlay-groups]', () => {
const response = layerReducer(initialState, {
type: REORDER_OVERLAY_GROUPS,
activeString: 'active',
layers: initialLayers,
overlayGroups: initialGroups,
eventLayers: initialEventLayers,
});
expect(response.active.layers).toEqual(initialLayers);
expect(response.active.overlayGroups).toEqual(initialGroups);
expect(response.active.prevLayers).toEqual([]);
});
test('INIT_SECOND_LAYER_GROUP copies current layer state [layers-reducer-second-layer-group]', () => {
const response = layerReducer(initialState, {
type: INIT_SECOND_LAYER_GROUP,
});
expect(initialState.activeB.layers).toEqual([]);
expect(initialState.active).toEqual(response.activeB);
});
test('SYNC_SECOND_LAYER_GROUP copies current layer state [layers-reducer-sync-second-layer-group]', () => {
const response = layerReducer(initialState, {
type: SYNC_SECOND_LAYER_GROUP,
});
expect(initialState.activeB.layers).toEqual([]);
expect(initialState.active).toEqual(response.active);
});
test('SET_FILTER_RANGE updates filter range [layers-reducer-set-filter-range]', () => {
const response = layerReducer(initialState, {
type: SET_FILTER_RANGE,
});
expect(initialState.activeB.layers).toEqual([]);
expect(initialState.active).toEqual(response.active);
});
test('CLEAR_VECTORSTYLE clears vector style [layers-reducer-clear-vectorstyle]', () => {
const response = layerReducer(initialState, {
type: CLEAR_VECTORSTYLE,
});
expect(initialState.activeB.layers).toEqual([]);
expect(initialState.active).toEqual(response.active);
});
test('TOGGLE_LAYER_VISIBILITY action toggles layer state visibility [layers-reducer-toggle-visibility]', () => {
const response = layerReducer(initialState, {
type: TOGGLE_LAYER_VISIBILITY,
id: 'terra-cr',
visible: false,
activeString: 'active',
});
expect(getTestLayer(initialLayers).visible).toBeTruthy();
expect(getTestLayer(response.active.layers).visible).toBeFalsy();
});
test('TOGGLE_COLLAPSE_OVERLAY_GROUP toggles collapsed state of group [layers-reducer-collapse-overlay-group]', () => {
const response = layerReducer(initialState, {
type: TOGGLE_COLLAPSE_OVERLAY_GROUP,
groupName: 'AOD',
activeString: 'active',
collapsed: true,
});
expect(getTestGroup(initialGroups).collapsed).toBeFalsy();
expect(getTestGroup(response.active.overlayGroups)).toBeTruthy();
});
test('TOGGLE_OVERLAY_GROUPS ungroups layers when grouped [layers-reducer-ungroup-layers]', () => {
const mockLayers = ['layer1', 'layer2', 'layer3'];
const response = layerReducer(initialState, {
type: TOGGLE_OVERLAY_GROUPS,
activeString: 'active',
groupOverlays: false,
layers: mockLayers,
overlayGroups: [],
});
expect(response.active.groupOverlays).toBeFalsy();
expect(response.active.overlayGroups).toEqual([]);
expect(response.active.layers).toEqual(mockLayers);
expect(response.active.prevLayers).toEqual(undefined);
});
test('TOGGLE_OVERLAY_GROUPS groups layers when ungrouped [layers-reducer-group-layers]', () => {
const response = layerReducer(initialState, {
type: TOGGLE_OVERLAY_GROUPS,
activeString: 'active',
groupOverlays: true,
layers: initialLayers,
overlayGroups: initialGroups,
prevLayers: initialLayers,
});
expect(response.active.groupOverlays).toBeTruthy();
expect(response.active.layers).toEqual(initialLayers);
expect(response.active.overlayGroups).toEqual(initialGroups);
expect(response.active.prevLayers).toEqual(initialLayers);
});
test('SET_THRESHOLD_RANGE_SQUASH_AND_NOCLIP action updates palette-related props [layers-reducer-update-palettes]', () => {
const response = layerReducer(initialState, {
type: SET_THRESHOLD_RANGE_SQUASH_AND_NOCLIP,
props: { squash: true, noclip: true, min: 0.3 },
id: 'terra-cr',
activeString: 'active',
});
const responseLayer = getTestLayer(response.active.layers);
expect(getTestLayer(initialLayers).squash).toEqual(undefined);
expect(getTestLayer(initialLayers).noclip).toEqual(undefined);
expect(responseLayer.squash).toBeTruthy();
expect(responseLayer.noclip).toBeTruthy();
expect(responseLayer.min).toEqual(0.3);
});
test('CLEAR_CUSTOM_PALETTE action removed custom value [layers-reducer-clear-custom-palette]', () => {
const customInitial = update(initialState, {
active: {
layers: {
2: { custom: { $set: 'custom-id' } },
},
},
});
const response = layerReducer(customInitial, {
type: CLEAR_CUSTOM_PALETTE,
id: 'terra-cr',
activeString: 'active',
});
expect(getTestLayer(customInitial.active.layers).custom).toEqual('custom-id');
expect(getTestLayer(response.active.layers).custom).toEqual(undefined);
});
test('SET_CUSTOM_PALETTE action removed custom value [layers-reducer-set-custom-palette]', () => {
const response = layerReducer(initialState, {
type: SET_CUSTOM_PALETTE,
id: 'terra-cr',
activeString: 'active',
paletteId: 'custom-id',
});
expect(getTestLayer(initialLayers).custom).toEqual(undefined);
expect(getTestLayer(response.active.layers).custom).toEqual(['custom-id']);
});
test('UPDATE_OPACITY action updates opacity for given layer [layers-reducer-update-opacity]', () => {
const response = layerReducer(initialState, {
type: UPDATE_OPACITY,
activeString: 'active',
opacity: 0.4,
id: 'terra-cr',
});
expect(getTestLayer(response.active.layers).opacity).toEqual(0.4);
});
test('UPDATE_DAY_COUNT action updates dayCount for given layer [layers-reducer-update-day-count]', () => {
const response = layerReducer(initialState, {
type: UPDATE_DAY_COUNT,
activeString: 'active',
dayCount: 5,
id: 'terra-cr',
});
expect(getTestLayer(response.active.layers).dayCount).toEqual(5);
});
test('UPDATE_DAY_COUNT returns unchanged state when layer id not found [layers-reducer-update-day-count-not-found]', () => {
const response = layerReducer(initialState, {
type: UPDATE_DAY_COUNT,
activeString: 'active',
dayCount: 5,
id: 'non-existent-layer',
});
expect(response).toEqual(initialState);
});
test('TOGGLE_LAYER_VISIBILITY returns unchanged state when layer id not found [layers-reducer-toggle-visibility-not-found]', () => {
const response = layerReducer(initialState, {
type: TOGGLE_LAYER_VISIBILITY,
id: 'non-existent-layer',
visible: false,
activeString: 'active',
});
expect(response).toEqual(initialState);
});
test('TOGGLE_COLLAPSE_OVERLAY_GROUP returns unchanged state when group not found [layers-reducer-collapse-group-not-found]', () => {
const response = layerReducer(initialState, {
type: TOGGLE_COLLAPSE_OVERLAY_GROUP,
groupName: 'NonExistentGroup',
activeString: 'active',
collapsed: true,
});
expect(response).toEqual(initialState);
});
test('SYNC_SECOND_LAYER_GROUP adds new A layers not present in B [layers-reducer-sync-second-layer-group-adds-layers]', () => {
const stateWithB = {
...initialState,
activeB: {
...initialState.activeB,
layers: [initialLayers[0]],
},
};
const response = layerReducer(stateWithB, {
type: SYNC_SECOND_LAYER_GROUP,
lastExitALayerIds: [],
});
expect(response.activeB.layers.length).toEqual(3);
expect(response.activeB.layers.map((l) => l.id)).toContain('aqua-cr');
expect(response.activeB.layers.map((l) => l.id)).toContain('terra-cr');
});
test('SYNC_SECOND_LAYER_GROUP does not re-add layers that were in lastExitALayerIds [layers-reducer-sync-second-layer-group-respects-last-exit]', () => {
const stateWithB = {
...initialState,
activeB: {
...initialState.activeB,
layers: [initialLayers[0]],
},
};
const response = layerReducer(stateWithB, {
type: SYNC_SECOND_LAYER_GROUP,
lastExitALayerIds: ['aqua-cr'],
});
const bIds = response.activeB.layers.map((l) => l.id);
expect(bIds).not.toContain('aqua-cr');
expect(bIds).toContain('terra-cr');
});
test('SYNC_SECOND_LAYER_GROUP removes layers that were removed from A while compare was off [layers-reducer-sync-second-layer-group-removes-layers]', () => {
const removedLayer = { id: 'granule-cr', group: 'overlays', layergroup: 'Granules' };
const stateWithB = {
...initialState,
activeB: {
...initialState.activeB,
layers: [removedLayer, ...initialLayers],
granuleLayers: { 'granule-cr': { count: 10 } },
},
};
const response = layerReducer(stateWithB, {
type: SYNC_SECOND_LAYER_GROUP,
lastExitALayerIds: ['granule-cr', 'aqua-cr', 'terra-cr'],
});
expect(response.activeB.layers.map((l) => l.id)).not.toContain('granule-cr');
expect(response.activeB.granuleLayers).toEqual({});
expect(response.activeB.overlayGroups.map((g) => g.groupName)).not.toContain('Granules');
});
test('SYNC_SECOND_LAYER_GROUP keeps layers added to B during compare [layers-reducer-sync-second-layer-group-keeps-b-layers]', () => {
const bOnlyLayer = { id: 'b-only', group: 'overlays', layergroup: 'Other' };
const stateWithB = {
...initialState,
activeB: {
...initialState.activeB,
layers: [bOnlyLayer, ...initialLayers],
},
};
const response = layerReducer(stateWithB, {
type: SYNC_SECOND_LAYER_GROUP,
lastExitALayerIds: ['aqua-cr', 'terra-cr'],
});
expect(response.activeB.layers.map((l) => l.id)).toContain('b-only');
});
test('ADD_LAYERS_FOR_EVENT sets eventLayers when provided [layers-reducer-add-layer-for-event-with-event-layers]', () => {
const mockEventLayers = ['layer-event-1'];
const response = layerReducer(initialState, {
type: ADD_LAYERS_FOR_EVENT,
activeString: 'active',
layers: initialLayers,
overlayGroups: initialGroups,
eventLayers: mockEventLayers,
});
expect(response.eventLayers).toEqual(mockEventLayers);
});
test('REORDER_OVERLAY_GROUPS with undefined eventLayers pushes nothing to eventLayers [layers-reducer-reorder-overlay-groups-no-event-layers]', () => {
const response = layerReducer(initialState, {
type: REORDER_OVERLAY_GROUPS,
activeString: 'active',
layers: initialLayers,
overlayGroups: initialGroups,
});
expect(response.eventLayers).toEqual([]);
});
test('SET_VECTORSTYLE sets custom vectorStyleId on the layer [layers-reducer-set-vectorstyle]', () => {
const response = layerReducer(initialState, {
type: SET_VECTORSTYLE,
id: 'terra-cr',
activeString: 'active',
vectorStyleId: 'my-vector-style',
});
expect(getTestLayer(response.active.layers).custom).toEqual('my-vector-style');
});
test('CLEAR_VECTORSTYLE clears custom on a layer [layers-reducer-clear-vectorstyle-layer]', () => {
const stateWithCustom = update(initialState, {
active: {
layers: {
2: { custom: { $set: 'some-style' } },
},
},
});
const response = layerReducer(stateWithCustom, {
type: CLEAR_VECTORSTYLE,
id: 'terra-cr',
activeString: 'active',
});
expect(getTestLayer(response.active.layers).custom).toEqual('some-style');
});
test('SET_DISABLED_CLASSIFICATION merges props onto the target layer [layers-reducer-set-disabled-classification]', () => {
const response = layerReducer(initialState, {
type: SET_DISABLED_CLASSIFICATION,
id: 'terra-cr',
activeString: 'active',
props: { disabledClassification: [0, 1] },
});
expect(getTestLayer(response.active.layers).disabledClassification).toEqual([0, 1]);
});
test('SET_DISABLED_CLASSIFICATION returns unchanged state when layer not found [layers-reducer-set-disabled-classification-not-found]', () => {
const response = layerReducer(initialState, {
type: SET_DISABLED_CLASSIFICATION,
id: 'non-existent-layer',
activeString: 'active',
props: { disabledClassification: [0] },
});
expect(response).toEqual(initialState);
});
test('CLEAR_CUSTOM_PALETTE returns unchanged state when layer not found [layers-reducer-clear-custom-palette-not-found]', () => {
const response = layerReducer(initialState, {
type: 'CLEAR_CUSTOM',
id: 'non-existent-layer',
activeString: 'active',
});
expect(response).toEqual(initialState);
});
test('SET_THRESHOLD_RANGE_SQUASH_AND_NOCLIP returns unchanged state when layer not found [layers-reducer-update-palettes-not-found]', () => {
const response = layerReducer(initialState, {
type: SET_THRESHOLD_RANGE_SQUASH_AND_NOCLIP,
id: 'non-existent-layer',
activeString: 'active',
props: { squash: true },
});
expect(response).toEqual(initialState);
});
test('ADD_GRANULE_LAYER_DATES adds granule layer entry to active state [layers-reducer-add-granule-layer-dates]', () => {
const granuleDates = ['2021-01-01', '2021-01-02'];
const granuleFootprints = { type: 'FeatureCollection', features: [] };
const response = layerReducer(initialState, {
type: ADD_GRANULE_LAYER_DATES,
id: 'terra-cr',
activeKey: 'active',
dates: granuleDates,
granuleFootprints,
granulePlatform: 'Terra',
count: 2,
});
expect(response.active.granuleLayers['terra-cr']).toBeDefined();
expect(response.active.granuleLayers['terra-cr'].dates).toEqual(granuleDates);
expect(response.active.granuleLayers['terra-cr'].granulePlatform).toEqual('Terra');
expect(response.active.granuleLayers['terra-cr'].count).toEqual(2);
expect(response.active.granuleFootprints).toEqual(granuleFootprints);
expect(response.active.granulePlatform).toEqual('Terra');
});
test('UPDATE_GRANULE_LAYER_OPTIONS merges count and dates into existing granule layer [layers-reducer-update-granule-layer-options]', () => {
const initialWithGranule = update(initialState, {
active: {
granuleLayers: {
$merge: {
'terra-cr': { dates: [], count: 0, granuleFootprints: {}, granulePlatform: 'Terra' },
},
},
},
});
const newDates = ['2022-05-01'];
const response = layerReducer(initialWithGranule, {
type: UPDATE_GRANULE_LAYER_OPTIONS,
id: 'terra-cr',
activeKey: 'active',
count: 5,
dates: newDates,
});
expect(response.active.granuleLayers['terra-cr'].count).toEqual(5);
expect(response.active.granuleLayers['terra-cr'].dates).toEqual(newDates);
});
test('UPDATE_GRANULE_LAYER_OPTIONS creates the granule layer entry when missing [layers-reducer-update-granule-layer-options-missing]', () => {
const response = layerReducer(initialState, {
type: UPDATE_GRANULE_LAYER_OPTIONS,
id: 'terra-cr',
activeKey: 'active',
count: 12,
dates: null,
});
expect(response.active.granuleLayers['terra-cr'].count).toEqual(12);
});
test('UPDATE_GRANULE_LAYER_OPTIONS keeps existing dates when none are passed [layers-reducer-update-granule-layer-options-keep-dates]', () => {
const dates = ['2022-05-01'];
const initialWithGranule = update(initialState, {
active: {
granuleLayers: {
$merge: { 'terra-cr': { dates, count: 10 } },
},
},
});
const response = layerReducer(initialWithGranule, {
type: UPDATE_GRANULE_LAYER_OPTIONS,
id: 'terra-cr',
activeKey: 'active',
count: 3,
dates: null,
});
expect(response.active.granuleLayers['terra-cr']).toEqual({ dates, count: 3 });
});
test('UPDATE_GRANULE_LAYER_GEOMETRY updates geometry and footprints for granule layer [layers-reducer-update-granule-layer-geometry]', () => {
const initialWithGranule = update(initialState, {
active: {
granuleLayers: {
$merge: {
'terra-cr': { dates: [], count: 0, granuleFootprints: {}, granulePlatform: 'Terra' },
},
},
},
});
const newFootprints = { type: 'FeatureCollection', features: [{ id: 1 }] };
const newDates = ['2022-06-01'];
const response = layerReducer(initialWithGranule, {
type: UPDATE_GRANULE_LAYER_GEOMETRY,
id: 'terra-cr',
activeKey: 'active',
dates: newDates,
granuleFootprints: newFootprints,
count: 3,
});
expect(response.active.granuleLayers['terra-cr'].granuleFootprints).toEqual(newFootprints);
expect(response.active.granuleLayers['terra-cr'].count).toEqual(3);
expect(response.active.granuleFootprints).toEqual(newFootprints);
});
test('CHANGE_GRANULE_SATELLITE_INSTRUMENT_GROUP sets granulePlatform and geometry [layers-reducer-change-granule-satellite]', () => {
const geometry = { type: 'FeatureCollection', features: [] };
const response = layerReducer(initialState, {
type: CHANGE_GRANULE_SATELLITE_INSTRUMENT_GROUP,
activeKey: 'active',
granulePlatform: 'Aqua',
geometry,
});
expect(response.active.granulePlatform).toEqual('Aqua');
expect(response.active.granuleFootprints).toEqual(geometry);
});
test('ADD_GRANULE_DATE_RANGES sets granuleDateRanges on the target layer [layers-reducer-add-granule-date-ranges]', () => {
const dateRanges = [{ startDate: '2020-01-01', endDate: '2020-12-31' }];
const response = layerReducer(initialState, {
type: ADD_GRANULE_DATE_RANGES,
id: 'terra-cr',
activeString: 'active',
granuleDateRanges: dateRanges,
});
expect(getTestLayer(response.active.layers).granuleDateRanges).toEqual(dateRanges);
});
test('ADD_GRANULE_DATE_RANGES returns unchanged state when layer not found [layers-reducer-add-granule-date-ranges-not-found]', () => {
const response = layerReducer(initialState, {
type: ADD_GRANULE_DATE_RANGES,
id: 'non-existent-layer',
activeString: 'active',
granuleDateRanges: [],
});
expect(response).toEqual(initialState);
});
test('ADD_TEMPO_DATE_RANGES sets tempoDateRanges on the target layer [layers-reducer-add-tempo-date-ranges]', () => {
const tempoRanges = [{ startDate: '2023-01-01', endDate: '2023-06-30' }];
const response = layerReducer(initialState, {
type: ADD_TEMPO_DATE_RANGES,
id: 'terra-cr',
activeString: 'active',
tempoDateRanges: tempoRanges,
});
expect(getTestLayer(response.active.layers).tempoDateRanges).toEqual(tempoRanges);
});
test('ADD_TEMPO_DATE_RANGES returns unchanged state when layer not found [layers-reducer-add-tempo-date-ranges-not-found]', () => {
const response = layerReducer(initialState, {
type: ADD_TEMPO_DATE_RANGES,
id: 'non-existent-layer',
activeString: 'active',
tempoDateRanges: [],
});
expect(response).toEqual(initialState);
});
test('UPDATE_COLLECTION initializes a new collection entry when id does not exist [layers-reducer-update-collection-new]', () => {
const payload = [{
id: 'new-collection-layer',
date: '2021-01-01',
type: 'cmr',
version: '006',
projection: 'geographic',
}];
const response = layerReducer(initialState, {
type: UPDATE_COLLECTION,
payload,
});
expect(response.collections['new-collection-layer']).toBeDefined();
expect(response.collections['new-collection-layer'].dates).toHaveLength(1);
expect(response.collections['new-collection-layer'].dates[0].version).toEqual('006');
});
test('UPDATE_COLLECTION pushes a new date entry when collection id already exists [layers-reducer-update-collection-existing]', () => {
const stateWithCollection = update(initialState, {
collections: {
$merge: {
'existing-collection': {
dates: [{ date: '2020-01-01', type: 'cmr', version: '005', projection: 'geographic' }],
},
},
},
});
const payload = [{
id: 'existing-collection',
date: '2021-06-01',
type: 'cmr',
version: '006',
projection: 'geographic',
}];
const response = layerReducer(stateWithCollection, {
type: UPDATE_COLLECTION,
payload,
});
expect(response.collections['existing-collection'].dates).toHaveLength(2);
expect(response.collections['existing-collection'].dates[1].date).toEqual('2021-06-01');
});
test('UPDATE_DDV_LAYER moves the target layer to the specified index [layers-reducer-update-ddv-layer]', () => {
const layersCopy = initialLayers.map((l) => ({ ...l }));
const response = layerReducer(initialState, {
type: UPDATE_DDV_LAYER,
activeString: 'active',
id: 'terra-cr',
layerIndex: 0,
layers: layersCopy,
});
expect(response.active.layers[0].id).toEqual('terra-cr');
});
test('unknown action type returns unchanged state [layers-reducer-default]', () => {
const response = layerReducer(initialState, {
type: 'UNKNOWN_ACTION_TYPE',
});
expect(response).toEqual(initialState);
});
});