Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 190 insertions, 0 deletions

diff --git a/dom/indexedDB/test/unit/test_add_put.js b/dom/indexedDB/test/unit/test_add_put.js
new file mode 100644
index 0000000000..ba880957c0
--- /dev/null
+++ b/dom/indexedDB/test/unit/test_add_put.js
@@ -0,0 +1,190 @@
+/**
+ * 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();
+}