Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
var assert = require('assert')
|
2016-06-24 16:13:27 -07:00
|
|
|
const extend = require('xtend')
|
|
|
|
const STORAGE_KEY = 'metamask-persistance-key'
|
|
|
|
var configManagerGen = require('../lib/mock-config-manager')
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
var configManager
|
|
|
|
|
|
|
|
describe('config-manager', function() {
|
|
|
|
|
2016-06-16 15:04:50 -07:00
|
|
|
beforeEach(function() {
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
window.localStorage = {} // Hacking localStorage support into JSDom
|
2016-06-24 16:13:27 -07:00
|
|
|
configManager = configManagerGen()
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
})
|
|
|
|
|
2016-06-16 15:04:50 -07:00
|
|
|
describe('confirmation', function() {
|
|
|
|
|
|
|
|
describe('#getConfirmed', function() {
|
|
|
|
it('should return false if no previous key exists', function() {
|
|
|
|
var result = configManager.getConfirmed()
|
|
|
|
assert.ok(!result)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('#setConfirmed', function() {
|
|
|
|
it('should make getConfirmed return true once set', function() {
|
2016-06-30 11:30:46 -07:00
|
|
|
assert.equal(configManager.getConfirmed(), false)
|
2016-06-16 15:04:50 -07:00
|
|
|
configManager.setConfirmed(true)
|
|
|
|
var result = configManager.getConfirmed()
|
|
|
|
assert.equal(result, true)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should be able to set false', function() {
|
|
|
|
configManager.setConfirmed(false)
|
|
|
|
var result = configManager.getConfirmed()
|
|
|
|
assert.equal(result, false)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should persist to local storage', function() {
|
|
|
|
configManager.setConfirmed(true)
|
|
|
|
var data = configManager.getData()
|
|
|
|
assert.equal(data.isConfirmed, true)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
describe('#setConfig', function() {
|
|
|
|
window.localStorage = {} // Hacking localStorage support into JSDom
|
|
|
|
|
|
|
|
it('should set the config key', function () {
|
|
|
|
var testConfig = {
|
|
|
|
provider: {
|
|
|
|
type: 'rpc',
|
|
|
|
rpcTarget: 'foobar'
|
|
|
|
}
|
|
|
|
}
|
|
|
|
configManager.setConfig(testConfig)
|
|
|
|
var result = configManager.getData()
|
|
|
|
|
|
|
|
assert.equal(result.config.provider.type, testConfig.provider.type)
|
|
|
|
assert.equal(result.config.provider.rpcTarget, testConfig.provider.rpcTarget)
|
|
|
|
})
|
|
|
|
|
|
|
|
it('setting wallet should not overwrite config', function() {
|
|
|
|
var testConfig = {
|
|
|
|
provider: {
|
|
|
|
type: 'rpc',
|
|
|
|
rpcTarget: 'foobar'
|
2016-06-30 11:30:46 -07:00
|
|
|
},
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
}
|
2016-06-30 11:30:46 -07:00
|
|
|
configManager.setConfirmed(true)
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
configManager.setConfig(testConfig)
|
|
|
|
|
|
|
|
var testWallet = {
|
|
|
|
name: 'this is my fake wallet'
|
|
|
|
}
|
|
|
|
configManager.setWallet(testWallet)
|
|
|
|
|
|
|
|
var result = configManager.getData()
|
|
|
|
assert.equal(result.wallet.name, testWallet.name, 'wallet name is set')
|
|
|
|
assert.equal(result.config.provider.rpcTarget, testConfig.provider.rpcTarget)
|
2016-06-30 11:30:46 -07:00
|
|
|
assert.equal(configManager.getConfirmed(), true)
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
|
|
|
|
testConfig.provider.type = 'something else!'
|
|
|
|
configManager.setConfig(testConfig)
|
|
|
|
|
|
|
|
result = configManager.getData()
|
|
|
|
assert.equal(result.wallet.name, testWallet.name, 'wallet name is set')
|
|
|
|
assert.equal(result.config.provider.rpcTarget, testConfig.provider.rpcTarget)
|
|
|
|
assert.equal(result.config.provider.type, testConfig.provider.type)
|
2016-06-30 11:30:46 -07:00
|
|
|
assert.equal(configManager.getConfirmed(), true)
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2016-05-20 16:18:54 -07:00
|
|
|
describe('wallet nicknames', function() {
|
|
|
|
it('should return null when no nicknames are saved', function() {
|
|
|
|
var nick = configManager.nicknameForWallet('0x0')
|
|
|
|
assert.equal(nick, null, 'no nickname returned')
|
|
|
|
})
|
|
|
|
|
|
|
|
it('should persist nicknames', function() {
|
|
|
|
var account = '0x0'
|
|
|
|
var nick1 = 'foo'
|
|
|
|
var nick2 = 'bar'
|
|
|
|
configManager.setNicknameForWallet(account, nick1)
|
|
|
|
|
|
|
|
var result1 = configManager.nicknameForWallet(account)
|
|
|
|
assert.equal(result1, nick1)
|
|
|
|
|
|
|
|
configManager.setNicknameForWallet(account, nick2)
|
|
|
|
var result2 = configManager.nicknameForWallet(account)
|
|
|
|
assert.equal(result2, nick2)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
describe('rpc manipulations', function() {
|
|
|
|
it('changing rpc should return a different rpc', function() {
|
|
|
|
var firstRpc = 'first'
|
|
|
|
var secondRpc = 'second'
|
|
|
|
|
|
|
|
configManager.setRpcTarget(firstRpc)
|
|
|
|
var firstResult = configManager.getCurrentRpcAddress()
|
|
|
|
assert.equal(firstResult, firstRpc)
|
|
|
|
|
|
|
|
configManager.setRpcTarget(secondRpc)
|
|
|
|
var secondResult = configManager.getCurrentRpcAddress()
|
|
|
|
assert.equal(secondResult, secondRpc)
|
|
|
|
})
|
|
|
|
})
|
2016-04-18 16:39:35 -07:00
|
|
|
|
|
|
|
describe('transactions', function() {
|
|
|
|
beforeEach(function() {
|
|
|
|
configManager._saveTxList([])
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('#getTxList', function() {
|
|
|
|
it('when new should return empty array', function() {
|
|
|
|
var result = configManager.getTxList()
|
|
|
|
assert.ok(Array.isArray(result))
|
|
|
|
assert.equal(result.length, 0)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('#_saveTxList', function() {
|
|
|
|
it('saves the submitted data to the tx list', function() {
|
|
|
|
var target = [{ foo: 'bar' }]
|
|
|
|
configManager._saveTxList(target)
|
|
|
|
var result = configManager.getTxList()
|
|
|
|
assert.equal(result[0].foo, 'bar')
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('#addTx', function() {
|
|
|
|
it('adds a tx returned in getTxList', function() {
|
|
|
|
var tx = { id: 1 }
|
|
|
|
configManager.addTx(tx)
|
|
|
|
var result = configManager.getTxList()
|
|
|
|
assert.ok(Array.isArray(result))
|
|
|
|
assert.equal(result.length, 1)
|
|
|
|
assert.equal(result[0].id, 1)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('#confirmTx', function() {
|
|
|
|
it('sets the tx status to confirmed', function() {
|
|
|
|
var tx = { id: 1, status: 'unconfirmed' }
|
|
|
|
configManager.addTx(tx)
|
|
|
|
configManager.confirmTx(1)
|
|
|
|
var result = configManager.getTxList()
|
|
|
|
assert.ok(Array.isArray(result))
|
|
|
|
assert.equal(result.length, 1)
|
|
|
|
assert.equal(result[0].status, 'confirmed')
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('#rejectTx', function() {
|
|
|
|
it('sets the tx status to rejected', function() {
|
|
|
|
var tx = { id: 1, status: 'unconfirmed' }
|
|
|
|
configManager.addTx(tx)
|
|
|
|
configManager.rejectTx(1)
|
|
|
|
var result = configManager.getTxList()
|
|
|
|
assert.ok(Array.isArray(result))
|
|
|
|
assert.equal(result.length, 1)
|
|
|
|
assert.equal(result[0].status, 'rejected')
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2016-04-19 17:32:09 -07:00
|
|
|
describe('#updateTx', function() {
|
|
|
|
it('replaces the tx with the same id', function() {
|
|
|
|
configManager.addTx({ id: '1', status: 'unconfirmed' })
|
|
|
|
configManager.addTx({ id: '2', status: 'confirmed' })
|
|
|
|
configManager.updateTx({ id: '1', status: 'blah', hash: 'foo' })
|
|
|
|
var result = configManager.getTx('1')
|
|
|
|
assert.equal(result.hash, 'foo')
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2016-04-18 16:39:35 -07:00
|
|
|
describe('#unconfirmedTxs', function() {
|
|
|
|
it('returns unconfirmed txs in a hash', function() {
|
|
|
|
configManager.addTx({ id: '1', status: 'unconfirmed' })
|
|
|
|
configManager.addTx({ id: '2', status: 'confirmed' })
|
|
|
|
let result = configManager.unconfirmedTxs()
|
|
|
|
assert.equal(typeof result, 'object')
|
|
|
|
assert.equal(result['1'].status, 'unconfirmed')
|
|
|
|
assert.equal(result['0'], undefined)
|
|
|
|
assert.equal(result['2'], undefined)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('#getTx', function() {
|
|
|
|
it('returns a tx with the requested id', function() {
|
|
|
|
configManager.addTx({ id: '1', status: 'unconfirmed' })
|
|
|
|
configManager.addTx({ id: '2', status: 'confirmed' })
|
|
|
|
assert.equal(configManager.getTx('1').status, 'unconfirmed')
|
|
|
|
assert.equal(configManager.getTx('2').status, 'confirmed')
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
Made configuration migrateable
Abstract all configuration data into a singleton called `configManager`, who is responsible for reading and writing to the persisted storage (localStorage, in our case).
Uses my new module [pojo-migrator](https://www.npmjs.com/package/pojo-migrator), and wraps it with the `ConfigManager` class, which we can hang any state setting or getting methods we need.
By keeping all the persisted state in one place, we can stabilize its outward-facing API, making the interactions increasingly atomic, which will allow us to add features that require restructuring the persisted data in the long term without having to rewrite UI or even `background.js` code.
All the restructuring and data-type management is kept in one neat little place.
This should make it very easy to add new configuration options like user-configured providers, per-domain vaults, and more!
I know this doesn't seem like a big user-facing feature, but we have a big laundry list of features that I think this will really help streamline.
2016-03-30 19:15:49 -07:00
|
|
|
})
|
2016-06-24 16:13:27 -07:00
|
|
|
|