@sis-cc/dotstatsuite-components 15.0.20 → 16.0.0

package/test/getUnitsArtefacts.test.js

@@ -1,117 +0,0 @@
-import { expect } from 'chai';
-import { getUnitsArtefacts } from '../src/rules/src/table/units/getUnitsArtefacts';
-
-const data = {
-  structure: {
-    attributes: {
-      observation: [
-        { id: 'A3', values: [] },
-        { id: 'A4', relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }] },
-        { id: 'A5', relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }, { id: 'V2' }] },
-        { id: 'A6', relationship: { dimensions: ['D1'] }, values: [{ id: 'V1' }] },
-        { id: 'A7', relationship: { dimensions: ['D1', 'D2'] }, values: [{ id: 'V1' }] },
-        { id: 'A8', relationship: { primaryMeasure: 'OBS_VALUE' }, values: [{ id: 'V1' }, { id: 'V2' }] },
-        { id: 'A9', relationship: { primaryMeasure: 'OBS_VALUE' }, values: [{ id: 'V1' }, { id: 'V2' }], display: false },
-        { id: 'A10', relationship: { observation: {} }, values: [{ id: 'V1' }, { id: 'V2' }] },
-        { id: 'A0', relationship: { none: {} }, values: [] },
-        { id: 'A1', relationship: { none: {} }, values: [{ id: 'V1' }] },
-        { id: 'A2', relationship: { dataflow: {} }, values: [{ id: 'V1' }, { id: 'V2' }] },
-      ]
-    },
-    dimensions: {
-      observation: [
-        { id: 'D0', values: [] },
-        { id: 'D1', values: [{ id: 'V1' }] },
-        { id: 'D2', values: [{ id: 'V1' }, { id: 'V2' }] },
-      ]
-    },
-  }
-};
-
-describe('getUnitsArtefacts tests', () => {
-  it('no data', () => {
-    expect(getUnitsArtefacts({ data: { data: undefined } })).to.deep.equal({
-      attributes: { header: {}, series: {} },
-      dimensions: { header: {}, series: {} },
-    });
-  });
-  it('no units definition codes', () => {
-    expect(getUnitsArtefacts({ data: { data } })).to.deep.equal({
-      attributes: { header: {}, series: {} },
-      dimensions: { header: {}, series: {} },
-    });
-  });
-  it('full header', () => {
-    expect(getUnitsArtefacts({ data: { data }, unitsDefinitionCodes: ['A1', 'D1'] })).to.deep.equal({
-      attributes: { header: { A1: { id: 'A1', relationship: { none: {} }, index: 9, datasetLevel: true, values: [{ id: 'V1' }] } }, series: {} },
-      dimensions: { header: { D1: { id: 'D1', header: true, index: 1, values: [{ id: 'V1' }] } }, series: {} },
-    });
-  });
-  it('full series', () => {
-    expect(getUnitsArtefacts({ data: { data }, unitsDefinitionCodes: ['A4', 'A5', 'D2'] })).to.deep.equal({
-      attributes: {
-        series: {
-          A4: { id: 'A4', index: 1, relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }] },
-          A5: { id: 'A5', index: 2, relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }, { id: 'V2' }] }
-        },
-        header: {}
-      },
-      dimensions: { series: { D2: { id: 'D2', index: 2, values: [{ id: 'V1' }, { id: 'V2' }] } }, header: {} },
-    });
-  });
-  it('header dimensions with series', () => {
-    expect(getUnitsArtefacts({ data: { data }, unitsDefinitionCodes: ['A4', 'A5', 'D1', 'D2'] })).to.deep.equal({
-      attributes: {
-        series: {
-          A4: { id: 'A4', index: 1, relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }] },
-          A5: { id: 'A5', index: 2, relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }, { id: 'V2' }] }
-        },
-        header: {}
-      },
-      dimensions: {
-        series: {
-          D1: { id: 'D1', index: 1, header: true, values: [{ id: 'V1' }] },
-          D2: { id: 'D2', index: 2, values: [{ id: 'V1' }, { id: 'V2' }] }
-        },
-        header: {},
-      }
-    });
-  });
-  it('header attributes with series', () => {
-    expect(getUnitsArtefacts({ data: { data }, unitsDefinitionCodes: ['A1', 'A4', 'A5', 'D2'] })).to.deep.equal({
-      attributes: {
-        series: {
-          A1: { id: 'A1', relationship: { none: {} }, index: 9, datasetLevel: true, values: [{ id: 'V1' }] },
-          A4: { id: 'A4', index: 1, relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }] },
-          A5: { id: 'A5', index: 2, relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }, { id: 'V2' }] }
-        },
-        header: {}
-      },
-      dimensions: { series: { D2: { id: 'D2', index: 2, values: [{ id: 'V1' }, { id: 'V2' }] } }, header: {} },
-    });
-  });
-  it('all attached dimensions single value makes a header', () => {
-    expect(getUnitsArtefacts({ data: { data }, unitsDefinitionCodes: ['A6'] })).to.deep.equal({
-      attributes: { header: { A6: { id: 'A6', index: 3, relationship: { dimensions: [] }, values: [{ id: 'V1' }] }, }, series: {} },
-      dimensions: { header: {}, series: {} },
-    });
-  });
-  it('series attributes keeps only multi values dimensions in attachment', () => {
-    expect(getUnitsArtefacts({ data: { data }, unitsDefinitionCodes: ['A7'] })).to.deep.equal({
-      attributes: { series: { A7: { id: 'A7', index: 4, relationship: { dimensions: ['D2'] }, values: [{ id: 'V1' }] }, }, header: {} },
-      dimensions: { header: {}, series: {} },
-    });
-  });
-  it('no display annotations', () => {
-    expect(getUnitsArtefacts({ data: { data }, unitsDefinitionCodes: ['A8', 'A9'] })).to.deep.equal({
-      attributes: { header: {}, series: { A8: { id: 'A8', observations: true, index: 5, relationship: { primaryMeasure: 'OBS_VALUE' }, values: [{ id: 'V1' }, { id: 'V2' }] } } },
-      dimensions: { header: {}, series: {} },
-    });
-  });
-  it('observation relationship', () => {
-    expect(getUnitsArtefacts({ data: { data }, unitsDefinitionCodes: ['A9', 'A10'] })).to.deep.equal({
-      attributes: { header: {}, series: { A10: { id: 'A10', observations: true, index: 7, relationship: { observation: {} }, values: [{ id: 'V1' }, { id: 'V2' }] } } },
-      dimensions: { header: {}, series: {} },
-    });
-  });
-});

package/test/getUnitsDefinition.test.js

@@ -1,37 +0,0 @@
-import { expect } from 'chai';
-import { getUnitsDefinition } from '../src/rules/src/table/units/getUnitsDefinition';
-
-const data = {
-  data: {
-    dataSets: [{
-      annotations: [0, 3]
-    }],
-    structure: {
-      annotations: [
-        { type: 'A0' },
-        { trash: true },
-        { type: 'A1', title: 'C0,C1,C2' },
-        { type: 'A2', title: 'C3,C4' },
-      ]
-    }
-  }
-};
-
-describe('getUnitsDefinition tests', () => {
-  it('no annotation id provided', () => {
-    expect(getUnitsDefinition({ data, defaultCodes: ['C5', 'C6'], annotationsDefinitionCodes: {} }))
-      .to.deep.equal(['C5', 'C6']);
-  });
-  it('no codes in annotation', () => {
-    expect(getUnitsDefinition({ data, defaultCodes: ['C5', 'C6'], annotationsDefinitionCodes: { concepts: ['A0'] } }))
-      .to.deep.equal(['C5', 'C6']);
-  });
-  it('not a dataset annotation', () => {
-    expect(getUnitsDefinition({ data, defaultCodes: ['C5', 'C6'], annotationsDefinitionCodes: { concepts: ['A1'] } }))
-      .to.deep.equal(['C5', 'C6']);
-  });
-  it('basic case', () => {
-    expect(getUnitsDefinition({ data, defaultCodes: ['C5', 'C6'], annotationsDefinitionCodes: { concepts: ['A2'] } }))
-      .to.deep.equal(['C3', 'C4']);
-  });
-});

package/test/getUnitsInLayout.test.js

@@ -1,77 +0,0 @@
-import { expect } from 'chai';
-import { getUnitsInLayout } from '../src/rules/src/table/units/getUnitsinLayout';
-
-describe('getUnitsInLayout tests', () => {
-  it('blank test', () => {
-    expect(getUnitsInLayout({
-      layoutIds: { header: [], sections: [], rows: [] },
-      unitsAttachmentSeriesIds: [],
-      unitsDefinitionCodes: [],
-      unitsSeries: {}
-    })).to.deep.equal({
-      unitsLevelDisplay: 'cells',
-      unitsAttachmentIndexesInLayout: { header: [], sections: [], rows: [] },
-      unitsIndexesInLayout: { header: [], sections: [], rows: [] },
-    });
-  });
-  it('header case', () => {
-    expect(getUnitsInLayout({
-      layoutIds: { header: ['H1', 'H2', 'H3'], sections: ['S1', 'S2', 'S3'], rows: ['R1', 'R2', 'R3'] },
-      unitsAttachmentSeriesIds: ['H1', 'H3'],
-      unitsDefinitionCodes: ['H1'],
-      unitsSeries: { not: 'empty' }
-    })).to.deep.equal({
-      unitsLevelDisplay: 'header',
-      unitsAttachmentIndexesInLayout: { header: [0, 2], sections: [], rows: [] },
-      unitsIndexesInLayout: { header: [0], sections: [], rows: [] },
-    });
-  });
-  it('sections case', () => {
-    expect(getUnitsInLayout({
-      layoutIds: { header: ['H1', 'H2', 'H3'], sections: ['S1', 'S2', 'S3'], rows: ['R1', 'R2', 'R3'] },
-      unitsAttachmentSeriesIds: ['S2', 'S3'],
-      unitsDefinitionCodes: ['S2', 'S3'],
-      unitsSeries: { not: 'empty' }
-    })).to.deep.equal({
-      unitsLevelDisplay: 'sections',
-      unitsAttachmentIndexesInLayout: { header: [], sections: [1, 2], rows: [] },
-      unitsIndexesInLayout: { header: [], sections: [1, 2], rows: [] },
-    });
-  });
-  it('only rows case', () => {
-    expect(getUnitsInLayout({
-      layoutIds: { header: ['H1', 'H2', 'H3'], sections: ['S1', 'S2', 'S3'], rows: ['R1', 'R2', 'R3'] },
-      unitsAttachmentSeriesIds: ['R2'],
-      unitsDefinitionCodes: [],
-      unitsSeries: { not: 'empty' }
-    })).to.deep.equal({
-      unitsLevelDisplay: 'rows',
-      unitsAttachmentIndexesInLayout: { header: [], sections: [], rows: [1] },
-      unitsIndexesInLayout: { header: [], sections: [], rows: [] },
-    });
-  });
-  it('rows and sections case', () => {
-    expect(getUnitsInLayout({
-      layoutIds: { header: ['H1', 'H2', 'H3'], sections: ['S1', 'S2', 'S3'], rows: ['R1', 'R2', 'R3'] },
-      unitsAttachmentSeriesIds: ['R2', 'S1', 'S3'],
-      unitsDefinitionCodes: ['R2', 'S1'],
-      unitsSeries: { not: 'empty' }
-    })).to.deep.equal({
-      unitsLevelDisplay: 'rows',
-      unitsAttachmentIndexesInLayout: { header: [], sections: [0, 2], rows: [1] },
-      unitsIndexesInLayout: { header: [], sections: [0], rows: [1] },
-    });
-  });
-  it('mixed case', () => {
-    expect(getUnitsInLayout({
-      layoutIds: { header: ['H1', 'H2', 'H3'], sections: ['S1', 'S2', 'S3'], rows: ['R1', 'R2', 'R3'] },
-      unitsAttachmentSeriesIds: ['R2', 'S1', 'H3'],
-      unitsDefinitionCodes: [],
-      unitsSeries: { not: 'empty' }
-    })).to.deep.equal({
-      unitsLevelDisplay: 'cells',
-      unitsAttachmentIndexesInLayout: { header: [], sections: [], rows: [] },
-      unitsIndexesInLayout: { header: [], sections: [], rows: [] },
-    });
-  });
-});

package/test/getUnitsSeries.test.js

@@ -1,154 +0,0 @@
-import { expect } from 'chai';
-import { getUnitsSeries } from '../src/rules/src/table/units/getUnitsSeries';
-
-
-describe('getUnitsSeries tests', () => {
-  const observations = {
-    0: {
-      key: '0:0:0:0',
-      units: {
-        serieKey: '0:0:x:x',
-        A: { value: { index: 0 } },
-        B: { value: { index: 0 } },
-        C: { value: { index: 0 } }
-      }
-    },
-    1: {
-      key: '0:0:1:0',
-      units: {
-        serieKey: '0:0:x:x',
-        A: { value: { index: 0 } },
-        B: { value: { index: 0 } },
-        C: { value: { index: 1 } }
-      }
-    },
-    2: {
-      key: '1:0:0:0',
-      units: {
-        serieKey: '1:0:x:x',
-        A: { value: { index: 1 } },
-        B: { value: { index: 1 } },
-        C: { value: { index: 0 } }
-      }
-    },
-    3: {
-      key: '1:0:1:0',
-      units: {
-        serieKey: '1:0:x:x',
-        A: { value: { index: 1 } },
-        B: { value: { index: 1 } },
-        C: { value: { index: 0 } }
-      }
-    },
-    4: {
-      key: '2:0:0:0',
-      units: {
-        serieKey: '2:0:x:x',
-        A: { value: { index: 2 } },
-        B: { value: { index: 0 } },
-        C: { value: { index: 0 } }
-      }
-    }
-  };
-  it('blank test', () => {
-    expect(getUnitsSeries({})).to.deep.equal({});
-  });
-  it('basic test', () => {
-    expect(getUnitsSeries(observations))
-      .to.deep.equal({
-        '0:0:x:x': { A: { value: { index: 0 } }, B: { value: { index: 0 } }, C: null, serieKey: '0:0:x:x' },
-        '1:0:x:x': { A: { value: { index: 1 } }, B: { value: { index: 1 } }, C: { value: { index: 0 } }, serieKey: '1:0:x:x' },
-        '2:0:x:x': { A: { value: { index: 2 } }, B: { value: { index: 0 } }, C: { value: { index: 0 } }, serieKey: '2:0:x:x' }
-      });
-  });
-  it('empty units test', () => {
-    const obs = {
-      0: {
-        key: '0:0:0:0',
-        units: { serieKey: '0:0:x:x' }
-      },
-      1: {
-        key: '0:0:1:0',
-        units: { serieKey: '0:0:x:x' }
-      },
-      2: {
-        key: '1:0:0:0',
-        units: { serieKey: '1:0:x:x' }
-      },
-      3: {
-        key: '1:0:1:0',
-        units: { serieKey: '1:0:x:x' }
-      },
-      4: {
-        key: '2:0:0:0',
-        units: { serieKey: '2:0:x:x' }
-      }
-    };
-    expect(getUnitsSeries(obs)).to.deep.equal({});
-  });
-});
-
-describe('getUnitsSeries tests keys difference', () => {
-  const observations = {
-    "0:0:0:0:0:0": {
-      "key": "0:0:0:0:0:0",
-      "units": {
-        "UNIT_MEASURE": { "value": { "index": 0 }},
-        "UNIT_MULT": { "value": { "index": 0 }},
-        "serieKey": "x:x:x:x:0:x"
-      },
-    },
-    "0:0:0:0:0:1": {
-      "key": "0:0:0:0:0:1",
-      "units": {
-        "UNIT_MEASURE": { "value": { "index": 0 }},
-        "UNIT_MULT": { "value": { "index": 0 }},
-        "serieKey": "x:x:x:x:0:x"
-      },
-    },
-    "0:0:0:1:0:0": {
-      "key": "0:0:0:1:0:0",
-      "units": {
-        "UNIT_MEASURE": { "value": { "index": 0 }},
-        "serieKey": "x:x:x:x:0:x"
-      },
-    },
-    "0:0:0:1:0:1": {
-      "key": "0:0:0:1:0:1",
-      "units": {
-        "UNIT_MEASURE": { "value": { "index": 0 }},
-        "serieKey": "x:x:x:x:0:x"
-      },
-    },
-    "0:0:0:2:1:0": {
-      "key": "0:0:0:2:1:0",
-      "units": { 
-        "UNIT_MEASURE": { "value": { "index": 1 }},
-        "UNIT_MULT": { "value": { "index": 0 }},
-        "serieKey": "x:x:x:x:1:x"
-        },
-    },
-    "0:0:0:2:1:1": {
-      "key": "0:0:0:2:1:1",
-      "units": {
-      "UNIT_MEASURE": { "value": { "index": 1 }},
-      "UNIT_MULT": { "value": { "index": 0 }},
-      "serieKey": "x:x:x:x:1:x"
-    },
-    }
-  };
-  const expected = {
-    "x:x:x:x:0:x": {
-      "UNIT_MEASURE": { "value": { "index": 0 }},
-      "serieKey": "x:x:x:x:0:x"
-    },
-    "x:x:x:x:1:x": {
-      "UNIT_MEASURE": { "value": { "index": 1 }},
-      "UNIT_MULT": { "value": { "index": 0 }},
-      "serieKey": "x:x:x:x:1:x"
-    }
-  };
-  it('basic test', () => {
-    expect(getUnitsSeries(observations)).to.deep.equal(expected);
-  });
-});

package/test/invertTime.test.js

@@ -1,77 +0,0 @@
-import { expect } from 'chai';
-import { invertTime } from '../src/rules2/src/invertTime';
-
-describe('invertTime tests', () => {
-  it('complete test', () => {
-    const dimensions = {
-      many: { 
-        TIME_PERIOD: {
-          id: 'TIME_PERIOD',
-          __index: 1,
-          role: 'TIME_PERIOD',
-          values: [
-            { id: 2000 },
-            { id: 2001 },
-            { id: 2002 },
-            { id: 2003 },
-            { id: 2004 },
-            { id: 2005 },
-            { id: 2006 },
-            { id: 2007 },
-            { id: 2008 },
-            { id: 2009 },
-          ]
-        }
-      }
-    };
-
-    const observations = {
-      '0:0': { orderedDimIndexes: [0, 0] },
-      '0:1': { orderedDimIndexes: [0, 1] },
-      '0:2': { orderedDimIndexes: [0, 2] },
-      '0:3': { orderedDimIndexes: [0, 3] },
-      '0:4': { orderedDimIndexes: [0, 4] },
-      '0:5': { orderedDimIndexes: [0, 5] },
-      '0:6': { orderedDimIndexes: [0, 6] },
-      '0:7': { orderedDimIndexes: [0, 7] },
-      '0:8': { orderedDimIndexes: [0, 8] },
-      '0:9': { orderedDimIndexes: [0, 9] },
-    };
-
-    const expected = {
-      dimensions: {
-        TIME_PERIOD: {
-          id: 'TIME_PERIOD',
-          role: 'TIME_PERIOD',
-          __index: 1,
-          values: [
-            { id: 2009 },
-            { id: 2008 },
-            { id: 2007 },
-            { id: 2006 },
-            { id: 2005 },
-            { id: 2004 },
-            { id: 2003 },
-            { id: 2002 },
-            { id: 2001 },
-            { id: 2000 },
-          ]
-        }
-      },
-      observations: {
-        '0:0': { orderedDimIndexes: [0, 9] },
-        '0:1': { orderedDimIndexes: [0, 8] },
-        '0:2': { orderedDimIndexes: [0, 7] },
-        '0:3': { orderedDimIndexes: [0, 6] },
-        '0:4': { orderedDimIndexes: [0, 5] },
-        '0:5': { orderedDimIndexes: [0, 4] },
-        '0:6': { orderedDimIndexes: [0, 3] },
-        '0:7': { orderedDimIndexes: [0, 2] },
-        '0:8': { orderedDimIndexes: [0, 1] },
-        '0:9': { orderedDimIndexes: [0, 0] },
-      }
-    };
-
-    expect(invertTime({ dimensions, observations }, true)).to.deep.equal(expected);
-  });
-});

package/test/parseAttributesValuesFromObservations.test.js

@@ -1,45 +0,0 @@
-import { expect } from 'chai';
-import { parseAttributesValuesFromObservations } from '../src/rules/src/table/preparators/parseAttributesValuesFromObservations';
-import { getDimensionsAttributesRegisters } from '../src/rules/src/table/preparators/getDimensionsAttributesRegisters';
-
-const attributesIdsIndexedByTargets = {
-  manyValuesDimensions: ['a1', 'a3'],
-  series: ['a2', 'a4']
-};
-
-const attributesIndexedByIds = {
-  a1: { id: 'a1', index: 0, targetIndex: 3 },
-  a2: { id: 'a2', index: 1, targetIndexes: { '0': 0, '1': 1 } },
-  a3: { id: 'a3', index: 2, targetIndex: 2 },
-  a4: { id: 'a4', index: 3, targetIndexes: { '1': 1, '4': 4 } }
-};
-
-const observations = {
-  a: { dimValuesIndexes: [0, 0, 0, 0, 0], attrValuesIndexes: [0, 3, 0, 0] },
-  b: { dimValuesIndexes: [0, 0, 0, 0, 1], attrValuesIndexes: [0, 3, 1, 2] },
-  c: { dimValuesIndexes: [0, 0, 1, 0, 0], attrValuesIndexes: [0, 3, 5, null] },
-  d: { dimValuesIndexes: [0, 0, 1, 0, 1], attrValuesIndexes: [0, 3, 0, 2] },
-};
-
-const attributesRegisters = getDimensionsAttributesRegisters(
-  attributesIdsIndexedByTargets,
-  attributesIndexedByIds
-);
-
-describe('parseAttributesValuesFromObservations test', () => {
-  it('test', () => {
-    expect(parseAttributesValuesFromObservations(observations, attributesRegisters))
-      .to.deep.equal({
-        series: {
-          '0:0:x:x:x': { a2: [3, 3, 3, 3] },
-          'x:0:x:x:0': { a4: [0, null] },
-          'x:0:x:x:1': { a4: [2, 2] }
-        },
-        dimensions: {
-          '3:0': { a1: [0, 0, 0, 0] },
-          '2:0': { a3: [0, 1] },
-          '2:1': { a3: [5, 0] }
-        }
-      });
-  });
-});

package/test/parseDimensionsIds.test.js

@@ -1,20 +0,0 @@
-import { expect } from 'chai';
-import { parseDimensionsIds } from '../src/rules/src/table/preparators/parseDimensionsIds';
-
-describe('parseDimensionsIds', () => {
-  it('basic test', () => {
-    const dimensions = [
-      {},
-      { id: 'a' },
-      { id: 'b', values: [] },
-      { id: 'c', values: [{}] },
-      { id: 'd', values: [{}, {}] },
-      { id: 'e', values: [{}, {}, {}] },
-      { id: 'f', values: [{}] }
-    ];
-    expect(parseDimensionsIds(dimensions)).to.deep.equal({
-      oneValue: { c: 3, f: 6 },
-      manyValues: { d: 4, e: 5 }
-    });
-  });
-});

package/test/prepareData.test.js

@@ -1,29 +0,0 @@
-import { expect } from 'chai';
-import { prepareData } from '../src/rules/src/table/preparators/prepareData';
-
-describe('prepareData tests', () => {
-  it('blank test', () => {
-    expect(prepareData(
-      { data: undefined },
-      {},
-      { defaultCodes: [], annotationsDefinitionCodes: {} }
-    )).to.deep.equal({
-      advancedAttributes: {},
-      dimensions: { one: {}, many: {}, length: 0 },
-      units: {
-        headerUnits: [],
-        rejectedValueIds: [],
-        unitsDefinitionCodes: [],
-        unitsAttachmentSeriesIds: [],
-        unitsSeries: {},
-      },
-      metadataCoordinates: [],
-      observations: {},
-      observationsType: undefined,
-      dataflowAttributes: {},
-      dataflowName: undefined,
-      seriesAttributes: [],
-      seriesAttributesValues: {}
-    });
-  });
-});

package/test/refineObservationsAttributesValues.test.js

@@ -1,33 +0,0 @@
-import { expect } from 'chai';
-import { refineObservationsAttributesValues } from '../src/rules/src/table/preparators/refineObservationsAttributesValues';
-
-
-const attributesByIds = {
-  a: { id: 'a', values: [{ id: 'a1' }] },
-  b: { id: 'b', values: [{ id: 'b1' }, { id: 'b2', annotations: [1, 3, 5] }] }
-};
-
-const attributesOccurences = {
-  o1: { a: [0, 0, 0, 0, 0], b: [3, 3, 3, 3, 3, 3, 3] },
-  o2: { a: [0, 0, 0, null], b: [] },
-  o3: { b: [0, 0] },
-  o4: { a: [0], b: [1, 1, 1], c: [4, 4, 4, 4, 4] },
-};
-
-describe('refineObservationsAttributesValues test', () => {
-  it('valid plus non existin value case', () => {
-    expect(
-      refineObservationsAttributesValues(attributesByIds)({ a: [0, 0, 0, 0, 0], b: [3, 3, 3, 3, 3, 3, 3] })
-    ).to.deep.equal({ a: { id: 'a', value: { id: 'a1' } } });
-  });
-  it('different indexes and no index case', () => {
-    expect(
-      refineObservationsAttributesValues(attributesByIds)({ a: [0, 0, 0, null], b: [] })
-    ).to.deep.equal({});
-  });
-  it('valids plus unknown atrtibute case', () => {
-    expect(
-      refineObservationsAttributesValues(attributesByIds)({ a: [0], b: [1, 1, 1], c: [4, 4, 4, 4, 4] })
-    ).to.deep.equal({ a: { id: 'a', value: { id: 'a1' } }, b: { id: 'b', value: { id: 'b2' } } });
-  });
-});

package/test/table-invert-time-perf.test.js

@@ -1,11 +0,0 @@
-import { expect } from 'chai';
-import { invertTime } from '../src/rules2/src/invertTime';
-import data from './mocks/table-invert-time--data.json';
-import inverted from './mocks/table-invert-time--inverted.json';
-
-describe('invertTime performace test', () => {
-  it('260 time period values and 2500 observations', function () {
-    this.timeout(3000);
-    expect(invertTime(data, true)).to.deep.equal(inverted);
-  });
-});

package/test/table-layout-perf.test.js

@@ -1,74 +0,0 @@
-import { expect } from 'chai';
-import { getSortedLayoutIndexes } from '../src/rules/src/table/factories/getSortedLayoutIndexes';
-import { refineLayoutSize } from '../src/rules/src/table/factories/refineLayoutSize';
-import { getLayoutData } from '../src/rules/src/table/factories/getLayoutData';
-import multiHierRowsLayout from './mocks/table-layout-multi-hierarchies--layout.json'
-import multiHierRowsObs from './mocks/table-layout-multi-hierarchies--observations.json'
-import multiHierRowsLayoutIndexes from './mocks/table-layout-multi-hierarchies--layoutIndexes.json'
-import multiHierRowsSizedIndexes from './mocks/table-layout-multi-hierarchies--sizedIndexes.json'
-import multiHierRowsLayoutData from './mocks/table-layout-multi-hierarchies--layoutData.json'
-import truncation1Layout from './mocks/table-layout-truncation1--layout.json'
-import truncation1Obs from './mocks/table-layout-truncation1--observations.json'
-import truncation1LayoutIndexes from './mocks/table-layout-truncation1--layoutIndexes.json'
-import truncation1SizedIndexes from './mocks/table-layout-truncation1--sizedIndexes.json'
-import truncation1LayoutData from './mocks/table-layout-truncation1--layoutData.json'
-import * as R from 'ramda';
-
-describe('table LayoutData performance tests', () => {
-  it('multi hierarchical rows getSortedLayoutIndexes test', function() {
-    this.timeout(2000);
-    expect(
-      getSortedLayoutIndexes(multiHierRowsLayout, multiHierRowsObs)
-    ).to.deep.equal(multiHierRowsLayoutIndexes);
-  });
-  it('multi hierarchical rows refineLayoutSize test', function() {
-    this.timeout(2000);
-    expect(
-      refineLayoutSize({ layout: multiHierRowsLayout, observations: multiHierRowsObs, limit: 3000 })(multiHierRowsLayoutIndexes)
-    ).to.deep.equal(multiHierRowsSizedIndexes);
-  });
-  it('multi hierarchical rows getLayoutData test', function() {
-    this.timeout(2000);
-    expect(
-      getLayoutData(multiHierRowsSizedIndexes, multiHierRowsLayout)
-    ).to.deep.equal(multiHierRowsLayoutData);
-  });
-  it('multi hierarchical rows test', function() {
-    this.timeout(2000);
-    expect(
-      R.pipe(
-        getSortedLayoutIndexes,
-        refineLayoutSize({ layout: multiHierRowsLayout, observations: multiHierRowsObs, limit: 3000 }),
-        indexes => getLayoutData(indexes, multiHierRowsLayout)
-      )(multiHierRowsLayout, multiHierRowsObs)
-    ).to.deep.equal(multiHierRowsLayoutData);
-  });
-  it('truncation1 getSortedLayoutIndexes test', function() {
-    this.timeout(2000);
-    expect(
-      getSortedLayoutIndexes(truncation1Layout, truncation1Obs)
-    ).to.deep.equal(truncation1LayoutIndexes);
-  });
-  it('truncation1 refineLayoutSize test', function() {
-    this.timeout(2000);
-    expect(
-      refineLayoutSize({ layout: truncation1Layout, observations: truncation1Obs, limit: 3000 })(truncation1LayoutIndexes)
-    ).to.deep.equal(truncation1SizedIndexes);
-  });
-  it('truncation1 getLayoutData test', function() {
-    this.timeout(2000);
-    expect(
-      getLayoutData(truncation1SizedIndexes, truncation1Layout)
-    ).to.deep.equal(truncation1LayoutData);
-  });
-  it('truncation1 test', function() {
-    this.timeout(2500);
-    expect(
-      R.pipe(
-        getSortedLayoutIndexes,
-        refineLayoutSize({ layout: truncation1Layout, observations: truncation1Obs, limit: 3000 }),
-        indexes => getLayoutData(indexes, truncation1Layout)
-      )(truncation1Layout, truncation1Obs)
-    ).to.deep.equal(truncation1LayoutData);
-  });
-});