Adding upstream version 115.8.0esr.upstream/115.8.0esr

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

1 files changed, 288 insertions, 0 deletions

diff --git a/testing/web-platform/tests/IndexedDB/idb-explicit-commit.any.js b/testing/web-platform/tests/IndexedDB/idb-explicit-commit.any.js
new file mode 100644
index 0000000000..898d461d7b
--- /dev/null
+++ b/testing/web-platform/tests/IndexedDB/idb-explicit-commit.any.js
@@ -0,0 +1,288 @@
+// META: script=resources/support-promises.js
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  objectStore.put({isbn: 'one', title: 'title1'});
+  objectStore.put({isbn: 'two', title: 'title2'});
+  objectStore.put({isbn: 'three', title: 'title3'});
+  txn.commit();
+  await promiseForTransaction(testCase, txn);
+
+  const txn2 = db.transaction(['books'], 'readonly');
+  const objectStore2 = txn2.objectStore('books');
+  const getRequestitle1 = objectStore2.get('one');
+  const getRequestitle2 = objectStore2.get('two');
+  const getRequestitle3 = objectStore2.get('three');
+  txn2.commit();
+  await promiseForTransaction(testCase, txn2);
+  assert_array_equals(
+      [getRequestitle1.result.title,
+          getRequestitle2.result.title,
+          getRequestitle3.result.title],
+      ['title1', 'title2', 'title3'],
+      'All three retrieved titles should match those that were put.');
+  db.close();
+}, 'Explicitly committed data can be read back out.');
+
+
+promise_test(async testCase => {
+  let db = await createDatabase(testCase, () => {});
+  assert_equals(1, db.version, 'A database should be created as version 1');
+  db.close();
+
+  // Upgrade the versionDB database and explicitly commit its versionchange
+  // transaction.
+  db = await migrateDatabase(testCase, 2, (db, txn) => {
+    txn.commit();
+  });
+  assert_equals(2, db.version,
+      'The database version should have been incremented regardless of '
+      + 'whether the versionchange transaction was explicitly or implicitly '
+      + 'committed.');
+  db.close();
+}, 'commit() on a version change transaction does not cause errors.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  txn.commit();
+  assert_throws_dom('TransactionInactiveError',
+      () => { objectStore.put({isbn: 'one', title: 'title1'}); },
+      'After commit is called, the transaction should be inactive.');
+  db.close();
+}, 'A committed transaction becomes inactive immediately.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  const putRequest = objectStore.put({isbn: 'one', title: 'title1'});
+  putRequest.onsuccess = testCase.step_func(() => {
+    assert_throws_dom('TransactionInactiveError',
+      () => { objectStore.put({isbn:'two', title:'title2'}); },
+      'The transaction should not be active in the callback of a request after '
+      + 'commit() is called.');
+  });
+  txn.commit();
+  await promiseForTransaction(testCase, txn);
+  db.close();
+}, 'A committed transaction is inactive in future request callbacks.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  txn.commit();
+
+  assert_throws_dom('TransactionInactiveError',
+      () => { objectStore.put({isbn:'one', title:'title1'}); },
+      'After commit is called, the transaction should be inactive.');
+
+  const txn2 = db.transaction(['books'], 'readonly');
+  const objectStore2 = txn2.objectStore('books');
+  const getRequest = objectStore2.get('one');
+  await promiseForTransaction(testCase, txn2);
+  assert_equals(getRequest.result, undefined);
+
+  db.close();
+}, 'Puts issued after commit are not fulfilled.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  txn.abort();
+  assert_throws_dom('InvalidStateError',
+      () => { txn.commit(); },
+      'The transaction should have been aborted.');
+  db.close();
+}, 'Calling commit on an aborted transaction throws.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  txn.commit();
+  assert_throws_dom('InvalidStateError',
+      () => { txn.commit(); },
+      'The transaction should have already committed.');
+  db.close();
+}, 'Calling commit on a committed transaction throws.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  const putRequest = objectStore.put({isbn:'one', title:'title1'});
+  txn.commit();
+  assert_throws_dom('InvalidStateError',
+      () => { txn.abort(); },
+      'The transaction should already have committed.');
+  const txn2 = db.transaction(['books'], 'readwrite');
+  const objectStore2 = txn2.objectStore('books');
+  const getRequest = objectStore2.get('one');
+  await promiseForTransaction(testCase, txn2);
+  assert_equals(
+      getRequest.result.title,
+      'title1',
+      'Explicitly committed data should be gettable.');
+  db.close();
+}, 'Calling abort on a committed transaction throws and does not prevent '
+   + 'persisting the data.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  const releaseTxnFunction = keepAlive(testCase, txn, 'books');
+
+  // Break up the scope of execution to force the transaction into an inactive
+  // state.
+  await timeoutPromise(0);
+
+  assert_throws_dom('InvalidStateError',
+      () => { txn.commit(); },
+      'The transaction should be inactive so calling commit should throw.');
+  releaseTxnFunction();
+  db.close();
+}, 'Calling txn.commit() when txn is inactive should throw.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+    createNotBooksStore(testCase, db);
+  });
+  // Txn1 should commit before txn2, even though txn2 uses commit().
+  const txn1 = db.transaction(['books'], 'readwrite');
+  txn1.objectStore('books').put({isbn: 'one', title: 'title1'});
+  const releaseTxnFunction = keepAlive(testCase, txn1, 'books');
+
+  const txn2 = db.transaction(['books'], 'readwrite');
+  txn2.objectStore('books').put({isbn:'one', title:'title2'});
+  txn2.commit();
+
+  // Exercise the IndexedDB transaction ordering by executing one with a
+  // different scope. A readonly transaction is used here because
+  // implementations are not required to run non-overlapping readwrite
+  // transactions in parallel, and some implementations (ex: Firefox)
+  // will not.
+  const txn3 = db.transaction(['not_books'], 'readonly');
+  txn3.objectStore('not_books').getAllKeys();
+  txn3.oncomplete = function() {
+    releaseTxnFunction();
+  }
+  await Promise.all([promiseForTransaction(testCase, txn1),
+                     promiseForTransaction(testCase, txn2)]);
+
+  // Read the data back to verify that txn2 executed last.
+  const txn4 = db.transaction(['books'], 'readonly');
+  const getRequest4 = txn4.objectStore('books').get('one');
+  await promiseForTransaction(testCase, txn4);
+  assert_equals(getRequest4.result.title, 'title2');
+  db.close();
+}, 'Transactions with same scope should stay in program order, even if one '
+   + 'calls commit.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  // Txn1 creates the book 'one' so the 'add()' below fails.
+  const txn1 = db.transaction(['books'], 'readwrite');
+  txn1.objectStore('books').add({isbn:'one', title:'title1'});
+  txn1.commit();
+  await promiseForTransaction(testCase, txn1);
+
+  // Txn2 should abort, because the 'add' call is invalid, and commit() was
+  // called.
+  const txn2 = db.transaction(['books'], 'readwrite');
+  const objectStore2 = txn2.objectStore('books');
+  objectStore2.put({isbn:'two', title:'title2'});
+  const addRequest = objectStore2.add({isbn:'one', title:'title2'});
+  txn2.commit();
+  txn2.oncomplete = () => { assert_unreached(
+    'Transaction with invalid "add" call should not be completed.'); };
+
+  // Wait for the transaction to complete. We have to explicitly wait for the
+  // error signal on the transaction because of the nature of the test tooling.
+  await Promise.all([
+      requestWatcher(testCase, addRequest).wait_for('error'),
+      transactionWatcher(testCase, txn2).wait_for(['error', 'abort'])
+  ]);
+
+  // Read the data back to verify that txn2 was aborted.
+  const txn3 = db.transaction(['books'], 'readonly');
+  const objectStore3 = txn3.objectStore('books');
+  const getRequest1 = objectStore3.get('one');
+  const getRequest2 = objectStore3.count('two');
+  await promiseForTransaction(testCase, txn3);
+  assert_equals(getRequest1.result.title, 'title1');
+  assert_equals(getRequest2.result, 0);
+  db.close();
+}, 'Transactions that explicitly commit and have errors should abort.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, db => {
+    createBooksStore(testCase, db);
+  });
+  const txn1 = db.transaction(['books'], 'readwrite');
+  txn1.objectStore('books').add({isbn: 'one', title: 'title1'});
+  txn1.commit();
+  await promiseForTransaction(testCase, txn1);
+
+  // The second add request will throw an error, but the onerror handler will
+  // appropriately catch the error allowing the valid put request on the
+  // transaction to commit.
+  const txn2 = db.transaction(['books'], 'readwrite');
+  const objectStore2 = txn2.objectStore('books');
+  objectStore2.put({isbn: 'two', title:'title2'});
+  const addRequest = objectStore2.add({isbn: 'one', title:'unreached_title'});
+  addRequest.onerror = (event) => {
+    event.preventDefault();
+    addRequest.transaction.commit();
+  };
+
+  // Wait for the transaction to complete. We have to explicitly wait for the
+  // error signal on the transaction because of the nature of the test tooling.
+  await transactionWatcher(testCase,txn2).wait_for(['error', 'complete'])
+
+  // Read the data back to verify that txn2 was committed.
+  const txn3 = db.transaction(['books'], 'readonly');
+  const objectStore3 = txn3.objectStore('books');
+  const getRequest1 = objectStore3.get('one');
+  const getRequest2 = objectStore3.get('two');
+  await promiseForTransaction(testCase, txn3);
+  assert_equals(getRequest1.result.title, 'title1');
+  assert_equals(getRequest2.result.title, 'title2');
+  db.close();
+}, 'Transactions that handle all errors properly should behave as ' +
+   'expected when an explicit commit is called in an onerror handler.');