@rosen-bridge/tx-pot 0.1.0 → 1.0.1

package/tests/transaction/TxPot.spec.ts

@@ -1,6 +1,11 @@
 import { Repository } from 'typeorm';
 import { mockDataSource } from '../db/dataSource.mock';
-import { TransactionEntity, TransactionStatus } from '../../lib';
+import {
+  CallbackFunction,
+  TransactionEntity,
+  TransactionStatus,
+  ValidatorFunction,
+} from '../../lib';
 import { TestTxPot } from './TestTxPot';
 import * as testData from './testData';
 import { TestPotChainManager } from '../network/TestPotChainManager';
@@ -25,6 +30,87 @@ describe('TxPot', () => {
     vi.useRealTimers();
   });
 
+  describe('unregisterValidator', () => {
+    /**
+     * @target TxPot.unregisterValidator should remove registered validator successfully
+     * @dependencies
+     * @scenario
+     * - register a validator function
+     * - run test
+     * - check registered validators
+     * @expected
+     * - there should be no validator
+     */
+    it('should remove registered validator successfully', async () => {
+      const mockedValidator = async (tx: TransactionEntity) => true;
+      txPot.registerValidator('chain', 'txType', 'id', mockedValidator);
+
+      txPot.unregisterValidator('chain', 'txType', 'id');
+
+      const validatorsMap: Map<
+        string,
+        Map<string, Map<string, ValidatorFunction>>
+      > = (txPot as any).validators;
+      expect(validatorsMap.get('chain')?.get('txType')?.size).toEqual(0);
+    });
+  });
+
+  describe('unregisterSubmitValidator', () => {
+    /**
+     * @target TxPot.unregisterSubmitValidator should remove registered submit validator successfully
+     * @dependencies
+     * @scenario
+     * - register a validator function
+     * - run test
+     * - check registered submit validators
+     * @expected
+     * - there should be no validator
+     */
+    it('should remove registered submit validator successfully', async () => {
+      const mockedValidator = async (tx: TransactionEntity) => true;
+      txPot.registerSubmitValidator('chain', 'id', mockedValidator);
+
+      txPot.unregisterSubmitValidator('chain', 'id');
+
+      const validatorsMap: Map<string, Map<string, ValidatorFunction>> = (
+        txPot as any
+      ).submissionAllowance;
+      expect(validatorsMap.get('chain')?.size).toEqual(0);
+    });
+  });
+
+  describe('unregisterCallback', () => {
+    /**
+     * @target TxPot.unregisterCallback should remove registered submit validator successfully
+     * @dependencies
+     * @scenario
+     * - register a validator function
+     * - run test
+     * - check registered submit validators
+     * @expected
+     * - there should be no validator
+     */
+    it('should remove registered submit validator successfully', async () => {
+      const mockedCallback = vi.fn();
+      txPot.registerCallback(
+        'txType',
+        TransactionStatus.SIGNED,
+        'id',
+        mockedCallback
+      );
+
+      txPot.unregisterCallback('txType', TransactionStatus.SIGNED, 'id');
+
+      const callbacksMap: Map<
+        string,
+        Map<TransactionStatus, Map<string, CallbackFunction>>
+      > = (txPot as any).txTypeCallbacks;
+      expect(
+        callbacksMap.get('txType')?.get(TransactionStatus.SIGNED)?.size
+      ).toEqual(0);
+    });
+  });
+
   describe('setTransactionAsInvalid', () => {
     /**
      * @target TxPot.setTransactionAsInvalid should update status when enough blocks is passed
@@ -153,6 +239,7 @@ describe('TxPot', () => {
       txPot.registerValidator(
         testData.tx1.chain,
         testData.tx1.txType,
+        'id',
         mockedValidator
       );
 
@@ -182,6 +269,7 @@ describe('TxPot', () => {
       txPot.registerValidator(
         testData.tx1.chain,
         testData.tx1.txType,
+        'id',
         mockedValidator
       );
 
@@ -194,6 +282,52 @@ describe('TxPot', () => {
       expect(res).toEqual(false);
       expect(mockedSetTransactionAsInvalid).toHaveBeenCalled();
     });
+
+    /**
+     * @target TxPot.validateTx should return false and set tx as invalid
+     * when at least one validator returns false
+     * @dependencies
+     * - database
+     * @scenario
+     * - insert tx into db
+     * - register 3 validator functions (1st and 3rd ones returns true, 2nd one returns false)
+     * - mock TxPot.setTransactionAsInvalid
+     * - run test
+     * - check returned value
+     * - check if function got called
+     * @expected
+     * - should return false
+     * - `setTransactionAsInvalid` should got called
+     */
+    it('should return false and set tx as invalid when at least one validator returns false', async () => {
+      await txRepository.insert(testData.tx1);
+
+      const mockedValidators = [
+        { id: 'validator-1', validator: async (tx: TransactionEntity) => true },
+        {
+          id: 'validator-2',
+          validator: async (tx: TransactionEntity) => false,
+        },
+        { id: 'validator-3', validator: async (tx: TransactionEntity) => true },
+      ];
+      mockedValidators.forEach((mockedValidator) =>
+        txPot.registerValidator(
+          testData.tx1.chain,
+          testData.tx1.txType,
+          mockedValidator.id,
+          mockedValidator.validator
+        )
+      );
+
+      const mockedSetTransactionAsInvalid = vi.fn();
+      vi.spyOn(txPot as any, 'setTransactionAsInvalid').mockImplementation(
+        mockedSetTransactionAsInvalid
+      );
+
+      const res = await txPot.callValidateTx(testData.tx1);
+      expect(res).toEqual(false);
+      expect(mockedSetTransactionAsInvalid).toHaveBeenCalled();
+    });
   });
 
   describe('setTxStatus', () => {
@@ -262,7 +396,12 @@ describe('TxPot', () => {
       const newStatus = TransactionStatus.IN_SIGN;
       const mockedCallback = vi.fn();
       mockedCallback.mockResolvedValue(undefined);
-      txPot.registerCallback(testData.tx1.txType, newStatus, mockedCallback);
+      txPot.registerCallback(
+        testData.tx1.txType,
+        newStatus,
+        'id',
+        mockedCallback
+      );
 
       // run test
       await txPot.callSetTxStatus(testData.tx1, newStatus);
@@ -348,6 +487,7 @@ describe('TxPot', () => {
      * - insert tx with signed status
      * - mock PotChainManager and register to TxPot
      *   - mock `submitTransaction` to throw error
+     * - register submit validator function
      * - run test (call `update`)
      * - check if function got called
      * - check db records
@@ -373,6 +513,13 @@ describe('TxPot', () => {
         mockedSubmitTransaction
       );
 
+      // register submit validator function
+      txPot.registerSubmitValidator(
+        testData.tx1.chain,
+        'validator-1',
+        async (tx: TransactionEntity) => true
+      );
+
       // run test
       await txPot.update();
 
@@ -393,6 +540,73 @@ describe('TxPot', () => {
         ],
       ]);
     });
+
+    /**
+     * @target TxPot.processSignedTx should not submit the tx nor update the status
+     * when at least one submit validator does not allow submission
+     * @dependencies
+     * - database
+     * @scenario
+     * - insert tx with signed status
+     * - mock PotChainManager and register to TxPot
+     *   - mock `submitTransaction`
+     * - register 3 submit validator functions
+     *   - 1st and 3rd ones returns true
+     *   - 2nd one returns false
+     * - run test (call `update`)
+     * - check if function got called
+     * - check db records
+     * @expected
+     * - `submitTransaction` should NOT got called
+     * - columns of the tx should remain unchanged
+     */
+    it('should not submit the tx nor update the status when at least one submit validator does not allow submission', async () => {
+      // insert tx with signed status
+      await txRepository.insert(testData.tx4);
+
+      // mock PotChainManager and register to TxPot
+      const mockedManager = new TestPotChainManager();
+      txPot.registerChain(testData.tx4.chain, mockedManager);
+      // mock `submitTransaction`
+      const mockedSubmitTransaction = vi.fn();
+      mockedSubmitTransaction.mockResolvedValue(undefined);
+      vi.spyOn(mockedManager, 'submitTransaction').mockImplementation(
+        mockedSubmitTransaction
+      );
+
+      // register 3 submit validator functions
+      const mockedValidators = [
+        { id: 'validator-1', validator: async (tx: TransactionEntity) => true },
+        {
+          id: 'validator-2',
+          validator: async (tx: TransactionEntity) => false,
+        },
+        { id: 'validator-3', validator: async (tx: TransactionEntity) => true },
+      ];
+      mockedValidators.forEach((mockedValidator) =>
+        txPot.registerSubmitValidator(
+          testData.tx1.chain,
+          mockedValidator.id,
+          mockedValidator.validator
+        )
+      );
+
+      // run test
+      await txPot.update();
+
+      // check if function got called
+      expect(mockedSubmitTransaction).not.toHaveBeenCalled();
+
+      // check db records
+      const txs = (await txRepository.find()).map((tx) => [
+        tx.txId,
+        tx.status,
+        tx.lastStatusUpdate,
+      ]);
+      expect(txs).toEqual([
+        [testData.tx4.txId, testData.tx4.status, testData.tx4.lastStatusUpdate],
+      ]);
+    });
   });
 
   describe('processesSentTx', () => {
@@ -593,6 +807,60 @@ describe('TxPot', () => {
       expect(mockedSubmitTransaction).toHaveBeenCalled();
     });
 
+    /**
+     * @target TxPot.processesSentTx should not resubmit if submit validator does not allow
+     * @dependencies
+     * - database
+     * @scenario
+     * - insert tx with sent status
+     * - mock PotChainManager and register to TxPot
+     *   - mock `getTxConfirmation`
+     *   - mock `getTxRequiredConfirmation` to return -1
+     *   - mock `isTxInMempool` to return false
+     *   - mock `isTxValid` to return true
+     *   - mock `submitTransaction`
+     * - register a submit validator function to return false
+     * - run test (call `update`)
+     * - check if function got called
+     * @expected
+     * - `submitTransaction` should NOT got called
+     */
+    it('should not resubmit if submit validator does not allow', async () => {
+      // insert tx with sent status
+      await txRepository.insert(testData.tx6);
+
+      // mock PotChainManager and register to TxPot
+      const mockedManager = new TestPotChainManager();
+      txPot.registerChain(testData.tx6.chain, mockedManager);
+      // mock `getTxConfirmation`
+      vi.spyOn(mockedManager, 'getTxConfirmation').mockResolvedValue(-1);
+      // mock `getTxRequiredConfirmation`
+      vi.spyOn(mockedManager, 'getTxRequiredConfirmation').mockReturnValue(10);
+      // mock `isTxInMempool`
+      vi.spyOn(mockedManager, 'isTxInMempool').mockResolvedValue(false);
+      // mock `isTxValid`
+      vi.spyOn(mockedManager, 'isTxValid').mockResolvedValue(true);
+      // mock `submitTransaction`
+      const mockedSubmitTransaction = vi.fn();
+      mockedSubmitTransaction.mockResolvedValue(undefined);
+      vi.spyOn(mockedManager, 'submitTransaction').mockImplementation(
+        mockedSubmitTransaction
+      );
+
+      // register a submit validator function to return false
+      txPot.registerSubmitValidator(
+        testData.tx6.chain,
+        'validator-2',
+        async (tx: TransactionEntity) => false
+      );
+
+      // run test
+      await txPot.update();
+
+      // check if function got called
+      expect(mockedSubmitTransaction).not.toHaveBeenCalled();
+    });
+
     /**
      * @target TxPot.processesSentTx should set transaction as invalid if tx is not valid anymore
      * @dependencies
@@ -669,6 +937,7 @@ describe('TxPot', () => {
       txPot.registerValidator(
         testData.tx6.chain,
         testData.tx6.txType,
+        'id',
         mockedValidator
       );
 
@@ -752,11 +1021,13 @@ describe('TxPot', () => {
       txPot.registerValidator(
         testData.tx3.chain,
         testData.tx3.txType,
+        'tx3-validator',
         mockedValidator
       );
       txPot.registerValidator(
         testData.tx5.chain,
         testData.tx5.txType,
+        'tx5-validator',
         mockedValidator
       );
 
@@ -807,6 +1078,42 @@ describe('TxPot', () => {
         extra2: null,
       });
     });
+
+    /**
+     * @target TxPot.addTx should insert new tx with extra fields successfully
+     * @dependencies
+     * - Date
+     * - database
+     * @scenario
+     * - run test
+     * - check db records
+     * @expected
+     * - new tx should be inserted
+     */
+    it('should insert new tx with extra fields successfully', async () => {
+      await txPot.addTx(
+        testData.tx3.txId,
+        testData.tx3.chain,
+        testData.tx3.txType,
+        testData.tx3.requiredSign,
+        testData.tx3.serializedTx,
+        testData.tx3.status as TransactionStatus,
+        testData.tx3.lastCheck,
+        testData.tx3.extra,
+        testData.tx3.extra2
+      );
+
+      const txs = await txRepository.find();
+      expect(txs.length).toEqual(1);
+      expect(txs[0]).toEqual({
+        ...testData.tx3,
+        failedInSign: false,
+        signFailedCount: 0,
+        lastStatusUpdate: String(testData.currentTimeStampAsSeconds),
+        extra: testData.tx3.extra,
+        extra2: null,
+      });
+    });
   });
 
   describe('setTxStatusById', () => {
@@ -1514,4 +1821,61 @@ describe('TxPot', () => {
       expect(txs[1].txId).toEqual(testData.tx2.txId);
     });
   });
+
+  describe('updateExtra', () => {
+    /**
+     * @target TxPot.updateExtra should update extra columns successfully
+     * @dependencies
+     * - database
+     * @scenario
+     * - insert 2 txs
+     * - run test
+     * - check db records
+     * @expected
+     * - extra of target tx should be updated
+     * - extra of other txs should remain unchanged
+     */
+    it('should update extra columns successfully', async () => {
+      await txRepository.insert(testData.tx3);
+      await txRepository.insert(testData.tx4);
+
+      const updatedExtra = 'new-extra';
+      await txPot.updateExtra(
+        testData.tx3.txId,
+        testData.tx3.chain,
+        updatedExtra
+      );
+
+      const txs = (await txRepository.find()).map((tx) => [tx.txId, tx.extra]);
+      expect(txs).toEqual([
+        [testData.tx3.txId, updatedExtra],
+        [testData.tx4.txId, testData.tx4.extra],
+      ]);
+    });
+
+    /**
+     * @target TxPot.updateExtra should set null successfully
+     * @dependencies
+     * - database
+     * @scenario
+     * - insert a tx with extra
+     * - run test
+     * - check db records
+     * @expected
+     * - extra of target tx should be updated
+     */
+    it('should set null successfully', async () => {
+      await txRepository.insert(testData.tx3);
+
+      const updatedExtra = null;
+      await txPot.updateExtra(
+        testData.tx3.txId,
+        testData.tx3.chain,
+        updatedExtra
+      );
+
+      const txs = (await txRepository.find()).map((tx) => [tx.txId, tx.extra]);
+      expect(txs).toEqual([[testData.tx3.txId, updatedExtra]]);
+    });
+  });
 });