git.pond.sub.org Git - eow/blob - static/dojo-release-1.1.1/dojo/tests/data/readOnlyItemFileTestTemplates.js

   1 if(!dojo._hasResource["tests.data.readOnlyItemFileTestTemplates"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
   2 dojo._hasResource["tests.data.readOnlyItemFileTestTemplates"] = true;
   3 dojo.provide("tests.data.readOnlyItemFileTestTemplates");
   4 dojo.require("dojo.data.api.Read");
   5 dojo.require("dojo.data.api.Identity");
   6 dojo.require("dojo.date");
   7 dojo.require("dojo.date.stamp");
   8
   9
  10 tests.data.readOnlyItemFileTestTemplates.registerTestsForDatastore = function(/* String */ datastoreClassName){
  11         // summary:
  12         //              Given the name of a datastore class to use, this function creates
  13         //              a set of unit tests for that datastore, and registers the new test
  14         //              group with the doh test framework.  The new unit tests are based
  15         //              on a set of "template" unit tests.
  16         var datastoreClass = dojo.getObject(datastoreClassName);
  17         var testTemplates = tests.data.readOnlyItemFileTestTemplates.testTemplates;
  18         var testsForDatastore = [];
  19         var makeNewTestFunction = function(template){
  20                 return function(t){return template.runTest(datastoreClass, t);};
  21         };
  22         for(var i = 0; i < testTemplates.length; ++i) {
  23                 var testTemplate = testTemplates[i];
  24                 var test = {};
  25                 test.name = testTemplate.name;
  26                 test.runTest = makeNewTestFunction(testTemplate);
  27                 testsForDatastore.push(test);
  28         }
  29         var testGroupName = "tests.data.readOnlyItemFileTestTemplates, with datastore " + datastoreClassName;
  30         doh.register(testGroupName, testsForDatastore);
  31 };
  32
  33
  34 //-----------------------------------------------------
  35 // testFile data-sets
  36 tests.data.readOnlyItemFileTestTemplates.getTestData = function(name){
  37         var data = null;
  38         if(name === "countries"){
  39                 if(dojo.isBrowser){
  40                         data = {url: dojo.moduleUrl("tests", "data/countries.json").toString() };
  41                 }else{
  42                         data = {data: {
  43                                 identifier:"abbr",
  44                                 label:"name",
  45                                 items:[
  46                                         {abbr:"ec", name:"Ecuador", capital:"Quito"},
  47                                         {abbr:'eg', name:'Egypt', capital:'Cairo'},
  48                                         {abbr:'sv', name:'El Salvador', capital:'San Salvador'},
  49                                         {abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
  50                                         {abbr:'er', name:'Eritrea', capital:'Asmara'},
  51                                         {abbr:'ee', name:'Estonia', capital:'Tallinn'},
  52                                         {abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
  53                                 ]
  54                         } };
  55                 }
  56         }else if(name === "countries_withNull"){
  57                 if(dojo.isBrowser){
  58                         data = {url: dojo.moduleUrl("tests", "data/countries_withNull.json").toString() };
  59                 }else{
  60                         data = {data: {
  61                                 identifier:"abbr",
  62                                 items:[
  63                                         {abbr:"ec", name:null, capital:"Quito"},
  64                                         {abbr:'eg', name:null, capital:'Cairo'},
  65                                         {abbr:'sv', name:'El Salvador', capital:'San Salvador'},
  66                                         {abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
  67                                         {abbr:'er', name:'Eritrea', capital:'Asmara'},
  68                                         {abbr:'ee', name:null, capital:'Tallinn'},
  69                                         {abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
  70                                 ]
  71                         } };
  72                 }
  73         }else if(name === "countries_withoutid"){
  74                 if(dojo.isBrowser){
  75                         data = {url: dojo.moduleUrl("tests", "data/countries_withoutid.json").toString() };
  76                 }else{
  77                         data = {data: {
  78                                 label: "name",
  79                                 items:[
  80                                         {abbr:"ec", name:null, capital:"Quito"},
  81                                         {abbr:'eg', name:null, capital:'Cairo'},
  82                                         {abbr:'sv', name:'El Salvador', capital:'San Salvador'},
  83                                         {abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
  84                                         {abbr:'er', name:'Eritrea', capital:'Asmara'},
  85                                         {abbr:'ee', name:null, capital:'Tallinn'},
  86                                         {abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
  87                                 ]
  88                         } };
  89                 }
  90         }else if (name === "countries_withBoolean"){
  91                 if(dojo.isBrowser){
  92                         data = {url: dojo.moduleUrl("tests", "data/countries_withBoolean.json").toString() };
  93                 }else{
  94                         data = {data: {
  95                                 identifier:"abbr",
  96                                 items:[
  97                                         {abbr:"ec", name:"Ecuador", capital:"Quito", real:true},
  98                                         {abbr:'eg', name:'Egypt', capital:'Cairo', real:true},
  99                                         {abbr:'sv', name:'El Salvador', capital:'San Salvador', real:true},
 100                                         {abbr:'gq', name:'Equatorial Guinea', capital:'Malabo', real:true},
 101                                         {abbr:'er', name:'Eritrea', capital:'Asmara', real:true},
 102                                         {abbr:'ee', name:'Estonia', capital:'Tallinn', real:true},
 103                                         {abbr:'et', name:'Ethiopia', capital:'Addis Ababa', real:true},
 104                                         {abbr:'ut', name:'Utopia', capital:'Paradise', real:false}
 105                                 ]
 106                         } };
 107                 }
 108         }else if (name === "countries_withDates"){
 109                 if(dojo.isBrowser){
 110                         data = {url: dojo.moduleUrl("tests", "data/countries_withDates.json").toString() };
 111                 }else{
 112                         data = {data: {
 113                                 identifier:"abbr",
 114                                 items:[
 115                                         {abbr:"ec", name:"Ecuador", capital:"Quito"},
 116                                         {abbr:'eg', name:'Egypt', capital:'Cairo'},
 117                                         {abbr:'sv', name:'El Salvador', capital:'San Salvador'},
 118                                         {abbr:'gq', name:'Equatorial Guinea', capital:'Malabo'},
 119                                         {abbr:'er', name:'Eritrea', capital:'Asmara', independence:{_type:'Date', _value:"1993-05-24T00:00:00Z"}}, // May 24, 1993,
 120                                         {abbr:'ee', name:'Estonia', capital:'Tallinn', independence:{_type:'Date', _value:"1991-08-20T00:00:00Z"}}, // August 20, 1991
 121                                         {abbr:'et', name:'Ethiopia', capital:'Addis Ababa'}
 122                                 ]
 123                         } };
 124                 }
 125         }else if (name === "geography_hierarchy_small"){
 126                 if(dojo.isBrowser){
 127                         data = {url: dojo.moduleUrl("tests", "data/geography_hierarchy_small.json").toString() };
 128                 }else{
 129                         data = {data: {
 130                                 items:[
 131                                         { name:'Africa', countries:[
 132                                                 { name:'Egypt', capital:'Cairo' },
 133                                                 { name:'Kenya', capital:'Nairobi' },
 134                                                 { name:'Sudan', capital:'Khartoum' }]},
 135                                         { name:'Australia', capital:'Canberra' },
 136                                         { name:'North America', countries:[
 137                                                 { name:'Canada', population:'33 million', cities:[
 138                                                         { name:'Toronto', population:'2.5 million' },
 139                                                         { name:'Alberta', population:'1 million' }
 140                                                         ]},
 141                                                 { name: 'United States of America', capital: 'Washington DC', states:[
 142                                                         { name: 'Missouri'},
 143                                                         { name: 'Arkansas'}
 144                                                         ]}
 145                                                 ]}
 146                                 ]
 147                         }};
 148                 }
 149         }else if (name === "data_multitype"){
 150                 if(dojo.isBrowser){
 151                         data = {url: dojo.moduleUrl("tests", "data/data_multitype.json").toString() };
 152                 }else{
 153                         data = {data: {
 154                                                         "identifier": "count",
 155                                                         "label": "count",
 156                                                         items: [
 157                                                                 { count: 1,    value: "true" },
 158                                                                 { count: 2,    value: true   },
 159                                                                 { count: 3,    value: "false"},
 160                                                                 { count: 4,    value: false  },
 161                                                                 { count: 5,    value: true   },
 162                                                                 { count: 6,    value: true   },
 163                                                                 { count: 7,    value: "true" },
 164                                                                 { count: 8,    value: "true" },
 165                                                                 { count: 9,    value: "false"},
 166                                                                 { count: 10,   value: false  },
 167                                                                 { count: 11,   value: [false, false]},
 168                                                                 { count: "12", value: [false, "true"]}
 169                                                    ]
 170                                                 }
 171                                         };
 172                 }
 173         }else if (name === "countries_references"){
 174                 if(dojo.isBrowser){
 175                         data = {url: dojo.moduleUrl("tests", "data/countries_references.json").toString() };
 176                 }else{
 177                         data = {data: { identifier: 'name',
 178                                                         label: 'name',
 179                                                         items: [
 180                                                                 { name:'Africa', type:'continent',
 181                                                                         children:[{_reference:'Egypt'}, {_reference:'Kenya'}, {_reference:'Sudan'}] },
 182                                                                 { name:'Egypt', type:'country' },
 183                                                                 { name:'Kenya', type:'country',
 184                                                                         children:[{_reference:'Nairobi'}, {_reference:'Mombasa'}] },
 185                                                                 { name:'Nairobi', type:'city' },
 186                                                                 { name:'Mombasa', type:'city' },
 187                                                                 { name:'Sudan', type:'country',
 188                                                                         children:{_reference:'Khartoum'} },
 189                                                                 { name:'Khartoum', type:'city' },
 190                                                                 { name:'Asia', type:'continent',
 191                                                                         children:[{_reference:'China'}, {_reference:'India'}, {_reference:'Russia'}, {_reference:'Mongolia'}] },
 192                                                                 { name:'China', type:'country' },
 193                                                                 { name:'India', type:'country' },
 194                                                                 { name:'Russia', type:'country' },
 195                                                                 { name:'Mongolia', type:'country' },
 196                                                                 { name:'Australia', type:'continent', population:'21 million',
 197                                                                         children:{_reference:'Commonwealth of Australia'}},
 198                                                                 { name:'Commonwealth of Australia', type:'country', population:'21 million'},
 199                                                                 { name:'Europe', type:'continent',
 200                                                                         children:[{_reference:'Germany'}, {_reference:'France'}, {_reference:'Spain'}, {_reference:'Italy'}] },
 201                                                                 { name:'Germany', type:'country' },
 202                                                                 { name:'France', type:'country' },
 203                                                                 { name:'Spain', type:'country' },
 204                                                                 { name:'Italy', type:'country' },
 205                                                                 { name:'North America', type:'continent',
 206                                                                         children:[{_reference:'Mexico'}, {_reference:'Canada'}, {_reference:'United States of America'}] },
 207                                                                 { name:'Mexico', type:'country',  population:'108 million', area:'1,972,550 sq km',
 208                                                                         children:[{_reference:'Mexico City'}, {_reference:'Guadalajara'}] },
 209                                                                 { name:'Mexico City', type:'city', population:'19 million', timezone:'-6 UTC'},
 210                                                                 { name:'Guadalajara', type:'city', population:'4 million', timezone:'-6 UTC' },
 211                                                                 { name:'Canada', type:'country',  population:'33 million', area:'9,984,670 sq km',
 212                                                                         children:[{_reference:'Ottawa'}, {_reference:'Toronto'}] },
 213                                                                 { name:'Ottawa', type:'city', population:'0.9 million', timezone:'-5 UTC'},
 214                                                                 { name:'Toronto', type:'city', population:'2.5 million', timezone:'-5 UTC' },
 215                                                                 { name:'United States of America', type:'country' },
 216                                                                 { name:'South America', type:'continent',
 217                                                                         children:[{_reference:'Brazil'}, {_reference:'Argentina'}] },
 218                                                                 { name:'Brazil', type:'country', population:'186 million' },
 219                                                                 { name:'Argentina', type:'country', population:'40 million' }
 220                                                         ]
 221                                                 }
 222                                         };
 223                 }
 224         }
 225         return data;
 226 };
 227
 228 //-----------------------------------------------------
 229 // testTemplates
 230 tests.data.readOnlyItemFileTestTemplates.testTemplates = [
 231         {
 232                 name: "Identity API: fetchItemByIdentity()",
 233                 runTest: function(datastore, t){
 234                         //      summary:
 235                         //              Simple test of the fetchItemByIdentity function of the store.
 236                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 237
 238                         var d = new doh.Deferred();
 239                         function onItem(item){
 240                                 t.assertTrue(item !== null);
 241                                 if(item !== null){
 242                                         var name = store.getValue(item,"name");
 243                                         t.assertEqual(name, "El Salvador");
 244                                 }
 245                                 d.callback(true);
 246                         }
 247                         function onError(errData){
 248                                 t.assertTrue(false);
 249                                 d.errback(errData);
 250                         }
 251                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
 252                         return d; // Deferred
 253                 }
 254         },
 255         {
 256                 name: "Identity API: fetchItemByIdentity() notFound",
 257                 runTest: function(datastore, t){
 258                         //      summary:
 259                         //              Simple test of the fetchItemByIdentity function of the store.
 260                         //      description:
 261                         //              Simple test of the fetchItemByIdentity function of the store.
 262                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 263
 264                         var d = new doh.Deferred();
 265                         function onItem(item){
 266                                 t.assertTrue(item === null);
 267                                 d.callback(true);
 268                         }
 269                         function onError(errData){
 270                                 t.assertTrue(false);
 271                                 d.errback(errData);
 272                         }
 273                         store.fetchItemByIdentity({identity: "sv_not", onItem: onItem, onError: onError});
 274                         return d; // Deferred
 275                 }
 276         },
 277         {
 278                 name: "Identity API: getIdentityAttributes()",
 279                 runTest: function(datastore, t){
 280                         //      summary:
 281                         //              Simple test of the getIdentityAttributes function.
 282                         //      description:
 283                         //              Simple test of the getIdentityAttributes function.
 284                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 285
 286                         var d = new doh.Deferred();
 287                         function onItem(item){
 288                                 t.assertTrue(item !== null)
 289                                 var identifiers = store.getIdentityAttributes(item);
 290                                 t.assertTrue(dojo.isArray(identifiers));
 291                                 t.assertEqual(1, identifiers.length);
 292                                 t.assertEqual("abbr", identifiers[0]);
 293                                 d.callback(true);
 294                         }
 295                         function onError(errData){
 296                                 t.assertTrue(false);
 297                                 d.errback(errData);
 298                         }
 299                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
 300                         return d; // Deferred
 301                 }
 302         },
 303         {
 304                 name: "Identity API: fetchItemByIdentity() commentFilteredJson",
 305                 runTest: function(datastore, t){
 306                         //      summary:
 307                         //              Simple test of the fetchItemByIdentity function of the store.
 308                         //      description:
 309                         //              Simple test of the fetchItemByIdentity function of the store.
 310                         //              This tests loading a comment-filtered json file so that people using secure
 311                         //              data with this store can bypass the JavaSceipt hijack noted in Fortify's
 312                         //              paper.
 313
 314                         if(dojo.isBrowser){
 315                 var store = new datastore({url: dojo.moduleUrl("tests", "data/countries_commentFiltered.json").toString()});
 316
 317                                 var d = new doh.Deferred();
 318                                 function onItem(item){
 319                                         t.assertTrue(item !== null);
 320                                         var name = store.getValue(item,"name");
 321                                         t.assertEqual(name, "El Salvador");
 322                                         d.callback(true);
 323                                 }
 324                                 function onError(errData){
 325                                         t.assertTrue(false);
 326                                         d.errback(errData);
 327                                 }
 328                                 store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
 329                                 return d; // Deferred
 330                         }
 331                 }
 332         },
 333         {
 334                 name: "Identity API: fetchItemByIdentity() nullValue",
 335                 runTest: function(datastore, t){
 336                         //      summary:
 337                         //              Simple test of the fetchItemByIdentity function of the store, checling a null value.
 338                         //      description:
 339                         //              Simple test of the fetchItemByIdentity function of the store, checking a null value.
 340                         //              This tests handling attributes in json that were defined as null properly.
 341                         //              Introduced because of tracker: #3153
 342                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withNull"));
 343
 344                         var d = new doh.Deferred();
 345                         function onItem(item){
 346                                 t.assertTrue(item !== null);
 347                                 var name = store.getValue(item,"name");
 348                                 t.assertEqual(name, null);
 349                                 d.callback(true);
 350                         }
 351                         function onError(errData){
 352                                 t.assertTrue(false);
 353                                 d.errback(errData);
 354                         }
 355                         store.fetchItemByIdentity({identity: "ec", onItem: onItem, onError: onError});
 356                         return d; // Deferred
 357                 }
 358         },
 359         {
 360                 name: "Identity API: fetchItemByIdentity() booleanValue",
 361                 runTest: function(datastore, t){
 362                         //      summary:
 363                         //              Simple test of the fetchItemByIdentity function of the store, checking a boolean value.
 364                         //      description:
 365                         //              Simple test of the fetchItemByIdentity function of the store, checking a boolean value.
 366                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withBoolean"));
 367
 368                         var d = new doh.Deferred();
 369                         function onItem(item){
 370                                 t.assertTrue(item !== null);
 371                                 var name = store.getValue(item,"name");
 372                                 t.assertEqual(name, "Utopia");
 373                                 var real = store.getValue(item,"real");
 374                                 t.assertEqual(real, false);
 375                                 d.callback(true);
 376                         }
 377                         function onError(errData){
 378                                 t.assertTrue(false);
 379                                 d.errback(errData);
 380                         }
 381                         store.fetchItemByIdentity({identity: "ut", onItem: onItem, onError: onError});
 382                         return d; // Deferred
 383                 }
 384         },
 385         {
 386                 name: "Identity API: fetchItemByIdentity() withoutSpecifiedIdInData",
 387                 runTest: function(datastore, t){
 388                         //      summary:
 389                         //              Simple test of bug #4691, looking up something by assigned id, not one specified in the JSON data.
 390                         //      description:
 391                         //              Simple test of bug #4691, looking up something by assigned id, not one specified in the JSON data.
 392                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withoutid"));
 393
 394                         var d = new doh.Deferred();
 395                         function onItem(item){
 396                                 t.assertTrue(item !== null);
 397                                 var name = store.getValue(item,"name");
 398                                 t.assertEqual(name, "El Salvador");
 399                                 d.callback(true);
 400                         }
 401                         function onError(errData){
 402                                 t.assertTrue(false);
 403                                 d.errback(errData);
 404                         }
 405                         store.fetchItemByIdentity({identity: "2", onItem: onItem, onError: onError});
 406                         return d; // Deferred
 407                 }
 408         },
 409         {
 410                 name: "Identity API: getIdentity()",
 411                 runTest: function(datastore, t){
 412                         //      summary:
 413                         //              Simple test of the getIdentity function of the store.
 414                         //      description:
 415                         //              Simple test of the getIdentity function of the store.
 416                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 417
 418                         var d = new doh.Deferred();
 419                         function onItem(item){
 420                                 t.assertTrue(item !== null);
 421                                 t.assertTrue(store.getIdentity(item) === "sv");
 422                                 d.callback(true);
 423                         }
 424                         function onError(errData){
 425                                 t.assertTrue(false);
 426                                 d.errback(errData);
 427                         }
 428                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
 429                         return d; // Deferred
 430                 }
 431         },
 432         {
 433                 name: "Identity API: getIdentity() withoutSpecifiedId",
 434                 runTest: function(datastore, t){
 435                         //      summary:
 436                         //              Simple test of the #4691 bug
 437                         //      description:
 438                         //              Simple test of the #4691 bug
 439                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withoutid"));
 440
 441                         var d = new doh.Deferred();
 442                         function onItem(item, request){
 443                                 t.assertTrue(item !== null);
 444                                 t.assertTrue(store.getIdentity(item) === 2);
 445                                 d.callback(true);
 446                         }
 447                         function onError(errData, request){
 448                                 t.assertTrue(false);
 449                                 d.errback(errData);
 450                         }
 451                         store.fetch({ query:{abbr: "sv"}, onItem: onItem, onError: onError});
 452                         return d; // Deferred
 453                 }
 454         },
 455         {
 456                 name: "Read API: fetch() all",
 457                 runTest: function(datastore, t){
 458                         //      summary:
 459                         //              Simple test of a basic fetch on ItemFileReadStore.
 460                         //      description:
 461                         //              Simple test of a basic fetch on ItemFileReadStore.
 462                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 463
 464                         var d = new doh.Deferred();
 465                         function completedAll(items, request){
 466                                 t.is(7, items.length);
 467                                 d.callback(true);
 468                         }
 469                         function error(errData, request){
 470                                 t.assertTrue(false);
 471                                 d.errback(errData);
 472                         }
 473
 474                         //Get everything...
 475                         store.fetch({ onComplete: completedAll, onError: error});
 476                         return d;
 477                 }
 478         },
 479         {
 480                 name: "Read API: fetch() one",
 481                 runTest: function(datastore, t){
 482                         //      summary:
 483                         //              Simple test of a basic fetch on ItemFileReadStore of a single item.
 484                         //      description:
 485                         //              Simple test of a basic fetch on ItemFileReadStore of a single item.
 486                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 487
 488                         var d = new doh.Deferred();
 489                         function onComplete(items, request){
 490                                 t.assertEqual(items.length, 1);
 491                                 d.callback(true);
 492                         }
 493                         function onError(errData, request){
 494                                 t.assertTrue(false);
 495                                 d.errback(errData);
 496                         }
 497                         store.fetch({   query: {abbr: "ec"},
 498                                                                         onComplete: onComplete,
 499                                                                         onError: onError
 500                                                                 });
 501                         return d;
 502                 }
 503         },
 504         {
 505                 name: "Read API: fetch() shallow",
 506                 runTest: function(datastore, t){
 507                         //      summary:
 508                         //              Simple test of a basic fetch on ItemFileReadStore of only toplevel items
 509                         //      description:
 510                         //              Simple test of a basic fetch on ItemFileReadStore of only toplevel items.
 511                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
 512
 513                         var d = new doh.Deferred();
 514                         function onComplete(items, request){
 515                                 t.assertEqual(items.length, 2);
 516                                 d.callback(true);
 517                         }
 518                         function onError(errData, request){
 519                                 t.assertTrue(false);
 520                                 d.errback(errData);
 521                         }
 522                         //Find all items starting with A, only toplevel (root) items.
 523                         store.fetch({   query: {name: "A*"},
 524                                                                         onComplete: onComplete,
 525                                                                         onError: onError
 526                                                                 });
 527                         return d;
 528                 }
 529         },
 530         {
 531                 name: "Read API: fetch() Multiple",
 532                 runTest: function(datastore, t){
 533                         //      summary:
 534                         //              Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
 535                         //      description:
 536                         //              Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
 537                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
 538
 539                         var d = new doh.Deferred();
 540                         var done = [false, false];
 541
 542                         function onCompleteOne(items, request){
 543                                 done[0] = true;
 544                                 t.assertEqual(items.length, 2);
 545                                 if(done[0] && done[1]){
 546                                         d.callback(true);
 547                                 }
 548                         }
 549                         function onCompleteTwo(items, request){
 550                                 done[1] = true;
 551                                 if(done[0] && done[1]){
 552                                         d.callback(true);
 553                                 }
 554                         }
 555                         function onError(errData, request){
 556                                 t.assertTrue(false);
 557                                 d.errback(errData);
 558                         }
 559                         //Find all items starting with A, only toplevel (root) items.
 560                         store.fetch({   query: {name: "A*"},
 561                                                                         onComplete: onCompleteOne,
 562                                                                         onError: onError
 563                                                                 });
 564
 565                         //Find all items starting with A, only toplevel (root) items.
 566                         store.fetch({   query: {name: "N*"},
 567                                                                         onComplete: onCompleteTwo,
 568                                                                         onError: onError
 569                                                                 });
 570
 571                         return d;
 572                 }
 573         },
 574         {
 575                 name: "Read API: fetch() MultipleMixedFetch",
 576                 runTest: function(datastore, t){
 577                         //      summary:
 578                         //              Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
 579                         //      description:
 580                         //              Tests that multiple fetches at the same time queue up properly and do not clobber each other on initial load.
 581                         //              Tests an item fetch and an identity fetch.
 582                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 583
 584                         var d = new doh.Deferred();
 585                         var done = [false, false];
 586
 587                         function onComplete(items, request){
 588                                 done[0] = true;
 589                                 t.assertEqual(items.length, 1);
 590                                 if(done[0] && done[1]){
 591                                         d.callback(true);
 592                                 }
 593                         }
 594                         function onItem(item){
 595                                 done[1] = true;
 596                                 t.assertTrue(item !== null);
 597                                 var name = store.getValue(item,"name");
 598                                 t.assertEqual(name, "El Salvador");
 599
 600                                 if(done[0] && done[1]){
 601                                         d.callback(true);
 602                                 }
 603                         }
 604                         function onError(errData){
 605                                 t.assertTrue(false);
 606                                 d.errback(errData);
 607                         }
 608
 609                         //Find all items starting with A, only toplevel (root) items.
 610                         store.fetch({   query: {name: "El*"},
 611                                                                         onComplete: onComplete,
 612                                                                         onError: onError
 613                                                                 });
 614
 615                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
 616                         return d;
 617                 }
 618         },
 619         {
 620                 name: "Read API: fetch() deep",
 621                 runTest: function(datastore, t){
 622                         //      summary:
 623                         //              Simple test of a basic fetch on ItemFileReadStore of all items (including children (nested))
 624                         //      description:
 625                         //              Simple test of a basic fetch on ItemFileReadStore of all items (including children (nested))
 626                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
 627
 628                         var d = new doh.Deferred();
 629                         function onComplete(items, request){
 630                                 t.assertEqual(items.length, 4);
 631                                 d.callback(true);
 632                         }
 633                         function onError(errData, request){
 634                                 t.assertTrue(false);
 635                                 d.errback(errData);
 636                         }
 637                         //Find all items starting with A, including child (nested) items.
 638                         store.fetch({   query: {name: "A*"},
 639                                                                         onComplete: onComplete,
 640                                                                         onError: onError,
 641                                                                         queryOptions: {deep:true}
 642                                                                 });
 643                         return d;
 644                 }
 645         },
 646         {
 647                 name: "Read API: fetch() one_commentFilteredJson",
 648                 runTest: function(datastore, t){
 649                         //      summary:
 650                         //              Simple test of a basic fetch on ItemFileReadStore of a single item.
 651                         //      description:
 652                         //              Simple test of a basic fetch on ItemFileReadStore of a single item.
 653                         //              This tests loading a comment-filtered json file so that people using secure
 654                         //              data with this store can bypass the JavaSceipt hijack noted in Fortify's
 655                         //              paper.
 656                         if(dojo.isBrowser){
 657                 var store = new datastore({url: dojo.moduleUrl("tests", "data/countries_commentFiltered.json").toString()});
 658
 659                                 var d = new doh.Deferred();
 660                                 function onComplete(items, request){
 661                                         t.assertEqual(items.length, 1);
 662                                         d.callback(true);
 663                                 }
 664                                 function onError(errData, request){
 665                                         t.assertTrue(false);
 666                                         d.errback(errData);
 667                                 }
 668                                 store.fetch({   query: {abbr: "ec"},
 669                                                                                 onComplete: onComplete,
 670                                                                                 onError: onError
 671                                                                         });
 672                                 return d;
 673                         }
 674                 }
 675         },
 676         {
 677                 name: "Read API: fetch() withNull",
 678                 runTest: function(datastore, t){
 679                         //      summary:
 680                         //              Simple test of a basic fetch on ItemFileReadStore of a single item where some attributes are null.
 681                         //      description:
 682                         //              Simple test of a basic fetch on ItemFileReadStore of a single item where some attributes are null.
 683                         //              Introduced because of tracker: #3153
 684                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withNull"));
 685
 686                         var d = new doh.Deferred();
 687                         function onComplete(items, request){
 688                                 t.assertEqual(4, items.length);
 689                                 d.callback(true);
 690                         }
 691                         function onError(errData, request){
 692                                 t.assertTrue(false);
 693                                 d.errback(errData);
 694                         }
 695                         store.fetch({   query: {name: "E*"},
 696                                                                         onComplete: onComplete,
 697                                                                         onError: onError
 698                                                                 });
 699                         return d;
 700                 }
 701         },
 702         {
 703                 name: "Read API: fetch() all_streaming",
 704                 runTest: function(datastore, t){
 705                         //      summary:
 706                         //              Simple test of a basic fetch on ItemFileReadStore.
 707                         //      description:
 708                         //              Simple test of a basic fetch on ItemFileReadStore.
 709                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 710
 711                         var d = new doh.Deferred();
 712                         count = 0;
 713
 714                         function onBegin(size, requestObj){
 715                                 t.assertEqual(size, 7);
 716                         }
 717                         function onItem(item, requestObj){
 718                                 t.assertTrue(store.isItem(item));
 719                                 count++;
 720                         }
 721                         function onComplete(items, request){
 722                                 t.assertEqual(count, 7);
 723                                 t.assertTrue(items === null);
 724                                 d.callback(true);
 725                         }
 726                         function onError(errData, request){
 727                                 t.assertTrue(false);
 728                                 d.errback(errData);
 729                         }
 730
 731                         //Get everything...
 732                         store.fetch({   onBegin: onBegin,
 733                                                                         onItem: onItem,
 734                                                                         onComplete: onComplete,
 735                                                                         onError: onError
 736                                                                 });
 737                         return d;
 738                 }
 739         },
 740         {
 741                 name: "Read API: fetch() paging",
 742                 runTest: function(datastore, t){
 743                         //      summary:
 744                         //              Test of multiple fetches on a single result.  Paging, if you will.
 745                         //      description:
 746                         //              Test of multiple fetches on a single result.  Paging, if you will.
 747                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 748
 749                         var d = new doh.Deferred();
 750                         function dumpFirstFetch(items, request){
 751                                 t.assertEqual(items.length, 5);
 752                                 request.start = 3;
 753                                 request.count = 1;
 754                                 request.onComplete = dumpSecondFetch;
 755                                 store.fetch(request);
 756                         }
 757
 758                         function dumpSecondFetch(items, request){
 759                                 t.assertEqual(items.length, 1);
 760                                 request.start = 0;
 761                                 request.count = 5;
 762                                 request.onComplete = dumpThirdFetch;
 763                                 store.fetch(request);
 764                         }
 765
 766                         function dumpThirdFetch(items, request){
 767                                 t.assertEqual(items.length, 5);
 768                                 request.start = 2;
 769                                 request.count = 20;
 770                                 request.onComplete = dumpFourthFetch;
 771                                 store.fetch(request);
 772                         }
 773
 774                         function dumpFourthFetch(items, request){
 775                                 t.assertEqual(items.length, 5);
 776                                 request.start = 9;
 777                                 request.count = 100;
 778                                 request.onComplete = dumpFifthFetch;
 779                                 store.fetch(request);
 780                         }
 781
 782                         function dumpFifthFetch(items, request){
 783                                 t.assertEqual(items.length, 0);
 784                                 request.start = 2;
 785                                 request.count = 20;
 786                                 request.onComplete = dumpSixthFetch;
 787                                 store.fetch(request);
 788                         }
 789
 790                         function dumpSixthFetch(items, request){
 791                                 t.assertEqual(items.length, 5);
 792                                 d.callback(true);
 793                         }
 794
 795                         function completed(items, request){
 796                                 t.assertEqual(items.length, 7);
 797                                 request.start = 1;
 798                                 request.count = 5;
 799                                 request.onComplete = dumpFirstFetch;
 800                                 store.fetch(request);
 801                         }
 802
 803                         function error(errData, request){
 804                                 t.assertTrue(false);
 805                                 d.errback(errData);
 806                         }
 807                         store.fetch({onComplete: completed, onError: error});
 808                         return d;
 809                 }
 810         },
 811         {
 812                 name: "Read API: fetch() with MultiType Match",
 813                 runTest: function(datastore, t){
 814                         //      summary:
 815                         //              Simple test of a basic fetch againct an attribute that has different types for the value across items
 816                         //      description:
 817                         //              Simple test of a basic fetch againct an attribute that has different types for the value across items
 818                         //              Introduced because of tracker: #4931
 819                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("data_multitype"));
 820
 821                         var d = new doh.Deferred();
 822                         function onComplete(items, request){
 823                                 t.assertEqual(4, items.length);
 824                                 d.callback(true);
 825                         }
 826                         function onError(errData, request){
 827                                 t.assertTrue(false);
 828                                 d.errback(errData);
 829                         }
 830                         store.fetch({   query: {count: "1*"},
 831                                                                         onComplete: onComplete,
 832                                                                         onError: onError
 833                                                                 });
 834                         return d;
 835                 }
 836         },
 837         {
 838                 name: "Read API: fetch() with MultiType, MultiValue Match",
 839                 runTest: function(datastore, t){
 840                         //      summary:
 841                         //              Simple test of a basic fetch againct an attribute that has different types for the value across items
 842                         //      description:
 843                         //              Simple test of a basic fetch againct an attribute that has different types for the value across items
 844                         //              Introduced because of tracker: #4931
 845                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("data_multitype"));
 846
 847                         var d = new doh.Deferred();
 848                         function onComplete(items, request){
 849                                 t.assertEqual(7, items.length);
 850                                 d.callback(true);
 851                         }
 852                         function onError(errData, request){
 853                                 t.assertTrue(false);
 854                                 d.errback(errData);
 855                         }
 856                         store.fetch({   query: {value: "true"},
 857                                                                         onComplete: onComplete,
 858                                                                         onError: onError
 859                                                                 });
 860                         return d;
 861                 }
 862         },
 863         {
 864                 name: "Read API: getLabel()",
 865                 runTest: function(datastore, t){
 866                         //      summary:
 867                         //              Simple test of the getLabel function against a store set that has a label defined.
 868                         //      description:
 869                         //              Simple test of the getLabel function against a store set that has a label defined.
 870                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 871
 872                         var d = new doh.Deferred();
 873                         function onComplete(items, request){
 874                                 t.assertEqual(items.length, 1);
 875                                 var label = store.getLabel(items[0]);
 876                                 t.assertTrue(label !== null);
 877                                 t.assertEqual("Ecuador", label);
 878                                 d.callback(true);
 879                         }
 880                         function onError(errData, request){
 881                                 t.assertTrue(false);
 882                                 d.errback(errData);
 883                         }
 884                         store.fetch({   query: {abbr: "ec"},
 885                                                                         onComplete: onComplete,
 886                                                                         onError: onError
 887                                                                 });
 888                         return d;
 889                 }
 890         },
 891         {
 892                 name: "Read API: getLabelAttributes()",
 893                 runTest: function(datastore, t){
 894                         //      summary:
 895                         //              Simple test of the getLabelAttributes function against a store set that has a label defined.
 896                         //      description:
 897                         //              Simple test of the getLabelAttributes function against a store set that has a label defined.
 898                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 899
 900                         var d = new doh.Deferred();
 901                         function onComplete(items, request){
 902                                 t.assertEqual(items.length, 1);
 903                                 var labelList = store.getLabelAttributes(items[0]);
 904                                 t.assertTrue(dojo.isArray(labelList));
 905                                 t.assertEqual("name", labelList[0]);
 906                                 d.callback(true);
 907                         }
 908                         function onError(errData, request){
 909                                 t.assertTrue(false);
 910                                 d.errback(errData);
 911                         }
 912                         store.fetch({   query: {abbr: "ec"},
 913                                                                         onComplete: onComplete,
 914                                                                         onError: onError
 915                                                                 });
 916                         return d;
 917                 }
 918         },
 919         {
 920                 name: "Read API: getValue()",
 921                 runTest: function(datastore, t){
 922                         //      summary:
 923                         //              Simple test of the getValue function of the store.
 924                         //      description:
 925                         //              Simple test of the getValue function of the store.
 926                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 927
 928                         var d = new doh.Deferred();
 929                         function onItem(item){
 930                                 t.assertTrue(item !== null);
 931                                 var name = store.getValue(item,"name");
 932                                 t.assertTrue(name === "El Salvador");
 933                                 d.callback(true);
 934                         }
 935                         function onError(errData){
 936                                 t.assertTrue(false);
 937                                 d.errback(errData);
 938                         }
 939                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
 940                         return d; // Deferred
 941                 }
 942         },
 943         {
 944                 name: "Read API: getValues()",
 945                 runTest: function(datastore, t){
 946                         //      summary:
 947                         //              Simple test of the getValues function of the store.
 948                         //      description:
 949                         //              Simple test of the getValues function of the store.
 950                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 951
 952                         var d = new doh.Deferred();
 953                         function onItem(item){
 954                                 t.assertTrue(item !== null);
 955                                 var names = store.getValues(item,"name");
 956                                 t.assertTrue(dojo.isArray(names));
 957                                 t.assertEqual(names.length, 1);
 958                                 t.assertEqual(names[0], "El Salvador");
 959                                 d.callback(true);
 960                         }
 961                         function onError(errData){
 962                                 t.assertTrue(false);
 963                                 d.errback(errData);
 964                         }
 965                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
 966                         return d; // Deferred
 967                 }
 968         },
 969         {
 970                 name: "Read API: isItem()",
 971                 runTest: function(datastore, t){
 972                         //      summary:
 973                         //              Simple test of the isItem function of the store
 974                         //      description:
 975                         //              Simple test of the isItem function of the store
 976                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
 977
 978                         var d = new doh.Deferred();
 979                         function onItem(item){
 980                                 t.assertTrue(item !== null);
 981                                 t.assertTrue(store.isItem(item));
 982                                 t.assertTrue(!store.isItem({}));
 983                                 d.callback(true);
 984                         }
 985                         function onError(errData){
 986                                 t.assertTrue(false);
 987                                 d.errback(errData);
 988                         }
 989                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
 990                         return d; // Deferred
 991                 }
 992         },
 993         {
 994                 name: "Read API: isItem() multistore",
 995                 runTest: function(datastore, t){
 996                         //      summary:
 997                         //              Simple test of the isItem function of the store
 998                         //              to verify two different store instances do not accept
 999                         //              items from each other.
1000                         //      description:
1001                         //              Simple test of the isItem function of the store
1002                         //              to verify two different store instances do not accept
1003                         //              items from each other.
1004
1005                         // Two different instances, even  if they read from the same URL
1006                         // should not accept items between each other!
1007                         var store1 = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
1008                         var store2 = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
1009
1010                         var d = new doh.Deferred();
1011                         function onItem1(item1){
1012                                 t.assertTrue(item1 !== null);
1013
1014                                 function onItem2(item2){
1015                                         t.assertTrue(item1 !== null);
1016                                         t.assertTrue(item2 !== null);
1017                                         t.assertTrue(store1.isItem(item1));
1018                                         t.assertTrue(store2.isItem(item2));
1019                                         t.assertTrue(!store1.isItem(item2));
1020                                         t.assertTrue(!store2.isItem(item1));
1021                                         d.callback(true);
1022                                 }
1023                                 store2.fetchItemByIdentity({identity: "sv", onItem: onItem2, onError: onError});
1024
1025                         }
1026                         function onError(errData){
1027                                 t.assertTrue(false);
1028                                 d.errback(errData);
1029                         }
1030                         store1.fetchItemByIdentity({identity: "sv", onItem: onItem1, onError: onError});
1031                         return d; // Deferred
1032                 }
1033         },
1034         {
1035                 name: "Read API: hasAttribute()",
1036                 runTest: function(datastore, t){
1037                         //      summary:
1038                         //              Simple test of the hasAttribute function of the store
1039                         //      description:
1040                         //              Simple test of the hasAttribute function of the store
1041                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
1042
1043                         var d = new doh.Deferred();
1044                         function onItem(item){
1045                                 t.assertTrue(item !== null);
1046                                 t.assertTrue(store.hasAttribute(item, "abbr"));
1047                                 t.assertTrue(!store.hasAttribute(item, "abbr_not"));
1048
1049                                 //Test that null attributes throw an exception
1050                                 var passed = false;
1051                                 try{
1052                                         store.hasAttribute(item, null);
1053                                 }catch (e){
1054                                         passed = true;
1055                                 }
1056                                 t.assertTrue(passed);
1057                                 d.callback(true);
1058                         }
1059                         function onError(errData){
1060                                 t.assertTrue(false);
1061                                 d.errback(errData);
1062                         }
1063                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
1064                         return d; // Deferred
1065                 }
1066         },
1067         {
1068                 name: "Read API: containsValue()",
1069                 runTest: function(datastore, t){
1070                         //      summary:
1071                         //              Simple test of the containsValue function of the store
1072                         //      description:
1073                         //              Simple test of the containsValue function of the store
1074                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
1075
1076                         var d = new doh.Deferred();
1077                         function onItem(item){
1078                                 t.assertTrue(item !== null);
1079                                 t.assertTrue(store.containsValue(item, "abbr", "sv"));
1080                                 t.assertTrue(!store.containsValue(item, "abbr", "sv1"));
1081                                 t.assertTrue(!store.containsValue(item, "abbr", null));
1082
1083                                 //Test that null attributes throw an exception
1084                                 var passed = false;
1085                                 try{
1086                                         store.containsValue(item, null, "foo");
1087                                 }catch (e){
1088                                         passed = true;
1089                                 }
1090                                 t.assertTrue(passed);
1091                                 d.callback(true);
1092                         }
1093                         function onError(errData){
1094                                 t.assertTrue(false);
1095                                 d.errback(errData);
1096                         }
1097                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
1098                         return d; // Deferred
1099                 }
1100         },
1101         {
1102                 name: "Read API: getAttributes()",
1103                 runTest: function(datastore, t){
1104                         //      summary:
1105                         //              Simple test of the getAttributes function of the store
1106                         //      description:
1107                         //              Simple test of the getAttributes function of the store
1108                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
1109
1110                         var d = new doh.Deferred();
1111                         function onItem(item){
1112                                 t.assertTrue(item !== null);
1113                                 t.assertTrue(store.isItem(item));
1114
1115                                 var attributes = store.getAttributes(item);
1116                                 t.assertEqual(attributes.length, 3);
1117                                 for(var i = 0; i < attributes.length; i++){
1118                                         t.assertTrue((attributes[i] === "name" || attributes[i] === "abbr" || attributes[i] === "capital"));
1119                                 }
1120                                 d.callback(true);
1121                         }
1122                         function onError(errData){
1123                                 t.assertTrue(false);
1124                                 d.errback(errData);
1125                         }
1126                         store.fetchItemByIdentity({identity: "sv", onItem: onItem, onError: onError});
1127                         return d; // Deferred
1128                 }
1129         },
1130         {
1131                 name: "Read API: getFeatures()",
1132                 runTest: function(datastore, t){
1133                         //      summary:
1134                         //              Simple test of the getFeatures function of the store
1135                         //      description:
1136                         //              Simple test of the getFeatures function of the store
1137                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
1138
1139                         var features = store.getFeatures();
1140                         t.assertTrue(features["dojo.data.api.Read"] != null);
1141                         t.assertTrue(features["dojo.data.api.Identity"] != null);
1142                 }
1143         },
1144         {
1145                 name: "Read API: fetch() patternMatch0",
1146                 runTest: function(datastore, t){
1147                         //      summary:
1148                         //              Function to test pattern matching of everything starting with lowercase e
1149                         //      description:
1150                         //              Function to test pattern matching of everything starting with lowercase e
1151                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
1152
1153                         var d = new doh.Deferred();
1154                         function completed(items, request) {
1155                                 t.assertEqual(items.length, 5);
1156                                 var passed = true;
1157                                 for(var i = 0; i < items.length; i++){
1158                                         var value = store.getValue(items[i], "abbr");
1159                                         if(!(value === "ec" || value === "eg" || value === "er" || value === "ee" || value === "et")){
1160                                                 passed=false;
1161                                                 break;
1162                                         }
1163                                 }
1164                                 t.assertTrue(passed);
1165                                 if (passed){
1166                                         d.callback(true);
1167                                 }else{
1168                                         d.errback(new Error("Unexpected abbreviation found, match failure."));
1169                                 }
1170                         }
1171                         function error(error, request) {
1172                                 t.assertTrue(false);
1173                                 d.errback(error);
1174                         }
1175                         store.fetch({query: {abbr: "e*"}, onComplete: completed, onError: error});
1176                         return d;
1177                 }
1178         },
1179         {
1180                 name: "Read API: fetch() patternMatch1",
1181                 runTest: function(datastore, t){
1182                         //      summary:
1183                         //              Function to test pattern matching of everything with $ in it.
1184                         //      description:
1185                         //              Function to test pattern matching of everything with $ in it.
1186
1187                         var store = new datastore({data: { identifier: "uniqueId",
1188                                                                                           items: [ {uniqueId: 1, value:"foo*bar"},
1189                                                                                                    {uniqueId: 2, value:"bar*foo"},
1190                                                                                                    {uniqueId: 3, value:"boomBam"},
1191                                                                                                    {uniqueId: 4, value:"bit$Bite"},
1192                                                                                                    {uniqueId: 5, value:"ouagadogou"},
1193                                                                                                    {uniqueId: 6, value:"BaBaMaSaRa***Foo"},
1194                                                                                                    {uniqueId: 7, value:"squawl"},
1195                                                                                                    {uniqueId: 8, value:"seaweed"},
1196                                                                                                    {uniqueId: 9, value:"jfq4@#!$!@Rf14r14i5u"}
1197                                                                                                  ]
1198                                                                                 }
1199                                                                  });
1200
1201                         var d = new doh.Deferred();
1202                         function completed(items, request){
1203                                 t.assertEqual(items.length, 2);
1204                                 var passed = true;
1205                                 for(var i = 0; i < items.length; i++){
1206                                         var value = store.getValue(items[i], "value");
1207                                         if(!(value === "bit$Bite" || value === "jfq4@#!$!@Rf14r14i5u")){
1208                                                 passed=false;
1209                                                 break;
1210                                         }
1211                                 }
1212                                 t.assertTrue(passed);
1213                                 if (passed){
1214                                         d.callback(true);
1215                                 }else{
1216                                         d.errback(new Error("Unexpected pattern matched.  Filter failure."));
1217                                 }
1218                         }
1219                         function error(error, request){
1220                                 t.assertTrue(false);
1221                                 d.errback(error);
1222                         }
1223                         store.fetch({query: {value: "*$*"}, onComplete: completed, onError: error});
1224                         return d;
1225                 }
1226         },
1227         {
1228                 name: "Read API: fetch() patternMatch2",
1229                 runTest: function(datastore, t){
1230                         //      summary:
1231                         //              Function to test exact pattern match
1232                         //      description:
1233                         //              Function to test exact pattern match
1234
1235                         var store = new datastore({data: { identifier: "uniqueId",
1236                                                                                           items: [ {uniqueId: 1, value:"foo*bar"},
1237                                                                                                    {uniqueId: 2, value:"bar*foo"},
1238                                                                                                    {uniqueId: 3, value:"boomBam"},
1239                                                                                                    {uniqueId: 4, value:"bit$Bite"},
1240                                                                                                    {uniqueId: 5, value:"ouagadogou"},
1241                                                                                                    {uniqueId: 6, value:"BaBaMaSaRa***Foo"},
1242                                                                                                    {uniqueId: 7, value:"squawl"},
1243                                                                                                    {uniqueId: 8, value:"seaweed"},
1244                                                                                                    {uniqueId: 9, value:"jfq4@#!$!@Rf14r14i5u"}
1245                                                                                                  ]
1246                                                                                 }
1247                                                                  });
1248
1249                         var d = new doh.Deferred();
1250                         function completed(items, request){
1251                                 t.assertEqual(items.length, 1);
1252                                 var passed = true;
1253                                 for(var i = 0; i < items.length; i++){
1254                                         var value = store.getValue(items[i], "value");
1255                                         if(!(value === "bar*foo")){
1256                                                 passed=false;
1257                                                 break;
1258                                         }
1259                                 }
1260                                 t.assertTrue(passed);
1261                                 if (passed){
1262                                         d.callback(true);
1263                                 }else{
1264                                         d.errback(new Error("Unexpected abbreviation found, match failure."));
1265                                 }
1266                         }
1267                         function error(error, request){
1268                                 t.assertTrue(false);
1269                                 d.errback(error);
1270                         }
1271                         store.fetch({query: {value: "bar\*foo"}, onComplete: completed, onError: error});
1272                         return d;
1273                 }
1274         },
1275         {
1276                 name: "Read API: fetch() patternMatch_caseSensitive",
1277                 runTest: function(datastore, t){
1278                         //      summary:
1279                         //              Function to test pattern matching of a pattern case-sensitively
1280                         //      description:
1281                         //              Function to test pattern matching of a pattern case-sensitively
1282
1283                         var store = new datastore({data: { identifier: "uniqueId",
1284                                                                                           items: [ {uniqueId: 1, value:"foo*bar"},
1285                                                                                                    {uniqueId: 2, value:"bar*foo"},
1286                                                                                                    {uniqueId: 3, value:"BAR*foo"},
1287                                                                                                    {uniqueId: 4, value:"BARBananafoo"}
1288                                                                                                  ]
1289                                                                                 }
1290                                                                  });
1291
1292                         var d = new doh.Deferred();
1293                         function completed(items, request){
1294                                 t.assertEqual(1, items.length);
1295                                 var passed = true;
1296                                 for(var i = 0; i < items.length; i++){
1297                                         var value = store.getValue(items[i], "value");
1298                                         if(!(value === "bar*foo")){
1299                                                 passed=false;
1300                                                 break;
1301                                         }
1302                                 }
1303                                 t.assertTrue(passed);
1304                                 if (passed){
1305                                         d.callback(true);
1306                                 }else{
1307                                         d.errback(new Error("Unexpected pattern matched.  Filter failure."));
1308                                 }
1309                         }
1310                         function error(error, request){
1311                                 t.assertTrue(false);
1312                                 d.errback(error);
1313                         }
1314                         store.fetch({query: {value: "bar\\*foo"}, queryOptions: {ignoreCase: false} , onComplete: completed, onError: error});
1315                         return d;
1316                 }
1317         },
1318         {
1319                 name: "Read API: fetch() patternMatch_caseInsensitive",
1320                 runTest: function(datastore, t){
1321                         //      summary:
1322                         //              Function to test pattern matching of a pattern case-insensitively
1323                         //      description:
1324                         //              Function to test pattern matching of a pattern case-insensitively
1325
1326                         var store = new datastore({data: { identifier: "uniqueId",
1327                                                                                           items: [ {uniqueId: 1, value:"foo*bar"},
1328                                                                                                    {uniqueId: 2, value:"bar*foo"},
1329                                                                                                    {uniqueId: 3, value:"BAR*foo"},
1330                                                                                                    {uniqueId: 4, value:"BARBananafoo"}
1331                                                                                                  ]
1332                                                                                 }
1333                                                                  });
1334
1335                         var d = new doh.Deferred();
1336                         function completed(items, request){
1337                                 t.assertEqual(items.length, 2);
1338                                 var passed = true;
1339                                 for(var i = 0; i < items.length; i++){
1340                                         var value = store.getValue(items[i], "value");
1341                                         if(!(value === "BAR*foo" || value === "bar*foo")){
1342                                                 passed=false;
1343                                                 break;
1344                                         }
1345                                 }
1346                                 t.assertTrue(passed);
1347                                 if (passed){
1348                                         d.callback(true);
1349                                 }else{
1350                                         d.errback(new Error("Unexpected pattern matched.  Filter failure."));
1351                                 }
1352                         }
1353                         function error(error, request){
1354                                 t.assertTrue(false);
1355                                 d.errback(error);
1356                         }
1357                         store.fetch({query: {value: "bar\\*foo"}, queryOptions: {ignoreCase: true}, onComplete: completed, onError: error});
1358                         return d;
1359                 }
1360         },
1361         {
1362                 name: "Read API: fetch() sortNumeric",
1363                 runTest: function(datastore, t){
1364                         //      summary:
1365                         //              Function to test sorting numerically.
1366                         //      description:
1367                         //              Function to test sorting numerically.
1368
1369                         var store = new datastore({data: { identifier: "uniqueId",
1370                                                                                           items: [ {uniqueId: 0, value:"fo|o*b.ar"},
1371                                                                                                    {uniqueId: 1, value:"ba|r*foo"},
1372                                                                                                    {uniqueId: 2, value:"boomBam"},
1373                                                                                                    {uniqueId: 3, value:"bit$Bite"},
1374                                                                                                    {uniqueId: 4, value:"ouagadogou"},
1375                                                                                                    {uniqueId: 5, value:"jfq4@#!$!@|f1.$4r14i5u"},
1376                                                                                                    {uniqueId: 6, value:"BaB{aMa|SaRa***F}oo"},
1377                                                                                                    {uniqueId: 7, value:"squawl"},
1378                                                                                                    {uniqueId: 9, value:"seaweed"},
1379                                                                                                    {uniqueId: 10, value:"zulu"},
1380                                                                                                    {uniqueId: 8, value:"seaweed"}
1381                                                                                                  ]
1382                                                                                 }
1383                                                                  });
1384
1385                         var d = new doh.Deferred();
1386                         function completed(items, request){
1387                                 t.assertEqual(items.length, 11);
1388                                 var passed = true;
1389                                 for(var i = 0; i < items.length; i++){
1390                                         var value = store.getValue(items[i], "value");
1391                                         if(!(store.getValue(items[i], "uniqueId") === i)){
1392                                                 passed=false;
1393                                                 break;
1394                                         }
1395                                 }
1396                                 t.assertTrue(passed);
1397                                 if (passed){
1398                                         d.callback(true);
1399                                 }else{
1400                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1401                                 }
1402                         }
1403
1404                         function error(error, request){
1405                                 t.assertTrue(false);
1406                                 d.errback(error);
1407                         }
1408
1409                         var sortAttributes = [{attribute: "uniqueId"}];
1410                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1411                         return d;
1412                 }
1413         },
1414         {
1415                 name: "Read API: fetch() sortNumericDescending",
1416                 runTest: function(datastore, t){
1417                         //      summary:
1418                         //              Function to test sorting numerically.
1419                         //      description:
1420                         //              Function to test sorting numerically.
1421
1422                         var store = new datastore({data: { identifier: "uniqueId",
1423                                                                                           items: [ {uniqueId: 0, value:"fo|o*b.ar"},
1424                                                                                                    {uniqueId: 1, value:"ba|r*foo"},
1425                                                                                                    {uniqueId: 2, value:"boomBam"},
1426                                                                                                    {uniqueId: 3, value:"bit$Bite"},
1427                                                                                                    {uniqueId: 4, value:"ouagadogou"},
1428                                                                                                    {uniqueId: 5, value:"jfq4@#!$!@|f1.$4r14i5u"},
1429                                                                                                    {uniqueId: 6, value:"BaB{aMa|SaRa***F}oo"},
1430                                                                                                    {uniqueId: 7, value:"squawl"},
1431                                                                                                    {uniqueId: 9, value:"seaweed"},
1432                                                                                                    {uniqueId: 10, value:"zulu"},
1433                                                                                                    {uniqueId: 8, value:"seaweed"}
1434                                                                                                  ]
1435                                                                                 }
1436                                                                  });
1437                         var d = new doh.Deferred();
1438                         function completed(items, request){
1439                                 t.assertEqual(items.length, 11);
1440                                 var passed = true;
1441                                 for(var i = 0; i < items.length; i++){
1442                                         var value = store.getValue(items[i], "value");
1443                                         if(!((items.length - (store.getValue(items[i], "uniqueId") + 1)) === i)){
1444                                                 passed=false;
1445                                                 break;
1446                                         }
1447                                 }
1448                                 t.assertTrue(passed);
1449                                 if (passed){
1450                                         d.callback(true);
1451                                 }else{
1452                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1453                                 }
1454                         }
1455
1456                         function error(error, request){
1457                                 t.assertTrue(false);
1458                                 d.errback(error);
1459                         }
1460
1461                         var sortAttributes = [{attribute: "uniqueId", descending: true}];
1462                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1463                         return d;
1464                 }
1465         },
1466         {
1467                 name: "Read API: fetch() sortNumericWithCount",
1468                 runTest: function(datastore, t){
1469                         //      summary:
1470                         //              Function to test sorting numerically in descending order, returning only a specified number of them.
1471                         //      description:
1472                         //              Function to test sorting numerically in descending order, returning only a specified number of them.
1473
1474                         var store = new datastore({data: { identifier: "uniqueId",
1475                                                                                          items: [ {uniqueId: 0, value:"fo|o*b.ar"},
1476                                                                                                   {uniqueId: 1, value:"ba|r*foo"},
1477                                                                                                   {uniqueId: 2, value:"boomBam"},
1478                                                                                                   {uniqueId: 3, value:"bit$Bite"},
1479                                                                                                   {uniqueId: 4, value:"ouagadogou"},
1480                                                                                                   {uniqueId: 5, value:"jfq4@#!$!@|f1.$4r14i5u"},
1481                                                                                                   {uniqueId: 6, value:"BaB{aMa|SaRa***F}oo"},
1482                                                                                                   {uniqueId: 7, value:"squawl"},
1483                                                                                                   {uniqueId: 9, value:"seaweed"},
1484                                                                                                   {uniqueId: 10, value:"zulu"},
1485                                                                                                   {uniqueId: 8, value:"seaweed"}
1486                                                                                                 ]
1487                                                                            }
1488                                                                 });
1489
1490                         var d = new doh.Deferred();
1491                         function completed(items, request){
1492                                 t.assertEqual(items.length, 5);
1493                                 var itemId = 10;
1494                                 var passed = true;
1495                                 for(var i = 0; i < items.length; i++){
1496                                         var value = store.getValue(items[i], "value");
1497                                         if(!(store.getValue(items[i], "uniqueId") === itemId)){
1498                                                 passed=false;
1499                                                 break;
1500                                         }
1501                                         itemId--; // Decrement the item id.  We are descending sorted, so it should go 10, 9, 8, etc.
1502                                 }
1503                                 t.assertTrue(passed);
1504                                 if (passed){
1505                                         d.callback(true);
1506                                 }else{
1507                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1508                                 }
1509                         }
1510
1511                         function error(error, request){
1512                                 t.assertTrue(false);
1513                                 d.errback(error);
1514                         }
1515
1516                         var sortAttributes = [{attribute: "uniqueId", descending: true}];
1517                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes, count: 5});
1518                         return d;
1519                 }
1520         },
1521         {
1522                 name: "Read API: fetch() sortAlphabetic",
1523                 runTest: function(datastore, t){
1524                         //      summary:
1525                         //              Function to test sorting alphabetic ordering.
1526                         //      description:
1527                         //              Function to test sorting alphabetic ordering.
1528
1529                         var store = new datastore({data: { identifier: "uniqueId",
1530                                                                                          items: [ {uniqueId: 0, value:"abc"},
1531                                                                                                   {uniqueId: 1, value:"bca"},
1532                                                                                                   {uniqueId: 2, value:"abcd"},
1533                                                                                                   {uniqueId: 3, value:"abcdefg"},
1534                                                                                                   {uniqueId: 4, value:"lmnop"},
1535                                                                                                   {uniqueId: 5, value:"foghorn"},
1536                                                                                                   {uniqueId: 6, value:"qberty"},
1537                                                                                                   {uniqueId: 7, value:"qwerty"},
1538                                                                                                   {uniqueId: 8, value:""},
1539                                                                                                   {uniqueId: 9, value:"seaweed"},
1540                                                                                                   {uniqueId: 10, value:"123abc"}
1541
1542                                                                                                 ]
1543                                                                            }
1544                                                                 });
1545
1546                         var d = new doh.Deferred();
1547                         function completed(items, request){
1548                                 //Output should be in this order...
1549                                 var orderedArray = [    "",
1550                                                                                 "123abc",
1551                                                                                 "abc",
1552                                                                                 "abcd",
1553                                                                                 "abcdefg",
1554                                                                                 "bca",
1555                                                                                 "foghorn",
1556                                                                                 "lmnop",
1557                                                                                 "qberty",
1558                                                                                 "qwerty",
1559                                                                                 "seaweed"
1560                                         ];
1561                                 t.assertEqual(items.length, 11);
1562                                 var passed = true;
1563                                 for(var i = 0; i < items.length; i++){
1564                                         var value = store.getValue(items[i], "value");
1565                                         if(!(store.getValue(items[i], "value") === orderedArray[i])){
1566                                                 passed=false;
1567                                                 break;
1568                                         }
1569                                 }
1570                                 t.assertTrue(passed);
1571                                 if (passed){
1572                                         d.callback(true);
1573                                 }else{
1574                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1575                                 }
1576                         }
1577
1578                         function error(error, request) {
1579                                 t.assertTrue(false);
1580                                 d.errback(error);
1581                         }
1582
1583                         var sortAttributes = [{attribute: "value"}];
1584                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1585                         return d;
1586                 }
1587         },
1588         {
1589                 name: "Read API: fetch() sortAlphabeticDescending",
1590                 runTest: function(datastore, t){
1591                         //      summary:
1592                         //              Function to test sorting alphabetic ordering in descending mode.
1593                         //      description:
1594                         //              Function to test sorting alphabetic ordering in descending mode.
1595
1596                         var store = new datastore({data: { identifier: "uniqueId",
1597                                                                                          items: [ {uniqueId: 0, value:"abc"},
1598                                                                                                   {uniqueId: 1, value:"bca"},
1599                                                                                                   {uniqueId: 2, value:"abcd"},
1600                                                                                                   {uniqueId: 3, value:"abcdefg"},
1601                                                                                                   {uniqueId: 4, value:"lmnop"},
1602                                                                                                   {uniqueId: 5, value:"foghorn"},
1603                                                                                                   {uniqueId: 6, value:"qberty"},
1604                                                                                                   {uniqueId: 7, value:"qwerty"},
1605                                                                                                   {uniqueId: 8, value:""},
1606                                                                                                   {uniqueId: 9, value:"seaweed"},
1607                                                                                                   {uniqueId: 10, value:"123abc"}
1608
1609                                                                                                 ]
1610                                                                            }
1611                                                                 });
1612                         var d = new doh.Deferred();
1613                         function completed(items, request){
1614                                 //Output should be in this order...
1615                                 var orderedArray = [    "",
1616                                                                                 "123abc",
1617                                                                                 "abc",
1618                                                                                 "abcd",
1619                                                                                 "abcdefg",
1620                                                                                 "bca",
1621                                                                                 "foghorn",
1622                                                                                 "lmnop",
1623                                                                                 "qberty",
1624                                                                                 "qwerty",
1625                                                                                 "seaweed"
1626                                         ];
1627                                 orderedArray = orderedArray.reverse();
1628                                 t.assertEqual(items.length, 11);
1629
1630                                 var passed = true;
1631                                 for(var i = 0; i < items.length; i++){
1632                                         var value = store.getValue(items[i], "value");
1633                                         if(!(store.getValue(items[i], "value") === orderedArray[i])){
1634                                                 passed=false;
1635                                                 break;
1636                                         }
1637                                 }
1638                                 t.assertTrue(passed);
1639                                 if (passed){
1640                                         d.callback(true);
1641                                 }else{
1642                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1643                                 }
1644                         }
1645
1646                         function error(error, request) {
1647                                 t.assertTrue(false);
1648                                 d.errback(error);
1649                         }
1650
1651                         var sortAttributes = [{attribute: "value", descending: true}];
1652                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1653                         return d;
1654                 }
1655         },
1656         {
1657                 name: "Read API: fetch() sortDate",
1658                 runTest: function(datastore, t){
1659                         //      summary:
1660                         //              Function to test sorting date.
1661                         //      description:
1662                         //              Function to test sorting date.
1663
1664                         var store = new datastore({data: { identifier: "uniqueId",
1665                                                                                          items: [ {uniqueId: 0, value: new Date(0)},
1666                                                                                                   {uniqueId: 1, value: new Date(100)},
1667                                                                                                   {uniqueId: 2, value:new Date(1000)},
1668                                                                                                   {uniqueId: 3, value:new Date(2000)},
1669                                                                                                   {uniqueId: 4, value:new Date(3000)},
1670                                                                                                   {uniqueId: 5, value:new Date(4000)},
1671                                                                                                   {uniqueId: 6, value:new Date(5000)},
1672                                                                                                   {uniqueId: 7, value:new Date(6000)},
1673                                                                                                   {uniqueId: 8, value:new Date(7000)},
1674                                                                                                   {uniqueId: 9, value:new Date(8000)},
1675                                                                                                   {uniqueId: 10, value:new Date(9000)}
1676
1677                                                                                                 ]
1678                                                                            }
1679                                                                 });
1680
1681                         var d = new doh.Deferred();
1682                         function completed(items,request){
1683                                 var orderedArray =      [0,100,1000,2000,3000,4000,5000,6000,7000,8000,9000];
1684                                 t.assertEqual(items.length, 11);
1685                                 var passed = true;
1686                                 for(var i = 0; i < items.length; i++){
1687                                         var value = store.getValue(items[i], "value");
1688                                         if(!(store.getValue(items[i], "value").getTime() === orderedArray[i])){
1689                                                 passed=false;
1690                                                 break;
1691                                         }
1692                                 }
1693                                 t.assertTrue(passed);
1694                                 if (passed){
1695                                         d.callback(true);
1696                                 }else{
1697                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1698                                 }
1699                         }
1700
1701                         function error(error, request){
1702                                 t.assertTrue(false);
1703                                 d.errback(error);
1704                         }
1705
1706                         var sortAttributes = [{attribute: "value"}];
1707                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1708                         return d;
1709                 }
1710         },
1711         {
1712                 name: "Read API: fetch() sortDateDescending",
1713                 runTest: function(datastore, t){
1714                         //      summary:
1715                         //              Function to test sorting date in descending order.
1716                         //      description:
1717                         //              Function to test sorting date in descending order.
1718
1719                         var store = new datastore({data: { identifier: "uniqueId",
1720                                                                                          items: [ {uniqueId: 0, value: new Date(0)},
1721                                                                                                   {uniqueId: 1, value: new Date(100)},
1722                                                                                                   {uniqueId: 2, value:new Date(1000)},
1723                                                                                                   {uniqueId: 3, value:new Date(2000)},
1724                                                                                                   {uniqueId: 4, value:new Date(3000)},
1725                                                                                                   {uniqueId: 5, value:new Date(4000)},
1726                                                                                                   {uniqueId: 6, value:new Date(5000)},
1727                                                                                                   {uniqueId: 7, value:new Date(6000)},
1728                                                                                                   {uniqueId: 8, value:new Date(7000)},
1729                                                                                                   {uniqueId: 9, value:new Date(8000)},
1730                                                                                                   {uniqueId: 10, value:new Date(9000)}
1731
1732                                                                                                 ]
1733                                                                            }
1734                                                                 });
1735
1736                         var d = new doh.Deferred();
1737                         function completed(items,request){
1738                                 var orderedArray =      [0,100,1000,2000,3000,4000,5000,6000,7000,8000,9000];
1739                                 orderedArray = orderedArray.reverse();
1740                                 t.assertEqual(items.length, 11);
1741                                 var passed = true;
1742                                 for(var i = 0; i < items.length; i++){
1743                                         var value = store.getValue(items[i], "value");
1744                                         if(!(store.getValue(items[i], "value").getTime() === orderedArray[i])){
1745                                                 passed=false;
1746                                                 break;
1747                                         }
1748                                 }
1749                                 t.assertTrue(passed);
1750                                 if (passed){
1751                                         d.callback(true);
1752                                 }else{
1753                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1754                                 }
1755                         }
1756
1757                         function error(error, request){
1758                                 t.assertTrue(false);
1759                                 d.errback(error);
1760                         }
1761
1762                         var sortAttributes = [{attribute: "value", descending: true}];
1763                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1764                         return d;
1765                 }
1766         },
1767         {
1768                 name: "Read API: fetch() sortMultiple",
1769                 runTest: function(datastore, t){
1770                         //      summary:
1771                         //              Function to test sorting on multiple attributes.
1772                         //      description:
1773                         //              Function to test sorting on multiple attributes.
1774
1775                         var store = new datastore({data: { identifier: "uniqueId",
1776                                                                                          items: [ {uniqueId: 1, value:"fo|o*b.ar"},
1777                                                                                                   {uniqueId: 2, value:"ba|r*foo"},
1778                                                                                                   {uniqueId: 3, value:"boomBam"},
1779                                                                                                   {uniqueId: 4, value:"bit$Bite"},
1780                                                                                                   {uniqueId: 5, value:"ouagadogou"},
1781                                                                                                   {uniqueId: 6, value:"jfq4@#!$!@|f1.$4r14i5u"},
1782                                                                                                   {uniqueId: 7, value:"BaB{aMa|SaRa***F}oo"},
1783                                                                                                   {uniqueId: 8, value:"squawl"},
1784                                                                                                   {uniqueId: 10, value:"seaweed"},
1785                                                                                                   {uniqueId: 12, value:"seaweed"},
1786                                                                                                   {uniqueId: 11, value:"zulu"},
1787                                                                                                   {uniqueId: 9, value:"seaweed"}
1788                                                                                                 ]
1789                                                                            }
1790                                                                 });
1791
1792                         var d = new doh.Deferred();
1793                         function completed(items, request){
1794                                 var orderedArray0 = [7,2,4,3,1,6,5,12,10,9,8,11];
1795                                 var orderedArray1 = [   "BaB{aMa|SaRa***F}oo",
1796                                                                                 "ba|r*foo",
1797                                                                                 "bit$Bite",
1798                                                                                 "boomBam",
1799                                                                                 "fo|o*b.ar",
1800                                                                                 "jfq4@#!$!@|f1.$4r14i5u",
1801                                                                                 "ouagadogou",
1802                                                                                 "seaweed",
1803                                                                                 "seaweed",
1804                                                                                 "seaweed",
1805                                                                                 "squawl",
1806                                                                                 "zulu"
1807                                                                         ];
1808                                 var passed = true;
1809                                 for(var i = 0; i < items.length; i++){
1810                                         var value = store.getValue(items[i], "value");
1811                                         if(!(   (store.getValue(items[i], "uniqueId") === orderedArray0[i])&&
1812                                                         (store.getValue(items[i], "value") === orderedArray1[i]))
1813                                                 ){
1814                                                 passed=false;
1815                                                 break;
1816                                         }
1817                                 }
1818                                 t.assertTrue(passed);
1819                                 if (passed){
1820                                         d.callback(true);
1821                                 }else{
1822                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1823                                 }
1824                         }
1825
1826                         function error(error, request){
1827                                 t.assertTrue(false);
1828                                 d.errback(error);
1829                         }
1830
1831                         var sortAttributes = [{ attribute: "value"}, { attribute: "uniqueId", descending: true}];
1832                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1833                         return d;
1834                 }
1835         },
1836         {
1837                 name: "Read API: fetch() sortMultipleSpecialComparator",
1838                 runTest: function(datastore, t){
1839                         //      summary:
1840                         //              Function to test sorting on multiple attributes with a custom comparator.
1841                         //      description:
1842                         //              Function to test sorting on multiple attributes with a custom comparator.
1843
1844                         var store = new datastore({data: { identifier: "uniqueId",
1845                                                                                          items: [ {uniqueId: 1, status:"CLOSED"},
1846                                                                                                   {uniqueId: 2,  status:"OPEN"},
1847                                                                                                   {uniqueId: 3,  status:"PENDING"},
1848                                                                                                   {uniqueId: 4,  status:"BLOCKED"},
1849                                                                                                   {uniqueId: 5,  status:"CLOSED"},
1850                                                                                                   {uniqueId: 6,  status:"OPEN"},
1851                                                                                                   {uniqueId: 7,  status:"PENDING"},
1852                                                                                                   {uniqueId: 8,  status:"PENDING"},
1853                                                                                                   {uniqueId: 10, status:"BLOCKED"},
1854                                                                                                   {uniqueId: 12, status:"BLOCKED"},
1855                                                                                                   {uniqueId: 11, status:"OPEN"},
1856                                                                                                   {uniqueId: 9,  status:"CLOSED"}
1857                                                                                                 ]
1858                                                                            }
1859                                                                 });
1860
1861
1862                         store.comparatorMap = {};
1863                         store.comparatorMap["status"] = function(a,b) {
1864                                 var ret = 0;
1865                                 // We want to map these by what the priority of these items are, not by alphabetical.
1866                                 // So, custom comparator.
1867                                 var enumMap = { OPEN: 3, BLOCKED: 2, PENDING: 1, CLOSED: 0};
1868                                 if (enumMap[a] > enumMap[b]) {
1869                                         ret = 1;
1870                                 }
1871                                 if (enumMap[a] < enumMap[b]) {
1872                                         ret = -1;
1873                                 }
1874                                 return ret;
1875                         };
1876
1877                         var sortAttributes = [{attribute: "status", descending: true}, { attribute: "uniqueId", descending: true}];
1878
1879                         var d = new doh.Deferred();
1880                         function completed(items, findResult){
1881                                 var orderedArray = [11,6,2,12,10,4,8,7,3,9,5,1];
1882                                 var passed = true;
1883                                 for(var i = 0; i < items.length; i++){
1884                                         var value = store.getValue(items[i], "value");
1885                                         if(!(store.getValue(items[i], "uniqueId") === orderedArray[i])){
1886                                                 passed=false;
1887                                                 break;
1888                                         }
1889                                 }
1890                                 t.assertTrue(passed);
1891                                 if (passed){
1892                                         d.callback(true);
1893                                 }else{
1894                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1895                                 }
1896                         }
1897
1898                         function error(errData, request){
1899                                 t.assertTrue(false);
1900                                 d.errback(errData);
1901                         }
1902                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1903                         return d;
1904                 }
1905         },
1906         {
1907                 name: "Read API: fetch() sortAlphabeticWithUndefined",
1908                 runTest: function(datastore, t){
1909                         //      summary:
1910                         //              Function to test sorting alphabetic ordering.
1911                         //      description:
1912                         //              Function to test sorting alphabetic ordering.
1913
1914                         var store = new datastore({data: { identifier: "uniqueId",
1915                                                                                          items: [ {uniqueId: 0, value:"abc"},
1916                                                                                                   {uniqueId: 1, value:"bca"},
1917                                                                                                   {uniqueId: 2, value:"abcd"},
1918                                                                                                   {uniqueId: 3, value:"abcdefg"},
1919                                                                                                   {uniqueId: 4, value:"lmnop"},
1920                                                                                                   {uniqueId: 5, value:"foghorn"},
1921                                                                                                   {uniqueId: 6, value:"qberty"},
1922                                                                                                   {uniqueId: 7, value:"qwerty"},
1923                                                                                                   {uniqueId: 8 },  //Deliberate undefined value
1924                                                                                                   {uniqueId: 9, value:"seaweed"},
1925                                                                                                   {uniqueId: 10, value:"123abc"}
1926
1927                                                                                                 ]
1928                                                                            }
1929                                                                 });
1930
1931                         var d = new doh.Deferred();
1932                         function completed(items, request){
1933                                 //Output should be in this order...
1934                                 var orderedArray = [10,0,2,3,1,5,4,6,7,9,8];
1935                                 t.assertEqual(items.length, 11);
1936                                 var passed = true;
1937                                 for(var i = 0; i < items.length; i++){
1938                                         if(!(store.getValue(items[i], "uniqueId") === orderedArray[i])){
1939                                                 passed=false;
1940                                                 break;
1941                                         }
1942                                 }
1943                                 t.assertTrue(passed);
1944                                 if (passed){
1945                                         d.callback(true);
1946                                 }else{
1947                                         d.errback(new Error("Unexpected sorting order found, sort failure."));
1948                                 }
1949                         }
1950
1951                         function error(error, request) {
1952                                 t.assertTrue(false);
1953                                 d.errback(error);
1954                         }
1955
1956                         var sortAttributes = [{attribute: "value"}];
1957                         store.fetch({onComplete: completed, onError: error, sort: sortAttributes});
1958                         return d;
1959                 }
1960         },
1961         {
1962                 name: "Read API: errorCondition_idCollision_inMemory",
1963                 runTest: function(datastore, t){
1964                         //      summary:
1965                         //              Simple test of the errors thrown when there is an id collision in the data.
1966                         //              Added because of tracker: #2546
1967                         //      description:
1968                         //              Simple test of the errors thrown when there is an id collision in the data.
1969                         //              Added because of tracker: #2546
1970
1971                         var store = new datastore({     data: { identifier: "uniqueId",
1972                                                                                                                                 items: [{uniqueId: 12345, value:"foo"},
1973                                                                                                                                                 {uniqueId: 123456, value:"bar"},
1974                                                                                                                                                 {uniqueId: 12345, value:"boom"},
1975                                                                                                                                                 {uniqueId: 123457, value:"bit"}
1976                                                                                                                                         ]
1977                                                                                                                                 }
1978                                                                                                                         });
1979                         var d = new doh.Deferred();
1980                         function onComplete(items, request){
1981                                 //This is bad if this fires, this case should fail and not call onComplete.
1982                                 t.assertTrue(false);
1983                                 d.callback(false);
1984                         }
1985
1986                         function reportError(errData, request){
1987                                 //This is good if this fires, it is expected.
1988                                 t.assertTrue(true);
1989                                 d.callback(true);
1990                         }
1991                         store.fetch({onComplete: onComplete, onError: reportError});
1992                         return d;
1993                 }
1994         },
1995         {
1996                 name: "Read API: errorCondition_idCollision_xhr",
1997                 runTest: function(datastore, t){
1998                         //      summary:
1999                         //              Simple test of the errors thrown when there is an id collision in the data.
2000                         //              Added because of tracker: #2546
2001                         //      description:
2002                         //              Simple test of the errors thrown when there is an id collision in the data.
2003                         //              Added because of tracker: #2546
2004
2005                         if(dojo.isBrowser){
2006                                 var store = new datastore({url: dojo.moduleUrl("tests", "data/countries_idcollision.json").toString() });
2007                                 var d = new doh.Deferred();
2008                                 function onComplete(items, request){
2009                                         //This is bad if this fires, this case should fail and not call onComplete.
2010                                         t.assertTrue(false);
2011                                         d.callback(false);
2012                                 }
2013
2014                                 function reportError(errData, request){
2015                                         //This is good if this fires, it is expected.
2016                                         t.assertTrue(true);
2017                                         d.callback(true);
2018                                 }
2019                                 store.fetch({onComplete: onComplete, onError: reportError});
2020                                 return d;
2021                         }
2022                 }
2023         },
2024         {
2025                 name: "Read API: Date_datatype",
2026                 runTest: function(datastore, t){
2027                         //var store = new datastore(tests.data.readOnlyItemFileTestTemplates.testFile["countries_withDates"]);
2028                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries_withDates"));
2029
2030                         var d = new doh.Deferred();
2031                         function onItem(item){
2032                                 t.assertTrue(item !== null);
2033                                 var independenceDate = store.getValue(item, "independence");
2034                                 t.assertTrue(independenceDate instanceof Date);
2035                                 //Check to see if the value was deserialized properly.  Since the store stores in UTC/GMT, it
2036                                 //should also be compared in the UTC/GMT mode
2037                                 t.assertTrue(dojo.date.stamp.toISOString(independenceDate, {zulu:true}) === "1993-05-24T00:00:00Z");
2038                                 d.callback(true);
2039                         }
2040                         function onError(errData){
2041                                 t.assertTrue(false);
2042                                 d.errback(errData);
2043                         }
2044                         store.fetchItemByIdentity({identity:"er", onItem:onItem, onError:onError});
2045                         return d; // Deferred
2046                 }
2047         },
2048         {
2049                 name: "Read API: custom_datatype_Color_SimpleMapping",
2050                 runTest: function(datastore, t){
2051                         //      summary:
2052                         //              Function to test using literal values with custom datatypes
2053                         var dataset = {
2054                                 identifier:'name',
2055                                 items: [
2056                                         { name:'Kermit', species:'frog', color:{_type:'Color', _value:'green'} },
2057                                         { name:'Beaker', hairColor:{_type:'Color', _value:'red'} }
2058                                 ]
2059                         };
2060                         var store = new datastore({
2061                                         data:dataset,
2062                                         typeMap:{'Color': dojo.Color}
2063                         });
2064                         var d = new doh.Deferred();
2065                         function onItem(item){
2066                                 t.assertTrue(item !== null);
2067                                 var beaker = item;
2068                                 var hairColor = store.getValue(beaker, "hairColor");
2069                                 t.assertTrue(hairColor instanceof dojo.Color);
2070                                 t.assertTrue(hairColor.toHex() == "#ff0000");
2071                                 d.callback(true);
2072                         }
2073                         function onError(errData){
2074                                 d.errback(errData);
2075                         }
2076                         store.fetchItemByIdentity({identity:"Beaker", onItem:onItem, onError:onError});
2077                         return d; // Deferred
2078                 }
2079         },
2080         {
2081                 name: "Read API: custom_datatype_Color_GeneralMapping",
2082                 runTest: function(datastore, t){
2083                         //      summary:
2084                         //              Function to test using literal values with custom datatypes
2085                         var dataset = {
2086                                 identifier:'name',
2087                                 items: [
2088                                         { name:'Kermit', species:'frog', color:{_type:'Color', _value:'green'} },
2089                                         { name:'Beaker', hairColor:{_type:'Color', _value:'red'} }
2090                                 ]
2091                         };
2092                         var store = new datastore({
2093                                         data:dataset,
2094                                         typeMap:{'Color':       {
2095                                                                                         type: dojo.Color,
2096                                                                                         deserialize: function(value){
2097                                                                                                 return new dojo.Color(value);
2098                                                                                         }
2099                                                                                 }
2100                                                         }
2101                         });
2102                         var d = new doh.Deferred();
2103                         function onItem(item){
2104                                 t.assertTrue(item !== null);
2105                                 var beaker = item;
2106                                 var hairColor = store.getValue(beaker, "hairColor");
2107                                 t.assertTrue(hairColor instanceof dojo.Color);
2108                                 t.assertTrue(hairColor.toHex() == "#ff0000");
2109                                 d.callback(true);
2110                         }
2111                         function onError(errData){
2112                                 d.errback(errData);
2113                         }
2114                         store.fetchItemByIdentity({identity:"Beaker", onItem:onItem, onError:onError});
2115                         return d; // Deferred
2116                 }
2117         },
2118         {
2119                 name: "Read API: hierarchical_data",
2120                 runTest: function(datastore, t){
2121                         //var store = new datastore(tests.data.readOnlyItemFileTestTemplates.testFile["geography_hierarchy_small"]);
2122                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
2123                         var d = new doh.Deferred();
2124                         function onComplete(items, request){
2125                                 t.assertEqual(items.length, 1);
2126                                 var northAmerica = items[0];
2127                                 var canada = store.getValue(northAmerica, "countries");
2128                                 var toronto = store.getValue(canada, "cities");
2129                                 t.assertEqual(store.getValue(canada, "name"), "Canada");
2130                                 t.assertEqual(store.getValue(toronto, "name"), "Toronto");
2131                                 d.callback(true);
2132                         }
2133                         function onError(errData){
2134                                 d.errback(errData);
2135                         }
2136                         store.fetch({
2137                                 query: {name: "North America"},
2138                                 onComplete: onComplete,
2139                                 onError: onError
2140                         });
2141
2142                         return d; // Deferred
2143                 }
2144         },
2145         {
2146                 name: "Identity API: no_identifier_specified",
2147                 runTest: function(datastore, t){
2148                         var arrayOfItems = [
2149                                 {name:"Kermit", color:"green"},
2150                                 {name:"Miss Piggy", likes:"Kermit"},
2151                                 {name:"Beaker", hairColor:"red"}
2152                         ];
2153                         var store = new datastore({data:{items:arrayOfItems}});
2154                         var d = new doh.Deferred();
2155                         function onComplete(items, request){
2156                                 var features = store.getFeatures();
2157                                 var hasIdentityFeature = Boolean(features['dojo.data.api.Identity']);
2158                                 t.assertTrue(hasIdentityFeature);
2159                                 for(var i = 0; i < items.length; ++i){
2160                                         var item = items[i];
2161                                         var identifier = store.getIdentityAttributes(item);
2162                                         t.assertTrue(identifier === null);
2163                                         var identity = store.getIdentity(item);
2164                                         t.assertTrue(typeof identity == "number");
2165                                 }
2166                                 d.callback(true);
2167                         }
2168                         function reportError(errData, request){
2169                                 d.errback(true);
2170                         }
2171                         store.fetch({onComplete: onComplete, onError: reportError});
2172                         return d; // Deferred
2173                 }
2174         },
2175         {
2176                 name: "Identity API: hierarchical_data",
2177                 runTest: function(datastore, t){
2178                         var store = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("geography_hierarchy_small"));
2179                         var d = new doh.Deferred();
2180                         function onComplete(items, request){
2181                                 var features = store.getFeatures();
2182                                 var hasIdentityFeature = Boolean(features['dojo.data.api.Identity']);
2183                                 t.assertTrue(hasIdentityFeature);
2184                                 for(var i = 0; i < items.length; ++i){
2185                                         var item = items[i];
2186                                         var identifier = store.getIdentityAttributes(item);
2187                                         t.assertTrue(identifier === null);
2188                                         var identity = store.getIdentity(item);
2189                                         t.assertTrue(typeof identity == "number");
2190                                 }
2191                                 d.callback(true);
2192                         }
2193                         function reportError(errData, request){
2194                                 d.errback(true);
2195                         }
2196                         store.fetch({onComplete: onComplete, onError: reportError});
2197                         return d; // Deferred
2198                 }
2199         },
2200         {
2201                 name: "Read API: functionConformance",
2202                 runTest: function(datastore, t){
2203                         //      summary:
2204                         //              Simple test read API conformance.  Checks to see all declared functions are actual functions on the instances.
2205                         //      description:
2206                         //              Simple test read API conformance.  Checks to see all declared functions are actual functions on the instances.
2207                         var testStore = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
2208                         var readApi = new dojo.data.api.Read();
2209                         var passed = true;
2210
2211                         for(i in readApi){
2212                                 if(i.toString().charAt(0) !== '_')
2213                                 {
2214                                         var member = readApi[i];
2215                                         //Check that all the 'Read' defined functions exist on the test store.
2216                                         if(typeof member === "function"){
2217                                                 var testStoreMember = testStore[i];
2218                                                 if(!(typeof testStoreMember === "function")){
2219                                                         passed = false;
2220                                                         break;
2221                                                 }
2222                                         }
2223                                 }
2224                         }
2225                         t.assertTrue(passed);
2226                 }
2227         },
2228         {
2229                 name: "Identity API: functionConformance",
2230                 runTest: function(datastore, t){
2231                         //      summary:
2232                         //              Simple test identity API conformance.  Checks to see all declared functions are actual functions on the instances.
2233                         //      description:
2234                         //              Simple test identity API conformance.  Checks to see all declared functions are actual functions on the instances.
2235                         var testStore = new datastore(tests.data.readOnlyItemFileTestTemplates.getTestData("countries"));
2236                         var identityApi = new dojo.data.api.Identity();
2237                         var passed = true;
2238
2239                         for(i in identityApi){
2240
2241                                 if(i.toString().charAt(0) !== '_')
2242                                 {
2243                                         var member = identityApi[i];
2244                                         //Check that all the 'Read' defined functions exist on the test store.
2245                                         if(typeof member === "function"){
2246                                                 var testStoreMember = testStore[i];
2247                                                 if(!(typeof testStoreMember === "function")){
2248                                                         passed = false;
2249                                                         break;
2250                                                 }
2251                                         }
2252                                 }
2253                         }
2254                         t.assertTrue(passed);
2255                 }
2256         }
2257 ];
2258
2259
2260 }