49fdd23d58
* Move secureApi to shell
* Extract isTestnet test
* Use mobx + subscriptions for status
* Re-add status indicator
* Add lerna
* Move intial packages to js/packages
* Move 3rdparty/{email,sms}-verification to correct location
* Move package.json & README to library src
* Move tests for library packages
* Move views & dapps to packages
* Move i18n to root
* Move shell to actual src (main app)
* Remove ~ references
* Change ~ to root (explicit imports)
* Finalise convert of ~
* Move views into dapps as well
* Move dapps to packages/
* Fix references
* Update css
* Update test spec locations
* Update tests
* Case fix
* Skip flakey tests
* Update enzyme
* Skip previously ignored tests
* Allow empty api for hw
* Re-add theme for embed
475 lines
16 KiB
JavaScript
475 lines
16 KiB
JavaScript
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity.
|
|
|
|
// Parity is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// Parity is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
import { TEST_HTTP_URL, mockHttp } from '../../../../test/mockRpc';
|
|
import { isBigNumber } from '../../../../test/types';
|
|
|
|
import { Http, PromiseProvider } from '../../provider';
|
|
import Eth from './eth';
|
|
|
|
const instance = new Eth(new PromiseProvider(new Http(TEST_HTTP_URL, -1)));
|
|
|
|
describe('rpc/Eth', () => {
|
|
const address = '0x63Cf90D3f0410092FC0fca41846f596223979195';
|
|
let scope;
|
|
|
|
describe('accounts', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_accounts', reply: { result: [address.toLowerCase()] } }]);
|
|
});
|
|
|
|
it('returns a list of accounts, formatted', () => {
|
|
return instance.accounts().then((accounts) => {
|
|
expect(accounts).to.deep.equal([address]);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('blockNumber', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_blockNumber', reply: { result: '0x123456' } }]);
|
|
});
|
|
|
|
it('returns the current blockNumber, formatted', () => {
|
|
return instance.blockNumber().then((blockNumber) => {
|
|
expect(isBigNumber(blockNumber)).to.be.true;
|
|
expect(blockNumber.toString(16)).to.equal('123456');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('call', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_call', reply: { result: [] } }]);
|
|
});
|
|
|
|
it('formats the input options & blockNumber', () => {
|
|
return instance.call({ data: '12345678' }, 'earliest').then(() => {
|
|
expect(scope.body.eth_call.params).to.deep.equal([{ data: '0x12345678' }, 'earliest']);
|
|
});
|
|
});
|
|
|
|
it('provides a latest blockNumber when not specified', () => {
|
|
return instance.call({ data: '12345678' }).then(() => {
|
|
expect(scope.body.eth_call.params).to.deep.equal([{ data: '0x12345678' }, 'latest']);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('coinbase', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_coinbase', reply: { result: address.toLowerCase() } }]);
|
|
});
|
|
|
|
it('returns the coinbase, formatted', () => {
|
|
return instance.coinbase().then((account) => {
|
|
expect(account).to.deep.equal(address);
|
|
});
|
|
});
|
|
});
|
|
|
|
['LLL', 'Serpent', 'Solidity'].forEach((type) => {
|
|
const method = `compile${type}`;
|
|
|
|
describe(method, () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: `eth_${method}`, reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('formats the input as data, returns the output', () => {
|
|
return instance[method]('0xabcdef').then((result) => {
|
|
expect(scope.body[`eth_${method}`].params).to.deep.equal(['0xabcdef']);
|
|
expect(result).to.equal('0x123');
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('estimateGas', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_estimateGas', reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('converts the options correctly', () => {
|
|
return instance.estimateGas({ gas: 21000 }).then(() => {
|
|
expect(scope.body.eth_estimateGas.params).to.deep.equal([{ gas: '0x5208' }]);
|
|
});
|
|
});
|
|
|
|
it('returns the gas used', () => {
|
|
return instance.estimateGas({}).then((gas) => {
|
|
expect(isBigNumber(gas)).to.be.true;
|
|
expect(gas.toString(16)).to.deep.equal('123');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('gasPrice', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_gasPrice', reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('returns the fomratted price', () => {
|
|
return instance.gasPrice().then((price) => {
|
|
expect(isBigNumber(price)).to.be.true;
|
|
expect(price.toString(16)).to.deep.equal('123');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getBalance', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getBalance', reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('passes in the address (default blockNumber)', () => {
|
|
return instance.getBalance(address).then(() => {
|
|
expect(scope.body.eth_getBalance.params).to.deep.equal([address.toLowerCase(), 'latest']);
|
|
});
|
|
});
|
|
|
|
it('passes in the address & blockNumber', () => {
|
|
return instance.getBalance(address, 0x456).then(() => {
|
|
expect(scope.body.eth_getBalance.params).to.deep.equal([address.toLowerCase(), '0x456']);
|
|
});
|
|
});
|
|
|
|
it('returns the balance', () => {
|
|
return instance.getBalance(address, 0x123).then((balance) => {
|
|
expect(isBigNumber(balance)).to.be.true;
|
|
expect(balance.toString(16)).to.deep.equal('123');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getBlockByHash', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getBlockByHash', reply: { result: { miner: address.toLowerCase() } } }]);
|
|
});
|
|
|
|
it('formats the input hash as a hash, default full', () => {
|
|
return instance.getBlockByHash('1234').then(() => {
|
|
expect(scope.body.eth_getBlockByHash.params).to.deep.equal(['0x1234', false]);
|
|
});
|
|
});
|
|
|
|
it('formats the input hash as a hash, full true', () => {
|
|
return instance.getBlockByHash('1234', true).then(() => {
|
|
expect(scope.body.eth_getBlockByHash.params).to.deep.equal(['0x1234', true]);
|
|
});
|
|
});
|
|
|
|
it('formats the output into block', () => {
|
|
return instance.getBlockByHash('1234').then((block) => {
|
|
expect(block.miner).to.equal(address);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getBlockByNumber', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getBlockByNumber', reply: { result: { miner: address.toLowerCase() } } }]);
|
|
});
|
|
|
|
it('assumes blockNumber latest & full false', () => {
|
|
return instance.getBlockByNumber().then(() => {
|
|
expect(scope.body.eth_getBlockByNumber.params).to.deep.equal(['latest', false]);
|
|
});
|
|
});
|
|
|
|
it('uses input blockNumber & full false', () => {
|
|
return instance.getBlockByNumber('0x1234').then(() => {
|
|
expect(scope.body.eth_getBlockByNumber.params).to.deep.equal(['0x1234', false]);
|
|
});
|
|
});
|
|
|
|
it('formats the input blockNumber, full true', () => {
|
|
return instance.getBlockByNumber(0x1234, true).then(() => {
|
|
expect(scope.body.eth_getBlockByNumber.params).to.deep.equal(['0x1234', true]);
|
|
});
|
|
});
|
|
|
|
it('formats the output into block', () => {
|
|
return instance.getBlockByNumber(0x1234).then((block) => {
|
|
expect(block.miner).to.equal(address);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getBlockTransactionCountByHash', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getBlockTransactionCountByHash', reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('formats input hash properly', () => {
|
|
return instance.getBlockTransactionCountByHash('abcdef').then(() => {
|
|
expect(scope.body.eth_getBlockTransactionCountByHash.params).to.deep.equal(['0xabcdef']);
|
|
});
|
|
});
|
|
|
|
it('formats the output number', () => {
|
|
return instance.getBlockTransactionCountByHash('0x1234').then((count) => {
|
|
expect(isBigNumber(count)).to.be.true;
|
|
expect(count.toString(16)).to.equal('123');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getBlockTransactionCountByNumber', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getBlockTransactionCountByNumber', reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('specified blockNumber latest when none specified', () => {
|
|
return instance.getBlockTransactionCountByNumber().then(() => {
|
|
expect(scope.body.eth_getBlockTransactionCountByNumber.params).to.deep.equal(['latest']);
|
|
});
|
|
});
|
|
|
|
it('formats input blockNumber properly', () => {
|
|
return instance.getBlockTransactionCountByNumber(0xabcdef).then(() => {
|
|
expect(scope.body.eth_getBlockTransactionCountByNumber.params).to.deep.equal(['0xabcdef']);
|
|
});
|
|
});
|
|
|
|
it('formats the output number', () => {
|
|
return instance.getBlockTransactionCountByNumber('0x1234').then((count) => {
|
|
expect(isBigNumber(count)).to.be.true;
|
|
expect(count.toString(16)).to.equal('123');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getCode', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getCode', reply: { result: '0x1234567890' } }]);
|
|
});
|
|
|
|
it('passes in the address (default blockNumber)', () => {
|
|
return instance.getCode(address).then(() => {
|
|
expect(scope.body.eth_getCode.params).to.deep.equal([address.toLowerCase(), 'latest']);
|
|
});
|
|
});
|
|
|
|
it('passes in the address & blockNumber', () => {
|
|
return instance.getCode(address, 0x456).then(() => {
|
|
expect(scope.body.eth_getCode.params).to.deep.equal([address.toLowerCase(), '0x456']);
|
|
});
|
|
});
|
|
|
|
it('returns the code', () => {
|
|
return instance.getCode(address, 0x123).then((code) => {
|
|
expect(code).to.equal('0x1234567890');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getStorageAt', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getStorageAt', reply: { result: '0x1234567890' } }]);
|
|
});
|
|
|
|
it('passes in the address (default index& blockNumber)', () => {
|
|
return instance.getStorageAt(address).then(() => {
|
|
expect(scope.body.eth_getStorageAt.params).to.deep.equal([address.toLowerCase(), '0x0', 'latest']);
|
|
});
|
|
});
|
|
|
|
it('passes in the address, index & blockNumber', () => {
|
|
return instance.getStorageAt(address, 15, 0x456).then(() => {
|
|
expect(scope.body.eth_getStorageAt.params).to.deep.equal([address.toLowerCase(), '0xf', '0x456']);
|
|
});
|
|
});
|
|
|
|
it('returns the storage', () => {
|
|
return instance.getStorageAt(address, 0x123).then((storage) => {
|
|
expect(storage).to.equal('0x1234567890');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getTransactionByBlockHashAndIndex', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getTransactionByBlockHashAndIndex', reply: { result: { to: address.toLowerCase() } } }]);
|
|
});
|
|
|
|
it('passes in the hash (default index)', () => {
|
|
return instance.getTransactionByBlockHashAndIndex('12345').then(() => {
|
|
expect(scope.body.eth_getTransactionByBlockHashAndIndex.params).to.deep.equal(['0x12345', '0x0']);
|
|
});
|
|
});
|
|
|
|
it('passes in the hash & specified index', () => {
|
|
return instance.getTransactionByBlockHashAndIndex('6789', 0x456).then(() => {
|
|
expect(scope.body.eth_getTransactionByBlockHashAndIndex.params).to.deep.equal(['0x6789', '0x456']);
|
|
});
|
|
});
|
|
|
|
it('returns the formatted transaction', () => {
|
|
return instance.getTransactionByBlockHashAndIndex('6789', 0x123).then((tx) => {
|
|
expect(tx).to.deep.equal({ to: address });
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getTransactionByBlockNumberAndIndex', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getTransactionByBlockNumberAndIndex', reply: { result: { to: address.toLowerCase() } } }]);
|
|
});
|
|
|
|
it('passes in the default parameters', () => {
|
|
return instance.getTransactionByBlockNumberAndIndex().then(() => {
|
|
expect(scope.body.eth_getTransactionByBlockNumberAndIndex.params).to.deep.equal(['latest', '0x0']);
|
|
});
|
|
});
|
|
|
|
it('passes in the blockNumber & specified index', () => {
|
|
return instance.getTransactionByBlockNumberAndIndex('0x6789', 0x456).then(() => {
|
|
expect(scope.body.eth_getTransactionByBlockNumberAndIndex.params).to.deep.equal(['0x6789', '0x456']);
|
|
});
|
|
});
|
|
|
|
it('returns the formatted transaction', () => {
|
|
return instance.getTransactionByBlockNumberAndIndex('0x6789', 0x123).then((tx) => {
|
|
expect(tx).to.deep.equal({ to: address });
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getTransactionByHash', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getTransactionByHash', reply: { result: { to: address.toLowerCase() } } }]);
|
|
});
|
|
|
|
it('passes in the hash', () => {
|
|
return instance.getTransactionByHash('12345').then(() => {
|
|
expect(scope.body.eth_getTransactionByHash.params).to.deep.equal(['0x12345']);
|
|
});
|
|
});
|
|
|
|
it('returns the formatted transaction', () => {
|
|
return instance.getTransactionByHash('6789').then((tx) => {
|
|
expect(tx).to.deep.equal({ to: address });
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getTransactionCount', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getTransactionCount', reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('passes in the address (default blockNumber)', () => {
|
|
return instance.getTransactionCount(address).then(() => {
|
|
expect(scope.body.eth_getTransactionCount.params).to.deep.equal([address.toLowerCase(), 'latest']);
|
|
});
|
|
});
|
|
|
|
it('passes in the address & blockNumber', () => {
|
|
return instance.getTransactionCount(address, 0x456).then(() => {
|
|
expect(scope.body.eth_getTransactionCount.params).to.deep.equal([address.toLowerCase(), '0x456']);
|
|
});
|
|
});
|
|
|
|
it('returns the count, formatted', () => {
|
|
return instance.getTransactionCount(address, 0x123).then((count) => {
|
|
expect(isBigNumber(count)).to.be.true;
|
|
expect(count.toString(16)).to.equal('123');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getUncleByBlockHashAndIndex', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getUncleByBlockHashAndIndex', reply: { result: [] } }]);
|
|
});
|
|
|
|
it('passes in the hash (default index)', () => {
|
|
return instance.getUncleByBlockHashAndIndex('12345').then(() => {
|
|
expect(scope.body.eth_getUncleByBlockHashAndIndex.params).to.deep.equal(['0x12345', '0x0']);
|
|
});
|
|
});
|
|
|
|
it('passes in the hash & specified index', () => {
|
|
return instance.getUncleByBlockHashAndIndex('6789', 0x456).then(() => {
|
|
expect(scope.body.eth_getUncleByBlockHashAndIndex.params).to.deep.equal(['0x6789', '0x456']);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getUncleByBlockNumberAndIndex', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getUncleByBlockNumberAndIndex', reply: { result: [] } }]);
|
|
});
|
|
|
|
it('passes in the default parameters', () => {
|
|
return instance.getUncleByBlockNumberAndIndex().then(() => {
|
|
expect(scope.body.eth_getUncleByBlockNumberAndIndex.params).to.deep.equal(['latest', '0x0']);
|
|
});
|
|
});
|
|
|
|
it('passes in the blockNumber & specified index', () => {
|
|
return instance.getUncleByBlockNumberAndIndex('0x6789', 0x456).then(() => {
|
|
expect(scope.body.eth_getUncleByBlockNumberAndIndex.params).to.deep.equal(['0x6789', '0x456']);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getUncleCountByBlockHash', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getUncleCountByBlockHash', reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('passes in the hash', () => {
|
|
return instance.getUncleCountByBlockHash('12345').then(() => {
|
|
expect(scope.body.eth_getUncleCountByBlockHash.params).to.deep.equal(['0x12345']);
|
|
});
|
|
});
|
|
|
|
it('formats the output number', () => {
|
|
return instance.getUncleCountByBlockHash('0x1234').then((count) => {
|
|
expect(isBigNumber(count)).to.be.true;
|
|
expect(count.toString(16)).to.equal('123');
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getUncleCountByBlockNumber', () => {
|
|
beforeEach(() => {
|
|
scope = mockHttp([{ method: 'eth_getUncleCountByBlockNumber', reply: { result: '0x123' } }]);
|
|
});
|
|
|
|
it('passes in the default parameters', () => {
|
|
return instance.getUncleCountByBlockNumber().then(() => {
|
|
expect(scope.body.eth_getUncleCountByBlockNumber.params).to.deep.equal(['latest']);
|
|
});
|
|
});
|
|
|
|
it('passes in the blockNumber', () => {
|
|
return instance.getUncleCountByBlockNumber('0x6789').then(() => {
|
|
expect(scope.body.eth_getUncleCountByBlockNumber.params).to.deep.equal(['0x6789']);
|
|
});
|
|
});
|
|
|
|
it('formats the output number', () => {
|
|
return instance.getUncleCountByBlockNumber('0x1234').then((count) => {
|
|
expect(isBigNumber(count)).to.be.true;
|
|
expect(count.toString(16)).to.equal('123');
|
|
});
|
|
});
|
|
});
|
|
});
|