fix tests to be compatible with solidity 5

Author: conr2d

test/helper/ASEANToken.sol

@@ -1,16 +1,16 @@
-pragma solidity ^0.4.23;
+pragma solidity ^0.5.0;
 
-import "openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
 
 /**
  * A basic token for testing the HashedTimelockERC20.
  */
-contract ASEANToken is StandardToken {
+contract ASEANToken is ERC20 {
     string public constant name = "ASEAN Token";
     string public constant symbol = "ASEAN";
     uint8 public constant decimals = 18;
-    
-    constructor(uint _initialBalance) public {
-        balances[msg.sender] = _initialBalance;
+
+    constructor(uint256 _initialBalance) public {
+        _mint(msg.sender, _initialBalance);
     }
 }

test/helper/assert.js

@@ -1,8 +1,12 @@
 if (!global.assert) global.assert = require('chai').assert
 
 const assertEqualBN = (actual, expected, msg = 'numbers not equal') => {
+  if (!web3.utils.isBN(actual))
+    actual = web3.utils.toBN(actual)
+  if (!web3.utils.isBN(expected))
+    expected = web3.utils.toBN(expected)
   assert.isTrue(
-    actual.equals(expected),
+    actual.eq(expected),
     `
 \tmsg: ${msg}
 \tactual: ${actual.toString()}

test/helper/utils.js

@@ -26,8 +26,8 @@ const newSecretHashPair = () => {
 
 const nowSeconds = () => Math.floor(Date.now() / 1000)
 
-const gasPrice = 100000000000 // truffle fixed gas price
-const txGas = txReceipt => txReceipt.receipt.gasUsed * gasPrice
+const defaultGasPrice = 100000000000 // truffle fixed gas price
+const txGas = (txReceipt, gasPrice = defaultGasPrice) => web3.utils.toBN(txReceipt.receipt.gasUsed * gasPrice)
 const txLoggedArgs = txReceipt => txReceipt.logs[0].args
 const txContractId = txReceipt => txLoggedArgs(txReceipt).contractId
 
@@ -58,8 +58,11 @@ const htlcERC20ArrayToObj = c => {
   }
 }
 
+const getBalance = async (address) => web3.utils.toBN(await web3.eth.getBalance(address))
+
 export {
   bufToStr,
+  getBalance,
   htlcArrayToObj,
   htlcERC20ArrayToObj,
   isSha256Hash,

test/htlc.js

@@ -3,6 +3,7 @@ import Promise from 'bluebird'
 import {assertEqualBN} from './helper/assert'
 import {
   bufToStr,
+  getBalance,
   htlcArrayToObj,
   isSha256Hash,
   newSecretHashPair,
@@ -15,11 +16,11 @@ import {
 
 const HashedTimelock = artifacts.require('./HashedTimelock.sol')
 
-const REQUIRE_FAILED_MSG = 'VM Exception while processing transaction: revert'
+const REQUIRE_FAILED_MSG = 'Returned error: VM Exception while processing transaction: revert'
 
 const hourSeconds = 3600
 const timeLock1Hour = nowSeconds() + hourSeconds
-const oneFinney = web3.toWei(1, 'finney')
+const oneFinney = web3.utils.toWei(web3.utils.toBN(1), 'finney')
 
 contract('HashedTimelock', accounts => {
   const sender = accounts[1]
@@ -44,15 +45,15 @@ contract('HashedTimelock', accounts => {
 
     assert.equal(logArgs.sender, sender)
     assert.equal(logArgs.receiver, receiver)
-    assert.equal(logArgs.amount, oneFinney)
+    assertEqualBN(logArgs.amount, oneFinney)
     assert.equal(logArgs.hashlock, hashPair.hash)
     assert.equal(logArgs.timelock, timeLock1Hour)
 
     const contractArr = await htlc.getContract.call(contractId)
     const contract = htlcArrayToObj(contractArr)
     assert.equal(contract.sender, sender)
     assert.equal(contract.receiver, receiver)
-    assert.equal(contract.amount, oneFinney)
+    assertEqualBN(contract.amount, oneFinney)
     assert.equal(contract.hashlock, hashPair.hash)
     assert.equal(contract.timelock.toNumber(), timeLock1Hour)
     assert.isFalse(contract.withdrawn)
@@ -73,7 +74,7 @@ contract('HashedTimelock', accounts => {
       })
       assert.fail('expected failure due to 0 value transferred')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 
@@ -89,7 +90,7 @@ contract('HashedTimelock', accounts => {
 
       assert.fail('expected failure due past timelock')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 
@@ -109,7 +110,7 @@ contract('HashedTimelock', accounts => {
       })
       assert.fail('expected failure due to duplicate request')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 
@@ -127,19 +128,20 @@ contract('HashedTimelock', accounts => {
     )
 
     const contractId = txContractId(newContractTx)
-    const receiverBalBefore = web3.eth.getBalance(receiver)
+    const receiverBalBefore = await getBalance(receiver)
 
     // receiver calls withdraw with the secret to get the funds
     const withdrawTx = await htlc.withdraw(contractId, hashPair.secret, {
       from: receiver,
     })
+    const tx = await web3.eth.getTransaction(withdrawTx.tx)
 
     // Check contract funds are now at the receiver address
     const expectedBal = receiverBalBefore
-      .plus(oneFinney)
-      .minus(txGas(withdrawTx))
+      .add(oneFinney)
+      .sub(txGas(withdrawTx, tx.gasPrice))
     assertEqualBN(
-      web3.eth.getBalance(receiver),
+      await getBalance(receiver),
       expectedBal,
       "receiver balance doesn't match"
     )
@@ -170,7 +172,7 @@ contract('HashedTimelock', accounts => {
       await htlc.withdraw(contractId, wrongSecret, {from: receiver})
       assert.fail('expected failure due to 0 value transferred')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 
@@ -192,7 +194,7 @@ contract('HashedTimelock', accounts => {
       await htlc.withdraw(contractId, hashPair.secret, {from: someGuy})
       assert.fail('expected failure due to wrong receiver')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 
@@ -222,7 +224,7 @@ contract('HashedTimelock', accounts => {
             new Error('expected failure due to withdraw after timelock expired')
           )
         } catch (err) {
-          assert.equal(err.message, REQUIRE_FAILED_MSG)
+          assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
           resolve()
         }
       }, 1000)
@@ -249,12 +251,13 @@ contract('HashedTimelock', accounts => {
     return new Promise((resolve, reject) =>
       setTimeout(async () => {
         try {
-          const balBefore = web3.eth.getBalance(sender)
-          const tx = await htlc.refund(contractId, {from: sender})
+          const balBefore = await getBalance(sender)
+          const refundTx = await htlc.refund(contractId, {from: sender})
+          const tx = await web3.eth.getTransaction(refundTx.tx)
           // Check contract funds are now at the senders address
-          const expectedBal = balBefore.plus(oneFinney).minus(txGas(tx))
+          const expectedBal = balBefore.add(oneFinney).sub(txGas(refundTx, tx.gasPrice))
           assertEqualBN(
-            web3.eth.getBalance(sender),
+            await getBalance(sender),
             expectedBal,
             "sender balance doesn't match"
           )
@@ -286,7 +289,7 @@ contract('HashedTimelock', accounts => {
       await htlc.refund(contractId, {from: sender})
       assert.fail('expected failure due to timelock')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 

test/htlcERC20.js

@@ -13,7 +13,7 @@ import {
 const HashedTimelockERC20 = artifacts.require('./HashedTimelockERC20.sol')
 const ASEANToken = artifacts.require('./helper/ASEANToken.sol')
 
-const REQUIRE_FAILED_MSG = 'VM Exception while processing transaction: revert'
+const REQUIRE_FAILED_MSG = 'Returned error: VM Exception while processing transaction: revert'
 
 // some testing data
 const hourSeconds = 3600
@@ -119,12 +119,12 @@ contract('HashedTimelockERC20', accounts => {
   it('newContract() should reject a duplicate contract request', async () => {
     const hashlock = newSecretHashPair().hash
     const timelock = timeLock1Hour + 5
-    const balBefore = await token.balanceOf(htlc.address)
+    const balBefore = web3.utils.toBN(await token.balanceOf(htlc.address))
 
     await newContract({hashlock: hashlock, timelock: timelock})
     await assertTokenBal(
       htlc.address,
-      balBefore.plus(tokenAmount),
+      balBefore.add(web3.utils.toBN(tokenAmount)),
       'tokens not transfered to htlc contract'
     )
 
@@ -172,7 +172,7 @@ contract('HashedTimelockERC20', accounts => {
       await htlc.withdraw(contractId, wrongSecret, {from: receiver})
       assert.fail('expected failure due to 0 value transferred')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 
@@ -188,14 +188,14 @@ contract('HashedTimelockERC20', accounts => {
       await htlc.withdraw(contractId, hashPair.secret, {from: someGuy})
       assert.fail('expected failure due to wrong receiver')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 
   it('withdraw() should fail after timelock expiry', async () => {
     const hashPair = newSecretHashPair()
-    const curBlkTime = web3.eth.getBlock('latest').timestamp
-    const timelock2Seconds = curBlkTime + 2
+    const curBlock = await web3.eth.getBlock('latest')
+    const timelock2Seconds = curBlock.timestamp + 2
 
     const newContractTx = await newContract({
       hashlock: hashPair.hash,
@@ -213,7 +213,7 @@ contract('HashedTimelockERC20', accounts => {
             new Error('expected failure due to withdraw after timelock expired')
           )
         } catch (err) {
-          assert.equal(err.message, REQUIRE_FAILED_MSG)
+          assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
           resolve({message: 'success'})
         }
       }, 2000)
@@ -222,8 +222,8 @@ contract('HashedTimelockERC20', accounts => {
 
   it('refund() should pass after timelock expiry', async () => {
     const hashPair = newSecretHashPair()
-    const curBlkTime = web3.eth.getBlock('latest').timestamp
-    const timelock2Seconds = curBlkTime + 2
+    const curBlock = await web3.eth.getBlock('latest')
+    const timelock2Seconds = curBlock.timestamp + 2
 
     await token.approve(htlc.address, tokenAmount, {from: sender})
     const newContractTx = await newContract({
@@ -243,7 +243,7 @@ contract('HashedTimelockERC20', accounts => {
           // Check tokens returned to the sender
           await assertTokenBal(
             sender,
-            balBefore.plus(tokenAmount),
+            balBefore.add(web3.utils.toBN(tokenAmount)),
             `sender balance unexpected`
           )
 
@@ -266,7 +266,7 @@ contract('HashedTimelockERC20', accounts => {
       await htlc.refund(contractId, {from: sender})
       assert.fail('expected failure due to timelock')
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   })
 
@@ -321,7 +321,7 @@ contract('HashedTimelockERC20', accounts => {
       )
       assert.fail(shouldFailMsg)
     } catch (err) {
-      assert.equal(err.message, REQUIRE_FAILED_MSG)
+      assert.isTrue(err.message.startsWith(REQUIRE_FAILED_MSG))
     }
   }
 })