aboutsummaryrefslogtreecommitdiffstats
path: root/rpc
diff options
context:
space:
mode:
Diffstat (limited to 'rpc')
-rw-r--r--rpc/api.go39
-rw-r--r--rpc/args.go316
-rw-r--r--rpc/args_test.go1008
-rw-r--r--rpc/messages.go16
-rw-r--r--rpc/messages_test.go9
5 files changed, 1120 insertions, 268 deletions
diff --git a/rpc/api.go b/rpc/api.go
index aa5b54199..76fa9b9df 100644
--- a/rpc/api.go
+++ b/rpc/api.go
@@ -94,10 +94,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
-
v := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Balance()
*reply = common.ToHex(v.Bytes())
case "eth_getStorage", "eth_storageAt":
@@ -106,19 +102,12 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
-
*reply = api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address).Storage()
case "eth_getStorageAt":
args := new(GetStorageAtArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
state := api.xethAtStateNum(args.BlockNumber).State().SafeGet(args.Address)
value := state.StorageString(args.Key)
@@ -130,11 +119,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- err := args.requirements()
- if err != nil {
- return err
- }
-
*reply = api.xethAtStateNum(args.BlockNumber).TxCountAt(args.Address)
case "eth_getBlockTransactionCountByHash":
args := new(GetBlockByHashArgs)
@@ -175,9 +159,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
*reply = api.xethAtStateNum(args.BlockNumber).CodeAt(args.Address)
case "eth_sendTransaction", "eth_transact":
args := new(NewTxArgs)
@@ -185,10 +166,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
-
v, err := api.xeth().Transact(args.From, args.To, args.Value.String(), args.Gas.String(), args.GasPrice.String(), args.Data)
if err != nil {
return err
@@ -279,8 +256,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return NewValidationError("Index", "does not exist")
}
- uhash := br.Uncles[args.Index].Hex()
- uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash))
+ uhash := br.Uncles[args.Index]
+ uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.Hex()))
*reply = uncle
case "eth_getUncleByBlockNumberAndIndex":
@@ -297,8 +274,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return NewValidationError("Index", "does not exist")
}
- uhash := v.Uncles[args.Index].Hex()
- uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash))
+ uhash := v.Uncles[args.Index]
+ uncle := NewBlockRes(api.xeth().EthBlockByHash(uhash.Hex()))
*reply = uncle
case "eth_getCompilers":
@@ -320,10 +297,6 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- if err := args.requirements(); err != nil {
- return err
- }
-
id := api.xeth().NewFilterString(args.Word)
*reply = common.ToHex(big.NewInt(int64(id)).Bytes())
case "eth_uninstallFilter":
@@ -359,7 +332,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
if err := json.Unmarshal(req.Params, &args); err != nil {
return err
}
- *reply = api.xeth().RemoteMining().SubmitWork(args.Nonce, args.Digest, args.Header)
+ *reply = api.xeth().RemoteMining().SubmitWork(args.Nonce, common.HexToHash(args.Digest), common.HexToHash(args.Header))
case "db_putString":
args := new(DbArgs)
if err := json.Unmarshal(req.Params, &args); err != nil {
@@ -444,7 +417,7 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
return err
}
opts := new(xeth.Options)
- opts.From = args.From
+ // opts.From = args.From
opts.To = args.To
opts.Topics = args.Topics
id := api.xeth().NewWhisperFilter(opts)
diff --git a/rpc/args.go b/rpc/args.go
index 1928ec218..65707aa37 100644
--- a/rpc/args.go
+++ b/rpc/args.go
@@ -3,14 +3,22 @@ package rpc
import (
"bytes"
"encoding/json"
- "errors"
- "fmt"
+ // "errors"
+ // "fmt"
"math/big"
"github.com/ethereum/go-ethereum/common"
)
-func blockHeight(raw interface{}, number *int64) (err error) {
+func blockHeightFromJson(msg json.RawMessage, number *int64) error {
+ var raw interface{}
+ if err := json.Unmarshal(msg, &raw); err != nil {
+ return NewDecodeParamError(err.Error())
+ }
+ return blockHeight(raw, number)
+}
+
+func blockHeight(raw interface{}, number *int64) error {
// Parse as integer
num, ok := raw.(float64)
if ok {
@@ -21,7 +29,7 @@ func blockHeight(raw interface{}, number *int64) (err error) {
// Parse as string/hexstring
str, ok := raw.(string)
if !ok {
- return NewDecodeParamError("BlockNumber is not a string")
+ return NewInvalidTypeError("blockNumber", "not a number or string")
}
switch str {
@@ -36,26 +44,44 @@ func blockHeight(raw interface{}, number *int64) (err error) {
return nil
}
-func toNumber(v interface{}) (int64, error) {
- var str string
- if v != nil {
- var ok bool
- str, ok = v.(string)
- if !ok {
- return 0, errors.New("is not a string or undefined")
- }
- } else {
- str = "latest"
+func numString(raw interface{}, number *int64) error {
+ // Parse as integer
+ num, ok := raw.(float64)
+ if ok {
+ *number = int64(num)
+ return nil
}
- switch str {
- case "latest":
- return -1, nil
- default:
- return int64(common.Big(v.(string)).Int64()), nil
+ // Parse as string/hexstring
+ str, ok := raw.(string)
+ if !ok {
+ return NewInvalidTypeError("", "not a number or string")
}
+ *number = common.String2Big(str).Int64()
+
+ return nil
}
+// func toNumber(v interface{}) (int64, error) {
+// var str string
+// if v != nil {
+// var ok bool
+// str, ok = v.(string)
+// if !ok {
+// return 0, errors.New("is not a string or undefined")
+// }
+// } else {
+// str = "latest"
+// }
+
+// switch str {
+// case "latest":
+// return -1, nil
+// default:
+// return int64(common.Big(v.(string)).Int64()), nil
+// }
+// }
+
type GetBlockByHashArgs struct {
BlockHash string
IncludeTxs bool
@@ -74,7 +100,7 @@ func (args *GetBlockByHashArgs) UnmarshalJSON(b []byte) (err error) {
argstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("BlockHash not a string")
+ return NewInvalidTypeError("blockHash", "not a string")
}
args.BlockHash = argstr
@@ -103,8 +129,10 @@ func (args *GetBlockByNumberArgs) UnmarshalJSON(b []byte) (err error) {
if v, ok := obj[0].(float64); ok {
args.BlockNumber = int64(v)
+ } else if v, ok := obj[0].(string); ok {
+ args.BlockNumber = common.Big(v).Int64()
} else {
- args.BlockNumber = common.Big(obj[0].(string)).Int64()
+ return NewInvalidTypeError("blockNumber", "not a number or string")
}
if len(obj) > 1 {
@@ -144,7 +172,10 @@ func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
return NewDecodeParamError(err.Error())
}
- // var ok bool
+ if len(ext.From) == 0 {
+ return NewValidationError("from", "is required")
+ }
+
args.From = ext.From
args.To = ext.To
args.Value = common.String2Big(ext.Value)
@@ -154,12 +185,7 @@ func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
// Check for optional BlockNumber param
if len(obj) > 1 {
- var raw interface{}
- if err = json.Unmarshal(obj[1], &raw); err != nil {
- return NewDecodeParamError(err.Error())
- }
-
- if err := blockHeight(raw, &args.BlockNumber); err != nil {
+ if err := blockHeightFromJson(obj[1], &args.BlockNumber); err != nil {
return err
}
}
@@ -167,13 +193,6 @@ func (args *NewTxArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *NewTxArgs) requirements() error {
- if len(args.From) == 0 {
- return NewValidationError("From", "Is required")
- }
- return nil
-}
-
type GetStorageArgs struct {
Address string
BlockNumber int64
@@ -191,7 +210,7 @@ func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
@@ -204,13 +223,6 @@ func (args *GetStorageArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetStorageArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
- return nil
-}
-
type GetStorageAtArgs struct {
Address string
Key string
@@ -229,13 +241,13 @@ func (args *GetStorageAtArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
keystr, ok := obj[1].(string)
if !ok {
- return NewDecodeParamError("Key is not a string")
+ return NewInvalidTypeError("key", "not a string")
}
args.Key = keystr
@@ -248,17 +260,6 @@ func (args *GetStorageAtArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetStorageAtArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
-
- if len(args.Key) == 0 {
- return NewValidationError("Key", "cannot be blank")
- }
- return nil
-}
-
type GetTxCountArgs struct {
Address string
BlockNumber int64
@@ -276,7 +277,7 @@ func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
@@ -289,13 +290,6 @@ func (args *GetTxCountArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetTxCountArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
- return nil
-}
-
type GetBalanceArgs struct {
Address string
BlockNumber int64
@@ -313,7 +307,7 @@ func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
@@ -326,13 +320,6 @@ func (args *GetBalanceArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetBalanceArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
- return nil
-}
-
type GetDataArgs struct {
Address string
BlockNumber int64
@@ -350,7 +337,7 @@ func (args *GetDataArgs) UnmarshalJSON(b []byte) (err error) {
addstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Address is not a string")
+ return NewInvalidTypeError("address", "not a string")
}
args.Address = addstr
@@ -363,13 +350,6 @@ func (args *GetDataArgs) UnmarshalJSON(b []byte) (err error) {
return nil
}
-func (args *GetDataArgs) requirements() error {
- if len(args.Address) == 0 {
- return NewValidationError("Address", "cannot be blank")
- }
- return nil
-}
-
type BlockNumIndexArgs struct {
BlockNumber int64
Index int64
@@ -386,16 +366,14 @@ func (args *BlockNumIndexArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- arg0, ok := obj[0].(string)
- if !ok {
- return NewDecodeParamError("BlockNumber is not string")
+ if err := blockHeight(obj[0], &args.BlockNumber); err != nil {
+ return err
}
- args.BlockNumber = common.Big(arg0).Int64()
if len(obj) > 1 {
arg1, ok := obj[1].(string)
if !ok {
- return NewDecodeParamError("Index not a string")
+ return NewInvalidTypeError("index", "not a string")
}
args.Index = common.Big(arg1).Int64()
}
@@ -421,14 +399,14 @@ func (args *HashIndexArgs) UnmarshalJSON(b []byte) (err error) {
arg0, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Hash not a string")
+ return NewInvalidTypeError("hash", "not a string")
}
args.Hash = arg0
if len(obj) > 1 {
arg1, ok := obj[1].(string)
if !ok {
- return NewDecodeParamError("Index not a string")
+ return NewInvalidTypeError("index", "not a string")
}
args.Index = common.Big(arg1).Int64()
}
@@ -450,8 +428,12 @@ func (args *Sha3Args) UnmarshalJSON(b []byte) (err error) {
if len(obj) < 1 {
return NewInsufficientParamsError(len(obj), 1)
}
- args.Data = obj[0].(string)
+ argstr, ok := obj[0].(string)
+ if !ok {
+ return NewInvalidTypeError("data", "is not a string")
+ }
+ args.Data = argstr
return nil
}
@@ -468,8 +450,8 @@ func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
var obj []struct {
FromBlock interface{} `json:"fromBlock"`
ToBlock interface{} `json:"toBlock"`
- Limit string `json:"limit"`
- Offset string `json:"offset"`
+ Limit interface{} `json:"limit"`
+ Offset interface{} `json:"offset"`
Address string `json:"address"`
Topics []interface{} `json:"topics"`
}
@@ -482,17 +464,40 @@ func (args *BlockFilterArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- args.Earliest, err = toNumber(obj[0].ToBlock)
- if err != nil {
- return NewDecodeParamError(fmt.Sprintf("FromBlock %v", err))
+ // args.Earliest, err = toNumber(obj[0].ToBlock)
+ // if err != nil {
+ // return NewDecodeParamError(fmt.Sprintf("FromBlock %v", err))
+ // }
+ // args.Latest, err = toNumber(obj[0].FromBlock)
+ // if err != nil {
+ // return NewDecodeParamError(fmt.Sprintf("ToBlock %v", err))
+
+ var num int64
+ if err := blockHeight(obj[0].FromBlock, &num); err != nil {
+ return err
+ }
+ if num < 0 {
+ args.Earliest = -1 //latest block
+ } else {
+ args.Earliest = num
+ }
+
+ if err := blockHeight(obj[0].ToBlock, &num); err != nil {
+ return err
}
- args.Latest, err = toNumber(obj[0].FromBlock)
- if err != nil {
- return NewDecodeParamError(fmt.Sprintf("ToBlock %v", err))
+ args.Latest = num
+
+ if err := numString(obj[0].Limit, &num); err != nil {
+ return err
}
+ args.Max = int(num)
+
+ if err := numString(obj[0].Offset, &num); err != nil {
+ return err
+
+ }
+ args.Skip = int(num)
- args.Max = int(common.Big(obj[0].Limit).Int64())
- args.Skip = int(common.Big(obj[0].Offset).Int64())
args.Address = obj[0].Address
args.Topics = obj[0].Topics
@@ -519,19 +524,19 @@ func (args *DbArgs) UnmarshalJSON(b []byte) (err error) {
var ok bool
if objstr, ok = obj[0].(string); !ok {
- return NewDecodeParamError("Database is not a string")
+ return NewInvalidTypeError("database", "not a string")
}
args.Database = objstr
if objstr, ok = obj[1].(string); !ok {
- return NewDecodeParamError("Key is not a string")
+ return NewInvalidTypeError("key", "not a string")
}
args.Key = objstr
if len(obj) > 2 {
objstr, ok = obj[2].(string)
if !ok {
- return NewDecodeParamError("Value is not a string")
+ return NewInvalidTypeError("value", "not a string")
}
args.Value = []byte(objstr)
@@ -570,19 +575,19 @@ func (args *DbHexArgs) UnmarshalJSON(b []byte) (err error) {
var ok bool
if objstr, ok = obj[0].(string); !ok {
- return NewDecodeParamError("Database is not a string")
+ return NewInvalidTypeError("database", "not a string")
}
args.Database = objstr
if objstr, ok = obj[1].(string); !ok {
- return NewDecodeParamError("Key is not a string")
+ return NewInvalidTypeError("key", "not a string")
}
args.Key = objstr
if len(obj) > 2 {
objstr, ok = obj[2].(string)
if !ok {
- return NewDecodeParamError("Value is not a string")
+ return NewInvalidTypeError("value", "not a string")
}
args.Value = common.FromHex(objstr)
@@ -616,8 +621,8 @@ func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) {
To string
From string
Topics []string
- Priority string
- Ttl string
+ Priority interface{}
+ Ttl interface{}
}
if err = json.Unmarshal(b, &obj); err != nil {
@@ -631,8 +636,17 @@ func (args *WhisperMessageArgs) UnmarshalJSON(b []byte) (err error) {
args.To = obj[0].To
args.From = obj[0].From
args.Topics = obj[0].Topics
- args.Priority = uint32(common.Big(obj[0].Priority).Int64())
- args.Ttl = uint32(common.Big(obj[0].Ttl).Int64())
+
+ var num int64
+ if err := numString(obj[0].Priority, &num); err != nil {
+ return err
+ }
+ args.Priority = uint32(num)
+
+ if err := numString(obj[0].Ttl, &num); err != nil {
+ return err
+ }
+ args.Ttl = uint32(num)
return nil
}
@@ -643,14 +657,18 @@ type CompileArgs struct {
func (args *CompileArgs) UnmarshalJSON(b []byte) (err error) {
var obj []interface{}
- r := bytes.NewReader(b)
- if err := json.NewDecoder(r).Decode(&obj); err != nil {
+ if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
- if len(obj) > 0 {
- args.Source = obj[0].(string)
+ if len(obj) < 1 {
+ return NewInsufficientParamsError(len(obj), 1)
+ }
+ argstr, ok := obj[0].(string)
+ if !ok {
+ return NewInvalidTypeError("arg0", "is not a string")
}
+ args.Source = argstr
return nil
}
@@ -673,20 +691,15 @@ func (args *FilterStringArgs) UnmarshalJSON(b []byte) (err error) {
var argstr string
argstr, ok := obj[0].(string)
if !ok {
- return NewDecodeParamError("Filter is not a string")
+ return NewInvalidTypeError("filter", "not a string")
}
- args.Word = argstr
-
- return nil
-}
-
-func (args *FilterStringArgs) requirements() error {
- switch args.Word {
+ switch argstr {
case "latest", "pending":
break
default:
return NewValidationError("Word", "Must be `latest` or `pending`")
}
+ args.Word = argstr
return nil
}
@@ -695,9 +708,8 @@ type FilterIdArgs struct {
}
func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) {
- var obj []string
- r := bytes.NewReader(b)
- if err := json.NewDecoder(r).Decode(&obj); err != nil {
+ var obj []interface{}
+ if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
@@ -705,7 +717,11 @@ func (args *FilterIdArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- args.Id = int(common.Big(obj[0]).Int64())
+ var num int64
+ if err := numString(obj[0], &num); err != nil {
+ return err
+ }
+ args.Id = int(num)
return nil
}
@@ -715,9 +731,8 @@ type WhisperIdentityArgs struct {
}
func (args *WhisperIdentityArgs) UnmarshalJSON(b []byte) (err error) {
- var obj []string
- r := bytes.NewReader(b)
- if err := json.NewDecoder(r).Decode(&obj); err != nil {
+ var obj []interface{}
+ if err := json.Unmarshal(b, &obj); err != nil {
return NewDecodeParamError(err.Error())
}
@@ -725,7 +740,14 @@ func (args *WhisperIdentityArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- args.Identity = obj[0]
+ argstr, ok := obj[0].(string)
+ if !ok {
+ return NewInvalidTypeError("arg0", "not a string")
+ }
+ // if !common.IsHex(argstr) {
+ // return NewValidationError("arg0", "not a hexstring")
+ // }
+ args.Identity = argstr
return nil
}
@@ -738,9 +760,8 @@ type WhisperFilterArgs struct {
func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
var obj []struct {
- To string
- From string
- Topics []string
+ To interface{}
+ Topics []interface{}
}
if err = json.Unmarshal(b, &obj); err != nil {
@@ -751,17 +772,30 @@ func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) {
return NewInsufficientParamsError(len(obj), 1)
}
- args.To = obj[0].To
- args.From = obj[0].From
- args.Topics = obj[0].Topics
+ var argstr string
+ argstr, ok := obj[0].To.(string)
+ if !ok {
+ return NewInvalidTypeError("to", "is not a string")
+ }
+ args.To = argstr
+
+ t := make([]string, len(obj[0].Topics))
+ for i, j := range obj[0].Topics {
+ argstr, ok := j.(string)
+ if !ok {
+ return NewInvalidTypeError("topics["+string(i)+"]", "is not a string")
+ }
+ t[i] = argstr
+ }
+ args.Topics = t
return nil
}
type SubmitWorkArgs struct {
Nonce uint64
- Header common.Hash
- Digest common.Hash
+ Header string
+ Digest string
}
func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) {
@@ -777,21 +811,21 @@ func (args *SubmitWorkArgs) UnmarshalJSON(b []byte) (err error) {
var objstr string
var ok bool
if objstr, ok = obj[0].(string); !ok {
- return NewDecodeParamError("Nonce is not a string")
+ return NewInvalidTypeError("nonce", "not a string")
}
args.Nonce = common.String2Big(objstr).Uint64()
if objstr, ok = obj[1].(string); !ok {
- return NewDecodeParamError("Header is not a string")
+ return NewInvalidTypeError("header", "not a string")
}
- args.Header = common.HexToHash(objstr)
+ args.Header = objstr
if objstr, ok = obj[2].(string); !ok {
- return NewDecodeParamError("Digest is not a string")
+ return NewInvalidTypeError("digest", "not a string")
}
- args.Digest = common.HexToHash(objstr)
+ args.Digest = objstr
return nil
}
diff --git a/rpc/args_test.go b/rpc/args_test.go
index 5cbafd4b2..c5d407c97 100644
--- a/rpc/args_test.go
+++ b/rpc/args_test.go
@@ -3,12 +3,63 @@ package rpc
import (
"bytes"
"encoding/json"
+ "fmt"
"math/big"
"testing"
-
- "github.com/ethereum/go-ethereum/common"
)
+func ExpectValidationError(err error) string {
+ var str string
+ switch err.(type) {
+ case nil:
+ str = "Expected error but didn't get one"
+ case *ValidationError:
+ break
+ default:
+ str = fmt.Sprintf("Expected *rpc.ValidationError but got %T with message `%s`", err, err.Error())
+ }
+ return str
+}
+
+func ExpectInvalidTypeError(err error) string {
+ var str string
+ switch err.(type) {
+ case nil:
+ str = "Expected error but didn't get one"
+ case *InvalidTypeError:
+ break
+ default:
+ str = fmt.Sprintf("Expected *rpc.InvalidTypeError but got %T with message `%s`", err, err.Error())
+ }
+ return str
+}
+
+func ExpectInsufficientParamsError(err error) string {
+ var str string
+ switch err.(type) {
+ case nil:
+ str = "Expected error but didn't get one"
+ case *InsufficientParamsError:
+ break
+ default:
+ str = fmt.Sprintf("Expected *rpc.InsufficientParamsError but got %T with message %s", err, err.Error())
+ }
+ return str
+}
+
+func ExpectDecodeParamError(err error) string {
+ var str string
+ switch err.(type) {
+ case nil:
+ str = "Expected error but didn't get one"
+ case *DecodeParamError:
+ break
+ default:
+ str = fmt.Sprintf("Expected *rpc.DecodeParamError but got %T with message `%s`", err, err.Error())
+ }
+ return str
+}
+
func TestSha3(t *testing.T) {
input := `["0x68656c6c6f20776f726c64"]`
expected := "0x68656c6c6f20776f726c64"
@@ -21,6 +72,35 @@ func TestSha3(t *testing.T) {
}
}
+func TestSha3ArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(Sha3Args)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestSha3ArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(Sha3Args)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+func TestSha3ArgsDataInvalid(t *testing.T) {
+ input := `[4]`
+
+ args := new(Sha3Args)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestGetBalanceArgs(t *testing.T) {
input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x1f"]`
expected := new(GetBalanceArgs)
@@ -32,10 +112,6 @@ func TestGetBalanceArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if args.Address != expected.Address {
t.Errorf("Address should be %v but is %v", expected.Address, args.Address)
}
@@ -56,10 +132,6 @@ func TestGetBalanceArgsLatest(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if args.Address != expected.Address {
t.Errorf("Address should be %v but is %v", expected.Address, args.Address)
}
@@ -69,15 +141,49 @@ func TestGetBalanceArgsLatest(t *testing.T) {
}
}
-func TestGetBalanceEmptyArgs(t *testing.T) {
+func TestGetBalanceArgsEmpty(t *testing.T) {
input := `[]`
args := new(GetBalanceArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBalanceArgsInvalid(t *testing.T) {
+ input := `6`
+
+ args := new(GetBalanceArgs)
err := json.Unmarshal([]byte(input), &args)
- if err == nil {
+ switch err.(type) {
+ case nil:
t.Error("Expected error but didn't get one")
+ case *DecodeParamError:
+ break
+ default:
+ t.Errorf("Expected *rpc.DecodeParamError but got %T with message %s", err, err.Error())
+ }
+}
+
+func TestGetBalanceArgsBlockInvalid(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", false]`
+
+ args := new(GetBalanceArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
+}
+
+func TestGetBalanceArgsAddressInvalid(t *testing.T) {
+ input := `[-9, "latest"]`
+ args := new(GetBalanceArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
}
func TestGetBlockByHashArgs(t *testing.T) {
@@ -100,17 +206,57 @@ func TestGetBlockByHashArgs(t *testing.T) {
}
}
-func TestGetBlockByHashEmpty(t *testing.T) {
+func TestGetBlockByHashArgsEmpty(t *testing.T) {
input := `[]`
args := new(GetBlockByHashArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBlockByHashArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(GetBlockByHashArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBlockByHashArgsHashInt(t *testing.T) {
+ input := `[8]`
+
+ args := new(GetBlockByHashArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
-func TestGetBlockByNumberArgs(t *testing.T) {
+func TestGetBlockByNumberArgsBlockNum(t *testing.T) {
+ input := `[436, false]`
+ expected := new(GetBlockByNumberArgs)
+ expected.BlockNumber = 436
+ expected.IncludeTxs = false
+
+ args := new(GetBlockByNumberArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err)
+ }
+
+ if args.BlockNumber != expected.BlockNumber {
+ t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
+ }
+
+ if args.IncludeTxs != expected.IncludeTxs {
+ t.Errorf("IncludeTxs should be %v but is %v", expected.IncludeTxs, args.IncludeTxs)
+ }
+}
+
+func TestGetBlockByNumberArgsBlockHex(t *testing.T) {
input := `["0x1b4", false]`
expected := new(GetBlockByNumberArgs)
expected.BlockNumber = 436
@@ -122,7 +268,7 @@ func TestGetBlockByNumberArgs(t *testing.T) {
}
if args.BlockNumber != expected.BlockNumber {
- t.Errorf("BlockHash should be %v but is %v", expected.BlockNumber, args.BlockNumber)
+ t.Errorf("BlockNumber should be %v but is %v", expected.BlockNumber, args.BlockNumber)
}
if args.IncludeTxs != expected.IncludeTxs {
@@ -134,9 +280,28 @@ func TestGetBlockByNumberEmpty(t *testing.T) {
input := `[]`
args := new(GetBlockByNumberArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetBlockByNumberBool(t *testing.T) {
+ input := `[true, true]`
+
+ args := new(GetBlockByNumberArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+func TestGetBlockByNumberBlockObject(t *testing.T) {
+ input := `{}`
+
+ args := new(GetBlockByNumberArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -211,41 +376,60 @@ func TestNewTxArgsBlockInt(t *testing.T) {
}
}
+func TestNewTxArgsBlockInvalid(t *testing.T) {
+ input := `[{"from": "0xb60e8dd61c5d32be8058bb8eb970870f07233155"}, false]`
+ expected := new(NewTxArgs)
+ expected.From = "0xb60e8dd61c5d32be8058bb8eb970870f07233155"
+ expected.BlockNumber = big.NewInt(5).Int64()
+
+ args := new(NewTxArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestNewTxArgsEmpty(t *testing.T) {
input := `[]`
args := new(NewTxArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
-func TestNewTxArgsReqs(t *testing.T) {
- args := new(NewTxArgs)
- args.From = "0xb60e8dd61c5d32be8058bb8eb970870f07233155"
+func TestNewTxArgsInvalid(t *testing.T) {
+ input := `{}`
- err := args.requirements()
- switch err.(type) {
- case nil:
- break
- default:
- t.Errorf("Get %T", err)
+ args := new(NewTxArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
+func TestNewTxArgsNotStrings(t *testing.T) {
+ input := `[{"from":6}]`
-func TestNewTxArgsReqsFromBlank(t *testing.T) {
args := new(NewTxArgs)
- args.From = ""
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestNewTxArgsFromEmpty(t *testing.T) {
+ input := `[{"to": "0xb60e8dd61c5d32be8058bb8eb970870f07233155"}]`
- err := args.requirements()
+ args := new(NewTxArgs)
+ err := json.Unmarshal([]byte(input), &args)
switch err.(type) {
case nil:
t.Error("Expected error but didn't get one")
case *ValidationError:
break
default:
- t.Error("Wrong type of error")
+ t.Errorf("Expected *rpc.ValidationError, but got %T with message `%s`", err, err.Error())
}
}
@@ -260,10 +444,6 @@ func TestGetStorageArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Address != args.Address {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
@@ -273,13 +453,43 @@ func TestGetStorageArgs(t *testing.T) {
}
}
+func TestGetStorageInvalidArgs(t *testing.T) {
+ input := `{}`
+
+ args := new(GetStorageArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageInvalidBlockheight(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", {}]`
+
+ args := new(GetStorageArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestGetStorageEmptyArgs(t *testing.T) {
input := `[]`
args := new(GetStorageArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAddressInt(t *testing.T) {
+ input := `[32456785432456, "latest"]`
+
+ args := new(GetStorageArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -295,10 +505,6 @@ func TestGetStorageAtArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Address != args.Address {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
@@ -316,27 +522,63 @@ func TestGetStorageAtEmptyArgs(t *testing.T) {
input := `[]`
args := new(GetStorageAtArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAtArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(GetStorageAtArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAtArgsAddressNotString(t *testing.T) {
+ input := `[true, "0x0", "0x2"]`
+
+ args := new(GetStorageAtArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAtArgsKeyNotString(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", true, "0x2"]`
+
+ args := new(GetStorageAtArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetStorageAtArgsValueNotString(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "0x1", true]`
+
+ args := new(GetStorageAtArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
func TestGetTxCountArgs(t *testing.T) {
- input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "latest"]`
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", "pending"]`
expected := new(GetTxCountArgs)
expected.Address = "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
- expected.BlockNumber = -1
+ expected.BlockNumber = -2
args := new(GetTxCountArgs)
if err := json.Unmarshal([]byte(input), &args); err != nil {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Address != args.Address {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
@@ -350,9 +592,39 @@ func TestGetTxCountEmptyArgs(t *testing.T) {
input := `[]`
args := new(GetTxCountArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetTxCountEmptyArgsInvalid(t *testing.T) {
+ input := `false`
+
+ args := new(GetTxCountArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetTxCountAddressNotString(t *testing.T) {
+ input := `[false, "pending"]`
+
+ args := new(GetTxCountArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetTxCountBlockheightInvalid(t *testing.T) {
+ input := `["0x407d73d8a49eeb85d32cf465507dd71d507100c1", {}]`
+
+ args := new(GetTxCountArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -367,10 +639,6 @@ func TestGetDataArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Address != args.Address {
t.Errorf("Address shoud be %#v but is %#v", expected.Address, args.Address)
}
@@ -380,13 +648,43 @@ func TestGetDataArgs(t *testing.T) {
}
}
-func TestGetDataEmptyArgs(t *testing.T) {
+func TestGetDataArgsEmpty(t *testing.T) {
input := `[]`
args := new(GetDataArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetDataArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(GetDataArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetDataArgsAddressNotString(t *testing.T) {
+ input := `[12, "latest"]`
+
+ args := new(GetDataArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestGetDataArgsBlocknumberNotString(t *testing.T) {
+ input := `["0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8", false]`
+
+ args := new(GetDataArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
}
@@ -437,6 +735,7 @@ func TestBlockFilterArgs(t *testing.T) {
}
func TestBlockFilterArgsWords(t *testing.T) {
+ t.Skip()
input := `[{
"fromBlock": "latest",
"toBlock": "pending"
@@ -459,21 +758,17 @@ func TestBlockFilterArgsWords(t *testing.T) {
}
}
-func TestBlockFilterArgsNums(t *testing.T) {
+func TestBlockFilterArgsBool(t *testing.T) {
input := `[{
- "fromBlock": 2,
- "toBlock": 3
+ "fromBlock": true,
+ "toBlock": false
}]`
args := new(BlockFilterArgs)
- err := json.Unmarshal([]byte(input), &args)
- switch err.(type) {
- case *DecodeParamError:
- break
- default:
- t.Errorf("Should have *DecodeParamError but instead have %T", err)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
}
-
}
func TestBlockFilterArgsEmptyArgs(t *testing.T) {
@@ -515,6 +810,84 @@ func TestDbArgs(t *testing.T) {
}
}
+func TestDbArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(DbArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(DbArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsDatabaseType(t *testing.T) {
+ input := `[true, "keyval", "valval"]`
+
+ args := new(DbArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsKeyType(t *testing.T) {
+ input := `["dbval", 3, "valval"]`
+
+ args := new(DbArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsValType(t *testing.T) {
+ input := `["dbval", "keyval", {}]`
+
+ args := new(DbArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsDatabaseEmpty(t *testing.T) {
+ input := `["", "keyval", "valval"]`
+
+ args := new(DbArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err.Error())
+ }
+
+ str := ExpectValidationError(args.requirements())
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbArgsKeyEmpty(t *testing.T) {
+ input := `["dbval", "", "valval"]`
+
+ args := new(DbArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err.Error())
+ }
+
+ str := ExpectValidationError(args.requirements())
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestDbHexArgs(t *testing.T) {
input := `["testDB","myKey","0xbeef"]`
expected := new(DbHexArgs)
@@ -544,6 +917,84 @@ func TestDbHexArgs(t *testing.T) {
}
}
+func TestDbHexArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(DbHexArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(DbHexArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsDatabaseType(t *testing.T) {
+ input := `[true, "keyval", "valval"]`
+
+ args := new(DbHexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsKeyType(t *testing.T) {
+ input := `["dbval", 3, "valval"]`
+
+ args := new(DbHexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsValType(t *testing.T) {
+ input := `["dbval", "keyval", {}]`
+
+ args := new(DbHexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsDatabaseEmpty(t *testing.T) {
+ input := `["", "keyval", "valval"]`
+
+ args := new(DbHexArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err.Error())
+ }
+
+ str := ExpectValidationError(args.requirements())
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestDbHexArgsKeyEmpty(t *testing.T) {
+ input := `["dbval", "", "valval"]`
+
+ args := new(DbHexArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err.Error())
+ }
+
+ str := ExpectValidationError(args.requirements())
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestWhisperMessageArgs(t *testing.T) {
input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
"topics": ["0x68656c6c6f20776f726c64"],
@@ -556,7 +1007,7 @@ func TestWhisperMessageArgs(t *testing.T) {
expected.Payload = "0x68656c6c6f20776f726c64"
expected.Priority = 100
expected.Ttl = 100
- expected.Topics = []string{"0x68656c6c6f20776f726c64"}
+ // expected.Topics = []string{"0x68656c6c6f20776f726c64"}
args := new(WhisperMessageArgs)
if err := json.Unmarshal([]byte(input), &args); err != nil {
@@ -588,6 +1039,96 @@ func TestWhisperMessageArgs(t *testing.T) {
// }
}
+func TestWhisperMessageArgsInt(t *testing.T) {
+ input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
+ "topics": ["0x68656c6c6f20776f726c64"],
+ "payload":"0x68656c6c6f20776f726c64",
+ "ttl": 12,
+ "priority": 16}]`
+ expected := new(WhisperMessageArgs)
+ expected.From = "0xc931d93e97ab07fe42d923478ba2465f2"
+ expected.To = ""
+ expected.Payload = "0x68656c6c6f20776f726c64"
+ expected.Priority = 16
+ expected.Ttl = 12
+ // expected.Topics = []string{"0x68656c6c6f20776f726c64"}
+
+ args := new(WhisperMessageArgs)
+ if err := json.Unmarshal([]byte(input), &args); err != nil {
+ t.Error(err)
+ }
+
+ if expected.From != args.From {
+ t.Errorf("From shoud be %#v but is %#v", expected.From, args.From)
+ }
+
+ if expected.To != args.To {
+ t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
+ }
+
+ if expected.Payload != args.Payload {
+ t.Errorf("Value shoud be %#v but is %#v", expected.Payload, args.Payload)
+ }
+
+ if expected.Ttl != args.Ttl {
+ t.Errorf("Ttl shoud be %v but is %v", expected.Ttl, args.Ttl)
+ }
+
+ if expected.Priority != args.Priority {
+ t.Errorf("Priority shoud be %v but is %v", expected.Priority, args.Priority)
+ }
+
+ // if expected.Topics != args.Topics {
+ // t.Errorf("Topic shoud be %#v but is %#v", expected.Topic, args.Topic)
+ // }
+}
+
+func TestWhisperMessageArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(WhisperMessageArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperMessageArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(WhisperMessageArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperMessageArgsTtlBool(t *testing.T) {
+ input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
+ "topics": ["0x68656c6c6f20776f726c64"],
+ "payload":"0x68656c6c6f20776f726c64",
+ "ttl": true,
+ "priority": "0x64"}]`
+ args := new(WhisperMessageArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperMessageArgsPriorityBool(t *testing.T) {
+ input := `[{"from":"0xc931d93e97ab07fe42d923478ba2465f2",
+ "topics": ["0x68656c6c6f20776f726c64"],
+ "payload":"0x68656c6c6f20776f726c64",
+ "ttl": "0x12",
+ "priority": true}]`
+ args := new(WhisperMessageArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestFilterIdArgs(t *testing.T) {
input := `["0x7"]`
expected := new(FilterIdArgs)
@@ -603,10 +1144,39 @@ func TestFilterIdArgs(t *testing.T) {
}
}
-func TestWhsiperFilterArgs(t *testing.T) {
+func TestFilterIdArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(FilterIdArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterIdArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(FilterIdArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterIdArgsBool(t *testing.T) {
+ input := `[true]`
+
+ args := new(FilterIdArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestWhisperFilterArgs(t *testing.T) {
input := `[{"topics": ["0x68656c6c6f20776f726c64"], "to": "0x34ag445g3455b34"}]`
expected := new(WhisperFilterArgs)
- expected.From = ""
expected.To = "0x34ag445g3455b34"
expected.Topics = []string{"0x68656c6c6f20776f726c64"}
@@ -615,10 +1185,6 @@ func TestWhsiperFilterArgs(t *testing.T) {
t.Error(err)
}
- if expected.From != args.From {
- t.Errorf("From shoud be %#v but is %#v", expected.From, args.From)
- }
-
if expected.To != args.To {
t.Errorf("To shoud be %#v but is %#v", expected.To, args.To)
}
@@ -628,6 +1194,46 @@ func TestWhsiperFilterArgs(t *testing.T) {
// }
}
+func TestWhisperFilterArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperFilterArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperFilterArgsToBool(t *testing.T) {
+ input := `[{"topics": ["0x68656c6c6f20776f726c64"], "to": false}]`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestWhisperFilterArgsTopicInt(t *testing.T) {
+ input := `[{"topics": [6], "to": "0x34ag445g3455b34"}]`
+
+ args := new(WhisperFilterArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestCompileArgs(t *testing.T) {
input := `["contract test { function multiply(uint a) returns(uint d) { return a * 7; } }"]`
expected := new(CompileArgs)
@@ -643,6 +1249,36 @@ func TestCompileArgs(t *testing.T) {
}
}
+func TestCompileArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(CompileArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestCompileArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(CompileArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestCompileArgsBool(t *testing.T) {
+ input := `[false]`
+
+ args := new(CompileArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestFilterStringArgs(t *testing.T) {
input := `["pending"]`
expected := new(FilterStringArgs)
@@ -653,10 +1289,6 @@ func TestFilterStringArgs(t *testing.T) {
t.Error(err)
}
- if err := args.requirements(); err != nil {
- t.Error(err)
- }
-
if expected.Word != args.Word {
t.Errorf("Word shoud be %#v but is %#v", expected.Word, args.Word)
}
@@ -666,9 +1298,39 @@ func TestFilterStringEmptyArgs(t *testing.T) {
input := `[]`
args := new(FilterStringArgs)
- err := json.Unmarshal([]byte(input), &args)
- if err == nil {
- t.Error("Expected error but didn't get one")
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterStringInvalidArgs(t *testing.T) {
+ input := `{}`
+
+ args := new(FilterStringArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterStringWordInt(t *testing.T) {
+ input := `[7]`
+
+ args := new(FilterStringArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestFilterStringWordWrong(t *testing.T) {
+ input := `["foo"]`
+
+ args := new(FilterStringArgs)
+ str := ExpectValidationError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
}
}
@@ -687,6 +1349,36 @@ func TestWhisperIdentityArgs(t *testing.T) {
}
}
+func TestWhisperIdentityArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(WhisperIdentityArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestWhisperIdentityArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(WhisperIdentityArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
+func TestWhisperIdentityArgsInt(t *testing.T) {
+ input := `[4]`
+
+ args := new(WhisperIdentityArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Errorf(str)
+ }
+}
+
func TestBlockNumIndexArgs(t *testing.T) {
input := `["0x29a", "0x0"]`
expected := new(BlockNumIndexArgs)
@@ -707,6 +1399,46 @@ func TestBlockNumIndexArgs(t *testing.T) {
}
}
+func TestBlockNumIndexArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(BlockNumIndexArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockNumIndexArgsInvalid(t *testing.T) {
+ input := `"foo"`
+
+ args := new(BlockNumIndexArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockNumIndexArgsBlocknumInvalid(t *testing.T) {
+ input := `[{}, "0x1"]`
+
+ args := new(BlockNumIndexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestBlockNumIndexArgsIndexInvalid(t *testing.T) {
+ input := `["0x29a", 1]`
+
+ args := new(BlockNumIndexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestHashIndexArgs(t *testing.T) {
input := `["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", "0x1"]`
expected := new(HashIndexArgs)
@@ -727,12 +1459,52 @@ func TestHashIndexArgs(t *testing.T) {
}
}
+func TestHashIndexArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(HashIndexArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestHashIndexArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(HashIndexArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestHashIndexArgsInvalidHash(t *testing.T) {
+ input := `[7, "0x1"]`
+
+ args := new(HashIndexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestHashIndexArgsInvalidIndex(t *testing.T) {
+ input := `["0xc6ef2fc5426d6ad6fd9e2a26abeab0aa2411b7ab17f30a99d3cb96aed1d1055b", false]`
+
+ args := new(HashIndexArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), &args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
func TestSubmitWorkArgs(t *testing.T) {
input := `["0x0000000000000001", "0x1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000"]`
expected := new(SubmitWorkArgs)
expected.Nonce = 1
- expected.Header = common.HexToHash("0x1234567890abcdef1234567890abcdef")
- expected.Digest = common.HexToHash("0xD1GE5700000000000000000000000000")
+ expected.Header = "0x1234567890abcdef1234567890abcdef"
+ expected.Digest = "0xD1GE5700000000000000000000000000"
args := new(SubmitWorkArgs)
if err := json.Unmarshal([]byte(input), &args); err != nil {
@@ -751,3 +1523,51 @@ func TestSubmitWorkArgs(t *testing.T) {
t.Errorf("Digest shoud be %#v but is %#v", expected.Digest, args.Digest)
}
}
+
+func TestSubmitWorkArgsInvalid(t *testing.T) {
+ input := `{}`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectDecodeParamError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestSubmitWorkArgsEmpty(t *testing.T) {
+ input := `[]`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectInsufficientParamsError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+
+func TestSubmitWorkArgsNonceInt(t *testing.T) {
+ input := `[1, "0x1234567890abcdef1234567890abcdef", "0xD1GE5700000000000000000000000000"]`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+func TestSubmitWorkArgsHeaderInt(t *testing.T) {
+ input := `["0x0000000000000001", 1, "0xD1GE5700000000000000000000000000"]`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
+func TestSubmitWorkArgsDigestInt(t *testing.T) {
+ input := `["0x0000000000000001", "0x1234567890abcdef1234567890abcdef", 1]`
+
+ args := new(SubmitWorkArgs)
+ str := ExpectInvalidTypeError(json.Unmarshal([]byte(input), args))
+ if len(str) > 0 {
+ t.Error(str)
+ }
+}
diff --git a/rpc/messages.go b/rpc/messages.go
index 7f5ebab11..5c498234f 100644
--- a/rpc/messages.go
+++ b/rpc/messages.go
@@ -21,6 +21,22 @@ import (
"fmt"
)
+type InvalidTypeError struct {
+ method string
+ msg string
+}
+
+func (e *InvalidTypeError) Error() string {
+ return fmt.Sprintf("invalid type on field %s: %s", e.method, e.msg)
+}
+
+func NewInvalidTypeError(method, msg string) *InvalidTypeError {
+ return &InvalidTypeError{
+ method: method,
+ msg: msg,
+ }
+}
+
type InsufficientParamsError struct {
have int
want int
diff --git a/rpc/messages_test.go b/rpc/messages_test.go
index 5274c91e4..91f0152dc 100644
--- a/rpc/messages_test.go
+++ b/rpc/messages_test.go
@@ -4,6 +4,15 @@ import (
"testing"
)
+func TestInvalidTypeError(t *testing.T) {
+ err := NewInvalidTypeError("testField", "not string")
+ expected := "invalid type on field testField: not string"
+
+ if err.Error() != expected {
+ t.Error(err.Error())
+ }
+}
+
func TestInsufficientParamsError(t *testing.T) {
err := NewInsufficientParamsError(0, 1)
expected := "insufficient params, want 1 have 0"
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-16 21:54:15 +0800