The Tor Browser: dom/indexedDB/test/test_blob

     1 <!--

     2   Any copyright is dedicated to the Public Domain.

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

     4 -->

     5 <html>

     6 <head>

     7   <title>Indexed Database Property Test</title>

     9   <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>

    10   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>

    12   <script type="text/javascript;version=1.7">

    13   function testSteps()

    14   {

    15     info("Setting up test fixtures: create an IndexedDB database and object store.");

    17     let request = indexedDB.open(window.location.pathname, 1);

    18     request.onerror = errorHandler;

    19     request.onupgradeneeded = grabEventAndContinueHandler;

    20     request.onsuccess = unexpectedSuccessHandler;

    21     let event = yield undefined;

    23     let db = event.target.result;

    24     db.onerror = errorHandler;

    26     let objectStore = db.createObjectStore("foo", { autoIncrement: true });

    27     let index = objectStore.createIndex("foo", "index");

    29     request.onsuccess = grabEventAndContinueHandler;

    30     event = yield undefined;

    33     info("Let's create a blob and store it in IndexedDB twice.");

    35     const BLOB_DATA = ["fun ", "times ", "all ", "around!"];

    36     const INDEX_KEY = 5;

    37     let blob = new Blob(BLOB_DATA, { type: "text/plain" });

    38     let data = { blob: blob, index: INDEX_KEY };

    40     objectStore = db.transaction("foo", "readwrite").objectStore("foo");

    41     objectStore.add(data).onsuccess = grabEventAndContinueHandler;

    42     event = yield undefined;

    44     let key = event.target.result;

    46     objectStore.add(data).onsuccess = grabEventAndContinueHandler;

    47     event = yield undefined;

    50     info("Let's retrieve the blob again and verify the contents is the same.");

    52     objectStore = db.transaction("foo").objectStore("foo");

    53     objectStore.get(key).onsuccess = grabEventAndContinueHandler;

    54     event = yield undefined;

    56     let fileReader = new FileReader();

    57     fileReader.onload = grabEventAndContinueHandler;

    58     fileReader.readAsText(event.target.result.blob);

    59     event = yield undefined;

    61     is(event.target.result, BLOB_DATA.join(""), "Correct text");

    64     info("Let's retrieve it again, create an object URL for the blob, load" +

    65          "it via an XMLHttpRequest, and verify the contents is the same.");

    67     objectStore = db.transaction("foo").objectStore("foo");

    68     objectStore.get(key).onsuccess = grabEventAndContinueHandler;

    69     event = yield undefined;

    71     let blobURL = URL.createObjectURL(event.target.result.blob);

    73     let xhr = new XMLHttpRequest();

    74     xhr.open("GET", blobURL);

    75     xhr.onload = grabEventAndContinueHandler;

    76     xhr.send();

    77     yield undefined;

    79     URL.revokeObjectURL(blobURL);

    81     is(xhr.responseText, BLOB_DATA.join(""), "Correct responseText");

    84     info("Retrieve both blob entries from the database and verify contents.");

    86     objectStore = db.transaction("foo").objectStore("foo");

    87     objectStore.mozGetAll().onsuccess = grabEventAndContinueHandler;

    88     event = yield undefined;

    90     is(event.target.result.length, 2, "Got right number of items");

    92     fileReader = new FileReader();

    93     fileReader.onload = grabEventAndContinueHandler;

    94     fileReader.readAsText(event.target.result[0].blob);

    95     event = yield undefined;

    97     is(event.target.result, BLOB_DATA.join(""), "Correct text");

    99     let cursorResults = [];

   101     objectStore = db.transaction("foo").objectStore("foo");

   102     objectStore.openCursor().onsuccess = function(event) {

   103       let cursor = event.target.result;

   104       if (cursor) {

   105         cursorResults.push(cursor.value);

   106         cursor.continue();

   107       }

   108       else {

   109         continueToNextStep();

   110       }

   111     };

   112     yield undefined;

   114     is(cursorResults.length, 2, "Got right number of items");

   116     fileReader = new FileReader();

   117     fileReader.onload = grabEventAndContinueHandler;

   118     fileReader.readAsText(cursorResults[0].blob);

   119     event = yield undefined;

   121     is(event.target.result, BLOB_DATA.join(""), "Correct text");

   124     info("Retrieve blobs from database via index and verify contents.");

   126     let index = db.transaction("foo").objectStore("foo").index("foo");

   127     index.get(INDEX_KEY).onsuccess = grabEventAndContinueHandler;

   128     event = yield undefined;

   130     fileReader = new FileReader();

   131     fileReader.onload = grabEventAndContinueHandler;

   132     fileReader.readAsText(event.target.result.blob);

   133     event = yield undefined;

   135     is(event.target.result, BLOB_DATA.join(""), "Correct text");

   137     index = db.transaction("foo").objectStore("foo").index("foo");

   138     index.mozGetAll().onsuccess = grabEventAndContinueHandler;

   139     event = yield undefined;

   141     is(event.target.result.length, 2, "Got right number of items");

   143     fileReader = new FileReader();

   144     fileReader.onload = grabEventAndContinueHandler;

   145     fileReader.readAsText(event.target.result[0].blob);

   146     event = yield undefined;

   148     is(event.target.result, BLOB_DATA.join(""), "Correct text");

   150     cursorResults = [];

   152     index = db.transaction("foo").objectStore("foo").index("foo");

   153     index.openCursor().onsuccess = function(event) {

   154       let cursor = event.target.result;

   155       if (cursor) {

   156         cursorResults.push(cursor.value);

   157         cursor.continue();

   158       }

   159       else {

   160         continueToNextStep();

   161       }

   162     };

   163     yield undefined;

   165     is(cursorResults.length, 2, "Got right number of items");

   167     fileReader = new FileReader();

   168     fileReader.onload = grabEventAndContinueHandler;

   169     fileReader.readAsText(cursorResults[0].blob);

   170     event = yield undefined;

   172     is(event.target.result, BLOB_DATA.join(""), "Correct text");

   174     fileReader = new FileReader();

   175     fileReader.onload = grabEventAndContinueHandler;

   176     fileReader.readAsText(cursorResults[1].blob);

   177     event = yield undefined;

   179     is(event.target.result, BLOB_DATA.join(""), "Correct text");

   182     info("Slice the the retrieved blob and verify its contents.");

   184     let slice = cursorResults[1].blob.slice(0, BLOB_DATA[0].length);

   186     fileReader = new FileReader();

   187     fileReader.onload = grabEventAndContinueHandler;

   188     fileReader.readAsText(slice);

   189     event = yield undefined;

   191     is(event.target.result, BLOB_DATA[0], "Correct text");

   194     info("Send blob to a worker, read its contents there, and verify results.");

   196     function workerScript() {

   197       onmessage = function(event) {

   198         var reader = new FileReaderSync();

   199         postMessage(reader.readAsText(event.data));

   201         var slice = event.data.slice(1, 2);

   202         postMessage(reader.readAsText(slice));

   204       }

   205     }

   207     let url =

   208       URL.createObjectURL(new Blob(["(", workerScript.toSource(), ")()"]));

   210     let worker = new Worker(url);

   211     worker.postMessage(slice);

   212     worker.onmessage = grabEventAndContinueHandler;

   213     event = yield undefined;

   215     is(event.data, BLOB_DATA[0], "Correct text");

   216     event = yield undefined;

   218     is(event.data, BLOB_DATA[0][1], "Correct text");

   221     info("Store a blob back in the database, and keep holding on to the " +

   222          "blob, verifying that it still can be read.");

   224     objectStore = db.transaction("foo").objectStore("foo");

   225     objectStore.get(key).onsuccess = grabEventAndContinueHandler;

   226     event = yield undefined;

   228     let blobFromDB = event.target.result.blob;

   229     let txn = db.transaction("foo", "readwrite");

   230     txn.objectStore("foo").put(event.target.result, key);

   231     txn.oncomplete = grabEventAndContinueHandler;

   232     event = yield undefined;

   234     let fileReader = new FileReader();

   235     fileReader.onload = grabEventAndContinueHandler;

   236     fileReader.readAsText(blobFromDB);

   237     event = yield undefined;

   239     is(event.target.result, BLOB_DATA.join(""), "Correct text");

   241     let blobURL = URL.createObjectURL(blobFromDB);

   243     let xhr = new XMLHttpRequest();

   244     xhr.open("GET", blobURL);

   245     xhr.onload = grabEventAndContinueHandler;

   246     xhr.send();

   247     yield undefined;

   249     URL.revokeObjectURL(blobURL);

   251     is(xhr.responseText, BLOB_DATA.join(""), "Correct responseText");

   254     finishTest();

   255     yield undefined;

   256   }

   257   </script>

   258   <script type="text/javascript;version=1.7" src="helpers.js"></script>

   260 </head>

   262 <body onload="runTest();"></body>

   264 </html>

The Tor Browser / file revision

dom/indexedDB/test/test_blob_simple.html@7e26c7da4463

dom/indexedDB/test/test_blob_simple.html