Adding upstream version 125.0.1.upstream/125.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 427 insertions, 0 deletions

diff --git a/testing/web-platform/tests/IndexedDB/idbobjectstore_put.any.js b/testing/web-platform/tests/IndexedDB/idbobjectstore_put.any.js
new file mode 100644
index 0000000000..89303291e9
--- /dev/null
+++ b/testing/web-platform/tests/IndexedDB/idbobjectstore_put.any.js
@@ -0,0 +1,427 @@
+// META: global=window,worker
+// META: title=IDBObjectStore.put()
+// META: script=resources/support.js
+// @author Microsoft <https://www.microsoft.com>
+// @author Intel <http://www.intel.com>
+
+'use strict';
+
+async_test(t => {
+    let db;
+    const record = { key: 1, property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        db = e.target.result;
+        const objStore = db.createObjectStore("store", { keyPath: "key" });
+
+        objStore.put(record);
+    };
+
+    open_rq.onsuccess = function(e) {
+        const rq = db.transaction("store", "readonly",
+         { durability: 'relaxed' })
+                   .objectStore("store")
+                   .get(record.key);
+
+        rq.onsuccess = t.step_func(function(e) {
+            assert_equals(e.target.result.property, record.property);
+            assert_equals(e.target.result.key, record.key);
+            t.done();
+        });
+    };
+}, 'put() with an inline key');
+
+async_test(t => {
+    let db;
+    const key = 1;
+    const record = { property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        db = e.target.result;
+        const objStore = db.createObjectStore("store");
+
+        objStore.put(record, key);
+    };
+
+    open_rq.onsuccess = function(e) {
+        const rq = db.transaction("store", "readonly", {durability: 'relaxed'})
+                   .objectStore("store")
+                   .get(key);
+
+        rq.onsuccess = t.step_func(function(e) {
+            assert_equals(e.target.result.property, record.property);
+
+            t.done();
+        });
+    };
+},'put() with an out-of-line key');
+
+async_test(t => {
+    let db;
+    let success_event;
+    const record = { key: 1, property: "data" };
+    const record_put = { key: 1, property: "changed", more: ["stuff", 2] };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        db = e.target.result;
+        const objStore = db.createObjectStore("store", { keyPath: "key" });
+        objStore.put(record);
+
+        const rq = objStore.put(record_put);
+        rq.onerror = fail(t, "error on put");
+
+        rq.onsuccess = t.step_func(function(e) {
+            success_event = true;
+        });
+    };
+
+    open_rq.onsuccess = function(e) {
+        assert_true(success_event);
+
+        const rq = db.transaction("store", "readonly",
+         { durability: 'relaxed' })
+                   .objectStore("store")
+                   .get(1);
+
+        rq.onsuccess = t.step_func(function(e) {
+            const rec = e.target.result;
+
+            assert_equals(rec.key, record_put.key);
+            assert_equals(rec.property, record_put.property);
+            assert_array_equals(rec.more, record_put.more);
+
+            t.done();
+        });
+    };
+}, 'put() record with key already exists');
+
+async_test(t => {
+    const record = { key: 1, property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        let db = e.target.result;
+        const objStore = db.createObjectStore("store", {
+             autoIncrement: true });
+        objStore.createIndex("i1", "property", { unique: true });
+        objStore.put(record);
+
+        const rq = objStore.put(record);
+        rq.onsuccess = fail(t, "success on putting duplicate indexed record");
+
+        rq.onerror = t.step_func(function(e) {
+            assert_equals(rq.error.name, "ConstraintError");
+            assert_equals(e.target.error.name, "ConstraintError");
+
+            assert_equals(e.type, "error");
+
+            e.preventDefault();
+            e.stopPropagation();
+        });
+    };
+
+    // Defer done, giving a spurious rq.onsuccess a chance to run
+    open_rq.onsuccess = function(e) {
+        t.done();
+    };
+}, 'put() where an index has unique:true specified');
+
+async_test(t => {
+    let db;
+    const record = { test: { obj: { key: 1 } }, property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        db = e.target.result;
+        const objStore = db.createObjectStore("store",
+        { keyPath: "test.obj.key" });
+        objStore.put(record);
+    };
+
+    open_rq.onsuccess = function(e) {
+        const rq = db.transaction("store", "readonly",
+        { durability: 'relaxed' })
+                   .objectStore("store")
+                   .get(record.test.obj.key);
+
+        rq.onsuccess = t.step_func(function(e) {
+            assert_equals(e.target.result.property, record.property);
+
+            t.done();
+        });
+    };
+}, 'Object store\'s key path is an object attribute');
+
+async_test(t => {
+    let db;
+    const record = { property: "data" };
+    const expected_keys = [1, 2, 3, 4];
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+      db = e.target.result;
+      const objStore = db.createObjectStore("store", { keyPath: "key",
+      autoIncrement: true });
+
+      objStore.put(record);
+      objStore.put(record);
+      objStore.put(record);
+      objStore.put(record);
+    };
+
+    open_rq.onsuccess = function(e) {
+      let actual_keys = [];
+      const rq = db.transaction("store", "readonly", { durability: 'relaxed' })
+          .objectStore("store")
+          .openCursor();
+
+      rq.onsuccess = t.step_func(function(e) {
+        const cursor = e.target.result;
+
+        if (cursor) {
+          actual_keys.push(cursor.value.key);
+          cursor.continue();
+        } else {
+          assert_array_equals(actual_keys, expected_keys);
+          t.done();
+        }
+      });
+    };
+  }, 'autoIncrement and inline keys');
+
+async_test(t => {
+    let db;
+    const record = { property: "data" };
+    const expected_keys = [1, 2, 3, 4];
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        db = e.target.result;
+        const objStore = db.createObjectStore("store", { keyPath: "key",
+        autoIncrement: true });
+
+        objStore.put(record);
+        objStore.put(record);
+        objStore.put(record);
+        objStore.put(record);
+    };
+
+    open_rq.onsuccess = function(e) {
+        const actual_keys = [];
+        const rq = db.transaction("store", "readonly",
+        { durability: 'relaxed' })
+                   .objectStore("store")
+                   .openCursor();
+
+        rq.onsuccess = t.step_func(function(e) {
+            const cursor = e.target.result;
+
+            if(cursor) {
+                actual_keys.push(cursor.value.key);
+                cursor.continue();
+            } else {
+                assert_array_equals(actual_keys, expected_keys);
+                t.done();
+            }
+        });
+    };
+}, 'autoIncrement and out-of-line keys');
+
+async_test(t => {
+    let db;
+    const record = { property: "data" };
+    const expected_keys = [1, 2, 3, 4];
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        db = e.target.result;
+        const objStore = db.createObjectStore("store",
+        { keyPath: "test.obj.key", autoIncrement: true });
+
+        objStore.put(record);
+        objStore.put(record);
+        objStore.put(record);
+        objStore.put(record);
+    };
+
+    open_rq.onsuccess = function(e) {
+        const actual_keys = [];
+        const rq = db.transaction("store", "readonly",
+        { durability: 'relaxed' })
+            .objectStore("store")
+            .openCursor();
+
+        rq.onsuccess = t.step_func(function(e) {
+            const cursor = e.target.result;
+
+            if (cursor) {
+                actual_keys.push(cursor.value.test.obj.key);
+                cursor.continue();
+            } else {
+                assert_array_equals(actual_keys, expected_keys);
+                t.done();
+            }
+        });
+    };
+}, 'Object store has autoIncrement:true and the key path is an object \
+attribute');
+
+async_test(t => {
+    const record = { key: 1, property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        let rq;
+        const db = e.target.result;
+        const objStore = db.createObjectStore("store", { keyPath: "key" });
+
+        assert_throws_dom("DataError", function() {
+            rq = objStore.put(record, 1);
+        });
+
+        assert_equals(rq, undefined);
+        t.done();
+    };
+}, 'Attempt to put() a record that does not meet the constraints of an object \
+store\'s inline key requirements');
+
+async_test(t => {
+    const record = { property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        let db = e.target.result;
+
+        let rq;
+        const objStore = db.createObjectStore("store", { keyPath: "key" });
+
+        assert_throws_dom("DataError", function() {
+            rq = objStore.put(record);
+        });
+
+        assert_equals(rq, undefined);
+        t.done();
+    };
+}, 'Attempt to call put() without an key parameter when the object store uses \
+out-of-line keys');
+
+async_test(t => {
+    const record = { key: { value: 1 }, property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        const db = e.target.result;
+
+        let rq;
+        const objStore = db.createObjectStore("store", { keyPath: "key" });
+
+        assert_throws_dom("DataError", function() {
+            rq = objStore.put(record);
+        });
+
+        assert_equals(rq, undefined);
+        t.done();
+    };
+}, 'Attempt to put() a record where the record\'s key does not meet the \
+constraints of a valid key');
+
+async_test(t => {
+    const record = { property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        const db = e.target.result;
+
+        let rq;
+        const objStore = db.createObjectStore("store", { keyPath: "key" });
+
+        assert_throws_dom("DataError", function() {
+            rq = objStore.put(record);
+        });
+
+        assert_equals(rq, undefined);
+        t.done();
+    };
+}, 'Attempt to put() a record where the record\'s in-line key is not defined');
+
+async_test(t => {
+    const record = { property: "data" };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        const db = e.target.result;
+
+        let rq;
+        const objStore = db.createObjectStore("store");
+
+        assert_throws_dom("DataError", function() {
+            rq = objStore.put(record, { value: 1 });
+        });
+
+        assert_equals(rq, undefined);
+        t.done();
+    };
+}, 'Attempt to put() a record where the out of line key provided does not \
+meet the constraints of a valid key');
+
+async_test(t => {
+    const record = { key: 1, indexedProperty: { property: "data" } };
+
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(e) {
+        const db = e.target.result;
+
+        let rq;
+        const objStore = db.createObjectStore("store", { keyPath: "key" });
+
+        objStore.createIndex("index", "indexedProperty");
+
+        rq = objStore.put(record);
+
+        assert_true(rq instanceof IDBRequest);
+        rq.onsuccess = function() {
+            t.done();
+        };
+    };
+}, 'put() a record where a value being indexed does not meet the constraints \
+of a valid key');
+
+async_test(t => {
+    let db;
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(event) {
+        db = event.target.result;
+        db.createObjectStore("store", { keyPath: "pKey" });
+    };
+
+    open_rq.onsuccess = function(event) {
+        const txn = db.transaction("store", "readonly",
+        { durability: 'relaxed' });
+        const ostore = txn.objectStore("store");
+        t.step(function() {
+            assert_throws_dom("ReadOnlyError", function() {
+                ostore.put({ pKey: "primaryKey_0" });
+            });
+        });
+        t.done();
+    };
+}, 'If the transaction this IDBObjectStore belongs to has its mode set to \
+readonly, throw ReadOnlyError');
+
+async_test(t => {
+    let ostore;
+    const open_rq = createdb(t);
+    open_rq.onupgradeneeded = function(event) {
+        const db = event.target.result;
+        ostore = db.createObjectStore("store", { keyPath: "pKey" });
+        db.deleteObjectStore("store");
+        assert_throws_dom("InvalidStateError", function() {
+            ostore.put({ pKey: "primaryKey_0" });
+        });
+        t.done();
+    };
+}, 'If the object store has been deleted, the implementation must throw a \
+DOMException of type InvalidStateError');