diff options
Diffstat (limited to 'test/unit')
| -rw-r--r-- | test/unit/actions/restore_vault_test.js | 60 | ||||
| -rw-r--r-- | test/unit/actions/tx_test.js | 8 | ||||
| -rw-r--r-- | test/unit/idStore-migration-test.js | 160 | ||||
| -rw-r--r-- | test/unit/keyring-controller-test.js | 173 | ||||
| -rw-r--r-- | test/unit/keyrings/hd-test.js | 108 | ||||
| -rw-r--r-- | test/unit/keyrings/simple-test.js | 83 |
6 files changed, 528 insertions, 64 deletions
diff --git a/test/unit/actions/restore_vault_test.js b/test/unit/actions/restore_vault_test.js deleted file mode 100644 index 609f5429e..000000000 --- a/test/unit/actions/restore_vault_test.js +++ /dev/null @@ -1,60 +0,0 @@ -var jsdom = require('mocha-jsdom') -var assert = require('assert') -var freeze = require('deep-freeze-strict') -var path = require('path') -var sinon = require('sinon') - -var actions = require(path.join(__dirname, '..', '..', '..', 'ui', 'app', 'actions.js')) -var reducers = require(path.join(__dirname, '..', '..', '..', 'ui', 'app', 'reducers.js')) - -describe('#recoverFromSeed(password, seed)', function() { - - beforeEach(function() { - // sinon allows stubbing methods that are easily verified - this.sinon = sinon.sandbox.create() - }) - - afterEach(function() { - // sinon requires cleanup otherwise it will overwrite context - this.sinon.restore() - }) - - // stub out account manager - actions._setAccountManager({ - recoverFromSeed(pw, seed, cb) { - cb(null, { - identities: { - foo: 'bar' - } - }) - }, - }) - - it('sets metamask.isUnlocked to true', function() { - var initialState = { - metamask: { - isUnlocked: false, - isInitialized: false, - } - } - freeze(initialState) - - const restorePhrase = 'invite heavy among daring outdoor dice jelly coil stable note seat vicious' - const password = 'foo' - const dispatchFunc = actions.recoverFromSeed(password, restorePhrase) - - var dispatchStub = this.sinon.stub() - dispatchStub.withArgs({ TYPE: actions.unlockMetamask() }).onCall(0) - dispatchStub.withArgs({ TYPE: actions.showAccountsPage() }).onCall(1) - - var action - var resultingState = initialState - dispatchFunc((newAction) => { - action = newAction - resultingState = reducers(resultingState, action) - }) - - assert.equal(resultingState.metamask.isUnlocked, true, 'was unlocked') - assert.equal(resultingState.metamask.isInitialized, true, 'was initialized') - }); -}); diff --git a/test/unit/actions/tx_test.js b/test/unit/actions/tx_test.js index c08a8aa26..1f06b1120 100644 --- a/test/unit/actions/tx_test.js +++ b/test/unit/actions/tx_test.js @@ -46,7 +46,7 @@ describe('tx confirmation screen', function() { describe('cancelTx', function() { before(function(done) { - actions._setAccountManager({ + actions._setBackgroundConnection({ approveTransaction(txId, cb) { cb('An error!') }, cancelTransaction(txId) { /* noop */ }, clearSeedWordCache(cb) { cb() }, @@ -75,7 +75,7 @@ describe('tx confirmation screen', function() { before(function(done) { alert = () => {/* noop */} - actions._setAccountManager({ + actions._setBackgroundConnection({ approveTransaction(txId, cb) { cb({message: 'An error!'}) }, }) @@ -96,7 +96,7 @@ describe('tx confirmation screen', function() { describe('when there is success', function() { it('should complete tx and go home', function() { - actions._setAccountManager({ + actions._setBackgroundConnection({ approveTransaction(txId, cb) { cb() }, }) @@ -135,7 +135,7 @@ describe('tx confirmation screen', function() { } freeze(initialState) - actions._setAccountManager({ + actions._setBackgroundConnection({ approveTransaction(txId, cb) { cb() }, }) diff --git a/test/unit/idStore-migration-test.js b/test/unit/idStore-migration-test.js new file mode 100644 index 000000000..59801c868 --- /dev/null +++ b/test/unit/idStore-migration-test.js @@ -0,0 +1,160 @@ +const async = require('async') +const assert = require('assert') +const ethUtil = require('ethereumjs-util') +const BN = ethUtil.BN +const ConfigManager = require('../../app/scripts/lib/config-manager') +const delegateCallCode = require('../lib/example-code.json').delegateCallCode + +// The old way: +const IdentityStore = require('../../app/scripts/lib/idStore') +const STORAGE_KEY = 'metamask-config' +const extend = require('xtend') + +// The new ways: +var KeyringController = require('../../app/scripts/keyring-controller') +const mockEncryptor = require('../lib/mock-encryptor') +const MockSimpleKeychain = require('../lib/mock-simple-keychain') +const sinon = require('sinon') + +const mockVault = { + seed: 'picnic injury awful upper eagle junk alert toss flower renew silly vague', + account: '0x5d8de92c205279c10e5669f797b853ccef4f739a', +} + +describe('IdentityStore to KeyringController migration', function() { + + // The stars of the show: + let idStore, keyringController, seedWords, configManager + + let password = 'password123' + let entropy = 'entripppppyy duuude' + let accounts = [] + let newAccounts = [] + let originalKeystore + + // This is a lot of setup, I know! + // We have to create an old style vault, populate it, + // and THEN create a new one, before we can run tests on it. + beforeEach(function(done) { + this.sinon = sinon.sandbox.create() + window.localStorage = {} // Hacking localStorage support into JSDom + configManager = new ConfigManager({ + loadData, + setData: (d) => { window.localStorage = d } + }) + + + idStore = new IdentityStore({ + configManager: configManager, + ethStore: { + addAccount(acct) { accounts.push(ethUtil.addHexPrefix(acct)) }, + del(acct) { delete accounts[acct] }, + }, + }) + + idStore._createVault(password, mockVault.seed, null, (err) => { + assert.ifError(err, 'createNewVault threw error') + originalKeystore = idStore._idmgmt.keyStore + + idStore.setLocked((err) => { + assert.ifError(err, 'createNewVault threw error') + keyringController = new KeyringController({ + configManager, + ethStore: { + addAccount(acct) { newAccounts.push(ethUtil.addHexPrefix(acct)) }, + del(acct) { delete newAccounts[acct] }, + }, + }) + + // Stub out the browser crypto for a mock encryptor. + // Browser crypto is tested in the integration test suite. + keyringController.encryptor = mockEncryptor + done() + }) + }) + }) + + describe('entering a password', function() { + it('should identify an old wallet as an initialized keyring', function() { + keyringController.configManager.setWallet('something') + const state = keyringController.getState() + assert(state.isInitialized, 'old vault counted as initialized.') + }) + + /* + it('should use the password to migrate the old vault', function(done) { + this.timeout(5000) + console.log('calling submitPassword') + console.dir(keyringController) + keyringController.submitPassword(password, function (err, state) { + assert.ifError(err, 'submitPassword threw error') + + function log(str, dat) { console.log(str + ': ' + JSON.stringify(dat)) } + + let newAccounts = keyringController.getAccounts() + log('new accounts: ', newAccounts) + + let newAccount = ethUtil.addHexPrefix(newAccounts[0]) + assert.equal(ethUtil.addHexPrefix(newAccount), mockVault.account, 'restored the correct account') + const newSeed = keyringController.keyrings[0].mnemonic + log('keyringController keyrings', keyringController.keyrings) + assert.equal(newSeed, mockVault.seed, 'seed phrase transferred.') + + assert(configManager.getVault(), 'new type of vault is persisted') + done() + }) + }) + */ + + }) +}) + +function loadData () { + var oldData = getOldStyleData() + var newData + try { + newData = JSON.parse(window.localStorage[STORAGE_KEY]) + } catch (e) {} + + var data = extend({ + meta: { + version: 0, + }, + data: { + config: { + provider: { + type: 'testnet', + }, + }, + }, + }, oldData || null, newData || null) + return data +} + +function setData (data) { + window.localStorage[STORAGE_KEY] = JSON.stringify(data) +} + +function getOldStyleData () { + var config, wallet, seedWords + + var result = { + meta: { version: 0 }, + data: {}, + } + + try { + config = JSON.parse(window.localStorage['config']) + result.data.config = config + } catch (e) {} + try { + wallet = JSON.parse(window.localStorage['lightwallet']) + result.data.wallet = wallet + } catch (e) {} + try { + seedWords = window.localStorage['seedWords'] + result.data.seedWords = seedWords + } catch (e) {} + + return result +} diff --git a/test/unit/keyring-controller-test.js b/test/unit/keyring-controller-test.js new file mode 100644 index 000000000..5f055e9ee --- /dev/null +++ b/test/unit/keyring-controller-test.js @@ -0,0 +1,173 @@ +var assert = require('assert') +var KeyringController = require('../../app/scripts/keyring-controller') +var configManagerGen = require('../lib/mock-config-manager') +const ethUtil = require('ethereumjs-util') +const BN = ethUtil.BN +const async = require('async') +const mockEncryptor = require('../lib/mock-encryptor') +const MockSimpleKeychain = require('../lib/mock-simple-keychain') +const sinon = require('sinon') + +describe('KeyringController', function() { + + let keyringController, state + let password = 'password123' + let entropy = 'entripppppyy duuude' + let seedWords = 'puzzle seed penalty soldier say clay field arctic metal hen cage runway' + let addresses = ['eF35cA8EbB9669A35c31b5F6f249A9941a812AC1'.toLowerCase()] + let accounts = [] + let originalKeystore + + beforeEach(function(done) { + this.sinon = sinon.sandbox.create() + window.localStorage = {} // Hacking localStorage support into JSDom + + keyringController = new KeyringController({ + configManager: configManagerGen(), + ethStore: { + addAccount(acct) { accounts.push(ethUtil.addHexPrefix(acct)) }, + }, + }) + + // Stub out the browser crypto for a mock encryptor. + // Browser crypto is tested in the integration test suite. + keyringController.encryptor = mockEncryptor + + keyringController.createNewVaultAndKeychain(password, null, function (err, newState) { + assert.ifError(err) + state = newState + done() + }) + }) + + afterEach(function() { + // Cleanup mocks + this.sinon.restore() + }) + + describe('#createNewVaultAndKeychain', function () { + this.timeout(10000) + + it('should set a vault on the configManager', function(done) { + keyringController.configManager.setVault(null) + assert(!keyringController.configManager.getVault(), 'no previous vault') + keyringController.createNewVaultAndKeychain(password, null, (err, state) => { + assert.ifError(err) + const vault = keyringController.configManager.getVault() + assert(vault, 'vault created') + done() + }) + }) + }) + + describe('#restoreKeyring', function() { + + it(`should pass a keyring's serialized data back to the correct type.`, function() { + const mockSerialized = { + type: 'HD Key Tree', + data: { + mnemonic: seedWords, + n: 1, + } + } + const mock = this.sinon.mock(keyringController) + + mock.expects('loadBalanceAndNickname') + .exactly(1) + + var keyring = keyringController.restoreKeyring(mockSerialized) + assert.equal(keyring.wallets.length, 1, 'one wallet restored') + assert.equal(keyring.getAccounts()[0], addresses[0]) + mock.verify() + }) + + }) + + describe('#migrateAndGetKey', function() { + it('should return the key for that password', function(done) { + keyringController.migrateAndGetKey(password) + .then((key) => { + assert(key, 'a key is returned') + done() + }) + }) + }) + + describe('#createNickname', function() { + it('should add the address to the identities hash', function() { + const fakeAddress = '0x12345678' + keyringController.createNickname(fakeAddress) + const identities = keyringController.identities + const identity = identities[fakeAddress] + assert.equal(identity.address, fakeAddress) + + const nick = keyringController.configManager.nicknameForWallet(fakeAddress) + assert.equal(typeof nick, 'string') + }) + }) + + describe('#saveAccountLabel', function() { + it ('sets the nickname', function() { + const account = addresses[0] + var nick = 'Test nickname' + keyringController.identities[ethUtil.addHexPrefix(account)] = {} + const label = keyringController.saveAccountLabel(account, nick) + assert.equal(label, nick) + + const persisted = keyringController.configManager.nicknameForWallet(account) + assert.equal(persisted, nick) + }) + + this.timeout(10000) + it('retrieves the persisted nickname', function(done) { + const account = addresses[0] + var nick = 'Test nickname' + keyringController.configManager.setNicknameForWallet(account, nick) + console.log('calling to restore') + keyringController.createNewVaultAndRestore(password, seedWords, (err, state) => { + console.dir({err}) + assert.ifError(err) + + const identity = keyringController.identities['0x' + account] + assert.equal(identity.name, nick) + + assert(accounts) + done() + }) + }) + }) + + describe('#getAccounts', function() { + it('returns the result of getAccounts for each keyring', function() { + keyringController.keyrings = [ + { getAccounts() { return [1,2,3] } }, + { getAccounts() { return [4,5,6] } }, + ] + + const result = keyringController.getAccounts() + assert.deepEqual(result, [1,2,3,4,5,6]) + }) + }) + + describe('#addGasBuffer', function() { + it('adds 100k gas buffer to estimates', function() { + + const gas = '0x04ee59' // Actual estimated gas example + const tooBigOutput = '0x80674f9' // Actual bad output + const bnGas = new BN(ethUtil.stripHexPrefix(gas), 16) + const correctBuffer = new BN('100000', 10) + const correct = bnGas.add(correctBuffer) + + const tooBig = new BN(tooBigOutput, 16) + const result = keyringController.addGasBuffer(gas) + const bnResult = new BN(ethUtil.stripHexPrefix(result), 16) + + assert.equal(result.indexOf('0x'), 0, 'included hex prefix') + assert(bnResult.gt(bnGas), 'Estimate increased in value.') + assert.equal(bnResult.sub(bnGas).toString(10), '100000', 'added 100k gas') + assert.equal(result, '0x' + correct.toString(16), 'Added the right amount') + assert.notEqual(result, tooBigOutput, 'not that bad estimate') + }) + }) +}) + diff --git a/test/unit/keyrings/hd-test.js b/test/unit/keyrings/hd-test.js new file mode 100644 index 000000000..5d7fbe3db --- /dev/null +++ b/test/unit/keyrings/hd-test.js @@ -0,0 +1,108 @@ +const assert = require('assert') +const extend = require('xtend') +const HdKeyring = require('../../../app/scripts/keyrings/hd') + +// Sample account: +const privKeyHex = 'b8a9c05beeedb25df85f8d641538cbffedf67216048de9c678ee26260eb91952' + +const sampleMnemonic = 'finish oppose decorate face calm tragic certain desk hour urge dinosaur mango' +const firstAcct = '1c96099350f13d558464ec79b9be4445aa0ef579' +const secondAcct = '1b00aed43a693f3a957f9feb5cc08afa031e37a0' + +describe('hd-keyring', function() { + + let keyring + beforeEach(function() { + keyring = new HdKeyring() + }) + + describe('constructor', function() { + keyring = new HdKeyring({ + mnemonic: sampleMnemonic, + n: 2, + }) + + const accounts = keyring.getAccounts() + assert.equal(accounts[0], firstAcct) + assert.equal(accounts[1], secondAcct) + }) + + describe('Keyring.type()', function() { + it('is a class method that returns the type string.', function() { + const type = HdKeyring.type() + assert.equal(typeof type, 'string') + }) + }) + + describe('#type', function() { + it('returns the correct value', function() { + const type = keyring.type + const correct = HdKeyring.type() + assert.equal(type, correct) + }) + }) + + describe('#serialize empty wallets.', function() { + it('serializes a new mnemonic', function() { + const output = keyring.serialize() + assert.equal(output.n, 0) + assert.equal(output.mnemonic, null) + }) + }) + + describe('#deserialize a private key', function() { + it('serializes what it deserializes', function() { + keyring.deserialize({ + mnemonic: sampleMnemonic, + n: 1 + }) + assert.equal(keyring.wallets.length, 1, 'restores two accounts') + keyring.addAccounts(1) + + const accounts = keyring.getAccounts() + assert.equal(accounts[0], firstAcct) + assert.equal(accounts[1], secondAcct) + assert.equal(accounts.length, 2) + + const serialized = keyring.serialize() + assert.equal(serialized.mnemonic, sampleMnemonic) + }) + }) + + describe('#addAccounts', function() { + describe('with no arguments', function() { + it('creates a single wallet', function() { + keyring.addAccounts() + assert.equal(keyring.wallets.length, 1) + }) + }) + + describe('with a numeric argument', function() { + it('creates that number of wallets', function() { + keyring.addAccounts(3) + assert.equal(keyring.wallets.length, 3) + }) + }) + }) + + describe('#getAccounts', function() { + it('calls getAddress on each wallet', function() { + + // Push a mock wallet + const desiredOutput = 'foo' + keyring.wallets.push({ + getAddress() { + return { + toString() { + return desiredOutput + } + } + } + }) + + const output = keyring.getAccounts() + assert.equal(output[0], desiredOutput) + assert.equal(output.length, 1) + }) + }) +}) diff --git a/test/unit/keyrings/simple-test.js b/test/unit/keyrings/simple-test.js new file mode 100644 index 000000000..ba000a7a8 --- /dev/null +++ b/test/unit/keyrings/simple-test.js @@ -0,0 +1,83 @@ +const assert = require('assert') +const extend = require('xtend') +const SimpleKeyring = require('../../../app/scripts/keyrings/simple') +const TYPE_STR = 'Simple Key Pair' + +// Sample account: +const privKeyHex = 'b8a9c05beeedb25df85f8d641538cbffedf67216048de9c678ee26260eb91952' + +describe('simple-keyring', function() { + + let keyring + beforeEach(function() { + keyring = new SimpleKeyring() + }) + + describe('Keyring.type()', function() { + it('is a class method that returns the type string.', function() { + const type = SimpleKeyring.type() + assert.equal(type, TYPE_STR) + }) + }) + + describe('#type', function() { + it('returns the correct value', function() { + const type = keyring.type + assert.equal(type, TYPE_STR) + }) + }) + + describe('#serialize empty wallets.', function() { + it('serializes an empty array', function() { + const output = keyring.serialize() + assert.deepEqual(output, []) + }) + }) + + describe('#deserialize a private key', function() { + it('serializes what it deserializes', function() { + keyring.deserialize([privKeyHex]) + assert.equal(keyring.wallets.length, 1, 'has one wallet') + + const serialized = keyring.serialize() + assert.equal(serialized[0], privKeyHex) + }) + }) + + describe('#addAccounts', function() { + describe('with no arguments', function() { + it('creates a single wallet', function() { + keyring.addAccounts() + assert.equal(keyring.wallets.length, 1) + }) + }) + + describe('with a numeric argument', function() { + it('creates that number of wallets', function() { + keyring.addAccounts(3) + assert.equal(keyring.wallets.length, 3) + }) + }) + }) + + describe('#getAccounts', function() { + it('calls getAddress on each wallet', function() { + + // Push a mock wallet + const desiredOutput = 'foo' + keyring.wallets.push({ + getAddress() { + return { + toString() { + return desiredOutput + } + } + } + }) + + const output = keyring.getAccounts() + assert.equal(output[0], desiredOutput) + assert.equal(output.length, 1) + }) + }) +}) |