Skip to content

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

[Bug] Correctly save filterProps to field while merging filter from config (#829)

Shan Heb279077e3395
diff --git a/src/reducers/vis-state-merger.js b/src/reducers/vis-state-merger.js
index 813b6836f..a46076640 100644
--- a/src/reducers/vis-state-merger.js
+++ b/src/reducers/vis-state-merger.js
@@ -45,6 +45,7 @@ export function mergeFilters(state, filtersToMerge) {
const merged = [];
const unmerged = [];
const {datasets} = state;
+ let updatedDatasets = datasets;
if (!Array.isArray(filtersToMerge) || !filtersToMerge.length) {
return state;
@@ -55,24 +56,32 @@ export function mergeFilters(state, filtersToMerge) {
// we can only look for datasets define in the filter dataId
const datasetIds = Array.isArray(filter.dataId) ? filter.dataId : [filter.dataId];
- // we can merge a filter only if all datasets supposed to be filtered are already laoded
+ // we can merge a filter only if all datasets in filter.dataId are laoded
if (datasetIds.every(d => datasets[d])) {
// all datasetIds in filter must be present the state datasets
- const {filter: validatedFilter, applytoDatasets} = datasetIds.reduce((acc, d) => {
- const dataset = datasets[d];
- const updatedFilter = validateFilterWithData(dataset, filter);
+ const {filter: validatedFilter, applyToDatasets, augmentedDatasets} = datasetIds.reduce((acc, datasetId) => {
+ const dataset = datasets[datasetId];
+ const {filter: updatedFilter, dataset: updatedDataset} = validateFilterWithData(dataset, filter);
+
if (updatedFilter) {
return {
...acc,
+ // merge filter props
filter: acc.filter ? {
...acc.filter,
...mergeFilterProps(acc, updatedFilter)
} : updatedFilter,
- applytoDatasets: [
- ...acc.applytoDatasets,
- d
- ]
+
+ applyToDatasets: [
+ ...acc.applyToDatasets,
+ datasetId
+ ],
+
+ augmentedDatasets: {
+ ...acc.augmentedDatasets,
+ [datasetId]: updatedDataset || dataset
+ }
};
}
@@ -80,11 +89,16 @@ export function mergeFilters(state, filtersToMerge) {
}, {
filter: null,
- applytoDatasets: []
+ applyToDatasets: [],
+ augmentedDatasets: {}
});
- if (validatedFilter && isEqual(datasetIds, applytoDatasets)) {
+ if (validatedFilter && isEqual(datasetIds, applyToDatasets)) {
merged.push(validatedFilter);
+ updatedDatasets = {
+ ...updatedDatasets,
+ ...augmentedDatasets
+ }
}
} else {
unmerged.push(filter);
@@ -97,12 +111,12 @@ export function mergeFilters(state, filtersToMerge) {
// flatten all filter dataIds
const datasetsToFilter = uniq(flattenDeep(merged.map(f => f.dataId)));
- const updatedDatasets = applyFiltersToDatasets(datasetsToFilter, datasets, updatedFilters);
+ const filtered = applyFiltersToDatasets(datasetsToFilter, updatedDatasets, updatedFilters);
return {
...state,
filters: updatedFilters,
- datasets: updatedDatasets,
+ datasets: filtered,
filterToBeMerged: unmerged
};
}
diff --git a/src/reducers/vis-state-updaters.js b/src/reducers/vis-state-updaters.js
index 977fc9c7f..297bebb87 100644
--- a/src/reducers/vis-state-updaters.js
+++ b/src/reducers/vis-state-updaters.js
@@ -546,12 +546,20 @@ export function setFilterUpdater(state, action) {
// we are supporting the current functionality
// TODO: Next PR for UI filter name will only update filter name but it won't have side effects
// we are gonna use pair of datasets and fieldIdx to update the filter
- const {filter: updateFilter, datasets: newDatasets} = applyFilterFieldName(newFilter, state.datasets, value, valueIndex);
- newFilter = updateFilter;
+ const datasetId = newFilter.dataId[valueIndex]
+ const {filter: updatedFilter, dataset: newDataset} = applyFilterFieldName(newFilter, state.datasets[datasetId], value, valueIndex);
+ if (!updatedFilter) {
+ return state;
+ }
+
+ newFilter = updatedFilter;
newState = {
...state,
- datasets: newDatasets
+ datasets: {
+ ...state.datasets,
+ [datasetId]: newDataset
+ }
};
// only filter the current dataset
diff --git a/src/utils/filter-utils.js b/src/utils/filter-utils.js
index 523961d61..c8944176b 100644
--- a/src/utils/filter-utils.js
+++ b/src/utils/filter-utils.js
@@ -133,7 +133,7 @@ export function getDefaultFilter(dataId) {
* @param {string} dataset id to validate filter against
* @return {boolean} true if a filter is valid, false otherwise
*/
-export function shouldApplyfilter(filter, datasetId) {
+export function shouldApplyFilter(filter, datasetId) {
const valid = Boolean(filter.dataId)
// datasetId is contained in dataId
&& (
@@ -156,71 +156,67 @@ export function shouldApplyfilter(filter, datasetId) {
* @return {Object | null} - validated filter
*/
export function validateFilterWithData(dataset, filter) {
- const {fields, allData} = dataset;
-
- // match filter.name to field.name
- const filterDataId = Array.isArray(filter.dataId) ? filter.dataId : [filter.dataId];
- const filterName = Array.isArray(filter.name) ? filter.name : [filter.name];
- const filterDatasetIndex = Array.isArray(filter.dataId) ? getDatasetIndexForFilter(dataset, filter) : 0;
- const fieldIndex = fields.findIndex(({name}) => name === filterName[filterDatasetIndex]);
- if (fieldIndex < 0) {
- return null;
- }
+ // match filter.dataId
+ const failed = {dataset, filter: null};
- const field = fields[fieldIndex];
+ const filterDataId = Array.isArray(filter.dataId) ? filter.dataId : [filter.dataId];
- if (filterDatasetIndex === -1) {
+ const filterDatasetIndex = filterDataId.indexOf(dataset.id);
+ if (filterDatasetIndex < 0) {
// the current filter is not mapped against the current dataset
- return null;
+ return failed;
}
- // update fieldIdx with the current value
- const newFieldIdx = [
- ...(Array.isArray(filter.fieldIdx) ? filter.fieldIdx : [filter.fieldIdx])
- ];
-
- newFieldIdx[filterDatasetIndex] = fieldIndex;
-
- // return filter type, default value, fieldType and fieldDomain from field
- const filterPropsFromField = getFilterProps(allData, field);
-
- let matchedFilter = {
+ const initializeFilter = {
...getDefaultFilter(filter.dataId),
...filter,
- ...filterPropsFromField,
dataId: filterDataId,
- freeze: true,
- fieldIdx: Object.assign([...newFieldIdx], {[filterDatasetIndex]: fieldIndex}),
- name: Object.assign([...filterName], {[filterDatasetIndex]: field.name})
+ name: Array.isArray(filter.name) ? filter.name : [filter.name]
};
- const {yAxis} = matchedFilter;
+ const fieldName = initializeFilter.name[filterDatasetIndex];
+ const {filter: updatedFilter, dataset: updatedDataset} =
+ applyFilterFieldName(initializeFilter, dataset, fieldName, filterDatasetIndex);
+
+ if (!updatedFilter) {
+ return failed;
+ }
+
+ updatedFilter.value = adjustValueToFilterDomain(filter.value, updatedFilter);
+ if (updatedFilter.value === null) {
+ // cannot adjust saved value to filter
+ return failed;
+ }
+
+ return {
+ filter: validateFilterYAxis(updatedFilter, updatedDataset),
+ dataset: updatedDataset
+ }
+}
+
+function validateFilterYAxis(filter, dataset) {
+ // TODO: validate yAxis against other datasets
+
+ const {fields, allData} = dataset;
+ const {yAxis} = filter;
// TODO: validate yAxis against other datasets
if (yAxis) {
- const matcheAxis = fields.find(
+ const matchedAxis = fields.find(
({name, type}) => name === yAxis.name && type === yAxis.type
);
- matchedFilter = matcheAxis
+ filter = matchedAxis
? {
- ...matchedFilter,
- yAxis: matcheAxis,
- ...getFilterPlot({...matchedFilter, yAxis: matcheAxis}, allData)
+ ...filter,
+ yAxis: matchedAxis,
+ ...getFilterPlot({...filter, yAxis: matchedAxis}, allData)
}
- : matchedFilter;
- }
-
- matchedFilter.value = adjustValueToFilterDomain(filter.value, matchedFilter);
-
- if (matchedFilter.value === null) {
- // cannot adjust saved value to filter
- return null;
+ : filter;
}
- return matchedFilter;
+ return filter;
}
-
/**
* Get default filter prop based on field type
*
@@ -229,7 +225,7 @@ export function validateFilterWithData(dataset, filter) {
* @returns {object} default filter
*/
export function getFilterProps(data, field) {
- const filterProp = {
+ const filterProps = {
...getFieldDomain(data, field),
fieldType: field.type
};
@@ -238,15 +234,15 @@ export function getFilterProps(data, field) {
case ALL_FIELD_TYPES.real:
case ALL_FIELD_TYPES.integer:
return {
- ...filterProp,
- value: filterProp.domain,
+ ...filterProps,
+ value: filterProps.domain,
type: FILTER_TYPES.range,
typeOptions: [FILTER_TYPES.range]
};
case ALL_FIELD_TYPES.boolean:
return {
- ...filterProp,
+ ...filterProps,
type: FILTER_TYPES.select,
value: true
};
@@ -254,18 +250,18 @@ export function getFilterProps(data, field) {
case ALL_FIELD_TYPES.string:
case ALL_FIELD_TYPES.date:
return {
- ...filterProp,
+ ...filterProps,
type: FILTER_TYPES.multiSelect,
value: []
};
case ALL_FIELD_TYPES.timestamp:
return {
- ...filterProp,
+ ...filterProps,
type: FILTER_TYPES.timeRange,
enlarged: true,
fixedDomain: true,
- value: filterProp.domain
+ value: filterProps.domain
};
default:
@@ -321,7 +317,7 @@ export function filterData(dataset, filters) {
return {data, filteredIndex: defaultValues, filteredIndexForDomain: defaultValues};
}
- const appliedFilters = filters.filter(d => shouldApplyfilter(d, dataset.id));
+ const appliedFilters = filters.filter(d => shouldApplyFilter(d, dataset.id));
// Map filter against current dataset field
const filtersToFields = filters.reduce((acc, filter) => {
@@ -394,8 +390,8 @@ export function isDataMatchFilter(data, filter, i, field) {
return isInRange(val, filter.value);
case FILTER_TYPES.timeRange:
- const timeVal = field && field.filterProp && Array.isArray(field.filterProp.mappedValue)
- ? field.filterProp.mappedValue[i]
+ const timeVal = field && field.filterProps && Array.isArray(field.filterProps.mappedValue)
+ ? field.filterProps.mappedValue[i]
: moment.utc(val).valueOf();
return isInRange(timeVal, filter.value);
@@ -705,20 +701,16 @@ export function applyFiltersToDatasets(datasetIds, datasets, filters) {
* @param fieldName
* @return {object} {filter, datasets}
*/
-export function applyFilterFieldName(filter, datasets, fieldName, filterDatasetIndex = 0) {
+export function applyFilterFieldName(filter, dataset, fieldName, filterDatasetIndex = 0) {
// using filterDatasetIndex we can filter only the specified dataset
- const {dataId} = filter;
-
- const dataIdentifier = dataId[filterDatasetIndex];
-
- const {fields, allData} = datasets[dataIdentifier];
+ const {fields, allData} = dataset;
const fieldIndex = fields.findIndex(f => f.name === fieldName);
-
// if no field with same name is found, move to the next datasets
if (fieldIndex === -1) {
- throw new Error(`fieldIndex not found. Dataset must contain a property with name: ${fieldName}`);
+ // throw new Error(`fieldIndex not found. Dataset must contain a property with name: ${fieldName}`);
+ return {filter: null, dataset};
}
const newFilter = {
@@ -729,34 +721,26 @@ export function applyFilterFieldName(filter, datasets, fieldName, filterDatasetI
// TODO: validate field type
const field = fields[fieldIndex];
-
const filterProps = field.hasOwnProperty('filterProps') ? field.filterProps : getFilterProps(allData, field);
- // Update Filter field idx
- const filterName = Array.isArray(filter.name) ? filter.name : [filter.name];
- const filterIdx = Array.isArray(filter.fieldIdx) ? filter.fieldIdx : [filter.fieldIdx];
-
const filterWithProps = {
...mergeFilterProps(newFilter, filterProps),
- name: Object.assign([...filterName], {[filterDatasetIndex]: field.name}),
- fieldIdx: Object.assign([...filterIdx], {[filterDatasetIndex]: field.tableFieldIndex - 1})
+ name: Object.assign([].concat(filter.name), {[filterDatasetIndex]: field.name}),
+ fieldIdx: Object.assign([].concat(filter.fieldIdx), {[filterDatasetIndex]: field.tableFieldIndex - 1})
};
const fieldWithFilterProps = {
...field,
- filterProp: filterProps
+ filterProps
};
const newFields = fields.map((d, i) => (i === fieldIndex ? fieldWithFilterProps : d));
return {
filter: filterWithProps,
- datasets: {
- ...datasets,
- [dataIdentifier]: {
- ...datasets[dataIdentifier],
- fields: newFields
- }
+ dataset: {
+ ...dataset,
+ fields: newFields
}
};
}
diff --git a/test/fixtures/test-hex-id-data.js b/test/fixtures/test-hex-id-data.js
index d89bde690..2776d4eeb 100644
--- a/test/fixtures/test-hex-id-data.js
+++ b/test/fixtures/test-hex-id-data.js
@@ -221,6 +221,298 @@ export const hexIdDataConfig = {
}
};
+export const mergedFilters = [
+ {
+ dataId: [dataId],
+ id: 'value',
+ name: ['value'],
+ type: 'range',
+ value: [11.2, 18],
+ enlarged: false,
+ freeze: true,
+ plotType: 'histogram',
+ yAxis: null,
+ isAnimating: false,
+ fieldIdx: [1],
+ domain: [1, 76],
+ step: 0.1,
+ interval: null,
+ histogram: ['Not tested'],
+ enlargedHistogram: ['Not tested'],
+ speed: 1,
+ fieldType: 'integer',
+ typeOptions: ['range'],
+ fixedDomain: false
+ }
+];
+
+const allData = [
+ ['89283082c2fffff', 64],
+ ['8928308288fffff', 73],
+ ['89283082c07ffff', 65],
+ ['89283082817ffff', 74],
+ ['89283082c3bffff', 66],
+ ['89283082883ffff', 76],
+ ['89283082c03ffff', 60],
+ ['89283082807ffff', 68],
+ ['8928308289bffff', 49],
+ ['89283082c0fffff', 41],
+ ['89283082c87ffff', 50],
+ ['89283082d4fffff', 45],
+ ['89283082c77ffff', 41],
+ ['89283082c2bffff', 53],
+ ['89283082803ffff', 41],
+ ['89283082813ffff', 43],
+ ['89283082d5bffff', 45],
+ ['89283082897ffff', 40],
+ ['89283082c67ffff', 42],
+ ['89283082d47ffff', 51],
+ ['89283082dc3ffff', 52],
+ ['89283082c33ffff', 43],
+ ['89283082c23ffff', 40],
+ ['89283082887ffff', 36],
+ ['89283082d4bffff', 36],
+ ['892830828bbffff', 48],
+ ['892830828b7ffff', 28],
+ ['89283082c17ffff', 34],
+ ['89283082c6fffff', 21],
+ ['8928308288bffff', 25],
+ ['892830828abffff', 26],
+ ['89283082c27ffff', 27],
+ ['89283082c8fffff', 33],
+ ['89283082cafffff', 29],
+ ['89283082c13ffff', 27],
+ ['89283082cabffff', 22],
+ ['89283082c63ffff', 26],
+ ['89283082d43ffff', 30],
+ ['89283082d53ffff', 19],
+ ['892830828a3ffff', 28],
+ ['89283082d1bffff', 20],
+ ['89283095367ffff', 17],
+ ['8928309536bffff', 26],
+ ['89283082c37ffff', 16],
+ ['89283082c73ffff', 17],
+ ['89283082c8bffff', 15],
+ ['89283082ca7ffff', 27],
+ ['89283082cb3ffff', 32],
+ ['89283082c0bffff', 26],
+ ['89283082ca3ffff', 19],
+ ['89283082dcfffff', 18],
+ ['89283082c1bffff', 20],
+ ['89283082ddbffff', 18],
+ ['8928309534fffff', 16],
+ ['89283082d03ffff', 15],
+ ['89283082cbbffff', 21],
+ ['89283082cd7ffff', 9],
+ ['8928309534bffff', 9],
+ ['892830828c7ffff', 13],
+ ['89283082cc7ffff', 12],
+ ['89283082d0bffff', 19],
+ ['89283082dcbffff', 19],
+ ['89283082dd3ffff', 15],
+ ['89283082dd7ffff', 15],
+ ['892830828d7ffff', 13],
+ ['89283082d17ffff', 5],
+ ['8928309536fffff', 8],
+ ['89283095373ffff', 6],
+ ['89283082cb7ffff', 15],
+ ['89283082d83ffff', 9],
+ ['89283082d07ffff', 4],
+ ['89283082d0fffff', 3],
+ ['89283082d13ffff', 6],
+ ['89283082d9bffff', 5],
+ ['89283082c83ffff', 11],
+ ['89283082d8bffff', 4],
+ ['89283082dc7ffff', 5],
+ ['89283095377ffff', 5],
+ ['89283082c97ffff', 4],
+ ['89283082d7bffff', 2],
+ ['89283082d8fffff', 1],
+ ['89283095347ffff', 3],
+ ['89283095363ffff', 2],
+ ['8928309537bffff', 4],
+ ['89283082d93ffff', 6],
+ ['89283082d73ffff', 1],
+ ['8928309530bffff', 1],
+ ['8928309532bffff', 1]
+];
+
+const filteredData = [
+ ['89283095367ffff', 17],
+ ['89283082c37ffff', 16],
+ ['89283082c73ffff', 17],
+ ['89283082c8bffff', 15],
+ ['89283082dcfffff', 18],
+ ['89283082ddbffff', 18],
+ ['8928309534fffff', 16],
+ ['89283082d03ffff', 15],
+ ['892830828c7ffff', 13],
+ ['89283082cc7ffff', 12],
+ ['89283082dd3ffff', 15],
+ ['89283082dd7ffff', 15],
+ ['892830828d7ffff', 13],
+ ['89283082cb7ffff', 15]
+];
+
+const filteredIndex = [41, 43, 44, 45, 50, 52, 53, 54, 58, 59, 62, 63, 64, 68];
+const filteredIndexForDomain = [41, 43, 44, 45, 50, 52, 53, 54, 58, 59, 62, 63, 64, 68];
+
+const fields = [
+ {
+ name: 'hex_id',
+ format: '',
+ tableFieldIndex: 1,
+ type: 'string',
+ id: 'hex_id'
+ },
+ {
+ name: 'value',
+ format: '',
+ tableFieldIndex: 2,
+ type: 'integer',
+ id: 'value',
+ filterProps: {
+ domain: [1, 76],
+ step: 0.1,
+ histogram: [
+ {count: 4, x0: 1, x1: 2},
+ {count: 4, x0: 2, x1: 4},
+ {count: 8, x0: 4, x1: 6},
+ {count: 3, x0: 6, x1: 8},
+ {count: 4, x0: 8, x1: 10},
+ {count: 1, x0: 10, x1: 12},
+ {count: 3, x0: 12, x1: 14},
+ {count: 5, x0: 14, x1: 16},
+ {count: 4, x0: 16, x1: 18},
+ {count: 6, x0: 18, x1: 20},
+ {count: 4, x0: 20, x1: 22},
+ {count: 1, x0: 22, x1: 24},
+ {count: 1, x0: 24, x1: 26},
+ {count: 7, x0: 26, x1: 28},
+ {count: 3, x0: 28, x1: 30},
+ {count: 1, x0: 30, x1: 32},
+ {count: 2, x0: 32, x1: 34},
+ {count: 1, x0: 34, x1: 36},
+ {count: 2, x0: 36, x1: 38},
+ {count: 0, x0: 38, x1: 40},
+ {count: 5, x0: 40, x1: 42},
+ {count: 3, x0: 42, x1: 44},
+ {count: 2, x0: 44, x1: 46},
+ {count: 0, x0: 46, x1: 48},
+ {count: 2, x0: 48, x1: 50},
+ {count: 2, x0: 50, x1: 52},
+ {count: 2, x0: 52, x1: 54},
+ {count: 0, x0: 54, x1: 56},
+ {count: 0, x0: 56, x1: 58},
+ {count: 0, x0: 58, x1: 60},
+ {count: 1, x0: 60, x1: 62},
+ {count: 0, x0: 62, x1: 64},
+ {count: 2, x0: 64, x1: 66},
+ {count: 1, x0: 66, x1: 68},
+ {count: 1, x0: 68, x1: 70},
+ {count: 0, x0: 70, x1: 72},
+ {count: 1, x0: 72, x1: 74},
+ {count: 1, x0: 74, x1: 76},
+ {count: 1, x0: 76, x1: 76}
+ ],
+ enlargedHistogram: [
+ {count: 4, x0: 1, x1: 2},
+ {count: 2, x0: 2, x1: 3},
+ {count: 2, x0: 3, x1: 4},
+ {count: 4, x0: 4, x1: 5},
+ {count: 4, x0: 5, x1: 6},
+ {count: 3, x0: 6, x1: 7},
+ {count: 0, x0: 7, x1: 8},
+ {count: 1, x0: 8, x1: 9},
+ {count: 3, x0: 9, x1: 10},
+ {count: 0, x0: 10, x1: 11},
+ {count: 1, x0: 11, x1: 12},
+ {count: 1, x0: 12, x1: 13},
+ {count: 2, x0: 13, x1: 14},
+ {count: 0, x0: 14, x1: 15},
+ {count: 5, x0: 15, x1: 16},
+ {count: 2, x0: 16, x1: 17},
+ {count: 2, x0: 17, x1: 18},
+ {count: 2, x0: 18, x1: 19},
+ {count: 4, x0: 19, x1: 20},
+ {count: 2, x0: 20, x1: 21},
+ {count: 2, x0: 21, x1: 22},
+ {count: 1, x0: 22, x1: 23},
+ {count: 0, x0: 23, x1: 24},
+ {count: 0, x0: 24, x1: 25},
+ {count: 1, x0: 25, x1: 26},
+ {count: 4, x0: 26, x1: 27},
+ {count: 3, x0: 27, x1: 28},
+ {count: 2, x0: 28, x1: 29},
+ {count: 1, x0: 29, x1: 30},
+ {count: 1, x0: 30, x1: 31},
+ {count: 0, x0: 31, x1: 32},
+ {count: 1, x0: 32, x1: 33},
+ {count: 1, x0: 33, x1: 34},
+ {count: 1, x0: 34, x1: 35},
+ {count: 0, x0: 35, x1: 36},
+ {count: 2, x0: 36, x1: 37},
+ {count: 0, x0: 37, x1: 38},
+ {count: 0, x0: 38, x1: 39},
+ {count: 0, x0: 39, x1: 40},
+ {count: 2, x0: 40, x1: 41},
+ {count: 3, x0: 41, x1: 42},
+ {count: 1, x0: 42, x1: 43},
+ {count: 2, x0: 43, x1: 44},
+ {count: 0, x0: 44, x1: 45},
+ {count: 2, x0: 45, x1: 46},
+ {count: 0, x0: 46, x1: 47},
+ {count: 0, x0: 47, x1: 48},
+ {count: 1, x0: 48, x1: 49},
+ {count: 1, x0: 49, x1: 50},
+ {count: 1, x0: 50, x1: 51},
+ {count: 1, x0: 51, x1: 52},
+ {count: 1, x0: 52, x1: 53},
+ {count: 1, x0: 53, x1: 54},
+ {count: 0, x0: 54, x1: 55},
+ {count: 0, x0: 55, x1: 56},
+ {count: 0, x0: 56, x1: 57},
+ {count: 0, x0: 57, x1: 58},
+ {count: 0, x0: 58, x1: 59},
+ {count: 0, x0: 59, x1: 60},
+ {count: 1, x0: 60, x1: 61},
+ {count: 0, x0: 61, x1: 62},
+ {count: 0, x0: 62, x1: 63},
+ {count: 0, x0: 63, x1: 64},
+ {count: 1, x0: 64, x1: 65},
+ {count: 1, x0: 65, x1: 66},
+ {count: 1, x0: 66, x1: 67},
+ {count: 0, x0: 67, x1: 68},
+ {count: 1, x0: 68, x1: 69},
+ {count: 0, x0: 69, x1: 70},
+ {count: 0, x0: 70, x1: 71},
+ {count: 0, x0: 71, x1: 72},
+ {count: 0, x0: 72, x1: 73},
+ {count: 1, x0: 73, x1: 74},
+ {count: 1, x0: 74, x1: 75},
+ {count: 0, x0: 75, x1: 76},
+ {count: 1, x0: 76, x1: 76}
+ ],
+ fieldType: 'integer',
+ value: [1, 76],
+ type: 'range',
+ typeOptions: ['range']
+ }
+ }
+];
+
+export const expectedHexDataset = {
+ id: dataId,
+ fields,
+ allData,
+ data: filteredData,
+ filteredIndex,
+ filteredIndexForDomain,
+ fieldPairs: [],
+ label: 'new dataset',
+ color: 'dont test me'
+};
+
export const mergedH3Layer = new H3Layer({
id: 'avlgol'
});
@@ -238,13 +530,7 @@ mergedH3Layer.config = {
isVisible: true,
highlightColor: [252, 242, 26, 255],
isConfigActive: false,
- colorField: {
- name: 'value',
- format: '',
- tableFieldIndex: 2,
- type: 'integer',
- id: 'value'
- },
+ colorField: fields[1],
colorScale: 'quantile',
colorDomain: [12, 13, 13, 15, 15, 15, 15, 15, 16, 16, 17, 17, 18, 18],
sizeField: null,
@@ -284,28 +570,3 @@ mergedH3Layer.config = {
enabled: false
}
};
-
-export const mergedFilters = [
- {
- dataId: [dataId],
- id: 'value',
- name: ['value'],
- type: 'range',
- value: [11.2, 18],
- enlarged: false,
- freeze: true,
- plotType: 'histogram',
- yAxis: null,
- isAnimating: false,
- fieldIdx: [1],
- domain: [1, 76],
- step: 0.1,
- interval: null,
- histogram: ['Not tested'],
- enlargedHistogram: ['Not tested'],
- speed: 1,
- fieldType: 'integer',
- typeOptions: ['range'],
- fixedDomain: false
- }
-];
diff --git a/test/node/reducers/composer-state-test.js b/test/node/reducers/composer-state-test.js
index 4c81b1112..869bbff40 100644
--- a/test/node/reducers/composer-state-test.js
+++ b/test/node/reducers/composer-state-test.js
@@ -25,8 +25,8 @@ import {registerEntry} from 'actions/identity-actions';
import {processCsvData} from 'processors/data-processor';
import testCsvData, {sampleConfig} from 'test/fixtures/test-csv-data';
-import testHexIdData, {hexIdDataConfig, mergedH3Layer, mergedFilters} from 'test/fixtures/test-hex-id-data';
-import {cmpLayers, cmpFilters, cmpDatasets, cmpInteraction} from 'test/helpers/comparison-utils';
+import testHexIdData, {hexIdDataConfig, mergedH3Layer, mergedFilters, expectedHexDataset} from 'test/fixtures/test-hex-id-data';
+import {cmpLayers, cmpFilters, cmpDatasets, cmpDataset, cmpInteraction} from 'test/helpers/comparison-utils';
import {INITIAL_UI_STATE} from 'reducers/ui-state-updaters';
const mockRawData = {
@@ -194,10 +194,8 @@ test('#composerStateReducer - addDataToMapUpdater: keepExistingConfig', t => {
});
const hexDataset = nextState1.visState.datasets[hexDataId];
+ cmpDataset(t, expectedHexDataset, nextState1.visState.datasets[hexDataId])
- t.equal(hexDataset.allData.length, hexData.rows.length, 'should only have new data');
- t.equal(hexDataset.fields.length, hexData.fields.length, 'should have same length of fields');
- t.equal(hexDataset.id, hexDataId, 'should have the id');
t.deepEqual(nextState1.visState.splitMaps, [], 'should clear out splitMaps');
cmpLayers(t, [mergedH3Layer], nextState1.visState.layers);
diff --git a/test/node/reducers/vis-state-test.js b/test/node/reducers/vis-state-test.js
index 5e6bdf47c..f4d86b953 100644
--- a/test/node/reducers/vis-state-test.js
+++ b/test/node/reducers/vis-state-test.js
@@ -1809,7 +1809,7 @@ test('#visStateReducer -> SET_FILTER (processCsvData)', t => {
const updatedField = {
...initialState.datasets.smoothie.fields[10],
- filterProp: {
+ filterProps: {
type: 'multiSelect',
value: [],
fieldType: 'date',
@@ -2264,7 +2264,7 @@ test('#visStateReducer -> SET_FILTER (processGeojson)', t => {
? {
...f,
id: f.name,
- filterProp: {
+ filterProps: {
domain: [4, 20],
fieldType: 'integer',
histogram: expectedHistogram,
@@ -2421,7 +2421,7 @@ test('#visStateReducer -> SET_FILTER.fixedDomain', t => {
f.name === 'gps_data.utc_timestamp'
? {
...f,
- filterProp: {
+ filterProps: {
domain: [1474070995000, 1474072208000],
step: 1000,
mappedValue: expectedFilterTs.mappedValue,
@@ -2468,7 +2468,7 @@ test('#visStateReducer -> SET_FILTER.fixedDomain', t => {
f.name === 'date'
? {
...f,
- filterProp: {
+ filterProps: {
domain: ['2016-09-23', '2016-09-24', '2016-10-10'],
fieldType: 'date',
type: 'multiSelect',