define([
|
'intern!tdd',
|
'intern/chai!assert',
|
'dojo/_base/declare',
|
'dojo/aspect',
|
'dojo/on',
|
'dgrid/Grid',
|
'dgrid/OnDemandGrid',
|
'dgrid/extensions/Pagination',
|
'dgrid/extensions/SingleQuery',
|
'dgrid/test/data/errorStores',
|
'dgrid/test/data/createSyncStore',
|
'dgrid/test/data/createAsyncStore',
|
'dgrid/test/data/genericData',
|
'dgrid/test/data/testPerformanceStore',
|
'../addCss!'
|
], function (test, assert, declare, aspect, on, Grid, OnDemandGrid, Pagination, SingleQuery,
|
errorStores, createSyncStore, createAsyncStore, genericData, testPerformanceStore) {
|
|
var PaginationGrid = declare([ Grid, Pagination ]);
|
var SingleQueryGrid = declare([ Grid, SingleQuery ]);
|
|
var grid;
|
var handles = [];
|
|
// Common reusable function for tests
|
function storeTest(CustomGrid, store, expectSuccess, dfd) {
|
var expectedEvent = expectSuccess ? 'dgrid-refresh-complete' : 'dgrid-error',
|
unexpectedEvent = !expectSuccess ? 'dgrid-refresh-complete' : 'dgrid-error';
|
|
grid = new CustomGrid({
|
collection: store
|
});
|
|
// Hook up event handler before calling startup, to be able to
|
// test both synchronous and asynchronous stores
|
handles.push(on.once(grid, expectedEvent, function () {
|
// After receiving the expected event, perform a refresh,
|
// to also test resolution/rejection of the promise it returns.
|
grid.refresh().then(function () {
|
dfd[expectSuccess ? 'resolve' : 'reject']();
|
}, function () {
|
dfd[!expectSuccess ? 'resolve' : 'reject']();
|
});
|
}));
|
|
// Also hook up the opposite event handler, to signal failure
|
handles.push(on.once(grid, unexpectedEvent, function () {
|
dfd.reject(new Error('Expected ' + expectedEvent + ' to fire, but ' +
|
unexpectedEvent + ' fired instead.'));
|
}));
|
|
document.body.appendChild(grid.domNode);
|
grid.startup();
|
return dfd;
|
}
|
|
function createReleaseRangeGrid(CustomGrid) {
|
grid = new CustomGrid({
|
collection: testPerformanceStore,
|
columns: {
|
id: 'ID'
|
},
|
sort: 'id'
|
});
|
document.body.appendChild(grid.domNode);
|
grid.startup();
|
}
|
|
function testReleaseRange(visibleId) {
|
var numInserts = 0;
|
|
handles.push(aspect.after(grid, 'insertRow', function () {
|
numInserts++;
|
}, true));
|
|
testPerformanceStore.putSync(testPerformanceStore.getSync(0));
|
assert.strictEqual(numInserts, 0,
|
'Item from unrendered range should not be added to grid when updated');
|
testPerformanceStore.putSync(testPerformanceStore.getSync(visibleId || 14499));
|
assert.strictEqual(numInserts, 1,
|
'Item from rendered range should be re-added to grid when updated');
|
}
|
|
test.suite('stores', function () {
|
// Setup / teardown
|
test.afterEach(function () {
|
for (var i = handles.length; i--;) {
|
handles[i].remove();
|
}
|
handles = [];
|
grid.destroy();
|
});
|
|
var store = createSyncStore({ data: genericData }),
|
asyncStore = createAsyncStore({ data: genericData });
|
|
test.test('OnDemandGrid + sync store', function () {
|
storeTest(OnDemandGrid, store, true, this.async());
|
});
|
|
test.test('OnDemandGrid + async store', function () {
|
storeTest(OnDemandGrid, asyncStore, true, this.async());
|
});
|
|
test.test('OnDemandGrid + async store w/ error', function () {
|
storeTest(OnDemandGrid, errorStores.asyncFetch, false, this.async());
|
});
|
|
test.test('OnDemandGrid + async store w/ total error', function () {
|
storeTest(OnDemandGrid, errorStores.asyncFetchTotal, false, this.async());
|
});
|
|
test.test('OnDemandGrid observes/releases ranges appropriately', function () {
|
var dfd = this.async();
|
createReleaseRangeGrid(OnDemandGrid);
|
|
// Since _processScroll gets called on a debounce, need to wait for it
|
var handle = aspect.after(grid, '_processScroll', dfd.callback(function () {
|
handle.remove();
|
testReleaseRange();
|
}), true);
|
handles.push(handle);
|
|
grid.scrollTo({ y: grid.bodyNode.scrollHeight });
|
return dfd;
|
});
|
|
test.test('PaginationGrid + sync store', function () {
|
storeTest(PaginationGrid, store, true, this.async());
|
});
|
|
test.test('PaginationGrid + async store', function () {
|
storeTest(PaginationGrid, asyncStore, true, this.async());
|
});
|
|
test.test('PaginationGrid + async store w/ error', function () {
|
storeTest(PaginationGrid, errorStores.asyncFetch, false, this.async());
|
});
|
|
test.test('Pagination observes/releases ranges appropriately', function () {
|
createReleaseRangeGrid(PaginationGrid);
|
grid.gotoPage(2);
|
testReleaseRange(10);
|
});
|
|
test.test('SingleQueryGrid + sync store', function () {
|
storeTest(SingleQueryGrid, store, true, this.async());
|
});
|
|
test.test('SingleQueryGrid + async store', function () {
|
storeTest(SingleQueryGrid, asyncStore, true, this.async());
|
});
|
|
test.test('SingleQueryGrid + async store w/ error', function () {
|
storeTest(SingleQueryGrid, errorStores.asyncFetch, false, this.async());
|
});
|
});
|
|
test.suite('Async empty stores', function () {
|
test.afterEach(function () {
|
grid.destroy();
|
});
|
|
var emptyStore = createAsyncStore({ data: [] });
|
|
function createTest(Grid) {
|
return function () {
|
var dfd = this.async(1000);
|
grid = new Grid({
|
columns: {
|
id: 'ID'
|
},
|
collection: emptyStore
|
});
|
document.body.appendChild(grid.domNode);
|
grid.startup();
|
|
grid.on('dgrid-error', function () {
|
dfd.reject('dgrid-error should not be emitted on consecutive synchronous refresh');
|
});
|
|
grid.refresh().then(function () {
|
dfd.resolve();
|
});
|
};
|
}
|
|
test.test('OnDemandGrid consecutive refresh with async empty store (#1065)',
|
createTest(OnDemandGrid));
|
|
test.test('Pagination consecutive refresh with async empty store',
|
createTest(PaginationGrid));
|
|
test.test('SingleQuery consecutive refresh with async empty store',
|
createTest(SingleQueryGrid));
|
});
|
});
|
