ciphermask/ui/app/components/send_/tests/send-selectors.test.js

import assert from 'assert'
import selectors from '../send.selectors.js'
const {
  accountsWithSendEtherInfoSelector,
  // autoAddToBetaUI,
  getAddressBook,
  getAmountConversionRate,
  getConversionRate,
  getConvertedCurrency,
  getCurrentAccountWithSendEtherInfo,
  getCurrentCurrency,
  getCurrentNetwork,
  getCurrentViewContext,
  getForceGasMin,
  getGasLimit,
  getGasPrice,
  getGasTotal,
  getPrimaryCurrency,
  getSelectedAccount,
  getSelectedAddress,
  getSelectedIdentity,
  getSelectedToken,
  // getSelectedTokenContract,
  getSelectedTokenExchangeRate,
  getSelectedTokenToFiatRate,
  getSendAmount,
  getSendEditingTransactionId,
  getSendErrors,
  getSendFrom,
  getSendFromBalance,
  getSendFromObject,
  getSendMaxModeState,
  getSendTo,
  getSendToAccounts,
  getTokenBalance,
  getTokenExchangeRate,
  getUnapprovedTxs,
  isSendFormInError,
  // transactionsSelector,
} = selectors
import mockState from './send-selectors-test-data'

describe('send selectors', () => {

  describe('accountsWithSendEtherInfoSelector()', () => {
    it('should return an array of account objects with name info from identities', () => {
      assert.deepEqual(
        accountsWithSendEtherInfoSelector(mockState),
        [
          {
            'code': '0x',
            'balance': '0x47c9d71831c76efe',
            'nonce': '0x1b',
            'address': '0xfdea65c8e26263f6d9a1b5de9555d2931a33b825',
            'name': 'Send Account 1',
          },
          {
            'code': '0x',
            'balance': '0x37452b1315889f80',
            'nonce': '0xa',
            'address': '0xc5b8dbac4c1d3f152cdeb400e2313f309c410acb',
            'name': 'Send Account 2',
          },
          {
            'code': '0x',
            'balance': '0x30c9d71831c76efe',
            'nonce': '0x1c',
            'address': '0x2f8d4a878cfa04a6e60d46362f5644deab66572d',
            'name': 'Send Account 3',
          },
          {
            'code': '0x',
            'balance': '0x0',
            'nonce': '0x0',
            'address': '0xd85a4b6a394794842887b8284293d69163007bbb',
            'name': 'Send Account 4',
          },
        ]
      )
    })
  })

  // describe('autoAddToBetaUI()', () => {
  //   it('should', () => {
  //     assert.deepEqual(
  //       autoAddToBetaUI(mockState),

  //     )
  //   })
  // })

  describe('getAddressBook()', () => {
    it('should return the address book', () => {
      assert.deepEqual(
        getAddressBook(mockState),
        [
          {
            'address': '0x06195827297c7a80a443b6894d3bdb8824b43896',
            'name': 'Address Book Account 1',
          },
        ],
      )
    })
  })

  describe('getAmountConversionRate()', () => {
    it('should return the token conversion rate if a token is selected', () => {
      assert.equal(
        getAmountConversionRate(mockState),
        2401.76400654
      )
    })

    it('should return the eth conversion rate if no token is selected', () => {
      const editedMockState = {
        metamask: Object.assign({}, mockState.metamask, { selectedTokenAddress: null }),
      }
      assert.equal(
        getAmountConversionRate(editedMockState),
        1200.88200327
      )
    })
  })

  describe('getConversionRate()', () => {
    it('should return the eth conversion rate', () => {
      assert.deepEqual(
        getConversionRate(mockState),
        1200.88200327
      )
    })
  })

  describe('getConvertedCurrency()', () => {
    it('should return the currently selected currency', () => {
      assert.equal(
        getConvertedCurrency(mockState),
        'USD'
      )
    })
  })

  describe('getCurrentAccountWithSendEtherInfo()', () => {
    it('should return the currently selected account with identity info', () => {
      assert.deepEqual(
        getCurrentAccountWithSendEtherInfo(mockState),
        {
          'code': '0x',
          'balance': '0x0',
          'nonce': '0x0',
          'address': '0xd85a4b6a394794842887b8284293d69163007bbb',
          'name': 'Send Account 4',
        }
      )
    })
  })

  describe('getCurrentCurrency()', () => {
    it('should return the currently selected currency', () => {
      assert.equal(
        getCurrentCurrency(mockState),
        'USD'
      )
    })
  })

  describe('getCurrentNetwork()', () => {
    it('should return the id of the currently selected network', () => {
      assert.equal(
        getCurrentNetwork(mockState),
        '3'
      )
    })
  })

  describe('getCurrentViewContext()', () => {
    it('should return the context of the current view', () => {
      assert.equal(
        getCurrentViewContext(mockState),
        '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc'
      )
    })
  })

  describe('getForceGasMin()', () => {
    it('should get the send.forceGasMin property', () => {
      assert.equal(
        getForceGasMin(mockState),
        true
      )
    })
  })

  describe('getGasLimit()', () => {
    it('should return the send.gasLimit', () => {
      assert.equal(
        getGasLimit(mockState),
        '0xFFFF'
      )
    })
  })

  describe('getGasPrice()', () => {
    it('should return the send.gasPrice', () => {
      assert.equal(
        getGasPrice(mockState),
        '0xaa'
      )
    })
  })

  describe('getGasTotal()', () => {
    it('should return the send.gasTotal', () => {
      assert.equal(
        getGasTotal(mockState),
        '0xb451dc41b578'
      )
    })
  })

  describe('getPrimaryCurrency()', () => {
    it('should return the symbol of the selected token', () => {
      assert.equal(
        getPrimaryCurrency(mockState),
        'DEF'
      )
    })
  })

  describe('getSelectedAccount()', () => {
    it('should return the currently selected account', () => {
      assert.deepEqual(
        getSelectedAccount(mockState),
        {
          'code': '0x',
          'balance': '0x0',
          'nonce': '0x0',
          'address': '0xd85a4b6a394794842887b8284293d69163007bbb',
        }
      )
    })
  })

  describe('getSelectedAddress()', () => {
    it('should', () => {
      assert.equal(
        getSelectedAddress(mockState),
        '0xd85a4b6a394794842887b8284293d69163007bbb'
      )
    })
  })

  describe('getSelectedIdentity()', () => {
    it('should return the identity object of the currently selected address', () => {
      assert.deepEqual(
        getSelectedIdentity(mockState),
        {
          'address': '0xd85a4b6a394794842887b8284293d69163007bbb',
          'name': 'Send Account 4',
        }
      )
    })
  })

  describe('getSelectedToken()', () => {
    it('should return the currently selected token if selected', () => {
      assert.deepEqual(
        getSelectedToken(mockState),
        {
          'address': '0x8d6b81208414189a58339873ab429b6c47ab92d3',
          'decimals': 4,
          'symbol': 'DEF',
        }
      )
    })

    it('should return the send token if none is currently selected, but a send token exists', () => {
      const mockSendToken = {
        'address': '0x123456708414189a58339873ab429b6c47ab92d3',
        'decimals': 4,
        'symbol': 'JKL',
      }
      const editedMockState = {
        metamask: Object.assign({}, mockState.metamask, {
          selectedTokenAddress: null,
          send: {
            token: mockSendToken,
          },
        }),
      }
      assert.deepEqual(
        getSelectedToken(editedMockState),
        Object.assign({}, mockSendToken)
      )
    })
  })

  // TODO
  // describe('getSelectedTokenContract()', () => {
  //   it('should', () => {
  //     assert.deepEqual(
  //       getSelectedTokenContract(mockState),

  //     )
  //   })
  // })

  describe('getSelectedTokenExchangeRate()', () => {
    it('should return the exchange rate for the selected token', () => {
      assert.equal(
        getSelectedTokenExchangeRate(mockState),
        2.0
      )
    })
  })

  describe('getSelectedTokenToFiatRate()', () => {
    it('should return rate for converting the selected token to fiat', () => {
      assert.equal(
        getSelectedTokenToFiatRate(mockState),
        2401.76400654
      )
    })
  })

  describe('getSendAmount()', () => {
    it('should return the send.amount', () => {
      assert.equal(
        getSendAmount(mockState),
        '0x080'
      )
    })
  })

  describe('getSendEditingTransactionId()', () => {
    it('should return the send.editingTransactionId', () => {
      assert.equal(
        getSendEditingTransactionId(mockState),
        97531
      )
    })
  })

  describe('getSendErrors()', () => {
    it('should return the send.errors', () => {
      assert.deepEqual(
        getSendErrors(mockState),
        { 'someError': null }
      )
    })
  })

  describe('getSendFrom()', () => {
    it('should return the send.from', () => {
      assert.deepEqual(
        getSendFrom(mockState),
        {
          'address': '0xabcdefg',
          'balance': '0x5f4e3d2c1',
        }
      )
    })
  })

  describe('getSendFromBalance()', () => {
    it('should get the send.from balance if it exists', () => {
      assert.equal(
        getSendFromBalance(mockState),
        '0x5f4e3d2c1'
      )
    })

    it('should get the selected account balance if the send.from does not exist', () => {
      const editedMockState = {
        metamask: Object.assign({}, mockState.metamask, {
          send: {
            from: null,
          },
        }),
      }
      assert.equal(
        getSendFromBalance(editedMockState),
        '0x0'
      )
    })
  })

  describe('getSendFromObject()', () => {
    it('should return send.from if it exists', () => {
      assert.deepEqual(
        getSendFromObject(mockState),
        {
          'address': '0xabcdefg',
          'balance': '0x5f4e3d2c1',
        }
      )
    })

    it('should return the current account with send ether info if send.from does not exist', () => {
      const editedMockState = {
        metamask: Object.assign({}, mockState.metamask, {
          send: {
            from: null,
          },
        }),
      }
      assert.deepEqual(
        getSendFromObject(editedMockState),
        {
          'code': '0x',
          'balance': '0x0',
          'nonce': '0x0',
          'address': '0xd85a4b6a394794842887b8284293d69163007bbb',
          'name': 'Send Account 4',
        }
      )
    })
  })

  describe('getSendMaxModeState()', () => {
    it('should return send.maxModeOn', () => {
      assert.equal(
        getSendMaxModeState(mockState),
        false
      )
    })
  })

  describe('getSendTo()', () => {
    it('should return send.to', () => {
      assert.equal(
        getSendTo(mockState),
        '0x987fedabc'
      )
    })
  })

  describe('getSendToAccounts()', () => {
    it('should return an array including all the users accounts and the address book', () => {
      assert.deepEqual(
        getSendToAccounts(mockState),
        [
          {
            'code': '0x',
            'balance': '0x47c9d71831c76efe',
            'nonce': '0x1b',
            'address': '0xfdea65c8e26263f6d9a1b5de9555d2931a33b825',
            'name': 'Send Account 1',
          },
          {
            'code': '0x',
            'balance': '0x37452b1315889f80',
            'nonce': '0xa',
            'address': '0xc5b8dbac4c1d3f152cdeb400e2313f309c410acb',
            'name': 'Send Account 2',
          },
          {
            'code': '0x',
            'balance': '0x30c9d71831c76efe',
            'nonce': '0x1c',
            'address': '0x2f8d4a878cfa04a6e60d46362f5644deab66572d',
            'name': 'Send Account 3',
          },
          {
            'code': '0x',
            'balance': '0x0',
            'nonce': '0x0',
            'address': '0xd85a4b6a394794842887b8284293d69163007bbb',
            'name': 'Send Account 4',
          },
          {
            'address': '0x06195827297c7a80a443b6894d3bdb8824b43896',
            'name': 'Address Book Account 1',
          },
        ]
      )
    })
  })

  describe('getTokenBalance()', () => {
    it('should', () => {
      assert.equal(
        getTokenBalance(mockState),
        3434
      )
    })
  })

  describe('getTokenExchangeRate()', () => {
    it('should return the passed tokens exchange rates', () => {
      assert.equal(
        getTokenExchangeRate(mockState, 'GHI'),
        31.01
      )
    })
  })

  describe('getUnapprovedTxs()', () => {
    it('should return the unapproved txs', () => {
      assert.deepEqual(
        getUnapprovedTxs(mockState),
        {
          '4768706228115573': {
            'id': 4768706228115573,
            'time': 1487363153561,
            'status': 'unapproved',
            'gasMultiplier': 1,
            'metamaskNetworkId': '3',
            'txParams': {
              'from': '0xc5b8dbac4c1d3f152cdeb400e2313f309c410acb',
              'to': '0x18a3462427bcc9133bb46e88bcbe39cd7ef0e761',
              'value': '0xde0b6b3a7640000',
              'metamaskId': 4768706228115573,
              'metamaskNetworkId': '3',
              'gas': '0x5209',
            },
            'gasLimitSpecified': false,
            'estimatedGas': '0x5209',
            'txFee': '17e0186e60800',
            'txValue': 'de0b6b3a7640000',
            'maxCost': 'de234b52e4a0800',
            'gasPrice': '4a817c800',
          },
        }
      )
    })
  })

  describe('isSendFormInError()', () => {
    it('should return true if amount or to errors are truthy', () => {
      const editedMockState1 = {
        send: Object.assign({}, mockState.send, {
          errors: { amount: true },
        }),
      }
      assert.deepEqual(
        isSendFormInError(editedMockState1),
        true
      )
      const editedMockState2 = {
        send: Object.assign({}, mockState.send, {
          errors: { to: true },
        }),
      }
      assert.deepEqual(
        isSendFormInError(editedMockState2),
        true
      )
    })

    it('should return false if amount is falsy and to is null', () => {
      const editedMockState = {
        send: Object.assign({}, mockState.send, { errors: { amount: false, to: null } }),
      }
      assert.deepEqual(
        isSendFormInError(editedMockState),
        false
      )
    })
  })

  // TODO
  // describe('transactionsSelector()', () => {
  //   it('should', () => {
  //     assert.deepEqual(
  //       transactionsSelector(mockState),

  //     )
  //   })
  // })

})