The Tor Browser: dom/indexedDB/test/unit/test

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 /**

     2  * Any copyright is dedicated to the Public Domain.

     3  * http://creativecommons.org/publicdomain/zero/1.0/

     4  */

     6 var testGenerator = testSteps();

     8 function testSteps()

9 {

    10   const name = this.window ? window.location.pathname : "Splendid Test";

    11   const objectStoreName = "People";

    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   ];

    24   const indexData = {

    25     name: "weight",

    26     keyPath: "weight",

    27     options: { unique: false }

    28   };

    30   const weightSort = [1, 0, 3, 7, 4, 2];

    32   let request = indexedDB.open(name, 1);

    33   request.onerror = errorHandler;

    34   request.onupgradeneeded = grabEventAndContinueHandler;

    35   request.onsuccess = grabEventAndContinueHandler;

    36   let event = yield undefined;

    38   is(event.type, "upgradeneeded", "Got correct event type");

    40   let db = event.target.result;

    41   db.onerror = errorHandler;

    43   let objectStore = db.createObjectStore(objectStoreName, { });

    44   objectStore.createIndex(indexData.name, indexData.keyPath,

    45                           indexData.options);

    47   for each (let data in objectStoreData) {

    48     objectStore.add(data.value, data.key);

    49   }

    51   event = yield undefined;

    53   is(event.type, "success", "Got correct event type");

    55   objectStore = db.transaction(db.objectStoreNames)

    56                   .objectStore(objectStoreName);

    58   objectStore.count().onsuccess = grabEventAndContinueHandler;

    59   event = yield undefined;

    61   is(event.target.result, objectStoreData.length,

    62      "Correct number of object store entries for all keys");

    64   objectStore.count(null).onsuccess = grabEventAndContinueHandler;

    65   event = yield undefined;

    67   is(event.target.result, objectStoreData.length,

    68      "Correct number of object store entries for null key");

    70   objectStore.count(objectStoreData[2].key).onsuccess =

    71     grabEventAndContinueHandler;

    72   event = yield undefined;

    74   is(event.target.result, 1,

    75      "Correct number of object store entries for single existing key");

    77   objectStore.count("foo").onsuccess = grabEventAndContinueHandler;

    78   event = yield undefined;

    80   is(event.target.result, 0,

    81      "Correct number of object store entries for single non-existing key");

    83   let keyRange = IDBKeyRange.only(objectStoreData[2].key);

    84   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

    85   event = yield undefined;

    87   is(event.target.result, 1,

    88      "Correct number of object store entries for existing only keyRange");

    90   keyRange = IDBKeyRange.only("foo");

    91   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

    92   event = yield undefined;

    94   is(event.target.result, 0,

    95      "Correct number of object store entries for non-existing only keyRange");

    97   keyRange = IDBKeyRange.lowerBound(objectStoreData[2].key);

    98   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

    99   event = yield undefined;

   101   is(event.target.result, objectStoreData.length - 2,

   102      "Correct number of object store entries for lowerBound keyRange");

   104   keyRange = IDBKeyRange.lowerBound(objectStoreData[2].key, true);

   105   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   106   event = yield undefined;

   108   is(event.target.result, objectStoreData.length - 3,

   109      "Correct number of object store entries for lowerBound keyRange");

   111   keyRange = IDBKeyRange.lowerBound("foo");

   112   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   113   event = yield undefined;

   115   is(event.target.result, 0,

   116      "Correct number of object store entries for lowerBound keyRange");

   118   keyRange = IDBKeyRange.upperBound(objectStoreData[2].key, false);

   119   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   120   event = yield undefined;

   122   is(event.target.result, 3,

   123      "Correct number of object store entries for upperBound keyRange");

   125   keyRange = IDBKeyRange.upperBound(objectStoreData[2].key, true);

   126   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   127   event = yield undefined;

   129   is(event.target.result, 2,

   130      "Correct number of object store entries for upperBound keyRange");

   132   keyRange = IDBKeyRange.upperBound("foo", true);

   133   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   134   event = yield undefined;

   136   is(event.target.result, objectStoreData.length,

   137      "Correct number of object store entries for upperBound keyRange");

   139   keyRange = IDBKeyRange.bound(objectStoreData[0].key,

   140                                objectStoreData[objectStoreData.length - 1].key);

   141   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   142   event = yield undefined;

   144   is(event.target.result, objectStoreData.length,

   145      "Correct number of object store entries for bound keyRange");

   147   keyRange = IDBKeyRange.bound(objectStoreData[0].key,

   148                                objectStoreData[objectStoreData.length - 1].key,

   149                                true);

   150   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   151   event = yield undefined;

   153   is(event.target.result, objectStoreData.length - 1,

   154      "Correct number of object store entries for bound keyRange");

   156   keyRange = IDBKeyRange.bound(objectStoreData[0].key,

   157                                objectStoreData[objectStoreData.length - 1].key,

   158                                true, true);

   159   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   160   event = yield undefined;

   162   is(event.target.result, objectStoreData.length - 2,

   163      "Correct number of object store entries for bound keyRange");

   165   keyRange = IDBKeyRange.bound("foo", "foopy", true, true);

   166   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   167   event = yield undefined;

   169   is(event.target.result, 0,

   170      "Correct number of object store entries for bound keyRange");

   172   keyRange = IDBKeyRange.bound(objectStoreData[0].key, "foo", true, true);

   173   objectStore.count(keyRange).onsuccess = grabEventAndContinueHandler;

   174   event = yield undefined;

   176   is(event.target.result, objectStoreData.length - 1,

   177      "Correct number of object store entries for bound keyRange");

   179   let index = objectStore.index(indexData.name);

   181   index.count().onsuccess = grabEventAndContinueHandler;

   182   event = yield undefined;

   184   is(event.target.result, weightSort.length,

   185      "Correct number of index entries for no key");

   187   index.count(objectStoreData[7].value.weight).onsuccess =

   188     grabEventAndContinueHandler;

   189   event = yield undefined;

   191   is(event.target.result, 2,

   192      "Correct number of index entries for duplicate key");

   194   index.count(objectStoreData[0].value.weight).onsuccess =

   195     grabEventAndContinueHandler;

   196   event = yield undefined;

   198   is(event.target.result, 1,

   199      "Correct number of index entries for single key");

   201   keyRange = IDBKeyRange.only(objectStoreData[0].value.weight);

   202   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   203   event = yield undefined;

   205   is(event.target.result, 1,

   206      "Correct number of index entries for only existing keyRange");

   208   keyRange = IDBKeyRange.only("foo");

   209   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   210   event = yield undefined;

   212   is(event.target.result, 0,

   213      "Correct number of index entries for only non-existing keyRange");

   215   keyRange = IDBKeyRange.only(objectStoreData[7].value.weight);

   216   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   217   event = yield undefined;

   219   is(event.target.result, 2,

   220      "Correct number of index entries for only duplicate keyRange");

   222   keyRange = IDBKeyRange.lowerBound(objectStoreData[weightSort[0]].value.weight);

   223   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   224   event = yield undefined;

   226   is(event.target.result, weightSort.length,

   227      "Correct number of index entries for lowerBound keyRange");

   229   keyRange = IDBKeyRange.lowerBound(objectStoreData[weightSort[1]].value.weight);

   230   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   231   event = yield undefined;

   233   is(event.target.result, weightSort.length - 1,

   234      "Correct number of index entries for lowerBound keyRange");

   236   keyRange = IDBKeyRange.lowerBound(objectStoreData[weightSort[0]].value.weight - 1);

   237   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   238   event = yield undefined;

   240   is(event.target.result, weightSort.length,

   241      "Correct number of index entries for lowerBound keyRange");

   243   keyRange = IDBKeyRange.lowerBound(objectStoreData[weightSort[0]].value.weight,

   244                                     true);

   245   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   246   event = yield undefined;

   248   is(event.target.result, weightSort.length - 1,

   249      "Correct number of index entries for lowerBound keyRange");

   251   keyRange = IDBKeyRange.lowerBound(objectStoreData[weightSort[weightSort.length - 1]].value.weight);

   252   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   253   event = yield undefined;

   255   is(event.target.result, 1,

   256      "Correct number of index entries for lowerBound keyRange");

   258   keyRange = IDBKeyRange.lowerBound(objectStoreData[weightSort[weightSort.length - 1]].value.weight,

   259                                     true);

   260   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   261   event = yield undefined;

   263   is(event.target.result, 0,

   264      "Correct number of index entries for lowerBound keyRange");

   266   keyRange = IDBKeyRange.lowerBound(objectStoreData[weightSort[weightSort.length - 1]].value.weight + 1,

   267                                     true);

   268   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   269   event = yield undefined;

   271   is(event.target.result, 0,

   272      "Correct number of index entries for lowerBound keyRange");

   274   keyRange = IDBKeyRange.upperBound(objectStoreData[weightSort[0]].value.weight);

   275   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   276   event = yield undefined;

   278   is(event.target.result, 1,

   279      "Correct number of index entries for upperBound keyRange");

   281   keyRange = IDBKeyRange.upperBound(objectStoreData[weightSort[0]].value.weight,

   282                                     true);

   283   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   284   event = yield undefined;

   286   is(event.target.result, 0,

   287      "Correct number of index entries for upperBound keyRange");

   289   keyRange = IDBKeyRange.upperBound(objectStoreData[weightSort[weightSort.length - 1]].value.weight);

   290   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   291   event = yield undefined;

   293   is(event.target.result, weightSort.length,

   294      "Correct number of index entries for upperBound keyRange");

   296   keyRange = IDBKeyRange.upperBound(objectStoreData[weightSort[weightSort.length - 1]].value.weight,

   297                                     true);

   298   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   299   event = yield undefined;

   301   is(event.target.result, weightSort.length - 1,

   302      "Correct number of index entries for upperBound keyRange");

   304   keyRange = IDBKeyRange.upperBound(objectStoreData[weightSort[weightSort.length - 1]].value.weight,

   305                                     true);

   306   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   307   event = yield undefined;

   309   is(event.target.result, weightSort.length - 1,

   310      "Correct number of index entries for upperBound keyRange");

   312   keyRange = IDBKeyRange.upperBound("foo");

   313   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   314   event = yield undefined;

   316   is(event.target.result, weightSort.length,

   317      "Correct number of index entries for upperBound keyRange");

   319   keyRange = IDBKeyRange.bound("foo", "foopy");

   320   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   321   event = yield undefined;

   323   is(event.target.result, 0,

   324      "Correct number of index entries for bound keyRange");

   326   keyRange = IDBKeyRange.bound(objectStoreData[weightSort[0]].value.weight,

   327                                objectStoreData[weightSort[weightSort.length - 1]].value.weight);

   328   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   329   event = yield undefined;

   331   is(event.target.result, weightSort.length,

   332      "Correct number of index entries for bound keyRange");

   334   keyRange = IDBKeyRange.bound(objectStoreData[weightSort[0]].value.weight,

   335                                objectStoreData[weightSort[weightSort.length - 1]].value.weight,

   336                                true);

   337   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   338   event = yield undefined;

   340   is(event.target.result, weightSort.length - 1,

   341      "Correct number of index entries for bound keyRange");

   343   keyRange = IDBKeyRange.bound(objectStoreData[weightSort[0]].value.weight,

   344                                objectStoreData[weightSort[weightSort.length - 1]].value.weight,

   345                                true, true);

   346   index.count(keyRange).onsuccess = grabEventAndContinueHandler;

   347   event = yield undefined;

   349   is(event.target.result, weightSort.length - 2,

   350      "Correct number of index entries for bound keyRange");

   352   finishTest();

   353   yield undefined;

   354 }

The Tor Browser / file revision

dom/indexedDB/test/unit/test_count.js@129ffea94266

dom/indexedDB/test/unit/test_count.js