@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/test/getTableLabelAccessor.test.js

@@ -1,50 +0,0 @@
-import { expect } from 'chai';
-import { getTableLabelAccessor } from '../src/rules2/src/table/getTableLabelAccessor';
-
-describe('getTableLabelAccessor tests', () => {
-  const values = [
-    { id: 'V0', name: 'Value 0', display: false },
-    { id: 'V1', name: 'Value 1', missingParents: [{ id: 'P0', name: 'Parent 0' }, { id: 'P1', name: 'Parent 1', display: false }] },
-    { id: '_T', name: 'Value 2' },
-  ];
-  it('combination label display', () => {
-    expect(getTableLabelAccessor('label')(values)).to.deep.equal('Parent 0 > Value 1');
-  });
-  it('combination code display', () => {
-    expect(getTableLabelAccessor('code')(values)).to.deep.equal('V0, V1, _T');
-  });
-  it('combination both display', () => {
-    expect(getTableLabelAccessor('both')(values)).to.deep.equal('(V0, V1, _T) Parent 0 > Value 1');
-  });
-  it('single value witrh missingParents', () => {
-    expect(getTableLabelAccessor('label')(values[1])).to.deep.equal('Parent 0 > Value 1');
-  });
-  it('not displayed single value', () => {
-    expect(getTableLabelAccessor('both')(values[0])).to.deep.equal('(V0) Value 0');
-  });
-  it('display _T label if all hidden', () => {
-    const _values = [
-        { id: 'v0', name: 'value 0', display: false },
-        { id: 'v1', name: 'value 1', display: false },
-        { id: '_T', name: 'Total' },
-        { id: 'v3', name: 'value 3', display: false },
-    ];
-    expect(getTableLabelAccessor('label')(_values)).to.deep.equal('Total');
-    expect(getTableLabelAccessor('both')(_values)).to.deep.equal('(v0, v1, _T, v3) Total');
-  });
-  it('display label first value if all hidden and no _T', () => {
-    const _values = [
-        { id: 'v0', name: 'value 0', display: false },
-        { id: 'v1', name: 'value 1', display: false },
-        { id: 'v2', name: 'value 2', display: false },
-        { id: 'v3', name: 'value 3', display: false },
-    ];
-    expect(getTableLabelAccessor('label')(_values)).to.deep.equal('value 0');
-    expect(getTableLabelAccessor('both')(_values)).to.deep.equal('(v0, v1, v2, v3) value 0');
-  });
-  it('empty case', () => {
-    expect(getTableLabelAccessor('label')([])).to.deep.equal('');
-    expect(getTableLabelAccessor('code')([])).to.deep.equal('');
-    expect(getTableLabelAccessor('both')([])).to.deep.equal('');
-  });
-});

package/test/getTableLayoutIds.test.js

@@ -1,356 +0,0 @@
-import { expect } from 'chai';
-import { injectCombinationsInLayout, getTableLayoutIds } from '../src/rules2/src/table/getTableLayoutIds';
-
-describe('injectCombinationsInLayout', () => {
-  it('no combinations', () => {
-    const layoutIds = {
-      header: ['D1'],
-      sections: ['D2'],
-      rows: ['D3']
-    };
-    const combinations = [];
-    expect(injectCombinationsInLayout(combinations, layoutIds)).to.deep.equal({
-      header: ['D1'],
-      sections: ['D2'],
-      rows: ['D3']
-    });
-  });
-  it('partial start', () => {
-    const layoutIds = {
-      header: ['D1', 'C1', 'D2'],
-      sections: ['C5', 'D5', 'D3'],
-      rows: ['D4']
-    };
-
-    const combinations = [
-      { id: 'C1', concepts: ['D0', 'A2'], relationship: ['D0'] }, // already in header
-      { id: 'C2', concepts: ['D1', 'D2', 'A1'], relationship: ['D1', 'D2', 'D0'] }, // concepts are in header and relate to one of C1 concepts
-      { id: 'C3', concepts: ['D1', 'D2', 'D3'], relationship: ['D1', 'D2', 'D3'] }, // concepts both in header & sections -> rejected
-      { id: 'C4', concepts: ['D1', 'D2', 'D4'], relationship: ['D1', 'D2', 'D4'] }, // concepts both in header & rows -> rejected
-      { id: 'C5', concepts: ['D6', 'D7'], relationship: ['D6', 'D7', 'D5'] }, // already in sections
-      { id: 'C6', concepts: ['D3', 'D5'], relationship: ['D3', 'D5', 'D7'] }, // concepts in sections and relate to one C5 concept
-      { id: 'C7', concepts: ['D3', 'D8'], relationship: ['D3', 'D8'] }, // partial concepts in sections, none in rows
-      { id: 'C8', concepts: ['A1', 'A2', 'D9'], relationship: ['D0', 'D9'] }, // partial concepts in header nothing elsewhere
-      { id: 'C9', concepts: ['A3', 'D10', 'D11', 'D12'], relationship: ['D10', 'D11', 'D12'] }, // all new concepts
-      { id: 'C10', concepts: ['D10', 'D8'], relationship: ['D10', 'D8'] }, // relates to one concept of C7 and to one of C9
-    ];
-
-    expect(injectCombinationsInLayout(combinations, layoutIds)).to.deep.equal({
-      header: ['C2', 'C1', 'C8'],
-      sections: ['C5', 'C6', 'C7'],
-      rows: ['D4', 'C9', 'C10']
-    });
-  });
-});
-
-describe('getTableLayoutIds tests', () => {
-  it('simple case blank start', () => {
-    const defaultLayoutIds = {
-      header: [],
-      sections: [],
-      rows: []
-    };
-    const layoutIds = {
-      header: [],
-      sections: [],
-      rows: []
-    };
-    const combinations = [];
-    const attributes = [];
-    const dimensions = [
-      { id: 'REF_AREA' },
-      { id: 'MEASURE' },
-      { id: 'REF_SECTOR' },
-      { id: 'TIME_PERIOD' },
-    ];
-
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['TIME_PERIOD'],
-      sections: ['MEASURE', 'REF_SECTOR'],
-      rows: ['REF_AREA']
-    });
-  });
-  it('blank start with combinations', () => {
-    const defaultLayoutIds = {
-      header: [],
-      sections: [],
-      rows: []
-    };
-    const layoutIds = {
-      header: [],
-      sections: ['COMB1'],
-      rows: []
-    };
-    const combinations = [
-      {
-        id: 'COMB1',
-        concepts: ['REF_SECTOR', 'MEASURE'],
-      },
-      {
-        id: 'COMB2',
-        concepts: ['UNIT_MEASURE', 'CURRENCY'],
-      },
-      {
-        id: 'COMB3',
-        concepts: ['ATTR1', 'ATTR2'],
-      },
-      {
-        id: 'COMB4',
-        concepts: ['ATTR3', 'ATTR4']
-      }
-    ];
-    const dimensions = [
-      { id: 'REF_AREA' },
-      { id: 'REF_SECTOR' },
-      { id: 'TRANSACTION' },
-      { id: 'MEASURE' },
-      { id: 'UNIT_MEASURE' },
-      { id: 'CURRENCY' }
-    ];
-    const attributes = [
-      { id: 'ATTR1', relationship: ['MEASURE'], series: true },
-      { id: 'ATTR2', relationship: ['MEASURE'], series: true },
-      { id: 'ATTR3', relationship: [], series: true },
-      { id: 'ATTR4', relationship: [], series: true },
-    ];
-
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['TRANSACTION'],
-      sections: ['COMB1', 'COMB3'],
-      rows: ['COMB2', 'REF_AREA']
-    });
-  });
-  it('nothing in rows 2', () => {
-    const combinations = [];
-    const attributes = [];
-    const dimensions = [
-      { id: 'D1', header: true },
-      { id: 'D2' },
-      { id: 'D3', header: true }
-    ];
-    const layoutIds = {
-      sections: ['D1'],
-      header: ['D2'],
-      rows: ['D3']
-    };
-    const defaultLayoutIds = {
-      header: [],
-      sections: [],
-      rows: []
-    };
-
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds, dimensions, attributes, combinations)).to.deep.equal({
-      header: [],
-      sections: [],
-      rows: ['D2']
-    });
-  });
-  it('nothing in rows with combinations', () => {
-    const combinations = [
-      {
-        id: 'COMB1',
-        concepts: ['D1', 'D2']
-      },
-      {
-        id: 'COMB2',
-        concepts: ['A1', 'A2']
-      },
-    ];
-    const attributes = [
-      { id: 'A1', series: true, relationship: ['D1', 'D2'] },
-      { id: 'A2', series: true, relationship: ['D1', 'D2'] },
-    ];
-    const dimensions = [
-      { id: 'D1' },
-      { id: 'D2' },
-      { id: 'D3' }
-    ];
-    const layoutIds = {
-      sections: ['D1', 'D2'],
-      header: ['D3'],
-      rows: []
-    };
-    const defaultLayoutIds = {
-      header: [],
-      sections: [],
-      rows: []
-    };
-
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['D3'],
-      sections: [],
-      rows: ['COMB1', 'COMB2']
-    });
-  });
-  it('nothing in rows with combinations 2', () => {
-    const combinations = [
-      {
-        id: 'COMB1',
-        concepts: ['D1', 'D2']
-      },
-      {
-        id: 'COMB2',
-        concepts: ['A1', 'A2']
-      },
-    ];
-    const attributes = [
-      { id: 'A1', series: true, relationship: ['D1', 'D2'] },
-      { id: 'A2', series: true, relationship: ['D1', 'D2'] },
-    ];
-    const dimensions = [
-      { id: 'D1' },
-      { id: 'D2' },
-      { id: 'D3' },
-      { id: 'D4' }
-    ];
-    const defaultLayoutIds = {
-      header: [],
-      sections: [],
-      rows: []
-    };
-    const layoutIds1 = {
-      sections: ['COMB1', 'D4', 'COMB2'],
-      header: ['D3'],
-      rows: []
-    };
-    const layoutIds2 = {
-      sections: ['D4', 'COMB1', 'COMB2'],
-      header: ['D3'],
-      rows: []
-    };
-    const layoutIds3 = {
-      sections: ['COMB2', 'COMB1', 'D4'],
-      header: ['D3'],
-      rows: []
-    };
-    const layoutIds4 = {
-      sections: ['COMB1', 'COMB2'],
-      header: ['D3'],
-      rows: []
-    };
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds1, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['D3'],
-      sections: ['D4'],
-      rows: ['COMB1', 'COMB2']
-    });
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds2, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['D3'],
-      sections: ['COMB1', 'COMB2'],
-      rows: ['D4']
-    });
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds3, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['D3'],
-      sections: ['D4'],
-      rows: ['COMB2', 'COMB1']
-    });
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds4, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['D3'],
-      sections: ['COMB1', 'COMB2'],
-      rows: ['D4']
-    });
-  });
-  it('nothing in rows with combination without dimensions', () => {
-    const combinations = [{
-      id: 'COMB',
-      concepts: ['A1', 'A2']
-    }];
-    const attributes = [
-      { id: 'A1', series: true, relationship: ['D1'] },
-      { id: 'A2', series: true, relationship: ['D1'] },
-    ]
-    const dimensions = [
-      { id: 'D1' },
-      { id: 'D2' },
-    ];
-    const defaultLayoutIds = {
-      header: [],
-      sections: [],
-      rows: []
-    };
-    const layoutIds = {
-      header: ['D2'],
-      sections: ['COMB', 'D1'],
-      rows: ['D3']
-    };
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['D2'],
-      sections: [],
-      rows: ['COMB', 'D1']
-    });
-  });
-  it('combinations and default layout definition', () => {
-    const defaultLayoutIds = {
-      header: ['MEASURE', 'REF_AREA'],
-      sections: ['COMB2', 'COMB3'],
-      rows: []
-    };
-    const combinations = [
-      {
-        id: 'COMB1',
-        concepts: ['REF_SECTOR', 'MEASURE'],
-      },
-      {
-        id: 'COMB2',
-        concepts: ['UNIT_MEASURE', 'CURRENCY'],
-      },
-      {
-        id: 'COMB3',
-        concepts: ['ATTR1', 'ATTR2'],
-      },
-      {
-        id: 'COMB4',
-        concepts: ['ATTR3', 'ATTR4']
-      }
-    ];
-    const dimensions = [
-      { id: 'REF_AREA' },
-      { id: 'REF_SECTOR' },
-      { id: 'TRANSACTION' },
-      { id: 'MEASURE' },
-      { id: 'UNIT_MEASURE' },
-      { id: 'CURRENCY' }
-    ];
-    const attributes = [
-      { id: 'ATTR1', relationship: ['MEASURE'], series: true },
-      { id: 'ATTR2', relationship: ['MEASURE'], series: true },
-      { id: 'ATTR3', relationship: [], series: true },
-      { id: 'ATTR4', relationship: [], series: true },
-    ];
-
-    const layoutIds1 = {
-      header: [],
-      sections: [],
-      rows: []
-    };
-
-    const layoutIds2 = {
-      header: ['TRANSACTION'],
-      sections: ['REF_AREA'],
-      rows: []
-    };
-
-    const layoutIds3 = {
-      header: [],
-      sections: ['MEASURE'],
-      rows: []
-    }
-
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds1, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['COMB1', 'REF_AREA', 'COMB3',],
-      sections: ['COMB2'],
-      rows: ['TRANSACTION']
-    });
-
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds2, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['TRANSACTION', 'COMB1', 'COMB3'],
-      sections: ['COMB2'],
-      rows: ['REF_AREA']
-    });
-
-    expect(getTableLayoutIds(defaultLayoutIds, layoutIds3, dimensions, attributes, combinations)).to.deep.equal({
-      header: ['REF_AREA'],
-      sections: ['COMB1', 'COMB2', 'COMB3'],
-      rows: ['TRANSACTION']
-    });
-  });
-});

package/test/hierarchiseDimensionWithNativeHierarchy2.test.js

@@ -1,109 +0,0 @@
-import { expect } from 'chai';
-import { hierarchiseDimensionWithNativeHierarchy } from '../src/rules2/src/hierarchiseDimensionWithNativeHierarchy2';
-
-describe('hierarchiseDimensionWithNativeHierarchy tests', () => {
-  it('basic test', () => {
-    const dimension = {
-      id: 'test',
-      values: [
-        { id: 'FRA', parent: 'EA', __indexPosition: 101, isSelected: true },
-        { id: 'GER', parent: 'EA', __indexPosition: 100, isSelected: true },
-        { id: 'EA', parent: 'W', __indexPosition: 30, isSelected: true },
-        { id: 'A', parent: 'W', __indexPosition: 20, isSelected: true },
-        { id: 'W', parent: undefined, __indexPosition: 5, isSelected: true },
-        { id: 'CHI', parent: undefined, __indexPosition: 0, isSelected: true }
-      ]
-    };
-    
-    const expected = {
-      id: 'test',
-      values: [
-        { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0, isSelected: true },
-        { id: 'W', parent: undefined, parents: [], __indexPosition: 1, isSelected: true },
-        { id: 'A', parent: 'W', parents: [1], __indexPosition: 2, isSelected: true },
-        { id: 'EA', parent: 'W', parents: [1], __indexPosition: 3, isSelected: true },
-        { id: 'GER', parent: 'EA', parents: [1, 3], __indexPosition: 4, isSelected: true },
-        { id: 'FRA', parent: 'EA', parents: [1, 3], __indexPosition: 5, isSelected: true }
-      ]
-    };
-
-    expect(hierarchiseDimensionWithNativeHierarchy(dimension)).to.deep.equal(expected);
-  });
-  it ('missing parent test', () => {
-    const dimension = {
-      id: 'test',
-      values: [
-        { id: 'FRA', parent: 'EA', __indexPosition: 101, isSelected: true },
-        { id: 'GER', parent: 'EA', __indexPosition: 100, isSelected: true },
-        { id: 'EA', parent: 'W', __indexPosition: 30, isSelected: true },
-        { id: 'A', parent: 'W', __indexPosition: 20, isSelected: true },
-        { id: 'CHI', parent: undefined, __indexPosition: 0, isSelected: true }
-      ]
-    };
-    
-    const expected = {
-      id: 'test',
-      values: [
-        { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0, isSelected: true },
-        { id: 'A', parent: undefined, parents: [], __indexPosition: 1, isSelected: true },
-        { id: 'EA', parent: undefined, parents: [], __indexPosition: 2, isSelected: true },
-        { id: 'GER', parent: 'EA', parents: [2], __indexPosition: 3, isSelected: true },
-        { id: 'FRA', parent: 'EA', parents: [2], __indexPosition: 4, isSelected: true }
-      ]
-    };
-
-    expect(hierarchiseDimensionWithNativeHierarchy(dimension)).to.deep.equal(expected);
-  });
-  it ('empty id', () => {
-    const dimension = {
-      id: 'test',
-      values: [
-        { id: '', parent: '', __indexPosition: 101, isSelected: true },
-        { id: 'GER', parent: 'EA', __indexPosition: 100, isSelected: true },
-        { id: 'EA', parent: 'W', __indexPosition: 30, isSelected: true },
-        { id: 'A', parent: 'W', __indexPosition: 20, isSelected: true },
-        { id: 'CHI', parent: undefined, __indexPosition: 0, isSelected: true }
-      ]
-    };
-    
-    const expected = {
-      id: 'test',
-      values: [
-        { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0, isSelected: true },
-        { id: 'A', parent: undefined, parents: [], __indexPosition: 1, isSelected: true },
-        { id: 'EA', parent: undefined, parents: [], __indexPosition: 2, isSelected: true },
-        { id: 'GER', parent: 'EA', parents: [2], __indexPosition: 3, isSelected: true },
-        { id: '', parent: undefined, parents: [], __indexPosition: 4, isSelected: true }
-      ]
-    };
-
-    expect(hierarchiseDimensionWithNativeHierarchy(dimension)).to.deep.equal(expected);
-  });
-  it('non selected parent', () => {
-    const dimension = {
-      id: 'test',
-      values: [
-        { id: 'FRA', parent: 'EA', __indexPosition: 101, isSelected: true },
-        { id: 'GER', parent: 'EA', __indexPosition: 100, isSelected: true },
-        { id: 'EA', parent: 'W', __indexPosition: 30, isSelected: false },
-        { id: 'A', parent: 'W', __indexPosition: 20, isSelected: true },
-        { id: 'W', parent: undefined, __indexPosition: 5, isSelected: true },
-        { id: 'CHI', parent: undefined, __indexPosition: 0, isSelected: true }
-      ]
-    };
-    
-    const expected = {
-      id: 'test',
-      values: [
-        { id: 'CHI', parent: undefined, parents: [], __indexPosition: 0, isSelected: true },
-        { id: 'W', parent: undefined, parents: [], __indexPosition: 1, isSelected: true },
-        { id: 'A', parent: 'W', parents: [1], __indexPosition: 2, isSelected: true },
-        { id: 'EA', parent: 'W', parents: [1], __indexPosition: 3, isSelected: false },
-        { id: 'GER', parent: 'EA', parents: [1], __indexPosition: 4, isSelected: true },
-        { id: 'FRA', parent: 'EA', parents: [1], __indexPosition: 5, isSelected: true }
-      ]
-    };
-
-    expect(hierarchiseDimensionWithNativeHierarchy(dimension)).to.deep.equal(expected);
-  })
-});

package/test/isTableLayoutCompatible.test.js

@@ -1,102 +0,0 @@
-import { expect } from 'chai';
-import { isSharedLayoutCompatible } from '../src/rules/src/layout';
-
-const sdmxData = {
-  structure: {
-    dimensions: {
-      observation: [
-        { id: 'd0', values: [{ id: 'v1' }, { id: 'v2' }] },
-        { id: 'd1', values: [{ id: 'v1' }, { id: 'v2' }, { id: 'v3' }] },
-        { id: 'd2', values: [{ id: 'v1' }, { id: 'v2' }] },
-        { id: 'd3', values: [{ id: 'v1' }] },
-        { id: 'd4', values: [] },
-      ]
-    },
-  }
-}
-const sdmxData2 = {
-  structure: {
-    dimensions: {
-      observation: [
-        { id: 'd0', values: [{ id: 'v1' }, { id: 'v2' }] },
-        { id: 'd1', values: [{ id: 'v1' }, { id: 'v2' }, { id: 'v3' }] },
-        { id: 'd2', values: [{ id: 'v1' }, { id: 'v2' }] },
-        { id: 'd3', values: [{ id: 'v1' }] },
-        { id: 'd4', values: [] },
-      ]
-    },
-    annotations: [
-      {
-        title: "d6:d1,d3,d4",
-        type: "COMBINED_CONCEPTS",
-        text: "d6:Combined unit of measure",
-        texts: {
-          en: "d6:Combined unit of measure"
-        }
-      }
-    ]
-  }
-}
-
-describe('isSharedLayoutCompatible', () => {
-  it('table compatible test', () => {
-    const layoutIds = { rows: ['d0'], sections: ['d1'], header: ['d2'] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'table', config: { table: { layoutIds } } })).to.equal(true);
-  });
-  it('table compatible test combined', () => {
-    const layoutIds = { rows: ['d0'], sections: ['d6'], header: ['d2'] };
-    expect(isSharedLayoutCompatible(sdmxData2, { type: 'table', config: { table: { layoutIds, locale: 'en' } } })).to.equal(true);
-  });
-  it('table incompatible absent dimension in multi dims test', () => {
-    const layoutIds = { rows: ['d0', 'd3'], sections: ['d1'], header: ['d2'] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'table', config: { table: { layoutIds } } })).to.equal(false);
-  });
-  it('table incompatible absent dimension in layout test', () => {
-    const layoutIds = { rows: [], sections: ['d1'], header: ['d2'] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'table', config: { table: { layoutIds } } })).to.equal(false);
-  });
-  it('scatter chart compatible test', () => {
-    const chartDimension = { id: 'd0', xId: 'v1', yId: 'v2' };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'ScatterChart', config: { chart: { chartDimension } } })).to.equal(true);
-  });
-  it('scatter chart incompatible  absent axis value test', () => {
-    const chartDimension = { id: 'd0', xId: 'v1', yId: 'v3' };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'ScatterChart', config: { chart: { chartDimension } } })).to.equal(false);
-  });
-  it('scatter chart incompatible wrong dimension test', () => {
-    const chartDimension = { id: 'd3', xId: 'v1', yId: 'v2' };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'ScatterChart', config: { chart: { chartDimension } } })).to.equal(false);
-  });
-  it('h symbol chart compatible test', () => {
-    const chartDimension = { id: 'd1', serie: [{ id: 'v1' }, { id: 'v2' }, { id: 'v3'}] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'HorizontalSymbolChart', config: { chart: { chartDimension } } })).to.equal(true);
-  });
-  it('h symbol chart incompatible absent symbol value test', () => {
-    const chartDimension = { id: 'd0', serie: [{ id: 'v1' }, { id: 'v2' }, { id: 'v3'}] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'HorizontalSymbolChart', config: { chart: { chartDimension } } })).to.equal(false);
-  });
-  it('h symbol chart incompatible absent dimension value test', () => {
-    const chartDimension = { id: 'd5', serie: [{ id: 'v1' }, { id: 'v2' }, { id: 'v3'}] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'HorizontalSymbolChart', config: { chart: { chartDimension } } })).to.equal(false);
-  });
-  it('v symbol chart compatible test', () => {
-    const chartDimension = { id: 'd1', serie: [{ id: 'v1' }, { id: 'v2' }, { id: 'v3'}] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'VerticalSymbolChart', config: { chart: { chartDimension } } })).to.equal(true);
-  });
-  it('v symbol chart incompatible absent symbol value test', () => {
-    const chartDimension = { id: 'd0', serie: [{ id: 'v1' }, { id: 'v2' }, { id: 'v3'}] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'VerticalSymbolChart', config: { chart: { chartDimension } } })).to.equal(false);
-  });
-  it('v symbol chart incompatible absent dimension value test', () => {
-    const chartDimension = { id: 'd5', serie: [{ id: 'v1' }, { id: 'v2' }, { id: 'v3'}] };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'VerticalSymbolChart', config: { chart: { chartDimension } } })).to.equal(false);
-  });
-  it('stacked chart compatible test', () => {
-    const chartDimension = { id: 'd0' };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'StackedBarChart', config: { chart: { chartDimension } } })).to.equal(true);
-  });
-  it('stacked chart incompatible test', () => {
-    const chartDimension = { id: 'd4' };
-    expect(isSharedLayoutCompatible(sdmxData, { type: 'StackedBarChart', config: { chart: { chartDimension } } })).to.equal(false);
-  });
-});