cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Squashed 'libjsqrc/ethereumjs/' changes from eceeda7..73b9ed2

Browse Source 
73b9ed2 rename to web3
c80ede5 fixed spelling in package description
67f0a75 version 0.2.4
e2990ae web3.eth.getBlockTransactionCount accepts pending/latest/earliest params
94429ff version 0.2.3
f9a5206 more tests for web3.eth.getBalance
31e046d Merge branch 'master' into develop
5e15037 fixed formatting address
b7a03cd version 0.2.2
2536888 let travis check if npm package is not broken
92aba81 merge master, gulp
e6a76ff Merge branch 'master' into develop
57d9f1f removed deprecated && unused lines from contract.js
5885bfe test for #128
e53f316 tests for transaction && call
31220d5 removed deprecated code in contract.js
b837667 unified asBlock from filter.js with blockNumber formatter
202a8cd #140 badge
608d211 blockNumber can be earliest
f0216fb fixed #149
e213551 tests for #144
21791f2 version 0.2.1
2262276 defaultBlockNumber accepts latest && pending
e01bb23 fixed #148 && fixed polling test
8c39acc merge branch 'develop' of https://github.com/ethereum/ethereum.js into develop
534e96d Merge branch 'master' of https://github.com/ethereum/ethereum.js
2f45df8 fix && tests for #147
e750fd9 fixed #147
e0d83d0 removed unecessary callformatter
9fc5575 version 0.2.0
2747f4c Merge pull request #137 from ethereum/sandbox
ed2b62d add whisper, network and ethereum version
aa9fc92 add whisper, network and ethereum version
f4e5a99 default log formatter, improved contract test
e9b5da4 updated package.js name to web3
8caf64a update package.json
07bcdb4 improved tests for contract.js, fixed few minor issues
1986c7f cleaned up web3.js
82b18c1 refactored filter.js
2133d27 filter changes in progress
0dbd68c Merge branch 'develop' into sandbox
17164be default toBlock && fromBlock is not null
e928e14 Merge branch 'develop' into sandbox
1a84015 fixed events topics
0beb01f test for creating signatures
a63d604 removed unused function
9d5b602 test names
a1ec149 renamed few more tests
cbf8ea1 test naming convention
04f0aa5 fixed filer.js complexity
722a5bc fixed eth.getTransaction.js location
c065f17 Merge branch 'develop' into sandbox
b78dffa small fix in filter tests
91baec2 polling tests
4f5c5fb first try to test polling
f2c8a14 removed duplicate code
9f073d9 applied fixes from cpp-ethereum
c01abfc add db tests
b247c49 add sha3 test
afd7e7b add shh tests
e7304b5 add storage tests
f32b8ad add runTest module to new tests
c52250e add block uncle and block counts
c1f5ab2 test.method.js in helpers
7df9099 moved test.utils to helpers
a4e3645 Merge branch 'develop' into sandbox
b3b95c5 add getBlock test
abe064f add Property and passing through of RPC erro texts
0b84376 fix for otto
36fe79f another fix for otto
be04c47 fixes for go otto env
c7e5d0a light browser bundle
4b37137 light browser bundle without bignumber.js
f13a727 add accounts test
b915ceb add defaultBlock back
b074a5e add check for providor async function
ae76428 Merge branch 'master' into develop
a34321d removed double FakeHTTPProvidor
7fb4405 add missing formatters, fixed tests
7511e4c fake providers moved to helpers directory
b16982b fix for polling
126b40c fixed registering coverage on providers
2924e00 fix for toHex transforming boolean
b6b809c setting up formatters for eth
99ea9cd fixed for defaultBlock formatter
33a3fc7 generic integration tests
4d1cf0b inputFormatter is an aray of functions
6b07920 add uninstall filter back
89b1ca6 first integration tests
a4cf661 tests for method.js
7519fab method.js
9423b72 Merge pull request #139 from gitter-badger/gitter-badge
24a03e0 Added Gitter badge
0898669 changes in input formatters
748cda2 requestmanager tests
476023e requestmanager refactored
e3faebe jsonrpc is an object
cbab0ae common changes in requestmanager
d408fb0 comments in requestmanager
5c1e85f requestmanager refactor in progress
f604670 tests for qtsyncprovider.js
288caf3 node-sandbox, tests for httpprovider, request manager refactor in progress
8c36a10 rename getData to getCode
de5de9e Merge branch 'develop' of https://github.com/ethereum/ethereum.js into develop
5cdea25 Merge branch 'getCode' of https://github.com/jorisbontje/ethereum.js into getCode
3550f91 Merge pull request #122 from frozeman/apiOverhaul
fb99d10 fixed meteor package
99795e3 expose bignumber.js
db7092b Merge pull request #117 from ethereum/bundle_name
5bee7be changed bundle name web3 -> ethereum.js
7ca3b40 gulp
517eff9 Merge pull request #120 from dchambers/make-browserify-compatibile
b032429 rename getData to getCode
768d4bf Make changes to 'gulpfile.js' reccomended by @debris.
0267e85 Use browserify's 'browser' field instead of 'envify' & 'unreachable-branch-transform to', plus always include 'bignumber.js' since it is needed in the browser.
cb7c209 removed unused property
12aed56 fixed #111

git-subtree-dir: libjsqrc/ethereumjs
git-subtree-split: 73b9ed29c09531817df311c2d050dec6667197e7
This commit is contained in:
Marek Kotewicz 2015-04-07 04:50:10 +02:00
parent 60162d919b
commit 3e4a9de0b0
80 changed files with 2127 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
abi.inputParser.js
View File

@ -19,7 +19,7 @@ var description = [{
]
}];
describe('abi', function() {
describe('lib/solidity/abi', function() {
describe('inputParser', function() {
it('should parse input uint', function() {

2
abi.outputParser.js
View File

@ -19,7 +19,7 @@ var description = [{
]
}];
describe('abi', function() {
describe('lib/solidity/abi', function() {
describe('outputParser', function() {
it('should parse output fixed bytes type', function() {

229
contract.js Normal file
View File

@ -0,0 +1,229 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var utils = require('../lib/utils/utils');
var desc = [{
"name": "balance(address)",
"type": "function",
"inputs": [{
"name": "who",
"type": "address"
}],
"constant": true,
"outputs": [{
"name": "value",
"type": "uint256"
}]
}, {
"name": "send(address,uint256)",
"type": "function",
"inputs": [{
"name": "to",
"type": "address"
}, {
"name": "value",
"type": "uint256"
}],
"outputs": []
}, {
"name":"Changed",
"type":"event",
"inputs": [
{"name":"from","type":"address","indexed":true},
{"name":"amount","type":"uint256","indexed":true},
{"name":"t1","type":"uint256","indexed":false},
{"name":"t2","type":"uint256","indexed":false}
],
}];
var address = '0x1234567890123456789012345678901234567890';
describe('web3.eth.contract', function () {
describe('event', function () {
it('should create event filter', function (done) {
var provider = new FakeHttpProvider();
web3.setProvider(provider);
web3.reset(); // reset different polls
var sha3 = '0x5131231231231231231231';
provider.injectResult(sha3);
var step = 0;
provider.injectValidation(function (payload) {
if (step === 0) {
step = 1;
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, 'web3_sha3');
assert.equal(payload.params[0], web3.fromAscii('Changed(address,uint256,uint256,uint256)'));
} else if (step === 1) {
step = 2;
provider.injectResult(3);
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, 'eth_newFilter');
assert.deepEqual(payload.params[0], {
topics: [
sha3,
'0x1234567890123456789012345678901234567890'
],
address: '0x1234567890123456789012345678901234567890'
});
} else if (step === 2 && utils.isArray(payload)) {
provider.injectBatchResults([[{
address: address,
topics: [
sha3,
'0x0000000000000000000000001234567890123456789012345678901234567890',
'0x0000000000000000000000000000000000000000000000000000000000000001'
],
number: 2,
data: '0x0000000000000000000000000000000000000000000000000000000000000001' +
'0000000000000000000000000000000000000000000000000000000000000008'
}]]);
var r = payload.filter(function (p) {
return p.jsonrpc === '2.0' && p.method === 'eth_getFilterChanges' && p.params[0] === 3;
});
assert.equal(r.length > 0, true);
}
});
var Contract = web3.eth.contract(desc);
var contract = new Contract(address);
contract.Changed({from: address}).watch(function(err, result) {
assert.equal(result.args.from, address);
assert.equal(result.args.amount, 1);
assert.equal(result.args.t1, 1);
assert.equal(result.args.t2, 8);
done();
});
});
it('should call constant function', function () {
var provider = new FakeHttpProvider();
web3.setProvider(provider);
web3.reset();
var sha3 = '0x5131231231231231231231';
var address = '0x1234567890123456789012345678901234567890';
provider.injectResult(sha3);
var step = 0;
provider.injectValidation(function (payload) {
if (step === 0) {
step = 1;
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, 'web3_sha3');
assert.equal(payload.params[0], web3.fromAscii('balance(address)'));
} else if (step === 1) {
assert.equal(payload.method, 'eth_call');
assert.deepEqual(payload.params, [{
data: sha3.slice(0, 10) + '0000000000000000000000001234567890123456789012345678901234567890',
to: address
}, 'latest']);
}
});
var Contract = web3.eth.contract(desc);
var contract = new Contract(address);
contract.balance(address);
});
it('should sendTransaction to contract function', function () {
var provider = new FakeHttpProvider();
web3.setProvider(provider);
web3.reset();
var sha3 = '0x5131231231231231231231';
var address = '0x1234567890123456789012345678901234567890';
provider.injectResult(sha3);
var step = 0;
provider.injectValidation(function (payload) {
if (step === 0) {
step = 1;
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, 'web3_sha3');
assert.equal(payload.params[0], web3.fromAscii('send(address,uint256)'));
} else if (step === 1) {
assert.equal(payload.method, 'eth_sendTransaction');
assert.deepEqual(payload.params, [{
data: sha3.slice(0, 10) +
'0000000000000000000000001234567890123456789012345678901234567890' +
'0000000000000000000000000000000000000000000000000000000000000011' ,
to: address
}]);
}
});
var Contract = web3.eth.contract(desc);
var contract = new Contract(address);
contract.send(address, 17);
});
it('should make a call with optional params', function () {
var provider = new FakeHttpProvider();
web3.setProvider(provider);
web3.reset();
var sha3 = '0x5131231231231231231231';
var address = '0x1234567890123456789012345678901234567890';
provider.injectResult(sha3);
var step = 0;
provider.injectValidation(function (payload) {
if (step === 0) {
step = 1;
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, 'web3_sha3');
assert.equal(payload.params[0], web3.fromAscii('balance(address)'));
} else if (step === 1) {
assert.equal(payload.method, 'eth_call');
assert.deepEqual(payload.params, [{
data: sha3.slice(0, 10) + '0000000000000000000000001234567890123456789012345678901234567890',
to: address,
from: address,
gas: '0xc350'
}, 'latest']);
}
});
var Contract = web3.eth.contract(desc);
var contract = new Contract(address);
contract.call({from: address, gas: 50000}).balance(address);
});
it('should sendTransaction with optional params', function () {
var provider = new FakeHttpProvider();
web3.setProvider(provider);
web3.reset();
var sha3 = '0x5131231231231231231231';
var address = '0x1234567890123456789012345678901234567890';
provider.injectResult(sha3);
var step = 0;
provider.injectValidation(function (payload) {
if (step === 0) {
step = 1;
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, 'web3_sha3');
assert.equal(payload.params[0], web3.fromAscii('send(address,uint256)'));
} else if (step === 1) {
assert.equal(payload.method, 'eth_sendTransaction');
assert.deepEqual(payload.params, [{
data: sha3.slice(0, 10) +
'0000000000000000000000001234567890123456789012345678901234567890' +
'0000000000000000000000000000000000000000000000000000000000000011' ,
to: address,
from: address,
gas: '0xc350',
gasPrice: '0xbb8',
value: '0x2710'
}]);
}
});
var Contract = web3.eth.contract(desc);
var contract = new Contract(address);
contract.sendTransaction({from: address, gas: 50000, gasPrice: 3000, value: 10000}).send(address, 17);
});
});
});

26
event.inputParser.js
View File

@ -2,7 +2,7 @@ var assert = require('assert');
var event = require('../lib/web3/event.js');
var f = require('../lib/solidity/formatters.js');
describe('event', function () {
describe('lib/web3/event', function () {
describe('inputParser', function () {
it('should create basic filter input object', function () {
@ -33,8 +33,6 @@ describe('event', function () {
var options = {
fromBlock: 1,
toBlock: 2,
offset: 3,
limit: 4
};
var e = {
name: 'Event',
@ -51,8 +49,6 @@ describe('event', function () {
assert.equal(result.topics[0], signature);
assert.equal(result.fromBlock, options.fromBlock);
assert.equal(result.toBlock, options.toBlock);
assert.equal(result.offset, options.offset);
assert.equal(result.limit, options.limit);
});
@ -63,9 +59,7 @@ describe('event', function () {
var signature = '0x987654';
var options = {
fromBlock: 1,
toBlock: 2,
offset: 3,
limit: 4
toBlock: 2
};
var e = {
name: 'Event',
@ -80,11 +74,9 @@ describe('event', function () {
assert.equal(result.address, address);
assert.equal(result.topics.length, 2);
assert.equal(result.topics[0], signature);
assert.equal(result.topics[1], f.formatInputInt(4));
assert.equal(result.topics[1], '0x' + f.formatInputInt(4));
assert.equal(result.fromBlock, options.fromBlock);
assert.equal(result.toBlock, options.toBlock);
assert.equal(result.offset, options.offset);
assert.equal(result.limit, options.limit);
});
@ -94,10 +86,8 @@ describe('event', function () {
var address = '0x012345';
var signature = '0x987654';
var options = {
earliest: 1,
latest: 2,
offset: 3,
max: 4
fromBlock: 1,
toBlock: 2,
};
var e = {
name: 'Event',
@ -114,10 +104,8 @@ describe('event', function () {
assert.equal(result.topics[0], signature);
assert.equal(result.topics[1][0], f.formatInputInt(4));
assert.equal(result.topics[1][1], f.formatInputInt(69));
assert.equal(result.earliest, options.earliest);
assert.equal(result.latest, options.latest);
assert.equal(result.offset, options.offset);
assert.equal(result.max, options.max);
assert.equal(result.fromBlock, options.fromBlock);
assert.equal(result.toBlock, options.toBlock);
});
});

6
event.outputParser.js
View File

@ -1,7 +1,7 @@
var assert = require('assert');
var event = require('../lib/web3/event.js');
describe('event', function () {
describe('lib/web3/event', function () {
describe('outputParser', function () {
it('should parse basic event output object', function () {
@ -10,7 +10,7 @@ describe('event', function () {
"address":"0x78dfc5983baecf65f73e3de3a96cee24e6b7981e",
"data":"0x000000000000000000000000000000000000000000000000000000000000004b",
"number":2,
"topic":[
"topics":[
"0x6e61ef44ac2747ff8b84d353a908eb8bd5c3fb118334d57698c5cfc7041196ad",
"0x0000000000000000000000000000000000000000000000000000000000000001"
]
@ -43,7 +43,7 @@ describe('event', function () {
"000000000000000000000000000000000000000000000000000000000000004c" +
"0000000000000000000000000000000000000000000000000000000000000001",
"number":3,
"topic":[
"topics":[
"0x6e61ef44ac2747ff8b84d353a908eb8bd5c3fb118334d57698c5cfc7041196ad",
"0x0000000000000000000000000000000000000000000000000000000000000001",
"0x0000000000000000000000000000000000000000000000000000000000000005"

24
filter.methods.js
View File

@ -1,24 +0,0 @@
var assert = require('assert');
var filter = require('../lib/web3/filter');
var u = require('./test.utils.js');
var empty = function () {};
var implementation = {
newFilter: empty,
getLogs: empty,
uninstallFilter: empty,
startPolling: empty,
stopPolling: empty,
};
describe('web3', function () {
describe('eth', function () {
describe('filter', function () {
var f = filter({}, implementation);
u.methodExists(f, 'watch');
u.methodExists(f, 'stopWatching');
u.methodExists(f, 'get');
});
});
});

24
formatters.inputDefaultBlockFormatter.js Normal file
View File

@ -0,0 +1,24 @@
var chai = require('chai');
var assert = chai.assert;
var formatters = require('../lib/web3/formatters');
var tests = [
{ value: 'latest', expected: 'latest' },
{ value: 'pending', expected: 'pending' },
{ value: 'earliest', expected: 'earliest' },
{ value: 1, expected: '0x1' },
{ value: '0x1', expected: '0x1' }
];
describe('lib/web3/formatters', function () {
describe('inputDefaultBlockNumberFormatter', function () {
tests.forEach(function (test) {
it('should turn ' + test.value + ' to ' + test.expected, function () {
assert.strictEqual(formatters.inputDefaultBlockNumberFormatter(test.value), test.expected);
});
});
});
});

3
formatters.inputPostFormatter.js
View File

@ -1,6 +1,6 @@
var chai = require('chai');
var formatters = require('../lib/web3/formatters.js');
var assert = chai.assert;
var formatters = require('../lib/web3/formatters.js');
describe('formatters', function () {
describe('inputPostFormatter', function () {
@ -26,3 +26,4 @@ describe('formatters', function () {
});
});
});

11
formatters.inputTransactionFormatter.js
View File

@ -1,4 +1,5 @@
var assert = require('assert');
var chai = require('chai');
var assert = chai.assert;
var formatters = require('../lib/web3/formatters.js');
var BigNumber = require('bignumber.js');
@ -7,19 +8,19 @@ describe('formatters', function () {
it('should return the correct value', function () {
assert.deepEqual(formatters.inputTransactionFormatter({
data: '0x34234kjh23kj4234',
data: '0x34234bf23bf4234',
value: new BigNumber(100),
from: '0x00000',
to: '0x00000',
gas: 1000,
gasPrice: new BigNumber(1000),
gasPrice: new BigNumber(1000)
}), {
data: '0x34234kjh23kj4234',
data: '0x34234bf23bf4234',
value: '0x64',
from: '0x00000',
to: '0x00000',
gas: '0x3e8',
gasPrice: '0x3e8',
gasPrice: '0x3e8'
});
});
});

8
formatters.outputTransactionFormatter.js
View File

@ -12,7 +12,10 @@ describe('formatters', function () {
to: '0x00000',
value: '0x3e8',
gas: '0x3e8',
gasPrice: '0x3e8'
gasPrice: '0x3e8',
transactionIndex: '0x1',
blockNumber: '0x3e8',
blockHash: '0x34234bf23bf4234'
}), {
input: '0x34234kjh23kj4234',
from: '0x00000',
@ -20,6 +23,9 @@ describe('formatters', function () {
value: new BigNumber(1000),
gas: 1000,
gasPrice: new BigNumber(1000),
blockNumber: 1000,
blockHash: '0x34234bf23bf4234',
transactionIndex: 1
});
});
});

68
helpers/FakeHttpProvider.js Normal file
View File

@ -0,0 +1,68 @@
var chai = require('chai');
var assert = require('assert');
var utils = require('../../lib/utils/utils');
var getResponseStub = function () {
return {
jsonrpc: '2.0',
id: 1,
result: 0
};
};
var FakeHttpProvider = function () {
this.response = getResponseStub();
this.error = null;
this.validation = null;
};
FakeHttpProvider.prototype.send = function (payload) {
assert.equal(utils.isArray(payload) || utils.isObject(payload), true);
// TODO: validate jsonrpc request
if (this.error) {
throw this.error;
}
if (this.validation) {
// imitate plain json object
this.validation(JSON.parse(JSON.stringify(payload)));
}
return this.response;
};
FakeHttpProvider.prototype.sendAsync = function (payload, callback) {
assert.equal(utils.isArray(payload) || utils.isObject(payload), true);
assert.equal(utils.isFunction(callback), true);
if (this.validation) {
// imitate plain json object
this.validation(JSON.parse(JSON.stringify(payload)), callback);
}
callback(this.error, this.response);
};
FakeHttpProvider.prototype.injectResponse = function (response) {
this.response = response;
};
FakeHttpProvider.prototype.injectResult = function (result) {
this.response = getResponseStub();
this.response.result = result;
};
FakeHttpProvider.prototype.injectBatchResults = function (results) {
this.response = results.map(function (r) {
var response = getResponseStub();
response.result = r;
return response;
});
};
FakeHttpProvider.prototype.injectError = function (error) {
this.error = error;
};
FakeHttpProvider.prototype.injectValidation = function (callback) {
this.validation = callback;
};
module.exports = FakeHttpProvider;

11
helpers/FakeQtNavigator.js Normal file
View File

@ -0,0 +1,11 @@
var navigator = {
qt: {
callMethod: function (payload) {
return "{}";
}
}
};
module.exports = navigator;

31
helpers/FakeXMLHttpRequest.js Normal file
View File

@ -0,0 +1,31 @@
var chai = require('chai');
var assert = chai.assert;
var FakeXMLHttpRequest = function () {
this.responseText = "{}";
this.readyState = 4;
this.onreadystatechange = null;
this.async = false;
};
FakeXMLHttpRequest.prototype.open = function (method, host, async) {
assert.equal(method, 'POST');
assert.notEqual(host, null);
assert.equal(async === false || async === true, true);
this.async = async;
};
FakeXMLHttpRequest.prototype.send = function (payload) {
assert.equal(typeof payload, 'string');
if (this.async) {
assert.equal(typeof this.onreadystatechange, 'function');
this.onreadystatechange();
return;
}
return this.responseText;
};
module.exports = {
XMLHttpRequest: FakeXMLHttpRequest
};

68
helpers/test.method.js Normal file
View File

@ -0,0 +1,68 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../../index');
var FakeHttpProvider = require('./FakeHttpProvider');
var runTests = function (obj, method, tests) {
var testName = obj ? 'web3.' + obj : 'web';
describe(testName, function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('sync test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, test.formattedArgs);
});
// when
var result = (obj)
? web3[obj][method].apply(null, test.args.slice(0))
: web3[method].apply(null, test.args.slice(0));
// then
assert.deepEqual(test.formattedResult, result);
});
it('async test: ' + index, function (done) {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, test.formattedArgs);
});
var args = test.args.slice(0);
// add callback
args.push(function (err, result) {
assert.deepEqual(test.formattedResult, result);
done();
});
// when
if(obj)
web3[obj][method].apply(null, args);
else
web3[method].apply(null, args);
});
});
});
});
};
module.exports = {
runTests: runTests
}

9
test.utils.js → helpers/test.utils.js
View File

@ -1,13 +1,20 @@
var assert = require('assert');
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../../index');
var FakeHttpProvider = require('./FakeHttpProvider');
var methodExists = function (object, method) {
it('should have method ' + method + ' implemented', function() {
web3.setProvider(null);
assert.equal('function', typeof object[method], 'method ' + method + ' is not implemented');
});
};
var propertyExists = function (object, property) {
it('should have property ' + property + ' implemented', function() {
// set dummy providor, to prevent error
web3.setProvider(new FakeHttpProvider());
assert.notEqual('undefined', typeof object[property], 'property ' + property + ' is not implemented');
});
};

33
httpprovider.js Normal file
View File

@ -0,0 +1,33 @@
var chai = require('chai');
var assert = chai.assert;
var SandboxedModule = require('sandboxed-module');
SandboxedModule.registerBuiltInSourceTransformer('istanbul');
var HttpProvider = SandboxedModule.require('../lib/web3/httpprovider', {
requires: {
'xmlhttprequest': require('./helpers/FakeXMLHttpRequest')
}
});
describe('lib/web3/httpprovider', function () {
describe('send', function () {
it('should send basic request', function () {
var provider = new HttpProvider();
var result = provider.send({});
assert.equal(typeof result, 'object');
});
});
describe('sendAsync', function () {
it('should send basic async request', function (done) {
var provider = new HttpProvider();
provider.sendAsync({}, function (err, result) {
assert.equal(typeof result, 'object');
done();
});
});
});
});

23
jsonrpc.id.js Normal file
View File

@ -0,0 +1,23 @@
var chai = require('chai');
var assert = chai.assert;
var Jsonrpc = require('../lib/web3/jsonrpc');
describe('lib/web3/jsonrpc', function () {
describe('id', function () {
it('should increment the id', function () {
// given
var a = Jsonrpc.getInstance();
var b = Jsonrpc.getInstance();
var method = 'm';
// when
var p1 = a.toPayload(method);
var p2 = b.toPayload(method);
// then
assert.equal(p2.id, p1.id + 1);
});
});
});

1
jsonrpc.isValidResponse.js
View File

@ -1,5 +1,6 @@
var assert = require('assert');
var jsonrpc = require('../lib/web3/jsonrpc');
jsonrpc = new jsonrpc();
describe('jsonrpc', function () {
describe('isValidResponse', function () {

1
jsonrpc.toBatchPayload.js
View File

@ -1,5 +1,6 @@
var assert = require('assert');
var jsonrpc = require('../lib/web3/jsonrpc');
jsonrpc = new jsonrpc();
describe('jsonrpc', function () {
describe('toBatchPayload', function () {

4
jsonrpc.toPayload.js
View File

@ -1,5 +1,7 @@
var assert = require('assert');
var chai = require('chai');
var assert = chai.assert;
var jsonrpc = require('../lib/web3/jsonrpc');
jsonrpc = new jsonrpc();
describe('jsonrpc', function () {
describe('toPayload', function () {

44
method.attachToObject.js Normal file
View File

@ -0,0 +1,44 @@
var chai = require('chai');
var assert = chai.assert;
var Method = require('../lib/web3/method');
var utils = require('../lib/utils/utils');
describe('lib/web3/method', function () {
describe('attachToObject', function () {
//it('attach simple function to an object', function () {
//// given
//var method = new Method({
//name: 'hello'
//});
//var object = {};
//var func = function () { return 1; };
//// when
//method.attachToObject(object, func);
//// then
//assert.equal(utils.isFunction(object.hello), true);
//assert.equal(object.hello(), 1);
//});
//it('attach nested function to an object', function () {
//// given
//var method = new Method({
//name: 'hello.world'
//});
//var object = {};
//var func = function () { return 1; };
//// when
//method.attachToObject(object, func);
//// then
//assert.equal(utils.isObject(object.hello), true);
//assert.equal(utils.isFunction(object.hello.world), true);
//assert.equal(object.hello.world(), 1);
//});
});
});

52
method.extractCallback.js Normal file
View File

@ -0,0 +1,52 @@
var chai = require('chai');
var assert = chai.assert;
var Method = require('../lib/web3/method');
describe('lib/web3/method', function () {
describe('extractCallback', function () {
it('should extract callback', function () {
// given
var method = new Method({});
var callback = function () { };
var args = [1, callback]
// when
var result = method.extractCallback(args);
// then
assert.equal(args.length, 1);
assert.equal(callback, result);
});
it('should extract callback created using newFunction', function () {
// given
var method = new Method({});
var callback = new Function ();
var args = [1, callback]
// when
var result = method.extractCallback(args);
// then
assert.equal(args.length, 1);
assert.equal(callback, result);
});
it('should not extract the callback', function () {
// given
var method = new Method({});
var args = [1, 2]
// when
var result = method.extractCallback(args);
// then
assert.equal(args.length, 2);
assert.equal(result, null);
});
});
});

41
method.formatInput.js Normal file
View File

@ -0,0 +1,41 @@
var chai = require('chai');
var assert = chai.assert;
var Method = require('../lib/web3/method');
describe('lib/web3/method', function () {
describe('formatInput', function () {
it('should format plain input', function () {
// given
var star = function (arg) {
return arg + '*';
};
var method = new Method({
inputFormatter: [star, star, star]
});
var args = ['1','2','3'];
var expectedArgs = ['1*', '2*', '3*'];
// when
var result = method.formatInput(args);
// then
assert.deepEqual(result, expectedArgs);
});
it('should do nothing if there is no formatter', function () {
// given
var method = new Method({});
var args = [1,2,3];
// when
var result = method.formatInput(args);
// then
assert.deepEqual(result, args);
});
});
});

43
method.formatOutput.js Normal file
View File

@ -0,0 +1,43 @@
var chai = require('chai');
var assert = chai.assert;
var Method = require('../lib/web3/method');
describe('lib/web3/method', function () {
describe('formatOutput', function () {
it('should format plain output', function () {
// given
var formatter = function (args) {
return args.map(function (arg) {
return arg + '*';
});
};
var method = new Method({
outputFormatter: formatter
});
var args = ['1','2','3'];
var expectedArgs = ['1*', '2*', '3*'];
// when
var result = method.formatOutput(args);
// then
assert.deepEqual(result, expectedArgs);
});
it('should do nothing if there is no formatter', function () {
// given
var method = new Method({});
var args = [1,2,3];
// when
var result = method.formatOutput(args);
// then
assert.deepEqual(result, args);
});
});
});

46
method.getCall.js Normal file
View File

@ -0,0 +1,46 @@
var chai = require('chai');
var assert = chai.assert;
var Method = require('../lib/web3/method');
describe('lib/web3/method', function () {
describe('getCall', function () {
it('should return call name', function () {
// given
var call = 'hello_call_world';
var method = new Method({
call: call
});
// when
var result = method.getCall();
// then
assert.equal(call, result);
});
it('should return call based on args', function () {
// given
var call = function (args) {
return args ? args.length.toString() : '0';
};
var method = new Method({
call: call
});
// when
var r0 = method.getCall();
var r1 = method.getCall([1]);
var r2 = method.getCall([1, 2]);
// then
assert.equal(r0, '0');
assert.equal(r1, '1');
assert.equal(r2, '2');
});
});
});

47
method.validateArgs.js Normal file
View File

@ -0,0 +1,47 @@
var chai = require('chai');
var assert = chai.assert;
var Method = require('../lib/web3/method');
var errors = require('../lib/web3/errors');
describe('lib/web3/method', function () {
describe('validateArgs', function () {
it('should pass', function () {
// given
var method = new Method({
params: 1
});
var args = [1];
var args2 = ['heloas'];
// when
var test = function () { method.validateArgs(args); };
var test2 = function () { method.validateArgs(args2); };
// then
assert.doesNotThrow(test);
assert.doesNotThrow(test2);
});
it('should return call based on args', function () {
// given
var method = new Method({
params: 2
});
var args = [1];
var args2 = ['heloas', '12', 3];
// when
var test = function () { method.validateArgs(args); };
var test2 = function () { method.validateArgs(args2); };
// then
assert.throws(test, errors.InvalidNumberOfParams);
assert.throws(test2, errors.InvalidNumberOfParams);
});
});
});

1
mocha.opts
View File

@ -1,2 +1 @@
--reporter spec

10
net.methods.js
View File

@ -1,10 +0,0 @@
var assert = require('assert');
var web3 = require('../index.js');
var u = require('./test.utils.js');
describe('web3', function() {
describe('net', function() {
u.propertyExists(web3.net, 'listening');
u.propertyExists(web3.net, 'peerCount');
});
});

5
node/app.js Normal file
View File

@ -0,0 +1,5 @@
var web3 = require('ethereum.js');
console.log(web3.version.api);

14
node/package.json Normal file
View File

@ -0,0 +1,14 @@
{
"name": "node",
"version": "1.0.0",
"description": "",
"main": "app.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC",
"dependencies": {
"ethereum.js": "ethereum/ethereum.js#master"
}
}

69
polling.js Normal file
View File

@ -0,0 +1,69 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var utils = require('../lib/utils/utils');
var tests = [{
protocol: 'eth',
args: ['pending'],
firstResult: 1,
firstPayload: {
method: "eth_newBlockFilter",
params: [
"pending"
]
},
secondResult: [null],
secondPayload: {
method: "eth_getFilterChanges"
}
}];
var testPolling = function (tests) {
describe('web3.eth.filter.polling', function () {
tests.forEach(function (test, index) {
it('should create && successfully poll filter', function (done) {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
web3.reset();
provider.injectResult(test.firstResult);
var step = 0;
provider.injectValidation(function (payload) {
if (step === 0) {
step = 1;
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.firstPayload.method);
assert.deepEqual(payload.params, test.firstPayload.params);
} else if (step === 1 && utils.isArray(payload)) {
var r = payload.filter(function (p) {
return p.jsonrpc === '2.0' && p.method === test.secondPayload.method && p.params[0] === test.firstResult;
});
assert.equal(r.length > 0, true);
}
});
// when
var filter = web3[test.protocol].filter.apply(null, test.args);
provider.injectBatchResults([test.secondResult]);
filter.watch(function (err, result) {
if (test.err) {
// todo
} else {
assert.equal(result, test.secondResult[0]);
}
done();
});
});
});
});
};
testPolling(tests);

22
qtsyncprovider.js Normal file
View File

@ -0,0 +1,22 @@
var chai = require('chai');
var assert = chai.assert;
var SandboxedModule = require('sandboxed-module');
SandboxedModule.registerBuiltInSourceTransformer('istanbul');
var QtSyncProvider = SandboxedModule.require('../lib/web3/qtsync', {
globals: {
navigator: require('./helpers/FakeQtNavigator')
}
});
describe('/lib/web3/qtsyncprovider', function () {
describe('send', function () {
it('should send basic request', function () {
var provider = new QtSyncProvider();
var result = provider.send({});
assert.equal(typeof result, 'object');
});
});
});

44
requestmanager.js Normal file
View File

@ -0,0 +1,44 @@
var chai = require('chai');
var assert = chai.assert;
var RequestManager = require('../lib/web3/requestmanager');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
// TODO: handling errors!
// TODO: validation of params!
describe('lib/web3/requestmanager', function () {
describe('send', function () {
it('should return expected result synchronously', function () {
var provider = new FakeHttpProvider();
var manager = RequestManager.getInstance();
manager.setProvider(provider);
var expected = 'hello_world';
provider.injectResult(expected);
var result = manager.send({
method: 'test',
params: [1,2,3]
});
assert.equal(expected, result);
});
it('should return expected result asynchronously', function (done) {
var provider = new FakeHttpProvider();
var manager = RequestManager.getInstance();
manager.setProvider(provider);
var expected = 'hello_world';
provider.injectResult(expected);
manager.sendAsync({
method: 'test',
params: [1,2,3]
}, function (error, result) {
assert.equal(error, null);
assert.equal(expected, result);
done();
});
});
});
});

45
shh.filter.js Normal file
View File

@ -0,0 +1,45 @@
var chai = require('chai');
var web3 = require('../index');
var assert = chai.assert;
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var method = 'filter';
var tests = [{
args: [{
to: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
topics: ['0x324f5435', '0x564b4566f3453']
}],
formattedArgs: [{
to: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
topics: ['0x324f5435', '0x564b4566f3453']
}],
result: '0xf',
formattedResult: '0xf',
call: 'shh_newFilter'
}];
describe('shh', function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('property test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, test.formattedArgs);
});
// call
web3.shh[method].apply(null, test.args);
});
});
});
});

16
shh.hasIdentity.js Normal file
View File

@ -0,0 +1,16 @@
var chai = require('chai');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'hasIdentity';
var tests = [{
args: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855'],
formattedArgs: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855'],
result: true,
formattedResult: true,
call: 'shh_'+ method
}];
testMethod.runTests('shh', method, tests);

48
signature.js Normal file
View File

@ -0,0 +1,48 @@
var chai = require('chai');
var assert = chai.assert;
var utils = require('../lib/utils/utils');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var signature = require('../lib/web3/signature');
var web3 = require('../index');
var tests = [{
method: 'functionSignatureFromAscii',
call: 'web3_sha3',
request: 'multiply',
formattedRequest: utils.fromAscii('multiply'),
result: '0x255d31552d29a21e93334e96055c6dca7cd329f5420ae74ec166d0c47f9f9843',
formattedResult: '0x255d3155'
},{
method: 'eventSignatureFromAscii',
call: 'web3_sha3',
request: 'multiply',
formattedRequest: utils.fromAscii('multiply'),
result: '0x255d31552d29a21e93334e96055c6dca7cd329f5420ae74ec166d0c47f9f9843',
formattedResult: '0x255d31552d29a21e93334e96055c6dca7cd329f5420ae74ec166d0c47f9f9843'
}];
describe('lib/web3/signature', function () {
tests.forEach(function (test, index) {
describe(test.method, function () {
it('should properly format and return signature of solidity functioni ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.method, test.call);
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.params[0], test.formattedRequest);
});
// when
var result = signature[test.method].call(null, test.request);
// then
assert.equal(result, test.formattedResult);
});
});
});
});

2
utils.extractDisplayName.js
View File

@ -1,7 +1,7 @@
var assert = require('assert');
var utils = require('../lib/utils/utils.js');
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('extractDisplayName', function () {
it('should extract display name from method with no params', function () {

2
utils.extractTypeName.js
View File

@ -1,7 +1,7 @@
var assert = require('assert');
var utils = require('../lib/utils/utils.js');
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('extractTypeName', function () {
it('should extract type name from method with no params', function () {

2
utils.filters.js
View File

@ -1,7 +1,7 @@
var assert = require('assert');
var utils = require('../lib/utils/utils.js');
describe('utils', function() {
describe('lib/utils/utils', function() {
it('should filter functions and events from input array properly', function () {
// given

2
utils.fromDecimal.js
View File

@ -31,7 +31,7 @@ var tests = [
{ value: '-0x0', expected: '0x0'}
];
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('fromDecimal', function () {
tests.forEach(function (test) {
it('should turn ' + test.value + ' to ' + test.expected, function () {

2
utils.fromWei.js
View File

@ -1,7 +1,7 @@
var assert = require('assert');
var utils = require('../lib/utils/utils.js');
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('fromWei', function () {
it('should return the correct value', function () {

4
utils.isAddress.js
View File

@ -8,10 +8,10 @@ var tests = [
{ value: 'function', is: false},
{ value: {}, is: false},
{ value: '0xc6d9d2cd449a754c494264e1809c50e34d64562b', is: true },
{ value: 'c6d9d2cd449a754c494264e1809c50e34d64562b', is: true }
{ value: 'c6d9d2cd449a754c494264e1809c50e34d64562b', is: false }
];
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('isAddress', function () {
tests.forEach(function (test) {
it('shoud test if value ' + test.value + ' is address: ' + test.is, function () {

2
utils.isBigNumber.js
View File

@ -15,7 +15,7 @@ var tests = [
];
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('isBigNumber', function () {
tests.forEach(function (test) {
it('shoud test if value ' + test.func + ' is BigNumber: ' + test.is, function () {

2
utils.isFunction.js
View File

@ -9,7 +9,7 @@ var tests = [
{ func: {}, is: false}
];
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('isFunction', function () {
tests.forEach(function (test) {
it('shoud test if value ' + test.func + ' is function: ' + test.is, function () {

26
utils.isJson.js Normal file
View File

@ -0,0 +1,26 @@
var chai = require('chai');
var utils = require('../lib/utils/utils.js');
var assert = chai.assert;
var tests = [
{ obj: function () {}, is: false},
{ obj: new Function(), is: false},
{ obj: 'function', is: false},
{ obj: {}, is: false},
{ obj: '[]', is: true},
{ obj: '[1, 2]', is: true},
{ obj: '{}', is: true},
{ obj: '{"a": 123, "b" :3,}', is: false},
{ obj: '{"c" : 2}', is: true}
];
describe('lib/utils/utils', function () {
describe('isJson', function () {
tests.forEach(function (test) {
it('shoud test if value ' + test.obj + ' is json: ' + test.is, function () {
assert.equal(utils.isJson(test.obj), test.is);
});
});
});
});

2
utils.isString.js
View File

@ -10,7 +10,7 @@ var tests = [
{ value: new String('hello'), is: true}
];
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('isString', function () {
tests.forEach(function (test) {
it('shoud test if value ' + test.func + ' is string: ' + test.is, function () {

2
utils.toBigNumber.js
View File

@ -34,7 +34,7 @@ var tests = [
{ value: new BigNumber(0), expected: '0'}
];
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('toBigNumber', function () {
tests.forEach(function (test) {
it('should turn ' + test.value + ' to ' + test.expected, function () {

2
utils.toDecimal.js
View File

@ -1,7 +1,7 @@
var assert = require('assert');
var utils = require('../lib/utils/utils.js');
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('toDecimal', function () {
it('should return the correct value', function () {

8
utils.toHex.js
View File

@ -27,14 +27,16 @@ var tests = [
{ value: {test: 'test'}, expected: '0x7b2274657374223a2274657374227d'},
{ value: '{"test": "test"}', expected: '0x7b2274657374223a202274657374227d'},
{ value: 'myString', expected: '0x6d79537472696e67'},
{ value: new BigNumber(15), expected: '0xf'}
{ value: new BigNumber(15), expected: '0xf'},
{ value: true, expected: '0x1'},
{ value: false, expected: '0x0'}
];
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('toHex', function () {
tests.forEach(function (test) {
it('should turn ' + test.value + ' to ' + test.expected, function () {
assert.equal(utils.toHex(test.value), test.expected);
assert.strictEqual(utils.toHex(test.value), test.expected);
});
});
});

2
utils.toWei.js
View File

@ -2,7 +2,7 @@ var chai = require('chai');
var utils = require('../lib/utils/utils');
var assert = chai.assert;
describe('utils', function () {
describe('lib/utils/utils', function () {
describe('toWei', function () {
it('should return the correct value', function () {

14
web3.db.getHex.js Normal file
View File

@ -0,0 +1,14 @@
var testMethod = require('./helpers/test.method.js');
var method = 'getHex';
var tests = [{
args: ['myDB', 'myKey'],
formattedArgs: ['myDB', 'myKey'],
result: '0xf',
formattedResult: '0xf',
call: 'db_'+ method
}];
testMethod.runTests('db', method, tests);

16
web3.db.getString.js Normal file
View File

@ -0,0 +1,16 @@
var chai = require('chai');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'getString';
var tests = [{
args: ['myDB', 'myKey'],
formattedArgs: ['myDB', 'myKey'],
result: 'myValue',
formattedResult: 'myValue',
call: 'db_'+ method
}];
testMethod.runTests('db', method, tests);

10
db.methods.js → web3.db.methods.js
View File

@ -1,10 +1,10 @@
var assert = require('assert');
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index.js');
var u = require('./test.utils.js');
var u = require('./helpers/test.utils.js');
describe('web3', function() {
describe('db', function() {
describe('web3.db', function() {
describe('methods', function() {
u.methodExists(web3.db, 'putHex');
u.methodExists(web3.db, 'getHex');
u.methodExists(web3.db, 'putString');

16
web3.db.putHex.js Normal file
View File

@ -0,0 +1,16 @@
var chai = require('chai');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'putHex';
var tests = [{
args: ['myDB', 'myKey', '0xb'],
formattedArgs: ['myDB', 'myKey', '0xb'],
result: true,
formattedResult: true,
call: 'db_'+ method
}];
testMethod.runTests('db', method, tests);

16
web3.db.putString.js Normal file
View File

@ -0,0 +1,16 @@
var chai = require('chai');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'putString';
var tests = [{
args: ['myDB', 'myKey', 'myValue'],
formattedArgs: ['myDB', 'myKey', 'myValue'],
result: true,
formattedResult: true,
call: 'db_'+ method
}];
testMethod.runTests('db', method, tests);

38
web3.eth.accounts.js Normal file
View File

@ -0,0 +1,38 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var method = 'accounts';
var tests = [{
result: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
formattedResult: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
call: 'eth_'+ method
}];
describe('web3.eth', function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('property test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, []);
});
// when
var result = web3.eth[method];
// then
assert.deepEqual(test.formattedResult, result);
});
});
});
});

38
web3.eth.blockNumber.js Normal file
View File

@ -0,0 +1,38 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var method = 'blockNumber';
var tests = [{
result: '0xb',
formattedResult: 11,
call: 'eth_'+ method
}];
describe('web3.eth', function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('property test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, []);
});
// when
var result = web3.eth[method];
// then
assert.strictEqual(test.formattedResult, result);
});
});
});
});

38
web3.eth.coinbase.js Normal file
View File

@ -0,0 +1,38 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var method = 'coinbase';
var tests = [{
result: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
call: 'eth_'+ method
}];
describe('web3.eth', function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('property test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, []);
});
// when
var result = web3.eth[method];
// then
assert.deepEqual(test.formattedResult, result);
});
});
});
});

2
eth.contract.js → web3.eth.contract.js
View File

@ -1,7 +1,7 @@
var assert = require('assert');
var contract = require('../lib/web3/contract.js');
describe('contract', function() {
describe('web3.eth.contract', function() {
it('should create simple contract with one method from abi with explicit type name', function () {
// given

12
web3.eth.defaultBlock.js Normal file
View File

@ -0,0 +1,12 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
describe('web3.eth', function () {
describe('defaultBlock', function () {
it('should check if defaultBlock is set to proper value', function () {
assert.equal(web3.eth.defaultBlock, 'latest');
});
});
});

55
web3.eth.filter.js Normal file
View File

@ -0,0 +1,55 @@
var chai = require('chai');
var web3 = require('../index');
var assert = chai.assert;
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var method = 'filter';
var tests = [{
args: [{
fromBlock: 0,
toBlock: 10,
address: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'
}],
formattedArgs: [{
fromBlock: '0x0',
toBlock: '0xa',
address: '0x47d33b27bb249a2dbab4c0612bf9caf4c1950855',
topics: []
}],
result: '0xf',
formattedResult: '0xf',
call: 'eth_newFilter'
},{
args: ['pending'],
formattedArgs: ['pending'],
result: '0xf',
formattedResult: '0xf',
call: 'eth_newBlockFilter'
}];
describe('web3.eth', function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('property test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, test.formattedArgs);
});
// call
web3.eth[method].apply(null, test.args);
});
});
});
});

23
web3.eth.filter.methods.js Normal file
View File

@ -0,0 +1,23 @@
var chai = require('chai');
var assert = chai.assert;
var filter = require('../lib/web3/filter');
var u = require('./helpers/test.utils.js');
var empty = function () {};
var implementation = {
newFilter: empty,
getLogs: empty,
uninstallFilter: empty,
startPolling: empty,
stopPolling: empty,
};
describe('web3.eth.filter', function () {
describe('methods', function () {
//var f = filter({}, implementation);
//u.methodExists(f, 'watch');
//u.methodExists(f, 'stopWatching');
//u.methodExists(f, 'get');
});
});

64
web3.eth.getBalance.js Normal file
View File

@ -0,0 +1,64 @@
var BigNumber = require('bignumber.js');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'getBalance';
var tests = [{
args: [301, 2],
formattedArgs: ['0x000000000000000000000000000000000000012d', '0x2'],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
},{
args: ['0x12d', '0x1'],
formattedArgs: ['0x000000000000000000000000000000000000012d', '0x1'],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
}, {
args: [0x12d, 0x1],
formattedArgs: ['0x000000000000000000000000000000000000012d', '0x1'],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
}, {
args: [0x12d],
formattedArgs: ['0x000000000000000000000000000000000000012d', web3.eth.defaultBlock],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
}, {
args: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', 0x1],
formattedArgs: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', '0x1'],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
}, {
args: ['dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', 0x1],
formattedArgs: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', '0x1'],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
}, {
args: ['1255171934823351805979544608257289442498956485798', 0x1],
formattedArgs: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', '0x1'],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
}, {
args: ['1255171934823351805979544608257289442498956485798'],
formattedArgs: ['0xdbdbdb2cbd23b783741e8d7fcf51e459b497e4a6', 'latest'],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
}, {
args: ['0x00000000000000000000aaaaaaaaaaaaaaaaaaa'],
formattedArgs: ['0x000000000000000000000aaaaaaaaaaaaaaaaaaa', 'latest'],
result: '0x31981',
formattedResult: new BigNumber('0x31981', 16),
call: 'eth_'+ method
}];
testMethod.runTests('eth', method, tests);

139
web3.eth.getBlock.js Normal file
View File

@ -0,0 +1,139 @@
var web3 = require('../index');
var BigNumber = require('bignumber.js');
var testMethod = require('./helpers/test.method.js');
var method = 'getBlock';
var blockResult = {
"number": "0x1b4",
"hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
"nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
"miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
"difficulty": "0x027f07",
"totalDifficulty": "0x027f07",
"size": "0x027f07",
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
"gasLimit": "0x9f759",
"minGasPrice": "0x9f759",
"gasUsed": "0x9f759",
"timestamp": "0x54e34e8e",
"transactions": ['0x460cfb8472af2c5fd05b5a2','0x460cfb8472af2c5fd05b5a2'],
"uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
};
var formattedBlockResult = {
"number": 436,
"hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
"nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
"miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
"difficulty": new BigNumber(163591),
"totalDifficulty": new BigNumber(163591),
"size": 163591,
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
"gasLimit": 653145,
"minGasPrice": new BigNumber(653145),
"gasUsed": 653145,
"timestamp": 1424182926,
"transactions": ['0x460cfb8472af2c5fd05b5a2','0x460cfb8472af2c5fd05b5a2'],
"uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
};
var blockResultWithTx = {
"number": "0x1b4",
"hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
"nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
"miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
"difficulty": "0x027f07",
"totalDifficulty": "0x027f07",
"size": "0x027f07",
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
"gasLimit": "0x9f759",
"minGasPrice": "0x9f759",
"gasUsed": "0x9f759",
"timestamp": "0x54e34e8e",
"transactions": [{
"status": "mined",
"hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
"nonce":"0x",
"blockHash": "0x6fd9e2a26ab",
"blockNumber": "0x15df",
"transactionIndex": "0x1",
"from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
"to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
"value":"0x7f110",
"gas": "0x7f110",
"gasPrice":"0x09184e72a000",
"input":"0x603880600c6000396000f30060",
}],
"uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
};
var formattedBlockResultWithTx = {
"number": 436,
"hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
"nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
"miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
"difficulty": new BigNumber(163591),
"totalDifficulty": new BigNumber(163591),
"size": 163591,
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
"gasLimit": 653145,
"minGasPrice": new BigNumber(653145),
"gasUsed": 653145,
"timestamp": 1424182926,
"transactions": [{
"status": "mined",
"hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
"nonce":"0x",
"blockHash": "0x6fd9e2a26ab",
"blockNumber": 5599,
"transactionIndex": 1,
"from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
"to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
"value": new BigNumber(520464),
"gas": 520464,
"gasPrice": new BigNumber(10000000000000),
"input":"0x603880600c6000396000f30060",
}],
"uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
};
var tests = [{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', false],
result: blockResult,
formattedResult: formattedBlockResult,
call: 'eth_'+ method + 'ByHash'
},{
args: [436],
formattedArgs: ['0x1b4', false],
result: blockResult,
formattedResult: formattedBlockResult,
call: 'eth_'+ method + 'ByNumber'
},{
args: [436, true],
formattedArgs: ['0x1b4', true],
result: blockResultWithTx,
formattedResult: formattedBlockResultWithTx,
call: 'eth_'+ method + 'ByNumber'
}];
testMethod.runTests('eth', method, tests);

29
web3.eth.getBlockTransactionCount.js Normal file
View File

@ -0,0 +1,29 @@
var chai = require('chai');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'getBlockTransactionCount';
var tests = [{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
result: '0xb',
formattedResult: 11,
call: 'eth_getBlockTransactionCountByHash'
},{
args: [436],
formattedArgs: ['0x1b4'],
result: '0xb',
formattedResult: 11,
call: 'eth_getBlockTransactionCountByNumber'
},{
args: ['pending'],
formattedArgs: ['pending'],
result: '0xb',
formattedResult: 11,
call: 'eth_getBlockTransactionCountByNumber'
}];
testMethod.runTests('eth', method, tests);

27
web3.eth.getBlockUncleCount.js Normal file
View File

@ -0,0 +1,27 @@
var chai = require('chai');
var web3 = require('../index');
var method = 'getBlockUncleCount';
var testMethod = require('./helpers/test.method.js');
var tests = [{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
result: '0xb',
formattedResult: 11,
call: 'eth_getUncleCountByBlockHash'
},{
args: [436],
formattedArgs: ['0x1b4'],
result: '0xb',
formattedResult: 11,
call: 'eth_getUncleCountByBlockNumber'
},{
args: ['pending'],
formattedArgs: ['pending'],
result: '0xb',
formattedResult: 11,
call: 'eth_getUncleCountByBlockNumber'
}];
testMethod.runTests('eth', method, tests);

23
web3.eth.getCode.js Normal file
View File

@ -0,0 +1,23 @@
var chai = require('chai');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'getCode';
var tests = [{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855'],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', web3.eth.defaultBlock],
result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
call: 'eth_'+ method
},{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 2],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0x2'],
result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
call: 'eth_'+ method
}];
testMethod.runTests('eth', method, tests);

23
web3.eth.getCompilers.js Normal file
View File

@ -0,0 +1,23 @@
var chai = require('chai');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'getCompilers';
var tests = [{
args: [],
formattedArgs: [],
result: ['solidity'],
formattedResult: ['solidity'],
call: 'eth_'+ method
},{
args: [],
formattedArgs: [],
result: ['solidity'],
formattedResult: ['solidity'],
call: 'eth_'+ method
}];
testMethod.runTests('eth', method, tests);

35
web3.eth.getStorageAt.js Normal file
View File

@ -0,0 +1,35 @@
var chai = require('chai');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'getStorageAt';
var tests = [{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 2],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0x2', web3.eth.defaultBlock],
result: '0x47d33b2',
formattedResult: '0x47d33b2',
call: 'eth_'+ method
},{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 2, 0],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0x2', '0x0'],
result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
call: 'eth_'+ method
},{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 0xb, 0x0],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0xb', '0x0'],
result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
call: 'eth_'+ method
}, {
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 0xb, 'latest'],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0xb', 'latest'],
result: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
formattedResult: '0x47d33b27bb249a2dbab4c0612bf9caf4747d33b27bb249a2dbab4c0612bf9cafd33b27bb249a2dbab4c0612bf9caf4c1950855',
call: 'eth_'+ method
}];
testMethod.runTests('eth', method, tests);

46
web3.eth.getTransaction.js Normal file
View File

@ -0,0 +1,46 @@
var chai = require('chai');
var web3 = require('../index');
var BigNumber = require('bignumber.js');
var testMethod = require('./helpers/test.method.js');
var method = 'getTransaction';
var txResult = {
"status": "mined",
"hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
"nonce":"0x",
"blockHash": "0x6fd9e2a26ab",
"blockNumber": "0x15df",
"transactionIndex": "0x1",
"from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
"to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
"value":"0x7f110",
"gas": "0x7f110",
"gasPrice":"0x09184e72a000",
"input":"0x603880600c6000396000f30060"
};
var formattedTxResult = {
"status": "mined",
"hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
"nonce":"0x",
"blockHash": "0x6fd9e2a26ab",
"blockNumber": 5599,
"transactionIndex": 1,
"from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
"to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
"value": new BigNumber(520464),
"gas": 520464,
"gasPrice": new BigNumber(10000000000000),
"input":"0x603880600c6000396000f30060"
};
var tests = [{
args: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855'],
formattedArgs: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855'],
result: txResult,
formattedResult: formattedTxResult,
call: 'eth_'+ method + 'ByHash'
}];
testMethod.runTests('eth', method, tests);

52
web3.eth.getTransactionFromBlock.js Normal file
View File

@ -0,0 +1,52 @@
var chai = require('chai');
var web3 = require('../index');
var BigNumber = require('bignumber.js');
var testMethod = require('./helpers/test.method.js');
var method = 'getTransactionFromBlock';
var txResult = {
"status": "mined",
"hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
"nonce":"0x",
"blockHash": "0x6fd9e2a26ab",
"blockNumber": "0x15df",
"transactionIndex": "0x1",
"from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
"to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
"value":"0x7f110",
"gas": "0x7f110",
"gasPrice":"0x09184e72a000",
"input":"0x603880600c6000396000f30060"
};
var formattedTxResult = {
"status": "mined",
"hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
"nonce":"0x",
"blockHash": "0x6fd9e2a26ab",
"blockNumber": 5599,
"transactionIndex": 1,
"from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
"to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
"value": new BigNumber(520464),
"gas": 520464,
"gasPrice": new BigNumber(10000000000000),
"input":"0x603880600c6000396000f30060"
};
var tests = [{
args: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855', 2],
formattedArgs: ['0x2dbab4c0612bf9caf4c195085547dc0612bf9caf4c1950855', '0x2'],
result: txResult,
formattedResult: formattedTxResult,
call: 'eth_getTransactionByBlockHashAndIndex'
},{
args: [436, 11],
formattedArgs: ['0x1b4', '0xb'],
result: txResult,
formattedResult: formattedTxResult,
call: 'eth_getTransactionByBlockNumberAndIndex'
}];
testMethod.runTests('eth', method, tests);

139
web3.eth.getUncle.js Normal file
View File

@ -0,0 +1,139 @@
var chai = require('chai');
var web3 = require('../index');
var BigNumber = require('bignumber.js');
var testMethod = require('./helpers/test.method.js');
var method = 'getUncle';
var blockResult = {
"number": "0x1b4",
"hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
"nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
"miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
"difficulty": "0x027f07",
"totalDifficulty": "0x027f07",
"size": "0x027f07",
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
"gasLimit": "0x9f759",
"minGasPrice": "0x9f759",
"gasUsed": "0x9f759",
"timestamp": "0x54e34e8e",
"transactions": ['0x460cfb8472af2c5fd05b5a2','0x460cfb8472af2c5fd05b5a2'],
"uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
};
var formattedBlockResult = {
"number": 436,
"hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
"nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
"miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
"difficulty": new BigNumber(163591),
"totalDifficulty": new BigNumber(163591),
"size": 163591,
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
"gasLimit": 653145,
"minGasPrice": new BigNumber(653145),
"gasUsed": 653145,
"timestamp": 1424182926,
"transactions": ['0x460cfb8472af2c5fd05b5a2','0x460cfb8472af2c5fd05b5a2'],
"uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
};
var blockResultWithTx = {
"number": "0x1b4",
"hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
"nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
"miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
"difficulty": "0x027f07",
"totalDifficulty": "0x027f07",
"size": "0x027f07",
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
"gasLimit": "0x9f759",
"minGasPrice": "0x9f759",
"gasUsed": "0x9f759",
"timestamp": "0x54e34e8e",
"transactions": [{
"status": "mined",
"hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
"nonce":"0x",
"blockHash": "0x6fd9e2a26ab",
"blockNumber": "0x15df",
"transactionIndex": "0x1",
"from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
"to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
"value":"0x7f110",
"gas": "0x7f110",
"gasPrice":"0x09184e72a000",
"input":"0x603880600c6000396000f30060",
}],
"uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
};
var formattedBlockResultWithTx = {
"number": 436,
"hash": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"parentHash": "0x9646252be9520f6e71339a8df9c55e4d7619deeb018d2a3f2d21fc165dde5eb5",
"nonce": "0xe04d296d2460cfb8472af2c5fd05b5a214109c25688d3704aed5484f9a7792f2",
"sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
"logsBloom": "0xe670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
"transactionsRoot": "0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"stateRoot": "0xd5855eb08b3387c0af375e9cdb6acfc05eb8f519e419b874b6ff2ffda7ed1dff",
"miner": "0x4e65fda2159562a496f9f3522f89122a3088497a",
"difficulty": new BigNumber(163591),
"totalDifficulty": new BigNumber(163591),
"size": 163591,
"extraData": "0x0000000000000000000000000000000000000000000000000000000000000000",
"gasLimit": 653145,
"minGasPrice": new BigNumber(653145),
"gasUsed": 653145,
"timestamp": 1424182926,
"transactions": [{
"status": "mined",
"hash":"0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b",
"nonce":"0x",
"blockHash": "0x6fd9e2a26ab",
"blockNumber": 5599,
"transactionIndex": 1,
"from":"0x407d73d8a49eeb85d32cf465507dd71d507100c1",
"to":"0x85h43d8a49eeb85d32cf465507dd71d507100c1",
"value": new BigNumber(520464),
"gas": 520464,
"gasPrice": new BigNumber(10000000000000),
"input":"0x603880600c6000396000f30060",
}],
"uncles": ["0x460cfb8472af2c5fd05b5a2", "0xd5460cfb8472af2c5fd05b5a2"]
};
var tests = [{
args: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', 2],
formattedArgs: ['0x47d33b27bb249a2dbab4c0612bf9caf4c1950855', '0x2', false],
result: blockResult,
formattedResult: formattedBlockResult,
call: 'eth_getUncleByBlockHashAndIndex'
},{
args: [436, 1],
formattedArgs: ['0x1b4', '0x1', false],
result: blockResult,
formattedResult: formattedBlockResult,
call: 'eth_getUncleByBlockNumberAndIndex'
},{
args: [436, 1, true],
formattedArgs: ['0x1b4', '0x1', true],
result: blockResultWithTx,
formattedResult: formattedBlockResultWithTx,
call: 'eth_getUncleByBlockNumberAndIndex'
}];
testMethod.runTests('eth', method, tests);

37
eth.methods.js → web3.eth.methods.js
View File

@ -1,14 +1,14 @@
var assert = require('assert');
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index.js');
var u = require('./test.utils.js');
var u = require('./helpers/test.utils.js');
describe('web3', function() {
describe('eth', function() {
describe('web3.eth', function() {
describe('methods', function() {
u.methodExists(web3.eth, 'getBalance');
u.methodExists(web3.eth, 'getStorageAt');
u.methodExists(web3.eth, 'getStorage');
u.methodExists(web3.eth, 'getTransactionCount');
u.methodExists(web3.eth, 'getData');
u.methodExists(web3.eth, 'getCode');
u.methodExists(web3.eth, 'sendTransaction');
u.methodExists(web3.eth, 'call');
u.methodExists(web3.eth, 'getBlock');
@ -30,30 +30,5 @@ describe('web3', function() {
u.propertyExists(web3.eth, 'defaultBlock');
u.propertyExists(web3.eth, 'blockNumber');
});
// Fail at the moment
// describe('eth', function(){
// it('should be a positive balance', function() {
// // when
// var testAddress = '0x50f4ed0e83f9da907017bcfb444e3e25407f59bb';
// var balance = web3.eth.balanceAt(testAddress);
// // then
// assert(balance > 0, 'Balance is ' + balance);
// });
// it('should return a block', function() {
// // when
// var block = web3.eth.block(0);
// // then
// assert.notEqual(block, null);
// assert.equal(block.number, 0);
// assert(web3.toDecimal(block.difficulty) > 0);
// });
// });
});

38
web3.eth.mining.js Normal file
View File

@ -0,0 +1,38 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var method = 'mining';
var tests = [{
result: true,
formattedResult: true,
call: 'eth_'+ method
}];
describe('web3.eth', function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('property test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, []);
});
// when
var result = web3.eth[method];
// then
assert.deepEqual(test.formattedResult, result);
});
});
});
});

6
web3.methods.js
View File

@ -1,8 +1,8 @@
var assert = require('assert');
var web3 = require('../index.js');
var u = require('./test.utils.js');
var u = require('./helpers/test.utils.js');
describe('web3', function() {
describe('methods', function () {
u.methodExists(web3, 'sha3');
u.methodExists(web3, 'toAscii');
u.methodExists(web3, 'fromAscii');
@ -15,10 +15,10 @@ describe('web3', function() {
u.methodExists(web3, 'setProvider');
u.methodExists(web3, 'reset');
u.propertyExists(web3, 'manager');
u.propertyExists(web3, 'providers');
u.propertyExists(web3, 'eth');
u.propertyExists(web3, 'db');
u.propertyExists(web3, 'shh');
});
});

38
web3.net.listening.js Normal file
View File

@ -0,0 +1,38 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var method = 'listening';
var tests = [{
result: true,
formattedResult: true,
call: 'net_'+ method
}];
describe('web3.net', function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('property test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, []);
});
// when
var result = web3.net[method];
// then
assert.deepEqual(test.formattedResult, result);
});
});
});
});

11
web3.net.methods.js Normal file
View File

@ -0,0 +1,11 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index.js');
var u = require('./helpers/test.utils.js');
describe('web3.net', function() {
describe('methods', function() {
u.propertyExists(web3.net, 'listening');
u.propertyExists(web3.net, 'peerCount');
});
});

38
web3.net.peerCount.js Normal file
View File

@ -0,0 +1,38 @@
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index');
var FakeHttpProvider = require('./helpers/FakeHttpProvider');
var method = 'peerCount';
var tests = [{
result: '0xf',
formattedResult: 15,
call: 'net_'+ method
}];
describe('web3.net', function () {
describe(method, function () {
tests.forEach(function (test, index) {
it('property test: ' + index, function () {
// given
var provider = new FakeHttpProvider();
web3.setProvider(provider);
provider.injectResult(test.result);
provider.injectValidation(function (payload) {
assert.equal(payload.jsonrpc, '2.0');
assert.equal(payload.method, test.call);
assert.deepEqual(payload.params, []);
});
// when
var result = web3.net[method];
// then
assert.deepEqual(test.formattedResult, result);
});
});
});
});

16
web3.sha3.js Normal file
View File

@ -0,0 +1,16 @@
var BigNumber = require('bignumber.js');
var web3 = require('../index');
var testMethod = require('./helpers/test.method.js');
var method = 'sha3';
var tests = [{
args: ['myString'],
formattedArgs: ['myString'],
result: '0x319319f831983198319881',
formattedResult: '0x319319f831983198319881',
call: 'web3_'+ method
}];
testMethod.runTests(null, method, tests);

9
shh.methods.js → web3.shh.methods.js
View File

@ -1,9 +1,10 @@
var assert = require('assert');
var chai = require('chai');
var assert = chai.assert;
var web3 = require('../index.js');
var u = require('./test.utils.js');
var u = require('./helpers/test.utils.js');
describe('web3', function() {
describe('shh', function() {
describe('web3.shh', function() {
describe('methods', function() {
u.methodExists(web3.shh, 'post');
u.methodExists(web3.shh, 'newIdentity');
u.methodExists(web3.shh, 'hasIdentity');