Add one more unit test

Author: schmidt-sebastian

packages/firestore/test/unit/local/persistence_transaction.test.ts

@@ -20,6 +20,8 @@ import { expect } from 'chai';
 import { IndexedDbPersistence } from '../../../src/local/indexeddb_persistence';
 import { Persistence } from '../../../src/local/persistence';
 import { PersistencePromise } from '../../../src/local/persistence_promise';
+import { DbTarget, DbTargetKey } from '../../../src/local/indexeddb_schema';
+import { TargetId } from '../../../src/core/types';
 
 let persistence: Persistence;
 
@@ -48,27 +50,63 @@ describe('IndexedDbTransaction', () => {
   afterEach(() => persistence.shutdown());
 
   genericTransactionTests();
+
+  it('only invokes onCommittedListener once with retries', async () => {
+    let runCount = 0;
+    let commitCount = 0;
+    await persistence.runTransaction(
+      'onCommitted',
+      'readwrite-idempotent',
+      txn => {
+        const targetsStore = IndexedDbPersistence.getStore<
+          DbTargetKey,
+          { targetId: TargetId }
+        >(txn, DbTarget.store);
+
+        txn.addOnCommittedListener(() => {
+          ++commitCount;
+        });
+
+        ++runCount;
+        if (runCount == 1) {
+          // Trigger a unique key violation
+          return targetsStore
+            .add({ targetId: 1 })
+            .next(() => targetsStore.add({ targetId: 1 }));
+        } else {
+          return PersistencePromise.resolve(0);
+        }
+      }
+    );
+
+    expect(runCount).to.be.equal(2);
+    expect(commitCount).to.be.equal(1);
+  });
 });
 
 function genericTransactionTests(): void {
   it('invokes onCommittedListener when transaction succeeds', async () => {
     let onCommitted = false;
-    await persistence.runTransaction('onCommitted', 'readonly', txn => {
-      txn.addOnCommittedListener(() => {
-        onCommitted = true;
-      });
+    await persistence.runTransaction(
+      'onCommitted',
+      'readonly-idempotent',
+      txn => {
+        txn.addOnCommittedListener(() => {
+          onCommitted = true;
+        });
 
-      expect(onCommitted).to.be.false;
-      return PersistencePromise.resolve();
-    });
+        expect(onCommitted).to.be.false;
+        return PersistencePromise.resolve();
+      }
+    );
 
     expect(onCommitted).to.be.true;
   });
 
   it('does not invoke onCommittedListener when transaction fails', async () => {
     let onCommitted = false;
     await persistence
-      .runTransaction('onCommitted', 'readonly', txn => {
+      .runTransaction('onCommitted', 'readonly-idempotent', txn => {
         txn.addOnCommittedListener(() => {
           onCommitted = true;
         });