Add missing test cases

Author: danmuf

test/wrapper/htlc-wrapper-test.js

@@ -139,12 +139,12 @@ contract('HashedTimelockWrapper', accounts => {
     const address = await HtlcWrapper.deployContract(HashedTimelock, null, null)
     htlcWrapper.setAddress(address.address)
 
-    const timelock1Second = nowSeconds() + 1
+    const timelock10Minutes = nowSeconds() + 600
 
     await htlcWrapper.newContract(
       receiver,
       hashPair.hash,
-      timelock1Second,
+      timelock10Minutes,
       sender,
       oneFinney
     )

test/wrapper/htlcErc20-wrapper-test.js

@@ -0,0 +1,95 @@
+const HtlcWrapperErc20 = require('../../wrapper/htlc-wrapper-erc20')
+
+const {assertEqualBN} = require('../helper/assert')
+const {
+  htlcERC20ArrayToObj,
+  isSha256Hash,
+  newSecretHashPair,
+  nowSeconds,
+  txLoggedArgs,
+} = require('../helper/utils')
+
+const HashedTimelockERC20 = artifacts.require('./HashedTimelockERC20.sol')
+const AliceERC20 = artifacts.require('./helper/AliceERC20.sol')
+
+// some testing data
+const hourSeconds = 3600
+const timeLock1Hour = nowSeconds() + hourSeconds
+const tokenAmount = 5
+
+contract('HashedTimelockErc20Wrapper', accounts => {
+  const sender = accounts[1]
+  const receiver = accounts[2]
+  const tokenSupply = 1000
+  const senderInitialBalance = 100
+  const provider = new web3.providers.HttpProvider("http://localhost:7545");
+
+  let htlcWrapper
+  let token
+
+  const assertTokenBal = async (addr, tokenAmount, msg) =>
+    assertEqualBN(
+      await token.balanceOf.call(addr),
+      tokenAmount,
+      msg ? msg : 'wrong token balance'
+    )
+
+  before(async () => {
+    htlcWrapper = new HtlcWrapperErc20(HashedTimelockERC20, provider, null);
+    let address = await HashedTimelockERC20.new()
+    htlcWrapper.setAddress(address.address)
+    token = await AliceERC20.new(tokenSupply)
+    await token.transfer(sender, senderInitialBalance)
+    await assertTokenBal(
+      sender,
+      senderInitialBalance,
+      'balance not transferred in before()'
+    )
+  })
+
+  it('newContract() in wrapper should create new contract and store correct details', async () => {
+    const hashPair = newSecretHashPair()
+    await token.approve(htlcWrapper.address, tokenAmount, {from: sender})
+    const newContractTx = await  htlcWrapper.newContract(
+      receiver,
+      hashPair.hash,
+      timeLock1Hour,
+      token.address,
+      tokenAmount,
+      sender
+    )
+
+    // check token balances
+    assertTokenBal(sender, senderInitialBalance - tokenAmount)
+    assertTokenBal(htlcWrapper.address, tokenAmount)
+
+    // check event logs
+    const logArgs = txLoggedArgs(newContractTx)
+
+    const contractId = logArgs.contractId
+    assert(isSha256Hash(contractId))
+
+    assert.equal(logArgs.sender, sender)
+    assert.equal(logArgs.receiver, receiver)
+    assert.equal(logArgs.tokenContract, token.address)
+    assert.equal(logArgs.amount.toNumber(), tokenAmount)
+    assert.equal(logArgs.hashlock, hashPair.hash)
+    assert.equal(logArgs.timelock, timeLock1Hour)
+
+    // check htlc record
+    const contractArr = await htlcWrapper.getContract(contractId)
+    const contract = htlcERC20ArrayToObj(contractArr)
+    assert.equal(contract.sender, sender)
+    assert.equal(contract.receiver, receiver)
+    assert.equal(contract.token, token.address)
+    assert.equal(contract.amount.toNumber(), tokenAmount)
+    assert.equal(contract.hashlock, hashPair.hash)
+    assert.equal(contract.timelock.toNumber(), timeLock1Hour)
+    assert.isFalse(contract.withdrawn)
+    assert.isFalse(contract.refunded)
+    assert.equal(
+      contract.preimage,
+      '0x0000000000000000000000000000000000000000000000000000000000000000'
+    )
+  })
+})

test/wrapper/htlcErc721-wrapper-test.js

@@ -0,0 +1,90 @@
+const HtlcWrapperErc721 = require('../../wrapper/htlc-wrapper-erc721')
+
+const {assertEqualBN} = require('../helper/assert')
+const {
+  htlcERC20ArrayToObj,
+  isSha256Hash,
+  newSecretHashPair,
+  nowSeconds,
+  txLoggedArgs,
+} = require('../helper/utils')
+
+const HashedTimelockERC721 = artifacts.require('./HashedTimelockERC721.sol')
+const AliceERC721 = artifacts.require('./helper/AliceERC721.sol')
+
+// some testing data
+const hourSeconds = 3600
+const timeLock1Hour = nowSeconds() + hourSeconds
+
+contract('HashedTimelockErc721Wrapper', accounts => {
+  const sender = accounts[1]
+  const receiver = accounts[2]
+  const tokenSupply = 1000
+  const provider = new web3.providers.HttpProvider("http://localhost:7545");
+
+  let htlcWrapper
+  let token
+
+  const assertTokenBal = async (token, addr, tokenAmount, msg) => {
+    assertEqualBN(
+      await token.balanceOf.call(addr),
+      tokenAmount,
+      msg ? msg : 'wrong token balance'
+    )
+  }
+
+  before(async () => {
+    htlcWrapper = new HtlcWrapperErc721(HashedTimelockERC721, provider, null);
+    let address = await HashedTimelockERC721.new()
+    htlcWrapper.setAddress(address.address)
+    token = await AliceERC721.new(tokenSupply)
+    await token.mint(sender, 1)
+    await assertTokenBal(
+      token,
+      sender,
+      1,
+      'balance not transferred to Alice in before()'
+    )
+  })
+
+  it('newContract() in wrapper should create new contract and store correct details', async () => {
+    const hashPair = newSecretHashPair()
+    await token.approve(htlcWrapper.address, 1, {from: sender})
+    const newContractTx = await  htlcWrapper.newContract(
+      receiver,
+      hashPair.hash,
+      timeLock1Hour,
+      token.address,
+      1,
+      sender
+    )
+
+    // check event logs
+    const logArgs = txLoggedArgs(newContractTx)
+
+    const contractId = logArgs.contractId
+    assert(isSha256Hash(contractId))
+
+    assert.equal(logArgs.sender, sender)
+    assert.equal(logArgs.receiver, receiver)
+    assert.equal(logArgs.tokenContract, token.address)
+    assert.equal(logArgs.hashlock, hashPair.hash)
+    assert.equal(logArgs.timelock, timeLock1Hour)
+
+    // check htlc record
+    const contractArr = await htlcWrapper.getContract(contractId)
+    const contract = htlcERC20ArrayToObj(contractArr)
+    assert.equal(contract.sender, sender)
+    assert.equal(contract.receiver, receiver)
+    assert.equal(contract.token, token.address)
+    assert.equal(contract.amount.toNumber(), 1)
+    assert.equal(contract.hashlock, hashPair.hash)
+    assert.equal(contract.timelock.toNumber(), timeLock1Hour)
+    assert.isFalse(contract.withdrawn)
+    assert.isFalse(contract.refunded)
+    assert.equal(
+      contract.preimage,
+      '0x0000000000000000000000000000000000000000000000000000000000000000'
+    )
+  })
+})

wrapper/htlc-wrapper-erc20.js

@@ -15,7 +15,7 @@ class HtlcErc20Wrapper extends BaseWrapper {
    */
   newContract(receiverAddress, hashlock, timelock, tokenContract, amount, sender) {
     return this.getContractInstance().then((instance) => {
-      return instance.newContract(receiverAddress, hashlock, timelock, tokenContract, {
+      return instance.newContract(receiverAddress, hashlock, timelock, tokenContract, amount, {
         from: sender
       })
     })