[IndexedDB] Adding transaction and value support to observers

third_party/WebKit/LayoutTests/storage/indexeddb/resources/observer-tests.js

 if (this.importScripts) {
   importScripts('../../../resources/testharness.js');
   importScripts('generic-idb-operations.js');
   importScripts('observer-helpers.js');
   importScripts('testharness-helpers.js');
 }
 
 setup({timeout: 20000});
 
 var openDB = function(t, dbName, openFunc) {
   var openRequest = indexedDB.open(dbName);
   openRequest.onupgradeneeded = t.unreached_func('upgrade should not be needed');
   openRequest.onsuccess = t.step_func(function() {
     openFunc(openRequest.result);
   });
   openRequest.onerror = t.unreached_func('opening database should not fail');
 };
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges = {
     dbName: db1_name,
     records: {
       'store1': [{type: 'delete', key: {lower: 'a', upper: 'b'}},
                  {type: 'put', key: 'a'}],
       'store2': [{type: 'add', key: 'z'}]
     }
   };
   var connection = null;
+  var observedTimes = 0;
   var observeFunction = function(changes) {
-    compareChanges(changes, expectedChanges);
-    assert_true(connection != null);
+    assert_true(connection != null, "Observer called before db opened.");
+    observedTimes++;
+    assert_equals(1, observedTimes, "Observer was called after calling unobserve.");
+    assertChangesEqual(changes, expectedChanges);
     obs.unobserve(connection);
     t.done();
   };
 
   var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection = db;
     var txn = db.transaction(['store1', 'store2'], 'readwrite');
 
@@ skipping 19 matching lines @@
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges = {
     dbName: db1_name,
     records: {
       'store2': [{type: 'add', key: 'z'}]
     }
   };
 
   var connection = null;
+  var observedTimes = 0;
   var observeFunction = function(changes) {
-    compareChanges(changes, expectedChanges);
-    assert_true(connection != null);
+    assert_true(connection != null, "Observer called before db opened.");
+    observedTimes++;
+    assert_equals(1, observedTimes, "Observer was called after calling unobserve.");
+    assertChangesEqual(changes, expectedChanges);
     obs.unobserve(connection);
     t.done();
   };
 
   var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection = db;
     var txn = db.transaction(['store2'], 'readonly');
     obs.observe(db, txn, {operationTypes: ['add']});
     txn.oncomplete = observers_added_callback;
     txn.onerror = t.unreached_func('transaction should not fail')
   }));
 }, 'IDB Observers: Operation filtering');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var expectedChanges = {
     dbName: db1_name,
     records: {
+      'store2': [{type: 'add', key: 'z', value: 'z'}]
+    }
+  };
+
+  var connection = null;
+  var observedTimes = 0;
+  var observeFunction = function(changes) {
+    assert_true(connection != null, "Observer called before db opened.");
+    observedTimes++;
+    assert_equals(1, observedTimes, "Observer was called after calling unobserve.");
+    assertChangesEqual(changes, expectedChanges);
+    obs.unobserve(connection);
+    t.done();
+  };
+
+  var obs = new IDBObserver(t.step_func(observeFunction));
+
+  openDB(t, db1_name, t.step_func(function(db) {
+    connection = db;
+    var txn = db.transaction(['store2'], 'readonly');
+    obs.observe(db, txn, {operationTypes: ['add'], values: true});
+    txn.oncomplete = observers_added_callback;
+    txn.onerror = t.unreached_func('transaction should not fail')
+  }));
+}, 'IDB Observers: Values');
+
+
+indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
+  var expectedChanges = {
+    dbName: db1_name,
+    records: {
+      'store2': [{type: 'add', key: 'z'}],
+    }
+  };
+
+  var connection = null;
+  var observedTimes = 0;
+  var observeFunction = function(changes) {
+    assert_true(connection != null, "Observer called before db opened.");
+    observedTimes++;
+    assert_equals(1, observedTimes, "Observer was called after calling unobserve.");
+    assertChangesEqual(changes, expectedChanges);
+    obs.unobserve(connection);
+    assert_true(changes.transaction != null);
+    var store2 = changes.transaction.objectStore('store2');
+    var request = store2.get('z');
+    request.onsuccess = t.step_func(function() {
+      assert_equals(request.result, 'z');
+      t.done();
+    });
+  };
+
+  var obs = new IDBObserver(t.step_func(observeFunction));
+
+  openDB(t, db1_name, t.step_func(function(db) {
+    connection = db;
+    var txn = db.transaction(['store2'], 'readonly');
+    obs.observe(db, txn, {operationTypes: ['add'], transaction: true});
+    txn.oncomplete = observers_added_callback;
+    txn.onerror = t.unreached_func('transaction should not fail')
+  }));
+}, 'IDB Observers: Transaction');
+
+indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
+  var expectedChanges = {
+    dbName: db1_name,
+    records: {
       'store2': [{type: 'add', key: 'z'}]
     }
   };
 
   var connection = null;
+  var observedTimes = 0;
   var observeFunction = function(changes) {
-    compareChanges(changes, expectedChanges);
-    assert_true(connection != null);
+    assert_true(connection != null, "Observer called before db opened.");
+    observedTimes++;
+    assert_equals(1, observedTimes, "Observer was called after calling unobserve.");
+    assertChangesEqual(changes, expectedChanges);
     obs.unobserve(connection);
     t.done();
   };
 
   var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection = db;
     var txn = db.transaction(['store2'], 'readonly');
     obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
@@ skipping 21 matching lines @@
   };
 
   var observers_added_barrier = create_barrier(observers_added_callback);
 
   var connection1 = null;
   var connection2 = null;
   var pendingObserves = 2;
   var observeFunction = function(changes) {
     pendingObserves = pendingObserves - 1;
     if (changes.database.name === db1_name) {
-      compareChanges(changes, expectedChanges1);
+      assertChangesEqual(changes, expectedChanges1);
       assert_true(connection1 != null);
       obs.unobserve(connection1);
     } else if (changes.database.name === db2_name) {
-      compareChanges(changes, expectedChanges2);
+      assertChangesEqual(changes, expectedChanges2);
       assert_true(connection2 != null);
       obs.unobserve(connection2);
     }
     if (pendingObserves === 0) {
       t.done();
     } else if (pendingObserves < 0) {
       assert_unreached("incorrect pendingObserves");
     }
   };
 
@@ skipping 23 matching lines @@
     records: {
       'store1': [{type: 'delete', key: {lower: 'a', upper: 'b'}},
                  {type: 'put', key: 'a'}],
       'store2': [{type: 'add', key: 'z'}]
     }
   };
 
   var connection = null;
   var pendingObserves = 2;
   var observeFunction = function(changes) {
-    compareChanges(changes, expectedChanges);
+    assertChangesEqual(changes, expectedChanges);
     pendingObserves = pendingObserves - 1;
     if (pendingObserves === 0) {
-      assert_true(connection != null);
+      assert_true(connection != null, "Observer called before db opened.");
       obs.unobserve(connection);
       t.done();
     } else if (pendingObserves < 0) {
       assert_unreached("incorrect pendingObserves");
     }
   };
 
   var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
@@ skipping 16 matching lines @@
   var expectedChanges2 = {
     dbName: db1_name,
     records: {
       'store2': [{type: 'add', key: 'z'}]
     }
   };
 
   var connection = null;
   var changeNumber = 0;
   var observeFunction = function(changes) {
-    assert_true(connection != null);
-    if (changeNumber === 0) {
-      compareChanges(changes, expectedChanges1);
-    } else if(changeNumber === 1) {
-      compareChanges(changes, expectedChanges2);
+    assert_true(connection != null, "Observer called before db opened.");
+    if (changes.records.has('store1')) {
+      assertChangesEqual(changes, expectedChanges1);
+    } else if(changes.records.has('store2')) {
+      assertChangesEqual(changes, expectedChanges2);
+    }
+    ++changeNumber;
+    assert_less_than_equal(changeNumber, 2, "incorrect pendingObserves");
+    if (changeNumber == 2) {
       obs.unobserve(connection);
       t.done();
     }
-    ++changeNumber;
-    assert_less_than_equal(changeNumber, 1, "incorrect pendingObserves");
   };
 
   var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection = db;
     var txn = db.transaction(['store1', 'store2'], 'readonly');
     obs.observe(db, txn, {operationTypes: ['put']});
     obs.observe(db, txn, {operationTypes: ['add']});
     txn.oncomplete = observers_added_callback;
@@ skipping 37 matching lines @@
   var connection3 = null;
   var observers_added_barrier = create_barrier(observers_added_callback);
 
   var pendingObserves = 4;
   var observeFunction = function(changes) {
     pendingObserves = pendingObserves - 1;
     var firstRound = pendingObserves != 0;
 
     if (changes.database === connection1) {
       assert_true(firstRound, "connection 1 should have been unobserved");
-      compareChanges(changes, partOneChanges1);
+      assertChangesEqual(changes, partOneChanges1);
       obs.unobserve(connection1);
     } else if (changes.database === connection2) {
       if (firstRound)
-        compareChanges(changes, partOneChanges2);
+        assertChangesEqual(changes, partOneChanges2);
       else
-        compareChanges(changes, partTwoChanges2);
+        assertChangesEqual(changes, partTwoChanges2);
     } else if (changes.database === connection3) {
       assert_true(firstRound, "connection 3 should have been unobserved ");
-      compareChanges(changes, partOneChanges3);
+      assertChangesEqual(changes, partOneChanges3);
       obs.unobserve(connection3);
     } else {
       assert_unreached('Unknown connection supplied with changes.');
     }
     if (pendingObserves === 0) {
       t.done();
     } else if (pendingObserves < 0) {
       assert_unreached("incorrect pendingObserves");
     }
   };
@@ skipping 23 matching lines @@
     obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb3;
     txn.onerror = t.unreached_func('transaction should not fail')
   }));
 }, 'IDB Observers: Three connections, unobserve two');
 
 indexeddb_observers_test(function(t, db1_name, db2_name, observers_added_callback) {
   var connection1 = null;
   var connection2 = null;
 
+  var observedTimes = 0;
   var observeFunction = function(changes) {
+    assert_true(connection2 != null, "Observer called before db opened.");
+    observedTimes++;
+    assert_equals(1, observedTimes, "Observer was called after calling unobserve.");
     assert_equals(changes.database, connection2);
     obs.unobserve(connection2);
     t.done();
   };
 
   var obs = new IDBObserver(t.step_func(observeFunction));
 
   openDB(t, db1_name, t.step_func(function(db) {
     connection1 = db;
     var txn = db.transaction(['store1'], 'readonly');
@@ skipping 65 matching lines @@
   var connection2 = null;
   var observers_added_barrier = create_barrier(observers_added_callback);
 
   var connection1Observes = 0;
   var connection2Observes = 0;
   var observeFunction = function(changes) {
     if (changes.database === connection1) {
       connection1Observes = connection1Observes + 1;
       assert_true(connection1Observes <= 2);
       if (changes.records.has('store1')) {
-        compareChanges(changes, expectedChanges1);
+        assertChangesEqual(changes, expectedChanges1);
       } else if (changes.records.has('store2')) {
-        compareChanges(changes, expectedChanges2);
+        assertChangesEqual(changes, expectedChanges2);
       } else {
         assert_unreached("unknown changes");
       }
       if (connection1Observes === 2) {
         obs.unobserve(connection1);
       }
     } else if (changes.database === connection2) {
       connection2Observes = connection2Observes + 1;
       if (connection2Observes > 1) {
         t.done();
@@ skipping 49 matching lines @@
   var connection2 = null;
   var observers_added_barrier = create_barrier(observers_added_callback);
 
   var connection1Observes = 0;
   var connection2Observes = 0;
   var observeFunction = function(changes) {
     if (changes.database === connection1) {
       connection1Observes = connection1Observes + 1;
       assert_true(connection1Observes <= 2);
       if (changes.records.has('store1')) {
-        compareChanges(changes, expectedChanges1);
+        assertChangesEqual(changes, expectedChanges1);
       } else if (changes.records.has('store2')) {
-        compareChanges(changes, expectedChanges2);
+        assertChangesEqual(changes, expectedChanges2);
       } else {
         assert_unreached("unknown changes");
       }
       if (connection1Observes === 2) {
         connection1.close();
       }
     } else if (changes.database === connection2) {
       connection2Observes = connection2Observes + 1;
       if (connection2Observes > 1) {
         t.done();
@@ skipping 24 matching lines @@
   openDB(t, db2_name, t.step_func(function(db) {
     connection2 = db;
     var txn = db.transaction(['store3'], 'readonly');
     obs.observe(db, txn, {operationTypes: ['clear', 'put', 'add', 'delete']});
     txn.oncomplete = cb3;
     txn.onerror = t.unreached_func('transaction should not fail');
   }));
 }, 'IDB Observers: Close connection removes observers');
 
 done();