From 3e4a9de0b0553230822d439ffd79022fb4839b94 Mon Sep 17 00:00:00 2001 From: Marek Kotewicz Date: Tue, 7 Apr 2015 04:50:10 +0200 Subject: [PATCH] Squashed 'libjsqrc/ethereumjs/' changes from eceeda7..73b9ed2 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 --- abi.inputParser.js | 2 +- abi.outputParser.js | 2 +- contract.js | 229 +++++++++++++++++++++++ event.inputParser.js | 26 +-- event.outputParser.js | 6 +- filter.methods.js | 24 --- formatters.inputDefaultBlockFormatter.js | 24 +++ formatters.inputPostFormatter.js | 3 +- formatters.inputTransactionFormatter.js | 11 +- formatters.outputTransactionFormatter.js | 8 +- helpers/FakeHttpProvider.js | 68 +++++++ helpers/FakeQtNavigator.js | 11 ++ helpers/FakeXMLHttpRequest.js | 31 +++ helpers/test.method.js | 68 +++++++ test.utils.js => helpers/test.utils.js | 9 +- httpprovider.js | 33 ++++ jsonrpc.id.js | 23 +++ jsonrpc.isValidResponse.js | 1 + jsonrpc.toBatchPayload.js | 1 + jsonrpc.toPayload.js | 4 +- method.attachToObject.js | 44 +++++ method.extractCallback.js | 52 +++++ method.formatInput.js | 41 ++++ method.formatOutput.js | 43 +++++ method.getCall.js | 46 +++++ method.validateArgs.js | 47 +++++ mocha.opts | 3 +- net.methods.js | 10 - node/app.js | 5 + node/package.json | 14 ++ polling.js | 69 +++++++ qtsyncprovider.js | 22 +++ requestmanager.js | 44 +++++ shh.filter.js | 45 +++++ shh.hasIdentity.js | 16 ++ signature.js | 48 +++++ utils.extractDisplayName.js | 2 +- utils.extractTypeName.js | 2 +- utils.filters.js | 2 +- utils.fromDecimal.js | 2 +- utils.fromWei.js | 2 +- utils.isAddress.js | 4 +- utils.isBigNumber.js | 2 +- utils.isFunction.js | 2 +- utils.isJson.js | 26 +++ utils.isString.js | 2 +- utils.toBigNumber.js | 2 +- utils.toDecimal.js | 2 +- utils.toHex.js | 8 +- utils.toWei.js | 2 +- web3.db.getHex.js | 14 ++ web3.db.getString.js | 16 ++ db.methods.js => web3.db.methods.js | 10 +- web3.db.putHex.js | 16 ++ web3.db.putString.js | 16 ++ web3.eth.accounts.js | 38 ++++ web3.eth.blockNumber.js | 38 ++++ web3.eth.coinbase.js | 38 ++++ eth.contract.js => web3.eth.contract.js | 2 +- web3.eth.defaultBlock.js | 12 ++ web3.eth.filter.js | 55 ++++++ web3.eth.filter.methods.js | 23 +++ web3.eth.getBalance.js | 64 +++++++ web3.eth.getBlock.js | 139 ++++++++++++++ web3.eth.getBlockTransactionCount.js | 29 +++ web3.eth.getBlockUncleCount.js | 27 +++ web3.eth.getCode.js | 23 +++ web3.eth.getCompilers.js | 23 +++ web3.eth.getStorageAt.js | 35 ++++ web3.eth.getTransaction.js | 46 +++++ web3.eth.getTransactionFromBlock.js | 52 +++++ web3.eth.getUncle.js | 139 ++++++++++++++ eth.methods.js => web3.eth.methods.js | 37 +--- web3.eth.mining.js | 38 ++++ web3.methods.js | 36 ++-- web3.net.listening.js | 38 ++++ web3.net.methods.js | 11 ++ web3.net.peerCount.js | 38 ++++ web3.sha3.js | 16 ++ shh.methods.js => web3.shh.methods.js | 9 +- 80 files changed, 2127 insertions(+), 144 deletions(-) create mode 100644 contract.js delete mode 100644 filter.methods.js create mode 100644 formatters.inputDefaultBlockFormatter.js create mode 100644 helpers/FakeHttpProvider.js create mode 100644 helpers/FakeQtNavigator.js create mode 100644 helpers/FakeXMLHttpRequest.js create mode 100644 helpers/test.method.js rename test.utils.js => helpers/test.utils.js (67%) create mode 100644 httpprovider.js create mode 100644 jsonrpc.id.js create mode 100644 method.attachToObject.js create mode 100644 method.extractCallback.js create mode 100644 method.formatInput.js create mode 100644 method.formatOutput.js create mode 100644 method.getCall.js create mode 100644 method.validateArgs.js delete mode 100644 net.methods.js create mode 100644 node/app.js create mode 100644 node/package.json create mode 100644 polling.js create mode 100644 qtsyncprovider.js create mode 100644 requestmanager.js create mode 100644 shh.filter.js create mode 100644 shh.hasIdentity.js create mode 100644 signature.js create mode 100644 utils.isJson.js create mode 100644 web3.db.getHex.js create mode 100644 web3.db.getString.js rename db.methods.js => web3.db.methods.js (57%) create mode 100644 web3.db.putHex.js create mode 100644 web3.db.putString.js create mode 100644 web3.eth.accounts.js create mode 100644 web3.eth.blockNumber.js create mode 100644 web3.eth.coinbase.js rename eth.contract.js => web3.eth.contract.js (99%) create mode 100644 web3.eth.defaultBlock.js create mode 100644 web3.eth.filter.js create mode 100644 web3.eth.filter.methods.js create mode 100644 web3.eth.getBalance.js create mode 100644 web3.eth.getBlock.js create mode 100644 web3.eth.getBlockTransactionCount.js create mode 100644 web3.eth.getBlockUncleCount.js create mode 100644 web3.eth.getCode.js create mode 100644 web3.eth.getCompilers.js create mode 100644 web3.eth.getStorageAt.js create mode 100644 web3.eth.getTransaction.js create mode 100644 web3.eth.getTransactionFromBlock.js create mode 100644 web3.eth.getUncle.js rename eth.methods.js => web3.eth.methods.js (54%) create mode 100644 web3.eth.mining.js create mode 100644 web3.net.listening.js create mode 100644 web3.net.methods.js create mode 100644 web3.net.peerCount.js create mode 100644 web3.sha3.js rename shh.methods.js => web3.shh.methods.js (65%) diff --git a/abi.inputParser.js b/abi.inputParser.js index 1d3a869e3..a488bb2e5 100644 --- a/abi.inputParser.js +++ b/abi.inputParser.js @@ -19,7 +19,7 @@ var description = [{ ] }]; -describe('abi', function() { +describe('lib/solidity/abi', function() { describe('inputParser', function() { it('should parse input uint', function() { diff --git a/abi.outputParser.js b/abi.outputParser.js index 955c0d5f1..a57b84a83 100644 --- a/abi.outputParser.js +++ b/abi.outputParser.js @@ -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() { diff --git a/contract.js b/contract.js new file mode 100644 index 000000000..fec9fc314 --- /dev/null +++ b/contract.js @@ -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); + }); + }); +}); diff --git a/event.inputParser.js b/event.inputParser.js index a2ce27112..15e0b6d2a 100644 --- a/event.inputParser.js +++ b/event.inputParser.js @@ -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); }); }); diff --git a/event.outputParser.js b/event.outputParser.js index 93b50ff2f..d31e49fa8 100644 --- a/event.outputParser.js +++ b/event.outputParser.js @@ -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" diff --git a/filter.methods.js b/filter.methods.js deleted file mode 100644 index d039ec9bb..000000000 --- a/filter.methods.js +++ /dev/null @@ -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'); - }); - }); -}); diff --git a/formatters.inputDefaultBlockFormatter.js b/formatters.inputDefaultBlockFormatter.js new file mode 100644 index 000000000..8ae5ea268 --- /dev/null +++ b/formatters.inputDefaultBlockFormatter.js @@ -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); + }); + }); + }); +}); + + + diff --git a/formatters.inputPostFormatter.js b/formatters.inputPostFormatter.js index 0995d6d79..7f0ce5298 100644 --- a/formatters.inputPostFormatter.js +++ b/formatters.inputPostFormatter.js @@ -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 () { }); }); }); + diff --git a/formatters.inputTransactionFormatter.js b/formatters.inputTransactionFormatter.js index 5ff0526e1..2f7f8c2e5 100644 --- a/formatters.inputTransactionFormatter.js +++ b/formatters.inputTransactionFormatter.js @@ -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' }); }); }); diff --git a/formatters.outputTransactionFormatter.js b/formatters.outputTransactionFormatter.js index f42ed8495..b1eaff52d 100644 --- a/formatters.outputTransactionFormatter.js +++ b/formatters.outputTransactionFormatter.js @@ -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 }); }); }); diff --git a/helpers/FakeHttpProvider.js b/helpers/FakeHttpProvider.js new file mode 100644 index 000000000..20d1f2580 --- /dev/null +++ b/helpers/FakeHttpProvider.js @@ -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; + diff --git a/helpers/FakeQtNavigator.js b/helpers/FakeQtNavigator.js new file mode 100644 index 000000000..fb251d239 --- /dev/null +++ b/helpers/FakeQtNavigator.js @@ -0,0 +1,11 @@ + +var navigator = { + qt: { + callMethod: function (payload) { + return "{}"; + } + } +}; + +module.exports = navigator; + diff --git a/helpers/FakeXMLHttpRequest.js b/helpers/FakeXMLHttpRequest.js new file mode 100644 index 000000000..a67d7f74a --- /dev/null +++ b/helpers/FakeXMLHttpRequest.js @@ -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 +}; + diff --git a/helpers/test.method.js b/helpers/test.method.js new file mode 100644 index 000000000..8de318d8c --- /dev/null +++ b/helpers/test.method.js @@ -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 +} + diff --git a/test.utils.js b/helpers/test.utils.js similarity index 67% rename from test.utils.js rename to helpers/test.utils.js index 8a1e9a0b6..ea710fdca 100644 --- a/test.utils.js +++ b/helpers/test.utils.js @@ -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'); }); }; diff --git a/httpprovider.js b/httpprovider.js new file mode 100644 index 000000000..6205a16d2 --- /dev/null +++ b/httpprovider.js @@ -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(); + }); + }); + }); +}); + diff --git a/jsonrpc.id.js b/jsonrpc.id.js new file mode 100644 index 000000000..07ede281e --- /dev/null +++ b/jsonrpc.id.js @@ -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); + }); + }); +}); + diff --git a/jsonrpc.isValidResponse.js b/jsonrpc.isValidResponse.js index 78388a443..fc42f505d 100644 --- a/jsonrpc.isValidResponse.js +++ b/jsonrpc.isValidResponse.js @@ -1,5 +1,6 @@ var assert = require('assert'); var jsonrpc = require('../lib/web3/jsonrpc'); +jsonrpc = new jsonrpc(); describe('jsonrpc', function () { describe('isValidResponse', function () { diff --git a/jsonrpc.toBatchPayload.js b/jsonrpc.toBatchPayload.js index c9a1e51e0..b1b523f4e 100644 --- a/jsonrpc.toBatchPayload.js +++ b/jsonrpc.toBatchPayload.js @@ -1,5 +1,6 @@ var assert = require('assert'); var jsonrpc = require('../lib/web3/jsonrpc'); +jsonrpc = new jsonrpc(); describe('jsonrpc', function () { describe('toBatchPayload', function () { diff --git a/jsonrpc.toPayload.js b/jsonrpc.toPayload.js index a79501d73..dbec9afd1 100644 --- a/jsonrpc.toPayload.js +++ b/jsonrpc.toPayload.js @@ -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 () { diff --git a/method.attachToObject.js b/method.attachToObject.js new file mode 100644 index 000000000..a27a3e821 --- /dev/null +++ b/method.attachToObject.js @@ -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); + //}); + }); +}); + diff --git a/method.extractCallback.js b/method.extractCallback.js new file mode 100644 index 000000000..34e480c32 --- /dev/null +++ b/method.extractCallback.js @@ -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); + }); + }); +}); + diff --git a/method.formatInput.js b/method.formatInput.js new file mode 100644 index 000000000..c778f1059 --- /dev/null +++ b/method.formatInput.js @@ -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); + }); + }); +}); + diff --git a/method.formatOutput.js b/method.formatOutput.js new file mode 100644 index 000000000..4d88e2dae --- /dev/null +++ b/method.formatOutput.js @@ -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); + }); + }); +}); + diff --git a/method.getCall.js b/method.getCall.js new file mode 100644 index 000000000..398de325e --- /dev/null +++ b/method.getCall.js @@ -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'); + + }); + }); +}); + diff --git a/method.validateArgs.js b/method.validateArgs.js new file mode 100644 index 000000000..5cb16e1e0 --- /dev/null +++ b/method.validateArgs.js @@ -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); + }); + }); +}); + diff --git a/mocha.opts b/mocha.opts index c4a633d64..5ada47be1 100644 --- a/mocha.opts +++ b/mocha.opts @@ -1,2 +1 @@ ---reporter spec - +--reporter spec diff --git a/net.methods.js b/net.methods.js deleted file mode 100644 index 26d9c224d..000000000 --- a/net.methods.js +++ /dev/null @@ -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'); - }); -}); \ No newline at end of file diff --git a/node/app.js b/node/app.js new file mode 100644 index 000000000..c3fd489a0 --- /dev/null +++ b/node/app.js @@ -0,0 +1,5 @@ +var web3 = require('ethereum.js'); + +console.log(web3.version.api); + + diff --git a/node/package.json b/node/package.json new file mode 100644 index 000000000..4c56b2c10 --- /dev/null +++ b/node/package.json @@ -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" + } +} diff --git a/polling.js b/polling.js new file mode 100644 index 000000000..ea7dd9829 --- /dev/null +++ b/polling.js @@ -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); + diff --git a/qtsyncprovider.js b/qtsyncprovider.js new file mode 100644 index 000000000..ce0064414 --- /dev/null +++ b/qtsyncprovider.js @@ -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'); + }); + }); +}); + diff --git a/requestmanager.js b/requestmanager.js new file mode 100644 index 000000000..5c951ded3 --- /dev/null +++ b/requestmanager.js @@ -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(); + }); + }); + }); +}); + diff --git a/shh.filter.js b/shh.filter.js new file mode 100644 index 000000000..57df4d0c5 --- /dev/null +++ b/shh.filter.js @@ -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); + + }); + }); + }); +}); + + diff --git a/shh.hasIdentity.js b/shh.hasIdentity.js new file mode 100644 index 000000000..569247a88 --- /dev/null +++ b/shh.hasIdentity.js @@ -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); + diff --git a/signature.js b/signature.js new file mode 100644 index 000000000..709f662fd --- /dev/null +++ b/signature.js @@ -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); + }); + }); + }); +}); + diff --git a/utils.extractDisplayName.js b/utils.extractDisplayName.js index c401b7e60..d3faef8da 100644 --- a/utils.extractDisplayName.js +++ b/utils.extractDisplayName.js @@ -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 () { diff --git a/utils.extractTypeName.js b/utils.extractTypeName.js index 7211ff613..41099787d 100644 --- a/utils.extractTypeName.js +++ b/utils.extractTypeName.js @@ -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 () { diff --git a/utils.filters.js b/utils.filters.js index 4629e4fe8..5e6870efa 100644 --- a/utils.filters.js +++ b/utils.filters.js @@ -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 diff --git a/utils.fromDecimal.js b/utils.fromDecimal.js index 4dc774c74..c0e5ed62f 100644 --- a/utils.fromDecimal.js +++ b/utils.fromDecimal.js @@ -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 () { diff --git a/utils.fromWei.js b/utils.fromWei.js index 735575c68..e8691eb2a 100644 --- a/utils.fromWei.js +++ b/utils.fromWei.js @@ -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 () { diff --git a/utils.isAddress.js b/utils.isAddress.js index d2d087ffd..3ebbce837 100644 --- a/utils.isAddress.js +++ b/utils.isAddress.js @@ -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 () { diff --git a/utils.isBigNumber.js b/utils.isBigNumber.js index a3de36916..d78739b8a 100644 --- a/utils.isBigNumber.js +++ b/utils.isBigNumber.js @@ -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 () { diff --git a/utils.isFunction.js b/utils.isFunction.js index c113bc334..05882b2c0 100644 --- a/utils.isFunction.js +++ b/utils.isFunction.js @@ -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 () { diff --git a/utils.isJson.js b/utils.isJson.js new file mode 100644 index 000000000..73d86d833 --- /dev/null +++ b/utils.isJson.js @@ -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); + }); + }); + }); +}); + diff --git a/utils.isString.js b/utils.isString.js index bb36ccd67..73b95d22b 100644 --- a/utils.isString.js +++ b/utils.isString.js @@ -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 () { diff --git a/utils.toBigNumber.js b/utils.toBigNumber.js index 2d293c12a..efe3fa714 100644 --- a/utils.toBigNumber.js +++ b/utils.toBigNumber.js @@ -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 () { diff --git a/utils.toDecimal.js b/utils.toDecimal.js index d785b0444..74352f324 100644 --- a/utils.toDecimal.js +++ b/utils.toDecimal.js @@ -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 () { diff --git a/utils.toHex.js b/utils.toHex.js index 2e9c59cb5..0a328e345 100644 --- a/utils.toHex.js +++ b/utils.toHex.js @@ -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); }); }); }); diff --git a/utils.toWei.js b/utils.toWei.js index 33e03ffc3..3bb0997c6 100644 --- a/utils.toWei.js +++ b/utils.toWei.js @@ -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 () { diff --git a/web3.db.getHex.js b/web3.db.getHex.js new file mode 100644 index 000000000..7e17d0c51 --- /dev/null +++ b/web3.db.getHex.js @@ -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); + diff --git a/web3.db.getString.js b/web3.db.getString.js new file mode 100644 index 000000000..f9aadffa3 --- /dev/null +++ b/web3.db.getString.js @@ -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); + diff --git a/db.methods.js b/web3.db.methods.js similarity index 57% rename from db.methods.js rename to web3.db.methods.js index aac8981d2..246ecfd0b 100644 --- a/db.methods.js +++ b/web3.db.methods.js @@ -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'); diff --git a/web3.db.putHex.js b/web3.db.putHex.js new file mode 100644 index 000000000..306abaec4 --- /dev/null +++ b/web3.db.putHex.js @@ -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); + diff --git a/web3.db.putString.js b/web3.db.putString.js new file mode 100644 index 000000000..ddd32874f --- /dev/null +++ b/web3.db.putString.js @@ -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); + diff --git a/web3.eth.accounts.js b/web3.eth.accounts.js new file mode 100644 index 000000000..da7da1a96 --- /dev/null +++ b/web3.eth.accounts.js @@ -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); + }); + }); + }); +}); + diff --git a/web3.eth.blockNumber.js b/web3.eth.blockNumber.js new file mode 100644 index 000000000..dfd73f57e --- /dev/null +++ b/web3.eth.blockNumber.js @@ -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); + }); + }); + }); +}); + diff --git a/web3.eth.coinbase.js b/web3.eth.coinbase.js new file mode 100644 index 000000000..f34c53588 --- /dev/null +++ b/web3.eth.coinbase.js @@ -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); + }); + }); + }); +}); + diff --git a/eth.contract.js b/web3.eth.contract.js similarity index 99% rename from eth.contract.js rename to web3.eth.contract.js index 59ad51b29..0f2fd8640 100644 --- a/eth.contract.js +++ b/web3.eth.contract.js @@ -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 diff --git a/web3.eth.defaultBlock.js b/web3.eth.defaultBlock.js new file mode 100644 index 000000000..5fc60df47 --- /dev/null +++ b/web3.eth.defaultBlock.js @@ -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'); + }); + }); +}); + diff --git a/web3.eth.filter.js b/web3.eth.filter.js new file mode 100644 index 000000000..d8b37311a --- /dev/null +++ b/web3.eth.filter.js @@ -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); + + }); + }); + }); +}); + + diff --git a/web3.eth.filter.methods.js b/web3.eth.filter.methods.js new file mode 100644 index 000000000..f40f3d0ac --- /dev/null +++ b/web3.eth.filter.methods.js @@ -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'); + }); +}); diff --git a/web3.eth.getBalance.js b/web3.eth.getBalance.js new file mode 100644 index 000000000..e1eb73707 --- /dev/null +++ b/web3.eth.getBalance.js @@ -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); + diff --git a/web3.eth.getBlock.js b/web3.eth.getBlock.js new file mode 100644 index 000000000..539e433a6 --- /dev/null +++ b/web3.eth.getBlock.js @@ -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); + diff --git a/web3.eth.getBlockTransactionCount.js b/web3.eth.getBlockTransactionCount.js new file mode 100644 index 000000000..009b25ec5 --- /dev/null +++ b/web3.eth.getBlockTransactionCount.js @@ -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); + diff --git a/web3.eth.getBlockUncleCount.js b/web3.eth.getBlockUncleCount.js new file mode 100644 index 000000000..f8193b712 --- /dev/null +++ b/web3.eth.getBlockUncleCount.js @@ -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); diff --git a/web3.eth.getCode.js b/web3.eth.getCode.js new file mode 100644 index 000000000..fc4f5b864 --- /dev/null +++ b/web3.eth.getCode.js @@ -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); + diff --git a/web3.eth.getCompilers.js b/web3.eth.getCompilers.js new file mode 100644 index 000000000..ab426b228 --- /dev/null +++ b/web3.eth.getCompilers.js @@ -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); + diff --git a/web3.eth.getStorageAt.js b/web3.eth.getStorageAt.js new file mode 100644 index 000000000..8973772e7 --- /dev/null +++ b/web3.eth.getStorageAt.js @@ -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); + diff --git a/web3.eth.getTransaction.js b/web3.eth.getTransaction.js new file mode 100644 index 000000000..fb833edf3 --- /dev/null +++ b/web3.eth.getTransaction.js @@ -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); + diff --git a/web3.eth.getTransactionFromBlock.js b/web3.eth.getTransactionFromBlock.js new file mode 100644 index 000000000..7b59a3ba1 --- /dev/null +++ b/web3.eth.getTransactionFromBlock.js @@ -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); + diff --git a/web3.eth.getUncle.js b/web3.eth.getUncle.js new file mode 100644 index 000000000..111865355 --- /dev/null +++ b/web3.eth.getUncle.js @@ -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); diff --git a/eth.methods.js b/web3.eth.methods.js similarity index 54% rename from eth.methods.js rename to web3.eth.methods.js index e1eea1ec4..8f9396866 100644 --- a/eth.methods.js +++ b/web3.eth.methods.js @@ -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); - // }); - // }); }); - - - - diff --git a/web3.eth.mining.js b/web3.eth.mining.js new file mode 100644 index 000000000..2c111542c --- /dev/null +++ b/web3.eth.mining.js @@ -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); + }); + }); + }); +}); + diff --git a/web3.methods.js b/web3.methods.js index 92d4e1604..d37277f40 100644 --- a/web3.methods.js +++ b/web3.methods.js @@ -1,24 +1,24 @@ -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() { - u.methodExists(web3, 'sha3'); - u.methodExists(web3, 'toAscii'); - u.methodExists(web3, 'fromAscii'); - u.methodExists(web3, 'toDecimal'); - u.methodExists(web3, 'fromDecimal'); - u.methodExists(web3, 'fromWei'); - u.methodExists(web3, 'toWei'); - u.methodExists(web3, 'toBigNumber'); - u.methodExists(web3, 'isAddress'); - u.methodExists(web3, 'setProvider'); - u.methodExists(web3, 'reset'); + describe('methods', function () { + u.methodExists(web3, 'sha3'); + u.methodExists(web3, 'toAscii'); + u.methodExists(web3, 'fromAscii'); + u.methodExists(web3, 'toDecimal'); + u.methodExists(web3, 'fromDecimal'); + u.methodExists(web3, 'fromWei'); + u.methodExists(web3, 'toWei'); + u.methodExists(web3, 'toBigNumber'); + u.methodExists(web3, 'isAddress'); + 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'); + u.propertyExists(web3, 'providers'); + u.propertyExists(web3, 'eth'); + u.propertyExists(web3, 'db'); + u.propertyExists(web3, 'shh'); + }); }); diff --git a/web3.net.listening.js b/web3.net.listening.js new file mode 100644 index 000000000..38b2c8763 --- /dev/null +++ b/web3.net.listening.js @@ -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); + }); + }); + }); +}); + diff --git a/web3.net.methods.js b/web3.net.methods.js new file mode 100644 index 000000000..97fddaa12 --- /dev/null +++ b/web3.net.methods.js @@ -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'); + }); +}); diff --git a/web3.net.peerCount.js b/web3.net.peerCount.js new file mode 100644 index 000000000..eb226892a --- /dev/null +++ b/web3.net.peerCount.js @@ -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); + }); + }); + }); +}); + diff --git a/web3.sha3.js b/web3.sha3.js new file mode 100644 index 000000000..0ae104962 --- /dev/null +++ b/web3.sha3.js @@ -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); + diff --git a/shh.methods.js b/web3.shh.methods.js similarity index 65% rename from shh.methods.js rename to web3.shh.methods.js index f8501d527..fc20e1d1c 100644 --- a/shh.methods.js +++ b/web3.shh.methods.js @@ -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');