define([
|
'intern!tdd',
|
'intern/chai!assert',
|
'dojo/_base/declare',
|
'dgrid/Grid',
|
'dgrid/extensions/CompoundColumns'
|
], function (test, assert, declare, Grid, CompoundColumns) {
|
var CompoundColumnGrid = declare([Grid, CompoundColumns]),
|
data = [],
|
grid;
|
|
// Generate data to be used for all tests
|
for (var itemIndex = 0; itemIndex < 12; itemIndex++) {
|
var item = { id: itemIndex };
|
for (var propIndex = 0; propIndex < 10; propIndex++) {
|
item['data' + propIndex] = 'Value ' + itemIndex + ':' + propIndex;
|
}
|
data.push(item);
|
}
|
|
function createGrid(columns, hideHeader) {
|
grid = new CompoundColumnGrid({
|
columns: columns,
|
showHeader: !hideHeader
|
});
|
document.body.appendChild(grid.domNode);
|
grid.startup();
|
grid.renderArray(data);
|
}
|
|
test.suite('CompoundColumns', function () {
|
test.suite('cell method', function () {
|
test.afterEach(function () {
|
grid.destroy();
|
});
|
|
test.test('simple grid', function () {
|
createGrid({
|
data0: 'Data 0',
|
data1: 'Data 1',
|
data2: 'Data 2',
|
data3: 'Data 3',
|
data4: 'Data 4'
|
}, true);
|
|
assert.strictEqual(grid.cell(0, 0).element.innerHTML, 'Value 0:0');
|
assert.strictEqual(grid.cell(0, 4).element.innerHTML, 'Value 0:4');
|
assert.strictEqual(grid.cell(11, 0).element.innerHTML, 'Value 11:0');
|
assert.strictEqual(grid.cell(11, 4).element.innerHTML, 'Value 11:4');
|
assert.isUndefined(grid.cell(0, 5).element);
|
assert.isUndefined(grid.cell(12, 0).element);
|
});
|
|
test.test('simple grid with column ids', function () {
|
createGrid({
|
data0: { label: 'Data 0', id: 'myData0' },
|
data1: { label: 'Data 1', id: 'myData1' },
|
data2: { label: 'Data 2', id: 'myData2' },
|
data3: { label: 'Data 3', id: 'myData3' },
|
data4: { label: 'Data 4', id: 'myData4' }
|
}, true);
|
|
assert.strictEqual(grid.cell(0, 'myData0').element.innerHTML, 'Value 0:0');
|
assert.strictEqual(grid.cell(0, 'myData4').element.innerHTML, 'Value 0:4');
|
assert.strictEqual(grid.cell(11, 'myData0').element.innerHTML, 'Value 11:0');
|
assert.strictEqual(grid.cell(11, 'myData4').element.innerHTML, 'Value 11:4');
|
assert.isUndefined(grid.cell(0, 'myData5').element);
|
assert.isUndefined(grid.cell(12, 'myData0').element);
|
|
assert.isUndefined(grid.cell(0, 0).element);
|
});
|
|
test.test('grid with children', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
children: [
|
{ field: 'data1', label: 'Data 1' },
|
{ field: 'data2', label: 'Data 2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
children: [
|
{ field: 'data4', label: 'Data 4' },
|
{ field: 'data5', label: 'Data 5' }
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.cell(0, 0).element.innerHTML, 'Value 0:0');
|
assert.strictEqual(grid.cell(0, 1).element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 2).element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, 5).element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(11, 0).element.innerHTML, 'Value 11:0');
|
assert.strictEqual(grid.cell(11, 1).element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 2).element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, 5).element.innerHTML, 'Value 11:5');
|
|
assert.isUndefined(grid.cell(0, 6).element);
|
assert.isUndefined(grid.cell(12, 0).element);
|
});
|
|
test.test('grid with children and children ids', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{ field: 'data5', label: 'Data 5', id: 'myData5' }
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.cell(0, 0).element.innerHTML, 'Value 0:0');
|
assert.strictEqual(grid.cell(0, 3).element.innerHTML, 'Value 0:3');
|
assert.strictEqual(grid.cell(0, 'myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'myData2').element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, 'myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(11, 0).element.innerHTML, 'Value 11:0');
|
assert.strictEqual(grid.cell(11, 3).element.innerHTML, 'Value 11:3');
|
assert.strictEqual(grid.cell(11, 'myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'myData2').element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, 'myData5').element.innerHTML, 'Value 11:5');
|
|
assert.strictEqual(grid.cell(0, '0-1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, '0-1-myData2').element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, '0-4-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(11, '0-1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, '0-1-myData2').element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, '0-4-myData5').element.innerHTML, 'Value 11:5');
|
|
assert.strictEqual(grid.cell(0, '1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, '1-myData2').element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, '4-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(11, '1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, '1-myData2').element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, '4-myData5').element.innerHTML, 'Value 11:5');
|
});
|
|
test.test('grid with children and ids', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
id: 'compound1',
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
id: 'compound2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{ field: 'data5', label: 'Data 5', id: 'myData5' }
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.cell(0, 0).element.innerHTML, 'Value 0:0');
|
assert.strictEqual(grid.cell(0, 3).element.innerHTML, 'Value 0:3');
|
assert.strictEqual(grid.cell(0, 'myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'myData2').element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, 'myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(11, 0).element.innerHTML, 'Value 11:0');
|
assert.strictEqual(grid.cell(11, 3).element.innerHTML, 'Value 11:3');
|
assert.strictEqual(grid.cell(11, 'myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'myData2').element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, 'myData5').element.innerHTML, 'Value 11:5');
|
|
assert.strictEqual(grid.cell(0, 'compound1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'compound1-myData2').element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, 'compound2-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(11, 'compound1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'compound1-myData2').element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, 'compound2-myData5').element.innerHTML, 'Value 11:5');
|
});
|
|
test.test('grid with nested children and ids', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
id: 'compound1',
|
children: [
|
{
|
label: 'Nested Compound 1',
|
id: 'nested1',
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data9', label: 'Data 9', id: 'myData9' }
|
]
|
},
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
id: 'compound2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{
|
label: 'Nested Compound 2',
|
id: 'nested2',
|
children: [
|
{ field: 'data5', label: 'Data 5', id: 'myData5' },
|
{ field: 'data8', label: 'Data 8', id: 'myData8' }
|
]
|
}
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.cell(0, 'myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'myData2').element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, 'myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'myData4').element.innerHTML, 'Value 0:4');
|
assert.strictEqual(grid.cell(0, 'myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'myData2').element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, 'myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'myData4').element.innerHTML, 'Value 11:4');
|
assert.strictEqual(grid.cell(11, 'myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'myData8').element.innerHTML, 'Value 11:8');
|
|
assert.strictEqual(grid.cell(0, 'nested1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'nested1-myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'nested2-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'nested2-myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'nested1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'nested1-myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'nested2-myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'nested2-myData8').element.innerHTML, 'Value 11:8');
|
|
assert.strictEqual(grid.cell(0, 'compound1-nested1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'compound1-nested1-myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'compound2-nested2-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'compound2-nested2-myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'compound1-nested1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'compound1-nested1-myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'compound2-nested2-myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'compound2-nested2-myData8').element.innerHTML, 'Value 11:8');
|
});
|
|
test.test('grid with nested children and ids hiding all headers', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
id: 'compound1',
|
children: [
|
{
|
label: 'Nested Compound 1',
|
id: 'nested1',
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data9', label: 'Data 9', id: 'myData9' }
|
]
|
},
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
id: 'compound2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{
|
label: 'Nested Compound 2',
|
id: 'nested2',
|
children: [
|
{ field: 'data5', label: 'Data 5', id: 'myData5' },
|
{ field: 'data8', label: 'Data 8', id: 'myData8' }
|
]
|
}
|
]
|
}
|
], true);
|
|
assert.strictEqual(grid.cell(0, 'myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'myData2').element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, 'myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'myData4').element.innerHTML, 'Value 0:4');
|
assert.strictEqual(grid.cell(0, 'myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'myData2').element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, 'myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'myData4').element.innerHTML, 'Value 11:4');
|
assert.strictEqual(grid.cell(11, 'myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'myData8').element.innerHTML, 'Value 11:8');
|
|
assert.strictEqual(grid.cell(0, 'nested1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'nested1-myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'nested2-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'nested2-myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'nested1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'nested1-myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'nested2-myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'nested2-myData8').element.innerHTML, 'Value 11:8');
|
|
assert.strictEqual(grid.cell(0, 'compound1-nested1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'compound1-nested1-myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'compound2-nested2-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'compound2-nested2-myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'compound1-nested1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'compound1-nested1-myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'compound2-nested2-myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'compound2-nested2-myData8').element.innerHTML, 'Value 11:8');
|
});
|
|
test.test('grid with nested children and ids hiding child headers', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
id: 'compound1',
|
children: [
|
{
|
label: 'Nested Compound 1',
|
id: 'nested1',
|
showChildHeaders: false,
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data9', label: 'Data 9', id: 'myData9' }
|
]
|
},
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
id: 'compound2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{
|
label: 'Nested Compound 2',
|
id: 'nested2',
|
showChildHeaders: false,
|
children: [
|
{ field: 'data5', label: 'Data 5', id: 'myData5' },
|
{ field: 'data8', label: 'Data 8', id: 'myData8' }
|
]
|
}
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.cell(0, 'myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'myData2').element.innerHTML, 'Value 0:2');
|
assert.strictEqual(grid.cell(0, 'myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'myData4').element.innerHTML, 'Value 0:4');
|
assert.strictEqual(grid.cell(0, 'myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'myData2').element.innerHTML, 'Value 11:2');
|
assert.strictEqual(grid.cell(11, 'myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'myData4').element.innerHTML, 'Value 11:4');
|
assert.strictEqual(grid.cell(11, 'myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'myData8').element.innerHTML, 'Value 11:8');
|
|
assert.strictEqual(grid.cell(0, 'nested1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'nested1-myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'nested2-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'nested2-myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'nested1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'nested1-myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'nested2-myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'nested2-myData8').element.innerHTML, 'Value 11:8');
|
|
assert.strictEqual(grid.cell(0, 'compound1-nested1-myData1').element.innerHTML, 'Value 0:1');
|
assert.strictEqual(grid.cell(0, 'compound1-nested1-myData9').element.innerHTML, 'Value 0:9');
|
assert.strictEqual(grid.cell(0, 'compound2-nested2-myData5').element.innerHTML, 'Value 0:5');
|
assert.strictEqual(grid.cell(0, 'compound2-nested2-myData8').element.innerHTML, 'Value 0:8');
|
assert.strictEqual(grid.cell(11, 'compound1-nested1-myData1').element.innerHTML, 'Value 11:1');
|
assert.strictEqual(grid.cell(11, 'compound1-nested1-myData9').element.innerHTML, 'Value 11:9');
|
assert.strictEqual(grid.cell(11, 'compound2-nested2-myData5').element.innerHTML, 'Value 11:5');
|
assert.strictEqual(grid.cell(11, 'compound2-nested2-myData8').element.innerHTML, 'Value 11:8');
|
});
|
});
|
|
test.suite('column method', function () {
|
test.afterEach(function () {
|
grid.destroy();
|
});
|
|
test.test('simple grid', function () {
|
createGrid({
|
data0: 'Data 0',
|
data1: 'Data 1',
|
data2: 'Data 2',
|
data3: 'Data 3',
|
data4: 'Data 4'
|
}, true);
|
|
assert.strictEqual(grid.column(0).label, 'Data 0');
|
assert.strictEqual(grid.column(4).label, 'Data 4');
|
assert.isUndefined(grid.column(5));
|
});
|
|
test.test('simple grid with column ids', function () {
|
createGrid({
|
data0: { label: 'Data 0', id: 'myData0' },
|
data1: { label: 'Data 1', id: 'myData1' },
|
data2: { label: 'Data 2', id: 'myData2' },
|
data3: { label: 'Data 3', id: 'myData3' },
|
data4: { label: 'Data 4', id: 'myData4' }
|
}, true);
|
|
assert.strictEqual(grid.column('myData0').label, 'Data 0');
|
assert.strictEqual(grid.column('myData4').label, 'Data 4');
|
assert.isUndefined(grid.column('myData5'));
|
assert.isUndefined(grid.column(0));
|
});
|
|
test.test('grid with children', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
children: [
|
{ field: 'data1', label: 'Data 1' },
|
{ field: 'data2', label: 'Data 2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
children: [
|
{ field: 'data4', label: 'Data 4' },
|
{ field: 'data5', label: 'Data 5' }
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.column(0).label, 'Data 0');
|
assert.strictEqual(grid.column(1).label, 'Data 1');
|
assert.strictEqual(grid.column(2).label, 'Data 2');
|
assert.strictEqual(grid.column(5).label, 'Data 5');
|
assert.isUndefined(grid.column(6));
|
});
|
|
test.test('grid with children and children ids', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{ field: 'data5', label: 'Data 5', id: 'myData5' }
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.column(0).label, 'Data 0');
|
assert.strictEqual(grid.column(3).label, 'Data 3');
|
assert.strictEqual(grid.column('myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('myData2').label, 'Data 2');
|
assert.strictEqual(grid.column('myData5').label, 'Data 5');
|
|
assert.strictEqual(grid.column('0-1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('0-1-myData2').label, 'Data 2');
|
assert.strictEqual(grid.column('0-4-myData5').label, 'Data 5');
|
|
assert.strictEqual(grid.column('1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('1-myData2').label, 'Data 2');
|
assert.strictEqual(grid.column('4-myData5').label, 'Data 5');
|
});
|
|
test.test('grid with children and ids', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
id: 'compound1',
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
id: 'compound2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{ field: 'data5', label: 'Data 5', id: 'myData5' }
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.column(0).label, 'Data 0');
|
assert.strictEqual(grid.column(3).label, 'Data 3');
|
assert.strictEqual(grid.column('myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('myData2').label, 'Data 2');
|
assert.strictEqual(grid.column('myData5').label, 'Data 5');
|
|
assert.strictEqual(grid.column('compound1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('compound1-myData2').label, 'Data 2');
|
assert.strictEqual(grid.column('compound2-myData5').label, 'Data 5');
|
});
|
|
test.test('grid with nested children and ids', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
id: 'compound1',
|
children: [
|
{
|
label: 'Nested Compound 1',
|
id: 'nested1',
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data9', label: 'Data 9', id: 'myData9' }
|
]
|
},
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
id: 'compound2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{
|
label: 'Nested Compound 2',
|
id: 'nested2',
|
children: [
|
{ field: 'data5', label: 'Data 5', id: 'myData5' },
|
{ field: 'data8', label: 'Data 8', id: 'myData8' }
|
]
|
}
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.column('myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('myData2').label, 'Data 2');
|
assert.strictEqual(grid.column('myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('myData4').label, 'Data 4');
|
assert.strictEqual(grid.column('myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('myData8').label, 'Data 8');
|
|
assert.strictEqual(grid.column('nested1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('nested1-myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('nested2-myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('nested2-myData8').label, 'Data 8');
|
|
assert.strictEqual(grid.column('compound1-nested1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('compound1-nested1-myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('compound2-nested2-myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('compound2-nested2-myData8').label, 'Data 8');
|
});
|
|
test.test('grid with nested children and ids hiding all headers', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
id: 'compound1',
|
children: [
|
{
|
label: 'Nested Compound 1',
|
id: 'nested1',
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data9', label: 'Data 9', id: 'myData9' }
|
]
|
},
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
id: 'compound2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{
|
label: 'Nested Compound 2',
|
id: 'nested2',
|
children: [
|
{ field: 'data5', label: 'Data 5', id: 'myData5' },
|
{ field: 'data8', label: 'Data 8', id: 'myData8' }
|
]
|
}
|
]
|
}
|
], true);
|
|
assert.strictEqual(grid.column('myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('myData2').label, 'Data 2');
|
assert.strictEqual(grid.column('myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('myData4').label, 'Data 4');
|
assert.strictEqual(grid.column('myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('myData8').label, 'Data 8');
|
|
assert.strictEqual(grid.column('nested1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('nested1-myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('nested2-myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('nested2-myData8').label, 'Data 8');
|
|
assert.strictEqual(grid.column('compound1-nested1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('compound1-nested1-myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('compound2-nested2-myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('compound2-nested2-myData8').label, 'Data 8');
|
});
|
|
test.test('grid with nested children and ids hiding child headers', function () {
|
createGrid([
|
{ field: 'data0', label: 'Data 0' },
|
{
|
label: 'Compound 1',
|
id: 'compound1',
|
children: [
|
{
|
label: 'Nested Compound 1',
|
id: 'nested1',
|
showChildHeaders: false,
|
children: [
|
{ field: 'data1', label: 'Data 1', id: 'myData1' },
|
{ field: 'data9', label: 'Data 9', id: 'myData9' }
|
]
|
},
|
{ field: 'data2', label: 'Data 2', id: 'myData2' }
|
]
|
},
|
{ field: 'data3', label: 'Data 3' },
|
{
|
label: 'Compound 2',
|
id: 'compound2',
|
children: [
|
{ field: 'data4', label: 'Data 4', id: 'myData4' },
|
{
|
label: 'Nested Compound 2',
|
id: 'nested2',
|
showChildHeaders: false,
|
children: [
|
{ field: 'data5', label: 'Data 5', id: 'myData5' },
|
{ field: 'data8', label: 'Data 8', id: 'myData8' }
|
]
|
}
|
]
|
}
|
]);
|
|
assert.strictEqual(grid.column('myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('myData2').label, 'Data 2');
|
assert.strictEqual(grid.column('myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('myData4').label, 'Data 4');
|
assert.strictEqual(grid.column('myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('myData8').label, 'Data 8');
|
|
assert.strictEqual(grid.column('nested1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('nested1-myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('nested2-myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('nested2-myData8').label, 'Data 8');
|
|
assert.strictEqual(grid.column('compound1-nested1-myData1').label, 'Data 1');
|
assert.strictEqual(grid.column('compound1-nested1-myData9').label, 'Data 9');
|
assert.strictEqual(grid.column('compound2-nested2-myData5').label, 'Data 5');
|
assert.strictEqual(grid.column('compound2-nested2-myData8').label, 'Data 8');
|
});
|
});
|
|
test.suite('sort method', function () {
|
test.afterEach(function () {
|
grid.destroy();
|
});
|
|
test.test('sort grid programmatically by field present in header', function () {
|
createGrid({
|
data0: 'Data 0',
|
data1: 'Data 1',
|
data2: 'Data 2',
|
data3: 'Data 3',
|
data4: 'Data 4'
|
});
|
assert.doesNotThrow(function () {
|
grid.set('sort', 'data0');
|
}, null, 'Sorting grid programmatically should not throw error');
|
});
|
});
|
});
|
});
|
