Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project
/* eslint-disable max-statements */
import {
drainTasksForTesting,
errorTaskInTest,
succeedTaskInTest,
succeedTaskWithValues
} from '@kepler.gl/tasks';
import test from 'tape';
import {
appendStagedLoadedFiles,
confirmReplaceDataset,
loadFilesSuccess,
registerEntry,
setColumnDisplayFormat,
stageLoadedFiles,
wrapTo
} from '@kepler.gl/actions';
import {processCsvData, processKeplerglJSON} from '@kepler.gl/processors';
import keplerGlReducer, {
addDataToMapUpdater,
replaceDataInMapUpdater,
combinedUpdaters,
fitBoundsUpdater,
INITIAL_UI_STATE,
visStateReducer,
mapStateReducer,
layerConfigChangeUpdater,
refreshDatasetUpdater,
removeDatasetUpdater,
setFilterUpdater,
setLoadingProgressUpdater
} from '@kepler.gl/reducers';
import {DatasetType, MapSplitMode} from '@kepler.gl/constants';
import {KeplerGlLayers} from '@kepler.gl/layers';
import KeplerGlSchema from '@kepler.gl/schemas';
import {KeplerTable, copyTableAndUpdate, sortDatasetByColumn} from '@kepler.gl/table';
import {getTimeBins, getMapJSON, exportToJsonString} from '@kepler.gl/utils';
import testCsvData, {sampleConfig, dataWithNulls} from 'test/fixtures/test-csv-data';
import testHexIdData, {
hexIdDataConfig,
mergedH3Layer,
mergedFilters,
expectedMergedDataset
} from 'test/fixtures/test-hex-id-data';
import {cmpLayers, cmpFilters, cmpDataset, cmpInteraction} from 'test/helpers/comparison-utils';
import {applyExistingDatasetTasks} from 'test/helpers/mock-state';
import {StateWSyncedTimeFilter} from '../../helpers/mock-state';
import {testCsvDataSlice1Id, testCsvDataSlice2Id} from '../../fixtures/test-csv-data';
const mockRawData = {
fields: [
{
name: 'start_point_lat',
id: 'start_point_lat',
displayName: 'start_point_lat',
type: 'real',
fieldIdx: 0
},
{
name: 'start_point_lng',
id: 'start_point_lng',
displayName: 'start_point_lng',
type: 'real',
fieldIdx: 2
},
{
name: 'end_point_lat',
id: 'end_point_lat',
displayName: 'end_point_lat',
type: 'real',
fieldIdx: 3
},
{
name: 'end_point_lng',
id: 'end_point_lng',
displayName: 'end_point_lng',
type: 'real',
fieldIdx: 4
}
],
rows: [
[12.25, 37.75, 45.21, 100.12],
[null, 35.2, 45.0, 21.3],
[12.29, 37.64, 46.21, 99.127],
[null, null, 33.1, 29.34]
]
};
test('#composerStateReducer - addDataToMapUpdater: mapStyle', t => {
// init kepler.gl root and instance
const state = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const newState = addDataToMapUpdater(state, {
payload: {
datasets: {
data: mockRawData,
info: {
id: 'foo'
}
},
options: null,
config: {
mapStyle: {
styleType: 'light'
}
}
}
});
drainTasksForTesting();
t.equal(newState.mapStyle.styleType, 'light', 'Map style is set correctly');
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: mapState should be centered (after dataset tasts are completed)', t => {
// init kepler.gl root and instance
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
const mapStateProperties = {
latitude: 33.88608913680742,
longitude: -84.43459130456425
};
let newState = addDataToMapUpdater(state, {
payload: {
datasets: {
data: mockRawData,
info: {
id: 'foo'
}
},
options: {
centerMap: true
},
config: {
mapState: mapStateProperties
}
}
});
// create datasets from existing tasks, trigger auto create layers
newState.visState = applyExistingDatasetTasks(visStateReducer, newState.visState);
// layers should generate a fit bounds task
const tasks = drainTasksForTesting();
t.equal(tasks.length, 1, 'Should create one fit bounds task');
newState.mapState = mapStateReducer(newState.mapState, succeedTaskWithValues(tasks[0], {}));
t.equal(newState.mapState.latitude, 29.23, 'centerMap: true should override mapState config');
t.equal(newState.mapState.longitude, 60.71, 'centerMap: true should override mapState config');
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: centerMap padding', t => {
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
const datasets = {
data: mockRawData,
info: {
id: 'foo'
}
};
const fitMapAfterAdd = options => {
let nextState = addDataToMapUpdater(state, {
payload: {
datasets,
options
}
});
nextState.visState = applyExistingDatasetTasks(visStateReducer, nextState.visState);
const tasks = drainTasksForTesting();
nextState.mapState = mapStateReducer(nextState.mapState, succeedTaskWithValues(tasks[0], {}));
drainTasksForTesting();
return nextState;
};
const unpadded = fitMapAfterAdd({centerMap: true});
const padded = fitMapAfterAdd({centerMap: true, padding: {left: 300}});
t.ok(
padded.mapState.zoom < unpadded.mapState.zoom,
'padding should zoom out relative to unpadded centerMap'
);
t.ok(
padded.mapState.longitude < unpadded.mapState.longitude,
'left padding should pan west so points are not hidden under the side panel'
);
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: uiState', t => {
// init kepler.gl root and instance
const state = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const newState = addDataToMapUpdater(state, {
payload: {
datasets: {
data: mockRawData,
info: {
id: 'foo'
}
}
}
});
drainTasksForTesting();
const expectedUIState = {
...INITIAL_UI_STATE,
initialState: {},
readOnly: false,
currentModal: null
};
t.deepEqual(
newState.uiState,
expectedUIState,
'ui state should be set readOnly:false,currentModal: null'
);
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: mapLegend', t => {
const state = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
t.equal(
state.uiState.mapControls.mapLegend.active,
false,
'mapLegend should be inactive by default'
);
const newState = addDataToMapUpdater(state, {
payload: {
datasets: {
data: mockRawData,
info: {id: 'foo'}
},
config: {
uiState: {
mapControls: {
mapLegend: {
active: true,
settings: {
position: {x: 20, y: 40, anchorX: 'left', anchorY: 'top'},
contentHeight: 150
}
}
}
}
}
}
});
drainTasksForTesting();
t.equal(
newState.uiState.mapControls.mapLegend.active,
true,
'mapLegend should be set to active from config'
);
t.deepEqual(
newState.uiState.mapControls.mapLegend.settings.position,
{x: 20, y: 40, anchorX: 'left', anchorY: 'top'},
'mapLegend settings position should be set from config'
);
t.equal(
newState.uiState.mapControls.mapLegend.settings.contentHeight,
150,
'mapLegend settings contentHeight should be set from config'
);
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: mapInfo', t => {
const state = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
t.equal(state.uiState.mapControls.mapInfo.active, true, 'map info panel starts open');
t.equal(state.visState.mapInfo.title, undefined, 'map title starts unset');
t.equal(state.visState.mapInfo.description, undefined, 'map description starts unset');
const withInfo = addDataToMapUpdater(state, {
payload: {
datasets: {
data: mockRawData,
info: {id: 'foo'}
},
info: {title: 'Harbor', description: 'Ferry routes'}
}
});
drainTasksForTesting();
t.equal(withInfo.visState.mapInfo.title, 'Harbor', 'loaded map title is restored');
t.equal(
withInfo.visState.mapInfo.description,
'Ferry routes',
'loaded map description is restored'
);
t.equal(withInfo.uiState.mapControls.mapInfo.active, true, 'panel stays open when title loads');
const collapsed = addDataToMapUpdater(state, {
payload: {
datasets: {
data: mockRawData,
info: {id: 'foo'}
},
info: {title: 'Harbor', description: ''},
config: {
uiState: {
mapControls: {
mapInfo: {active: false}
}
}
}
}
});
drainTasksForTesting();
t.equal(collapsed.visState.mapInfo.title, 'Harbor', 'collapsed map still restores its title');
t.equal(collapsed.visState.mapInfo.description, undefined, 'a blank description stays unset');
t.equal(
collapsed.uiState.mapControls.mapInfo.active,
false,
'saved collapsed map info panel stays closed'
);
const hidden = addDataToMapUpdater(state, {
payload: {
datasets: {
data: mockRawData,
info: {id: 'foo'}
},
info: {title: 'Harbor', description: 'Ferry routes'},
config: {
uiState: {
mapControls: {
mapInfo: {show: false, active: true}
}
}
}
}
});
drainTasksForTesting();
t.equal(hidden.visState.mapInfo.title, 'Harbor', 'a hidden map still restores its title');
t.equal(
hidden.uiState.mapControls.mapInfo.show,
false,
'saved hidden map info stays off the map'
);
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: locale', t => {
const state = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
t.equal(state.uiState.locale, 'en', 'locale should be en by default');
const newState = addDataToMapUpdater(state, {
payload: {
datasets: {
data: mockRawData,
info: {id: 'foo'}
},
config: {
uiState: {
locale: 'es'
}
}
}
});
drainTasksForTesting();
t.equal(newState.uiState.locale, 'es', 'locale should be set to es from config');
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: keepExistingConfig', t => {
const data = processCsvData(testCsvData);
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
// old state contain splitMaps
let oldState = addDataToMapUpdater(state, {
payload: {
datasets: {
data,
info: {
id: sampleConfig.dataId
}
},
config: sampleConfig.config
}
});
// create datasets from existing tasks, trigger auto create layers
oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
const {
layers: oldLayers,
filters: oldFilters,
datasets: oldDatasets,
interactionConfig: oldInteractionConfig,
splitMaps: oldSplitMaps
} = oldState.visState;
const hexData = processCsvData(testHexIdData);
const hexDataId = hexIdDataConfig.dataId;
// keepExistingConfig is not defined, default to false
let nextState1 = addDataToMapUpdater(oldState, {
payload: {
datasets: {
data: hexData,
info: {
id: hexDataId
}
},
config: hexIdDataConfig.config
}
});
// create datasets from existing tasks, trigger auto create layers
nextState1 = {
...nextState1,
visState: applyExistingDatasetTasks(visStateReducer, nextState1.visState)
};
t.deepEqual(nextState1.visState.layerOrder, ['avlgol'], 'Should contain nextState1 layer order');
cmpDataset(t, expectedMergedDataset, nextState1.visState.datasets[hexDataId]);
t.deepEqual(nextState1.visState.splitMaps, [], 'should clear out splitMaps');
cmpLayers(t, [mergedH3Layer], nextState1.visState.layers);
cmpFilters(t, mergedFilters, nextState1.visState.filters);
// add data and config keep existing data and config
let nextState2 = addDataToMapUpdater(oldState, {
payload: {
datasets: {
data: hexData,
info: {
id: hexDataId
}
},
config: hexIdDataConfig.config,
options: {
keepExistingConfig: true
}
}
});
// create datasets from existing tasks, trigger auto create layers
nextState2 = {
...nextState2,
visState: applyExistingDatasetTasks(visStateReducer, nextState2.visState)
};
const actualVisState = nextState2.visState;
const newLayers = [...oldLayers, mergedH3Layer];
const expectedVisState = {
layers: newLayers,
filters: [...oldFilters, ...mergedFilters],
datasets: 'test seperate',
interactionConfig: {
...oldInteractionConfig,
tooltip: {
...oldInteractionConfig.tooltip,
config: {
timezone: null,
compareMode: false,
compareType: 'absolute',
fieldsToShow: {
...oldInteractionConfig.tooltip.config.fieldsToShow,
[hexDataId]: [
{
name: 'hex_id',
format: null
},
{
name: 'value',
format: null
}
]
}
}
}
},
splitMaps: [
{
layers: {
...oldSplitMaps[0].layers,
avlgol: true
}
},
{
layers: {
...oldSplitMaps[1].layers,
avlgol: true
}
}
],
layerOrder: [newLayers[2].id, newLayers[0].id, newLayers[1].id]
};
cmpLayers(t, expectedVisState.layers, actualVisState.layers);
cmpFilters(t, expectedVisState.filters, actualVisState.filters);
// test datasets
t.deepEqual(
Object.keys(actualVisState.datasets),
[sampleConfig.dataId, hexDataId],
'should save 2 datasets to state'
);
t.equal(
actualVisState.datasets[sampleConfig.dataId],
oldDatasets[sampleConfig.dataId],
'should keep oldDataset same'
);
cmpDataset(
t,
expectedMergedDataset,
actualVisState.datasets[hexDataId],
'should merge and filter hexdata'
);
cmpInteraction(t, expectedVisState.interactionConfig, actualVisState.interactionConfig);
t.deepEqual(
expectedVisState.layerOrder,
actualVisState.layerOrder,
'Should create new layer, move it to the top'
);
t.deepEqual(
expectedVisState.splitMaps,
actualVisState.splitMaps,
'Should keep existing splitMaps, add new layers to splitMaps'
);
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: readOnly', t => {
const datasets = {
data: processCsvData(testCsvData),
info: {
id: sampleConfig.dataId
}
};
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
// old state contain splitMaps
const nextState = addDataToMapUpdater(state, {
payload: {
datasets,
options: {
readOnly: true
}
}
});
t.equal(nextState.uiState.readOnly, true, 'should set readonly to be true');
const nextState1 = addDataToMapUpdater(state, {
payload: {
datasets
}
});
t.equal(nextState1.uiState.readOnly, false, 'should set readonly to be false');
const nextState2 = addDataToMapUpdater(state, {
payload: {
datasets,
options: {
readOnly: false
}
}
});
t.equal(nextState2.uiState.readOnly, false, 'should set readonly to be false');
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: autoCreateLayers', t => {
const datasets = {
data: processCsvData(testCsvData),
info: {
id: sampleConfig.dataId
}
};
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
// old state contain splitMaps
const nextState = addDataToMapUpdater(state, {
payload: {
datasets,
options: {
autoCreateLayers: false
}
}
});
t.equal(nextState.visState.layers.length, 0, 'should not create layers');
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: layerVisConfig only affects new datasets; unknown keys ignored', t => {
const data = processCsvData(testCsvData);
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
let oldState = addDataToMapUpdater(state, {
payload: {
datasets: {
data,
info: {id: 'first-csv-dataset'}
}
}
});
oldState = {
...oldState,
visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)
};
drainTasksForTesting();
const firstLayer = oldState.visState.layers.find(l => l.config.dataId === 'first-csv-dataset');
t.ok(firstLayer, 'first dataset should have a layer');
const allowHoverFirstBefore = firstLayer.config.visConfig.allowHover;
let nextState = addDataToMapUpdater(oldState, {
payload: {
datasets: {
data,
info: {id: 'second-csv-dataset'}
},
options: {
keepExistingConfig: true,
layerVisConfig: {
allowHover: false,
opacity: undefined,
totallyUnknownVisKey999: 'strip-me'
}
}
}
});
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
drainTasksForTesting();
const layerFirst = nextState.visState.layers.find(l => l.config.dataId === 'first-csv-dataset');
const layerSecond = nextState.visState.layers.find(l => l.config.dataId === 'second-csv-dataset');
t.ok(layerSecond, 'second dataset should have a layer');
t.equal(
layerFirst.config.visConfig.allowHover,
allowHoverFirstBefore,
'layerVisConfig must not change visConfig for layers tied to prior datasets'
);
t.equal(
layerSecond.config.visConfig.allowHover,
false,
'layerVisConfig should merge allowHover onto layers for datasets added in this action'
);
t.equal(
layerFirst.config.visConfig.totallyUnknownVisKey999,
undefined,
'unknown keys must not be applied to existing layers'
);
t.equal(
layerSecond.config.visConfig.totallyUnknownVisKey999,
undefined,
'unknown keys must not be merged into visConfig when absent from visConfigSettings'
);
t.ok(
typeof layerSecond.config.visConfig.opacity === 'number',
'undefined patch values must not overwrite visConfig (e.g. opacity)'
);
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater', t => {
const dataIdToReplace = 'dataset_to_replace';
const datasets = {
data: processCsvData(testCsvData),
info: {
id: sampleConfig.dataId
}
};
const datasetToUse = {
data: processCsvData(dataWithNulls),
info: {
id: dataIdToReplace
}
};
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
// old state contain splitMaps
let oldState = addDataToMapUpdater(state, {
payload: {
datasets,
config: sampleConfig.config
}
});
// create datasets from existing tasks, trigger auto create layers
oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
const oldSavedConfig = state.visState.schema.getConfigToSave(oldState).config;
let nextState = replaceDataInMapUpdater(oldState, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse
}
});
// create datasets from existing tasks, trigger auto create layers
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
// layers should generate a fit bounds task
const tasks = drainTasksForTesting();
t.equal(tasks.length, 1, 'Should create one fit bounds task');
nextState = {
...nextState,
mapState: mapStateReducer(nextState.mapState, succeedTaskWithValues(tasks[0], {}))
};
const nextSavedConfig = nextState.visState.schema.getConfigToSave(nextState).config;
const expectedLayers = oldSavedConfig.visState.layers.map(l => ({
...l,
config: {
...l.config,
dataId: dataIdToReplace
}
}));
const bounds = nextState.visState.layers[0].meta.bounds;
const expectedMapState = fitBoundsUpdater(oldState.mapState, {payload: bounds});
const expectedInteractionConfig = {
...oldSavedConfig.visState.interactionConfig,
tooltip: {
...oldSavedConfig.visState.interactionConfig.tooltip,
fieldsToShow: {
[dataIdToReplace]:
oldSavedConfig.visState.interactionConfig.tooltip.fieldsToShow[sampleConfig.dataId]
}
}
};
// dataWithNulls gps_data.utc_timestamp domain
const expectedFilterDomain = [1474071056000, 1474071677000];
const expectedFilter = {
...oldSavedConfig.visState.filters[0],
dataId: [dataIdToReplace],
// reset vaue to bonded by domain
value: expectedFilterDomain
};
t.deepEqual(
nextState.visState.filters[0].domain,
expectedFilterDomain,
'Should set corect filter domain'
);
// compare replaced state with old state
Object.keys(oldSavedConfig).forEach(key => {
if (key === 'mapState') {
// should center map
t.deepEqual(nextState.mapState, expectedMapState, 'should center map to new layer;');
} else if (key === 'visState') {
Object.keys(oldSavedConfig.visState).forEach(prop => {
if (prop === 'layers') {
t.deepEqual(
nextSavedConfig.visState.layers,
expectedLayers,
'should replace layer dataId'
);
} else if (prop === 'filters') {
t.deepEqual(
nextSavedConfig.visState.filters,
[expectedFilter],
'should replace filter dataId and reset value'
);
} else if (prop === 'interactionConfig') {
t.deepEqual(
nextSavedConfig.visState.interactionConfig,
expectedInteractionConfig,
'should replace interactionConfig dataId'
);
} else {
t.deepEqual(
nextSavedConfig.visState[prop],
oldSavedConfig.visState[prop],
`visState.${prop} should not change`
);
}
});
} else {
// mapStyle
t.deepEqual(nextSavedConfig[key], oldSavedConfig[key], 'mapStyle should not change');
}
});
t.deepEqual(nextState.visState.layerToBeMerged, [], 'should reset layerToBeMerged');
t.deepEqual(nextState.visState.filterToBeMerged, [], 'should reset filterToBeMerged');
t.deepEqual(nextState.visState.interactionToBeMerged, {}, 'should reset interactionToBeMerged');
t.deepEqual(nextState.visState.splitMapsToBeMerged, [], 'should reset splitMapsToBeMerged');
t.end();
});
test('#composerStateReducer - failed remote replacement retains the current map', t => {
const initial = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
let original = addDataToMapUpdater(initial, {
payload: {
datasets: {info: {id: sampleConfig.dataId}, data: processCsvData(testCsvData)},
config: sampleConfig.config
}
});
original = {...original, visState: applyExistingDatasetTasks(visStateReducer, original.visState)};
drainTasksForTesting();
const before = original.visState.schema.getConfigToSave(original);
const pending = replaceDataInMapUpdater(original, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse: {
info: {id: 'remote', type: DatasetType.EXTERNALLY_HOSTED},
metadata: {source: 'https://example.test/missing.csv', sourceFormat: 'csv'}
}
}
});
t.equal(
pending.visState.datasets[sampleConfig.dataId],
original.visState.datasets[sampleConfig.dataId],
'original stays while downloading'
);
t.equal(pending.visState.layers, original.visState.layers, 'layers stay while downloading');
t.equal(pending.visState.filters, original.visState.filters, 'filters stay while downloading');
const task = drainTasksForTesting().find(task =>
task.label.includes('HYDRATE_EXTERNALLY_HOSTED_DATASET_TASK')
);
t.ok(task, 'runs the normal remote download task');
const failure = errorTaskInTest(task, new Error('Simulated failed download'));
const failed = {...pending, visState: visStateReducer(pending.visState, failure)};
t.equal(
failed.visState.datasets[sampleConfig.dataId],
original.visState.datasets[sampleConfig.dataId],
'failure retains original table'
);
t.deepEqual(
failed.visState.schema.getConfigToSave(failed),
before,
'failure retains complete saved map configuration'
);
t.equal(failed.visState.loadingIndicatorValue, 0, 'failure clears loading');
t.deepEqual(failed.visState.loadingProgress, {}, 'failure clears progress');
t.ok(drainTasksForTesting().length, 'failure schedules an error notification');
t.end();
});
function replacementTestState() {
const initial = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const added = addDataToMapUpdater(initial, {
payload: {
datasets: {info: {id: sampleConfig.dataId}, data: processCsvData(testCsvData)},
config: sampleConfig.config
}
});
const state = {...added, visState: applyExistingDatasetTasks(visStateReducer, added.visState)};
drainTasksForTesting();
return state;
}
function beginRemoteReplacement(state, id, options = {}) {
const datasetToUse = {
info: {id, type: DatasetType.EXTERNALLY_HOSTED},
metadata: {source: `https://example.test/${id}.csv`, sourceFormat: 'csv'}
};
const pending = replaceDataInMapUpdater(state, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse,
options
}
});
const task = drainTasksForTesting().find(task =>
task.label.includes('HYDRATE_EXTERNALLY_HOSTED_DATASET_TASK')
);
return {pending, task, datasetToUse};
}
// Simulate only the network result; run the real table creation/import task.
function finishRemoteDownload(task, datasetToUse, data = processCsvData(dataWithNulls)) {
let downloaded = false;
return new Promise((resolve, reject) =>
task.run(
(effect, onSuccess, onError) => {
if (!downloaded) {
downloaded = true;
return onSuccess({...datasetToUse, data});
}
return effect(onSuccess, onError);
},
resolve,
reject
)
);
}
test('#composerStateReducer - remote replacement commits fresh data and the latest layer config', async t => {
for (const id of [sampleConfig.dataId, 'replacement']) {
for (const deleteOriginalDataset of [true, false]) {
const original = replacementTestState();
const table = original.visState.datasets[sampleConfig.dataId];
const originalRows = table.dataContainer.flattenData();
const {pending, task, datasetToUse} = beginRemoteReplacement(original, id, {
deleteOriginalDataset
});
let edited = {
...pending,
visState: layerConfigChangeUpdater(pending.visState, {
oldLayer: pending.visState.layers[0],
newConfig: {label: 'Edited while downloading'}
})
};
edited = {
...edited,
visState: setFilterUpdater(edited.visState, {
idx: 0,
prop: 'enabled',
value: false
})
};
edited.visState = {
...edited.visState,
datasets: {
...edited.visState.datasets,
[sampleConfig.dataId]: copyTableAndUpdate(edited.visState.datasets[sampleConfig.dataId], {
hiddenColumns: ['trip_distance']
})
}
};
const completion = await finishRemoteDownload(task, datasetToUse);
t.equal(
table.dataContainer.flattenData(),
originalRows,
'download/import never mutates the live original'
);
const next = visStateReducer(edited.visState, completion);
t.ok(next.datasets[id], 'commits the requested dataset ID');
t.notEqual(next.datasets[id], table, 'builds a fresh table even for the same ID');
t.equal(
next.datasets[id].length,
processCsvData(dataWithNulls).rows.length,
'commits all downloaded rows'
);
t.equal(
Boolean(next.datasets[sampleConfig.dataId]),
id === sampleConfig.dataId || !deleteOriginalDataset,
'honors keep-original for distinct IDs'
);
t.equal(
next.layers[0].config.label,
'Edited while downloading',
'preserves a newer layer edit'
);
t.ok(
next.layers.every(layer => layer.config.dataId === id),
'remaps layers'
);
t.ok(
next.filters.every(filter => filter.dataId.includes(id)),
'remaps filters'
);
t.equal(next.filters[0].enabled, false, 'retains a newer filter edit');
t.deepEqual(next.splitMaps, original.visState.splitMaps, 'preserves split panel assignments');
t.deepEqual(next.pendingDatasetReplacements, {}, 'clears the completed request');
drainTasksForTesting();
}
}
t.end();
});
test('#composerStateReducer - stale remote replacements cannot overwrite newer work', async t => {
for (const order of ['older-first', 'newer-first']) {
const original = replacementTestState();
const first = beginRemoteReplacement(original, 'first');
const second = beginRemoteReplacement(first.pending, 'second');
const firstDone = await finishRemoteDownload(first.task, first.datasetToUse);
const secondDone = await finishRemoteDownload(second.task, second.datasetToUse);
let next = second.pending.visState;
for (const action of order === 'older-first'
? [firstDone, secondDone]
: [secondDone, firstDone]) {
next = visStateReducer(next, action);
}
t.deepEqual(
Object.keys(next.datasets),
['second'],
`${order}: only the newest request commits`
);
t.equal(next.loadingIndicatorValue, 0, 'settles both loading counters');
t.deepEqual(next.loadingProgress, {}, 'clears all completed progress');
drainTasksForTesting();
}
for (const change of ['remove', 'remove-and-readd', 'edit']) {
const original = replacementTestState();
const {pending, task, datasetToUse} = beginRemoteReplacement(original, 'stale');
let current = pending.visState;
if (change.startsWith('remove')) {
const removed = current.datasets[sampleConfig.dataId];
current = removeDatasetUpdater(current, {dataId: sampleConfig.dataId});
if (change === 'remove-and-readd')
current = {...current, datasets: {[sampleConfig.dataId]: removed}};
} else {
current.datasets[sampleConfig.dataId].appendRows([
current.datasets[sampleConfig.dataId].dataContainer.rowAsArray(0)
]);
}
const datasets = current.datasets;
const done = await finishRemoteDownload(task, datasetToUse);
const next = visStateReducer(current, done);
t.equal(next.datasets, datasets, `${change}: does not roll back current datasets`);
t.notOk(next.datasets.stale, `${change}: ignores stale completion`);
t.equal(next.loadingIndicatorValue, 0, `${change}: clears loading`);
drainTasksForTesting();
}
t.end();
});
test('#composerStateReducer - replacement into an existing target preserves its latest settings', async t => {
for (const remote of [false, true]) {
for (const deleteOriginalDataset of [false, true]) {
for (const succeeds of [false, true]) {
const original = replacementTestState();
const target = new KeplerTable({
info: {id: 'existing', label: 'Live feed', type: DatasetType.EXTERNALLY_HOSTED},
color: [10, 20, 30],
metadata: {
source: 'https://example.test/feed.csv',
sourceFormat: 'csv',
refreshIntervalMs: 10000
},
supportedFilterTypes: ['range'],
disableDataOperation: true
});
await target.importData({data: processCsvData(testCsvData)});
target.pinnedColumns = ['gps_data.lng'];
target.hiddenColumns = ['gps_data.lat'];
sortDatasetByColumn(target, 'gps_data.lng', 'DESCENDING');
original.visState = {
...original.visState,
datasets: {...original.visState.datasets, existing: target}
};
original.visState = visStateReducer(
original.visState,
setColumnDisplayFormat(target.id, {'gps_data.lng': '.1f'})
);
const rows = target.dataContainer.flattenData();
const datasetToUse = {
info: {
id: target.id,
label: 'Incoming label',
...(remote ? {type: DatasetType.EXTERNALLY_HOSTED} : {})
},
...(remote
? {metadata: {source: 'https://example.test/incoming.csv', sourceFormat: 'csv'}}
: {data: processCsvData(dataWithNulls)})
};
const pending = replaceDataInMapUpdater(original, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse,
options: {deleteOriginalDataset, centerMap: false}
}
});
const [task] = drainTasksForTesting();
pending.visState = visStateReducer(
pending.visState,
setColumnDisplayFormat(target.id, {'gps_data.lng': '.2f'})
);
const latestTarget = copyTableAndUpdate(pending.visState.datasets.existing, {
label: 'Renamed while loading',
metadata: {...target.metadata, refreshIntervalMs: 20000}
});
pending.visState = {
...pending.visState,
datasets: {...pending.visState.datasets, existing: latestTarget}
};
const completion = !succeeds
? errorTaskInTest(task, new Error('Import failed'))
: remote
? await finishRemoteDownload(task, datasetToUse)
: await new Promise((resolve, reject) =>
task.run((effect, onSuccess, onError) => effect(onSuccess, onError), resolve, reject)
);
t.equal(
target.dataContainer.flattenData(),
rows,
'import leaves the live target untouched'
);
const next = visStateReducer(pending.visState, completion);
const replaced = next.datasets.existing;
t.equal(
replaced.fields.find(field => field.name === 'gps_data.lng').displayFormat,
'.2f',
'keeps the column format edited while loading'
);
t.equal(replaced.label, latestTarget.label, 'keeps the latest target label');
t.equal(replaced.type, latestTarget.type, 'keeps the remote dataset type');
t.deepEqual(replaced.color, target.color, 'keeps the target color');
t.deepEqual(
replaced.metadata,
latestTarget.metadata,
'keeps source and latest polling settings'
);
t.deepEqual(replaced.pinnedColumns, target.pinnedColumns, 'keeps pinned columns');
t.deepEqual(replaced.hiddenColumns, target.hiddenColumns, 'keeps export exclusions');
t.deepEqual(
replaced.supportedFilterTypes,
target.supportedFilterTypes,
'keeps filter restrictions'
);
t.equal(replaced.disableDataOperation, true, 'keeps the data operation restriction');
if (succeeds) {
t.equal(
replaced.length,
processCsvData(dataWithNulls).rows.length,
'installs every incoming row'
);
t.deepEqual(replaced.sortColumn, target.sortColumn, 'keeps the selected sort');
t.deepEqual(
[...replaced.sortOrder].sort((a, b) => a - b),
replaced.allIndexes,
'sort indexes cover the new rows'
);
t.equal(
Boolean(next.datasets[sampleConfig.dataId]),
!deleteOriginalDataset,
'honors original retention'
);
t.ok(
next.layers.every(layer => layer.config.dataId === target.id),
'remaps the original layers'
);
} else {
t.equal(replaced, latestTarget, 'failure retains the live target');
t.equal(
next.datasets[sampleConfig.dataId],
original.visState.datasets[sampleConfig.dataId],
'failure retains the original'
);
}
drainTasksForTesting();
const refreshing = refreshDatasetUpdater(next, {dataId: target.id});
t.equal(
refreshing.datasets.existing.metadata.refreshStatus,
'loading',
'target remains refreshable'
);
t.equal(drainTasksForTesting().length, 1, 'schedules a refresh');
}
}
}
t.end();
});
test('#composerStateReducer - existing-target field settings follow unchanged column names and order', async t => {
for (const displayFormat of [undefined, '.2f']) {
for (const reorder of [false, true]) {
const original = replacementTestState();
const target = new KeplerTable({info: {id: 'existing'}, color: [1, 2, 3]});
await target.importData({data: processCsvData('value,other\n1,10\n2,11')});
target.fields[0].displayName = 'Friendly value';
target.getColumnFilterProps('value');
original.visState = {
...original.visState,
datasets: {...original.visState.datasets, existing: target}
};
original.visState = visStateReducer(
original.visState,
setColumnDisplayFormat(target.id, {value: displayFormat})
);
const data = processCsvData(
reorder ? 'other,value\n200,20\n300,30' : 'value,other\n20,200\n30,300'
);
data.fields = data.fields.map(field => ({...field, displayFormat: '.3f'}));
const pending = replaceDataInMapUpdater(original, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse: {info: {id: target.id}, data},
options: {centerMap: false}
}
});
const [task] = drainTasksForTesting();
const completion = await new Promise((resolve, reject) =>
task.run((effect, onSuccess, onError) => effect(onSuccess, onError), resolve, reject)
);
const next = visStateReducer(pending.visState, completion);
const value = next.datasets.existing.fields.find(field => field.name === 'value');
t.equal(
value.displayFormat,
reorder ? '.3f' : displayFormat,
'retains the target format only when the column layout is unchanged'
);
t.equal(value.valueAccessor({index: 0}), 20, 'accessor reads the incoming rows');
t.equal(
value.displayName,
reorder ? 'value' : 'Friendly value',
'preserves the column label'
);
t.deepEqual(
next.datasets.existing.getColumnFilterProps('value').domain,
[20, 30],
'rebuilds cached domains from the incoming rows'
);
drainTasksForTesting();
}
}
t.end();
});
test('#composerStateReducer - empty existing-target replacements retain timestamp fields and filters', async t => {
for (const remote of [false, true]) {
const original = replacementTestState();
const target = new KeplerTable({info: {id: 'existing'}, color: [1, 2, 3]});
await target.importData({data: processCsvData(testCsvData)});
original.visState = {
...original.visState,
datasets: {...original.visState.datasets, existing: target}
};
const data = {...processCsvData(dataWithNulls), rows: []};
const datasetToUse = remote
? {
info: {id: target.id, type: DatasetType.EXTERNALLY_HOSTED},
metadata: {source: 'https://example.test/empty.csv', sourceFormat: 'csv'}
}
: {info: {id: target.id}, data};
const pending = replaceDataInMapUpdater(original, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse,
options: {centerMap: false}
}
});
const [task] = drainTasksForTesting();
const completion = remote
? await finishRemoteDownload(task, datasetToUse, data)
: await new Promise((resolve, reject) =>
task.run((effect, onSuccess, onError) => effect(onSuccess, onError), resolve, reject)
);
const next = visStateReducer(pending.visState, completion);
t.equal(next.datasets.existing.length, 0, 'commits the empty replacement');
t.deepEqual(
next.datasets.existing.fields.map(({name, type, format}) => ({name, type, format})),
target.fields.map(({name, type, format}) => ({name, type, format})),
'retains the existing field types and timestamp formats'
);
t.equal(next.filters[0].type, 'timeRange', 'keeps the time filter');
const filled = addDataToMapUpdater(
{...pending, visState: next},
{
payload: {
datasets: {info: {id: target.id}, data: processCsvData(dataWithNulls)},
options: {centerMap: false, keepExistingConfig: true, autoCreateLayers: false}
}
}
);
const [refillTask] = drainTasksForTesting();
const refilled = visStateReducer(
filled.visState,
await new Promise((resolve, reject) =>
refillTask.run((effect, onSuccess, onError) => effect(onSuccess, onError), resolve, reject)
)
);
t.equal(refilled.filters[0].type, 'timeRange', 'keeps the time filter when rows return');
t.deepEqual(
refilled.datasets.existing.getColumnFilterProps('gps_data.utc_timestamp').domain,
[1474071056000, 1474071677000],
'rebuilds the timestamp domain from returning rows'
);
t.equal(
refilled.datasets.existing.fields[0].valueAccessor({index: 1}),
1474071056000,
'timestamp accessor reads and converts the new rows'
);
drainTasksForTesting();
}
t.end();
});
test('#composerStateReducer - replacement takes priority over background refresh', async t => {
for (const targetId of [sampleConfig.dataId, 'replacement', 'existing-target']) {
for (const refreshId of targetId === 'existing-target'
? [sampleConfig.dataId, targetId]
: [sampleConfig.dataId]) {
for (const succeeds of [true, false]) {
let original = replacementTestState();
const table = original.visState.datasets[sampleConfig.dataId];
const remote = copyTableAndUpdate(table, {
type: DatasetType.EXTERNALLY_HOSTED,
metadata: {
source: 'https://example.test/original.csv',
sourceFormat: 'csv',
refreshIntervalMs: 1000,
etag: 'original-etag'
}
});
original.visState = {
...original.visState,
datasets: {
[sampleConfig.dataId]: remote,
...(targetId === 'existing-target'
? {[targetId]: copyTableAndUpdate(remote, {id: targetId})}
: {})
}
};
original.visState = refreshDatasetUpdater(original.visState, {dataId: refreshId});
const refreshTask = drainTasksForTesting()[0];
const {pending, task, datasetToUse} = beginRemoteReplacement(original, targetId, {
deleteOriginalDataset: false
});
const rows = original.visState.datasets[refreshId].dataContainer.flattenData();
const refreshed = visStateReducer(
pending.visState,
succeedTaskInTest(refreshTask, {
data: processCsvData(dataWithNulls),
etag: 'uncommitted-etag'
})
);
t.equal(
refreshed.datasets[refreshId].dataContainer.flattenData(),
rows,
'in-flight poll leaves current rows intact'
);
t.equal(
refreshed.datasets[refreshId].metadata.etag,
'original-etag',
'does not cache validators for discarded rows'
);
t.equal(
refreshed.datasets[refreshId].metadata.refreshStatus,
'idle',
'settles the in-flight refresh'
);
t.equal(
refreshDatasetUpdater(refreshed, {dataId: refreshId}),
refreshed,
'defers new polls while replacing'
);
t.deepEqual(drainTasksForTesting(), [], 'does not start another refresh');
const completion = succeeds
? await finishRemoteDownload(task, datasetToUse)
: errorTaskInTest(task, new Error('Failed replacement'));
const next = visStateReducer(refreshed, completion);
if (succeeds) {
t.equal(
next.datasets[targetId].length,
processCsvData(dataWithNulls).rows.length,
'commits replacement after an overlapping poll'
);
t.ok(
next.layers.every(layer => layer.config.dataId === targetId),
'remaps layers after the poll'
);
} else {
t.equal(
next.datasets[refreshId].dataContainer.flattenData(),
rows,
'failure retains original rows'
);
}
drainTasksForTesting();
const resumed = refreshDatasetUpdater(next, {dataId: refreshId});
t.equal(
resumed.datasets[refreshId].metadata.refreshStatus,
'loading',
'refresh resumes after replacement settles'
);
t.equal(drainTasksForTesting().length, 1, 'schedules the resumed refresh');
}
}
}
t.end();
});
test('#composerStateReducer - cancelled replacements clear progress while other downloads continue', async t => {
for (const succeeds of [true, false]) {
const original = replacementTestState();
const {pending, task, datasetToUse} = beginRemoteReplacement(original, 'cancelled');
const progressId = Object.keys(pending.visState.loadingProgress)[0];
pending.visState = setLoadingProgressUpdater(pending.visState, {
id: progressId,
percent: 100,
phase: 'processing'
});
const other = addDataToMapUpdater(pending, {
payload: {
datasets: {...datasetToUse, info: {...datasetToUse.info, id: 'unrelated'}},
options: {keepExistingConfig: true}
}
});
drainTasksForTesting();
const removed = removeDatasetUpdater(other.visState, {dataId: sampleConfig.dataId});
const completion = succeeds
? await finishRemoteDownload(task, datasetToUse)
: errorTaskInTest(task, new Error('Cancelled download ended'));
const next = visStateReducer(removed, completion);
t.equal(next.datasets, removed.datasets, 'does not resurrect the removed dataset');
t.equal(next.loadingIndicatorValue, 1, 'only the unrelated download is loading');
t.deepEqual(next.loadingProgress, {unrelated: 0}, 'clears the cancelled download progress');
t.deepEqual(next.loadingProcessing, {}, 'clears the cancelled processing state');
drainTasksForTesting();
}
t.end();
});
test('#composerStateReducer - overlapping replacements keep independent progress', async t => {
for (const sameTarget of [true, false]) {
for (const olderFirst of [true, false]) {
const original = replacementTestState();
const first = beginRemoteReplacement(original, 'first');
const second = beginRemoteReplacement(first.pending, sameTarget ? 'first' : 'second');
const firstProgressId = Object.keys(first.pending.visState.loadingProgress)[0];
const secondProgressId = Object.keys(second.pending.visState.loadingProgress).find(
id => id !== firstProgressId
);
let current = setLoadingProgressUpdater(second.pending.visState, {
id: firstProgressId,
percent: 30
});
current = setLoadingProgressUpdater(current, {id: secondProgressId, percent: 80});
const firstDone = await finishRemoteDownload(first.task, first.datasetToUse);
const secondDone = await finishRemoteDownload(second.task, second.datasetToUse);
current = visStateReducer(current, olderFirst ? firstDone : secondDone);
t.deepEqual(
Object.values(current.loadingProgress),
[olderFirst ? 80 : 30],
'only the remaining request contributes progress'
);
current = visStateReducer(current, olderFirst ? secondDone : firstDone);
t.deepEqual(current.loadingProgress, {}, 'clears progress after both requests settle');
t.deepEqual(
Object.keys(current.datasets),
[sameTarget ? 'first' : 'second'],
'only the newest replacement commits'
);
drainTasksForTesting();
}
}
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater: same dataId', t => {
const datasets = {
data: processCsvData(testCsvData),
info: {
id: sampleConfig.dataId
}
};
const datasetToUse = {
data: processCsvData(dataWithNulls),
info: {
id: sampleConfig.dataId
}
};
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
// old state contain splitMaps
let oldState = addDataToMapUpdater(state, {
payload: {
datasets,
config: sampleConfig.config
}
});
// create datasets from existing tasks, trigger auto create layers
oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
const oldSavedConfig = state.visState.schema.getConfigToSave(oldState).config;
let nextState = replaceDataInMapUpdater(oldState, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse
}
});
// create datasets from existing tasks, trigger auto create layers
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
// dataset should be replaced
t.ok(nextState.visState.datasets[sampleConfig.dataId], ' dataset should be replaced');
const nextSavedConfig = nextState.visState.schema.getConfigToSave(nextState).config;
const expectedLayers = oldSavedConfig.visState.layers.map(l => ({
...l,
config: {
...l.config,
dataId: sampleConfig.dataId
}
}));
t.deepEqual(nextSavedConfig.visState.layers, expectedLayers, 'should replace layer dataId');
t.end();
});
test('#composerStateReducer - dataset replacement preserves data-independent bookmarks', t => {
const bookmarks = [
{
id: 'first',
name: 'Home',
camera: {longitude: 10, latitude: 20, zoom: 6, bearing: 30, pitch: 45}
},
{
id: 'second',
name: 'Away',
camera: {longitude: -20, latitude: 30, zoom: 8, bearing: 0, pitch: 0}
}
];
for (const [dataId, replacementId] of [
['id', 'id'],
['id', 'replacement'],
['ordinary-dataset', 'id'],
['name', 'name'],
['camera', 'camera'],
['ordinary-dataset', 'ordinary-dataset']
]) {
const data = {
fields: [{name: 'value', type: 'integer', format: '', analyzerType: 'INT'}],
rows: [[1]]
};
const dataset = new KeplerTable({info: {id: dataId, label: 'Original'}});
dataset.importData({data});
const initial = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const state = {
...initial,
visState: {...initial.visState, cameraBookmarks: bookmarks, datasets: {[dataId]: dataset}}
};
const next = replaceDataInMapUpdater(state, {
payload: {
datasetToReplaceId: dataId,
datasetToUse: {
info: {id: replacementId, label: 'Replacement'},
data: {...data, rows: [[2], [3]]}
},
options: {centerMap: false}
}
});
const result = {...next, visState: applyExistingDatasetTasks(visStateReducer, next.visState)};
t.equal(
result.visState.datasets[replacementId].dataContainer.numRows(),
2,
`${dataId}: replaces rows`
);
t.deepEqual(
result.visState.cameraBookmarks,
bookmarks,
`${dataId}: preserves every saved view`
);
t.deepEqual(
KeplerGlSchema.getConfigToSave(result).config.visState.cameraBookmarks,
bookmarks,
`${dataId}: subsequent saves retain bookmarks`
);
}
t.end();
});
test('#composerStateReducer - legacy bookmarks do not opt in or reset an explicit host preference', t => {
const initial = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const bookmarks = [
{
id: 'home',
name: 'Home',
camera: {longitude: 10, latitude: 20, zoom: 6, bearing: 30, pitch: 45}
}
];
const config = KeplerGlSchema.getConfigToSave({
...initial,
visState: {...initial.visState, cameraBookmarks: bookmarks}
});
delete config.config.uiState.mapControls.cameraBookmarks; // Legacy files have no preference.
const {cameraBookmarks, ...legacyControls} = initial.uiState.mapControls;
for (const controls of [
initial.uiState.mapControls,
legacyControls,
{...legacyControls, cameraBookmarks: {...cameraBookmarks, show: true}}
]) {
const state = {...initial, uiState: {...initial.uiState, mapControls: controls}};
const loaded = addDataToMapUpdater(state, {
payload: {datasets: [], config, options: {centerMap: false}}
});
t.deepEqual(loaded.visState.cameraBookmarks, bookmarks, 'restores saved views');
t.equal(
loaded.uiState.mapControls.cameraBookmarks?.show === true,
controls.cameraBookmarks?.show === true,
'loading views preserves explicit opt-in and leaves default/missing controls off'
);
}
t.end();
});
test('#composerStateReducer - vector tile unique ID survives JSON export and import', async t => {
const initial = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const dataset = new KeplerTable({
info: {id: 'vector-data', type: DatasetType.VECTOR_TILE},
color: [1, 2, 3],
// No metadata endpoint is needed to restore the saved fields.
metadata: {remoteTileFormat: 'mvt', tilesetDataUrl: 'https://example.com/{z}/{x}/{y}.pbf'}
});
await dataset.importData({
data: {
fields: [
{name: 'id', type: 'integer'},
{name: 'feature_key', type: 'string'}
],
rows: []
}
});
const layer = new KeplerGlLayers.VectorTileLayer({id: 'vector-layer', dataId: dataset.id});
const source = {
...initial,
visState: {
...initial.visState,
datasets: {[dataset.id]: dataset},
layers: [layer],
layerOrder: [layer.id]
}
};
try {
for (const selection of ['feature_key', null, 'missing_key', undefined]) {
layer.updateLayerConfig({uniqueIdField: selection ?? null});
for (const hasData of [true, false]) {
const json = JSON.parse(exportToJsonString(getMapJSON(source, {hasData})));
const savedConfig = hasData ? json.config : json;
const savedLayer = savedConfig.config.visState.layers[0];
if (selection === undefined) {
delete savedLayer.config.uniqueIdField; // Older maps omit the setting entirely.
} else {
t.equal(savedLayer.config.uniqueIdField, selection, 'JSON preserves the selection');
}
drainTasksForTesting();
let imported = hasData
? keplerGlReducer(
{test: initial},
wrapTo(
'test',
loadFilesSuccess(
[
{
info: {format: 'keplergl', label: 'vector.json'},
data: processKeplerglJSON(json)
}
],
{centerMap: false}
)
)
).test
: addDataToMapUpdater(initial, {
payload: {
config: json,
datasets: {
info: {id: dataset.id, type: dataset.type},
metadata: dataset.metadata,
// Config-only imports can reconstruct the same fields in a different order.
data: {fields: [...dataset.fields].reverse(), rows: []}
},
options: {centerMap: false}
}
});
for (let tasks = drainTasksForTesting(); tasks.length; tasks = drainTasksForTesting()) {
for (const task of tasks) {
// Execute real dataset reconstruction without loading unrelated basemap styles.
if (!task.label.includes('CREATE_TABLE_TASK')) continue;
const action = await new Promise((resolve, reject) => {
task.run((effect, succeed, fail, ctx) => effect(succeed, fail, ctx), resolve, reject);
});
imported = keplerGlReducer({test: imported}, wrapTo('test', action)).test;
}
}
const restored = imported.visState.layers.find(item => item.id === layer.id);
t.ok(restored, 'restores the vector tile layer');
t.equal(
restored?.config.uniqueIdField,
selection ?? null,
`${hasData ? 'full map' : 'config-only'} restores the field name or automatic default`
);
const fields = imported.visState.datasets[dataset.id].fields;
const field = fields.find(item => item.name === 'feature_key');
t.notEqual(field, dataset.fields[1], 'reconstructs dataset fields');
t.equal(field.fieldIdx, hasData ? 1 : 0, 'selection does not depend on the field index');
t.equal(typeof field.valueAccessor, 'function', 'restores the field accessor');
}
}
} catch (error) {
t.fail(error.stack || error.message);
} finally {
drainTasksForTesting();
t.end();
}
});
test('#composerStateReducer - project JSON bookmark visibility and layout survive file import', t => {
const initial = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const bookmarks = [
{
id: 'home',
name: 'Home',
camera: {longitude: 10, latitude: 20, zoom: 6, bearing: 30, pitch: 45}
}
];
const settings = {
position: {x: 42, y: 64, anchorX: 'left', anchorY: 'bottom'},
contentHeight: 80
};
for (const show of [true, false]) {
for (const isSplit of [false, true]) {
const source = {
...initial,
visState: {...initial.visState, cameraBookmarks: bookmarks},
mapState: {...initial.mapState, isSplit},
uiState: {
...initial.uiState,
mapControls: {
...initial.uiState.mapControls,
cameraBookmarks: {
...initial.uiState.mapControls.cameraBookmarks,
show,
settings,
activeMapIndex: 1
}
}
}
};
// This is the same JSON construction and parsing used by project export/import.
const json = JSON.parse(exportToJsonString(getMapJSON(source, {hasData: true})));
t.deepEqual(
json.config.config.uiState.mapControls.cameraBookmarks,
{show, settings},
'project JSON carries visibility and layout only'
);
const {cameraBookmarks, ...legacyControls} = initial.uiState.mapControls;
for (const controls of [
legacyControls,
{
...initial.uiState.mapControls,
cameraBookmarks: {...cameraBookmarks, show: !show, activeMapIndex: 1}
}
]) {
const target = {...initial, uiState: {...initial.uiState, mapControls: controls}};
const imported = keplerGlReducer(
{test: target},
wrapTo(
'test',
loadFilesSuccess(
[
{
info: {format: 'keplergl', label: 'saved-map.json'},
data: processKeplerglJSON(json)
}
],
{centerMap: false}
)
)
).test;
t.equal(
imported.uiState.mapControls.cameraBookmarks.show,
show,
'restores explicit visibility over the target preference'
);
t.deepEqual(
imported.uiState.mapControls.cameraBookmarks.settings,
settings,
'restores floating panel layout'
);
t.equal(
imported.uiState.mapControls.cameraBookmarks.activeMapIndex,
0,
'does not restore transient split-map index'
);
t.deepEqual(imported.visState.cameraBookmarks, bookmarks, 'preserves saved camera data');
t.equal(imported.mapState.isSplit, isSplit, 'preserves the saved map mode');
}
}
}
const legacyJson = JSON.parse(exportToJsonString(getMapJSON(initial, {hasData: true})));
delete legacyJson.config.config.uiState.mapControls.cameraBookmarks;
for (const withUiState of [true, false]) {
const json = JSON.parse(JSON.stringify(legacyJson));
if (!withUiState) delete json.config.config.uiState;
const imported = keplerGlReducer(
{test: initial},
wrapTo(
'test',
loadFilesSuccess(
[{info: {format: 'keplergl', label: 'legacy.json'}, data: processKeplerglJSON(json)}],
{centerMap: false}
)
)
).test;
t.equal(
imported.uiState.mapControls.cameraBookmarks.show,
false,
'legacy project defaults off'
);
}
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater: replacing a dataset with no layers before the previous replace merges', t => {
const noLayersId = 'dataset_without_layers';
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
let oldState = addDataToMapUpdater(state, {
payload: {
datasets: [
{data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
{data: processCsvData(testCsvData), info: {id: noLayersId}}
],
config: sampleConfig.config,
options: {autoCreateLayers: false}
}
});
oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
drainTasksForTesting();
const layerOrder = oldState.visState.layerOrder;
t.ok(layerOrder.length > 1, 'should start with more than one layer on the first dataset');
// Refresh both datasets back to back, the way an app refreshing every query
// does: the second replace is prepared before the first one has merged.
let nextState = replaceDataInMapUpdater(oldState, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
options: {autoCreateLayers: false, centerMap: false}
}
});
nextState = replaceDataInMapUpdater(nextState, {
payload: {
datasetToReplaceId: noLayersId,
datasetToUse: {data: processCsvData(testCsvData), info: {id: noLayersId}},
options: {autoCreateLayers: false, centerMap: false}
}
});
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
drainTasksForTesting();
t.deepEqual(nextState.visState.layerToBeMerged, [], 'should merge every layer back');
t.deepEqual(nextState.visState.layerOrder, layerOrder, 'should keep the layer order');
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater: replacing a dataset that has layers before the previous replace merges', t => {
const secondDataId = 'dataset_with_its_own_layer';
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
// Two layers on the first dataset and one on the second, which is what an app
// drawing a query per dataset ends up with.
const configWithBothDatasets = {
...sampleConfig.config,
config: {
...sampleConfig.config.config,
visState: {
...sampleConfig.config.config.visState,
layers: [
...sampleConfig.config.config.visState.layers,
{
id: 'second_ds_layer',
type: 'point',
config: {
dataId: secondDataId,
label: 'second dataset',
columns: {lat: 'gps_data.lat', lng: 'gps_data.lng', altitude: null},
isVisible: true
}
}
]
}
}
};
let oldState = addDataToMapUpdater(state, {
payload: {
datasets: [
{data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
{data: processCsvData(testCsvData), info: {id: secondDataId}}
],
config: configWithBothDatasets,
options: {autoCreateLayers: false}
}
});
oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
drainTasksForTesting();
const layerOrder = oldState.visState.layerOrder;
t.equal(layerOrder.length, 3, 'should start with the three layers of the config');
// Refresh both datasets back to back: the second replace is prepared while the
// first one's layers are still parked in layerToBeMerged.
let nextState = replaceDataInMapUpdater(oldState, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
options: {autoCreateLayers: false, centerMap: false}
}
});
nextState = replaceDataInMapUpdater(nextState, {
payload: {
datasetToReplaceId: secondDataId,
datasetToUse: {data: processCsvData(testCsvData), info: {id: secondDataId}},
options: {autoCreateLayers: false, centerMap: false}
}
});
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
drainTasksForTesting();
t.deepEqual(nextState.visState.layerToBeMerged, [], 'should merge every layer back');
t.deepEqual(nextState.visState.layerOrder, layerOrder, 'should keep the layer order');
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater: replacing datasets back to back keeps the split map panels', t => {
const noLayersId = 'dataset_without_layers';
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
let oldState = addDataToMapUpdater(state, {
payload: {
datasets: [
{data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
{data: processCsvData(testCsvData), info: {id: noLayersId}}
],
config: sampleConfig.config,
options: {autoCreateLayers: false}
}
});
oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
drainTasksForTesting();
const splitMaps = [
{layers: {'3zucml7': true, nob639j: false}},
{layers: {'3zucml7': false, nob639j: true}}
];
t.deepEqual(oldState.visState.splitMaps, splitMaps, 'should start with one layer on each side');
// Refresh both datasets back to back, several times, the way an app refreshing
// every query does.
let nextState = oldState;
for (let refresh = 0; refresh < 3; refresh++) {
nextState = replaceDataInMapUpdater(nextState, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
options: {autoCreateLayers: false, centerMap: false}
}
});
nextState = replaceDataInMapUpdater(nextState, {
payload: {
datasetToReplaceId: noLayersId,
datasetToUse: {data: processCsvData(testCsvData), info: {id: noLayersId}},
options: {autoCreateLayers: false, centerMap: false}
}
});
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
drainTasksForTesting();
t.deepEqual(
nextState.visState.splitMaps,
splitMaps,
`should keep one layer on each side after refresh ${refresh + 1}`
);
}
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater: keeps the right panel of a dual map empty', t => {
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
const config = {
...sampleConfig.config,
config: {
...sampleConfig.config.config,
visState: {...sampleConfig.config.config.visState, splitMaps: []},
mapState: {...sampleConfig.config.config.mapState, isSplit: false}
}
};
let oldState = addDataToMapUpdater(state, {
payload: {
datasets: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
config,
options: {autoCreateLayers: false}
}
});
oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
drainTasksForTesting();
// split the map: every layer on the left panel, nothing on the right one
oldState = combinedUpdaters.setMapSplitModeUpdater(oldState, {
payload: {mapSplitMode: MapSplitMode.DUAL_MAP}
});
const splitMaps = [{layers: {'3zucml7': true, nob639j: true}}, {layers: {}}];
t.deepEqual(oldState.visState.splitMaps, splitMaps, 'should split the map');
let nextState = replaceDataInMapUpdater(oldState, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
options: {autoCreateLayers: false, centerMap: false}
}
});
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
drainTasksForTesting();
t.deepEqual(nextState.visState.splitMaps, splitMaps, 'should keep the right panel empty');
t.end();
});
test('#composerStateReducer - addDataToMapUpdater: loads a dual map saved with an empty panel', t => {
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
// saved from DUAL_MAP mode: every layer on the left panel, nothing on the right one
const splitMaps = [{layers: {'3zucml7': true, nob639j: true}}, {layers: {}}];
const config = {
...sampleConfig.config,
config: {
...sampleConfig.config.config,
visState: {...sampleConfig.config.config.visState, splitMaps}
}
};
let nextState = addDataToMapUpdater(state, {
payload: {
datasets: {data: processCsvData(testCsvData), info: {id: sampleConfig.dataId}},
config,
options: {autoCreateLayers: false}
}
});
// the dataset is still loading, its layers are waiting to be merged
t.deepEqual(
nextState.visState.splitMaps,
[{layers: {}}, {layers: {}}],
'should create both panels while the layers load'
);
const savedConfig = JSON.parse(JSON.stringify(KeplerGlSchema.getConfigToSave(nextState)));
t.doesNotThrow(
() => KeplerGlSchema.parseSavedConfig(savedConfig),
'should save a config that loads while the layers load'
);
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
drainTasksForTesting();
t.deepEqual(nextState.visState.splitMaps, splitMaps, 'should keep the right panel empty');
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater: syncedTimeFilter & match', t => {
const oldState = StateWSyncedTimeFilter;
const dataIdToReplace = 'dataset_to_replace';
const datasetToUse = {
data: processCsvData(dataWithNulls),
info: {
id: dataIdToReplace
}
};
let nextState = replaceDataInMapUpdater(oldState, {
payload: {
datasetToReplaceId: testCsvDataSlice1Id,
datasetToUse
}
});
// create datasets from existing tasks, trigger auto create layers
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
const oldFilter = oldState.visState.filters[0];
const expectedFilter = {
...oldState.visState.filters[0],
dataId: [dataIdToReplace, testCsvDataSlice2Id],
// union [147407 1056000, 147407 1677000]; [147407 1301000, 1474072208000];
domain: [1474071056000, 1474072208000],
// value [1474071116000, 1474072188000] is still within so it doesnt change
value: oldState.visState.filters[0].value,
timeBins: {},
plotType: {
...oldState.visState.filters[0].plotType,
colorsByDataId: {
[dataIdToReplace]: '#FF0000',
'test-csv-data-2': '#00FF00'
}
}
};
// should recalculate timeBins based on new datasets
expectedFilter.timeBins = getTimeBins(
expectedFilter,
nextState.visState.datasets,
oldFilter.plotType.interval
);
t.deepEqual(
nextState.visState.filters,
[expectedFilter],
'should replace dataset with syncd filter'
);
const expectedDomain0 = 1474071056000;
const expectedGpuFilter = {
filterRange: [
[expectedFilter.value[0] - expectedDomain0, expectedFilter.value[1] - expectedDomain0],
[0, 0],
[0, 0],
[0, 0]
],
filterValueUpdateTriggers: {
gpuFilter_0: {name: 'gps_data.utc_timestamp', domain0: expectedDomain0},
gpuFilter_1: null,
gpuFilter_2: null,
gpuFilter_3: null
},
filterValueAccessor: 'dont test me'
};
t.deepEqual(
nextState.visState.datasets[dataIdToReplace].gpuFilter.filterRange,
expectedGpuFilter.filterRange,
'gpu filterRange should be correct'
);
t.deepEqual(
nextState.visState.datasets[dataIdToReplace].gpuFilter.filterValueUpdateTriggers,
expectedGpuFilter.filterValueUpdateTriggers,
'gpu filterValueUpdateTriggers should be correct'
);
t.deepEqual(
nextState.visState.datasets[testCsvDataSlice2Id].gpuFilter.filterRange,
expectedGpuFilter.filterRange,
'gpu filterRange should be correct'
);
t.deepEqual(
nextState.visState.datasets[testCsvDataSlice2Id].gpuFilter.filterValueUpdateTriggers,
expectedGpuFilter.filterValueUpdateTriggers,
'gpu filterValueUpdateTriggers should be correct'
);
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater: syncedTimeFilter & no match', t => {
const oldState = StateWSyncedTimeFilter;
const dataIdToReplace = 'dataset_to_replace';
const datasetToUse = {
// a different dataset with no match
data: processCsvData(testHexIdData),
info: {
id: dataIdToReplace
}
};
let nextState = replaceDataInMapUpdater(oldState, {
payload: {
datasetToReplaceId: testCsvDataSlice1Id,
datasetToUse
}
});
// create datasets from existing tasks, trigger auto create layers
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
t.equal(nextState.visState.filters.length, 0, 'should not merge filter if no match');
t.equal(
nextState.visState.layers.length,
1,
'should only keep 1 layer (not able to merge the other)'
);
t.deepEqual(oldState.visState.layers[1], nextState.visState.layers[0], 'should keep 1 layer');
t.equal(nextState.visState.layerToBeMerged.length, 1, 'should keep unmerged in layerToBeMerged');
t.equal(
nextState.visState.filterToBeMerged.length,
1,
'should keep unmerged in filterToBeMerged'
);
t.deepEqual(nextState.visState.interactionToBeMerged, {}, 'should reset interactionToBeMerged');
t.deepEqual(nextState.visState.splitMapsToBeMerged, [], 'should reset splitMapsToBeMerged');
t.end();
});
test('#composerStateReducer -> stageLoadedFilesUpdater keeps the modal open', t => {
const base = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const result = [{info: {label: 'points.csv', format: 'csv'}, data: []}];
const loadingState = {
...base,
uiState: {
...base.uiState,
currentModal: 'addData',
loadFiles: {fileLoading: true}
},
visState: {
...base.visState,
fileLoading: {filesToLoad: [], fileCache: [], onFinish: () => null},
fileLoadingProgress: {
a: {percent: 1, message: 'Done', fileName: 'points.csv', error: null}
}
}
};
const staged = combinedUpdaters.stageLoadedFilesUpdater(loadingState, stageLoadedFiles(result));
t.equal(staged.uiState.currentModal, 'addData', 'should leave the Add Data modal open');
t.equal(staged.uiState.loadFiles.fileLoading, false, 'should clear the loading flag');
t.equal(staged.visState.fileLoading, false, 'should finish the visState load');
t.equal(staged.visState.stagedToAdd[0].info.label, 'points.csv', 'should keep the parsed file');
t.equal(staged.visState.datasets, base.visState.datasets, 'should not add datasets yet');
const closed = {
...loadingState,
uiState: {...loadingState.uiState, currentModal: null}
};
const dropped = combinedUpdaters.stageLoadedFilesUpdater(closed, stageLoadedFiles(result));
t.equal(
dropped.visState.stagedToAdd,
null,
'should discard files when the modal is already closed'
);
const withPrevious = {
...loadingState,
visState: {
...loadingState.visState,
stagedToAdd: [{info: {label: 'points.csv', format: 'csv'}, data: []}]
}
};
const appended = combinedUpdaters.stageLoadedFilesUpdater(
withPrevious,
stageLoadedFiles([{info: {label: 'cities.csv', format: 'csv'}, data: []}])
);
t.deepEqual(
appended.visState.stagedToAdd.map(item => item.info.label),
['points.csv', 'cities.csv'],
'should append a later file instead of replacing the staged list'
);
const replacedLoad = {
...loadingState,
visState: {
...loadingState.visState,
fileLoading: {...loadingState.visState.fileLoading, loadId: 2},
stagedToAdd: null
}
};
const staleFinish = combinedUpdaters.stageLoadedFilesUpdater(replacedLoad, {
...stageLoadedFiles(result),
loadId: 1
});
t.equal(staleFinish, replacedLoad, 'a finish from a canceled load does not replace the new one');
const canceledLoad = {
...loadingState,
visState: {...loadingState.visState, fileLoading: false, stagedToAdd: null}
};
const afterCancel = combinedUpdaters.stageLoadedFilesUpdater(canceledLoad, {
...stageLoadedFiles(result),
loadId: 1
});
t.equal(afterCancel.visState.fileLoading, false, 'a canceled load stays stopped');
t.equal(afterCancel.visState.stagedToAdd, null, 'a canceled load is not restored');
const remote = {
data: {fields: [], rows: []},
info: {id: 'remote-1', label: 'quakes.csv', format: 'row', type: 'externally-hosted'},
metadata: {source: 'https://example.com/quakes.csv', sourceFormat: 'csv'}
};
const withRemote = combinedUpdaters.appendStagedLoadedFilesUpdater(
appended,
appendStagedLoadedFiles([remote])
);
t.deepEqual(
withRemote.visState.stagedToAdd.map(item => item.info.label),
['points.csv', 'cities.csv', 'quakes.csv'],
'should add a remote url without replacing staged files'
);
t.equal(withRemote.visState.fileLoading, false, 'should not start a file load for a remote url');
const duplicate = combinedUpdaters.appendStagedLoadedFilesUpdater(
withRemote,
appendStagedLoadedFiles([remote])
);
t.equal(duplicate, withRemote, 'should ignore a url that is already staged');
const closedModal = {
...withRemote,
uiState: {...withRemote.uiState, currentModal: null}
};
const afterClose = combinedUpdaters.appendStagedLoadedFilesUpdater(
closedModal,
appendStagedLoadedFiles([
{
...remote,
info: {...remote.info, id: 'remote-2', label: 'cities.csv'},
metadata: {source: 'https://example.com/cities.csv'}
}
])
);
t.equal(afterClose, closedModal, 'a remote url is not staged after the modal closes');
const activeLoad = {
...loadingState,
visState: {
...loadingState.visState,
fileLoading: {...loadingState.visState.fileLoading, loadId: 2},
stagedToAdd: [{info: {label: 'fresh.csv'}}]
}
};
const staleAdd = combinedUpdaters.loadFilesSuccessUpdater(activeLoad, {
...loadFilesSuccess([{info: {label: 'old.csv', format: 'csv'}, data: {fields: [], rows: []}}]),
loadId: 1
});
t.equal(staleAdd, activeLoad, 'a stale add does not replace the current load');
t.end();
});
test('#composerStateReducer -> progressive Arrow confirmation queues the next snapshot', t => {
const base = keplerGlReducer(undefined, registerEntry({id: 'test'})).test;
const first = {
info: {id: 'progressive-arrow', label: 'progressive.arrow', format: 'arrow'},
data: {...mockRawData, rows: mockRawData.rows.slice(0, 1)}
};
const final = {
...first,
data: {...mockRawData, rows: mockRawData.rows.slice(0, 2)}
};
const staged = {
...final,
progressiveData: [first.data, final.data]
};
const afterFirstDispatch = combinedUpdaters.loadFilesSuccessUpdater(
base,
loadFilesSuccess([staged], {autoCreateLayers: false, centerMap: true})
);
const afterFirstCommit = applyExistingDatasetTasks(visStateReducer, afterFirstDispatch.visState);
const continuation = drainTasksForTesting().find(task => task.label === 'DELAY_TASK');
const nextAction = succeedTaskInTest(continuation, undefined);
const afterFinalDispatch = combinedUpdaters.loadFilesSuccessUpdater(
{...afterFirstDispatch, visState: afterFirstCommit},
nextAction
);
const [updateTask] = drainTasksForTesting();
const finalTable = new KeplerTable({info: final.info});
finalTable.importData({data: final.data});
const afterFinalCommit = visStateReducer(
afterFinalDispatch.visState,
succeedTaskWithValues(updateTask, [finalTable])
);
t.equal(afterFirstCommit.datasets['progressive-arrow'].length, 1, 'commits the first snapshot');
t.equal(nextAction.result[0].data.rows.length, 2, 'queues the next cumulative snapshot');
t.deepEqual(
nextAction.progressiveSteps,
[],
'marks the final step without queueing another snapshot'
);
t.equal(nextAction.options.centerMap, false, 'does not center subsequent snapshots');
t.equal(afterFinalCommit.datasets['progressive-arrow'].length, 2, 'commits the final snapshot');
t.equal(drainTasksForTesting().length, 0, 'does not leave another continuation queued');
t.end();
});
test('#composerStateReducer - replaceDataInMapUpdater keeps the original dataset when asked', t => {
const dataIdToReplace = 'dataset_to_replace';
const datasets = {
data: processCsvData(testCsvData),
info: {
id: sampleConfig.dataId
}
};
const datasetToUse = {
data: processCsvData(dataWithNulls),
info: {
id: dataIdToReplace,
label: 'Replaced'
}
};
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
let oldState = addDataToMapUpdater(state, {
payload: {
datasets,
config: sampleConfig.config
}
});
oldState = {...oldState, visState: applyExistingDatasetTasks(visStateReducer, oldState.visState)};
let nextState = replaceDataInMapUpdater(oldState, {
payload: {
datasetToReplaceId: sampleConfig.dataId,
datasetToUse,
options: {deleteOriginalDataset: false}
}
});
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
drainTasksForTesting();
t.ok(nextState.visState.datasets[sampleConfig.dataId], 'should keep the original dataset');
t.ok(nextState.visState.datasets[dataIdToReplace], 'should add the replacement dataset');
t.ok(
nextState.visState.layers.every(layer => layer.config.dataId === dataIdToReplace),
'should remap layers onto the replacement'
);
t.ok(
nextState.visState.filters.every(filter => filter.dataId.includes(dataIdToReplace)),
'should remap filters onto the replacement'
);
t.end();
});
test('#composerStateReducer - confirmReplaceDatasetUpdater replaces the confirmed upload', t => {
const datasets = {
data: processCsvData(testCsvData),
info: {
id: sampleConfig.dataId
}
};
const state = keplerGlReducer({}, registerEntry({id: 'test'})).test;
let oldState = addDataToMapUpdater(state, {
payload: {
datasets,
config: sampleConfig.config
}
});
oldState = {
...oldState,
visState: applyExistingDatasetTasks(visStateReducer, {
...oldState.visState,
stagedToAdd: [
{info: {id: 'pending', label: 'pending', format: 'csv'}, data: {fields: [], rows: []}}
]
}),
uiState: {
...oldState.uiState,
datasetToReplaceId: sampleConfig.dataId,
currentModal: 'addData'
}
};
let nextState = combinedUpdaters.confirmReplaceDatasetUpdater(
oldState,
confirmReplaceDataset({
datasetToReplaceId: sampleConfig.dataId,
deleteOriginalDataset: true,
result: [
{
data: processCsvData(dataWithNulls),
info: {id: 'uploaded-replacement', label: 'Uploaded', format: 'csv'}
}
]
})
);
nextState = {
...nextState,
visState: applyExistingDatasetTasks(visStateReducer, nextState.visState)
};
drainTasksForTesting();
t.notOk(nextState.visState.datasets[sampleConfig.dataId], 'should drop the original dataset');
t.ok(nextState.visState.datasets['uploaded-replacement'], 'should add the uploaded dataset');
t.equal(nextState.visState.stagedToAdd, null, 'should clear the staged upload');
t.equal(nextState.uiState.datasetToReplaceId, null, 'should clear replace mode');
t.equal(nextState.uiState.currentModal, null, 'should close the modal');
t.ok(
nextState.visState.layers.every(layer => layer.config.dataId === 'uploaded-replacement'),
'should remap layers onto the upload'
);
t.end();
});