dom/indexedDB/test/unit/test_count.js

   1 /**
   2  * Any copyright is dedicated to the Public Domain.
   3  * http://creativecommons.org/publicdomain/zero/1.0/
   4  */
   5
   6 /* exported testGenerator */
   7 var testGenerator = testSteps();
   8
   9 function* testSteps() {
  10   const name = this.window ? window.location.pathname : "Splendid Test";
  11   const objectStoreName = "People";
  12
  13   const objectStoreData = [
  14     { key: "237-23-7732", value: { name: "Bob", height: 60, weight: 120 } },
  15     { key: "237-23-7733", value: { name: "Ann", height: 52, weight: 110 } },
  16     { key: "237-23-7734", value: { name: "Ron", height: 73, weight: 180 } },
  17     { key: "237-23-7735", value: { name: "Sue", height: 58, weight: 130 } },
  18     { key: "237-23-7736", value: { name: "Joe", height: 65, weight: 150 } },
  19     { key: "237-23-7737", value: { name: "Pat", height: 65 } },
  20     { key: "237-23-7738", value: { name: "Mel", height: 66, weight: {} } },
  21     { key: "237-23-7739", value: { name: "Tom", height: 62, weight: 130 } },
  22   ];
  23
  24   const indexData = {
  25     name: "weight",
  26     keyPath: "weight",
  27     options: { unique: false },
  28   };
  29
  30   const weightSort = [1, 0, 3, 7, 4, 2];
  31
  32   let request = indexedDB.open(name, 1);
  33   request.onerror = errorHandler;
  34   request.onupgradeneeded = grabEventAndContinueHandler;
  35   request.onsuccess = grabEventAndContinueHandler;
  36   let event = yield undefined;
  37
  38   is(event.type, "upgradeneeded", "Got correct event type");
  39
  40   let db = event.target.result;
  41   db.onerror = errorHandler;
  42
  43   let objectStore = db.createObjectStore(objectStoreName, {});
  44   objectStore.createIndex(indexData.name, indexData.keyPath, indexData.options);
  45
  46   for (let data of objectStoreData) {
  47     objectStore.add(data.value, data.key);
  48   }
  49
  50   event = yield undefined;
  51
  52   is(event.type, "success", "Got correct event type");
  53
  54   objectStore = db
  55     .transaction(db.objectStoreNames)
  56     .objectStore(objectStoreName);
  57
  58   objectStore.count().onsuccess = grabEventAndContinueHandler;
  59   event = yield undefined;
  60
  61   is(
  62     event.target.result,
  63     objectStoreData.length,
  64     "Correct number of object store entries for all keys"
  65   );
  66
  67   objectStore.count(null).onsuccess = grabEventAndContinueHandler;
  68   event = yield undefined;
  69
  70   is(
  71     event.target.result,
  72     objectStoreData.length,
  73     "Correct number of object store entries for null key"
  74   );
  75
  76   objectStore.count(
  77     objectStoreData[2].key
  78   ).onsuccess = grabEventAndContinueHandler;
  79   event = yield undefined;
  80
  81   is(
  82     event.target.result,
  83     1,
  84     "Correct number of object store entries for single existing key"
  85   );
  86
  87   objectStore.count("foo").onsuccess = grabEventAndContinueHandler;
  88   event = yield undefined;
  89
  90   is(
  91     event.target.result,
  92     0,
  93     "Correct number of object store entries for single non-existing key"
  94   );
  95
  96   let keyRange = IDBKeyRange.only(objectStoreData[2].key);
  97   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
  98   event = yield undefined;
  99
 100   is(
 101     event.target.result,
 102     1,
 103     "Correct number of object store entries for existing only keyRange"
 104   );
 105
 106   keyRange = IDBKeyRange.only("foo");
 107   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 108   event = yield undefined;
 109
 110   is(
 111     event.target.result,
 112     0,
 113     "Correct number of object store entries for non-existing only keyRange"
 114   );
 115
 116   keyRange = IDBKeyRange.lowerBound(objectStoreData[2].key);
 117   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 118   event = yield undefined;
 119
 120   is(
 121     event.target.result,
 122     objectStoreData.length - 2,
 123     "Correct number of object store entries for lowerBound keyRange"
 124   );
 125
 126   keyRange = IDBKeyRange.lowerBound(objectStoreData[2].key, true);
 127   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 128   event = yield undefined;
 129
 130   is(
 131     event.target.result,
 132     objectStoreData.length - 3,
 133     "Correct number of object store entries for lowerBound keyRange"
 134   );
 135
 136   keyRange = IDBKeyRange.lowerBound("foo");
 137   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 138   event = yield undefined;
 139
 140   is(
 141     event.target.result,
 142     0,
 143     "Correct number of object store entries for lowerBound keyRange"
 144   );
 145
 146   keyRange = IDBKeyRange.upperBound(objectStoreData[2].key, false);
 147   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 148   event = yield undefined;
 149
 150   is(
 151     event.target.result,
 152     3,
 153     "Correct number of object store entries for upperBound keyRange"
 154   );
 155
 156   keyRange = IDBKeyRange.upperBound(objectStoreData[2].key, true);
 157   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 158   event = yield undefined;
 159
 160   is(
 161     event.target.result,
 162     2,
 163     "Correct number of object store entries for upperBound keyRange"
 164   );
 165
 166   keyRange = IDBKeyRange.upperBound("foo", true);
 167   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 168   event = yield undefined;
 169
 170   is(
 171     event.target.result,
 172     objectStoreData.length,
 173     "Correct number of object store entries for upperBound keyRange"
 174   );
 175
 176   keyRange = IDBKeyRange.bound(
 177     objectStoreData[0].key,
 178     objectStoreData[objectStoreData.length - 1].key
 179   );
 180   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 181   event = yield undefined;
 182
 183   is(
 184     event.target.result,
 185     objectStoreData.length,
 186     "Correct number of object store entries for bound keyRange"
 187   );
 188
 189   keyRange = IDBKeyRange.bound(
 190     objectStoreData[0].key,
 191     objectStoreData[objectStoreData.length - 1].key,
 192     true
 193   );
 194   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 195   event = yield undefined;
 196
 197   is(
 198     event.target.result,
 199     objectStoreData.length - 1,
 200     "Correct number of object store entries for bound keyRange"
 201   );
 202
 203   keyRange = IDBKeyRange.bound(
 204     objectStoreData[0].key,
 205     objectStoreData[objectStoreData.length - 1].key,
 206     true,
 207     true
 208   );
 209   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 210   event = yield undefined;
 211
 212   is(
 213     event.target.result,
 214     objectStoreData.length - 2,
 215     "Correct number of object store entries for bound keyRange"
 216   );
 217
 218   keyRange = IDBKeyRange.bound("foo", "foopy", true, true);
 219   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 220   event = yield undefined;
 221
 222   is(
 223     event.target.result,
 224     0,
 225     "Correct number of object store entries for bound keyRange"
 226   );
 227
 228   keyRange = IDBKeyRange.bound(objectStoreData[0].key, "foo", true, true);
 229   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;
 230   event = yield undefined;
 231
 232   is(
 233     event.target.result,
 234     objectStoreData.length - 1,
 235     "Correct number of object store entries for bound keyRange"
 236   );
 237
 238   let index = objectStore.index(indexData.name);
 239
 240   index.count().onsuccess = grabEventAndContinueHandler;
 241   event = yield undefined;
 242
 243   is(
 244     event.target.result,
 245     weightSort.length,
 246     "Correct number of index entries for no key"
 247   );
 248
 249   index.count(
 250     objectStoreData[7].value.weight
 251   ).onsuccess = grabEventAndContinueHandler;
 252   event = yield undefined;
 253
 254   is(
 255     event.target.result,
 256     2,
 257     "Correct number of index entries for duplicate key"
 258   );
 259
 260   index.count(
 261     objectStoreData[0].value.weight
 262   ).onsuccess = grabEventAndContinueHandler;
 263   event = yield undefined;
 264
 265   is(event.target.result, 1, "Correct number of index entries for single key");
 266
 267   keyRange = IDBKeyRange.only(objectStoreData[0].value.weight);
 268   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 269   event = yield undefined;
 270
 271   is(
 272     event.target.result,
 273     1,
 274     "Correct number of index entries for only existing keyRange"
 275   );
 276
 277   keyRange = IDBKeyRange.only("foo");
 278   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 279   event = yield undefined;
 280
 281   is(
 282     event.target.result,
 283     0,
 284     "Correct number of index entries for only non-existing keyRange"
 285   );
 286
 287   keyRange = IDBKeyRange.only(objectStoreData[7].value.weight);
 288   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 289   event = yield undefined;
 290
 291   is(
 292     event.target.result,
 293     2,
 294     "Correct number of index entries for only duplicate keyRange"
 295   );
 296
 297   keyRange = IDBKeyRange.lowerBound(
 298     objectStoreData[weightSort[0]].value.weight
 299   );
 300   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 301   event = yield undefined;
 302
 303   is(
 304     event.target.result,
 305     weightSort.length,
 306     "Correct number of index entries for lowerBound keyRange"
 307   );
 308
 309   keyRange = IDBKeyRange.lowerBound(
 310     objectStoreData[weightSort[1]].value.weight
 311   );
 312   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 313   event = yield undefined;
 314
 315   is(
 316     event.target.result,
 317     weightSort.length - 1,
 318     "Correct number of index entries for lowerBound keyRange"
 319   );
 320
 321   keyRange = IDBKeyRange.lowerBound(
 322     objectStoreData[weightSort[0]].value.weight - 1
 323   );
 324   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 325   event = yield undefined;
 326
 327   is(
 328     event.target.result,
 329     weightSort.length,
 330     "Correct number of index entries for lowerBound keyRange"
 331   );
 332
 333   keyRange = IDBKeyRange.lowerBound(
 334     objectStoreData[weightSort[0]].value.weight,
 335     true
 336   );
 337   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 338   event = yield undefined;
 339
 340   is(
 341     event.target.result,
 342     weightSort.length - 1,
 343     "Correct number of index entries for lowerBound keyRange"
 344   );
 345
 346   keyRange = IDBKeyRange.lowerBound(
 347     objectStoreData[weightSort[weightSort.length - 1]].value.weight
 348   );
 349   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 350   event = yield undefined;
 351
 352   is(
 353     event.target.result,
 354     1,
 355     "Correct number of index entries for lowerBound keyRange"
 356   );
 357
 358   keyRange = IDBKeyRange.lowerBound(
 359     objectStoreData[weightSort[weightSort.length - 1]].value.weight,
 360     true
 361   );
 362   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 363   event = yield undefined;
 364
 365   is(
 366     event.target.result,
 367     0,
 368     "Correct number of index entries for lowerBound keyRange"
 369   );
 370
 371   keyRange = IDBKeyRange.lowerBound(
 372     objectStoreData[weightSort[weightSort.length - 1]].value.weight + 1,
 373     true
 374   );
 375   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 376   event = yield undefined;
 377
 378   is(
 379     event.target.result,
 380     0,
 381     "Correct number of index entries for lowerBound keyRange"
 382   );
 383
 384   keyRange = IDBKeyRange.upperBound(
 385     objectStoreData[weightSort[0]].value.weight
 386   );
 387   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 388   event = yield undefined;
 389
 390   is(
 391     event.target.result,
 392     1,
 393     "Correct number of index entries for upperBound keyRange"
 394   );
 395
 396   keyRange = IDBKeyRange.upperBound(
 397     objectStoreData[weightSort[0]].value.weight,
 398     true
 399   );
 400   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 401   event = yield undefined;
 402
 403   is(
 404     event.target.result,
 405     0,
 406     "Correct number of index entries for upperBound keyRange"
 407   );
 408
 409   keyRange = IDBKeyRange.upperBound(
 410     objectStoreData[weightSort[weightSort.length - 1]].value.weight
 411   );
 412   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 413   event = yield undefined;
 414
 415   is(
 416     event.target.result,
 417     weightSort.length,
 418     "Correct number of index entries for upperBound keyRange"
 419   );
 420
 421   keyRange = IDBKeyRange.upperBound(
 422     objectStoreData[weightSort[weightSort.length - 1]].value.weight,
 423     true
 424   );
 425   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 426   event = yield undefined;
 427
 428   is(
 429     event.target.result,
 430     weightSort.length - 1,
 431     "Correct number of index entries for upperBound keyRange"
 432   );
 433
 434   keyRange = IDBKeyRange.upperBound(
 435     objectStoreData[weightSort[weightSort.length - 1]].value.weight,
 436     true
 437   );
 438   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 439   event = yield undefined;
 440
 441   is(
 442     event.target.result,
 443     weightSort.length - 1,
 444     "Correct number of index entries for upperBound keyRange"
 445   );
 446
 447   keyRange = IDBKeyRange.upperBound("foo");
 448   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 449   event = yield undefined;
 450
 451   is(
 452     event.target.result,
 453     weightSort.length,
 454     "Correct number of index entries for upperBound keyRange"
 455   );
 456
 457   keyRange = IDBKeyRange.bound("foo", "foopy");
 458   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 459   event = yield undefined;
 460
 461   is(
 462     event.target.result,
 463     0,
 464     "Correct number of index entries for bound keyRange"
 465   );
 466
 467   keyRange = IDBKeyRange.bound(
 468     objectStoreData[weightSort[0]].value.weight,
 469     objectStoreData[weightSort[weightSort.length - 1]].value.weight
 470   );
 471   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 472   event = yield undefined;
 473
 474   is(
 475     event.target.result,
 476     weightSort.length,
 477     "Correct number of index entries for bound keyRange"
 478   );
 479
 480   keyRange = IDBKeyRange.bound(
 481     objectStoreData[weightSort[0]].value.weight,
 482     objectStoreData[weightSort[weightSort.length - 1]].value.weight,
 483     true
 484   );
 485   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 486   event = yield undefined;
 487
 488   is(
 489     event.target.result,
 490     weightSort.length - 1,
 491     "Correct number of index entries for bound keyRange"
 492   );
 493
 494   keyRange = IDBKeyRange.bound(
 495     objectStoreData[weightSort[0]].value.weight,
 496     objectStoreData[weightSort[weightSort.length - 1]].value.weight,
 497     true,
 498     true
 499   );
 500   index.count(keyRange).onsuccess = grabEventAndContinueHandler;
 501   event = yield undefined;
 502
 503   is(
 504     event.target.result,
 505     weightSort.length - 2,
 506     "Correct number of index entries for bound keyRange"
 507   );
 508
 509   finishTest();
 510 }