fixup! test(wallet): unit test proposal for better rollbacks coverage

Author: mirceahasegan

packages/wallet/src/services/TransactionsTracker.ts

@@ -220,9 +220,6 @@ const findIntersectionAndUpdateTxStore = ({
 
         if (!sameTxAndOrder) {
           localTransactions = revertLastBlock(localTransactions, lowerBound, rollback$, newTransactions, logger);
-          localTransactions = [...localTransactions, ...newTransactions];
-          store.setAll(localTransactions);
-
           continue;
         }
 

packages/wallet/test/services/TransactionsTracker.test.ts

@@ -28,6 +28,18 @@ import delay from 'delay';
 
 const { generateTxAlonzo, mockChainHistoryProvider, queryTransactionsResult, queryTransactionsResult2 } = mockProviders;
 
+const updateTransactionsBlockNo = (transactions: Cardano.HydratedTx[], blockNo = Cardano.BlockNo(10_050)) =>
+  transactions.map((tx) => ({
+    ...tx,
+    blockHeader: { ...tx.blockHeader, blockNo }
+  }));
+
+const updateTransactionIds = (transactions: Cardano.HydratedTx[], tailPattern = 'aaa') =>
+  transactions.map((tx) => ({
+    ...tx,
+    id: Cardano.TransactionId(`${tx.id.slice(0, -tailPattern.length)}${tailPattern}`)
+  }));
+
 describe('TransactionsTracker', () => {
   const logger = dummyLogger;
 
@@ -287,34 +299,239 @@ describe('TransactionsTracker', () => {
 
       // latestStoredBlock  <1 2 3>
       // newBlock           <4 5 6>
-      // rollback$          [1 2 3]  - transactions need to be retried
+      // rollback$          [3 2 1]  - transactions need to be retried
       // store&emit         [4 5 6]
-      it.todo('rolls back all transactions on completely disjoin sets');
+      it('rolls back all transactions on completely disjoin sets', async () => {
+        const [txId1, txId2, txId3] = updateTransactionsBlockNo(queryTransactionsResult2.pageResults);
+        const [txId4, txId5, txId6] = updateTransactionIds([txId1, txId2, txId3]);
+
+        await firstValueFrom(store.setAll([txId1, txId2, txId3]));
+
+        chainHistoryProvider.transactionsByAddresses = jest.fn(() => ({
+          pageResults: [txId4, txId5, txId6],
+          totalResultCount: 3
+        }));
+
+        const { transactionsSource$: provider$, rollback$ } = createAddressTransactionsProvider({
+          addresses$: of(addresses),
+          chainHistoryProvider,
+          logger,
+          retryBackoffConfig,
+          store,
+          tipBlockHeight$
+        });
+
+        const rollbacks: Cardano.HydratedTx[] = [];
+        rollback$.subscribe((tx) => rollbacks.push(tx));
+
+        expect(await firstValueFrom(provider$.pipe(bufferCount(2)))).toEqual([
+          [txId1, txId2, txId3], // from store
+          [txId4, txId5, txId6] // chain history
+        ]);
+        expect(rollbacks).toEqual([txId3, txId2, txId1]);
+        expect(store.setAll).toBeCalledTimes(2);
+      });
 
       // latestStoredBlock  <1 2>
       // newBlock           <1 2 3>
       // rollback$          none
       // store&emit         [1,2,3]
-      it.todo('stores new transactions when new block is superset');
+      it('stores new transactions when new block is superset', async () => {
+        const [txId1, txId2] = updateTransactionsBlockNo(queryTransactionsResult2.pageResults, Cardano.BlockNo(10_050));
+        const [txId1OtherBlock, txId2OtherBlock, txId3] = updateTransactionsBlockNo(
+          queryTransactionsResult2.pageResults,
+          Cardano.BlockNo(10_051)
+        );
+
+        await firstValueFrom(store.setAll([txId1, txId2]));
+
+        chainHistoryProvider.transactionsByAddresses = jest.fn(() => ({
+          pageResults: [txId1OtherBlock, txId2OtherBlock, txId3],
+          totalResultCount: 3
+        }));
+
+        const { transactionsSource$: provider$, rollback$ } = createAddressTransactionsProvider({
+          addresses$: of(addresses),
+          chainHistoryProvider,
+          logger,
+          retryBackoffConfig,
+          store,
+          tipBlockHeight$
+        });
+
+        const rollbacks: Cardano.HydratedTx[] = [];
+        rollback$.subscribe((tx) => rollbacks.push(tx));
+
+        expect(await firstValueFrom(provider$.pipe(bufferCount(2)))).toEqual([
+          [txId1, txId2], // from store
+          [txId1OtherBlock, txId2OtherBlock, txId3] // chain history
+        ]);
+        expect(rollbacks.length).toBe(0);
+        expect(store.setAll).toBeCalledTimes(2);
+        expect(store.setAll).nthCalledWith(2, [txId1OtherBlock, txId2OtherBlock, txId3]);
+      });
 
       // latestStoredBlock  <1 2 3>
       // newBlock           <1 2>
       // rollback$          3
       // store&emit         [1,2]
-      it.todo('rollback some transactions when new block is subset');
+      it('rollback some transactions when new block is subset', async () => {
+        const [txId1, txId2, txId3] = updateTransactionsBlockNo(
+          queryTransactionsResult2.pageResults,
+          Cardano.BlockNo(10_050)
+        );
+        const [txId1OtherBlock, txId2OtherBlock] = updateTransactionsBlockNo([txId1, txId2], Cardano.BlockNo(10_051));
+
+        await firstValueFrom(store.setAll([txId1, txId2, txId3]));
+
+        chainHistoryProvider.transactionsByAddresses = jest.fn(() => ({
+          pageResults: [txId1OtherBlock, txId2OtherBlock],
+          totalResultCount: 2
+        }));
+
+        const { transactionsSource$: provider$, rollback$ } = createAddressTransactionsProvider({
+          addresses$: of(addresses),
+          chainHistoryProvider,
+          logger,
+          retryBackoffConfig,
+          store,
+          tipBlockHeight$
+        });
+
+        const rollbacks: Cardano.HydratedTx[] = [];
+        rollback$.subscribe((tx) => rollbacks.push(tx));
+
+        expect(await firstValueFrom(provider$.pipe(bufferCount(2)))).toEqual([
+          [txId1, txId2, txId3], // from store
+          [txId1OtherBlock, txId2OtherBlock] // chain history
+        ]);
+        expect(rollbacks).toEqual([txId3]);
+        expect(store.setAll).toBeCalledTimes(2);
+        expect(store.setAll).nthCalledWith(2, [txId1OtherBlock, txId2OtherBlock]);
+      });
 
       // latestStoredBlock  <1 2>
       // newBlocks          <3> <1> <2>
       // rollback$          none         - transactions are on chain
       // store&emit         [3 1 2]      - re-emit all as they might have a different blockNo
       // Noop - produces the same result in the tx history
-      it.todo('detects when latest block transactions are found in among new blocks');
+      it('detects when latest block transactions are found in among new blocks', async () => {
+        const [txId1, txId2, txId3] = updateTransactionsBlockNo(
+          queryTransactionsResult2.pageResults,
+          Cardano.BlockNo(10_000)
+        );
+
+        const [txId3OtherBlock] = updateTransactionsBlockNo([txId3], Cardano.BlockNo(10_100));
+        const [txId1OtherBlock] = updateTransactionsBlockNo([txId1], Cardano.BlockNo(10_200));
+        const [txId2OtherBlock] = updateTransactionsBlockNo([txId2], Cardano.BlockNo(10_300));
+
+        await firstValueFrom(store.setAll([txId1, txId2, txId3]));
+
+        chainHistoryProvider.transactionsByAddresses = jest.fn(() => ({
+          pageResults: [txId3OtherBlock, txId1OtherBlock, txId2OtherBlock],
+          totalResultCount: 3
+        }));
+
+        const { transactionsSource$: provider$, rollback$ } = createAddressTransactionsProvider({
+          addresses$: of(addresses),
+          chainHistoryProvider,
+          logger,
+          retryBackoffConfig,
+          store,
+          tipBlockHeight$
+        });
+
+        const rollbacks: Cardano.HydratedTx[] = [];
+        rollback$.subscribe((tx) => rollbacks.push(tx));
+
+        expect(await firstValueFrom(provider$.pipe(bufferCount(2)))).toEqual([
+          [txId1, txId2, txId3], // from store
+          [txId3OtherBlock, txId1OtherBlock, txId2OtherBlock] // chain history
+        ]);
+        expect(rollbacks.length).toBe(0);
+        expect(store.setAll).toBeCalledTimes(2);
+        expect(store.setAll).nthCalledWith(2, [txId3OtherBlock, txId1OtherBlock, txId2OtherBlock]);
+      });
 
       // latestStoredBlock <1 2>
       // newBlock          <3 2 1>
       // rollback$         none   - transactions are on chain
       // store&emit        [3 2 1]
-      it.todo('reversed order transactions plus new tx are re-emitted, but not considered rollbacks');
+      it('reversed order transactions plus new tx are re-emitted, but not considered rollbacks', async () => {
+        const [txId1, txId2, txId3] = updateTransactionsBlockNo(
+          queryTransactionsResult2.pageResults,
+          Cardano.BlockNo(10_000)
+        );
+
+        const [txId1OtherBlock, txId2OtherBlock, txId3OtherBlock] = updateTransactionsBlockNo(
+          [txId1, txId2, txId3],
+          Cardano.BlockNo(10_100)
+        );
+
+        await firstValueFrom(store.setAll([txId1, txId2]));
+
+        chainHistoryProvider.transactionsByAddresses = jest.fn(() => ({
+          pageResults: [txId3OtherBlock, txId2OtherBlock, txId1OtherBlock],
+          totalResultCount: 3
+        }));
+
+        const { transactionsSource$: provider$, rollback$ } = createAddressTransactionsProvider({
+          addresses$: of(addresses),
+          chainHistoryProvider,
+          logger,
+          retryBackoffConfig,
+          store,
+          tipBlockHeight$
+        });
+
+        const rollbacks: Cardano.HydratedTx[] = [];
+        rollback$.subscribe((tx) => rollbacks.push(tx));
+
+        expect(await firstValueFrom(provider$.pipe(bufferCount(2)))).toEqual([
+          [txId1, txId2], // from store
+          [txId3OtherBlock, txId2OtherBlock, txId1OtherBlock] // chain history
+        ]);
+        expect(rollbacks.length).toBe(0);
+        expect(store.setAll).toBeCalledTimes(2);
+        expect(store.setAll).nthCalledWith(2, [txId3OtherBlock, txId2OtherBlock, txId1OtherBlock]);
+      });
+
+      // latestStoredBlock  <1 2 3>
+      // newBlock           <1 2 3>
+      // rollback$          none
+      // store&emit         none
+      it('does not emit when newBlock transactions are identical to stored transactions', async () => {
+        const [txId1, txId2, txId3] = updateTransactionsBlockNo(
+          queryTransactionsResult2.pageResults,
+          Cardano.BlockNo(10_000)
+        );
+
+        await firstValueFrom(store.setAll([txId1, txId2, txId3]));
+
+        chainHistoryProvider.transactionsByAddresses = jest.fn(() => ({
+          pageResults: [txId1, txId2, txId3],
+          totalResultCount: 3
+        }));
+
+        const { transactionsSource$: provider$, rollback$ } = createAddressTransactionsProvider({
+          addresses$: of(addresses),
+          chainHistoryProvider,
+          logger,
+          retryBackoffConfig,
+          store,
+          tipBlockHeight$
+        });
+
+        const rollbacks: Cardano.HydratedTx[] = [];
+        rollback$.subscribe((tx) => rollbacks.push(tx));
+
+        expect(await firstValueFrom(provider$.pipe(bufferCount(1)))).toEqual([
+          [txId1, txId2, txId3] // from store
+        ]);
+        expect(rollbacks.length).toBe(0);
+        expect(store.setAll).toBeCalledTimes(1);
+        expect(store.setAll).nthCalledWith(1, [txId1, txId2, txId3]);
+      });
     });
   });