tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

test_cursors.js (8849B)

      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  function checkCursor(cursor, expectedKey) {
     11    is(cursor.key, expectedKey, "Correct key");
     12    is(cursor.primaryKey, expectedKey, "Correct primary key");
     13    is(cursor.value, "foo", "Correct value");
     14  }
     15 
     16  const name = this.window ? window.location.pathname : "Splendid Test";
     17  const keys = [1, -1, 0, 10, 2000, "q", "z", "two", "b", "a"];
     18  const sortedKeys = [-1, 0, 1, 10, 2000, "a", "b", "q", "two", "z"];
     19 
     20  is(keys.length, sortedKeys.length, "Good key setup");
     21 
     22  let request = indexedDB.open(name, 1);
     23  request.onerror = errorHandler;
     24  request.onupgradeneeded = grabEventAndContinueHandler;
     25  request.onsuccess = grabEventAndContinueHandler;
     26  let event = yield undefined;
     27 
     28  let db = event.target.result;
     29 
     30  let objectStore = db.createObjectStore("autoIncrement", {
     31    autoIncrement: true,
     32  });
     33 
     34  request = objectStore.openCursor();
     35  request.onerror = errorHandler;
     36  request.onsuccess = function (event) {
     37    ok(!event.target.result, "No results");
     38    testGenerator.next();
     39  };
     40  yield undefined;
     41 
     42  objectStore = db.createObjectStore("autoIncrementKeyPath", {
     43    keyPath: "foo",
     44    autoIncrement: true,
     45  });
     46 
     47  request = objectStore.openCursor();
     48  request.onerror = errorHandler;
     49  request.onsuccess = function (event) {
     50    ok(!event.target.result, "No results");
     51    testGenerator.next();
     52  };
     53  yield undefined;
     54 
     55  objectStore = db.createObjectStore("keyPath", { keyPath: "foo" });
     56 
     57  request = objectStore.openCursor();
     58  request.onerror = errorHandler;
     59  request.onsuccess = function (event) {
     60    ok(!event.target.result, "No results");
     61    testGenerator.next();
     62  };
     63  yield undefined;
     64 
     65  objectStore = db.createObjectStore("foo");
     66 
     67  request = objectStore.openCursor();
     68  request.onerror = errorHandler;
     69  request.onsuccess = function (event) {
     70    ok(!event.target.result, "No results");
     71    testGenerator.next();
     72  };
     73  yield undefined;
     74 
     75  let keyIndex = 0;
     76 
     77  for (let i in keys) {
     78    request = objectStore.add("foo", keys[i]);
     79    request.onerror = errorHandler;
     80    request.onsuccess = function () {
     81      if (++keyIndex == keys.length) {
     82        testGenerator.next();
     83      }
     84    };
     85  }
     86  yield undefined;
     87 
     88  keyIndex = 0;
     89 
     90  request = objectStore.openCursor();
     91  request.onerror = errorHandler;
     92  request.onsuccess = function (event) {
     93    let cursor = event.target.result;
     94    if (cursor) {
     95      checkCursor(cursor, sortedKeys[keyIndex]);
     96 
     97      cursor.continue();
     98 
     99      try {
    100        cursor.continue();
    101        ok(false, "continue twice should throw");
    102      } catch (e) {
    103        ok(e instanceof DOMException, "got a database exception");
    104        is(e.name, "InvalidStateError", "correct error");
    105        is(e.code, DOMException.INVALID_STATE_ERR, "correct code");
    106      }
    107 
    108      checkCursor(cursor, sortedKeys[keyIndex]);
    109 
    110      keyIndex++;
    111    } else {
    112      testGenerator.next();
    113    }
    114  };
    115  yield undefined;
    116 
    117  is(keyIndex, keys.length, "Saw all added items");
    118 
    119  keyIndex = 4;
    120 
    121  let range = IDBKeyRange.bound(2000, "q");
    122  request = objectStore.openCursor(range);
    123  request.onerror = errorHandler;
    124  request.onsuccess = function (event) {
    125    let cursor = event.target.result;
    126    if (cursor) {
    127      checkCursor(cursor, sortedKeys[keyIndex]);
    128 
    129      cursor.continue();
    130 
    131      checkCursor(cursor, sortedKeys[keyIndex]);
    132 
    133      keyIndex++;
    134    } else {
    135      testGenerator.next();
    136    }
    137  };
    138  yield undefined;
    139 
    140  is(keyIndex, 8, "Saw all the expected keys");
    141 
    142  keyIndex = 0;
    143 
    144  request = objectStore.openCursor();
    145  request.onerror = errorHandler;
    146  request.onsuccess = function (event) {
    147    let cursor = event.target.result;
    148    if (cursor) {
    149      checkCursor(cursor, sortedKeys[keyIndex]);
    150 
    151      if (keyIndex) {
    152        cursor.continue();
    153      } else {
    154        cursor.continue("b");
    155      }
    156 
    157      checkCursor(cursor, sortedKeys[keyIndex]);
    158 
    159      keyIndex += keyIndex ? 1 : 6;
    160    } else {
    161      testGenerator.next();
    162    }
    163  };
    164  yield undefined;
    165 
    166  is(keyIndex, keys.length, "Saw all the expected keys");
    167 
    168  keyIndex = 0;
    169 
    170  request = objectStore.openCursor();
    171  request.onerror = errorHandler;
    172  request.onsuccess = function (event) {
    173    let cursor = event.target.result;
    174    if (cursor) {
    175      checkCursor(cursor, sortedKeys[keyIndex]);
    176 
    177      if (keyIndex) {
    178        cursor.continue();
    179      } else {
    180        cursor.continue(10);
    181      }
    182 
    183      checkCursor(cursor, sortedKeys[keyIndex]);
    184 
    185      keyIndex += keyIndex ? 1 : 3;
    186    } else {
    187      testGenerator.next();
    188    }
    189  };
    190  yield undefined;
    191 
    192  is(keyIndex, keys.length, "Saw all the expected keys");
    193 
    194  keyIndex = 0;
    195 
    196  request = objectStore.openCursor();
    197  request.onerror = errorHandler;
    198  request.onsuccess = function (event) {
    199    let cursor = event.target.result;
    200    if (cursor) {
    201      checkCursor(cursor, sortedKeys[keyIndex]);
    202 
    203      if (keyIndex) {
    204        cursor.continue();
    205      } else {
    206        cursor.continue("c");
    207      }
    208 
    209      checkCursor(cursor, sortedKeys[keyIndex]);
    210 
    211      keyIndex += keyIndex ? 1 : 7;
    212    } else {
    213      ok(cursor === null, "The request result should be null.");
    214      testGenerator.next();
    215    }
    216  };
    217  yield undefined;
    218 
    219  is(keyIndex, keys.length, "Saw all the expected keys");
    220 
    221  keyIndex = 0;
    222 
    223  request = objectStore.openCursor();
    224  request.onerror = errorHandler;
    225  let storedCursor = null;
    226  request.onsuccess = function (event) {
    227    let cursor = event.target.result;
    228    if (cursor) {
    229      storedCursor = cursor;
    230 
    231      checkCursor(cursor, sortedKeys[keyIndex]);
    232 
    233      if (keyIndex == 4) {
    234        request = cursor.update("bar");
    235        request.onerror = errorHandler;
    236        request.onsuccess = function () {
    237          keyIndex++;
    238          cursor.continue();
    239        };
    240      } else {
    241        keyIndex++;
    242        cursor.continue();
    243      }
    244    } else {
    245      ok(cursor === null, "The request result should be null.");
    246      ok(
    247        storedCursor.value === undefined,
    248        "The cursor's value should be undefined."
    249      );
    250      testGenerator.next();
    251    }
    252  };
    253  yield undefined;
    254 
    255  is(keyIndex, keys.length, "Saw all the expected keys");
    256 
    257  request = objectStore.get(sortedKeys[4]);
    258  request.onerror = errorHandler;
    259  request.onsuccess = grabEventAndContinueHandler;
    260  event = yield undefined;
    261 
    262  is(event.target.result, "bar", "Update succeeded");
    263 
    264  request = objectStore.put("foo", sortedKeys[4]);
    265  request.onerror = errorHandler;
    266  request.onsuccess = grabEventAndContinueHandler;
    267  event = yield undefined;
    268 
    269  keyIndex = 0;
    270 
    271  let gotRemoveEvent = false;
    272 
    273  request = objectStore.openCursor(null, "next");
    274  request.onerror = errorHandler;
    275  storedCursor = null;
    276  request.onsuccess = function (event) {
    277    let cursor = event.target.result;
    278    if (cursor) {
    279      storedCursor = cursor;
    280 
    281      checkCursor(cursor, sortedKeys[keyIndex]);
    282 
    283      if (keyIndex == 4) {
    284        request = cursor.delete();
    285        request.onerror = errorHandler;
    286        request.onsuccess = function (event) {
    287          ok(event.target.result === undefined, "Should be undefined");
    288          is(keyIndex, 5, "Got result of delete before next continue");
    289          gotRemoveEvent = true;
    290        };
    291      }
    292 
    293      keyIndex++;
    294      cursor.continue();
    295    } else {
    296      ok(cursor === null, "The request result should be null.");
    297      ok(
    298        storedCursor.value === undefined,
    299        "The cursor's value should be undefined."
    300      );
    301      testGenerator.next();
    302    }
    303  };
    304  yield undefined;
    305 
    306  is(keyIndex, keys.length, "Saw all the expected keys");
    307  is(gotRemoveEvent, true, "Saw the remove event");
    308 
    309  request = objectStore.get(sortedKeys[4]);
    310  request.onerror = errorHandler;
    311  request.onsuccess = grabEventAndContinueHandler;
    312  event = yield undefined;
    313 
    314  is(event.target.result, undefined, "Entry was deleted");
    315 
    316  request = objectStore.add("foo", sortedKeys[4]);
    317  request.onerror = errorHandler;
    318  request.onsuccess = grabEventAndContinueHandler;
    319  event = yield undefined;
    320 
    321  keyIndex = sortedKeys.length - 1;
    322 
    323  request = objectStore.openCursor(null, "prev");
    324  request.onerror = errorHandler;
    325  storedCursor = null;
    326  request.onsuccess = function (event) {
    327    let cursor = event.target.result;
    328    if (cursor) {
    329      storedCursor = cursor;
    330 
    331      checkCursor(cursor, sortedKeys[keyIndex]);
    332 
    333      cursor.continue();
    334 
    335      checkCursor(cursor, sortedKeys[keyIndex]);
    336 
    337      keyIndex--;
    338    } else {
    339      ok(cursor === null, "The request result should be null.");
    340      ok(
    341        storedCursor.value === undefined,
    342        "The cursor's value should be undefined."
    343      );
    344      testGenerator.next();
    345    }
    346  };
    347  yield undefined;
    348 
    349  is(keyIndex, -1, "Saw all added items");
    350 
    351  // Wait for success
    352  yield undefined;
    353 
    354  db.close();
    355 
    356  finishTest();
    357 }