test for pending tx watcher

test/unit/pending-tx-test.js

@@ -0,0 +1,271 @@
+const assert = require('assert')
+const ethUtil = require('ethereumjs-util')
+const EthTx = require('ethereumjs-tx')
+const ObservableStore = require('obs-store')
+const clone = require('clone')
+const PendingTransactionWatcher = require('../../app/scripts/lib/pending-tx-watchers')
+const noop = () => true
+const currentNetworkId = 42
+const otherNetworkId = 36
+const privKey = new Buffer('8718b9618a37d1fc78c436511fc6df3c8258d3250635bba617f33003270ec03e', 'hex')
+
+describe('PendingTransactionWatcher', function () {
+  let pendingTxWatcher, txMeta, txMetaNoHash, txMetaNoRawTx
+  this.timeout(10000)
+  beforeEach(function () {
+    txMeta = {
+      id: 1,
+      hash: '0x0593ee121b92e10d63150ad08b4b8f9c7857d1bd160195ee648fb9a0f8d00eebBlock',
+      status: 'signed',
+      txParams: {
+        from: '0x1678a085c290ebd122dc42cba69373b5953b831d',
+        nonce: '0x1',
+        value: '0xfffff',
+      },
+      rawTx: '0xf86c808504a817c800827b0d940c62bb85faa3311a998d3aba8098c1235c564966880de0b6b3a7640000802aa08ff665feb887a25d4099e40e11f0fef93ee9608f404bd3f853dd9e84ed3317a6a02ec9d3d1d6e176d4d2593dd760e74ccac753e6a0ea0d00cc9789d0d7ff1f471d',
+    }
+    txMetaNoHash = {
+      id: 2,
+      status: 'signed',
+      txParams: { from: '0x1678a085c290ebd122dc42cba69373b5953b831d'},
+    }
+    txMetaNoRawTx = {
+      hash: '0x0593ee121b92e10d63150ad08b4b8f9c7857d1bd160195ee648fb9a0f8d00eebBlock',
+      status: 'signed',
+      txParams: { from: '0x1678a085c290ebd122dc42cba69373b5953b831d'},
+    }
+
+    pendingTxWatcher = new PendingTransactionWatcher({
+      provider: { sendAsync: noop },
+      getBalance: () => {},
+      nonceTracker: {
+        getGlobalLock: async () => {
+          return { releaseLock: () => {} }
+        }
+      },
+      getPendingTransactions: () => {return []},
+      sufficientBalance: () => {},
+      publishTransaction: () => {},
+    })
+
+    pendingTxWatcher.query = new Proxy({}, {
+      get: (queryStubResult, key) => {
+        if (key === 'stubResult') {
+          return function (method, ...args) {
+            queryStubResult[method] = args
+          }
+        } else {
+          const returnValues = queryStubResult[key]
+          return () => Promise.resolve(...returnValues)
+        }
+      },
+    })
+
+  })
+
+  describe('#checkForTxInBlock', function () {
+    it('should return if no pending transactions', function () {
+      // throw a type error if it trys to do anything on the block
+      // thus failing the test
+      const block = Proxy.revocable({}, {}).revoke()
+      pendingTxWatcher.checkForTxInBlock(block)
+    })
+    it('should emit \'txFailed\' if the txMeta does not have a hash', function (done) {
+      const block = Proxy.revocable({}, {}).revoke()
+      pendingTxWatcher.getPendingTransactions = () => [txMetaNoHash]
+      pendingTxWatcher.once('txFailed', (txId, err) => {
+        assert(txId, txMetaNoHash.id, 'should pass txId')
+        done()
+      })
+      pendingTxWatcher.checkForTxInBlock(block)
+    })
+    it('should emit \'txConfirmed\' if the tx is in the block', function (done) {
+      const block = { transactions: [txMeta]}
+      pendingTxWatcher.getPendingTransactions = () => [txMeta]
+      pendingTxWatcher.once('txConfirmed', (txId) => {
+        assert(txId, txMeta.id, 'should pass txId')
+        done()
+      })
+      pendingTxWatcher.once('txFailed', (_, err) => { done(err) })
+      pendingTxWatcher.checkForTxInBlock(block)
+    })
+  })
+  describe('#queryPendingTxs', function () {
+    it('should call #_checkPendingTxs if their is no oldBlock', function (done) {
+      let newBlock, oldBlock
+      newBlock = { number: '0x01' }
+      pendingTxWatcher._checkPendingTxs = done
+      pendingTxWatcher.queryPendingTxs({oldBlock, newBlock})
+    })
+    it('should call #_checkPendingTxs if oldBlock and the newBlock have a diff of greater then 1', function (done) {
+      let newBlock, oldBlock
+      oldBlock = { number: '0x01' }
+      newBlock = { number: '0x03' }
+      pendingTxWatcher._checkPendingTxs = done
+      pendingTxWatcher.queryPendingTxs({oldBlock, newBlock})
+    })
+    it('should not call #_checkPendingTxs if oldBlock and the newBlock have a diff of 1 or less', function (done) {
+      let newBlock, oldBlock
+      oldBlock = { number: '0x1' }
+      newBlock = { number: '0x2' }
+      pendingTxWatcher._checkPendingTxs = () => {
+        const err = new Error('should not call #_checkPendingTxs if oldBlock and the newBlock have a diff of 1 or less')
+        done(err)
+      }
+      pendingTxWatcher.queryPendingTxs({oldBlock, newBlock})
+      done()
+    })
+  })
+
+  describe('#_checkPendingTx', function () {
+    it('should emit \'txFailed\' if the txMeta does not have a hash', function (done) {
+      pendingTxWatcher.once('txFailed', (txId, err) => {
+        assert(txId, txMetaNoHash.id, 'should pass txId')
+        done()
+      })
+      pendingTxWatcher._checkPendingTx(txMetaNoHash)
+    })
+
+    it('should should return if query does not return txParams', function () {
+      pendingTxWatcher.query.stubResult('getTransactionByHash', null)
+      pendingTxWatcher._checkPendingTx(txMeta)
+    })
+
+    it('should emit \'txConfirmed\'', function (done) {
+      pendingTxWatcher.query.stubResult('getTransactionByHash', {blockNumber: '0x01'})
+      pendingTxWatcher.once('txConfirmed', (txId) => {
+        assert(txId, txMeta.id, 'should pass txId')
+        done()
+      })
+      pendingTxWatcher.once('txFailed', (_, err) => { done(err) })
+      pendingTxWatcher._checkPendingTx(txMeta)
+    })
+  })
+
+  describe('#_checkPendingTxs', function () {
+    beforeEach(function () {
+      const txMeta2 = txMeta3 = txMeta
+      txMeta2.id = 2
+      txMeta3.id = 3
+      txList = [txMeta, txMeta2, txMeta3].map((tx) => {
+        tx.processed = new Promise ((resolve) => { tx.resolve = resolve })
+        return tx
+      })
+    })
+
+    it('should warp all txMeta\'s in #_checkPendingTx', function (done) {
+      pendingTxWatcher.getPendingTransactions = () => txList
+      pendingTxWatcher._checkPendingTx = (tx) => { tx.resolve(tx) }
+      const list = txList.map
+      Promise.all(txList.map((tx) => tx.processed))
+      .then((txCompletedList) => done())
+      .catch(done)
+
+      pendingTxWatcher._checkPendingTxs()
+    })
+  })
+
+  describe('#resubmitPendingTxs', function () {
+    beforeEach(function () {
+    const txMeta2 = txMeta3 = txMeta
+    txList = [txMeta, txMeta2, txMeta3].map((tx) => {
+        tx.processed = new Promise ((resolve) => { tx.resolve = resolve })
+        return tx
+      })
+    })
+
+    it('should return if no pending transactions', function () {
+      pendingTxWatcher.resubmitPendingTxs()
+    })
+    it('should call #_resubmitTx for all pending tx\'s', function (done) {
+      pendingTxWatcher.getPendingTransactions = () => txList
+      pendingTxWatcher._resubmitTx = async (tx) => { tx.resolve(tx) }
+      Promise.all(txList.map((tx) => tx.processed))
+      .then((txCompletedList) => done())
+      .catch(done)
+      pendingTxWatcher.resubmitPendingTxs()
+    })
+    it('should not emit \'txFailed\' if the txMeta throws a known txError', function (done) {
+      knownErrors =[
+        // geth
+        '     Replacement transaction Underpriced            ',
+        '       known transaction',
+        // parity
+        'Gas price too low to replace     ',
+        '     transaction with the sAme hash was already imported',
+        // other
+        '       gateway timeout',
+        '         noncE too low       ',
+      ]
+      const enoughForAllErrors = txList.concat(txList)
+
+      pendingTxWatcher.on('txFailed', (_, err) => done(err))
+
+      pendingTxWatcher.getPendingTransactions = () => enoughForAllErrors
+      pendingTxWatcher._resubmitTx = async (tx) => {
+        tx.resolve()
+        throw new Error(knownErrors.pop())
+      }
+      Promise.all(txList.map((tx) => tx.processed))
+      .then((txCompletedList) => done())
+      .catch(done)
+
+      pendingTxWatcher.resubmitPendingTxs()
+    })
+    it('should emit \'txFailed\' if it encountered a real error', function (done) {
+      pendingTxWatcher.once('txFailed', (id, err) => err.message === 'im some real error' ? txList[id - 1].resolve() : done(err))
+
+      pendingTxWatcher.getPendingTransactions = () => txList
+      pendingTxWatcher._resubmitTx = async (tx) => { throw new TypeError('im some real error') }
+      Promise.all(txList.map((tx) => tx.processed))
+      .then((txCompletedList) => done())
+      .catch(done)
+
+      pendingTxWatcher.resubmitPendingTxs()
+    })
+  })
+  describe('#_resubmitTx with a too-low balance', function () {
+    it('should return before publishing the transaction because to low of balance', function (done) {
+    const lowBalance = '0x0'
+    pendingTxWatcher.getBalance = (address) => {
+      assert.equal(address, txMeta.txParams.from, 'Should pass the address')
+      return lowBalance
+    }
+    pendingTxWatcher.publishTransaction = async (rawTx) => {
+      done(new Error('tried to publish transaction'))
+    }
+
+    // Stubbing out current account state:
+    // Adding the fake tx:
+    pendingTxWatcher.once('txWarning', (txMeta) => {
+      assert(txMeta.warning.message, 'Should have a warning message')
+      done()
+    })
+    pendingTxWatcher._resubmitTx(txMeta)
+    .catch((err) => {
+     assert.ifError(err, 'should not throw an error')
+     done(err)
+    })
+  })
+
+    it('should publishing the transaction', function (done) {
+    const enoughBalance = '0x100000'
+    pendingTxWatcher.getBalance = (address) => {
+      assert.equal(address, txMeta.txParams.from, 'Should pass the address')
+      return enoughBalance
+    }
+    pendingTxWatcher.publishTransaction = async (rawTx) => {
+      assert.equal(rawTx, txMeta.rawTx, 'Should pass the rawTx')
+    }
+
+    // Stubbing out current account state:
+    // Adding the fake tx:
+    pendingTxWatcher._resubmitTx(txMeta)
+    .then(() => done())
+    .catch((err) => {
+     assert.ifError(err, 'should not throw an error')
+     done(err)
+    })
+  })
+ })
+})

test/unit/tx-controller-test.js

@@ -27,7 +27,8 @@ describe('Transaction Controller', function () {
       }),
     })
     txController.nonceTracker.getNonceLock = () => Promise.resolve({ nextNonce: 0, releaseLock: noop })
-    txController.query = new Proxy({}, {
+    txController.txProviderUtils = new TxProvideUtils(txController.provider)
+    txController.query = txController.txProviderUtils.query = new Proxy({}, {
       get: (queryStubResult, key) => {
         if (key === 'stubResult') {
           return function (method, ...args) {
@@ -39,7 +40,7 @@ describe('Transaction Controller', function () {
         }
       },
     })
-    txController.txProviderUtils = new TxProvideUtils(txController.query)
+
   })
 
   describe('#newUnapprovedTransaction', function () {
@@ -76,7 +77,6 @@ describe('Transaction Controller', function () {
     it('should resolve when finished and status is submitted and resolve with the hash', function (done) {
       txController.once('newUnaprovedTx', (txMetaFromEmit) => {
         setTimeout(() => {
-          console.log('HELLLO')
           txController.setTxHash(txMetaFromEmit.id, '0x0')
           txController.setTxStatusSubmitted(txMetaFromEmit.id)
         }, 10)
@@ -93,7 +93,6 @@ describe('Transaction Controller', function () {
     it('should reject when finished and status is rejected', function (done) {
       txController.once('newUnaprovedTx', (txMetaFromEmit) => {
         setTimeout(() => {
-          console.log('HELLLO')
           txController.setTxStatusRejected(txMetaFromEmit.id)
         }, 10)
       })
@@ -429,46 +428,4 @@ describe('Transaction Controller', function () {
       }).catch(done)
     })
   })
-
-  describe('#_resubmitTx with a too-low balance', function () {
-    it('should fail the transaction', function (done) {
-      const from = '0xda0da0'
-      const txMeta = {
-        id: 1,
-        status: 'submitted',
-        metamaskNetworkId: currentNetworkId,
-        txParams: {
-          from,
-          nonce: '0x1',
-          value: '0xfffff',
-        },
-      }
-
-      const lowBalance = '0x0'
-      const fakeStoreState = { accounts: {} }
-      fakeStoreState.accounts[from] = {
-        balance: lowBalance,
-        nonce: '0x0',
-      }
-
-      // Stubbing out current account state:
-      const getStateStub = sinon.stub(txController.ethStore, 'getState')
-      .returns(fakeStoreState)
-
-      // Adding the fake tx:
-      txController.addTx(clone(txMeta))
-
-      txController._resubmitTx(txMeta)
-      .then(() => {
-        const updatedMeta = txController.getTx(txMeta.id)
-        assert.notEqual(updatedMeta.status, txMeta.status, 'status changed.')
-        assert.equal(updatedMeta.status, 'failed', 'tx set to failed.')
-        done()
-      })
-      .catch((err) => {
-        assert.ifError(err, 'should not throw an error')
-        done(err)
-      })
-    })
-  })
 })

test/unit/tx-utils-test.js

@@ -1,7 +1,7 @@
 const assert = require('assert')
-const ethUtil = require('ethereumjs-util')
-const BN = ethUtil.BN
+const BN = require('bn.js')
 
+const { hexToBn, bnToHex } = require('../../app/scripts/lib/util')
 const TxUtils = require('../../app/scripts/lib/tx-utils')
 
 
@@ -16,44 +16,6 @@ describe('txUtils', function () {
     }))
   })
 
-  describe('#sufficientBalance', function () {
-    it('returns true if max tx cost is equal to balance.', function () {
-      const tx = {
-        'value': '0x1',
-        'gas': '0x2',
-        'gasPrice': '0x3',
-      }
-      const balance = '0x8'
-
-      const result = txUtils.sufficientBalance(tx, balance)
-      assert.ok(result, 'sufficient balance found.')
-    })
-
-    it('returns true if max tx cost is less than balance.', function () {
-      const tx = {
-        'value': '0x1',
-        'gas': '0x2',
-        'gasPrice': '0x3',
-      }
-      const balance = '0x9'
-
-      const result = txUtils.sufficientBalance(tx, balance)
-      assert.ok(result, 'sufficient balance found.')
-    })
-
-    it('returns false if max tx cost is more than balance.', function () {
-      const tx = {
-        'value': '0x1',
-        'gas': '0x2',
-        'gasPrice': '0x3',
-      }
-      const balance = '0x6'
-
-      const result = txUtils.sufficientBalance(tx, balance)
-      assert.ok(!result, 'insufficient balance found.')
-    })
-  })
-
   describe('chain Id', function () {
     it('prepares a transaction with the provided chainId', function () {
       const txParams = {
@@ -96,7 +58,7 @@ describe('txUtils', function () {
       assert(outputBn.eq(expectedBn), 'returns the original estimatedGas value')
     })
 
-    it('buffers up to reccomend gas limit reccomended ceiling', function () {
+    it('buffers up to recommend gas limit recommended ceiling', function () {
       // naive estimatedGas: 0x16e360 (1.5 mil)
       const inputHex = '0x16e360'
       // dummy gas limit: 0x1e8480 (2 mil)
@@ -107,17 +69,7 @@ describe('txUtils', function () {
       // const inputBn = hexToBn(inputHex)
       // const outputBn = hexToBn(output)
       const expectedHex = bnToHex(ceilGasLimitBn)
-      assert.equal(output, expectedHex, 'returns the gas limit reccomended ceiling value')
+      assert.equal(output, expectedHex, 'returns the gas limit recommended ceiling value')
     })
   })
 })
-
-// util
-
-function hexToBn (inputHex) {
-  return new BN(ethUtil.stripHexPrefix(inputHex), 16)
-}
-
-function bnToHex (inputBn) {
-  return ethUtil.addHexPrefix(inputBn.toString(16))
-}

test/unit/util-test.js

@@ -2,7 +2,7 @@ const assert = require('assert')
 const { sufficientBalance } = require('../../app/scripts/lib/util')
 
 
-describe.only('SufficientBalance', function () {
+describe('SufficientBalance', function () {
   it('returns true if max tx cost is equal to balance.', function () {
     const tx = {
       'value': '0x1',