test: add transaction coverage cases

Co-authored-by: Francis Nepomuceno <n3ps@users.noreply.github.com>

Author: cursoragent

app/components/Views/UnifiedTransactionsView/helpers/transformations.test.ts

@@ -3,7 +3,12 @@ import type {
   V4MultiAccountTransactionsResponse,
 } from '@metamask/core-backend';
 import type { InfiniteData } from '@tanstack/react-query';
-import { selectTransactions } from './transformations';
+import {
+  isBridgeHistoryForEvmTransaction,
+  mergeTransactionsByTime,
+  selectTransactions,
+} from './transformations';
+import { TransactionKind } from '../types';
 
 describe('selectTransactions', () => {
   const address = '0x0000000000000000000000000000000000000001';
@@ -88,4 +93,163 @@ describe('selectTransactions', () => {
     expect(result.pages[0].data).toHaveLength(1);
     expect(result.pages[0].data[0].hash).toBe('0xnormal');
   });
+
+  it('filters incoming token transfers', () => {
+    const incomingTokenTransfer = buildTransaction({
+      hash: '0xincoming-token',
+      from: otherAddress,
+      to: address,
+      valueTransfers: [
+        {
+          contractAddress: '0x00000000000000000000000000000000000000aa',
+          from: otherAddress,
+          to: address,
+        },
+      ],
+    } as Partial<V1TransactionByHashResponse>);
+    const outgoing = buildTransaction({ hash: '0xoutgoing' });
+
+    const result = selectTransactions({ address })(
+      buildData([incomingTokenTransfer, outgoing]),
+    );
+
+    expect(result.pages[0].data).toHaveLength(1);
+    expect(result.pages[0].data[0].hash).toBe('0xoutgoing');
+  });
+
+  it('filters incoming native transfers', () => {
+    const incomingNativeTransfer = buildTransaction({
+      hash: '0xincoming-native',
+      from: otherAddress,
+      to: address,
+      valueTransfers: [
+        {
+          from: otherAddress,
+          to: address,
+        },
+      ],
+    } as Partial<V1TransactionByHashResponse>);
+    const outgoing = buildTransaction({ hash: '0xoutgoing' });
+
+    const result = selectTransactions({ address })(
+      buildData([incomingNativeTransfer, outgoing]),
+    );
+
+    expect(result.pages[0].data).toHaveLength(1);
+    expect(result.pages[0].data[0].hash).toBe('0xoutgoing');
+  });
+
+  it('filters zero-value self sends without calldata or transfers', () => {
+    const selfSend = buildTransaction({
+      from: address,
+      to: address,
+      value: '0',
+      methodId: '0x',
+      valueTransfers: [],
+    });
+
+    const result = selectTransactions({ address })(buildData([selfSend]));
+
+    expect(result.pages[0].data).toHaveLength(0);
+  });
+});
+
+describe('isBridgeHistoryForEvmTransaction', () => {
+  it('matches bridge history by original transaction id', () => {
+    const tx = {
+      id: 'tx-id',
+      actionId: 'action-id',
+    };
+    const bridgeHistoryValues = [
+      {
+        txMetaId: 'different-id',
+        originalTransactionId: 'action-id',
+      },
+    ];
+
+    const result = isBridgeHistoryForEvmTransaction(
+      tx as Parameters<typeof isBridgeHistoryForEvmTransaction>[0],
+      bridgeHistoryValues as Parameters<
+        typeof isBridgeHistoryForEvmTransaction
+      >[1],
+    );
+
+    expect(result).toBe(true);
+  });
+
+  it('matches bridge history by source hash', () => {
+    const tx = {
+      id: 'tx-id',
+      hash: '0xABC',
+    };
+    const bridgeHistoryValues = [
+      {
+        txMetaId: 'different-id',
+        status: {
+          srcChain: {
+            txHash: '0xabc',
+          },
+        },
+      },
+    ];
+
+    const result = isBridgeHistoryForEvmTransaction(
+      tx as Parameters<typeof isBridgeHistoryForEvmTransaction>[0],
+      bridgeHistoryValues as Parameters<
+        typeof isBridgeHistoryForEvmTransaction
+      >[1],
+    );
+
+    expect(result).toBe(true);
+  });
+});
+
+describe('mergeTransactionsByTime', () => {
+  it('sorts unified transactions by time and removes local transactions with confirmed hashes', () => {
+    const localDuplicate = {
+      id: 'local-duplicate',
+      hash: '0xDUPLICATE',
+      time: 300,
+    };
+    const localUnique = {
+      id: 'local-unique',
+      hash: '0xlocal',
+      time: 200,
+    };
+    const confirmedDuplicate = {
+      id: 'confirmed-duplicate',
+      hash: '0xduplicate',
+      time: 400,
+    };
+    const nonEvm = {
+      id: 'non-evm',
+      timestamp: 1,
+    };
+
+    const result = mergeTransactionsByTime(
+      [localDuplicate, localUnique] as Parameters<
+        typeof mergeTransactionsByTime
+      >[0],
+      [confirmedDuplicate] as Parameters<typeof mergeTransactionsByTime>[1],
+      [nonEvm] as Parameters<typeof mergeTransactionsByTime>[2],
+    );
+
+    expect(result).toStrictEqual([
+      {
+        kind: TransactionKind.NonEvm,
+        tx: nonEvm,
+        time: 1000,
+      },
+      {
+        kind: TransactionKind.ConfirmedEvm,
+        tx: confirmedDuplicate,
+        time: 400,
+      },
+      {
+        kind: TransactionKind.Evm,
+        tx: localUnique,
+        time: 200,
+      },
+    ]);
+  });
 });

app/selectors/transactionController.test.ts

@@ -6,9 +6,14 @@ import {
   selectLastWithdrawTokenByType,
   selectLocalTransactions,
   selectNonReplacedTransactions,
+  selectRequiredTransactionIds,
   selectRequiredTransactionHashes,
+  selectRequiredTransactions,
   selectSwapsTransactions,
+  selectTransactionBatchMetadataById,
   selectTransactionMetadataById,
+  selectTransactionsByBatchId,
+  selectTransactionsByIds,
   selectSortedTransactions,
   selectSortedEVMTransactionsForSelectedAccountGroup,
 } from './transactionController';
@@ -125,6 +130,57 @@ describe('TransactionController Selectors', () => {
     });
   });
 
+  describe('selectRequiredTransactionIds', () => {
+    it('returns required child transaction ids', () => {
+      const state = {
+        engine: {
+          backgroundState: {
+            TransactionController: {
+              transactions: [
+                {
+                  id: 'parent',
+                  requiredTransactionIds: ['child-1', 'child-2'],
+                },
+                {
+                  id: 'child-1',
+                },
+              ],
+            },
+          },
+        },
+      } as unknown as RootState;
+
+      expect(selectRequiredTransactionIds(state)).toStrictEqual(
+        new Set(['child-1', 'child-2']),
+      );
+    });
+  });
+
+  describe('selectRequiredTransactions', () => {
+    it('returns transactions referenced by required ids', () => {
+      const child = {
+        id: 'child',
+      };
+      const state = {
+        engine: {
+          backgroundState: {
+            TransactionController: {
+              transactions: [
+                {
+                  id: 'parent',
+                  requiredTransactionIds: ['child'],
+                },
+                child,
+              ],
+            },
+          },
+        },
+      } as unknown as RootState;
+
+      expect(selectRequiredTransactions(state)).toStrictEqual([child]);
+    });
+  });
+
   describe('selectLocalTransactions', () => {
     it('filters required child transactions before nonce dedupe', () => {
       const activeEvmAddress = '0x0000000000000000000000000000000000000001';
@@ -173,8 +229,8 @@ describe('TransactionController Selectors', () => {
         pendingSmartTransactionsForGroup: [],
       } as unknown as RootState;
 
-      expect(selectLocalTransactions(state).map(({ id }) => id)).toStrictEqual([
-        'parent',
+      expect(selectLocalTransactions(state)).toStrictEqual([
+        expect.objectContaining({ id: 'parent' }),
       ]);
     });
   });
@@ -221,6 +277,78 @@ describe('TransactionController Selectors', () => {
     });
   });
 
+  describe('selectTransactionBatchMetadataById', () => {
+    it('returns the transaction batch matching the given id', () => {
+      const batch = {
+        id: 'batch-id',
+      };
+      const state = {
+        engine: {
+          backgroundState: {
+            TransactionController: {
+              transactions: [],
+              transactionBatches: [batch],
+            },
+          },
+        },
+      } as unknown as RootState;
+
+      expect(selectTransactionBatchMetadataById(state, 'batch-id')).toBe(batch);
+    });
+  });
+
+  describe('selectTransactionsByIds', () => {
+    it('returns matching transactions in requested id order', () => {
+      const first = {
+        id: 'first',
+      };
+      const second = {
+        id: 'second',
+      };
+      const state = {
+        engine: {
+          backgroundState: {
+            TransactionController: {
+              transactions: [first, second],
+            },
+          },
+        },
+      } as unknown as RootState;
+
+      expect(
+        selectTransactionsByIds(state, ['second', 'missing', 'first']),
+      ).toStrictEqual([second, first]);
+    });
+  });
+
+  describe('selectTransactionsByBatchId', () => {
+    it('returns transactions matching the batch id', () => {
+      const matchingTransaction = {
+        id: 'matching',
+        batchId: 'batch-id',
+      };
+      const state = {
+        engine: {
+          backgroundState: {
+            TransactionController: {
+              transactions: [
+                matchingTransaction,
+                {
+                  id: 'other',
+                  batchId: 'other-batch-id',
+                },
+              ],
+            },
+          },
+        },
+      } as unknown as RootState;
+
+      expect(selectTransactionsByBatchId(state, 'batch-id')).toStrictEqual([
+        matchingTransaction,
+      ]);
+    });
+  });
+
   describe('selectSortedTransactions', () => {
     it('merges non-replaced transactions and pending smart transactions and sorts them descending by time', () => {
       // Transactions with one replaced transaction and two non-replaced ones