tor-browser

test_add_put.js (5851B)

---

/**
* Any copyright is dedicated to the Public Domain.
* http://creativecommons.org/publicdomain/zero/1.0/
*/

/* exported testGenerator */
var testGenerator = testSteps();

function* testSteps() {
 const name = this.window ? window.location.pathname : "Splendid Test";
 let openRequest = indexedDB.open(name, 1);
 openRequest.onerror = errorHandler;
 openRequest.onupgradeneeded = grabEventAndContinueHandler;
 openRequest.onsuccess = unexpectedSuccessHandler;
 let event = yield undefined;
 let db = event.target.result;

 for (let autoincrement of [true, false]) {
   for (let keypath of [false, true, "missing", "invalid"]) {
     for (let method of ["put", "add"]) {
       for (let explicit of [true, false, undefined, "invalid"]) {
         for (let existing of [true, false]) {
           let speccedNoKey = (!keypath || keypath == "missing") && !explicit;

           // We can't do 'existing' checks if we use autogenerated key
           if (speccedNoKey && autoincrement && existing) {
             continue;
           }

           // Create store
           if (db.objectStoreNames.contains("mystore")) {
             db.deleteObjectStore("mystore");
           }
           let store = db.createObjectStore("mystore", {
             autoIncrement: autoincrement,
             keyPath: keypath ? "id" : null,
           });

           let test =
             " for test " +
             JSON.stringify({
               autoincrement,
               keypath,
               method,
               explicit: explicit === undefined ? "undefined" : explicit,
               existing,
             });

           // Insert "existing" data if needed
           if (existing) {
             if (keypath) {
               store.add({
                 existing: "data",
                 id: 5,
               }).onsuccess = grabEventAndContinueHandler;
             } else {
               store.add({ existing: "data" }, 5).onsuccess =
                 grabEventAndContinueHandler;
             }

             let e = yield undefined;
             is(e.type, "success", "success inserting existing" + test);
             is(e.target.result, 5, "inserted correct key" + test);
           }

           // Set up value to be inserted
           let value = { theObj: true };
           if (keypath === true) {
             value.id = 5;
           } else if (keypath === "invalid") {
             value.id = /x/;
           }

           // Which arguments are passed to function
           let args = [value];
           if (explicit === true) {
             args.push(5);
           } else if (explicit === undefined) {
             args.push(undefined);
           } else if (explicit === "invalid") {
             args.push(/x/);
           }

           let expected = expectedResult(
             method,
             keypath,
             explicit,
             autoincrement,
             existing
           );

           let valueJSON = JSON.stringify(value);

           ok(true, "making call" + test);

           // Make function call for throwing functions
           if (expected === "throw") {
             try {
               store[method].apply(store, args);
               ok(false, "should have thrown" + test);
             } catch (ex) {
               ok(true, "did throw" + test);
               ok(ex instanceof DOMException, "Got a DOMException" + test);
               is(ex.name, "DataError", "expect a DataError" + test);
               is(ex.code, 0, "expect zero" + test);
               is(
                 JSON.stringify(value),
                 valueJSON,
                 "call didn't modify value" + test
               );
             }
             continue;
           }

           // Make non-throwing function call
           let req = store[method].apply(store, args);
           is(
             JSON.stringify(value),
             valueJSON,
             "call didn't modify value" + test
           );

           req.onsuccess = req.onerror = grabEventAndContinueHandler;
           let e = yield undefined;

           // Figure out what key we used
           let key = 5;
           if (autoincrement && speccedNoKey) {
             key = 1;
           }

           // Adjust value if expected
           if (autoincrement && keypath && speccedNoKey) {
             value.id = key;
           }

           // Check result
           if (expected === "error") {
             is(e.type, "error", "write should fail" + test);
             e.preventDefault();
             e.stopPropagation();
             continue;
           }

           is(e.type, "success", "write should succeed" + test);
           is(e.target.result, key, "write should return correct key" + test);

           store.get(key).onsuccess = grabEventAndContinueHandler;
           e = yield undefined;
           is(e.type, "success", "read back should succeed" + test);
           is(
             JSON.stringify(e.target.result),
             JSON.stringify(value),
             "read back should return correct value" + test
           );
         }
       }
     }
   }
 }

 function expectedResult(method, keypath, explicit, autoincrement, existing) {
   if (keypath && explicit) {
     return "throw";
   }
   if (!keypath && !explicit && !autoincrement) {
     return "throw";
   }
   if (keypath == "invalid") {
     return "throw";
   }
   if (keypath == "missing" && !autoincrement) {
     return "throw";
   }
   if (explicit == "invalid") {
     return "throw";
   }

   if (method == "add" && existing) {
     return "error";
   }

   return "success";
 }

 openRequest.onsuccess = grabEventAndContinueHandler;
 yield undefined;

 finishTest();
}