import { strict as assert } from 'assert'
import * as txUtils from '../../../../../app/scripts/controllers/transactions/lib/util'

describe('txUtils', function () {
  describe('#validateTxParams', function () {
    it('does not throw for positive values', function () {
      const sample = {
        from: '0x1678a085c290ebd122dc42cba69373b5953b831d',
        value: '0x01',
      }
      txUtils.validateTxParams(sample)
    })

    it('returns error for negative values', function () {
      const sample = {
        from: '0x1678a085c290ebd122dc42cba69373b5953b831d',
        value: '-0x01',
      }
      try {
        txUtils.validateTxParams(sample)
      } catch (err) {
        assert.ok(err, 'error')
      }
    })
  })

  describe('#normalizeTxParams', function () {
    it('should normalize txParams', function () {
      const txParams = {
        chainId: '0x1',
        from: 'a7df1beDBF813f57096dF77FCd515f0B3900e402',
        to: null,
        data: '68656c6c6f20776f726c64',
        random: 'hello world',
      }

      let normalizedTxParams = txUtils.normalizeTxParams(txParams)

      assert.ok(!normalizedTxParams.chainId, 'there should be no chainId')
      assert.ok(!normalizedTxParams.to, 'there should be no to address if null')
      assert.equal(normalizedTxParams.from.slice(0, 2), '0x', 'from should be hex-prefixed')
      assert.equal(normalizedTxParams.data.slice(0, 2), '0x', 'data should be hex-prefixed')
      assert.ok(!('random' in normalizedTxParams), 'there should be no random key in normalizedTxParams')

      txParams.to = 'a7df1beDBF813f57096dF77FCd515f0B3900e402'
      normalizedTxParams = txUtils.normalizeTxParams(txParams)
      assert.equal(normalizedTxParams.to.slice(0, 2), '0x', 'to should be hex-prefixed')
    })
  })

  describe('#validateRecipient', function () {
    it('removes recipient for txParams with 0x when contract data is provided', function () {
      const zeroRecipientDataTxParams = {
        from: '0x1678a085c290ebd122dc42cba69373b5953b831d',
        to: '0x',
        data: 'bytecode',
      }
      const sanitizedTxParams = txUtils.validateRecipient(zeroRecipientDataTxParams)
      assert.deepEqual(sanitizedTxParams, { from: '0x1678a085c290ebd122dc42cba69373b5953b831d', data: 'bytecode' }, 'no recipient with 0x')
    })

    it('should error when recipient is 0x', function () {
      const zeroRecipientTxParams = {
        from: '0x1678a085c290ebd122dc42cba69373b5953b831d',
        to: '0x',
      }
      assert.throws(() => {
        txUtils.validateRecipient(zeroRecipientTxParams)
      }, Error, 'Invalid recipient address')
    })
  })


  describe('#validateFrom', function () {
    it('should error when from is not a hex string', function () {

      // where from is undefined
      const txParams = {}
      assert.throws(() => {
        txUtils.validateFrom(txParams)
      }, Error, `Invalid from address ${txParams.from} not a string`)

      // where from is array
      txParams.from = []
      assert.throws(() => {
        txUtils.validateFrom(txParams)
      }, Error, `Invalid from address ${txParams.from} not a string`)

      // where from is a object
      txParams.from = {}
      assert.throws(() => {
        txUtils.validateFrom(txParams)
      }, Error, `Invalid from address ${txParams.from} not a string`)

      // where from is a invalid address
      txParams.from = 'im going to fail'
      assert.throws(() => {
        txUtils.validateFrom(txParams)
      }, Error, `Invalid from address`)

      // should run
      txParams.from = '0x1678a085c290ebd122dc42cba69373b5953b831d'
      txUtils.validateFrom(txParams)
    })
  })
})