@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/src/rules/test/stacked-property.js

@@ -1,273 +0,0 @@
-import { expect } from 'chai';
-import { BAR, PERCENT, STACKED, VALUES } from '../src/constants';
-import {
-  onChangeStackedDimension,
-  onChangeStackedMode,
-  stackedStateFromNewProps
-} from '../src/properties/stacked';
-import oecd_KEI from './oecd-KEI.json';
-
-const undefinedState = {
-  stackedDimension: undefined,
-  stackedMode: undefined
-};
-
-const defaultState = {
-  stackedDimension: 'LOCATION',
-  stackedMode: VALUES,
-};
-
-const stateWithFocus = (state) => ({ ...state, baseline: [], highlight: [] });
-
-const defaultStateWithFocus = stateWithFocus(defaultState);
-
-describe('stackedStateFromNewProps tests', () => {
-  it('undefined state with focus from no data', () => {
-    const props = { type: STACKED };
-    const expected = stateWithFocus(undefinedState);
-    expect(stackedStateFromNewProps(props, defaultState)).to.deep.equal(expected);
-  });
-  it('undefined state without focus from non stacked type', () => {
-    const props = { data: oecd_KEI, type: BAR };
-    expect(stackedStateFromNewProps(props, defaultState)).to.deep.equal(undefinedState);
-  });
-  it('default state from no state', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    expect(stackedStateFromNewProps(props, undefined)).to.deep.equal(defaultStateWithFocus);
-  });
-  it('default state from undefined state', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    expect(stackedStateFromNewProps(props, undefinedState)).to.deep.equal(defaultStateWithFocus);
-  });
-  it('default state from default state', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    expect(stackedStateFromNewProps(props, defaultState)).to.deep.equal(defaultStateWithFocus);
-  });
-  it('default state from non existing mode', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    const state = { stackedDimension: 'LOCATION', stackedMode: 'RANDOM' }
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal(defaultStateWithFocus);
-  });
-  it('correct dimension but non existing mode', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    const state = { stackedDimension: 'SUBJECT', stackedMode: 'RANDOM' }
-    const expected = stateWithFocus({ stackedDimension: 'SUBJECT', stackedMode: VALUES });
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('non existing dimension but correct mode', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    const state = { stackedDimension: 'RANDOM', stackedMode: PERCENT }
-    const expected = stateWithFocus({ stackedDimension: 'LOCATION', stackedMode: PERCENT });
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('dimension with only one value', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    const state = { stackedDimension: 'MEASURE', stackedMode: VALUES }
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal(defaultStateWithFocus);
-  });
-});
-
-describe('focus tests through stackedStateFromNewProps', () => {
-  it('empty focus', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    const state = { type: STACKED, baseline: [], highlight: [] };
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal(defaultStateWithFocus);
-  });
-  it('correct focus', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    const state = {
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'Australia',
-          value: 'AUS'
-        },
-        {
-          label: 'Austria',
-          value: 'AUT'
-        },
-        {
-          label: 'Czech Republic',
-          value: 'CZE'
-        }
-      ]
-    };
-    const expected = { ...defaultState, ...state }
-    expect(stackedStateFromNewProps(props, { ...state, type: STACKED })).to.deep.equal(expected);
-  });
-  it('all wrong focus', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    const state = {
-      type: STACKED,
-      baseline: [
-        {
-          label: 'RANDOM 1',
-          value: 'RANDOM_VAL1'
-        }
-      ],
-      highlight: [
-        {
-          label: 'RANDOM 2',
-          value: 'RANDOM_VAL2'
-        },
-        {
-          label: 'RANDOM 3',
-          value: 'RANDOM_VAL3'
-        },
-        {
-          label: 'RANDOM 4',
-          value: 'RANDOM_VAL4'
-        }
-      ]
-    };
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal(defaultStateWithFocus);
-  });
-  it('mix of correct and wrong', () => {
-    const props = { data: oecd_KEI, type: STACKED };
-    const state = {
-      type: STACKED,
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'RANDOM 2',
-          value: 'RANDOM_VAL2'
-        },
-        {
-          label: 'Austria',
-          value: 'AUT'
-        },
-        {
-          label: 'RANDOM 4',
-          value: 'RANDOM_VAL4'
-        }
-      ]
-    };
-    const expected = {
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'Austria',
-          value: 'AUT'
-        }
-      ]
-    };
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal({ ...defaultState, ...expected });
-  });
-  it('code display', () => {
-    const props = { data: oecd_KEI, type: STACKED, display: 'code' };
-    const state = {
-      type: STACKED,
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'Austria',
-          value: 'AUT'
-        }
-      ]
-    };
-    const expected = {
-      ...defaultState,
-      baseline: [
-        {
-          label: 'FRA',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'AUT',
-          value: 'AUT'
-        }
-      ]
-    };
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('both display', () => {
-    const props = { data: oecd_KEI, type: STACKED, display: 'both' };
-    const state = {
-      type: STACKED,
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'Austria',
-          value: 'AUT'
-        }
-      ]
-    };
-    const expected = {
-      ...defaultState,
-      baseline: [
-        {
-          label: '(FRA) France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: '(AUT) Austria',
-          value: 'AUT'
-        }
-      ]
-    };
-    expect(stackedStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-});
-
-describe('onChangeStackedDimension tests', () => {
-  it('no data', () => {
-    expect(onChangeStackedDimension({})('LOCATION')).to.deep.equal({});
-  });
-  it('no value', () => {
-    expect(onChangeStackedDimension({ data: oecd_KEI })(undefined)).to.deep.equal({});
-  });
-  it('non existing dimension', () => {
-    expect(onChangeStackedDimension({ data: oecd_KEI })('RANDOM')).to.deep.equal({});
-  });
-  it('correct dimension', () => {
-    const expected = stateWithFocus({ stackedDimension: 'SUBJECT' });
-    expect(onChangeStackedDimension({ data: oecd_KEI })('SUBJECT')).to.deep.equal(expected);
-  });
-  it('dimension with only one value', () => {
-    expect(onChangeStackedDimension({ data: oecd_KEI })('MEASURE')).to.deep.equal({});
-  });
-});
-
-describe('onChangeStackedMode tests', () => {
-  it('no value', () => {
-    expect(onChangeStackedMode(undefined)).to.deep.equal({});
-  });
-  it('non existing mode', () => {
-    expect(onChangeStackedMode('random')).to.deep.equal({});
-  })
-  it('values', () => {
-    expect(onChangeStackedMode(VALUES)).to.deep.equal({ stackedMode: VALUES });
-  });
-  it('percent', () => {
-    expect(onChangeStackedMode(PERCENT)).to.deep.equal({ stackedMode: PERCENT });
-  });
-});

package/src/rules/test/symbol-property.js

@@ -1,262 +0,0 @@
-import { expect } from 'chai';
-import { BAR, H_SYMBOL } from '../src/constants';
-import {
-  onChangeSymbolDim,
-  symbolStateFromNewProps
-} from '../src/properties/symbol';
-import oecd_KEI from './oecd-KEI.json';
-
-const undefinedState = {
-  symbolDimension: undefined,
-};
-
-const undefinedStateWithFocus = {
-  baseline: [],
-  highlight: [],
-  symbolDimension: undefined,
-};
-
-describe('symbolStateFromNewProps tests', () => {
-  it('undefined with focus from no data', () => {
-    const props = { type: H_SYMBOL };
-    const state = { symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(undefinedStateWithFocus);
-  });
-  it('undefined without focus from not symbol type', () => {
-    const props = { data: oecd_KEI, type: BAR };
-    const state = { symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(undefinedState);
-  });
-  it('default from no state', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL};
-    const expected = { baseline: [], highlight: [], symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, undefined)).to.deep.equal(expected);
-  });
-  it('default from undefined state', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL};
-    const expected = { baseline: [], highlight: [], symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, undefinedState)).to.deep.equal(expected);
-  });
-  it('default from default state', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL};
-    const state =  { symbolDimension: 'SUBJECT' };
-    const expected = { baseline: [], highlight: [], symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('default from no existing dimension', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL};
-    const state =  { symbolDimension: 'RANDOM' };
-    const expected = { baseline: [], highlight: [], symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('default from dimension with only one value', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL};
-    const state =  { symbolDimension: 'MEASURE' };
-    const expected = { baseline: [], highlight: [], symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('correct dimension', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL};
-    const state =  { symbolDimension: 'LOCATION' };
-    const expected = { baseline: [], highlight: [], symbolDimension: 'LOCATION' };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-});
-
-describe('focus tests through symbolStateFromNewProps', () => {
-  it('empty focus', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL };
-    const state = { type: H_SYMBOL, baseline: [], highlight: [] };
-    const expected = { baseline: [], highlight: [], symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('correct focus', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL };
-    const state = {
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'Australia',
-          value: 'AUS'
-        },
-        {
-          label: 'Austria',
-          value: 'AUT'
-        },
-        {
-          label: 'Czech Republic',
-          value: 'CZE'
-        }
-      ]
-    };
-    const expected = { symbolDimension: 'SUBJECT', ...state }
-    expect(symbolStateFromNewProps(props, { ...state, type: H_SYMBOL })).to.deep.equal(expected);
-  });
-  it('all wrong focus', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL };
-    const state = {
-      type: H_SYMBOL,
-      baseline: [
-        {
-          label: 'RANDOM 1',
-          value: 'RANDOM_VAL1'
-        }
-      ],
-      highlight: [
-        {
-          label: 'RANDOM 2',
-          value: 'RANDOM_VAL2'
-        },
-        {
-          label: 'RANDOM 3',
-          value: 'RANDOM_VAL3'
-        },
-        {
-          label: 'RANDOM 4',
-          value: 'RANDOM_VAL4'
-        }
-      ]
-    };
-    const expected = { baseline: [], highlight: [], symbolDimension: 'SUBJECT' };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('mix of correct and wrong', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL };
-    const state = {
-      type: H_SYMBOL,
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'RANDOM 2',
-          value: 'RANDOM_VAL2'
-        },
-        {
-          label: 'Austria',
-          value: 'AUT'
-        },
-        {
-          label: 'RANDOM 4',
-          value: 'RANDOM_VAL4'
-        }
-      ]
-    };
-    const expected = {
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'Austria',
-          value: 'AUT'
-        }
-      ],
-      symbolDimension: 'SUBJECT'
-    };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('code display', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL, display: 'code' };
-    const state = {
-      type: H_SYMBOL,
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'Austria',
-          value: 'AUT'
-        }
-      ]
-    };
-    const expected = {
-      baseline: [
-        {
-          label: 'FRA',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'AUT',
-          value: 'AUT'
-        }
-      ],
-      symbolDimension: 'SUBJECT'
-    };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-  it('both display', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL, display: 'both' };
-    const state = {
-      type: H_SYMBOL,
-      baseline: [
-        {
-          label: 'France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: 'Austria',
-          value: 'AUT'
-        }
-      ]
-    };
-    const expected = {
-      baseline: [
-        {
-          label: '(FRA) France',
-          value: 'FRA'
-        }
-      ],
-      highlight: [
-        {
-          label: '(AUT) Austria',
-          value: 'AUT'
-        }
-      ],
-      symbolDimension: 'SUBJECT'
-    };
-    expect(symbolStateFromNewProps(props, state)).to.deep.equal(expected);
-  });
-});
-
-describe('onChangeSymbolDim tests', () => {
-  it('no data', () => {
-    const props = { type: H_SYMBOL };
-    expect(onChangeSymbolDim(props)('LOCATION')).to.deep.equal({});
-  });
-  it('no selection', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL };
-    expect(onChangeSymbolDim(props)(undefined)).to.deep.equal({});
-  });
-  it('valid dimension within dataset', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL };
-    const expected = { baseline: [], highlight: [], symbolDimension: 'LOCATION' };
-    expect(onChangeSymbolDim(props)('LOCATION')).to.deep.equal(expected);
-  });
-  it('non valid dimension', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL };
-    expect(onChangeSymbolDim(props)('RANDOM')).to.deep.equal({});
-  });
-  it('dimension with only one value', () => {
-    const props = { data: oecd_KEI, type: H_SYMBOL };
-    expect(onChangeSymbolDim(props)('MEASURE')).to.deep.equal({});
-  })
-});

package/src/rules/test/v8-transformer.test.js

@@ -1,90 +0,0 @@
-import * as V8 from '../sdmx-data';
-
-describe('rules - sdmx-data', () => {
-  describe('setAnnotationsLayout', () => {
-    const layout1 = {};
-    test('annotations is row', () => {
-      expect(V8.setAnnotationsLayout('ID', layout1)([{ type: V8.LAYOUT_ROW }])).toEqual({ rows: ['ID'] });
-    });
-    test('annotations is header', () => {
-      expect(V8.setAnnotationsLayout('ID', layout1)([{ type: V8.LAYOUT_COLUMN }, {type: 'truc'}, {type: 'truc'}])).toEqual({ header: ['ID'] });
-    });
-    test('annotations is sections', () => {
-      expect(V8.setAnnotationsLayout('ID', layout1)([{type: 'truc'}, {type: 'truc'}, { type: V8.LAYOUT_ROW_SECTION }])).toEqual({ sections: ['ID'] });
-    });
-    test('annotations is undefined - should be return layout', () => {
-      expect(V8.setAnnotationsLayout('ID', layout1)([undefined])).toEqual({});
-    });
-    test('ids should be ["ID1","ID2","ID3"]', () => {
-      expect(V8.setAnnotationsLayout('ID1,ID2,ID3', layout1)([{ type: V8.LAYOUT_ROW_SECTION }])).toEqual({ sections: ['ID1','ID2','ID3'] });
-    });
-    test('id is undefined - should be return layout', () => {
-      const layout2 = { header: ['id'] };
-      expect(V8.setAnnotationsLayout(undefined, layout2)([{ type: V8.LAYOUT_ROW_SECTION }])).toEqual({ header: ['id'], sections: ['']});
-    });
-  });
-  describe('getIsHidden', () => {
-    test('return isHidden', () => {
-      const annotations = [
-        {"type": "NOT_DISPLAYED", "texts": { "en": "Dimension to be shown in row section - full description" }},
-        {"type": "ORDER", "texts": { "en": "5" }},
-        {"type": "FULL_NAME","texts": { "en": "Dimension to be shown in row section - full last"}},
-      ];
-      expect(V8.getIsHidden(annotations)).toEqual({ isHidden: true});
-    });
-    test('return empty string', () => {
-      const annotations = [{"type": "ORDER", "texts": { "en": "5" }}];
-      expect(V8.getIsHidden(annotations)).toEqual({});
-    });
-  });
-  describe('setIndexPositions', () => {
-    const annotations = [
-      {type: 0},
-      {type: 1},
-      {type: 2},
-      {type: 3 },
-      {type: "ORDER", text: "5"},
-      {type: "ORDER"},
-      {type: 6},
-      {type: 7},
-      {type: 8}
-    ];
-    test('has no result', () => {
-      const dimObservationAnnotations = [0,1];
-      expect(V8.setIndexPositions('en')([])).toEqual({});
-    }); 
-    test('__indexPosition 5', () => {
-      const dimObservationAnnotations = [4];
-      expect(V8.setIndexPositions('en')([{type: "ORDER", texts: { "en": "5" }}] )).toEqual({ __indexPosition: 5});
-    });
-    test('__indexPosition null', () => {
-      const dimObservationAnnotations = [5];
-      expect(V8.setIndexPositions('en')([{type: "ORDER"}])).toEqual({ __indexPosition: null});
-    });
-  });
-  describe('getRelationnalAnnotations', () => {
-    const annotations = [{type: 0},{type: 1},{type: 2},{type: 3},{type: 4},{type: 5},{type: 6},{type: 7},{type: 8}];
-    const dimAnnotations = [2,3,5,8];
-
-    test('get the true indexes ', () => {
-      expect(V8.getRelationnalAnnotations(dimAnnotations)(annotations)).toEqual([{type: 2},{type: 3},{type: 5},{type: 8}]);
-    });
-    test('annotations is empty', () => {
-      expect(V8.getRelationnalAnnotations(dimAnnotations)([])).toEqual([{}, {}, {}, {}]);
-    });
-    test('dimAnnotations is empty', () => {
-      expect(V8.getRelationnalAnnotations([])(annotations)).toEqual([]);
-    });
-  });
-  describe('getPriorityIndexPosition', () => {
-    test('__indexPosition isNil expected order value', () => {
-      expect(V8.getPriorityIndexPosition(50)({ __indexPosition: undefined })).toEqual({ __indexPosition: 50 });
-    });
-    test('__indexPosition 5 expected __indexPosition', () => {
-      expect(V8.getPriorityIndexPosition(50)({ __indexPosition: 5 })).toEqual({ __indexPosition: 5 });
-    });
-    test('__indexPosition isNil and order too expected null', () => {
-      expect(V8.getPriorityIndexPosition(null)({ __indexPosition: undefined })).toEqual({ __indexPosition: null });
-    });
-  });
-});