test/unit/data/GroupingStore.js

   1 /*!
   2  * Ext JS Library 3.2.1
   3  * Copyright(c) 2006-2010 Ext JS, Inc.
   4  * licensing@extjs.com
   5  * http://www.extjs.com/license
   6  */
   7 /**
   8  * Tests Ext.data.Store functionality
   9  * @author Ed Spencer
  10  */
  11 (function() {
  12     var suite  = Ext.test.session.getSuite('Ext.data.GroupingStore'),
  13         assert = Y.Assert;
  14
  15     //a shared setup function used by several of the suites
  16     var defaultSetup = function(config) {
  17         config = config || {};
  18
  19         Ext.applyIf(config, {
  20             proxy : new Ext.data.MemoryProxy({}),
  21             reader: new Ext.data.ArrayReader({}, [
  22                 {name: 'name',      type: 'string'},
  23                 {name: 'email',     type: 'string'},
  24                 {name: 'greatness', type: 'int'},
  25                 {name: 'group',     type: 'string'},
  26                 {name: 'old',       type: 'boolean'}
  27             ]),
  28             storeId: 'myStore',
  29             remoteSort : false,
  30             remoteGroup: false,
  31             groupField : 'group',
  32
  33             sortInfo: {field: 'name', direction: 'ASC'}
  34         });
  35
  36         var store = new Ext.data.GroupingStore(config);
  37
  38         store.loadData([
  39             ['Ed Spencer',   'ed@extjs.com',    100, 'code',  false],
  40             ['Abe Elias',    'abe@extjs.com',   70,  'admin', false],
  41             ['Aaron Conran', 'aaron@extjs.com', 5,   'admin', true],
  42             ['Tommy Maintz', 'tommy@extjs.com', -15, 'code',  true]
  43         ]);
  44
  45         return store;
  46     };
  47
  48     suite.add(new Y.Test.Case({
  49         name: 'constructor',
  50
  51         testAppliesGroupField: function() {
  52             var GroupingStore = Ext.data.GroupingStore,
  53                 proto         = GroupingStore.prototype,
  54                 oldFunc       = proto.applyGroupField,
  55                 wasCalled     = false;
  56
  57             proto.applyGroupField = function() {
  58                 wasCalled = true;
  59             };
  60
  61             var store = new GroupingStore();
  62             assert.isTrue(wasCalled);
  63
  64             proto.applyGroupField = oldFunc;
  65         }
  66     }));
  67
  68     suite.add(new Y.Test.Case({
  69         name: 'clear grouping',
  70
  71         testUnsetsGroupField: function() {
  72             var store = defaultSetup();
  73             store.groupField = 'abc';
  74
  75             store.clearGrouping();
  76             assert.isFalse(store.groupField);
  77         },
  78
  79         testLocalGroupingAppliesSort: function() {
  80             var GroupingStore = Ext.data.GroupingStore,
  81                 proto         = GroupingStore.prototype,
  82                 oldFunc       = proto.sort,
  83                 wasCalled     = false;
  84
  85             proto.sort = function() {
  86                 wasCalled = true;
  87             };
  88
  89             var store = defaultSetup({remoteGroup: false});
  90             store.clearGrouping();
  91
  92             assert.isTrue(wasCalled);
  93
  94             proto.sort = oldFunc;
  95         },
  96
  97         testLocalGroupingFiresEvent: function() {
  98             var store = defaultSetup({remoteGroup: false}),
  99                 fired = false;
 100
 101             store.on('datachanged', function() {
 102                 fired = true;
 103             }, this);
 104
 105             store.clearGrouping();
 106             assert.isTrue(fired);
 107         },
 108
 109         testRemoteGroupingReloads: function() {
 110             var GroupingStore = Ext.data.GroupingStore,
 111                 proto         = GroupingStore.prototype,
 112                 oldFunc       = proto.reload,
 113                 wasCalled     = false;
 114
 115             proto.reload = function() {
 116                 wasCalled = true;
 117             };
 118
 119             var store = defaultSetup({remoteGroup: true});
 120             store.clearGrouping();
 121
 122             assert.isTrue(wasCalled);
 123
 124             proto.reload = oldFunc;
 125         },
 126
 127         testRemoteGroupingDeletesBaseParams: function() {
 128             var store = defaultSetup({remoteGroup: true});
 129
 130             //these params should be deleted
 131             Ext.apply(store.baseParams, {
 132                 groupBy : 'abc',
 133                 groupDir: 'ASC'
 134             });
 135
 136             store.clearGrouping();
 137
 138             assert.isUndefined(store.baseParams.groupBy);
 139             assert.isUndefined(store.baseParams.groupDir);
 140         },
 141
 142         testRemoteGroupingDeletesLastOptions: function() {
 143             var store = defaultSetup({remoteGroup: true});
 144
 145             //these params should be deleted
 146             store.lastOptions        = store.lastOptions        || {};
 147             store.lastOptions.params = store.lastOptions.params || {};
 148
 149             Ext.apply(store.lastOptions.params, {
 150                 groupBy : 'abc',
 151                 groupDir: 'ASC'
 152             });
 153
 154             store.clearGrouping();
 155
 156             assert.isUndefined(store.lastOptions.params.groupBy);
 157             assert.isUndefined(store.lastOptions.params.groupDir);
 158         }
 159     }));
 160
 161     suite.add(new Y.Test.Case({
 162         name: 'group by',
 163
 164         testForceRegroup: function() {
 165             var GroupingStore = Ext.data.GroupingStore,
 166                 proto         = GroupingStore.prototype,
 167                 oldFunc       = proto.applyGroupField,
 168                 callCount     = 0;
 169
 170             proto.applyGroupField = function() {
 171                 callCount++;
 172             };
 173
 174             var store = defaultSetup({sortInfo: {field: 'name', direction: 'ASC'}});
 175             store.groupBy('name', 'DESC');
 176
 177             var currentCallCount = callCount;
 178
 179             //this should activate another group operation
 180             store.groupBy('name', 'DESC', true);
 181
 182             //cleanup
 183             proto.applyGroupField = oldFunc;
 184
 185             assert.areEqual(currentCallCount + 1, callCount);
 186         },
 187
 188         //if we already group by this field and direction, it should not group again
 189         testNoForceRegroup: function() {
 190             var GroupingStore = Ext.data.GroupingStore,
 191                 proto         = GroupingStore.prototype,
 192                 oldFunc       = proto.applyGroupField,
 193                 callCount     = 0;
 194
 195             proto.applyGroupField = function() {
 196                 callCount++;
 197             };
 198
 199             var store = defaultSetup({sortInfo: {field: 'name', direction: 'ASC'}});
 200             store.groupBy('name');
 201
 202             var currentCallCount = callCount;
 203
 204             //this should not activate another group operation
 205             store.groupBy('name');
 206
 207             //cleanup
 208             proto.applyGroupField = oldFunc;
 209
 210             assert.areEqual(currentCallCount, callCount);
 211         },
 212
 213         testSetsGroupDir: function() {
 214             var store = defaultSetup({sortInfo: {field: 'name', direction: 'ASC'}});
 215             store.groupBy('name');
 216
 217             assert.areEqual('name', store.groupField);
 218         },
 219
 220         testSetsGroupField: function() {
 221             var store = defaultSetup({sortInfo: {field: 'name', direction: 'ASC'}});
 222             store.groupBy('name', false, 'DESC');
 223
 224             assert.areEqual('DESC', store.groupDir);
 225         },
 226
 227         testAppliesGroupField: function() {
 228             var GroupingStore = Ext.data.GroupingStore,
 229                 proto         = GroupingStore.prototype,
 230                 oldFunc       = proto.applyGroupField,
 231                 wasCalled     = false;
 232
 233             proto.applyGroupField = function() {
 234                 wasCalled = true;
 235             };
 236
 237             var store = defaultSetup({sortInfo: {field: 'name', direction: 'ASC'}});
 238             store.groupBy('name');
 239
 240             //cleanup
 241             proto.applyGroupField = oldFunc;
 242
 243             assert.isTrue(wasCalled);
 244         },
 245
 246         testReloadsIfRemote: function() {
 247             var fired = false;
 248             var store = defaultSetup({
 249                 remoteGroup: true,
 250                 sortInfo   : {field: 'name', direction: 'ASC'}
 251             });
 252
 253             //fake a remote load
 254             store.load = function() {
 255                 fired = true;
 256             };
 257
 258             store.groupBy('name');
 259
 260             assert.isTrue(fired);
 261         },
 262
 263         testFiresDatachangedIfLocal: function() {
 264             var fired = false,
 265                 store = defaultSetup({remoteGroup: false, sortInfo: {field: 'name', direction: 'ASC'}});
 266
 267             store.on('datachanged', function() {
 268                 fired = true;
 269             }, this);
 270
 271             store.groupBy('name');
 272
 273             assert.isTrue(fired);
 274         },
 275
 276         testFiresGroupchangeIfLocal: function() {
 277             var fired = false,
 278                 store = defaultSetup({remoteGroup: false, sortInfo: {field: 'name', direction: 'ASC'}});
 279
 280             store.on('groupchange', function() {
 281                 fired = true;
 282             }, this);
 283
 284             store.groupBy('name');
 285
 286             assert.isTrue(fired);
 287         },
 288
 289         testFiresGroupchangeIfRemote: function() {
 290             var fired = false;
 291             var store = defaultSetup({
 292                 remoteGroup: true,
 293                 sortInfo   : {field: 'name', direction: 'ASC'}
 294             });
 295
 296             //fake a remote load
 297             store.load = function() {
 298                 store.fireEvent('load', store);
 299             };
 300
 301             store.on('groupchange', function() {
 302                 fired = true;
 303             }, this);
 304
 305             store.groupBy('name');
 306
 307             assert.isTrue(fired);
 308         },
 309
 310         testGroupOnSort: function() {
 311
 312         }
 313     }));
 314
 315     suite.add(new Y.Test.Case({
 316         name: 'apply group field',
 317
 318         setUp: function() {
 319             this.store = defaultSetup({
 320                 remoteGroup: true
 321             });
 322
 323             this.store.groupField  = 'abc';
 324             this.store.groupDir    = 'DESC';
 325             this.store.lastOptions = {params: {}};
 326         },
 327
 328         testSetsBaseParams: function() {
 329             this.store.applyGroupField();
 330
 331             assert.areEqual('abc',  this.store.baseParams.groupBy);
 332             assert.areEqual('DESC', this.store.baseParams.groupDir);
 333         },
 334
 335         testSetsLastOptionsGroupDir: function() {
 336             this.store.applyGroupField();
 337
 338             assert.areEqual('DESC', this.store.lastOptions.params.groupDir);
 339         },
 340
 341         testDeletesLastOptionsGroupBy: function() {
 342             this.store.applyGroupField();
 343
 344             assert.isUndefined(this.store.lastOptions.params.groupBy);
 345         }
 346     }));
 347
 348     suite.add(new Y.Test.Case({
 349         name: 'apply sort'
 350     }));
 351
 352     suite.add(new Y.Test.Case({
 353         name: 'apply grouping'
 354     }));
 355
 356     //not really sure what this function does or why it does it. These tests just ensure
 357     //that any refactoring does not break it
 358     suite.add(new Y.Test.Case({
 359         name: 'get group state',
 360
 361         testReturnsGroupField: function() {
 362             var store = defaultSetup();
 363             store.groupField = 'abc';
 364
 365             assert.areEqual('abc', store.getGroupState());
 366         },
 367
 368         //if only sorting is on sortinfo
 369         testReturnsSortInfoField: function() {
 370             var store = defaultSetup({groupOnSort: true});
 371             store.groupField = 'abc';
 372             store.sortInfo   = {field: 'def'};
 373
 374             assert.areEqual('def', store.getGroupState());
 375         },
 376
 377         //if no sorting is applied anywhere
 378         testReturnsUndefined: function() {
 379             var store = defaultSetup({groupOnSort: true});
 380             store.groupField = 'abc';
 381             store.sortInfo   = {};
 382
 383             assert.isUndefined(store.getGroupState());
 384         }
 385     }));
 386 })();