602 lines
17 KiB
JavaScript
602 lines
17 KiB
JavaScript
/*
|
|
This file is part of Ext JS 3.4
|
|
|
|
Copyright (c) 2011-2013 Sencha Inc
|
|
|
|
Contact: http://www.sencha.com/contact
|
|
|
|
GNU General Public License Usage
|
|
This file may be used under the terms of the GNU General Public License version 3.0 as
|
|
published by the Free Software Foundation and appearing in the file LICENSE included in the
|
|
packaging of this file.
|
|
|
|
Please review the following information to ensure the GNU General Public License version 3.0
|
|
requirements will be met: http://www.gnu.org/copyleft/gpl.html.
|
|
|
|
If you are unsure which license is appropriate for your use, please contact the sales department
|
|
at http://www.sencha.com/contact.
|
|
|
|
Build date: 2013-04-03 15:07:25
|
|
*/
|
|
/**
|
|
* Tests Ext.data.Store functionality
|
|
* @author Ed Spencer
|
|
*/
|
|
(function() {
|
|
var suite = Ext.test.session.getSuite('Ext.data.Store'),
|
|
assert = Y.Assert;
|
|
|
|
//a shared setup function used by several of the suites
|
|
var defaultSetup = function() {
|
|
this.store = new Ext.data.Store({
|
|
proxy : new Ext.data.MemoryProxy({}),
|
|
reader: new Ext.data.ArrayReader({}, [
|
|
{name: 'name', type: 'string'},
|
|
{name: 'email', type: 'string'},
|
|
{name: 'greatness', type: 'int'},
|
|
{name: 'group', type: 'string'},
|
|
{name: 'old', type: 'boolean'}
|
|
]),
|
|
storeId: 'myStore',
|
|
remoteSort: false
|
|
});
|
|
|
|
this.store.loadData([
|
|
['Ed Spencer', 'ed@extjs.com', 100, 'code', false],
|
|
['Abe Elias', 'abe@extjs.com', 70, 'admin', false],
|
|
['Aaron Conran', 'aaron@extjs.com', 5, 'admin', true],
|
|
['Tommy Maintz', 'tommy@extjs.com', -15, 'code', true]
|
|
]);
|
|
};
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'local single sorting',
|
|
|
|
setUp: defaultSetup,
|
|
|
|
testSetDefaultSort: function() {
|
|
this.store.setDefaultSort('name', 'DESC');
|
|
|
|
var store = this.store,
|
|
sortInfo = store.sortInfo;
|
|
|
|
assert.areEqual('name', sortInfo.field);
|
|
assert.areEqual('DESC', sortInfo.direction);
|
|
assert.areEqual('DESC', store.sortToggle['name']);
|
|
},
|
|
|
|
testSetDefaultSortDefaultToASC: function() {
|
|
this.store.setDefaultSort('email');
|
|
|
|
var store = this.store,
|
|
sortInfo = store.sortInfo;
|
|
|
|
assert.areEqual('email', sortInfo.field);
|
|
assert.areEqual('ASC', sortInfo['direction']);
|
|
assert.areEqual('ASC', store.sortToggle['email']);
|
|
},
|
|
|
|
testSortByField: function() {
|
|
var store = this.store;
|
|
|
|
store.sort('name', 'ASC');
|
|
assert.areEqual('Aaron Conran', store.getAt(0).get('name'));
|
|
assert.areEqual('Abe Elias', store.getAt(1).get('name'));
|
|
assert.areEqual('Ed Spencer', store.getAt(2).get('name'));
|
|
assert.areEqual('Tommy Maintz', store.getAt(3).get('name'));
|
|
},
|
|
|
|
testToggling: function() {
|
|
var store = this.store;
|
|
|
|
store.sort('name', 'ASC');
|
|
|
|
//second call to sort toggles the direction
|
|
store.sort('name');
|
|
|
|
assert.areEqual('Aaron Conran', store.getAt(3).get('name'));
|
|
assert.areEqual('Abe Elias', store.getAt(2).get('name'));
|
|
assert.areEqual('Ed Spencer', store.getAt(1).get('name'));
|
|
assert.areEqual('Tommy Maintz', store.getAt(0).get('name'));
|
|
},
|
|
|
|
testSetsHasMultiSort: function() {
|
|
this.store.sort('name', 'ASC');
|
|
|
|
assert.isFalse(this.store.hasMultiSort);
|
|
},
|
|
|
|
testEventFired: function() {
|
|
var executed = false,
|
|
store = this.store;
|
|
|
|
store.on('datachanged', function() {
|
|
executed = true;
|
|
}, this);
|
|
|
|
store.sort('name');
|
|
assert.isTrue(executed);
|
|
},
|
|
|
|
testSavesSortInfo: function() {
|
|
var store = this.store;
|
|
|
|
store.sort('name', 'DESC');
|
|
|
|
assert.areEqual('name', store.sortInfo.field);
|
|
assert.areEqual('DESC', store.sortInfo.direction);
|
|
},
|
|
|
|
//if we tell store to sort on a non-existent field it should return false and do nothing
|
|
testInvalidFieldIgnored: function() {
|
|
var store = this.store;
|
|
|
|
//first we'll sort by name to give some reference sorting
|
|
store.sort('name', 'ASC');
|
|
|
|
assert.isFalse(store.sort('someUnknownField'));
|
|
|
|
//make sure the original sorting was preserved
|
|
assert.areEqual('Aaron Conran', store.getAt(0).get('name'));
|
|
assert.areEqual('Abe Elias', store.getAt(1).get('name'));
|
|
assert.areEqual('Ed Spencer', store.getAt(2).get('name'));
|
|
assert.areEqual('Tommy Maintz', store.getAt(3).get('name'));
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'local multiple sorting',
|
|
|
|
setUp: function() {
|
|
defaultSetup.call(this);
|
|
|
|
this.sorters = [
|
|
{
|
|
field : 'group',
|
|
direction: 'ASC'
|
|
},
|
|
{
|
|
field : 'old',
|
|
direction: 'DESC'
|
|
}
|
|
];
|
|
},
|
|
|
|
testSetsHasMultiSort: function() {
|
|
this.store.sort(this.sorters);
|
|
|
|
assert.isTrue(this.store.hasMultiSort);
|
|
},
|
|
|
|
testMultipleSorters: function() {
|
|
var store = this.store,
|
|
sorters = this.sorters;
|
|
|
|
store.sort(sorters);
|
|
|
|
assert.areEqual('Aaron Conran', store.getAt(0).get('name'));
|
|
assert.areEqual('Abe Elias', store.getAt(1).get('name'));
|
|
assert.areEqual('Tommy Maintz', store.getAt(2).get('name'));
|
|
assert.areEqual('Ed Spencer', store.getAt(3).get('name'));
|
|
}
|
|
|
|
// testMultipleSorterToggling: function() {
|
|
// var store = this.store,
|
|
// sorters = this.sorters;
|
|
//
|
|
// //first we'll sort to give some reference sorting
|
|
// store.sort(sorters, "ASC");
|
|
//
|
|
// //second call to sort toggles direction
|
|
// store.sort(sorters);
|
|
//
|
|
// assert.areEqual('Aaron Conran', store.getAt(3).get('name'));
|
|
// assert.areEqual('Abe Elias', store.getAt(2).get('name'));
|
|
// assert.areEqual('Tommy Maintz', store.getAt(1).get('name'));
|
|
// assert.areEqual('Ed Spencer', store.getAt(0).get('name'));
|
|
// }
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'single filtering',
|
|
|
|
setUp: defaultSetup,
|
|
|
|
testFilterByField: function() {
|
|
var store = this.store;
|
|
|
|
store.filter('group', 'code');
|
|
assert.areEqual(2, store.getCount());
|
|
},
|
|
|
|
testFilterByFieldAnyMatch: function() {
|
|
var store = this.store;
|
|
|
|
store.filter('email', 'extjs', true);
|
|
assert.areEqual(4, store.getCount());
|
|
},
|
|
|
|
testFilterByFieldCaseSensitive: function() {
|
|
var store = this.store;
|
|
|
|
store.filter('group', 'Code', false, true);
|
|
assert.areEqual(0, store.getCount());
|
|
},
|
|
|
|
testFilterByFieldExactMatch: function() {
|
|
var store = this.store;
|
|
|
|
store.filter('email', 'aaron', false, false, true);
|
|
assert.areEqual(0, store.getCount());
|
|
},
|
|
|
|
testClearFilter: function() {
|
|
var store = this.store,
|
|
executed = false;
|
|
|
|
store.on('datachanged', function() {
|
|
executed = true;
|
|
}, this);
|
|
|
|
store.filter('group', 'code');
|
|
assert.areEqual(2, store.getCount());
|
|
|
|
store.clearFilter();
|
|
assert.areEqual(4, store.getCount());
|
|
|
|
assert.isTrue(executed);
|
|
},
|
|
|
|
testSuppressClearFilterEvent: function() {
|
|
var store = this.store,
|
|
executed = false;
|
|
|
|
store.filter('group', 'email');
|
|
store.clearFilter(true);
|
|
|
|
store.on('datachanged', function() {
|
|
executed = true;
|
|
}, this);
|
|
assert.isFalse(executed);
|
|
},
|
|
|
|
testIsFiltered: function() {
|
|
var store = this.store;
|
|
|
|
assert.isFalse(store.isFiltered());
|
|
store.filter('group', 'code');
|
|
assert.isTrue(store.isFiltered());
|
|
},
|
|
|
|
testFilterByFunction: function() {
|
|
var store = this.store,
|
|
execScope,
|
|
executed;
|
|
|
|
store.on('datachanged', function() {
|
|
executed = true;
|
|
}, this);
|
|
|
|
var filterFn = function(item) {
|
|
execScope = this;
|
|
|
|
return item.get('greatness') > 50;
|
|
};
|
|
|
|
store.filterBy(filterFn, this);
|
|
assert.areEqual(this, execScope);
|
|
assert.areEqual(2, store.getCount());
|
|
assert.isTrue(executed);
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name : 'filtering more than once',
|
|
setUp: defaultSetup,
|
|
|
|
testFirstFilterIsCleared: function() {
|
|
var store = this.store;
|
|
|
|
store.filter('group', 'code');
|
|
assert.areEqual(2, store.getCount());
|
|
|
|
store.filter('old', false);
|
|
|
|
//if filter had not been reset first, count would be 1
|
|
assert.areEqual(2, store.getCount());
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name : 'multiple filters',
|
|
setUp: function() {
|
|
defaultSetup.call(this);
|
|
|
|
this.filters = [
|
|
{
|
|
property: 'group',
|
|
value : 'code'
|
|
},
|
|
{
|
|
property: 'old',
|
|
value : true
|
|
}
|
|
];
|
|
},
|
|
|
|
testMultipleBasicFilters: function() {
|
|
this.store.filter(this.filters);
|
|
|
|
//applying the filter set above shoule yield one result
|
|
assert.areEqual(1, this.store.getCount());
|
|
assert.areEqual('Tommy Maintz', this.store.data.first().get('name'));
|
|
},
|
|
|
|
testMultiFiltersFiresDataChanged: function() {
|
|
var executed = false;
|
|
|
|
this.store.on('datachanged', function() {
|
|
executed = true;
|
|
}, this);
|
|
|
|
this.store.filter(this.filters);
|
|
|
|
assert.isTrue(executed);
|
|
},
|
|
|
|
//tests that the anyMatch and caseSensitive defaults are correctly applied
|
|
testMultiFilterDefaults: function() {
|
|
//PENDING
|
|
},
|
|
|
|
//tests a single custom filter
|
|
testCustomFilter: function() {
|
|
var execScope;
|
|
|
|
//tests that the passed filter function is called
|
|
//tests that the filter is called in the right scope
|
|
this.store.filter({
|
|
fn: function(record) {
|
|
execScope = this;
|
|
return record.get('group') == 'admin' && record.get('old') === true;
|
|
},
|
|
scope: this
|
|
});
|
|
|
|
assert.areEqual(this, execScope);
|
|
assert.areEqual(1, this.store.getCount());
|
|
assert.areEqual('Aaron Conran', this.store.data.first().get('name'));
|
|
},
|
|
|
|
//tests multiple filters where we pass in custom matcher functions
|
|
testMultiCustomFilters: function() {
|
|
this.store.filter([
|
|
{
|
|
fn: function(record) {
|
|
return record.get('group') == 'admin';
|
|
}
|
|
},
|
|
{
|
|
fn: function(record) {
|
|
return record.get('old') === false;
|
|
}
|
|
}
|
|
]);
|
|
|
|
assert.areEqual(1, this.store.getCount());
|
|
assert.areEqual('Abe Elias', this.store.data.first().get('name'));
|
|
},
|
|
|
|
testBasicAndCustomFilters: function() {
|
|
//should return a single result - Ed Spencer
|
|
this.store.filter([
|
|
{
|
|
fn: function(record) {
|
|
return record.get('old') === false;
|
|
}
|
|
},
|
|
{
|
|
property: 'group',
|
|
value : 'code'
|
|
}
|
|
]);
|
|
|
|
assert.areEqual(1, this.store.getCount());
|
|
assert.areEqual('Ed Spencer', this.store.data.first().get('name'));
|
|
},
|
|
|
|
testClearMultipleFilters: function() {
|
|
this.store.filter(this.filters);
|
|
assert.areEqual(1, this.store.getCount());
|
|
|
|
//make sure that clearing multiple filters is still correct
|
|
this.store.clearFilter();
|
|
assert.areEqual(4, this.store.getCount());
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'inserting and removing',
|
|
|
|
testInsert: function() {
|
|
//PENDING
|
|
},
|
|
|
|
testInsertFiresAddEvent: function() {
|
|
//PENDING
|
|
},
|
|
|
|
testRemove: function() {
|
|
//PENDING
|
|
},
|
|
|
|
testRemoveAll: function() {
|
|
//PENDING
|
|
},
|
|
|
|
testRemoveAt: function() {
|
|
//PENDING
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'destroying',
|
|
|
|
setUp: defaultSetup,
|
|
|
|
//we hijack Ext.StoreMgr.unregister temporarily and then set it back in this test case
|
|
testUnregistersFromStore: function() {
|
|
var executed = false,
|
|
arg = undefined,
|
|
unregister = Ext.StoreMgr.unregister;
|
|
|
|
Ext.StoreMgr.unregister = function(store) {
|
|
executed = true;
|
|
arg = store;
|
|
};
|
|
|
|
this.store.destroy();
|
|
|
|
assert.isTrue(executed);
|
|
assert.areEqual(this.store, arg);
|
|
|
|
Ext.StoreMgr.unregister = unregister;
|
|
},
|
|
|
|
testClearsData: function() {
|
|
var executed = false;
|
|
this.store.clearData = function() {
|
|
executed = true;
|
|
};
|
|
|
|
this.store.destroy();
|
|
assert.isTrue(executed);
|
|
},
|
|
|
|
testDestroysProxy: function() {
|
|
var executed = false,
|
|
arg = undefined,
|
|
proxy = this.store.proxy,
|
|
destroy = Ext.destroy;
|
|
|
|
Ext.destroy = function(store) {
|
|
executed = true;
|
|
arg = store;
|
|
};
|
|
|
|
this.store.destroy();
|
|
|
|
assert.isTrue(executed);
|
|
assert.areEqual(proxy, arg);
|
|
|
|
Ext.destroy = destroy;
|
|
},
|
|
|
|
testUnsetsReferences: function() {
|
|
this.store.destroy();
|
|
|
|
assert.isNull(this.store.reader);
|
|
assert.isNull(this.store.writer);
|
|
assert.isNull(this.store.data);
|
|
},
|
|
|
|
testIsDestroyed: function() {
|
|
assert.isFalse(this.store.isDestroyed);
|
|
|
|
this.store.destroy();
|
|
|
|
assert.isTrue(this.store.isDestroyed);
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'counting and iterators',
|
|
|
|
setUp: defaultSetup,
|
|
|
|
testGetCount: function() {
|
|
assert.areEqual(4, this.store.getCount());
|
|
},
|
|
|
|
testGetTotalCount: function() {
|
|
//PENDING - need a fake remote data set test with paging
|
|
},
|
|
|
|
testEach: function() {
|
|
var count = 0,
|
|
callScope;
|
|
|
|
this.store.each(function() {
|
|
callScope = this;
|
|
count ++;
|
|
}, this);
|
|
|
|
assert.areEqual(4, count);
|
|
assert.areEqual(this, callScope);
|
|
},
|
|
|
|
testSum: function() {
|
|
var sum = this.store.sum('greatness');
|
|
|
|
assert.areEqual(160, sum);
|
|
},
|
|
|
|
testSumWithStartAndEnd: function() {
|
|
var sum = this.store.sum('greatness', 1, 3);
|
|
|
|
assert.areEqual(60, sum);
|
|
},
|
|
|
|
//a normal collect test - check that we're pulling the right values out of the store
|
|
testCollect: function() {
|
|
var values = this.store.collect('name');
|
|
|
|
assert.areEqual(4, values.length);
|
|
assert.areNotEqual(-1, values.indexOf("Ed Spencer"));
|
|
assert.areNotEqual(-1, values.indexOf("Abe Elias"));
|
|
assert.areNotEqual(-1, values.indexOf("Aaron Conran"));
|
|
assert.areNotEqual(-1, values.indexOf("Tommy Maintz"));
|
|
},
|
|
|
|
//checks that all collected values are unique
|
|
testCollectIsUnique: function() {
|
|
var values = this.store.collect('group');
|
|
|
|
assert.areEqual(2, values.length);
|
|
assert.areNotEqual(-1, values.indexOf("code"));
|
|
assert.areNotEqual(-1, values.indexOf("admin"));
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'committing',
|
|
|
|
testCommitChanges: function() {
|
|
//PENDING
|
|
},
|
|
|
|
testRejectChanges: function() {
|
|
//PENDING
|
|
},
|
|
|
|
testAfterCommit: function() {
|
|
//PENDING
|
|
},
|
|
|
|
testAfterReject: function() {
|
|
//PENDING
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'modified',
|
|
|
|
testGetModifiedRecords: function() {
|
|
//PENDING
|
|
}
|
|
}));
|
|
|
|
suite.add(new Y.Test.Case({
|
|
name: 'loading'
|
|
}));
|
|
})();
|