@sis-cc/dotstatsuite-components 21.0.1 → 21.1.0

package/test/getAxisOptions.test.js

@@ -1,309 +0,0 @@
-import { expect } from 'chai';
-import * as R from 'ramda';
-import { getAxisOptions } from '../src/rules/src/chart/getAxisOptions';
-
-describe('getAxisOptions tests', () => {
-  it('blank test', () => {
-    expect(getAxisOptions(null, null, null)).to.deep.equal({
-      x: {
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0
-      },
-      y: {
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0
-      }
-    });
-  });
-  it('default bar options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions(null, 'BarChart', null))).to.deep.equal({
-      x: {
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0,
-        tick: { thickness: 0, size: 0 }
-      },
-      y: {
-        font: { baseline: 'ideographic' },
-        format: {},
-        linear: { pivot: { color: 'white', value: 0 } },
-        ordinal: { gap: .3, padding: .3 },
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      }
-    });
-  });
-  it('default bar procs options', () => {
-    const options = getAxisOptions(null, 'BarChart', null);
-    const xProc = R.path(['x', 'format', 'proc'], options);
-    const yProc = R.path(['y', 'format', 'proc'], options);
-    expect({ x: xProc('ordinal'), y: yProc(321.573) }).to.deep.equal({ x: 'ordinal', y: '321.57' });
-  });
-  it('default row options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions(null, 'RowChart', null))).to.deep.equal({
-      x: {
-        format: {},
-        linear: { pivot: { color: 'white', value: 0 } },
-        ordinal: { gap: .3, padding: .3 },
-        orient: 'top',
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      },
-      y: {
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3, minDisplaySize: 300 },
-        thickness: 0,
-        tick: { thickness: 0, size: 0 }
-      }
-    });
-  });
-  it('default row procs options', () => {
-    const options = getAxisOptions(null, 'RowChart', null);
-    const xProc = R.path(['x', 'format', 'proc'], options);
-    const yProc = R.path(['y', 'format', 'proc'], options);
-    expect({ y: yProc('ordinal'), x: xProc(321.573) }).to.deep.equal({ y: 'ordinal', x: '321.57' });
-  });
-  it('default scatter options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions(null, 'ScatterChart', null))).to.deep.equal({
-      x: {
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0,
-        tick: { thickness: 0, size: 0 }
-      },
-      y: {
-        font: { baseline: 'ideographic' },
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      }
-    });
-  });
-  it('default scatter procs options', () => {
-    const options = getAxisOptions(null, 'ScatterChart', null);
-    const xProc = R.path(['x', 'format', 'proc'], options);
-    const yProc = R.path(['y', 'format', 'proc'], options);
-    expect({ x: xProc(29.686), y: yProc(321.573) }).to.deep.equal({ x: '29.69', y: '321.57' });
-  });
-  it('default annual timeline options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions({ frequency: 'A' }, 'TimelineChart', null, null))).to.deep.equal({
-      x: {
-        format: { isTime: true, pattern: null },
-        linear: {
-          frequency: 'year',
-          step: 1,
-          pivot: { color: 'white' }
-        },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0,
-        tick: { size: -6, minorSize: -3, thickness: 2, minorThickness: 2, color: 'white', step: 1 }
-      },
-      y: {
-        font: { baseline: 'ideographic' },
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      }
-    });
-  });
-  it('default quarterly timeline options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions({ frequency: 'Q' }, 'TimelineChart', null, null))).to.deep.equal({
-      x: {
-        format: { isTime: true, pattern: null },
-        linear: {
-          frequency: 'month',
-          step: 3,
-          pivot: { color: 'white' }
-        },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0,
-        tick: { size: -6, minorSize: -3, thickness: 2, minorThickness: 2, color: 'white', step: 3 }
-      },
-      y: {
-        font: { baseline: 'ideographic' },
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      }
-    });
-  });
-  it('default monthly timeline options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions({ frequency: 'M' }, 'TimelineChart', null, null))).to.deep.equal({
-      x: {
-        format: { isTime: true, pattern: null },
-        linear: {
-          frequency: 'month',
-          step: 1,
-          pivot: { color: 'white' }
-        },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0,
-        tick: { size: -6, minorSize: -3, thickness: 2, minorThickness: 2, color: 'white', step: 1 }
-      },
-      y: {
-        font: { baseline: 'ideographic' },
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      }
-    });
-  });
-  it('default quarterly timeline procs options', () => {
-    const options = getAxisOptions({ frequency: 'Q' }, 'TimelineChart', null, null);
-    const xProc = R.path(['x', 'format', 'proc'], options);
-    const yProc = R.path(['y', 'format', 'proc'], options);
-    expect({ x: xProc(new Date(2021, 5, 1)), y: yProc(321.573) }).to.deep.equal({ x: '2021-Q2', y: '321.57' });
-  });
-  it('default horizontal symbol options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions(null, 'HorizontalSymbolChart', null))).to.deep.equal({
-      x: {
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        orient: 'top',
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      },
-      y: {
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3, minDisplaySize: 300 },
-        thickness: 0,
-        tick: { thickness: 0, size: 5 }
-      }
-    });
-  });
-  it('default horizontal symbol procs options', () => {
-    const options = getAxisOptions(null, 'HorizontalSymbolChart', null);
-    const xProc = R.path(['x', 'format', 'proc'], options);
-    const yProc = R.path(['y', 'format', 'proc'], options);
-    expect({ y: yProc('ordinal'), x: xProc(321.573) }).to.deep.equal({ y: 'ordinal', x: '321.57' });
-  });
-  it('default vertical symbol options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions(null, 'VerticalSymbolChart', null))).to.deep.equal({
-      x: {
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0,
-        tick: { thickness: 0, size: 0 }
-      },
-      y: {
-        font: { baseline: 'ideographic' },
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      }
-    });
-  });
-  it('default vertical symbol procs options', () => {
-    const options = getAxisOptions(null, 'VerticalSymbolChart', null);
-    const xProc = R.path(['x', 'format', 'proc'], options);
-    const yProc = R.path(['y', 'format', 'proc'], options);
-    expect({ x: xProc('ordinal'), y: yProc(321.573) }).to.deep.equal({ x: 'ordinal', y: '321.57' });
-  });
-  it('default stacked bar options', () => {
-    expect(
-      R.pipe(
-        R.dissocPath(['x', 'format', 'proc']),
-        R.dissocPath(['y', 'format', 'proc']),
-      )(getAxisOptions(null, 'StackedBarChart', null))).to.deep.equal({
-      x: {
-        format: {},
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0,
-        tick: { thickness: 0, size: 0 }
-      },
-      y: {
-        font: { baseline: 'ideographic' },
-        format: {},
-        linear: { pivot: { color: 'white', value: 0 } },
-        ordinal: { gap: .3, padding: .3 },
-        padding: 10,
-        thickness: 0,
-        tick: { thickness: 0 }
-      }
-    });
-  });
-  it('default stacked procs options', () => {
-    const options = getAxisOptions(null, 'StackedBarChart', null);
-    const xProc = R.path(['x', 'format', 'proc'], options);
-    const yProc = R.path(['y', 'format', 'proc'], options);
-    expect({ x: xProc('ordinal'), y: yProc(321.573) }).to.deep.equal({ x: 'ordinal', y: '321.57' });
-  });
-  it('customization test', () => {
-    expect(getAxisOptions(null, null, {
-      axis: {
-        x: { ordinal: { prop: 'test' }, thickness: 5 },
-        y: { linear: { pivot: { value: 10 } } }
-      }
-    })).to.deep.equal({
-      x: {
-        linear: { pivot: { color: 'white' } },
-        ordinal: { gap: .3, padding: .3, prop: 'test' },
-        thickness: 5
-      },
-      y: {
-        linear: { pivot: { color: 'white', value: 10 } },
-        ordinal: { gap: .3, padding: .3 },
-        thickness: 0
-      }
-    });
-  });
-});

package/test/getBaseOptions.test.js

@@ -1,77 +0,0 @@
-import { expect } from 'chai';
-import { getBaseOptions } from '../src/rules/src/chart/getBaseOptions';
-
-describe('getBaseOptions tests', () => {
-  it('blank test', () => {
-    expect(getBaseOptions(null, null)).to.deep.equal({});
-  });
-  it('default bar test', () => {
-    expect(getBaseOptions('BarChart', {})).to.deep.equal({
-      minDisplayWidth: 300,
-      minDisplayHeight: 100,
-      padding: { top: 20 },
-      innerPadding: { left: 20, right: 20, bottom: 10 }
-    });
-  });
-  it('default row test', () => {
-    expect(getBaseOptions('RowChart', {})).to.deep.equal({
-      minDisplayWidth: 100,
-      minDisplayHeight: 300,
-      padding: { top: 10, left: 10, right: 20 }
-    });
-  });
-  it('default scatter test', () => {
-    expect(getBaseOptions('ScatterChart', {})).to.deep.equal({
-      minDisplayWidth: 100,
-      minDisplayHeight: 100,
-      padding: { top: 40, right: 10 }
-    });
-  });
-  it('default timeline test', () => {
-    expect(getBaseOptions('TimelineChart', {})).to.deep.equal({
-      minDisplayWidth: 100,
-      minDisplayHeight: 300,
-      isAnnotated:false,
-      padding: { top: 20 },
-      innerPadding: { left: 40, right: 40 }
-    });
-  });
-  it('default horizontal symbol test', () => {
-    expect(getBaseOptions('HorizontalSymbolChart', {})).to.deep.equal({
-      minDisplayWidth: 100,
-      minDisplayHeight: 300,
-      padding: { top: 10, left: 10, right: 20 },
-    });
-  });
-  it('default vertical symbol test', () => {
-    expect(getBaseOptions('VerticalSymbolChart', {})).to.deep.equal({
-      minDisplayWidth: 300,
-      minDisplayHeight: 100,
-      padding: { top: 20 },
-      innerPadding: { left: 20, right: 20, bottom: 10 }
-    });
-  });
-  it('default stacked test', () => {
-    expect(getBaseOptions('StackedBarChart', {})).to.deep.equal({
-      minDisplayWidth: 300,
-      minDisplayHeight: 100,
-      padding: { top: 20 },
-      innerPadding: { left: 20, right: 20, bottom: 10 }
-    });
-  });
-  it('customization test', () => {
-    expect(getBaseOptions('StackedBarChart', {
-      base: {
-        minDisplayHeight: 300,
-        customOptions: { deep: 'test' },
-        innerPadding: { top: 15, left: 0 }
-      }
-    })).to.deep.equal({
-      customOptions: { deep: 'test' },
-      minDisplayWidth: 300,
-      minDisplayHeight: 300,
-      padding: { top: 20 },
-      innerPadding: { left: 0, right: 20, bottom: 10, top: 15 }
-    });
-  });
-});

package/test/getCellValue.test.js

@@ -1,32 +0,0 @@
-import { expect } from 'chai';
-import { getCellValue } from '../src/rules/src/table/factories/getCellValue';
-
-describe('getCellValue tests', () => {
-  it('simple muber test', () => {
-    expect(getCellValue({ value: 2 })).to.equal('2');
-  });
-  it('number -1 scale test', () => {
-    expect(getCellValue({ value: 8.3, prefscale: '-1' })).to.equal('83');
-  });
-  it('number 3 scale test', () => {
-    expect(getCellValue({ value: 25.62, prefscale: '3' })).to.equal('0.02562');
-  });
-  it('number 0 decimals test', () => {
-    expect(getCellValue({ value: 155062.56, decimals: '0' })).to.equal('155,063');
-  });
-  it('random string test', () => {
-    expect(getCellValue({ value: 'blablablablabalba' })).to.equal('blablablablabalba');
-  });
-  it('numerical string test', () => {
-    expect(getCellValue({ value: '654789', prefscale: '3', decimals: '1' })).to.equal('654789');
-  });
-  it('boolean test', () => {
-    expect(getCellValue({ value: true })).to.equal(true);
-  });
-  it('month test', () => {
-    expect(getCellValue({ value: '--06' })).to.equal('06');
-  });
-  it('monthDay test', () => {
-    expect(getCellValue({ value: '--12-31' })).to.equal('12-31');
-  });
-});

package/test/getCells.test.js

@@ -1,178 +0,0 @@
-import { expect } from 'chai';
-import { getCells } from '../src/rules2/src/';
-
-const customAttributes = {
-  flags: ['FL1', 'FL2'],
-  notes: ['FT1', 'FT2', 'FT3']
-};
-
-describe('getCells tests', () => {
-  it('flags', () => {
-    expect(
-      getCells(customAttributes, ['FL1', 'FL2', 'FT1', 'FT2', 'FT3'], [], {}, [])({
-        a: {
-          key: 'a',
-          value: 33,
-          formattedValue: '33',
-          attributes: {
-            FL1: { id: 'FL1', name: 'Flag 1', Value: null },
-            FL2: { id: 'FL2', name: 'Flag 2', value: { id: 'FL2.1', name: 'Flag 2 Value 1' } },
-            FT1: { id: 'FT1', name: 'Footnote 1', value: { id: 'FT1.1', name: 'Footnote 1 Value 1' } },
-            FT3: { id: 'FT3', name: 'Footnote 3', value: { id: 'FT3.3', name: 'Footnote 3 Value 3' } },
-          },
-          indexedDimValIds: {}
-        }
-    })).to.deep.equal({
-      a: {
-        key: 'a',
-        value: '33',
-        intValue: 33,
-        flags: [
-          { code: 'FL2.1', id: 'FL2', name: 'Flag 2', value: { id: 'FL2.1', name: 'Flag 2 Value 1' } },
-          { id: 'FT1', name: 'Footnote 1', value: { id: 'FT1.1', name: 'Footnote 1 Value 1' } },
-          { id: 'FT3', name: 'Footnote 3', value: { id: 'FT3.3', name: 'Footnote 3 Value 3' } }
-        ],
-        indexedDimValIds: {},
-        sideProps: null
-      }
-    })
-  });
-  it('combinations', () => {
-    const combinations = {
-      cells: [{ id: 'CELLS_COMB', concepts: ['D1', 'D2', 'A1', 'A4'], fixedDimValues: { D1: { id: 'D1V' } } }],
-      layout: [{ id: 'LAYOUT_COMB', concepts: ['D3', 'A2', 'A3'] }]
-    };
-
-    const attributesSeries = {
-      'D3=v0': { serieKey: 'D3=v0', A2: { value: 'A2V' } }
-    };
-
-    const cellsAttributesIds = ['FL1', 'FT1', 'A1'];
-
-    const observations = {
-      'obs': {
-        formattedValue: '33',
-        value: 33,
-        attributes: {
-          FL1: { id: 'FL1', value: { id: 'A' } },
-          FT1: { id: 'FT1', value: { id: 'V' } },
-          A1: { id: 'A1', value: { id: 'A1V' } },
-          A2: { id: 'A2', value: { id: 'A2V' }, serieKey: 'D3=v0' },
-          A3: { id: 'A3', value: { id: 'A3V' }, serieKey: 'D3=v0' },
-        }
-      }
-    };
-
-
-    expect(getCells(customAttributes, cellsAttributesIds, combinations, attributesSeries, [])(observations)).to.deep.equal({
-      'obs': {
-        value: '33',
-        intValue: 33,
-        sideProps: null,
-        flags: [
-          { code: 'A', id: 'FL1', value: { id: 'A' } }, // regular flag
-          { id: 'FT1', value: { id: 'V' } }, // regular foot note
-          { id: 'A3', value: { id: 'A3V' } }, // rejected layout combination value displayed as a footnote
-          { id: 'CELLS_COMB', values: [{ id: 'D1V' }, { id: 'A1V' }] } // cell level combination with fixed dim value
-        ]
-      }
-    });
-  });
-  it('duplication between notes and combinations definitions', () => {
-    const _customAttributes = {
-      flags: [],
-      notes: ['A1', 'A2']
-    };
-
-    const combinations = {
-      cells: [],
-      layout: [{ id: 'LAYOUT_COMB', concepts: ['D1', 'A1'] }]
-    };
-
-    const attributesSeries = { 'D1=V0': {} };
-
-    const cellsAttributesIds = ['A2'];
-
-    const observations = {
-      'obs': {
-        value: 'val',
-        formattedValue: 'val',
-        attributes: {
-          A1: { id: 'A1', value: { id: 'A1V' }, serieKey: 'D1=V0' },
-          A2: { id: 'A2', value: { id: 'A2V' } },
-        }
-      }
-    };
-    expect(getCells(_customAttributes, cellsAttributesIds, combinations, attributesSeries, [])(observations)).to.deep.equal({
-      'obs': {
-        value: 'val',
-        intValue: null,
-        sideProps: null,
-        flags: [
-          { id: 'A1', value: { id: 'A1V' } },
-          { id: 'A2', value: { id: 'A2V' } }
-        ]
-      }
-    });
-  });
-  it('metadata and OBS_ATTRIBUTES', () => {
-    const _customAttributes = {
-      flags: [],
-      notes: []
-    };
-
-    const combinations = {
-      cells: [],
-      layout: []
-    };
-
-    const observations = {
-      'a': {
-        value: 'val',
-        formattedValue: 'val',
-        attributes: {},
-        indexedDimValIds: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' }
-      },
-      'b': {
-        value: 'attr val',
-        formattedValue: 'attr val',
-        attributes: {},
-        indexedDimValIds: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'A' }
-      },
-      'c': {
-        value: 'val',
-        formattedValue: 'val',
-        attributes: { ADV_ATTR: { id: 'ADV_ATTR', value: { id: 'v' } } },
-        indexedDimValIds: { d0: 'v1', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' }
-      },
-    };
-    const metadataCoordinates = [{ d0: 'v0', d1: 'v0' }];
-    expect(getCells(_customAttributes, {}, combinations, {}, metadataCoordinates)(observations)).to.deep.equal({
-      'a': {
-        value: 'val',
-        intValue: null,
-        indexedDimValIds: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' },
-        sideProps: { advancedAttributes: {}, hasMetadata: true, coordinates: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' } },
-        flags: []
-      },
-      'b': {
-        value: 'attr val',
-        intValue: null,
-        indexedDimValIds: { d0: 'v0', d1: 'v0', OBS_ATTRIBUTES: 'A' },
-        sideProps: null,
-        flags: []
-      },
-      'c': {
-        value: 'val',
-        intValue: null,
-        indexedDimValIds: { d0: 'v1', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' },
-        flags: [],
-        sideProps: { 
-          advancedAttributes: { ADV_ATTR: { id: 'ADV_ATTR', value: { id: 'v' } } },
-          hasMetadata: false,
-          coordinates: { d0: 'v1', d1: 'v0', OBS_ATTRIBUTES: 'OBS_VALUE' }
-        },
-      },
-    });
-  });
-});

package/test/getCellsMetadataCoordinates.test.js

@@ -1,40 +0,0 @@
-import { expect } from 'chai';
-import { getCellsMetadataCoordinates } from '../src/rules2/src/';
-
-describe('getCellsMetadataCoordinates tests', () => {
-  it('basic tests', () => {
-    const oneValueDimensions = [
-      { id: 'HEADER1' },
-      { id: 'HEADER2' },
-    ];
-
-    const layoutIds = {
-      header: ['COLUMN1', 'COLUMN2'],
-      sections: ['SECTION1', 'SECTION2'],
-      rows: ['ROW1', 'ROW2'],
-    };
-
-    const coordinates = [
-      {},
-      { HEADER1: 'v' },
-      { HEADER1: 'v', HEADER2: 'v' },
-      { COLUMN1: 'v' },
-      { COLUMN1: 'v', COLUMN2: 'v' },
-      { HEADER1: 'v', COLUMN1: 'v', COLUMN2: 'v' },
-      { SECTION1: 'v' },
-      { SECTION1: 'v', SECTION2: 'v' },
-      { HEADER1: 'v', SECTION1: 'v', SECTION2: 'v' },
-      { ROW1: 'v' },
-      { ROW1: 'v', ROW2: 'v' },
-      { HEADER1: 'v', ROW1: 'v', ROW2: 'v' },
-      { HEADER1: 'v', SECTION1: 'v', SECTION2: 'v', ROW1: 'v', ROW2: 'v' },
-      { ROW1: 'v', HEADER2: 'v', COLUMN2: 'v' },
-      { SECTION1: 'v', ROW2: 'v', COLUMN1: 'v' }
-    ];
-
-    expect(getCellsMetadataCoordinates(coordinates, oneValueDimensions, layoutIds)).to.deep.equal([
-      { ROW1: 'v', HEADER2: 'v', COLUMN2: 'v' },
-      { SECTION1: 'v', ROW2: 'v', COLUMN1: 'v' }
-    ]);
-  });
-});