Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

82.6 KB
Raw Blame
// 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();
});