@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/test/getCombinationDefinitions.test.js

@@ -1,104 +0,0 @@
-import { expect } from 'chai';
-import { getCombinationDefinitions } from '../src/rules2/src';
-
-describe('getCombinationDefinitions tests', () => {
-  it('no annotations', () => {
-    const annotations = [
-      { type: 'random', title: 'test' },
-      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  }
-    ];
-
-    expect(getCombinationDefinitions(annotations, 'en')).to.deep.equal([]);
-  });
-  it('basic case', () => {
-    const annotations = [
-      { type: 'random', title: 'test' },
-      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  },
-      {
-        type: 'COMBINED_CONCEPTS',
-        texts: { en: 'COMB_1:First Combination;COMB_2:Second Combination' },
-        title: 'COMB_1:D1,D2,A1;COMB_2:D3,D4,A2,A3'
-      }
-    ];
-
-    expect(getCombinationDefinitions(annotations, 'en')).to.deep.equal([
-      { id: 'COMB_1', name: 'First Combination', concepts: ['D1', 'D2', 'A1'] },
-      { id: 'COMB_2', name: 'Second Combination', concepts: ['D3', 'D4', 'A2', 'A3'] },
-    ]);
-  });
-  it('bad formatted test 1', () => {
-    const annotations = [
-      { type: 'random', title: 'test' },
-      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  },
-      {
-        type: 'COMBINED_CONCEPTS',
-        texts: { en: 'COMB_1:First Combination;COMB_2:Second Combination' },
-        title: 'COMB_1:D1,D2,A1;D3,D4,A2,A3'
-      }
-    ];
-
-    expect(getCombinationDefinitions(annotations, 'en')).to.deep.equal([
-      { id: 'COMB_1', name: 'First Combination', concepts: ['D1', 'D2', 'A1'] },
-    ]);
-  });
-  it('bad formatted test 2', () => {
-    const annotations = [
-      { type: 'random', title: 'test' },
-      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  },
-      {
-        type: 'COMBINED_CONCEPTS',
-        texts: { en: 'COMB_1:First Combination;COMB_2:Second Combination' },
-        title: 'COMB_1:D1,D2,A1;COMB_2:'
-      }
-    ];
-
-    expect(getCombinationDefinitions(annotations, 'en')).to.deep.equal([
-      { id: 'COMB_1', name: 'First Combination', concepts: ['D1', 'D2', 'A1'] },
-    ]);
-  });
-  it('bad formatted test 3', () => {
-    const annotations = [
-      { type: 'random', title: 'test' },
-      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  },
-      {
-        type: 'COMBINED_CONCEPTS',
-        texts: { en: 'First Combination;Second Combination' },
-        title: 'D1,D2,A1;D3,D4,A2,A3'
-      }
-    ];
-
-    expect(getCombinationDefinitions(annotations, 'en')).to.deep.equal([]);
-  });
-  it('missing localised text', () => {
-    const annotations = [
-      { type: 'random', title: 'test' },
-      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  },
-      {
-        type: 'COMBINED_CONCEPTS',
-        texts: { en: 'COMB_1:First Combination;COMB_2:Second Combination' },
-        title: 'COMB_1:D1,D2,A1;COMB_2:D3,D4,A2,A3'
-      }
-    ];
-
-    expect(getCombinationDefinitions(annotations, 'fr')).to.deep.equal([
-      { id: 'COMB_1', name: '[COMB_1]', concepts: ['D1', 'D2', 'A1'] },
-      { id: 'COMB_2', name: '[COMB_2]', concepts: ['D3', 'D4', 'A2', 'A3'] },
-    ]);
-  });
-  it('mixed order texts', () => {
-    const annotations = [
-      { type: 'random', title: 'test' },
-      { type: 'NOT_DISPLAYED', title: 'FREQ=A'  },
-      {
-        type: 'COMBINED_CONCEPTS',
-        texts: { en: 'COMB_2:Second Combination;COMB_1:First Combination' },
-        title: 'COMB_1:D1,D2,A1;COMB_2:D3,D4,A2,A3'
-      }
-    ];
-
-    expect(getCombinationDefinitions(annotations, 'en')).to.deep.equal([
-      { id: 'COMB_1', name: 'First Combination', concepts: ['D1', 'D2', 'A1'] },
-      { id: 'COMB_2', name: 'Second Combination', concepts: ['D3', 'D4', 'A2', 'A3'] },
-    ]);
-  });
-});

package/test/getCombinationDimensionsData.test.js

@@ -1,99 +0,0 @@
-import { expect } from 'chai';
-import { getCombinationDimensionsData } from '../src/rules2/src/table/getCombinationDimensionsData';
-
-describe('getCombinationDimensionsData', () => {
-  it('basic test', () => {
-    const combination = {
-      id: 'COMB',
-      dimensions: [
-        {
-          id: 'D0',
-          values: [
-            { id: 'v0' },
-            { id: 'v1' },
-            { id: 'v2' },
-          ]
-        },
-        {
-          id: 'D1',
-          display: false,
-          values: [
-            { id: 'v0' },
-            { id: 'v1', hasAdvancedAttributes: true },
-            { id: 'v2' },
-          ]
-        },
-        {
-          id: 'D2',
-          values: [
-            { id: 'v0' },
-            { id: 'v1' },
-            { id: 'v2' },
-          ]
-        }
-      ]
-    };
-
-    const indexes = [0, 1, -2];
-
-    const previous = { D0: { id: 'v0', display: true }, D1: { id: 'v0', display: false }, D2: { id: 'v2', display: true } };
-
-    expect(getCombinationDimensionsData(indexes, combination, previous, true)).to.deep.equal({
-      dimValues: {
-        D0: { id: 'v0', display: true },
-        D1: { id: 'v1', hasAdvancedAttributes: true, display: false },
-        D2: { id: 'v2', display: true }
-      },
-      sameSerie: false,
-      coordinates: { D0: 'v0', D1: 'v1', D2: 'v2' },
-      ids: ['D0=v0', 'D1=v1', 'D2=v2'],
-      hasAdvancedAttributes: true
-    });
-  });
-  it('same value but under different hierarchy', () => {
-    const combination = {
-      id: 'COMB',
-      dimensions: [
-        {
-          id: 'D0',
-          values: [
-            { id: 'v0' },
-            { id: 'v1' },
-            { id: 'v2' },
-          ]
-        },
-        {
-          id: 'D1',
-          values: [
-            { id: 'EU' },
-            { id: 'FRA', parents: ['EU'] },
-            { id: 'GER', parents: ['EU'] },
-            { id: 'OECD' },
-            { id: 'FRA', parents: ['OECD'] },
-            { id: 'GER', parents: ['OECD'] },
-          ],
-          indexedValues: {
-            EU: { id: 'EU' },
-            FRA: { id: 'FRA' },
-            GER: { id: 'GER' },
-            OECD: { id: 'OECD' },
-          }
-        },
-      ]
-    };
-
-    const indexes = [0, 4];
-
-    const previous = { D0: { id: 'v0', display: true }, D1: { id: 'FRA', display: true, parents: [{ id: 'EU' }], parentsIds: ['EU'], missingParents: [] } };
-    expect(getCombinationDimensionsData(indexes, combination, previous, true)).to.deep.equal({
-      dimValues: {
-        D0: { id: 'v0', display: true },
-        D1: { id: 'FRA', display: true, parents: [], missingParents: [{ id: 'OECD' }], parentsIds: ['OECD'] },
-      },
-      sameSerie: false,
-      coordinates: { D0: 'v0', D1: 'FRA' },
-      ids: ['D0=v0', 'D1=FRA'],
-      hasAdvancedAttributes: undefined
-    });
-  });
-});

package/test/getDataflowAttributes.test.js

@@ -1,23 +0,0 @@
-import { expect } from 'chai';
-import { getDataflowAttributes } from '../src/rules2/src/';
-
-describe('getDataflowAttributes tests', () => {
-  it('complete case', () => {
-    const attributes = [
-      { id: 'HEADER1', header: true, relationship: [], display: false, values: [{ id: 'v' }] },
-      { id: 'HEADER2', header: true, relationship: [], values: [{ id: 'v', display: false }] },
-      { id: 'HEADER3', header: true, relationship: [], values: [{ id: '_Z' }] },
-      { id: 'HEADER4', header: true, relationship: [], values: [] },
-      { id: 'HEADER5', header: true, relationship: [], values: [{ id: 'v' }] },
-      { id: 'HEADER6', header: true, relationship: [], values: [{ id: 'v' }] },
-      { id: 'HEADER7', header: true, relationship: ['DIM1'], values: [{ id: 'v' }] },
-      { id: 'SERIE', series: true, relationship: [], values: [{ id: 'v' }] },
-    ];
-
-    const combinations = [{ id: 'COMB', concepts: ['DIM1', 'DIM2', 'HEADER5'] }];
-
-    expect(getDataflowAttributes(attributes, combinations)).to.deep.equal({
-      HEADER6: { id: 'HEADER6', value: { id: 'v' } }
-    });
-  });
-});

package/test/getDataflowTooltipAttributesIds.test.js

@@ -1,146 +0,0 @@
-import { expect } from 'chai';
-import { getDataflowTooltipAttributesIds } from '../src/rules2/src';
-
-const def = {
-  flags: ['f0', 'f1'],
-  notes: ['foot0', 'foot1']
-};
-
-describe('getDataflowTooltipAttributesIds tests', () => {
-  it('blank case', () => {
-    expect(getDataflowTooltipAttributesIds({ data: undefined }, undefined))
-      .to.deep.equal({ flags: [], notes: [] });
-  });
-  it('no override', () => {
-    const data = {
-      dataSets: [{
-        annotations: [0, 1]
-      }],
-      structure: {
-        annotations: [
-          { id: 'annot0', title: 'test' },
-          { id: 'annot1', title: 'test' },
-          { id: 'annot2', title: 'test' },
-        ]
-      }
-    };
-
-    expect(getDataflowTooltipAttributesIds({ data }, def)).to.deep.equal(def);
-  });
-  it('flags override', () => {
-    const data = {
-      dataSets: [{
-        annotations: [0, 1]
-      }],
-      structure: {
-        annotations: [
-          { id: 'annot0', title: 'test' },
-          { id: 'annot1', type: 'LAYOUT_FLAG', title: 'f2,f3' },
-          { id: 'annot2', title: 'test' },
-        ]
-      }
-    };
-
-    expect(getDataflowTooltipAttributesIds({ data }, def)).to.deep.equal({ flags: ['f2', 'f3'], notes: ['foot0', 'foot1'] });
-  });
-  it('footnotes override', () => {
-    const data = {
-      dataSets: [{
-        annotations: [0, 1]
-      }],
-      structure: {
-        annotations: [
-          { id: 'annot0', title: 'test' },
-          { id: 'annot1', type: 'LAYOUT_NOTE', title: 'foot2,foot3' },
-          { id: 'annot2', title: 'test' },
-        ]
-      }
-    };
-
-    expect(getDataflowTooltipAttributesIds({ data }, def)).to.deep.equal({ flags: ['f0', 'f1'], notes: ['foot2', 'foot3'] });
-  });
-  it('flags and footnotes override', () => {
-    const data = {
-      dataSets: [{
-        annotations: [0, 1]
-      }],
-      structure: {
-        annotations: [
-          { id: 'annot0', type: 'LAYOUT_FLAG', title: 'f2,f3' },
-          { id: 'annot1', type: 'LAYOUT_NOTE', title: 'foot2,foot3' },
-          { id: 'annot2', title: 'test' },
-        ]
-      }
-    };
-
-    expect(getDataflowTooltipAttributesIds({ data }, def)).to.deep.equal({ flags: ['f2', 'f3'], notes: ['foot2', 'foot3'] });
-  });
-  it('annotation without content erase defaults', () => {
-    const data = {
-      dataSets: [{
-        annotations: [0, 1]
-      }],
-      structure: {
-        annotations: [
-          { id: 'annot0', type: 'LAYOUT_FLAG', title: 'f2,f3' },
-          { id: 'annot1', type: 'LAYOUT_NOTE' },
-          { id: 'annot2', title: 'test' },
-        ]
-      }
-    };
-
-    expect(getDataflowTooltipAttributesIds({ data }, def)).to.deep.equal({ flags: ['f2', 'f3'], notes: [] });
-  });
-  it('custom flags overrides default notes', () => {
-    const defaultIds = {
-      flags: [],
-      notes: ['ATTR0', 'ATTR1']
-    };
-    const data = {
-      dataSets: [{
-        annotations: [0]
-      }],
-      structure: {
-        annotations: [
-          { id: 'annot0', type: 'LAYOUT_FLAG', title: 'ATTR0,ATTR1' },
-        ]
-      }
-    };
-    expect(getDataflowTooltipAttributesIds({ data }, defaultIds)).to.deep.equal({ flags: ['ATTR0', 'ATTR1'], notes: [] });
-  });
-  it('custom notes overrides default flags', () => {
-    const defaultIds  = {
-      flags: ['ATTR0', 'ATTR1'],
-      notes: ['ATTR2', 'ATTR3']
-    };
-    const data = {
-      dataSets: [{
-        annotations: [0]
-      }],
-      structure: {
-        annotations: [
-          { id: 'annot0', type: 'LAYOUT_NOTE', title: 'ATTR1,ATTR2' },
-        ]
-      }
-    };
-    expect(getDataflowTooltipAttributesIds({ data }, defaultIds)).to.deep.equal({ flags: ['ATTR0'], notes: ['ATTR1', 'ATTR2'] });
-  });
-  it('custom flags overrides custom notes', () => {
-    const defaultIds  = {
-      flags: [],
-      notes: []
-    };
-    const data = {
-      dataSets: [{
-        annotations: [0, 1]
-      }],
-      structure: {
-        annotations: [
-          { id: 'annot0', type: 'LAYOUT_FLAG', title: 'ATTR0,ATTR1' },
-          { id: 'annot1', type: 'LAYOUT_NOTE', title: 'ATTR1,ATTR2' },
-        ]
-      }
-    };
-    expect(getDataflowTooltipAttributesIds({ data }, defaultIds)).to.deep.equal({ flags: ['ATTR0', 'ATTR1'], notes: ['ATTR2'] });
-  });
-});

package/test/getDimensionValuesIndexes.test.js

@@ -1,33 +0,0 @@
-import { expect } from 'chai';
-import { getDimensionValuesIndexes } from '../src/rules2/src/getDimensionValuesIndexes';
-
-describe('getDimensionValuesIndexes test', () => {
-  it('basic test', () => {
-    const values = [
-      { id: 'OECD', parent: undefined, parents: [], __index: 2 },
-      { id: 'GER', parent: 'OECD', parents: ['OECD'], __index: 1 },
-      { id: 'FRA', parent: 'OECD', parents: ['OECD'], __index: 0 },
-      { id: 'USA', parent: 'OECD', parents: ['OECD'], __index: 3 },
-      { id: 'A', parent: undefined, parents: [], __index: 4 },
-      { id: 'USA', parent: 'A', parents: ['A'], __index: 3 },
-      { id: 'MEX', parent: 'A', parents: ['A'], __index: 7 },
-      { id: 'EA', parent: undefined, parents: [], __index: 5 },
-      { id: 'FRA', parent: 'EA', parents: ['EA'], __index: 0 },
-      { id: 'GER', parent: 'EA', parents: ['EA'], __index: 1 },
-      { id: 'CHI', parent: undefined, parents: [], __index: 6 }
-    ];
-
-    const indexes = {
-      '0': [2, 8],
-      '1': [1, 9],
-      '2': [0],
-      '3': [3, 5],
-      '4': [4],
-      '5': [7],
-      '6': [10],
-      '7': [6]
-    };
-
-    expect(getDimensionValuesIndexes(values)).to.deep.equal(indexes);
-  });
-});

package/test/getGridOptions.test.js

@@ -1,65 +0,0 @@
-import { expect } from 'chai';
-import { getGridOptions } from '../src/rules/src/chart/getGridOptions';
-
-describe('getGridOptions tests', () => {
-  it('blank test', () => {
-    expect(getGridOptions(null, null)).to.deep.equal({
-      x: { baselines: [0], color: 'white' },
-      y: { baselines: [0], color: 'white' }
-    });
-  });
-  it('default bar test', () => {
-    expect(getGridOptions('BarChart', {})).to.deep.equal({
-      x: { baselines: [0], color: 'white', thickness: 0 },
-      y: { baselines: [0], color: 'white' }
-    });
-  });
-  it('default row test', () => {
-    expect(getGridOptions('RowChart', {})).to.deep.equal({
-      x: { baselines: [0], color: 'white' },
-      y: { baselines: [0], color: 'white', thickness: 0 }
-    });
-  });
-  it('default scatter test', () => {
-    expect(getGridOptions('ScatterChart', {})).to.deep.equal({
-      x: { baselines: [0], color: 'white' },
-      y: { baselines: [0], color: 'white' }
-    });
-  });
-  it('default timeline test', () => {
-    expect(getGridOptions('TimelineChart', {})).to.deep.equal({
-      x: { baselines: [0], color: 'white', thickness: 0 },
-      y: { baselines: [0], color: 'white' }
-    });
-  });
-  it('default horizontal symbol test', () => {
-    expect(getGridOptions('HorizontalSymbolChart', {})).to.deep.equal({
-      x: { baselines: [0], color: 'white' },
-      y: { baselines: [0], color: 'white', thickness: 0 }
-    });
-  });
-  it('default vertical symbol test', () => {
-    expect(getGridOptions('VerticalSymbolChart', {})).to.deep.equal({
-      x: { baselines: [0], color: 'white', thickness: 0 },
-      y: { baselines: [0], color: 'white' }
-    });
-  });
-  it('default stacked test', () => {
-    expect(getGridOptions('StackedBarChart', {})).to.deep.equal({
-      x: { baselines: [0], color: 'white', thickness: 0 },
-      y: { baselines: [0], color: 'white' }
-    });
-  });
-  it('customization test', () => {
-    expect(getGridOptions('BarChart', {
-      grid: {
-        customOptions: { deep: 'test' },
-        x: { color: 'red', thickness: 2 }
-      }
-    })).to.deep.equal({
-      customOptions: { deep: 'test' },
-      x: { baselines: [0], color: 'red', thickness: 2 },
-      y: { baselines: [0], color: 'white' }
-    });
-  });
-});

package/test/getHCodelistsRefs.test.js

@@ -1,23 +0,0 @@
-import { expect } from 'chai';
-import { getHCodelistsRefs } from '../src/rules2/src';
-
-describe('getHCodelistsRefs tests', () => {
-  it('complete case', () => {
-    const annotations = [
-      { type: 'test' },
-      { type: 'HIER_CONTEXT', text: 'C1:A:HCL1(1.0).HIER1' },
-      { type: 'HIER_CONTEXT', title: 'C2:A:HCL2(1.0).HIER1' },
-      { type: 'HIER_CONTEXT', text: 'C1:A:HCL1(1.0).HIER2' },
-      { type: 'HIER_CONTEXT', text: 'C3:A:HCL3(1.0).HIER,C4:A:HCL4(1.0).HIER' }
-    ];
-
-    const expected = {
-      C1: { agencyId: 'A', codelistId: 'C1', code: 'HCL1', hierarchy: 'HIER2', version: '1.0' },
-      C2: { agencyId: 'A', codelistId: 'C2', code: 'HCL2', hierarchy: 'HIER1', version: '1.0' },
-      C3: { agencyId: 'A', codelistId: 'C3', code: 'HCL3', hierarchy: 'HIER', version: '1.0' },
-      C4: { agencyId: 'A', codelistId: 'C4', code: 'HCL4', hierarchy: 'HIER', version: '1.0' },
-    }
-  
-    expect(getHCodelistsRefs(annotations)).to.deep.equal(expected);
-  });
-});

package/test/getHeaderCombinations.test.js

@@ -1,62 +0,0 @@
-import { expect } from 'chai';
-import { getHeaderCombinations } from '../src/rules2/src/';
-
-describe('getHeaderCombinations tests', () => {
-  it('complete test', () => {
-    const combinations = [
-      { id: 'COMB1', name: 'comb 1', header: true, concepts: ['DIM1', 'DIM2', 'DIM4', 'ATTR1'] },
-      { id: 'COMB2', name: 'comb 2', series: true, concepts: ['DIM3', 'ATTR2'] },
-      { id: 'COMB3', name: 'comb 3', header: true, display: false, concepts: ['DIM3', 'ATTR2'] }
-    ];
-
-    const dimensions = [
-      { id: 'DIM1', name: 'dim 1', values: [{ id: 'v', name: 'dim 1 value' }] },
-      { id: 'DIM3', name: 'dim 3', values: [{ id: 'v', name: 'dim 3 value' }] },
-      { id: 'DIM4', name: 'dim 4', values: [{ id: '_Z', name: 'Not applicable' }] },
-    ];
-
-    const attributes = [
-      { id: 'ATTR1', name: 'attr 1', values: [{ id: 'v', name: 'attr 1 value', display: false }] },
-      { id: 'ATTR2', name: 'attr 2', values: [{ id: 'v', name: 'attr 2 value' }] },
-    ];
-
-    expect(getHeaderCombinations(combinations, dimensions, attributes, 'label')).to.deep.equal([
-      { header: 'comb 1:', label: 'dim 1 value' }
-    ]);
-  });
-  it('not display usecases', () => {
-    const dimensions = [
-      { id: 'd0', values: [{ id: 'd0v', name: 'd0 value', display: false }] },
-      { id: 'd1', values: [{ id: '_T', name: 'Total' }] },
-      { id: 'd2', values: [{ id: 'd2v', name: 'd2 value', display: false }] },
-    ];
-
-    const attributes = [
-      { id: 'a0', values: [{ id: 'a0v', name: 'a0 value', display: false }] },
-      { id: 'a1', values: [{ id: 'a1v', name: 'a1 value', display: false }] },
-      { id: 'a2', values: [{ id: '_T', name: 'Total' }] },
-    ];
-
-    const combinations = [
-      { id: 'comb0', name: 'combination 0', header: true, concepts: ['a0', 'a1', 'd0'] },
-      { id: 'comb1', name: 'combination 1', header: true, concepts: ['d0', 'd2', 'a3'] },
-      { id: 'comb2', name: 'combination 2', header: true, concepts: ['d0', 'd1', 'd2'] },
-      { id: 'comb3', name: 'combination 3', header: true, concepts: ['a0', 'a1', 'a2'] },
-    ];
-    expect(getHeaderCombinations(combinations, dimensions, attributes, 'label')).to.deep.equal([
-      { header: 'combination 0:', label: 'd0 value' },
-      { header: 'combination 1:', label: 'd0 value' },
-      { header: 'combination 2:', label: 'Total' },
-    ]);
-    expect(getHeaderCombinations(combinations, dimensions, attributes, 'code')).to.deep.equal([
-      { header: 'comb0:', label: 'd0v' },
-      { header: 'comb1:', label: 'd0v, d2v' },
-      { header: 'comb2:', label: 'd0v, _T, d2v' },
-    ]);
-    expect(getHeaderCombinations(combinations, dimensions, attributes, 'both')).to.deep.equal([
-      { header: '(comb0) combination 0:', label: '(d0v) d0 value' },
-      { header: '(comb1) combination 1:', label: '(d0v, d2v) d0 value' },
-      { header: '(comb2) combination 2:', label: '(d0v, _T, d2v) Total' },
-    ]);
-  })
-});

package/test/getHeaderTitle.test.js

@@ -1,25 +0,0 @@
-import { expect } from 'chai';
-import { getHeaderTitle } from '../src/rules2/src/';
-
-describe('getHeaderTitle tests', () => {
-  it('basic case', () => {
-
-    const dataflow = { id: 'DF', name: 'dataflow' };
-
-    const attributes = {
-      FLAG: { id: 'FLAG', name: 'flag', value: { id: 'v', name: 'flag value' } },
-      NOTE: { id: 'NOTE', name: 'note', value: { id: 'v2', name: 'note value' } },
-      OTHER: { id: 'OTHER', name: 'other', value: { id: 'v3', name: 'other value' } },
-    }
-
-    const customAttributes = { flags: ['FLAG'], notes: ['NOTE'] };
-
-    expect(getHeaderTitle(dataflow, attributes, 'label', customAttributes)).to.deep.equal({
-      label: 'dataflow',
-      flags: [
-        { code: 'v', header: 'flag:', label: 'flag value' },
-        { code: undefined, header: 'note:', label: 'note value' },
-      ]
-    });
-  });
-});

package/test/getLayout.test.js

@@ -1,54 +0,0 @@
-import { expect } from 'chai';
-import { getLayout } from '../src/rules2/src';
-
-describe('getLayout tests', () => {
-  it('complete test', () => {
-    const isTimeInverted = true;
-    const dimensions = [
-      { id: 'D1', values: [{ id: 'v1' }, { id: 'v2' }] },
-      { id: 'D2', values: [{ id: 'v1' }, { id: 'v2' }] },
-      { id: 'D3', values: [{ id: 'v1' }, { id: 'v2' }] },
-      { id: 'D4', values: [{ id: 'v1' }, { id: 'v2' }] },
-      { id: 'D5', values: [{ id: 'v1' }, { id: 'v2' }] },
-      { id: 'TIME_PERIOD', values: [{ id: 'v1' }, { id: 'v2' }] }
-    ];
-
-    const layoutIds = {
-      header: ['TIME_PERIOD', 'COMB1', 'COMB2'],
-      sections: ['D4'],
-      rows: ['COMB3', 'COMB4']
-    };
-
-    const combinations = [
-       { id: 'COMB1', concepts: ['D1', 'D2'], relationship: ['D1', 'D2'] },
-       { id: 'COMB2', concepts: ['D3', 'A1'], relationship: ['D3', 'D4', 'TIME_PERIOD'] },
-       { id: 'COMB3', concepts: ['D4', 'D5'], relationship: ['D4', 'D5'] },
-       { id: 'COMB4', concepts: ['A2', 'A3'], relationship: ['D5', 'TIME_PERIOD'] }
-    ];
-
-    expect(getLayout(layoutIds, dimensions, combinations, isTimeInverted)).to.deep.equal({
-      header: [
-        { id: 'TIME_PERIOD', isInverted: true, values: [{ id: 'v1' }, { id: 'v2' }] },
-        {
-          id: 'COMB1',
-          concepts: ['D1', 'D2'],
-          relationship: ['D1', 'D2'],
-          dimensions: [
-            { id: 'D1', values: [{ id: 'v1' }, { id: 'v2' }] },
-            { id: 'D2', values: [{ id: 'v1' }, { id: 'v2' }] },
-          ]
-        },
-        { id: 'D3', values: [{ id: 'v1' }, { id: 'v2' }] },
-      ],
-      sections: [{ id: 'D4', values: [{ id: 'v1' }, { id: 'v2' }] }],
-      rows: [
-        {
-          id: 'COMB3',
-          concepts: ['D4', 'D5'],
-          relationship: ['D4', 'D5'],
-          dimensions: [{ id: 'D5', values: [{ id: 'v1' }, { id: 'v2' }] }]
-        },
-      ]
-    })
-  });
-});