TheDude
/
ciphermask
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup detect-tokens controller and tests (#8329)

Browse Source 
The tests for the detect-tokens controller were nearly all broken. They
have been fixed, and a few improvements were made to controller itself
to help with this.

* The core `detectNewTokens` method has been updated to be async, so
that the caller can know when the operation had completed.
* The part of the function that used `Web3` to check the token balances
has been split into a separate function, so that that part could be
stubbed out in tests. Eventually we should test this using `ganache`
instead, but this was an easier first step.
* The internal `tokenAddresses` array is now initialized on
construction, rather than upon the first Preferences controller update.
The `detectNewTokens` function would have previously failed if it ran
prior to this initialization, so it was failing if called before any
preferences state changes.

Additionally, the `detectTokenBalance` function was removed, as it was
no longer used.

The tests have been updated to ensure they're actually testing the
behavior they purport to be testing. I've simulated a test failure with
each one to check that it'd fail when it should. The preferences
controller instance was updated to set addresses correctly as well.
feature/default_network_editable
Mark Stacey 5 years ago committed by GitHub
parent d03f6b0167
commit 656dc4cf18
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 91 additions and 68 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 43
      app/scripts/controllers/detect-tokens.js
  2. 102
      test/unit/app/controllers/detect-tokens-test.js

43
app/scripts/controllers/detect-tokens.js
Unescape View File

@ -4,7 +4,6 @@ import { warn } from 'loglevel'
import { MAINNET } from './network/enums'
// By default, poll every 3 minutes
const DEFAULT_INTERVAL = 180 * 1000
const ERC20_ABI = [{ 'constant': true, 'inputs': [{ 'name': '_owner', 'type': 'address' }], 'name': 'balanceOf', 'outputs': [{ 'name': 'balance', 'type': 'uint256' }], 'payable': false, 'type': 'function' }]
import SINGLE_CALL_BALANCES_ABI from 'single-call-balance-checker-abi'
const SINGLE_CALL_BALANCES_ADDRESS = '0xb1f8e55c7f64d203c1400b9d8555d050f94adf39'
@ -36,6 +35,7 @@ class DetectTokensController {
if (this._network.store.getState().provider.type !== MAINNET) {
return
}
const tokensToDetect = []
this.web3.setProvider(this._network._provider)
for (const contractAddress in contracts) {
@ -44,38 +44,31 @@ class DetectTokensController {
}
}
const ethContract = this.web3.eth.contract(SINGLE_CALL_BALANCES_ABI).at(SINGLE_CALL_BALANCES_ADDRESS)
ethContract.balances([this.selectedAddress], tokensToDetect, (error, result) => {
if (error) {
let result
try {
result = await this._getTokenBalances(tokensToDetect)
} catch (error) {
warn(`MetaMask - DetectTokensController single call balance fetch failed`, error)
return
}
tokensToDetect.forEach((tokenAddress, index) => {
const balance = result[index]
if (balance && !balance.isZero()) {
this._preferences.addToken(tokenAddress, contracts[tokenAddress].symbol, contracts[tokenAddress].decimals)
}
})
})
}
/**
* Find if selectedAddress has tokens with contract in contractAddress.
*
* @param {string} contractAddress - Hex address of the token contract to explore.
* @returns {boolean} - If balance is detected, token is added.
*
*/
async detectTokenBalance (contractAddress) {
const ethContract = this.web3.eth.contract(ERC20_ABI).at(contractAddress)
ethContract.balanceOf(this.selectedAddress, (error, result) => {
if (!error) {
if (!result.isZero()) {
this._preferences.addToken(contractAddress, contracts[contractAddress].symbol, contracts[contractAddress].decimals)
}
} else {
warn(`MetaMask - DetectTokensController balance fetch failed for ${contractAddress}.`, error)
async _getTokenBalances (tokens) {
const ethContract = this.web3.eth.contract(SINGLE_CALL_BALANCES_ABI).at(SINGLE_CALL_BALANCES_ADDRESS)
return new Promise((resolve, reject) => {
ethContract.balances([this.selectedAddress], tokens, (error, result) => {
if (error) {
return reject(error)
}
return resolve(result)
})
})
}
@ -114,9 +107,13 @@ class DetectTokensController {
return
}
this._preferences = preferences
const currentTokens = preferences.store.getState().tokens
this.tokenAddresses = currentTokens
? currentTokens.map((token) => token.address)
: []
preferences.store.subscribe(({ tokens = [] }) => {
this.tokenAddresses = tokens.map((obj) => {
return obj.address
this.tokenAddresses = tokens.map((token) => {
return token.address
})
})
preferences.store.subscribe(({ selectedAddress }) => {

102
test/unit/app/controllers/detect-tokens-test.js
Unescape View File

@ -2,13 +2,17 @@ import assert from 'assert'
import nock from 'nock'
import sinon from 'sinon'
import ObservableStore from 'obs-store'
import contracts from 'eth-contract-metadata'
import BigNumber from 'bignumber.js'
import DetectTokensController from '../../../../app/scripts/controllers/detect-tokens'
import NetworkController from '../../../../app/scripts/controllers/network/network'
import PreferencesController from '../../../../app/scripts/controllers/preferences'
import { MAINNET, ROPSTEN } from '../../../../app/scripts/controllers/network/enums'
describe('DetectTokensController', function () {
const sandbox = sinon.createSandbox()
let clock, keyringMemStore, network, preferences, controller
let keyringMemStore, network, preferences
const noop = () => {}
@ -26,8 +30,10 @@ describe('DetectTokensController', function () {
keyringMemStore = new ObservableStore({ isUnlocked: false })
network = new NetworkController()
preferences = new PreferencesController({ network })
controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
preferences.setAddresses([
'0x7e57e2',
'0xbc86727e770de68b1060c91f6bb6945c73e10388',
])
network.initializeProvider(networkControllerProviderConfig)
})
@ -45,12 +51,9 @@ describe('DetectTokensController', function () {
})
it('should be called on every polling period', async function () {
clock = sandbox.useFakeTimers()
const network = new NetworkController()
network.initializeProvider(networkControllerProviderConfig)
network.setProviderType('mainnet')
const preferences = new PreferencesController({ network })
const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
const clock = sandbox.useFakeTimers()
network.setProviderType(MAINNET)
const controller = new DetectTokensController({ preferences, network, keyringMemStore })
controller.isOpen = true
controller.isUnlocked = true
@ -66,52 +69,61 @@ describe('DetectTokensController', function () {
sandbox.assert.calledThrice(stub)
})
it('should not check tokens while in test network', async function () {
it('should not check tokens while on test network', async function () {
sandbox.useFakeTimers()
network.setProviderType(ROPSTEN)
const controller = new DetectTokensController({ preferences, network, keyringMemStore })
controller.isOpen = true
controller.isUnlocked = true
const stub = sandbox.stub(controller, 'detectTokenBalance')
.withArgs('0x0D262e5dC4A06a0F1c90cE79C7a60C09DfC884E4').returns(true)
.withArgs('0xBC86727E770de68B1060C91f6BB6945c73e10388').returns(true)
const stub = sandbox.stub(controller, '_getTokenBalances')
await controller.detectNewTokens()
sandbox.assert.notCalled(stub)
})
it('should only check and add tokens while in main network', async function () {
const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
it('should check and add tokens while on main network', async function () {
sandbox.useFakeTimers()
network.setProviderType(MAINNET)
const controller = new DetectTokensController({ preferences, network, keyringMemStore })
controller.isOpen = true
controller.isUnlocked = true
sandbox.stub(controller, 'detectTokenBalance')
.withArgs('0x0D262e5dC4A06a0F1c90cE79C7a60C09DfC884E4')
.returns(preferences.addToken('0x0d262e5dc4a06a0f1c90ce79c7a60c09dfc884e4', 'J8T', 8))
.withArgs('0xBC86727E770de68B1060C91f6BB6945c73e10388')
.returns(preferences.addToken('0xbc86727e770de68b1060c91f6bb6945c73e10388', 'XNK', 18))
const contractAddressses = Object.keys(contracts)
const erc20ContractAddresses = contractAddressses
.filter((contractAddress) => contracts[contractAddress].erc20 === true)
await controller.detectNewTokens()
assert.deepEqual(preferences.store.getState().tokens, [{ address: '0x0d262e5dc4a06a0f1c90ce79c7a60c09dfc884e4', decimals: 8, symbol: 'J8T' },
{ address: '0xbc86727e770de68b1060c91f6bb6945c73e10388', decimals: 18, symbol: 'XNK' }])
})
const existingTokenAddress = erc20ContractAddresses[0]
const existingToken = contracts[existingTokenAddress]
await preferences.addToken(existingTokenAddress, existingToken.symbol, existingToken.decimals)
it('should not detect same token while in main network', async function () {
preferences.addToken('0x0d262e5dc4a06a0f1c90ce79c7a60c09dfc884e4', 'J8T', 8)
const controller = new DetectTokensController({ preferences: preferences, network: network, keyringMemStore: keyringMemStore })
controller.isOpen = true
controller.isUnlocked = true
const tokenAddressToAdd = erc20ContractAddresses[1]
const tokenToAdd = contracts[tokenAddressToAdd]
sandbox.stub(controller, 'detectTokenBalance')
.withArgs('0x0D262e5dC4A06a0F1c90cE79C7a60C09DfC884E4')
.returns(preferences.addToken('0x0d262e5dc4a06a0f1c90ce79c7a60c09dfc884e4', 'J8T', 8))
.withArgs('0xBC86727E770de68B1060C91f6BB6945c73e10388')
.returns(preferences.addToken('0xbc86727e770de68b1060c91f6bb6945c73e10388', 'XNK', 18))
const contractAddresssesToDetect = contractAddressses
.filter((address) => address !== existingTokenAddress)
const indexOfTokenToAdd = contractAddresssesToDetect.indexOf(tokenAddressToAdd)
const balances = new Array(contractAddresssesToDetect.length)
balances[indexOfTokenToAdd] = new BigNumber(10)
sandbox.stub(controller, '_getTokenBalances')
.returns(Promise.resolve(balances))
await controller.detectNewTokens()
assert.deepEqual(preferences.store.getState().tokens, [{ address: '0x0d262e5dc4a06a0f1c90ce79c7a60c09dfc884e4', decimals: 8, symbol: 'J8T' },
{ address: '0xbc86727e770de68b1060c91f6bb6945c73e10388', decimals: 18, symbol: 'XNK' }])
assert.deepEqual(
preferences.store.getState().tokens,
[
{ address: existingTokenAddress.toLowerCase(), decimals: existingToken.decimals, symbol: existingToken.symbol },
{ address: tokenAddressToAdd.toLowerCase(), decimals: tokenToAdd.decimals, symbol: tokenToAdd.symbol },
]
)
})
it('should trigger detect new tokens when change address', async function () {
sandbox.useFakeTimers()
const controller = new DetectTokensController({ preferences, network, keyringMemStore })
controller.isOpen = true
controller.isUnlocked = true
const stub = sandbox.stub(controller, 'detectNewTokens')
@ -120,6 +132,8 @@ describe('DetectTokensController', function () {
})
it('should trigger detect new tokens when submit password', async function () {
sandbox.useFakeTimers()
const controller = new DetectTokensController({ preferences, network, keyringMemStore })
controller.isOpen = true
controller.selectedAddress = '0x0'
const stub = sandbox.stub(controller, 'detectNewTokens')
@ -127,14 +141,26 @@ describe('DetectTokensController', function () {
sandbox.assert.called(stub)
})
it('should not trigger detect new tokens when not open or not unlocked', async function () {
it('should not trigger detect new tokens when not unlocked', async function () {
const clock = sandbox.useFakeTimers()
network.setProviderType(MAINNET)
const controller = new DetectTokensController({ preferences, network, keyringMemStore })
controller.isOpen = true
controller.isUnlocked = false
const stub = sandbox.stub(controller, 'detectTokenBalance')
const stub = sandbox.stub(controller, '_getTokenBalances')
clock.tick(180000)
sandbox.assert.notCalled(stub)
})
it('should not trigger detect new tokens when not open', async function () {
const clock = sandbox.useFakeTimers()
network.setProviderType(MAINNET)
const controller = new DetectTokensController({ preferences, network, keyringMemStore })
// trigger state update from preferences controller
await preferences.setSelectedAddress('0xbc86727e770de68b1060c91f6bb6945c73e10388')
controller.isOpen = false
controller.isUnlocked = true
const stub = sandbox.stub(controller, '_getTokenBalances')
clock.tick(180000)
sandbox.assert.notCalled(stub)
})

Write Preview
Loading…
Cancel
Save