Marek Kotewicz
10 years ago
24 changed files with 1012 additions and 571 deletions
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -0,0 +1,65 @@ |
|||
/* |
|||
This file is part of ethereum.js. |
|||
|
|||
ethereum.js is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU Lesser General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
ethereum.js is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU Lesser General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU Lesser General Public License |
|||
along with ethereum.js. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file jsonrpc.js |
|||
* @authors: |
|||
* Marek Kotewicz <marek@ethdev.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
var messageId = 1; |
|||
|
|||
/// Should be called to valid json create payload object
|
|||
/// @param method of jsonrpc call, required
|
|||
/// @param params, an array of method params, optional
|
|||
/// @returns valid jsonrpc payload object
|
|||
var toPayload = function (method, params) { |
|||
if (!method) |
|||
console.error('jsonrpc method should be specified!'); |
|||
|
|||
return { |
|||
jsonrpc: '2.0', |
|||
method: method, |
|||
params: params || [], |
|||
id: messageId++ |
|||
}; |
|||
}; |
|||
|
|||
/// Should be called to check if jsonrpc response is valid
|
|||
/// @returns true if response is valid, otherwise false
|
|||
var isValidResponse = function (response) { |
|||
return !!response && |
|||
!response.error && |
|||
response.jsonrpc === '2.0' && |
|||
typeof response.id === 'number' && |
|||
(!!response.result || typeof response.result === 'boolean'); |
|||
}; |
|||
|
|||
/// Should be called to create batch payload object
|
|||
/// @param messages, an array of objects with method (required) and params (optional) fields
|
|||
var toBatchPayload = function (messages) { |
|||
return messages.map(function (message) { |
|||
return toPayload(message.method, message.params); |
|||
}); |
|||
}; |
|||
|
|||
module.exports = { |
|||
toPayload: toPayload, |
|||
isValidResponse: isValidResponse, |
|||
toBatchPayload: toBatchPayload |
|||
}; |
|||
|
|||
|
|||
@ -0,0 +1,461 @@ |
|||
var assert = require('assert'); |
|||
var BigNumber = require('bignumber.js'); |
|||
var abi = require('../lib/abi.js'); |
|||
var clone = function (object) { return JSON.parse(JSON.stringify(object)); }; |
|||
|
|||
var description = [{ |
|||
"name": "test", |
|||
"type": "function", |
|||
"inputs": [{ |
|||
"name": "a", |
|||
"type": "uint256" |
|||
} |
|||
], |
|||
"outputs": [ |
|||
{ |
|||
"name": "d", |
|||
"type": "uint256" |
|||
} |
|||
] |
|||
}]; |
|||
|
|||
describe('abi', function() { |
|||
describe('outputParser', function() { |
|||
it('should parse output string', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: "string" } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"68656c6c6f000000000000000000000000000000000000000000000000000000")[0], |
|||
'hello' |
|||
); |
|||
assert.equal( |
|||
parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"776f726c64000000000000000000000000000000000000000000000000000000")[0], |
|||
'world' |
|||
); |
|||
|
|||
}); |
|||
|
|||
it('should parse output uint', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'uint' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal( |
|||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), |
|||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
|||
); |
|||
assert.equal( |
|||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), |
|||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
|||
); |
|||
}); |
|||
|
|||
it('should parse output uint256', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'uint256' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal( |
|||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), |
|||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
|||
); |
|||
assert.equal( |
|||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), |
|||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
|||
); |
|||
}); |
|||
|
|||
it('should parse output uint128', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'uint128' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal( |
|||
parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0].toString(10), |
|||
new BigNumber("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", 16).toString(10) |
|||
); |
|||
assert.equal( |
|||
parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0].toString(10), |
|||
new BigNumber("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0", 16).toString(10) |
|||
); |
|||
}); |
|||
|
|||
it('should parse output int', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'int' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
|||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
|||
}); |
|||
|
|||
it('should parse output int256', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'int256' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
|||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
|||
}); |
|||
|
|||
it('should parse output int128', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'int128' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test("0x000000000000000000000000000000000000000000000000000000000000000a")[0], 10); |
|||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")[0], -1); |
|||
assert.equal(parser.test("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0")[0], -16); |
|||
}); |
|||
|
|||
it('should parse output hash', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'hash' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
|||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
|||
); |
|||
}); |
|||
|
|||
it('should parse output hash256', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'hash256' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
|||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
|||
); |
|||
}); |
|||
|
|||
it('should parse output hash160', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'hash160' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
|||
"0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1" |
|||
); |
|||
// TODO shouldnt' the expected hash be shorter?
|
|||
}); |
|||
|
|||
it('should parse output address', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'address' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x000000000000000000000000407d73d8a49eeb85d32cf465507dd71d507100c1")[0], |
|||
"0x407d73d8a49eeb85d32cf465507dd71d507100c1" |
|||
); |
|||
}); |
|||
|
|||
it('should parse output bool', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'bool' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000001")[0], true); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000000000000000000000000000000000000")[0], false); |
|||
|
|||
|
|||
}); |
|||
|
|||
it('should parse output real', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'real' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); |
|||
assert.equal(parser.test("0xffffffffffffffffffffffffffffffff00000000000000000000000000000000")[0], -1); |
|||
|
|||
}); |
|||
|
|||
it('should parse output ureal', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: 'ureal' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x0000000000000000000000000000000100000000000000000000000000000000")[0], 1); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000220000000000000000000000000000000")[0], 2.125); |
|||
assert.equal(parser.test("0x0000000000000000000000000000000880000000000000000000000000000000")[0], 8.5); |
|||
|
|||
}); |
|||
|
|||
|
|||
it('should parse multiple output strings', function() { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
|
|||
d[0].outputs = [ |
|||
{ type: "string" }, |
|||
{ type: "string" } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal( |
|||
parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"68656c6c6f000000000000000000000000000000000000000000000000000000" + |
|||
"776f726c64000000000000000000000000000000000000000000000000000000")[0], |
|||
'hello' |
|||
); |
|||
assert.equal( |
|||
parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"68656c6c6f000000000000000000000000000000000000000000000000000000" + |
|||
"776f726c64000000000000000000000000000000000000000000000000000000")[1], |
|||
'world' |
|||
); |
|||
|
|||
}); |
|||
|
|||
it('should use proper method name', function () { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
d[0].name = 'helloworld(int)'; |
|||
d[0].outputs = [ |
|||
{ type: "int" } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.helloworld("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.helloworld['int']("0x0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
|
|||
}); |
|||
|
|||
|
|||
it('should parse multiple methods', function () { |
|||
|
|||
// given
|
|||
var d = [{ |
|||
name: "test", |
|||
type: "function", |
|||
inputs: [{ type: "int" }], |
|||
outputs: [{ type: "int" }] |
|||
},{ |
|||
name: "test2", |
|||
type: "function", |
|||
inputs: [{ type: "string" }], |
|||
outputs: [{ type: "string" }] |
|||
}]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
//then
|
|||
assert.equal(parser.test("0000000000000000000000000000000000000000000000000000000000000001")[0], 1); |
|||
assert.equal(parser.test2("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"68656c6c6f000000000000000000000000000000000000000000000000000000")[0], |
|||
"hello" |
|||
); |
|||
|
|||
}); |
|||
|
|||
it('should parse output array', function () { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
d[0].outputs = [ |
|||
{ type: 'int[]' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000002" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"0000000000000000000000000000000000000000000000000000000000000006")[0][0], |
|||
5 |
|||
); |
|||
assert.equal(parser.test("0x" + |
|||
"0000000000000000000000000000000000000000000000000000000000000002" + |
|||
"0000000000000000000000000000000000000000000000000000000000000005" + |
|||
"0000000000000000000000000000000000000000000000000000000000000006")[0][1], |
|||
6 |
|||
); |
|||
|
|||
}); |
|||
|
|||
it('should parse 0x value', function () { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
d[0].outputs = [ |
|||
{ type: 'int' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x")[0], 0); |
|||
|
|||
}); |
|||
|
|||
it('should parse 0x value', function () { |
|||
|
|||
// given
|
|||
var d = clone(description); |
|||
d[0].outputs = [ |
|||
{ type: 'uint' } |
|||
]; |
|||
|
|||
// when
|
|||
var parser = abi.outputParser(d); |
|||
|
|||
// then
|
|||
assert.equal(parser.test("0x")[0], 0); |
|||
|
|||
}); |
|||
|
|||
}); |
|||
}); |
|||
|
|||
@ -0,0 +1,128 @@ |
|||
var assert = require('assert'); |
|||
var jsonrpc = require('../lib/jsonrpc'); |
|||
|
|||
describe('jsonrpc', function () { |
|||
describe('isValidResponse', function () { |
|||
it('should validate basic jsonrpc response', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 1, |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, true); |
|||
}); |
|||
|
|||
it('should validate basic undefined response', function () { |
|||
|
|||
// given
|
|||
var response = undefined; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response without jsonrpc field', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
id: 1, |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response with wrong jsonrpc version', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '1.0', |
|||
id: 1, |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response without id number', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response with wrong id field', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 'x', |
|||
result: [] |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response without result field', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 1 |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, false); |
|||
}); |
|||
|
|||
it('should validate jsonrpc response with result field === false', function () { |
|||
|
|||
// given
|
|||
var response = { |
|||
jsonrpc: '2.0', |
|||
id: 1, |
|||
result: false |
|||
}; |
|||
|
|||
// when
|
|||
var valid = jsonrpc.isValidResponse(response); |
|||
|
|||
// then
|
|||
assert.equal(valid, true); |
|||
}); |
|||
|
|||
}); |
|||
}); |
|||
@ -0,0 +1,47 @@ |
|||
var assert = require('assert'); |
|||
var jsonrpc = require('../lib/jsonrpc'); |
|||
|
|||
describe('jsonrpc', function () { |
|||
describe('toBatchPayload', function () { |
|||
it('should create basic batch payload', function () { |
|||
|
|||
// given
|
|||
var messages = [{ |
|||
method: 'helloworld' |
|||
}, { |
|||
method: 'test2', |
|||
params: [1] |
|||
}]; |
|||
|
|||
// when
|
|||
var payload = jsonrpc.toBatchPayload(messages); |
|||
|
|||
// then
|
|||
assert.equal(payload instanceof Array, true); |
|||
assert.equal(payload.length, 2); |
|||
assert.equal(payload[0].jsonrpc, '2.0'); |
|||
assert.equal(payload[1].jsonrpc, '2.0'); |
|||
assert.equal(payload[0].method, 'helloworld'); |
|||
assert.equal(payload[1].method, 'test2'); |
|||
assert.equal(payload[0].params instanceof Array, true); |
|||
assert.equal(payload[1].params.length, 1); |
|||
assert.equal(payload[1].params[0], 1); |
|||
assert.equal(typeof payload[0].id, 'number'); |
|||
assert.equal(typeof payload[1].id, 'number'); |
|||
assert.equal(payload[0].id + 1, payload[1].id); |
|||
}); |
|||
|
|||
it('should create batch payload for empty input array', function () { |
|||
|
|||
// given
|
|||
var messages = []; |
|||
|
|||
// when
|
|||
var payload = jsonrpc.toBatchPayload(messages); |
|||
|
|||
// then
|
|||
assert.equal(payload instanceof Array, true); |
|||
assert.equal(payload.length, 0); |
|||
}); |
|||
}); |
|||
}); |
|||
@ -0,0 +1,40 @@ |
|||
var assert = require('assert'); |
|||
var jsonrpc = require('../lib/jsonrpc'); |
|||
|
|||
describe('jsonrpc', function () { |
|||
describe('toPayload', function () { |
|||
it('should create basic payload', function () { |
|||
|
|||
// given
|
|||
var method = 'helloworld'; |
|||
|
|||
// when
|
|||
var payload = jsonrpc.toPayload(method); |
|||
|
|||
// then
|
|||
assert.equal(payload.jsonrpc, '2.0'); |
|||
assert.equal(payload.method, method); |
|||
assert.equal(payload.params instanceof Array, true); |
|||
assert.equal(payload.params.length, 0); |
|||
assert.equal(typeof payload.id, 'number'); |
|||
}); |
|||
|
|||
it('should create payload with params', function () { |
|||
|
|||
// given
|
|||
var method = 'helloworld1'; |
|||
var params = [123, 'test']; |
|||
|
|||
// when
|
|||
var payload = jsonrpc.toPayload(method, params); |
|||
|
|||
// then
|
|||
assert.equal(payload.jsonrpc, '2.0'); |
|||
assert.equal(payload.method, method); |
|||
assert.equal(payload.params.length, 2); |
|||
assert.equal(payload.params[0], params[0]); |
|||
assert.equal(payload.params[1], params[1]); |
|||
assert.equal(typeof payload.id, 'number'); |
|||
}); |
|||
}); |
|||
}); |
|||
@ -0,0 +1,42 @@ |
|||
var assert = require('assert'); |
|||
var utils = require('../lib/utils.js'); |
|||
|
|||
describe('utils', function () { |
|||
describe('extractDisplayName', function () { |
|||
it('should extract display name from method with no params', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld()'; |
|||
|
|||
// when
|
|||
var displayName = utils.extractDisplayName(test); |
|||
|
|||
// then
|
|||
assert.equal(displayName, 'helloworld'); |
|||
}); |
|||
|
|||
it('should extract display name from method with one param' , function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld1(int)'; |
|||
|
|||
// when
|
|||
var displayName = utils.extractDisplayName(test); |
|||
|
|||
// then
|
|||
assert.equal(displayName, 'helloworld1'); |
|||
}); |
|||
|
|||
it('should extract display name from method with two params' , function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld2(int,string)'; |
|||
|
|||
// when
|
|||
var displayName = utils.extractDisplayName(test); |
|||
|
|||
// then
|
|||
assert.equal(displayName, 'helloworld2'); |
|||
}); |
|||
}); |
|||
}); |
|||
@ -0,0 +1,55 @@ |
|||
var assert = require('assert'); |
|||
var utils = require('../lib/utils.js'); |
|||
|
|||
describe('utils', function () { |
|||
describe('extractTypeName', function () { |
|||
it('should extract type name from method with no params', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld()'; |
|||
|
|||
// when
|
|||
var typeName = utils.extractTypeName(test); |
|||
|
|||
// then
|
|||
assert.equal(typeName, ''); |
|||
}); |
|||
|
|||
it('should extract type name from method with one param', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld1(int)'; |
|||
|
|||
// when
|
|||
var typeName = utils.extractTypeName(test); |
|||
|
|||
// then
|
|||
assert.equal(typeName, 'int'); |
|||
}); |
|||
|
|||
it('should extract type name from method with two params', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld2(int,string)'; |
|||
|
|||
// when
|
|||
var typeName = utils.extractTypeName(test); |
|||
|
|||
// then
|
|||
assert.equal(typeName, 'int,string'); |
|||
}); |
|||
|
|||
it('should extract type name from method with spaces between params', function () { |
|||
|
|||
// given
|
|||
var test = 'helloworld3(int, string)'; |
|||
|
|||
// when
|
|||
var typeName = utils.extractTypeName(test); |
|||
|
|||
// then
|
|||
assert.equal(typeName, 'int,string'); |
|||
}); |
|||
|
|||
}); |
|||
}); |
|||
Loading…
Reference in new issue