You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@zeppelin.apache.org by pr...@apache.org on 2018/02/23 04:54:45 UTC
[05/12] zeppelin git commit: [ZEPPELIN-3245] checkstyle/eslintrc for
zeppelin-web (JavaScript)
http://git-wip-us.apache.org/repos/asf/zeppelin/blob/ea2c9447/zeppelin-web/src/app/tabledata/advanced-transformation-util.test.js
----------------------------------------------------------------------
diff --git a/zeppelin-web/src/app/tabledata/advanced-transformation-util.test.js b/zeppelin-web/src/app/tabledata/advanced-transformation-util.test.js
index 90f569f..84ea441 100644
--- a/zeppelin-web/src/app/tabledata/advanced-transformation-util.test.js
+++ b/zeppelin-web/src/app/tabledata/advanced-transformation-util.test.js
@@ -12,1728 +12,1730 @@
* limitations under the License.
*/
-import * as Util from './advanced-transformation-util.js'
+import * as Util from './advanced-transformation-util.js';
/* eslint-disable max-len */
const MockParameter = {
- 'floatParam': { valueType: 'float', defaultValue: 10, description: '', },
- 'intParam': { valueType: 'int', defaultValue: 50, description: '', },
- 'jsonParam': { valueType: 'JSON', defaultValue: '', description: '', widget: 'textarea', },
- 'stringParam1': { valueType: 'string', defaultValue: '', description: '', },
- 'stringParam2': { valueType: 'string', defaultValue: '', description: '', widget: 'input', },
- 'boolParam': { valueType: 'boolean', defaultValue: false, description: '', widget: 'checkbox', },
- 'optionParam': { valueType: 'string', defaultValue: 'line', description: '', widget: 'option', optionValues: [ 'line', 'smoothedLine', ], },
-}
+ 'floatParam': {valueType: 'float', defaultValue: 10, description: ''},
+ 'intParam': {valueType: 'int', defaultValue: 50, description: ''},
+ 'jsonParam': {valueType: 'JSON', defaultValue: '', description: '', widget: 'textarea'},
+ 'stringParam1': {valueType: 'string', defaultValue: '', description: ''},
+ 'stringParam2': {valueType: 'string', defaultValue: '', description: '', widget: 'input'},
+ 'boolParam': {valueType: 'boolean', defaultValue: false, description: '', widget: 'checkbox'},
+ 'optionParam': {valueType: 'string', defaultValue: 'line', description: '', widget: 'option', optionValues: ['line', 'smoothedLine']},
+};
/* eslint-enable max-len */
const MockAxis1 = {
- 'keyAxis': { dimension: 'multiple', axisType: 'key', },
- 'aggrAxis': { dimension: 'multiple', axisType: 'aggregator', },
- 'groupAxis': { dimension: 'multiple', axisType: 'group', },
-}
+ 'keyAxis': {dimension: 'multiple', axisType: 'key'},
+ 'aggrAxis': {dimension: 'multiple', axisType: 'aggregator'},
+ 'groupAxis': {dimension: 'multiple', axisType: 'group'},
+};
const MockAxis2 = {
- 'singleKeyAxis': { dimension: 'single', axisType: 'key', },
- 'limitedAggrAxis': { dimension: 'multiple', axisType: 'aggregator', maxAxisCount: 2, },
- 'groupAxis': { dimension: 'multiple', axisType: 'group', },
-}
+ 'singleKeyAxis': {dimension: 'single', axisType: 'key'},
+ 'limitedAggrAxis': {dimension: 'multiple', axisType: 'aggregator', maxAxisCount: 2},
+ 'groupAxis': {dimension: 'multiple', axisType: 'group'},
+};
const MockAxis3 = {
- 'customAxis1': { dimension: 'single', axisType: 'unique', },
- 'customAxis2': { dimension: 'multiple', axisType: 'value', },
-}
+ 'customAxis1': {dimension: 'single', axisType: 'unique'},
+ 'customAxis2': {dimension: 'multiple', axisType: 'value'},
+};
const MockAxis4 = {
- 'key1Axis': { dimension: 'multiple', axisType: 'key', },
- 'key2Axis': { dimension: 'multiple', axisType: 'key', },
- 'aggrAxis': { dimension: 'multiple', axisType: 'aggregator', },
- 'groupAxis': { dimension: 'multiple', axisType: 'group', },
-}
+ 'key1Axis': {dimension: 'multiple', axisType: 'key'},
+ 'key2Axis': {dimension: 'multiple', axisType: 'key'},
+ 'aggrAxis': {dimension: 'multiple', axisType: 'aggregator'},
+ 'groupAxis': {dimension: 'multiple', axisType: 'group'},
+};
// test spec for axis, param, widget
const MockSpec = {
charts: {
'object-chart': {
- transform: { method: 'object', },
+ transform: {method: 'object'},
sharedAxis: true,
axis: JSON.parse(JSON.stringify(MockAxis1)),
parameter: MockParameter,
},
'array-chart': {
- transform: { method: 'array', },
+ transform: {method: 'array'},
sharedAxis: true,
axis: JSON.parse(JSON.stringify(MockAxis1)),
parameter: {
- 'arrayChartParam0': { valueType: 'string', defaultValue: '', description: 'param0', },
+ 'arrayChartParam0': {valueType: 'string', defaultValue: '', description: 'param0'},
},
},
'drillDown-chart': {
- transform: { method: 'drill-down', },
+ transform: {method: 'drill-down'},
axis: JSON.parse(JSON.stringify(MockAxis2)),
parameter: {
- 'drillDownChartParam0': { valueType: 'string', defaultValue: '', description: 'param0', },
+ 'drillDownChartParam0': {valueType: 'string', defaultValue: '', description: 'param0'},
},
},
'raw-chart': {
- transform: { method: 'raw', },
+ transform: {method: 'raw'},
axis: JSON.parse(JSON.stringify(MockAxis3)),
parameter: {
- 'rawChartParam0': { valueType: 'string', defaultValue: '', description: 'param0', },
+ 'rawChartParam0': {valueType: 'string', defaultValue: '', description: 'param0'},
},
},
},
-}
+};
// test spec for transformation
const MockSpec2 = {
charts: {
'object-chart': {
- transform: { method: 'object', },
+ transform: {method: 'object'},
sharedAxis: false,
axis: JSON.parse(JSON.stringify(MockAxis1)),
parameter: MockParameter,
},
'array-chart': {
- transform: { method: 'array', },
+ transform: {method: 'array'},
sharedAxis: false,
axis: JSON.parse(JSON.stringify(MockAxis1)),
parameter: {
- 'arrayChartParam0': { valueType: 'string', defaultValue: '', description: 'param0', },
+ 'arrayChartParam0': {valueType: 'string', defaultValue: '', description: 'param0'},
},
},
'drillDown-chart': {
- transform: { method: 'drill-down', },
+ transform: {method: 'drill-down'},
sharedAxis: false,
axis: JSON.parse(JSON.stringify(MockAxis1)),
parameter: {
- 'drillDownChartParam0': { valueType: 'string', defaultValue: '', description: 'param0', },
+ 'drillDownChartParam0': {valueType: 'string', defaultValue: '', description: 'param0'},
},
},
'array2Key-chart': {
- transform: { method: 'array:2-key', },
+ transform: {method: 'array:2-key'},
sharedAxis: false,
axis: JSON.parse(JSON.stringify(MockAxis4)),
parameter: {
- 'drillDownChartParam0': { valueType: 'string', defaultValue: '', description: 'param0', },
+ 'drillDownChartParam0': {valueType: 'string', defaultValue: '', description: 'param0'},
},
},
'raw-chart': {
- transform: { method: 'raw', },
+ transform: {method: 'raw'},
sharedAxis: false,
axis: JSON.parse(JSON.stringify(MockAxis3)),
parameter: {
- 'rawChartParam0': { valueType: 'string', defaultValue: '', description: 'param0', },
+ 'rawChartParam0': {valueType: 'string', defaultValue: '', description: 'param0'},
},
},
},
-}
+};
/* eslint-disable max-len */
const MockTableDataColumn = [
- {'name': 'age', 'index': 0, 'aggr': 'sum', },
- {'name': 'job', 'index': 1, 'aggr': 'sum', },
- {'name': 'marital', 'index': 2, 'aggr': 'sum', },
- {'name': 'education', 'index': 3, 'aggr': 'sum', },
- {'name': 'default', 'index': 4, 'aggr': 'sum', },
- {'name': 'balance', 'index': 5, 'aggr': 'sum', },
- {'name': 'housing', 'index': 6, 'aggr': 'sum', },
- {'name': 'loan', 'index': 7, 'aggr': 'sum', },
- {'name': 'contact', 'index': 8, 'aggr': 'sum', },
- {'name': 'day', 'index': 9, 'aggr': 'sum', },
- {'name': 'month', 'index': 10, 'aggr': 'sum', },
- {'name': 'duration', 'index': 11, 'aggr': 'sum', },
- {'name': 'campaign', 'index': 12, 'aggr': 'sum', },
- {'name': 'pdays', 'index': 13, 'aggr': 'sum', },
- {'name': 'previous', 'index': 14, 'aggr': 'sum', },
- {'name': 'poutcome', 'index': 15, 'aggr': 'sum', },
- {'name': 'y', 'index': 16, 'aggr': 'sum', }
-]
+ {'name': 'age', 'index': 0, 'aggr': 'sum'},
+ {'name': 'job', 'index': 1, 'aggr': 'sum'},
+ {'name': 'marital', 'index': 2, 'aggr': 'sum'},
+ {'name': 'education', 'index': 3, 'aggr': 'sum'},
+ {'name': 'default', 'index': 4, 'aggr': 'sum'},
+ {'name': 'balance', 'index': 5, 'aggr': 'sum'},
+ {'name': 'housing', 'index': 6, 'aggr': 'sum'},
+ {'name': 'loan', 'index': 7, 'aggr': 'sum'},
+ {'name': 'contact', 'index': 8, 'aggr': 'sum'},
+ {'name': 'day', 'index': 9, 'aggr': 'sum'},
+ {'name': 'month', 'index': 10, 'aggr': 'sum'},
+ {'name': 'duration', 'index': 11, 'aggr': 'sum'},
+ {'name': 'campaign', 'index': 12, 'aggr': 'sum'},
+ {'name': 'pdays', 'index': 13, 'aggr': 'sum'},
+ {'name': 'previous', 'index': 14, 'aggr': 'sum'},
+ {'name': 'poutcome', 'index': 15, 'aggr': 'sum'},
+ {'name': 'y', 'index': 16, 'aggr': 'sum'},
+];
const MockTableDataRows1 = [
- [ '44', 'services', 'single', 'tertiary', 'no', '106', 'no', 'no', 'unknown', '12', 'jun', '109', '2', '-1', '0', 'unknown', 'no' ],
- [ '43', 'services', 'married', 'primary', 'no', '-88', 'yes', 'yes', 'cellular', '17', 'apr', '313', '1', '147', '2', 'failure', 'no' ],
- [ '39', 'services', 'married', 'secondary', 'no', '9374', 'yes', 'no', 'unknown', '20', 'may', '273', '1', '-1', '0', 'unknown', 'no' ],
- [ '33', 'services', 'single', 'tertiary', 'no', '4789', 'yes', 'yes', 'cellular', '11', 'may', '220', '1', '339', '4', 'failure', 'no' ],
-]
+ ['44', 'services', 'single', 'tertiary', 'no', '106', 'no', 'no', 'unknown', '12', 'jun', '109', '2', '-1', '0', 'unknown', 'no'],
+ ['43', 'services', 'married', 'primary', 'no', '-88', 'yes', 'yes', 'cellular', '17', 'apr', '313', '1', '147', '2', 'failure', 'no'],
+ ['39', 'services', 'married', 'secondary', 'no', '9374', 'yes', 'no', 'unknown', '20', 'may', '273', '1', '-1', '0', 'unknown', 'no'],
+ ['33', 'services', 'single', 'tertiary', 'no', '4789', 'yes', 'yes', 'cellular', '11', 'may', '220', '1', '339', '4', 'failure', 'no'],
+];
/* eslint-enable max-len */
describe('advanced-transformation-util', () => {
describe('getCurrent* funcs', () => {
it('should set return proper value of the current chart', () => {
- const config = {}
- const spec = JSON.parse(JSON.stringify(MockSpec))
- Util.initializeConfig(config, spec)
- expect(Util.getCurrentChart(config)).toEqual('object-chart')
- expect(Util.getCurrentChartTransform(config)).toEqual({method: 'object'})
+ const config = {};
+ const spec = JSON.parse(JSON.stringify(MockSpec));
+ Util.initializeConfig(config, spec);
+ expect(Util.getCurrentChart(config)).toEqual('object-chart');
+ expect(Util.getCurrentChartTransform(config)).toEqual({method: 'object'});
// use `toBe` to compare reference
- expect(Util.getCurrentChartAxis(config)).toBe(config.axis['object-chart'])
+ expect(Util.getCurrentChartAxis(config)).toBe(config.axis['object-chart']);
// use `toBe` to compare reference
- expect(Util.getCurrentChartParam(config)).toBe(config.parameter['object-chart'])
- })
- })
+ expect(Util.getCurrentChartParam(config)).toBe(config.parameter['object-chart']);
+ });
+ });
describe('useSharedAxis', () => {
it('should set chartChanged for initial drawing', () => {
- const config = {}
- const spec = JSON.parse(JSON.stringify(MockSpec))
- Util.initializeConfig(config, spec)
- expect(Util.useSharedAxis(config, 'object-chart')).toEqual(true)
- expect(Util.useSharedAxis(config, 'array-chart')).toEqual(true)
- expect(Util.useSharedAxis(config, 'drillDown-chart')).toBeUndefined()
- expect(Util.useSharedAxis(config, 'raw-chart')).toBeUndefined()
- })
- })
+ const config = {};
+ const spec = JSON.parse(JSON.stringify(MockSpec));
+ Util.initializeConfig(config, spec);
+ expect(Util.useSharedAxis(config, 'object-chart')).toEqual(true);
+ expect(Util.useSharedAxis(config, 'array-chart')).toEqual(true);
+ expect(Util.useSharedAxis(config, 'drillDown-chart')).toBeUndefined();
+ expect(Util.useSharedAxis(config, 'raw-chart')).toBeUndefined();
+ });
+ });
describe('initializeConfig', () => {
- const config = {}
- const spec = JSON.parse(JSON.stringify(MockSpec))
- Util.initializeConfig(config, spec)
+ const config = {};
+ const spec = JSON.parse(JSON.stringify(MockSpec));
+ Util.initializeConfig(config, spec);
it('should set chartChanged for initial drawing', () => {
- expect(config.chartChanged).toBe(true)
- expect(config.parameterChanged).toBe(false)
- })
+ expect(config.chartChanged).toBe(true);
+ expect(config.parameterChanged).toBe(false);
+ });
it('should set panel toggles ', () => {
- expect(config.panel.columnPanelOpened).toBe(true)
- expect(config.panel.parameterPanelOpened).toBe(false)
- })
+ expect(config.panel.columnPanelOpened).toBe(true);
+ expect(config.panel.parameterPanelOpened).toBe(false);
+ });
it('should set version and initialized', () => {
- expect(config.spec.version).toBeDefined()
- expect(config.spec.initialized).toBe(true)
- })
+ expect(config.spec.version).toBeDefined();
+ expect(config.spec.initialized).toBe(true);
+ });
it('should set chart', () => {
- expect(config.chart.current).toBe('object-chart')
+ expect(config.chart.current).toBe('object-chart');
expect(config.chart.available).toEqual([
'object-chart',
'array-chart',
'drillDown-chart',
'raw-chart',
- ])
- })
+ ]);
+ });
it('should set sharedAxis', () => {
expect(config.sharedAxis).toEqual({
keyAxis: [], aggrAxis: [], groupAxis: [],
- })
+ });
// should use `toBe` to compare object reference
- expect(config.sharedAxis).toBe(config.axis['object-chart'])
+ expect(config.sharedAxis).toBe(config.axis['object-chart']);
// should use `toBe` to compare object reference
- expect(config.sharedAxis).toBe(config.axis['array-chart'])
- })
+ expect(config.sharedAxis).toBe(config.axis['array-chart']);
+ });
it('should set paramSpecs', () => {
- const expected = Util.getSpecs(MockParameter)
- expect(config.paramSpecs['object-chart']).toEqual(expected)
- expect(config.paramSpecs['array-chart'].length).toEqual(1)
- expect(config.paramSpecs['drillDown-chart'].length).toEqual(1)
- expect(config.paramSpecs['raw-chart'].length).toEqual(1)
- })
+ const expected = Util.getSpecs(MockParameter);
+ expect(config.paramSpecs['object-chart']).toEqual(expected);
+ expect(config.paramSpecs['array-chart'].length).toEqual(1);
+ expect(config.paramSpecs['drillDown-chart'].length).toEqual(1);
+ expect(config.paramSpecs['raw-chart'].length).toEqual(1);
+ });
it('should set parameter with default value', () => {
- expect(Object.keys(MockParameter).length).toBeGreaterThan(0) // length > 0
+ expect(Object.keys(MockParameter).length).toBeGreaterThan(0); // length > 0
for (let paramName in MockParameter) {
- expect(config.parameter['object-chart'][paramName])
- .toEqual(MockParameter[paramName].defaultValue)
+ if (MockParameter.hasOwnProperty(paramName)) {
+ expect(config.parameter['object-chart'][paramName])
+ .toEqual(MockParameter[paramName].defaultValue);
+ }
}
- })
+ });
it('should set axisSpecs', () => {
- const expected = Util.getSpecs(MockAxis1)
- expect(config.axisSpecs['object-chart']).toEqual(expected)
- expect(config.axisSpecs['array-chart'].length).toEqual(3)
- expect(config.axisSpecs['drillDown-chart'].length).toEqual(3)
- expect(config.axisSpecs['raw-chart'].length).toEqual(2)
- })
+ const expected = Util.getSpecs(MockAxis1);
+ expect(config.axisSpecs['object-chart']).toEqual(expected);
+ expect(config.axisSpecs['array-chart'].length).toEqual(3);
+ expect(config.axisSpecs['drillDown-chart'].length).toEqual(3);
+ expect(config.axisSpecs['raw-chart'].length).toEqual(2);
+ });
it('should prepare axis depending on dimension', () => {
expect(config.axis['object-chart']).toEqual({
keyAxis: [], aggrAxis: [], groupAxis: [],
- })
+ });
expect(config.axis['array-chart']).toEqual({
keyAxis: [], aggrAxis: [], groupAxis: [],
- })
+ });
// it's ok not to set single dimension axis
- expect(config.axis['drillDown-chart']).toEqual({ limitedAggrAxis: [], groupAxis: [], })
+ expect(config.axis['drillDown-chart']).toEqual({limitedAggrAxis: [], groupAxis: []});
// it's ok not to set single dimension axis
- expect(config.axis['raw-chart']).toEqual({ customAxis2: [], })
- })
- })
+ expect(config.axis['raw-chart']).toEqual({customAxis2: []});
+ });
+ });
describe('axis', () => {
- })
+ });
describe('parameter:widget', () => {
it('isInputWidget', () => {
- expect(Util.isInputWidget(MockParameter.stringParam1)).toBe(true)
- expect(Util.isInputWidget(MockParameter.stringParam2)).toBe(true)
+ expect(Util.isInputWidget(MockParameter.stringParam1)).toBe(true);
+ expect(Util.isInputWidget(MockParameter.stringParam2)).toBe(true);
- expect(Util.isInputWidget(MockParameter.boolParam)).toBe(false)
- expect(Util.isInputWidget(MockParameter.jsonParam)).toBe(false)
- expect(Util.isInputWidget(MockParameter.optionParam)).toBe(false)
- })
+ expect(Util.isInputWidget(MockParameter.boolParam)).toBe(false);
+ expect(Util.isInputWidget(MockParameter.jsonParam)).toBe(false);
+ expect(Util.isInputWidget(MockParameter.optionParam)).toBe(false);
+ });
it('isOptionWidget', () => {
- expect(Util.isOptionWidget(MockParameter.optionParam)).toBe(true)
+ expect(Util.isOptionWidget(MockParameter.optionParam)).toBe(true);
- expect(Util.isOptionWidget(MockParameter.stringParam1)).toBe(false)
- expect(Util.isOptionWidget(MockParameter.stringParam2)).toBe(false)
- expect(Util.isOptionWidget(MockParameter.boolParam)).toBe(false)
- expect(Util.isOptionWidget(MockParameter.jsonParam)).toBe(false)
- })
+ expect(Util.isOptionWidget(MockParameter.stringParam1)).toBe(false);
+ expect(Util.isOptionWidget(MockParameter.stringParam2)).toBe(false);
+ expect(Util.isOptionWidget(MockParameter.boolParam)).toBe(false);
+ expect(Util.isOptionWidget(MockParameter.jsonParam)).toBe(false);
+ });
it('isCheckboxWidget', () => {
- expect(Util.isCheckboxWidget(MockParameter.boolParam)).toBe(true)
+ expect(Util.isCheckboxWidget(MockParameter.boolParam)).toBe(true);
- expect(Util.isCheckboxWidget(MockParameter.stringParam1)).toBe(false)
- expect(Util.isCheckboxWidget(MockParameter.stringParam2)).toBe(false)
- expect(Util.isCheckboxWidget(MockParameter.jsonParam)).toBe(false)
- expect(Util.isCheckboxWidget(MockParameter.optionParam)).toBe(false)
- })
+ expect(Util.isCheckboxWidget(MockParameter.stringParam1)).toBe(false);
+ expect(Util.isCheckboxWidget(MockParameter.stringParam2)).toBe(false);
+ expect(Util.isCheckboxWidget(MockParameter.jsonParam)).toBe(false);
+ expect(Util.isCheckboxWidget(MockParameter.optionParam)).toBe(false);
+ });
it('isTextareaWidget', () => {
- expect(Util.isTextareaWidget(MockParameter.jsonParam)).toBe(true)
+ expect(Util.isTextareaWidget(MockParameter.jsonParam)).toBe(true);
- expect(Util.isTextareaWidget(MockParameter.stringParam1)).toBe(false)
- expect(Util.isTextareaWidget(MockParameter.stringParam2)).toBe(false)
- expect(Util.isTextareaWidget(MockParameter.boolParam)).toBe(false)
- expect(Util.isTextareaWidget(MockParameter.optionParam)).toBe(false)
- })
- })
+ expect(Util.isTextareaWidget(MockParameter.stringParam1)).toBe(false);
+ expect(Util.isTextareaWidget(MockParameter.stringParam2)).toBe(false);
+ expect(Util.isTextareaWidget(MockParameter.boolParam)).toBe(false);
+ expect(Util.isTextareaWidget(MockParameter.optionParam)).toBe(false);
+ });
+ });
describe('parameter:parseParameter', () => {
- const paramSpec = Util.getSpecs(MockParameter)
+ const paramSpec = Util.getSpecs(MockParameter);
it('should parse number', () => {
- const params = { intParam: '3', }
- const parsed = Util.parseParameter(paramSpec, params)
- expect(parsed.intParam).toBe(3)
- })
+ const params = {intParam: '3'};
+ const parsed = Util.parseParameter(paramSpec, params);
+ expect(parsed.intParam).toBe(3);
+ });
it('should parse float', () => {
- const params = { floatParam: '0.10', }
- const parsed = Util.parseParameter(paramSpec, params)
- expect(parsed.floatParam).toBe(0.10)
- })
+ const params = {floatParam: '0.10'};
+ const parsed = Util.parseParameter(paramSpec, params);
+ expect(parsed.floatParam).toBe(0.10);
+ });
it('should parse boolean', () => {
- const params1 = { boolParam: 'true', }
- const parsed1 = Util.parseParameter(paramSpec, params1)
- expect(typeof parsed1.boolParam).toBe('boolean')
- expect(parsed1.boolParam).toBe(true)
+ const params1 = {boolParam: 'true'};
+ const parsed1 = Util.parseParameter(paramSpec, params1);
+ expect(typeof parsed1.boolParam).toBe('boolean');
+ expect(parsed1.boolParam).toBe(true);
- const params2 = { boolParam: 'false', }
- const parsed2 = Util.parseParameter(paramSpec, params2)
- expect(typeof parsed2.boolParam).toBe('boolean')
- expect(parsed2.boolParam).toBe(false)
- })
+ const params2 = {boolParam: 'false'};
+ const parsed2 = Util.parseParameter(paramSpec, params2);
+ expect(typeof parsed2.boolParam).toBe('boolean');
+ expect(parsed2.boolParam).toBe(false);
+ });
it('should parse JSON', () => {
- const params = { jsonParam: '{ "a": 3 }', }
- const parsed = Util.parseParameter(paramSpec, params)
- expect(typeof parsed.jsonParam).toBe('object')
- expect(JSON.stringify(parsed.jsonParam)).toBe('{"a":3}')
- })
+ const params = {jsonParam: '{ "a": 3 }'};
+ const parsed = Util.parseParameter(paramSpec, params);
+ expect(typeof parsed.jsonParam).toBe('object');
+ expect(JSON.stringify(parsed.jsonParam)).toBe('{"a":3}');
+ });
it('should not parse string', () => {
- const params = { stringParam: 'example', }
- const parsed = Util.parseParameter(paramSpec, params)
- expect(typeof parsed.stringParam).toBe('string')
- expect(parsed.stringParam).toBe('example')
- })
- })
+ const params = {stringParam: 'example'};
+ const parsed = Util.parseParameter(paramSpec, params);
+ expect(typeof parsed.stringParam).toBe('string');
+ expect(parsed.stringParam).toBe('example');
+ });
+ });
describe('removeDuplicatedColumnsInMultiDimensionAxis', () => {
- let config = {}
+ let config = {};
beforeEach(() => {
- config = {}
- const spec = JSON.parse(JSON.stringify(MockSpec))
- Util.initializeConfig(config, spec)
- config.chart.current = 'drillDown-chart' // set non-sharedAxis chart
- })
+ config = {};
+ const spec = JSON.parse(JSON.stringify(MockSpec));
+ Util.initializeConfig(config, spec);
+ config.chart.current = 'drillDown-chart'; // set non-sharedAxis chart
+ });
it('should remove duplicated axis names in config when axis is not aggregator', () => {
const addColumn = function(config, col) {
- const axis = Util.getCurrentChartAxis(config)['groupAxis']
- axis.push(col)
- const axisSpecs = Util.getCurrentChartAxisSpecs(config)
- Util.removeDuplicatedColumnsInMultiDimensionAxis(config, axisSpecs[2])
- }
+ const axis = Util.getCurrentChartAxis(config)['groupAxis'];
+ axis.push(col);
+ const axisSpecs = Util.getCurrentChartAxisSpecs(config);
+ Util.removeDuplicatedColumnsInMultiDimensionAxis(config, axisSpecs[2]);
+ };
- addColumn(config, { name: 'columnA', aggr: 'sum', index: 0, })
- addColumn(config, { name: 'columnA', aggr: 'sum', index: 0, })
- addColumn(config, { name: 'columnA', aggr: 'sum', index: 0, })
+ addColumn(config, {name: 'columnA', aggr: 'sum', index: 0});
+ addColumn(config, {name: 'columnA', aggr: 'sum', index: 0});
+ addColumn(config, {name: 'columnA', aggr: 'sum', index: 0});
- expect(Util.getCurrentChartAxis(config)['groupAxis'].length).toEqual(1)
- })
+ expect(Util.getCurrentChartAxis(config)['groupAxis'].length).toEqual(1);
+ });
it('should remove duplicated axis names in config when axis is aggregator', () => {
const addColumn = function(config, value) {
- const axis = Util.getCurrentChartAxis(config)['limitedAggrAxis']
- axis.push(value)
- const axisSpecs = Util.getCurrentChartAxisSpecs(config)
- Util.removeDuplicatedColumnsInMultiDimensionAxis(config, axisSpecs[1])
- }
+ const axis = Util.getCurrentChartAxis(config)['limitedAggrAxis'];
+ axis.push(value);
+ const axisSpecs = Util.getCurrentChartAxisSpecs(config);
+ Util.removeDuplicatedColumnsInMultiDimensionAxis(config, axisSpecs[1]);
+ };
- config.chart.current = 'drillDown-chart' // set non-sharedAxis chart
- addColumn(config, { name: 'columnA', aggr: 'sum', index: 0, })
- addColumn(config, { name: 'columnA', aggr: 'aggr', index: 0, })
- addColumn(config, { name: 'columnA', aggr: 'sum', index: 0, })
+ config.chart.current = 'drillDown-chart'; // set non-sharedAxis chart
+ addColumn(config, {name: 'columnA', aggr: 'sum', index: 0});
+ addColumn(config, {name: 'columnA', aggr: 'aggr', index: 0});
+ addColumn(config, {name: 'columnA', aggr: 'sum', index: 0});
- expect(Util.getCurrentChartAxis(config)['limitedAggrAxis'].length).toEqual(2)
- })
- })
+ expect(Util.getCurrentChartAxis(config)['limitedAggrAxis'].length).toEqual(2);
+ });
+ });
describe('applyMaxAxisCount', () => {
- const config = {}
- const spec = JSON.parse(JSON.stringify(MockSpec))
- Util.initializeConfig(config, spec)
+ const config = {};
+ const spec = JSON.parse(JSON.stringify(MockSpec));
+ Util.initializeConfig(config, spec);
const addColumn = function(config, value) {
- const axis = Util.getCurrentChartAxis(config)['limitedAggrAxis']
- axis.push(value)
- const axisSpecs = Util.getCurrentChartAxisSpecs(config)
- Util.applyMaxAxisCount(config, axisSpecs[1])
- }
+ const axis = Util.getCurrentChartAxis(config)['limitedAggrAxis'];
+ axis.push(value);
+ const axisSpecs = Util.getCurrentChartAxisSpecs(config);
+ Util.applyMaxAxisCount(config, axisSpecs[1]);
+ };
it('should remove duplicated axis names in config', () => {
- config.chart.current = 'drillDown-chart' // set non-sharedAxis chart
+ config.chart.current = 'drillDown-chart'; // set non-sharedAxis chart
- addColumn(config, 'columnA')
- addColumn(config, 'columnB')
- addColumn(config, 'columnC')
- addColumn(config, 'columnD')
+ addColumn(config, 'columnA');
+ addColumn(config, 'columnB');
+ addColumn(config, 'columnC');
+ addColumn(config, 'columnD');
expect(Util.getCurrentChartAxis(config)['limitedAggrAxis']).toEqual([
'columnC', 'columnD',
- ])
- })
- })
+ ]);
+ });
+ });
describe('getColumnsFromAxis', () => {
it('should return proper value for regular axis spec (key, aggr, group)', () => {
- const config = {}
-
- const spec = JSON.parse(JSON.stringify(MockSpec))
- Util.initializeConfig(config, spec)
- const chart = 'object-chart'
- config.chart.current = chart
-
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- axis['keyAxis'].push('columnA')
- axis['keyAxis'].push('columnB')
- axis['aggrAxis'].push('columnC')
- axis['groupAxis'].push('columnD')
- axis['groupAxis'].push('columnE')
- axis['groupAxis'].push('columnF')
-
- const column = Util.getColumnsFromAxis(axisSpecs, axis)
- expect(column.key).toEqual([ 'columnA', 'columnB', ])
- expect(column.aggregator).toEqual([ 'columnC', ])
- expect(column.group).toEqual([ 'columnD', 'columnE', 'columnF', ])
- })
+ const config = {};
+
+ const spec = JSON.parse(JSON.stringify(MockSpec));
+ Util.initializeConfig(config, spec);
+ const chart = 'object-chart';
+ config.chart.current = chart;
+
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ axis['keyAxis'].push('columnA');
+ axis['keyAxis'].push('columnB');
+ axis['aggrAxis'].push('columnC');
+ axis['groupAxis'].push('columnD');
+ axis['groupAxis'].push('columnE');
+ axis['groupAxis'].push('columnF');
+
+ const column = Util.getColumnsFromAxis(axisSpecs, axis);
+ expect(column.key).toEqual(['columnA', 'columnB']);
+ expect(column.aggregator).toEqual(['columnC']);
+ expect(column.group).toEqual(['columnD', 'columnE', 'columnF']);
+ });
it('should return proper value for custom axis spec', () => {
- const config = {}
- const spec = JSON.parse(JSON.stringify(MockSpec))
- Util.initializeConfig(config, spec)
- const chart = 'raw-chart' // for test custom columns
- config.chart.current = chart
-
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- axis['customAxis1'] = ['columnA']
- axis['customAxis2'].push('columnB')
- axis['customAxis2'].push('columnC')
- axis['customAxis2'].push('columnD')
-
- const column = Util.getColumnsFromAxis(axisSpecs, axis)
- expect(column.custom.unique).toEqual([ 'columnA', ])
- expect(column.custom.value).toEqual([ 'columnB', 'columnC', 'columnD', ])
- })
- })
+ const config = {};
+ const spec = JSON.parse(JSON.stringify(MockSpec));
+ Util.initializeConfig(config, spec);
+ const chart = 'raw-chart'; // for test custom columns
+ config.chart.current = chart;
+
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ axis['customAxis1'] = ['columnA'];
+ axis['customAxis2'].push('columnB');
+ axis['customAxis2'].push('columnC');
+ axis['customAxis2'].push('columnD');
+
+ const column = Util.getColumnsFromAxis(axisSpecs, axis);
+ expect(column.custom.unique).toEqual(['columnA']);
+ expect(column.custom.value).toEqual(['columnB', 'columnC', 'columnD']);
+ });
+ });
// it's hard to test all methods for transformation.
// so let's do behavioral (black-box) test instead of
describe('getTransformer', () => {
describe('method: raw', () => {
- let config = {}
- const spec = JSON.parse(JSON.stringify(MockSpec2))
- Util.initializeConfig(config, spec)
+ let config = {};
+ const spec = JSON.parse(JSON.stringify(MockSpec2));
+ Util.initializeConfig(config, spec);
it('should return original rows when transform.method is `raw`', () => {
- const chart = 'raw-chart'
- config.chart.current = chart
+ const chart = 'raw-chart';
+ config.chart.current = chart;
- const rows = [ { 'r1': 1, }, ]
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, rows, axisSpecs, axis).transformer
- const transformed = transformer()
+ const rows = [{'r1': 1}];
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, rows, axisSpecs, axis).transformer;
+ const transformed = transformer();
- expect(transformed).toBe(rows)
- })
- })
+ expect(transformed).toBe(rows);
+ });
+ });
describe('array method', () => {
- let config = {}
- const chart = 'array-chart'
- let ageColumn = null
- let balanceColumn = null
- let educationColumn = null
- let martialColumn = null
- let tableDataRows = []
+ let config = {};
+ const chart = 'array-chart';
+ let ageColumn = null;
+ let balanceColumn = null;
+ let educationColumn = null;
+ let martialColumn = null;
+ let tableDataRows = [];
beforeEach(() => {
- const spec = JSON.parse(JSON.stringify(MockSpec2))
- config = {}
- Util.initializeConfig(config, spec)
- config.chart.current = chart
- tableDataRows = JSON.parse(JSON.stringify(MockTableDataRows1))
- ageColumn = JSON.parse(JSON.stringify(MockTableDataColumn[0]))
- balanceColumn = JSON.parse(JSON.stringify(MockTableDataColumn[5]))
- educationColumn = JSON.parse(JSON.stringify(MockTableDataColumn[3]))
- martialColumn = JSON.parse(JSON.stringify(MockTableDataColumn[2]))
- })
+ const spec = JSON.parse(JSON.stringify(MockSpec2));
+ config = {};
+ Util.initializeConfig(config, spec);
+ config.chart.current = chart;
+ tableDataRows = JSON.parse(JSON.stringify(MockTableDataRows1));
+ ageColumn = JSON.parse(JSON.stringify(MockTableDataColumn[0]));
+ balanceColumn = JSON.parse(JSON.stringify(MockTableDataColumn[5]));
+ educationColumn = JSON.parse(JSON.stringify(MockTableDataColumn[3]));
+ martialColumn = JSON.parse(JSON.stringify(MockTableDataColumn[2]));
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
-
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
-
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ '', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', ])
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
+
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
+
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['age(sum)']);
expect(rows).toEqual([
- { selector: 'age(sum)', value: [ 159, ], }
- ])
- })
+ {selector: 'age(sum)', value: [159]},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(count)', () => {
- ageColumn.aggr = 'count'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'count';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- let { rows, } = transformer()
+ let {rows} = transformer();
expect(rows).toEqual([
- { selector: 'age(count)', value: [ 4, ], }
- ])
- })
+ {selector: 'age(count)', value: [4]},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(avg)', () => {
- ageColumn.aggr = 'avg'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'avg';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
+ const {rows} = transformer();
expect(rows).toEqual([
- { selector: 'age(avg)', value: [ (44 + 43 + 39 + 33) / 4.0, ], }
- ])
- })
+ {selector: 'age(avg)', value: [(44 + 43 + 39 + 33) / 4.0]},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(max)', () => {
- ageColumn.aggr = 'max'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'max';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
+ const {rows} = transformer();
expect(rows).toEqual([
- { selector: 'age(max)', value: [ 44, ], }
- ])
- })
+ {selector: 'age(max)', value: [44]},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(min)', () => {
- ageColumn.aggr = 'min'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'min';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
+ const {rows} = transformer();
expect(rows).toEqual([
- { selector: 'age(min)', value: [ 33, ], }
- ])
- })
+ {selector: 'age(min)', value: [33]},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 2 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- balanceColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].aggrAxis.push(balanceColumn)
+ ageColumn.aggr = 'sum';
+ balanceColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].aggrAxis.push(balanceColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ '', ])
- expect(groupNames).toEqual([ 'age(sum)', 'balance(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', 'balance(sum)', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['']);
+ expect(groupNames).toEqual(['age(sum)', 'balance(sum)']);
+ expect(selectors).toEqual(['age(sum)', 'balance(sum)']);
expect(rows).toEqual([
- { selector: 'age(sum)', value: [ 159, ], },
- { selector: 'balance(sum)', value: [ 14181, ], },
- ])
- })
+ {selector: 'age(sum)', value: [159]},
+ {selector: 'balance(sum)', value: [14181]},
+ ]);
+ });
it('should transform properly: 0 key, 1 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].groupAxis.push(martialColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital', ])
- expect(groupNames).toEqual([ 'married', 'single', ])
- expect(selectors).toEqual([ 'married', 'single', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital']);
+ expect(groupNames).toEqual(['married', 'single']);
+ expect(selectors).toEqual(['married', 'single']);
expect(rows).toEqual([
- { selector: 'married', value: [ 82, ], },
- { selector: 'single', value: [ 77, ], },
- ])
- })
+ {selector: 'married', value: [82]},
+ {selector: 'single', value: [77]},
+ ]);
+ });
it('should transform properly: 0 key, 1 group, 2 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- balanceColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].aggrAxis.push(balanceColumn)
- config.axis[chart].groupAxis.push(martialColumn)
+ ageColumn.aggr = 'sum';
+ balanceColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].aggrAxis.push(balanceColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital', ])
- expect(groupNames).toEqual([ 'married', 'single', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital']);
+ expect(groupNames).toEqual(['married', 'single']);
expect(selectors).toEqual([
'married / age(sum)', 'married / balance(sum)', 'single / age(sum)', 'single / balance(sum)',
- ])
+ ]);
expect(rows).toEqual([
- { selector: 'married / age(sum)', value: [ 82 ] },
- { selector: 'married / balance(sum)', value: [ 9286 ] },
- { selector: 'single / age(sum)', value: [ 77 ] },
- { selector: 'single / balance(sum)', value: [ 4895 ] },
- ])
- })
+ {selector: 'married / age(sum)', value: [82]},
+ {selector: 'married / balance(sum)', value: [9286]},
+ {selector: 'single / age(sum)', value: [77]},
+ {selector: 'single / balance(sum)', value: [4895]},
+ ]);
+ });
it('should transform properly: 0 key, 2 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].groupAxis.push(martialColumn)
- config.axis[chart].groupAxis.push(educationColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
+ config.axis[chart].groupAxis.push(educationColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital.education', ])
- expect(groupNames).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
- expect(selectors).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital.education']);
+ expect(groupNames).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
+ expect(selectors).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
expect(rows).toEqual([
- { selector: 'married.primary', value: [ '43' ] },
- { selector: 'married.secondary', value: [ '39' ] },
- { selector: 'single.tertiary', value: [ 77 ] },
- ])
- })
+ {selector: 'married.primary', value: ['43']},
+ {selector: 'married.secondary', value: ['39']},
+ {selector: 'single.tertiary', value: [77]},
+ ]);
+ });
it('should transform properly: 1 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].keyAxis.push(martialColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].keyAxis.push(martialColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('marital')
- expect(keyNames).toEqual([ 'married', 'single', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', ])
+ expect(keyColumnName).toEqual('marital');
+ expect(keyNames).toEqual(['married', 'single']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['age(sum)']);
expect(rows).toEqual([
- { selector: 'age(sum)', value: [ 82, 77, ] },
- ])
- })
+ {selector: 'age(sum)', value: [82, 77]},
+ ]);
+ });
it('should transform properly: 2 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].keyAxis.push(martialColumn)
- config.axis[chart].keyAxis.push(educationColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].keyAxis.push(martialColumn);
+ config.axis[chart].keyAxis.push(educationColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('marital.education')
- expect(keyNames).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', ])
+ expect(keyColumnName).toEqual('marital.education');
+ expect(keyNames).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['age(sum)']);
expect(rows).toEqual([
- { selector: 'age(sum)', value: [ '43', '39', 77, ] },
- ])
- })
+ {selector: 'age(sum)', value: ['43', '39', 77]},
+ ]);
+ });
it('should transform properly: 1 key, 1 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].keyAxis.push(martialColumn)
- config.axis[chart].groupAxis.push(educationColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].keyAxis.push(martialColumn);
+ config.axis[chart].groupAxis.push(educationColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('marital')
- expect(keyNames).toEqual([ 'married', 'single', ])
- expect(groupNames).toEqual([ 'primary', 'secondary', 'tertiary', ])
- expect(selectors).toEqual([ 'primary', 'secondary', 'tertiary', ])
+ expect(keyColumnName).toEqual('marital');
+ expect(keyNames).toEqual(['married', 'single']);
+ expect(groupNames).toEqual(['primary', 'secondary', 'tertiary']);
+ expect(selectors).toEqual(['primary', 'secondary', 'tertiary']);
expect(rows).toEqual([
- { selector: 'primary', value: [ '43', null, ] },
- { selector: 'secondary', value: [ '39', null, ] },
- { selector: 'tertiary', value: [ null, 77, ] },
- ])
- })
- }) // end: describe('method: array')
+ {selector: 'primary', value: ['43', null]},
+ {selector: 'secondary', value: ['39', null]},
+ {selector: 'tertiary', value: [null, 77]},
+ ]);
+ });
+ }); // end: describe('method: array')
describe('method: object', () => {
- let config = {}
- const chart = 'object-chart'
- let ageColumn = null
- let balanceColumn = null
- let educationColumn = null
- let martialColumn = null
- const tableDataRows = JSON.parse(JSON.stringify(MockTableDataRows1))
+ let config = {};
+ const chart = 'object-chart';
+ let ageColumn = null;
+ let balanceColumn = null;
+ let educationColumn = null;
+ let martialColumn = null;
+ const tableDataRows = JSON.parse(JSON.stringify(MockTableDataRows1));
beforeEach(() => {
- const spec = JSON.parse(JSON.stringify(MockSpec2))
- config = {}
- Util.initializeConfig(config, spec)
- config.chart.current = chart
- ageColumn = JSON.parse(JSON.stringify(MockTableDataColumn[0]))
- balanceColumn = JSON.parse(JSON.stringify(MockTableDataColumn[5]))
- educationColumn = JSON.parse(JSON.stringify(MockTableDataColumn[3]))
- martialColumn = JSON.parse(JSON.stringify(MockTableDataColumn[2]))
- })
+ const spec = JSON.parse(JSON.stringify(MockSpec2));
+ config = {};
+ Util.initializeConfig(config, spec);
+ config.chart.current = chart;
+ ageColumn = JSON.parse(JSON.stringify(MockTableDataColumn[0]));
+ balanceColumn = JSON.parse(JSON.stringify(MockTableDataColumn[5]));
+ educationColumn = JSON.parse(JSON.stringify(MockTableDataColumn[3]));
+ martialColumn = JSON.parse(JSON.stringify(MockTableDataColumn[2]));
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ '', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', ])
- expect(rows).toEqual([{ 'age(sum)': 44 + 43 + 39 + 33, }])
- })
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['age(sum)']);
+ expect(rows).toEqual([{'age(sum)': 44 + 43 + 39 + 33}]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(count)', () => {
- ageColumn.aggr = 'count'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'count';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
- expect(rows).toEqual([{ 'age(count)': 4, }])
- })
+ const {rows} = transformer();
+ expect(rows).toEqual([{'age(count)': 4}]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(avg)', () => {
- ageColumn.aggr = 'avg'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'avg';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
+ const {rows} = transformer();
expect(rows).toEqual([
- { 'age(avg)': (44 + 43 + 39 + 33) / 4.0, }
- ])
- })
+ {'age(avg)': (44 + 43 + 39 + 33) / 4.0},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(max)', () => {
- ageColumn.aggr = 'max'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'max';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
- expect(rows).toEqual([{ 'age(max)': 44, }])
- })
+ const {rows} = transformer();
+ expect(rows).toEqual([{'age(max)': 44}]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(min)', () => {
- ageColumn.aggr = 'min'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'min';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
- expect(rows).toEqual([{ 'age(min)': 33, }])
- })
+ const {rows} = transformer();
+ expect(rows).toEqual([{'age(min)': 33}]);
+ });
it('should transform properly: 0 key, 0 group, 2 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- balanceColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].aggrAxis.push(balanceColumn)
+ ageColumn.aggr = 'sum';
+ balanceColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].aggrAxis.push(balanceColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ '', ])
- expect(groupNames).toEqual([ 'age(sum)', 'balance(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', 'balance(sum)', ])
- expect(rows).toEqual([{ 'age(sum)': 159, 'balance(sum)': 14181, }])
- })
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['']);
+ expect(groupNames).toEqual(['age(sum)', 'balance(sum)']);
+ expect(selectors).toEqual(['age(sum)', 'balance(sum)']);
+ expect(rows).toEqual([{'age(sum)': 159, 'balance(sum)': 14181}]);
+ });
it('should transform properly: 0 key, 1 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].groupAxis.push(martialColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital', ])
- expect(groupNames).toEqual([ 'married', 'single', ])
- expect(selectors).toEqual([ 'married', 'single', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital']);
+ expect(groupNames).toEqual(['married', 'single']);
+ expect(selectors).toEqual(['married', 'single']);
expect(rows).toEqual([
- { single: 77, married: 82, }
- ])
- })
+ {single: 77, married: 82},
+ ]);
+ });
it('should transform properly: 0 key, 1 group, 2 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- balanceColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].aggrAxis.push(balanceColumn)
- config.axis[chart].groupAxis.push(martialColumn)
+ ageColumn.aggr = 'sum';
+ balanceColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].aggrAxis.push(balanceColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital', ])
- expect(groupNames).toEqual([ 'married', 'single', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital']);
+ expect(groupNames).toEqual(['married', 'single']);
expect(selectors).toEqual([
'married / age(sum)', 'married / balance(sum)', 'single / age(sum)', 'single / balance(sum)',
- ])
+ ]);
expect(rows).toEqual([{
'married / age(sum)': 82,
'single / age(sum)': 77,
'married / balance(sum)': 9286,
'single / balance(sum)': 4895,
- }])
- })
+ }]);
+ });
it('should transform properly: 0 key, 2 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].groupAxis.push(martialColumn)
- config.axis[chart].groupAxis.push(educationColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
+ config.axis[chart].groupAxis.push(educationColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital.education', ])
- expect(groupNames).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
- expect(selectors).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital.education']);
+ expect(groupNames).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
+ expect(selectors).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
expect(rows).toEqual([{
'married.primary': '43', 'married.secondary': '39', 'single.tertiary': 77,
- }])
- })
+ }]);
+ });
it('should transform properly: 1 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].keyAxis.push(martialColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].keyAxis.push(martialColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('marital')
- expect(keyNames).toEqual([ 'married', 'single', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', ])
+ expect(keyColumnName).toEqual('marital');
+ expect(keyNames).toEqual(['married', 'single']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['age(sum)']);
expect(rows).toEqual([
- { 'age(sum)': 82, 'marital': 'married', },
- { 'age(sum)': 77, 'marital': 'single', },
- ])
- })
+ {'age(sum)': 82, 'marital': 'married'},
+ {'age(sum)': 77, 'marital': 'single'},
+ ]);
+ });
it('should transform properly: 2 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].keyAxis.push(martialColumn)
- config.axis[chart].keyAxis.push(educationColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].keyAxis.push(martialColumn);
+ config.axis[chart].keyAxis.push(educationColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('marital.education')
- expect(keyNames).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', ])
+ expect(keyColumnName).toEqual('marital.education');
+ expect(keyNames).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['age(sum)']);
expect(rows).toEqual([
- { 'age(sum)': '43', 'marital.education': 'married.primary' },
- { 'age(sum)': '39', 'marital.education': 'married.secondary' },
- { 'age(sum)': 77, 'marital.education': 'single.tertiary' },
- ])
- })
+ {'age(sum)': '43', 'marital.education': 'married.primary'},
+ {'age(sum)': '39', 'marital.education': 'married.secondary'},
+ {'age(sum)': 77, 'marital.education': 'single.tertiary'},
+ ]);
+ });
it('should transform properly: 1 key, 1 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].keyAxis.push(martialColumn)
- config.axis[chart].groupAxis.push(educationColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].keyAxis.push(martialColumn);
+ config.axis[chart].groupAxis.push(educationColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('marital')
- expect(keyNames).toEqual([ 'married', 'single', ])
- expect(groupNames).toEqual([ 'primary', 'secondary', 'tertiary', ])
- expect(selectors).toEqual([ 'primary', 'secondary', 'tertiary', ])
+ expect(keyColumnName).toEqual('marital');
+ expect(keyNames).toEqual(['married', 'single']);
+ expect(groupNames).toEqual(['primary', 'secondary', 'tertiary']);
+ expect(selectors).toEqual(['primary', 'secondary', 'tertiary']);
expect(rows).toEqual([
- { primary: '43', secondary: '39', marital: 'married' },
- { tertiary: 44 + 33, marital: 'single' },
- ])
- })
- }) // end: describe('method: object')
+ {primary: '43', secondary: '39', marital: 'married'},
+ {tertiary: 44 + 33, marital: 'single'},
+ ]);
+ });
+ }); // end: describe('method: object')
describe('method: drill-down', () => {
- let config = {}
- const chart = 'drillDown-chart'
- let ageColumn = null
- let balanceColumn = null
- let educationColumn = null
- let martialColumn = null
- const tableDataRows = JSON.parse(JSON.stringify(MockTableDataRows1))
+ let config = {};
+ const chart = 'drillDown-chart';
+ let ageColumn = null;
+ let balanceColumn = null;
+ let educationColumn = null;
+ let martialColumn = null;
+ const tableDataRows = JSON.parse(JSON.stringify(MockTableDataRows1));
beforeEach(() => {
- const spec = JSON.parse(JSON.stringify(MockSpec2))
- config = {}
- Util.initializeConfig(config, spec)
- config.chart.current = chart
- ageColumn = JSON.parse(JSON.stringify(MockTableDataColumn[0]))
- balanceColumn = JSON.parse(JSON.stringify(MockTableDataColumn[5]))
- educationColumn = JSON.parse(JSON.stringify(MockTableDataColumn[3]))
- martialColumn = JSON.parse(JSON.stringify(MockTableDataColumn[2]))
- })
+ const spec = JSON.parse(JSON.stringify(MockSpec2));
+ config = {};
+ Util.initializeConfig(config, spec);
+ config.chart.current = chart;
+ ageColumn = JSON.parse(JSON.stringify(MockTableDataColumn[0]));
+ balanceColumn = JSON.parse(JSON.stringify(MockTableDataColumn[5]));
+ educationColumn = JSON.parse(JSON.stringify(MockTableDataColumn[3]));
+ martialColumn = JSON.parse(JSON.stringify(MockTableDataColumn[2]));
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ '', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['age(sum)']);
expect(rows).toEqual([
- { selector: 'age(sum)', value: 44 + 43 + 39 + 33, drillDown: [ ], },
- ])
- })
+ {selector: 'age(sum)', value: 44 + 43 + 39 + 33, drillDown: []},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(count)', () => {
- ageColumn.aggr = 'count'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'count';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
+ const {rows} = transformer();
expect(rows).toEqual([
- { selector: 'age(count)', value: 4, drillDown: [ ], },
- ])
- })
+ {selector: 'age(count)', value: 4, drillDown: []},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(avg)', () => {
- ageColumn.aggr = 'avg'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'avg';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
+ const {rows} = transformer();
expect(rows).toEqual([
- { selector: 'age(avg)', value: (44 + 43 + 39 + 33) / 4.0, drillDown: [ ], },
- ])
- })
+ {selector: 'age(avg)', value: (44 + 43 + 39 + 33) / 4.0, drillDown: []},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(max)', () => {
- ageColumn.aggr = 'max'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'max';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
+ const {rows} = transformer();
expect(rows).toEqual([
- { selector: 'age(max)', value: 44, drillDown: [ ], },
- ])
- })
+ {selector: 'age(max)', value: 44, drillDown: []},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 1 aggr(min)', () => {
- ageColumn.aggr = 'min'
- config.axis[chart].aggrAxis.push(ageColumn)
+ ageColumn.aggr = 'min';
+ config.axis[chart].aggrAxis.push(ageColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, } = transformer()
+ const {rows} = transformer();
expect(rows).toEqual([
- { selector: 'age(min)', value: 33, drillDown: [ ], },
- ])
- })
+ {selector: 'age(min)', value: 33, drillDown: []},
+ ]);
+ });
it('should transform properly: 0 key, 0 group, 2 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- balanceColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].aggrAxis.push(balanceColumn)
+ ageColumn.aggr = 'sum';
+ balanceColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].aggrAxis.push(balanceColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ '', ])
- expect(groupNames).toEqual([ 'age(sum)', 'balance(sum)', ])
- expect(selectors).toEqual([ 'age(sum)', 'balance(sum)', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['']);
+ expect(groupNames).toEqual(['age(sum)', 'balance(sum)']);
+ expect(selectors).toEqual(['age(sum)', 'balance(sum)']);
expect(rows).toEqual([
- { selector: 'age(sum)', value: 159, drillDown: [ ], },
- { selector: 'balance(sum)', value: 14181, drillDown: [ ], },
- ])
- })
+ {selector: 'age(sum)', value: 159, drillDown: []},
+ {selector: 'balance(sum)', value: 14181, drillDown: []},
+ ]);
+ });
it('should transform properly: 0 key, 1 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].groupAxis.push(martialColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital', ])
- expect(groupNames).toEqual([ 'married', 'single', ])
- expect(selectors).toEqual([ 'age(sum)', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital']);
+ expect(groupNames).toEqual(['married', 'single']);
+ expect(selectors).toEqual(['age(sum)']);
expect(rows).toEqual([
{
selector: 'age(sum)',
value: 159,
drillDown: [
- { group: 'married', value: 82 },
- { group: 'single', value: 77 },
+ {group: 'married', value: 82},
+ {group: 'single', value: 77},
],
},
- ])
- })
+ ]);
+ });
it('should transform properly: 0 key, 1 group, 2 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- balanceColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].aggrAxis.push(balanceColumn)
- config.axis[chart].groupAxis.push(martialColumn)
-
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
-
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
-
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital', ])
- expect(groupNames).toEqual([ 'married', 'single', ])
- expect(selectors).toEqual([ 'age(sum)', 'balance(sum)' ])
+ ageColumn.aggr = 'sum';
+ balanceColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].aggrAxis.push(balanceColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
+
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
+
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
+
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital']);
+ expect(groupNames).toEqual(['married', 'single']);
+ expect(selectors).toEqual(['age(sum)', 'balance(sum)']);
expect(rows).toEqual([
{
selector: 'age(sum)',
value: 159,
drillDown: [
- { group: 'married', value: 82 },
- { group: 'single', value: 77 },
+ {group: 'married', value: 82},
+ {group: 'single', value: 77},
],
},
{
selector: 'balance(sum)',
value: 14181,
drillDown: [
- { group: 'married', value: 9286 },
- { group: 'single', value: 4895 },
+ {group: 'married', value: 9286},
+ {group: 'single', value: 4895},
],
},
- ])
- })
+ ]);
+ });
it('should transform properly: 0 key, 2 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].groupAxis.push(martialColumn)
- config.axis[chart].groupAxis.push(educationColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].groupAxis.push(martialColumn);
+ config.axis[chart].groupAxis.push(educationColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('')
- expect(keyNames).toEqual([ 'marital.education', ])
- expect(groupNames).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
- expect(selectors).toEqual([ 'age(sum)', ])
+ expect(keyColumnName).toEqual('');
+ expect(keyNames).toEqual(['marital.education']);
+ expect(groupNames).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
+ expect(selectors).toEqual(['age(sum)']);
expect(rows).toEqual([
{
selector: 'age(sum)',
value: 159,
drillDown: [
- { group: 'married.primary', value: '43' },
- { group: 'married.secondary', value: '39' },
- { group: 'single.tertiary', value: 77 },
+ {group: 'married.primary', value: '43'},
+ {group: 'married.secondary', value: '39'},
+ {group: 'single.tertiary', value: 77},
],
},
- ])
- })
+ ]);
+ });
it('should transform properly: 1 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].keyAxis.push(martialColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].keyAxis.push(martialColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('marital')
- expect(keyNames).toEqual([ 'married', 'single', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'married', 'single', ])
+ expect(keyColumnName).toEqual('marital');
+ expect(keyNames).toEqual(['married', 'single']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['married', 'single']);
expect(rows).toEqual([
- { selector: 'married', value: 82, drillDown: [ ], },
- { selector: 'single', value: 77, drillDown: [ ], },
- ])
- })
+ {selector: 'married', value: 82, drillDown: []},
+ {selector: 'single', value: 77, drillDown: []},
+ ]);
+ });
it('should transform properly: 2 key, 0 group, 1 aggr(sum)', () => {
- ageColumn.aggr = 'sum'
- config.axis[chart].aggrAxis.push(ageColumn)
- config.axis[chart].keyAxis.push(martialColumn)
- config.axis[chart].keyAxis.push(educationColumn)
+ ageColumn.aggr = 'sum';
+ config.axis[chart].aggrAxis.push(ageColumn);
+ config.axis[chart].keyAxis.push(martialColumn);
+ config.axis[chart].keyAxis.push(educationColumn);
- const axisSpecs = config.axisSpecs[chart]
- const axis = config.axis[chart]
- const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer
+ const axisSpecs = config.axisSpecs[chart];
+ const axis = config.axis[chart];
+ const transformer = Util.getTransformer(config, tableDataRows, axisSpecs, axis).transformer;
- const { rows, keyColumnName, keyNames, groupNames, selectors, } = transformer()
+ const {rows, keyColumnName, keyNames, groupNames, selectors} = transformer();
- expect(keyColumnName).toEqual('marital.education')
- expect(keyNames).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
- expect(groupNames).toEqual([ 'age(sum)', ])
- expect(selectors).toEqual([ 'married.primary', 'married.secondary', 'single.tertiary', ])
+ expect(keyColumnName).toEqual('marital.education');
+ expect(keyNames).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
+ expect(groupNames).toEqual(['age(sum)']);
+ expect(selectors).toEqual(['married.primary', 'married.secondary', 'single.tertiary']);
expect(rows).toEqual([
- { selector: 'married.primary', value: '43', drillDown: [ ], },
- { selector: 'married.secondary', value: '39', drillDown: [ ], },
- { selector: 'single.tertiary', value: 77, drillDown: [ ], },
- ])
- })
+ {selector: 'married.primary', value: '43', drillDown: []},
+ {selector: 'marr
<TRUNCATED>