mirror of
https://github.com/kremalicious/metamask-extension.git
synced 2024-10-23 11:46:13 +02:00
1483 lines
44 KiB
JavaScript
1483 lines
44 KiB
JavaScript
import assert from 'assert'
|
|
import sinon from 'sinon'
|
|
import { cloneDeep } from 'lodash'
|
|
import configureStore from 'redux-mock-store'
|
|
import thunk from 'redux-thunk'
|
|
import EthQuery from 'eth-query'
|
|
import Eth from 'ethjs'
|
|
import KeyringController from 'eth-keyring-controller'
|
|
import { createTestProviderTools } from '../../../stub/provider'
|
|
import enLocale from '../../../../app/_locales/en/messages.json'
|
|
import * as actions from '../../../../ui/app/store/actions'
|
|
import MetaMaskController from '../../../../app/scripts/metamask-controller'
|
|
import firstTimeState from '../../localhostState'
|
|
|
|
const { provider } = createTestProviderTools({ scaffold: {} })
|
|
const middleware = [thunk]
|
|
const defaultState = { metamask: { provider: { chainId: '0x1' } } }
|
|
const mockStore = (state = defaultState) => configureStore(middleware)(state)
|
|
const extensionMock = {
|
|
runtime: {
|
|
onInstalled: {
|
|
addListener: () => undefined,
|
|
},
|
|
},
|
|
}
|
|
|
|
describe('Actions', function () {
|
|
const noop = () => undefined
|
|
|
|
const currentNetworkId = '42'
|
|
|
|
let background, metamaskController
|
|
|
|
const TEST_SEED =
|
|
'debris dizzy just program just float decrease vacant alarm reduce speak stadium'
|
|
const password = 'a-fake-password'
|
|
const importPrivkey =
|
|
'4cfd3e90fc78b0f86bf7524722150bb8da9c60cd532564d7ff43f5716514f553'
|
|
|
|
beforeEach(async function () {
|
|
metamaskController = new MetaMaskController({
|
|
extension: extensionMock,
|
|
platform: { getVersion: () => 'foo' },
|
|
provider,
|
|
keyringController: new KeyringController({}),
|
|
showUnapprovedTx: noop,
|
|
showUnconfirmedMessage: noop,
|
|
encryptor: {
|
|
encrypt(_, object) {
|
|
this.object = object
|
|
return Promise.resolve('mock-encrypted')
|
|
},
|
|
decrypt() {
|
|
return Promise.resolve(this.object)
|
|
},
|
|
},
|
|
initState: cloneDeep(firstTimeState),
|
|
infuraProjectId: 'foo',
|
|
})
|
|
|
|
metamaskController.threeBoxController = {
|
|
new3Box: sinon.spy(),
|
|
getThreeBoxSyncingState: sinon.spy(),
|
|
}
|
|
|
|
await metamaskController.createNewVaultAndRestore(password, TEST_SEED)
|
|
|
|
await metamaskController.importAccountWithStrategy('Private Key', [
|
|
importPrivkey,
|
|
])
|
|
|
|
background = metamaskController.getApi()
|
|
|
|
actions._setBackgroundConnection(background)
|
|
|
|
global.ethQuery = new EthQuery(provider)
|
|
})
|
|
|
|
describe('#tryUnlockMetamask', function () {
|
|
let submitPasswordSpy, verifySeedPhraseSpy
|
|
|
|
afterEach(function () {
|
|
submitPasswordSpy.restore()
|
|
verifySeedPhraseSpy.restore()
|
|
})
|
|
|
|
it('calls submitPassword and verifySeedPhrase', async function () {
|
|
const store = mockStore()
|
|
|
|
submitPasswordSpy = sinon.spy(background, 'submitPassword')
|
|
verifySeedPhraseSpy = sinon.spy(background, 'verifySeedPhrase')
|
|
|
|
await store.dispatch(actions.tryUnlockMetamask())
|
|
assert(submitPasswordSpy.calledOnce)
|
|
assert(verifySeedPhraseSpy.calledOnce)
|
|
})
|
|
|
|
it('errors on submitPassword will fail', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'UNLOCK_IN_PROGRESS' },
|
|
{ type: 'UNLOCK_FAILED', value: 'error in submitPassword' },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
]
|
|
|
|
submitPasswordSpy = sinon.stub(background, 'submitPassword')
|
|
|
|
submitPasswordSpy.callsFake((_, callback) => {
|
|
callback(new Error('error in submitPassword'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.tryUnlockMetamask('test'))
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
|
|
it('displays warning error and unlock failed when verifySeed fails', async function () {
|
|
const store = mockStore()
|
|
const displayWarningError = [{ type: 'DISPLAY_WARNING', value: 'error' }]
|
|
const unlockFailedError = [{ type: 'UNLOCK_FAILED', value: 'error' }]
|
|
|
|
verifySeedPhraseSpy = sinon.stub(background, 'verifySeedPhrase')
|
|
verifySeedPhraseSpy.callsFake((callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.tryUnlockMetamask('test'))
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
const actions1 = store.getActions()
|
|
const warning = actions1.filter(
|
|
(action) => action.type === 'DISPLAY_WARNING',
|
|
)
|
|
const unlockFailed = actions1.filter(
|
|
(action) => action.type === 'UNLOCK_FAILED',
|
|
)
|
|
assert.deepEqual(warning, displayWarningError)
|
|
assert.deepEqual(unlockFailed, unlockFailedError)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#createNewVaultAndRestore', function () {
|
|
let createNewVaultAndRestoreSpy
|
|
|
|
afterEach(function () {
|
|
createNewVaultAndRestoreSpy.restore()
|
|
})
|
|
|
|
it('restores new vault', async function () {
|
|
const store = mockStore()
|
|
|
|
createNewVaultAndRestoreSpy = sinon.spy(
|
|
background,
|
|
'createNewVaultAndRestore',
|
|
)
|
|
|
|
try {
|
|
await store.dispatch(actions.createNewVaultAndRestore())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert(createNewVaultAndRestoreSpy.calledOnce)
|
|
}
|
|
})
|
|
|
|
it('errors when callback in createNewVaultAndRestore throws', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
]
|
|
|
|
createNewVaultAndRestoreSpy = sinon.stub(
|
|
background,
|
|
'createNewVaultAndRestore',
|
|
)
|
|
|
|
createNewVaultAndRestoreSpy.callsFake((_, __, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.createNewVaultAndRestore())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#requestRevealSeedWords', function () {
|
|
let submitPasswordSpy
|
|
|
|
afterEach(function () {
|
|
submitPasswordSpy.restore()
|
|
})
|
|
|
|
it('calls submitPassword in background', async function () {
|
|
const store = mockStore()
|
|
|
|
submitPasswordSpy = sinon.spy(background, 'verifySeedPhrase')
|
|
|
|
await store.dispatch(actions.requestRevealSeedWords())
|
|
assert(submitPasswordSpy.calledOnce)
|
|
})
|
|
|
|
it('displays warning error message then callback in background errors', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
submitPasswordSpy = sinon.stub(background, 'verifySeedPhrase')
|
|
submitPasswordSpy.callsFake((callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.requestRevealSeedWords())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#removeAccount', function () {
|
|
let removeAccountStub
|
|
|
|
afterEach(function () {
|
|
removeAccountStub.restore()
|
|
})
|
|
|
|
it('calls removeAccount in background and expect actions to show account', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
'SHOW_LOADING_INDICATION',
|
|
'SELECTED_ADDRESS_CHANGED',
|
|
'UPDATE_METAMASK_STATE',
|
|
'HIDE_LOADING_INDICATION',
|
|
'SHOW_ACCOUNTS_PAGE',
|
|
]
|
|
|
|
removeAccountStub = sinon.stub(background, 'removeAccount')
|
|
removeAccountStub.callsFake((_, callback) => callback())
|
|
|
|
await store.dispatch(
|
|
actions.removeAccount('0xe18035bf8712672935fdb4e5e431b1a0183d2dfc'),
|
|
)
|
|
assert(removeAccountStub.calledOnce)
|
|
const actionTypes = store.getActions().map((action) => action.type)
|
|
assert.deepEqual(actionTypes, expectedActions)
|
|
})
|
|
|
|
it('displays warning error message when removeAccount callback errors', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
'SHOW_LOADING_INDICATION',
|
|
'DISPLAY_WARNING',
|
|
'HIDE_LOADING_INDICATION',
|
|
]
|
|
|
|
removeAccountStub = sinon.stub(background, 'removeAccount')
|
|
removeAccountStub.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(
|
|
actions.removeAccount('0xe18035bf8712672935fdb4e5e431b1a0183d2dfc'),
|
|
)
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
const actionTypes = store.getActions().map((action) => action.type)
|
|
assert.deepEqual(actionTypes, expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#resetAccount', function () {
|
|
let resetAccountSpy
|
|
|
|
afterEach(function () {
|
|
resetAccountSpy.restore()
|
|
})
|
|
|
|
it('resets account', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'SHOW_ACCOUNTS_PAGE' },
|
|
]
|
|
|
|
resetAccountSpy = sinon.spy(background, 'resetAccount')
|
|
|
|
await store.dispatch(actions.resetAccount())
|
|
assert(resetAccountSpy.calledOnce)
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
|
|
it('throws if resetAccount throws', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
resetAccountSpy = sinon.stub(background, 'resetAccount')
|
|
resetAccountSpy.callsFake((callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.resetAccount())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#importNewAccount', function () {
|
|
let importAccountWithStrategySpy
|
|
|
|
afterEach(function () {
|
|
importAccountWithStrategySpy.restore()
|
|
})
|
|
|
|
it('calls importAccountWithStrategies in background', async function () {
|
|
const store = mockStore()
|
|
|
|
importAccountWithStrategySpy = sinon.spy(
|
|
background,
|
|
'importAccountWithStrategy',
|
|
)
|
|
|
|
await store.dispatch(
|
|
actions.importNewAccount('Private Key', [
|
|
'c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3',
|
|
]),
|
|
)
|
|
assert(importAccountWithStrategySpy.calledOnce)
|
|
})
|
|
|
|
it('displays warning error message when importAccount in background callback errors', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{
|
|
type: 'SHOW_LOADING_INDICATION',
|
|
value: 'This may take a while, please be patient.',
|
|
},
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
importAccountWithStrategySpy = sinon.stub(
|
|
background,
|
|
'importAccountWithStrategy',
|
|
)
|
|
importAccountWithStrategySpy.callsFake((_, __, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.importNewAccount())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#addNewAccount', function () {
|
|
it('Adds a new account', async function () {
|
|
const store = mockStore({ metamask: { identities: {} } })
|
|
|
|
const addNewAccountSpy = sinon.spy(background, 'addNewAccount')
|
|
|
|
await store.dispatch(actions.addNewAccount())
|
|
assert(addNewAccountSpy.calledOnce)
|
|
})
|
|
})
|
|
|
|
describe('#checkHardwareStatus', function () {
|
|
let checkHardwareStatusSpy
|
|
|
|
afterEach(function () {
|
|
checkHardwareStatusSpy.restore()
|
|
})
|
|
|
|
it('calls checkHardwareStatus in background', async function () {
|
|
checkHardwareStatusSpy = sinon
|
|
.stub(background, 'checkHardwareStatus')
|
|
.callsArgWith(2, null)
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(
|
|
actions.checkHardwareStatus('ledger', `m/44'/60'/0'/0`),
|
|
)
|
|
assert.equal(checkHardwareStatusSpy.calledOnce, true)
|
|
})
|
|
|
|
it('shows loading indicator and displays error', async function () {
|
|
checkHardwareStatusSpy = sinon
|
|
.stub(background, 'checkHardwareStatus')
|
|
.callsArgWith(2, new Error('error'))
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
try {
|
|
await store.dispatch(actions.checkHardwareStatus())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#forgetDevice', function () {
|
|
let forgetDeviceSpy
|
|
|
|
afterEach(function () {
|
|
forgetDeviceSpy.restore()
|
|
})
|
|
|
|
it('calls forgetDevice in background', async function () {
|
|
forgetDeviceSpy = sinon
|
|
.stub(background, 'forgetDevice')
|
|
.callsArgWith(1, null)
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(actions.forgetDevice('ledger'))
|
|
assert.equal(forgetDeviceSpy.calledOnce, true)
|
|
})
|
|
|
|
it('shows loading indicator and displays error', async function () {
|
|
forgetDeviceSpy = sinon
|
|
.stub(background, 'forgetDevice')
|
|
.callsArgWith(1, new Error('error'))
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
try {
|
|
await store.dispatch(actions.forgetDevice())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#connectHardware', function () {
|
|
let connectHardwareSpy
|
|
|
|
afterEach(function () {
|
|
connectHardwareSpy.restore()
|
|
})
|
|
|
|
it('calls connectHardware in background', async function () {
|
|
connectHardwareSpy = sinon
|
|
.stub(background, 'connectHardware')
|
|
.callsArgWith(3, null)
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(
|
|
actions.connectHardware('ledger', 0, `m/44'/60'/0'/0`),
|
|
)
|
|
assert.equal(connectHardwareSpy.calledOnce, true)
|
|
})
|
|
|
|
it('shows loading indicator and displays error', async function () {
|
|
connectHardwareSpy = sinon
|
|
.stub(background, 'connectHardware')
|
|
.callsArgWith(3, new Error('error'))
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{
|
|
type: 'SHOW_LOADING_INDICATION',
|
|
value: 'Looking for your Ledger...',
|
|
},
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
try {
|
|
await store.dispatch(actions.connectHardware('ledger'))
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#unlockHardwareWalletAccount', function () {
|
|
let unlockHardwareWalletAccountSpy
|
|
|
|
afterEach(function () {
|
|
unlockHardwareWalletAccountSpy.restore()
|
|
})
|
|
|
|
it('calls unlockHardwareWalletAccount in background', async function () {
|
|
unlockHardwareWalletAccountSpy = sinon
|
|
.stub(background, 'unlockHardwareWalletAccount')
|
|
.callsArgWith(3, null)
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(
|
|
actions.unlockHardwareWalletAccount('ledger', 0, `m/44'/60'/0'/0`),
|
|
)
|
|
assert.equal(unlockHardwareWalletAccountSpy.calledOnce, true)
|
|
})
|
|
|
|
it('shows loading indicator and displays error', async function () {
|
|
unlockHardwareWalletAccountSpy = sinon
|
|
.stub(background, 'unlockHardwareWalletAccount')
|
|
.callsArgWith(3, new Error('error'))
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
try {
|
|
await store.dispatch(actions.unlockHardwareWalletAccount())
|
|
assert.fail('Should have thrown error')
|
|
} catch (error) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#setCurrentCurrency', function () {
|
|
let setCurrentCurrencySpy
|
|
|
|
afterEach(function () {
|
|
setCurrentCurrencySpy.restore()
|
|
})
|
|
|
|
it('calls setCurrentCurrency', async function () {
|
|
setCurrentCurrencySpy = sinon
|
|
.stub(background, 'setCurrentCurrency')
|
|
.callsArgWith(1, null, {})
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(actions.setCurrentCurrency('jpy'))
|
|
assert(setCurrentCurrencySpy.calledOnce)
|
|
})
|
|
|
|
it('throws if setCurrentCurrency throws', async function () {
|
|
setCurrentCurrencySpy = sinon
|
|
.stub(background, 'setCurrentCurrency')
|
|
.callsArgWith(1, new Error('error'))
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
await store.dispatch(actions.setCurrentCurrency())
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
})
|
|
|
|
describe('#signMsg', function () {
|
|
let signMessageSpy, metamaskMsgs, msgId, messages
|
|
|
|
const msgParams = {
|
|
from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
|
|
data:
|
|
'0x879a053d4800c6354e76c7985a865d2922c82fb5b3f4577b2fe08b998954f2e0',
|
|
}
|
|
|
|
beforeEach(function () {
|
|
metamaskController.newUnsignedMessage(msgParams, noop)
|
|
metamaskMsgs = metamaskController.messageManager.getUnapprovedMsgs()
|
|
messages = metamaskController.messageManager.messages
|
|
msgId = Object.keys(metamaskMsgs)[0]
|
|
messages[0].msgParams.metamaskId = parseInt(msgId, 10)
|
|
})
|
|
|
|
afterEach(function () {
|
|
signMessageSpy.restore()
|
|
})
|
|
|
|
it('calls signMsg in background', async function () {
|
|
const store = mockStore()
|
|
|
|
signMessageSpy = sinon.spy(background, 'signMessage')
|
|
await store.dispatch(actions.signMsg(msgParams))
|
|
assert(signMessageSpy.calledOnce)
|
|
})
|
|
|
|
it('errors when signMessage in background throws', async function () {
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
signMessageSpy = sinon.stub(background, 'signMessage')
|
|
signMessageSpy.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.signMsg())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#signPersonalMsg', function () {
|
|
let signPersonalMessageSpy, metamaskMsgs, msgId, personalMessages
|
|
|
|
const msgParams = {
|
|
from: '0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
|
|
data:
|
|
'0x879a053d4800c6354e76c7985a865d2922c82fb5b3f4577b2fe08b998954f2e0',
|
|
}
|
|
|
|
beforeEach(function () {
|
|
metamaskController.newUnsignedPersonalMessage(msgParams, noop)
|
|
metamaskMsgs = metamaskController.personalMessageManager.getUnapprovedMsgs()
|
|
personalMessages = metamaskController.personalMessageManager.messages
|
|
msgId = Object.keys(metamaskMsgs)[0]
|
|
personalMessages[0].msgParams.metamaskId = parseInt(msgId, 10)
|
|
})
|
|
|
|
afterEach(function () {
|
|
signPersonalMessageSpy.restore()
|
|
})
|
|
|
|
it('calls signPersonalMessage', async function () {
|
|
const store = mockStore()
|
|
|
|
signPersonalMessageSpy = sinon.spy(background, 'signPersonalMessage')
|
|
|
|
await store.dispatch(actions.signPersonalMsg(msgParams))
|
|
assert(signPersonalMessageSpy.calledOnce)
|
|
})
|
|
|
|
it('throws if signPersonalMessage throws', async function () {
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
signPersonalMessageSpy = sinon.stub(background, 'signPersonalMessage')
|
|
signPersonalMessageSpy.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.signPersonalMsg(msgParams))
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#signTypedMsg', function () {
|
|
let signTypedMsgSpy, messages, typedMessages, msgId
|
|
|
|
const msgParamsV3 = {
|
|
from: '0x0DCD5D886577d5081B0c52e242Ef29E70Be3E7bc',
|
|
data: JSON.stringify({
|
|
types: {
|
|
EIP712Domain: [
|
|
{ name: 'name', type: 'string' },
|
|
{ name: 'version', type: 'string' },
|
|
{ name: 'chainId', type: 'uint256' },
|
|
{ name: 'verifyingContract', type: 'address' },
|
|
],
|
|
Person: [
|
|
{ name: 'name', type: 'string' },
|
|
{ name: 'wallet', type: 'address' },
|
|
],
|
|
Mail: [
|
|
{ name: 'from', type: 'Person' },
|
|
{ name: 'to', type: 'Person' },
|
|
{ name: 'contents', type: 'string' },
|
|
],
|
|
},
|
|
primaryType: 'Mail',
|
|
domain: {
|
|
name: 'Ether Mainl',
|
|
version: '1',
|
|
verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
|
|
},
|
|
message: {
|
|
from: {
|
|
name: 'Cow',
|
|
wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
|
|
},
|
|
to: {
|
|
name: 'Bob',
|
|
wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
|
|
},
|
|
contents: 'Hello, Bob!',
|
|
},
|
|
}),
|
|
}
|
|
|
|
beforeEach(function () {
|
|
metamaskController.newUnsignedTypedMessage(msgParamsV3, null, 'V3')
|
|
messages = metamaskController.typedMessageManager.getUnapprovedMsgs()
|
|
typedMessages = metamaskController.typedMessageManager.messages
|
|
msgId = Object.keys(messages)[0]
|
|
typedMessages[0].msgParams.metamaskId = parseInt(msgId, 10)
|
|
})
|
|
|
|
afterEach(function () {
|
|
signTypedMsgSpy.restore()
|
|
})
|
|
|
|
it('calls signTypedMsg in background with no error', async function () {
|
|
signTypedMsgSpy = sinon
|
|
.stub(background, 'signTypedMessage')
|
|
.callsArgWith(1, null, defaultState)
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(actions.signTypedMsg(msgParamsV3))
|
|
assert(signTypedMsgSpy.calledOnce)
|
|
})
|
|
|
|
it('returns expected actions with error', async function () {
|
|
signTypedMsgSpy = sinon
|
|
.stub(background, 'signTypedMessage')
|
|
.callsArgWith(1, new Error('error'))
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
try {
|
|
await store.dispatch(actions.signTypedMsg())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#signTx', function () {
|
|
let sendTransactionSpy
|
|
|
|
beforeEach(function () {
|
|
sendTransactionSpy = sinon.stub(global.ethQuery, 'sendTransaction')
|
|
})
|
|
|
|
afterEach(function () {
|
|
sendTransactionSpy.restore()
|
|
})
|
|
|
|
it('calls sendTransaction in global ethQuery', function () {
|
|
const store = mockStore()
|
|
|
|
store.dispatch(actions.signTx())
|
|
assert(sendTransactionSpy.calledOnce)
|
|
})
|
|
|
|
it('errors in when sendTransaction throws', function () {
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
{ type: 'SHOW_CONF_TX_PAGE', id: undefined },
|
|
]
|
|
sendTransactionSpy.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
store.dispatch(actions.signTx())
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
})
|
|
|
|
describe('#updatedGasData', function () {
|
|
it('errors when get code does not return', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'GAS_LOADING_STARTED' },
|
|
{
|
|
type: 'UPDATE_SEND_ERRORS',
|
|
value: { gasLoadingError: 'gasLoadingError' },
|
|
},
|
|
{ type: 'GAS_LOADING_FINISHED' },
|
|
]
|
|
|
|
const mockData = {
|
|
gasPrice: '0x3b9aca00', //
|
|
blockGasLimit: '0x6ad79a', // 7002010
|
|
selectedAddress: '0x0DCD5D886577d5081B0c52e242Ef29E70Be3E7bc',
|
|
to: '0xEC1Adf982415D2Ef5ec55899b9Bfb8BC0f29251B',
|
|
value: '0xde0b6b3a7640000', // 1000000000000000000
|
|
}
|
|
|
|
try {
|
|
await store.dispatch(actions.updateGasData(mockData))
|
|
assert.fail('Should have thrown error')
|
|
} catch (error) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
|
|
it('returns default gas limit for basic eth transaction', async function () {
|
|
const mockData = {
|
|
gasPrice: '0x3b9aca00',
|
|
blockGasLimit: '0x6ad79a', // 7002010
|
|
selectedAddress: '0x0DCD5D886577d5081B0c52e242Ef29E70Be3E7bc',
|
|
to: '0xEC1Adf982415D2Ef5ec55899b9Bfb8BC0f29251B',
|
|
value: '0xde0b6b3a7640000', // 1000000000000000000
|
|
}
|
|
|
|
global.eth = {
|
|
getCode: sinon.stub().returns('0x'),
|
|
}
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'GAS_LOADING_STARTED' },
|
|
{ type: 'UPDATE_GAS_LIMIT', value: '0x5208' },
|
|
{ type: 'metamask/gas/SET_CUSTOM_GAS_LIMIT', value: '0x5208' },
|
|
{ type: 'UPDATE_SEND_ERRORS', value: { gasLoadingError: null } },
|
|
{ type: 'GAS_LOADING_FINISHED' },
|
|
]
|
|
|
|
await store.dispatch(actions.updateGasData(mockData))
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
global.eth.getCode.reset()
|
|
})
|
|
})
|
|
|
|
describe('#signTokenTx', function () {
|
|
it('calls eth.contract', function () {
|
|
global.eth = new Eth(provider)
|
|
const tokenSpy = sinon.spy(global.eth, 'contract')
|
|
const store = mockStore()
|
|
store.dispatch(actions.signTokenTx())
|
|
assert(tokenSpy.calledOnce)
|
|
tokenSpy.restore()
|
|
})
|
|
})
|
|
|
|
describe('#updateTransaction', function () {
|
|
let updateTransactionSpy
|
|
|
|
const txParams = {
|
|
from: '0x1',
|
|
gas: '0x5208',
|
|
gasPrice: '0x3b9aca00',
|
|
to: '0x2',
|
|
value: '0x0',
|
|
}
|
|
|
|
const txData = {
|
|
id: '1',
|
|
status: 'unapproved',
|
|
metamaskNetworkId: currentNetworkId,
|
|
txParams,
|
|
}
|
|
|
|
beforeEach(async function () {
|
|
await metamaskController.txController.txStateManager.addTx(txData)
|
|
})
|
|
|
|
afterEach(function () {
|
|
updateTransactionSpy.restore()
|
|
})
|
|
|
|
it('updates transaction', async function () {
|
|
const store = mockStore()
|
|
|
|
updateTransactionSpy = sinon.spy(background, 'updateTransaction')
|
|
|
|
await store.dispatch(actions.updateTransaction(txData))
|
|
|
|
const resultantActions = store.getActions()
|
|
assert.ok(updateTransactionSpy.calledOnce)
|
|
assert.deepEqual(resultantActions[1], {
|
|
type: 'UPDATE_TRANSACTION_PARAMS',
|
|
id: txData.id,
|
|
value: txParams,
|
|
})
|
|
})
|
|
|
|
it('rejects with error message', async function () {
|
|
const store = mockStore()
|
|
|
|
updateTransactionSpy = sinon.stub(background, 'updateTransaction')
|
|
updateTransactionSpy.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.updateTransaction(txData))
|
|
assert.fail('Should have thrown error')
|
|
} catch (error) {
|
|
assert.equal(error.message, 'error')
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#lockMetamask', function () {
|
|
let backgroundSetLockedSpy
|
|
|
|
afterEach(function () {
|
|
backgroundSetLockedSpy.restore()
|
|
})
|
|
|
|
it('calls setLocked', async function () {
|
|
const store = mockStore()
|
|
|
|
backgroundSetLockedSpy = sinon.spy(background, 'setLocked')
|
|
|
|
await store.dispatch(actions.lockMetamask())
|
|
assert(backgroundSetLockedSpy.calledOnce)
|
|
})
|
|
|
|
it('returns display warning error with value when setLocked in background callback errors', async function () {
|
|
const store = mockStore()
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'LOCK_METAMASK' },
|
|
]
|
|
backgroundSetLockedSpy = sinon.stub(background, 'setLocked')
|
|
backgroundSetLockedSpy.callsFake((callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.lockMetamask())
|
|
assert.fail('Should have thrown error')
|
|
} catch (error) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#setSelectedAddress', function () {
|
|
let setSelectedAddressSpy
|
|
|
|
afterEach(function () {
|
|
setSelectedAddressSpy.restore()
|
|
})
|
|
|
|
it('calls setSelectedAddress in background', async function () {
|
|
setSelectedAddressSpy = sinon
|
|
.stub(background, 'setSelectedAddress')
|
|
.callsArgWith(1, null)
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(
|
|
actions.setSelectedAddress(
|
|
'0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
|
|
),
|
|
)
|
|
assert(setSelectedAddressSpy.calledOnce)
|
|
})
|
|
|
|
it('errors when setSelectedAddress throws', async function () {
|
|
setSelectedAddressSpy = sinon
|
|
.stub(background, 'setSelectedAddress')
|
|
.callsArgWith(1, new Error('error'))
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
await store.dispatch(actions.setSelectedAddress())
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
})
|
|
|
|
describe('#showAccountDetail', function () {
|
|
let setSelectedAddressSpy
|
|
|
|
afterEach(function () {
|
|
setSelectedAddressSpy.restore()
|
|
})
|
|
|
|
it('#showAccountDetail', async function () {
|
|
setSelectedAddressSpy = sinon
|
|
.stub(background, 'setSelectedAddress')
|
|
.callsArgWith(1, null)
|
|
const store = mockStore({
|
|
activeTab: {},
|
|
metamask: { alertEnabledness: {}, selectedAddress: '0x123' },
|
|
})
|
|
|
|
await store.dispatch(actions.showAccountDetail())
|
|
assert(setSelectedAddressSpy.calledOnce)
|
|
})
|
|
|
|
it('displays warning if setSelectedAddress throws', async function () {
|
|
setSelectedAddressSpy = sinon
|
|
.stub(background, 'setSelectedAddress')
|
|
.callsArgWith(1, new Error('error'))
|
|
const store = mockStore({
|
|
activeTab: {},
|
|
metamask: { alertEnabledness: {}, selectedAddress: '0x123' },
|
|
})
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
await store.dispatch(actions.showAccountDetail())
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
})
|
|
|
|
describe('#addToken', function () {
|
|
let addTokenSpy
|
|
|
|
afterEach(function () {
|
|
addTokenSpy.restore()
|
|
})
|
|
|
|
it('calls addToken in background', async function () {
|
|
addTokenSpy = sinon.stub(background, 'addToken').callsArgWith(4, null)
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(actions.addToken())
|
|
assert(addTokenSpy.calledOnce)
|
|
})
|
|
|
|
it('errors when addToken in background throws', async function () {
|
|
addTokenSpy = sinon
|
|
.stub(background, 'addToken')
|
|
.callsArgWith(4, new Error('error'))
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
try {
|
|
await store.dispatch(actions.addToken())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#removeToken', function () {
|
|
let removeTokenSpy
|
|
|
|
afterEach(function () {
|
|
removeTokenSpy.restore()
|
|
})
|
|
|
|
it('calls removeToken in background', async function () {
|
|
removeTokenSpy = sinon
|
|
.stub(background, 'removeToken')
|
|
.callsArgWith(1, null)
|
|
const store = mockStore()
|
|
await store.dispatch(actions.removeToken())
|
|
assert(removeTokenSpy.calledOnce)
|
|
})
|
|
|
|
it('errors when removeToken in background fails', async function () {
|
|
removeTokenSpy = sinon
|
|
.stub(background, 'removeToken')
|
|
.callsArgWith(1, new Error('error'))
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
try {
|
|
await store.dispatch(actions.removeToken())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#setProviderType', function () {
|
|
let setProviderTypeSpy
|
|
let store
|
|
|
|
beforeEach(function () {
|
|
store = mockStore({ metamask: { provider: {} } })
|
|
})
|
|
|
|
afterEach(function () {
|
|
setProviderTypeSpy.restore()
|
|
})
|
|
|
|
it('calls setProviderType', async function () {
|
|
setProviderTypeSpy = sinon
|
|
.stub(background, 'setProviderType')
|
|
.callsArgWith(1, null)
|
|
await store.dispatch(actions.setProviderType())
|
|
assert(setProviderTypeSpy.calledOnce)
|
|
})
|
|
|
|
it('displays warning when setProviderType throws', async function () {
|
|
setProviderTypeSpy = sinon
|
|
.stub(background, 'setProviderType')
|
|
.callsArgWith(1, new Error('error'))
|
|
const expectedActions = [
|
|
{ type: 'DISPLAY_WARNING', value: 'Had a problem changing networks!' },
|
|
]
|
|
|
|
await store.dispatch(actions.setProviderType())
|
|
assert(setProviderTypeSpy.calledOnce)
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
})
|
|
|
|
describe('#setRpcTarget', function () {
|
|
let setRpcTargetSpy
|
|
|
|
afterEach(function () {
|
|
setRpcTargetSpy.restore()
|
|
})
|
|
|
|
it('calls setRpcTarget', async function () {
|
|
setRpcTargetSpy = sinon
|
|
.stub(background, 'setCustomRpc')
|
|
.callsArgWith(4, null)
|
|
const store = mockStore()
|
|
await store.dispatch(actions.setRpcTarget('http://localhost:8545'))
|
|
assert(setRpcTargetSpy.calledOnce)
|
|
})
|
|
|
|
it('displays warning when setRpcTarget throws', async function () {
|
|
setRpcTargetSpy = sinon
|
|
.stub(background, 'setCustomRpc')
|
|
.callsArgWith(4, new Error('error'))
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'DISPLAY_WARNING', value: 'Had a problem changing networks!' },
|
|
]
|
|
|
|
await store.dispatch(actions.setRpcTarget())
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
})
|
|
|
|
describe('#addToAddressBook', function () {
|
|
it('calls setAddressBook', async function () {
|
|
const addToAddressBookSpy = sinon
|
|
.stub(background, 'setAddressBook')
|
|
.callsArgWith(4, null, true)
|
|
const store = mockStore()
|
|
await store.dispatch(actions.addToAddressBook('test'))
|
|
assert(addToAddressBookSpy.calledOnce)
|
|
addToAddressBookSpy.restore()
|
|
})
|
|
})
|
|
|
|
describe('#exportAccount', function () {
|
|
let verifyPasswordSpy, exportAccountSpy
|
|
|
|
afterEach(function () {
|
|
verifyPasswordSpy.restore()
|
|
exportAccountSpy.restore()
|
|
})
|
|
|
|
it('returns expected actions for successful action', async function () {
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{
|
|
type: 'SHOW_PRIVATE_KEY',
|
|
value:
|
|
'7ec73b91bb20f209a7ff2d32f542c3420b4fccf14abcc7840d2eff0ebcb18505',
|
|
},
|
|
]
|
|
|
|
verifyPasswordSpy = sinon.spy(background, 'verifyPassword')
|
|
exportAccountSpy = sinon.spy(background, 'exportAccount')
|
|
|
|
await store.dispatch(
|
|
actions.exportAccount(
|
|
password,
|
|
'0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
|
|
),
|
|
)
|
|
assert(verifyPasswordSpy.calledOnce)
|
|
assert(exportAccountSpy.calledOnce)
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
|
|
it('returns action errors when first func callback errors', async function () {
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'Incorrect Password.' },
|
|
]
|
|
|
|
verifyPasswordSpy = sinon.stub(background, 'verifyPassword')
|
|
verifyPasswordSpy.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(
|
|
actions.exportAccount(
|
|
password,
|
|
'0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
|
|
),
|
|
)
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
|
|
it('returns action errors when second func callback errors', async function () {
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{
|
|
type: 'DISPLAY_WARNING',
|
|
value: 'Had a problem exporting the account.',
|
|
},
|
|
]
|
|
|
|
exportAccountSpy = sinon.stub(background, 'exportAccount')
|
|
exportAccountSpy.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(
|
|
actions.exportAccount(
|
|
password,
|
|
'0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
|
|
),
|
|
)
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#setAccountLabel', function () {
|
|
it('calls setAccountLabel', async function () {
|
|
const setAccountLabelSpy = sinon
|
|
.stub(background, 'setAccountLabel')
|
|
.callsArgWith(2, null)
|
|
const store = mockStore()
|
|
await store.dispatch(
|
|
actions.setAccountLabel(
|
|
'0x0dcd5d886577d5081b0c52e242ef29e70be3e7bc',
|
|
'test',
|
|
),
|
|
)
|
|
assert(setAccountLabelSpy.calledOnce)
|
|
})
|
|
})
|
|
|
|
describe('#setFeatureFlag', function () {
|
|
let setFeatureFlagSpy
|
|
|
|
afterEach(function () {
|
|
setFeatureFlagSpy.restore()
|
|
})
|
|
|
|
it('calls setFeatureFlag in the background', async function () {
|
|
setFeatureFlagSpy = sinon
|
|
.stub(background, 'setFeatureFlag')
|
|
.callsArgWith(2, null)
|
|
const store = mockStore()
|
|
|
|
await store.dispatch(actions.setFeatureFlag())
|
|
assert(setFeatureFlagSpy.calledOnce)
|
|
})
|
|
|
|
it('errors when setFeatureFlag in background throws', async function () {
|
|
setFeatureFlagSpy = sinon
|
|
.stub(background, 'setFeatureFlag')
|
|
.callsArgWith(2, new Error('error'))
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
|
|
try {
|
|
await store.dispatch(actions.setFeatureFlag())
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#setCompletedOnboarding', function () {
|
|
it('completes onboarding', async function () {
|
|
const completeOnboardingSpy = sinon.stub(background, 'completeOnboarding')
|
|
completeOnboardingSpy.callsFake((cb) => cb())
|
|
const store = mockStore()
|
|
await store.dispatch(actions.setCompletedOnboarding())
|
|
assert.equal(completeOnboardingSpy.callCount, 1)
|
|
completeOnboardingSpy.restore()
|
|
})
|
|
})
|
|
|
|
describe('#setUseBlockie', function () {
|
|
let setUseBlockieSpy
|
|
|
|
beforeEach(function () {
|
|
setUseBlockieSpy = sinon.stub(background, 'setUseBlockie')
|
|
})
|
|
|
|
afterEach(function () {
|
|
setUseBlockieSpy.restore()
|
|
})
|
|
|
|
it('calls setUseBlockie in background', function () {
|
|
const store = mockStore()
|
|
|
|
store.dispatch(actions.setUseBlockie())
|
|
assert(setUseBlockieSpy.calledOnce)
|
|
})
|
|
|
|
it('errors when setUseBlockie in background throws', function () {
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
{ type: 'SET_USE_BLOCKIE', value: undefined },
|
|
]
|
|
|
|
setUseBlockieSpy.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
store.dispatch(actions.setUseBlockie())
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
})
|
|
|
|
describe('#updateCurrentLocale', function () {
|
|
let setCurrentLocaleSpy
|
|
|
|
beforeEach(function () {
|
|
sinon.stub(window, 'fetch').resolves({
|
|
json: async () => enLocale,
|
|
})
|
|
})
|
|
|
|
afterEach(function () {
|
|
setCurrentLocaleSpy.restore()
|
|
window.fetch.restore()
|
|
})
|
|
|
|
it('calls expected actions', async function () {
|
|
const store = mockStore()
|
|
setCurrentLocaleSpy = sinon.spy(background, 'setCurrentLocale')
|
|
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{
|
|
type: 'SET_CURRENT_LOCALE',
|
|
value: { locale: 'en', messages: enLocale },
|
|
},
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
]
|
|
|
|
await store.dispatch(actions.updateCurrentLocale('en'))
|
|
assert(setCurrentLocaleSpy.calledOnce)
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
})
|
|
|
|
it('errors when setCurrentLocale throws', async function () {
|
|
const store = mockStore()
|
|
const expectedActions = [
|
|
{ type: 'SHOW_LOADING_INDICATION', value: undefined },
|
|
{ type: 'HIDE_LOADING_INDICATION' },
|
|
{ type: 'DISPLAY_WARNING', value: 'error' },
|
|
]
|
|
setCurrentLocaleSpy = sinon.stub(background, 'setCurrentLocale')
|
|
setCurrentLocaleSpy.callsFake((_, callback) => {
|
|
callback(new Error('error'))
|
|
})
|
|
|
|
try {
|
|
await store.dispatch(actions.updateCurrentLocale('en'))
|
|
assert.fail('Should have thrown error')
|
|
} catch (_) {
|
|
assert.deepEqual(store.getActions(), expectedActions)
|
|
}
|
|
})
|
|
})
|
|
|
|
describe('#markPasswordForgotten', function () {
|
|
it('calls markPasswordForgotten', async function () {
|
|
const store = mockStore()
|
|
const markPasswordForgottenSpy = sinon
|
|
.stub(background, 'markPasswordForgotten')
|
|
.callsArg(0)
|
|
|
|
await store.dispatch(actions.markPasswordForgotten())
|
|
|
|
const resultantActions = store.getActions()
|
|
assert.deepEqual(resultantActions[1], {
|
|
type: 'FORGOT_PASSWORD',
|
|
value: true,
|
|
})
|
|
assert.ok(markPasswordForgottenSpy.calledOnce)
|
|
markPasswordForgottenSpy.restore()
|
|
})
|
|
})
|
|
|
|
describe('#unMarkPasswordForgotten', function () {
|
|
it('calls unMarkPasswordForgotten', async function () {
|
|
const store = mockStore()
|
|
const unMarkPasswordForgottenSpy = sinon
|
|
.stub(background, 'unMarkPasswordForgotten')
|
|
.callsArg(0)
|
|
|
|
await store.dispatch(actions.unMarkPasswordForgotten())
|
|
|
|
const resultantActions = store.getActions()
|
|
assert.deepEqual(resultantActions[0], {
|
|
type: 'FORGOT_PASSWORD',
|
|
value: false,
|
|
})
|
|
assert.ok(unMarkPasswordForgottenSpy.calledOnce)
|
|
unMarkPasswordForgottenSpy.restore()
|
|
})
|
|
})
|
|
})
|