tor-browser

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

test_objectStore_openKeyCursor.js (9410B)

      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 dbName = this.window
     11    ? window.location.pathname
     12    : "test_objectStore_openKeyCursor";
     13  const dbVersion = 1;
     14  const objectStoreName = "foo";
     15  const keyCount = 100;
     16 
     17  let request = indexedDB.open(dbName, dbVersion);
     18  request.onerror = errorHandler;
     19  request.onupgradeneeded = grabEventAndContinueHandler;
     20  request.onsuccess = unexpectedSuccessHandler;
     21 
     22  let event = yield undefined;
     23 
     24  info("Creating database");
     25 
     26  let db = event.target.result;
     27  let objectStore = db.createObjectStore(objectStoreName);
     28  for (let i = 0; i < keyCount; i++) {
     29    objectStore.add(true, i);
     30  }
     31 
     32  request.onupgradeneeded = unexpectedSuccessHandler;
     33  request.onsuccess = grabEventAndContinueHandler;
     34 
     35  event = yield undefined;
     36 
     37  db = event.target.result;
     38  objectStore = db
     39    .transaction(objectStoreName, "readwrite")
     40    .objectStore(objectStoreName);
     41 
     42  info("Getting all keys");
     43  objectStore.getAllKeys().onsuccess = grabEventAndContinueHandler;
     44  event = yield undefined;
     45 
     46  const allKeys = event.target.result;
     47 
     48  ok(Array.isArray(allKeys), "Got an array result");
     49  is(allKeys.length, keyCount, "Got correct array length");
     50 
     51  info("Opening normal key cursor");
     52 
     53  let seenKeys = [];
     54  objectStore.openKeyCursor().onsuccess = event => {
     55    let cursor = event.target.result;
     56    if (!cursor) {
     57      continueToNextStepSync();
     58      return;
     59    }
     60 
     61    is(cursor.source, objectStore, "Correct source");
     62    is(cursor.direction, "next", "Correct direction");
     63 
     64    let exception = null;
     65    try {
     66      cursor.update(10);
     67    } catch (e) {
     68      exception = e;
     69    }
     70    ok(!!exception, "update() throws for key cursor");
     71 
     72    exception = null;
     73    try {
     74      cursor.delete();
     75    } catch (e) {
     76      exception = e;
     77    }
     78    ok(!!exception, "delete() throws for key cursor");
     79 
     80    is(cursor.key, cursor.primaryKey, "key and primaryKey match");
     81    ok(!("value" in cursor), "No 'value' property on key cursor");
     82 
     83    seenKeys.push(cursor.key);
     84    cursor.continue();
     85  };
     86  yield undefined;
     87 
     88  is(seenKeys.length, allKeys.length, "Saw the right number of keys");
     89 
     90  let match = true;
     91  for (let i = 0; i < seenKeys.length; i++) {
     92    if (seenKeys[i] !== allKeys[i]) {
     93      match = false;
     94      break;
     95    }
     96  }
     97  ok(match, "All keys matched");
     98 
     99  info("Opening key cursor with keyRange");
    100 
    101  let keyRange = IDBKeyRange.bound(10, 20, false, true);
    102 
    103  seenKeys = [];
    104  objectStore.openKeyCursor(keyRange).onsuccess = event => {
    105    let cursor = event.target.result;
    106    if (!cursor) {
    107      continueToNextStepSync();
    108      return;
    109    }
    110 
    111    is(cursor.source, objectStore, "Correct source");
    112    is(cursor.direction, "next", "Correct direction");
    113 
    114    let exception = null;
    115    try {
    116      cursor.update(10);
    117    } catch (e) {
    118      exception = e;
    119    }
    120    ok(!!exception, "update() throws for key cursor");
    121 
    122    exception = null;
    123    try {
    124      cursor.delete();
    125    } catch (e) {
    126      exception = e;
    127    }
    128    ok(!!exception, "delete() throws for key cursor");
    129 
    130    is(cursor.key, cursor.primaryKey, "key and primaryKey match");
    131    ok(!("value" in cursor), "No 'value' property on key cursor");
    132 
    133    seenKeys.push(cursor.key);
    134    cursor.continue();
    135  };
    136  yield undefined;
    137 
    138  is(seenKeys.length, 10, "Saw the right number of keys");
    139 
    140  match = true;
    141  for (let i = 0; i < seenKeys.length; i++) {
    142    if (seenKeys[i] !== allKeys[i + 10]) {
    143      match = false;
    144      break;
    145    }
    146  }
    147  ok(match, "All keys matched");
    148 
    149  info("Opening key cursor with unmatched keyRange");
    150 
    151  keyRange = IDBKeyRange.bound(10000, 200000);
    152 
    153  seenKeys = [];
    154  objectStore.openKeyCursor(keyRange).onsuccess = event => {
    155    let cursor = event.target.result;
    156    if (!cursor) {
    157      continueToNextStepSync();
    158      return;
    159    }
    160 
    161    ok(false, "Shouldn't have any keys here");
    162    cursor.continue();
    163  };
    164  yield undefined;
    165 
    166  is(seenKeys.length, 0, "Saw the right number of keys");
    167 
    168  info("Opening reverse key cursor");
    169 
    170  seenKeys = [];
    171  objectStore.openKeyCursor(null, "prev").onsuccess = event => {
    172    let cursor = event.target.result;
    173    if (!cursor) {
    174      continueToNextStepSync();
    175      return;
    176    }
    177 
    178    is(cursor.source, objectStore, "Correct source");
    179    is(cursor.direction, "prev", "Correct direction");
    180 
    181    let exception = null;
    182    try {
    183      cursor.update(10);
    184    } catch (e) {
    185      exception = e;
    186    }
    187    ok(!!exception, "update() throws for key cursor");
    188 
    189    exception = null;
    190    try {
    191      cursor.delete();
    192    } catch (e) {
    193      exception = e;
    194    }
    195    ok(!!exception, "delete() throws for key cursor");
    196 
    197    is(cursor.key, cursor.primaryKey, "key and primaryKey match");
    198    ok(!("value" in cursor), "No 'value' property on key cursor");
    199 
    200    seenKeys.push(cursor.key);
    201    cursor.continue();
    202  };
    203  yield undefined;
    204 
    205  is(seenKeys.length, allKeys.length, "Saw the right number of keys");
    206 
    207  seenKeys.reverse();
    208 
    209  match = true;
    210  for (let i = 0; i < seenKeys.length; i++) {
    211    if (seenKeys[i] !== allKeys[i]) {
    212      match = false;
    213      break;
    214    }
    215  }
    216  ok(match, "All keys matched");
    217 
    218  info("Opening reverse key cursor with key range");
    219 
    220  keyRange = IDBKeyRange.bound(10, 20, false, true);
    221 
    222  seenKeys = [];
    223  objectStore.openKeyCursor(keyRange, "prev").onsuccess = event => {
    224    let cursor = event.target.result;
    225    if (!cursor) {
    226      continueToNextStepSync();
    227      return;
    228    }
    229 
    230    is(cursor.source, objectStore, "Correct source");
    231    is(cursor.direction, "prev", "Correct direction");
    232 
    233    let exception = null;
    234    try {
    235      cursor.update(10);
    236    } catch (e) {
    237      exception = e;
    238    }
    239    ok(!!exception, "update() throws for key cursor");
    240 
    241    exception = null;
    242    try {
    243      cursor.delete();
    244    } catch (e) {
    245      exception = e;
    246    }
    247    ok(!!exception, "delete() throws for key cursor");
    248 
    249    is(cursor.key, cursor.primaryKey, "key and primaryKey match");
    250    ok(!("value" in cursor), "No 'value' property on key cursor");
    251 
    252    seenKeys.push(cursor.key);
    253    cursor.continue();
    254  };
    255  yield undefined;
    256 
    257  is(seenKeys.length, 10, "Saw the right number of keys");
    258 
    259  seenKeys.reverse();
    260 
    261  match = true;
    262  for (let i = 0; i < 10; i++) {
    263    if (seenKeys[i] !== allKeys[i + 10]) {
    264      match = false;
    265      break;
    266    }
    267  }
    268  ok(match, "All keys matched");
    269 
    270  info("Opening reverse key cursor with unmatched key range");
    271 
    272  keyRange = IDBKeyRange.bound(10000, 200000);
    273 
    274  seenKeys = [];
    275  objectStore.openKeyCursor(keyRange, "prev").onsuccess = event => {
    276    let cursor = event.target.result;
    277    if (!cursor) {
    278      continueToNextStepSync();
    279      return;
    280    }
    281 
    282    ok(false, "Shouldn't have any keys here");
    283    cursor.continue();
    284  };
    285  yield undefined;
    286 
    287  is(seenKeys.length, 0, "Saw the right number of keys");
    288 
    289  info("Opening key cursor with advance");
    290 
    291  seenKeys = [];
    292  objectStore.openKeyCursor().onsuccess = event => {
    293    let cursor = event.target.result;
    294    if (!cursor) {
    295      continueToNextStepSync();
    296      return;
    297    }
    298 
    299    is(cursor.source, objectStore, "Correct source");
    300    is(cursor.direction, "next", "Correct direction");
    301 
    302    let exception = null;
    303    try {
    304      cursor.update(10);
    305    } catch (e) {
    306      exception = e;
    307    }
    308    ok(!!exception, "update() throws for key cursor");
    309 
    310    exception = null;
    311    try {
    312      cursor.delete();
    313    } catch (e) {
    314      exception = e;
    315    }
    316    ok(!!exception, "delete() throws for key cursor");
    317 
    318    is(cursor.key, cursor.primaryKey, "key and primaryKey match");
    319    ok(!("value" in cursor), "No 'value' property on key cursor");
    320 
    321    seenKeys.push(cursor.key);
    322    if (seenKeys.length == 1) {
    323      cursor.advance(10);
    324    } else {
    325      cursor.continue();
    326    }
    327  };
    328  yield undefined;
    329 
    330  is(seenKeys.length, allKeys.length - 9, "Saw the right number of keys");
    331 
    332  match = true;
    333  for (let i = 0, j = 0; i < seenKeys.length; i++) {
    334    if (seenKeys[i] !== allKeys[i + j]) {
    335      match = false;
    336      break;
    337    }
    338    if (i == 0) {
    339      j = 9;
    340    }
    341  }
    342  ok(match, "All keys matched");
    343 
    344  info("Opening key cursor with continue-to-key");
    345 
    346  seenKeys = [];
    347  objectStore.openKeyCursor().onsuccess = event => {
    348    let cursor = event.target.result;
    349    if (!cursor) {
    350      continueToNextStepSync();
    351      return;
    352    }
    353 
    354    is(cursor.source, objectStore, "Correct source");
    355    is(cursor.direction, "next", "Correct direction");
    356 
    357    let exception = null;
    358    try {
    359      cursor.update(10);
    360    } catch (e) {
    361      exception = e;
    362    }
    363    ok(!!exception, "update() throws for key cursor");
    364 
    365    exception = null;
    366    try {
    367      cursor.delete();
    368    } catch (e) {
    369      exception = e;
    370    }
    371    ok(!!exception, "delete() throws for key cursor");
    372 
    373    is(cursor.key, cursor.primaryKey, "key and primaryKey match");
    374    ok(!("value" in cursor), "No 'value' property on key cursor");
    375 
    376    seenKeys.push(cursor.key);
    377 
    378    if (seenKeys.length == 1) {
    379      cursor.continue(10);
    380    } else {
    381      cursor.continue();
    382    }
    383  };
    384  yield undefined;
    385 
    386  is(seenKeys.length, allKeys.length - 9, "Saw the right number of keys");
    387 
    388  match = true;
    389  for (let i = 0, j = 0; i < seenKeys.length; i++) {
    390    if (seenKeys[i] !== allKeys[i + j]) {
    391      match = false;
    392      break;
    393    }
    394    if (i == 0) {
    395      j = 9;
    396    }
    397  }
    398  ok(match, "All keys matched");
    399 
    400  finishTest();
    401 }