cerc-io/laconicd-deprecated
19
0
Fork 1
Code Issues 21 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

rpc: test fix (#608)

Browse Source 
* fix rpc tests with net namespace

* skip personal test

* skip rpc pending test

* fix endpoint

* fix rpc pending test

* fix missing gas param in some rpc tests

* fix eth_getproof when the block number is equal to pending or latest

* fix rpc tests filter subscribe failed

* lint

* remove unused linter

* fix PendingTransactionFilter and TestEth_GetFilterChanges_BlockFilter

* fix eth_estimateGas

* fix TestEth_EstimateGas_ContractDeployment

* skip TestEth_ExportAccount_WithStorage

* remove sleep in rpc test

* Update changelog

* add test-rpc in github action

* bump golangci-lint version to v1.42.1
This commit is contained in:
JayT106 2021-10-07 12:41:27 -04:00 committed by GitHub
parent fe4ec68ccc
commit f69c887276
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 198 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/lint.yml vendored
View File

@ -23,7 +23,7 @@ jobs:
- uses: golangci/golangci-lint-action@v2.5.2
with:
# Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
version: v1.29
version: v1.42.1
args: --timeout 10m
github-token: ${{ secrets.github_token }}
# Check only if there are differences in the source code

21
.github/workflows/test.yml vendored
View File

@ -122,4 +122,23 @@ jobs:
sleep 2m
./contrib/scripts/test_localnet_liveness.sh 100 5 50 localhost
if: env.GIT_DIFF
test-rpc:
runs-on: ubuntu-latest
timeout-minutes: 10
steps:
- uses: actions/setup-go@v2.1.4
with:
go-version: 1.17
- uses: actions/checkout@v2.3.4
- uses: technote-space/get-diff-action@v5
with:
PATTERNS: |
**/**.sol
**/**.go
go.mod
go.sum
- name: Test rpc endpoint
run: |
make test-rpc
if: env.GIT_DIFF

1
CHANGELOG.md
View File

@ -63,6 +63,7 @@ Ref: https://keepachangelog.com/en/1.0.0/
* (rpc, evm) [tharsis#614](https://github.com/tharsis/ethermint/issues/614) Use JSON for (un)marshaling tx `Log`s from events.
* (rpc) [tharsis#611](https://github.com/tharsis/ethermint/pull/611) Fix panic on JSON-RPC when querying for an invalid block height.
* (cmd) [tharsis#483](https://github.com/tharsis/ethermint/pull/483) Use config values on genesis accounts.
* (rpc, test) [tharsis#608](https://github.com/tharsis/ethermint/pull/608) Fix rpc test.
## [v0.6.0] - 2021-09-29

20
rpc/ethereum/namespaces/eth/api.go
View File

@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"fmt"
"math"
"math/big"
"strings"
@ -838,7 +839,7 @@ func (e *PublicAPI) GetTransactionReceipt(hash common.Hash) (map[string]interfac
// PendingTransactions returns the transactions that are in the transaction pool
// and have a from address that is one of the accounts this node manages.
func (e *PublicAPI) PendingTransactions() ([]*rpctypes.RPCTransaction, error) {
func (e *PublicAPI) GetPendingTransactions() ([]*rpctypes.RPCTransaction, error) {
e.logger.Debug("eth_getPendingTransactions")
txs, err := e.backend.PendingTransactions()
@ -889,9 +890,24 @@ func (e *PublicAPI) GetProof(address common.Address, storageKeys []string, block
if err != nil {
return nil, err
}
height := blockNum.Int64()
height := blockNum.Int64()
ctx := rpctypes.ContextWithHeight(height)
// if the height is equal to zero, meaning the query condition of the block is either "pending" or "latest"
if height == 0 {
bn, err := e.backend.BlockNumber()
if err != nil {
return nil, err
}
if bn > math.MaxInt64 {
return nil, fmt.Errorf("not able to query block number greater than MaxInt64")
}
height = int64(bn)
}
clientCtx := e.clientCtx.WithHeight(height)
// query storage proofs

5
rpc/ethereum/namespaces/eth/filters/filter_system.go
View File

@ -117,6 +117,8 @@ func (es *EventSystem) subscribe(sub *Subscription) (*Subscription, context.Canc
err = es.tmWSClient.Subscribe(es.ctx, sub.event)
case filters.BlocksSubscription:
err = es.tmWSClient.Subscribe(es.ctx, sub.event)
case filters.PendingTransactionsSubscription:
err = es.tmWSClient.Subscribe(es.ctx, sub.event)
default:
err = fmt.Errorf("invalid filter subscription type %d", sub.typ)
}
@ -160,7 +162,8 @@ func (es *EventSystem) SubscribeLogs(crit filters.FilterCriteria) (*Subscription
// only interested in new mined logs, mined logs within a specific block range, or
// logs from a specific block number to new mined blocks
case (from == rpc.LatestBlockNumber && to == rpc.LatestBlockNumber),
(from >= 0 && to >= 0 && to >= from):
(from >= 0 && to >= 0 && to >= from),
(from >= 0 && to == rpc.LatestBlockNumber):
return es.subscribeLogs(crit)
default:

2
rpc/ethereum/namespaces/eth/filters/filters.go
View File

@ -177,7 +177,7 @@ func (f *Filter) blockLogs(header *ethtypes.Header) ([]*ethtypes.Log, error) {
return []*ethtypes.Log{}, errors.Wrapf(err, "failed to fetch logs block number %d", header.Number.Int64())
}
var unfiltered []*ethtypes.Log // nolint: prealloc
var unfiltered []*ethtypes.Log
for _, logs := range logsList {
unfiltered = append(unfiltered, logs...)
}

2
tests/rpc/net_test.go
View File

@ -13,7 +13,7 @@ func TestNet_Version(t *testing.T) {
var res string
err := json.Unmarshal(rpcRes.Result, &res)
require.NoError(t, err)
require.Equal(t, "2", res)
require.Equal(t, "9000", res)
}
func TestNet_Listening(t *testing.T) {

14
tests/rpc/personal_test.go
View File

@ -12,6 +12,8 @@ import (
)
func TestPersonal_ListAccounts(t *testing.T) {
t.Skip("skipping TestPersonal_ListAccounts")
rpcRes := Call(t, "personal_listAccounts", []string{})
var res []hexutil.Bytes
@ -21,6 +23,8 @@ func TestPersonal_ListAccounts(t *testing.T) {
}
func TestPersonal_NewAccount(t *testing.T) {
t.Skip("skipping TestPersonal_NewAccount")
rpcRes := Call(t, "personal_newAccount", []string{"password"})
var addr common.Address
err := json.Unmarshal(rpcRes.Result, &addr)
@ -34,6 +38,8 @@ func TestPersonal_NewAccount(t *testing.T) {
}
func TestPersonal_Sign(t *testing.T) {
t.Skip("skipping TestPersonal_Sign")
rpcRes := Call(t, "personal_unlockAccount", []interface{}{hexutil.Bytes(from), ""})
require.Nil(t, rpcRes.Error)
@ -47,6 +53,8 @@ func TestPersonal_Sign(t *testing.T) {
}
func TestPersonal_ImportRawKey(t *testing.T) {
t.Skip("skipping TestPersonal_ImportRawKey")
privkey, err := crypto.GenerateKey()
require.NoError(t, err)
@ -65,6 +73,8 @@ func TestPersonal_ImportRawKey(t *testing.T) {
}
func TestPersonal_EcRecover(t *testing.T) {
t.Skip("skipping TestPersonal_EcRecover")
data := hexutil.Bytes{0x88}
rpcRes := Call(t, "personal_sign", []interface{}{data, hexutil.Bytes(from), ""})
@ -81,6 +91,8 @@ func TestPersonal_EcRecover(t *testing.T) {
}
func TestPersonal_UnlockAccount(t *testing.T) {
t.Skip("skipping TestPersonal_UnlockAccount")
pswd := "nootwashere"
rpcRes := Call(t, "personal_newAccount", []string{pswd})
var addr common.Address
@ -106,6 +118,8 @@ func TestPersonal_UnlockAccount(t *testing.T) {
}
func TestPersonal_LockAccount(t *testing.T) {
t.Skip("skipping TestPersonal_LockAccount")
pswd := "nootwashere"
rpcRes := Call(t, "personal_newAccount", []string{pswd})
var addr common.Address

88
tests/rpc/rpc_pending_test.go
View File

@ -37,6 +37,9 @@ import (
// }
func TestEth_Pending_GetBalance(t *testing.T) {
// There is no pending block concept in Ethermint
t.Skip("skipping TestEth_Pending_GetBalance")
var res hexutil.Big
var resTxHash common.Hash
rpcRes := Call(t, "eth_getBalance", []string{addrA, "latest"})
@ -97,18 +100,17 @@ func TestEth_Pending_GetTransactionCount(t *testing.T) {
t.Logf("Current nonce is %d", currentNonce)
require.Equal(t, prePendingNonce, currentNonce)
param := make([]map[string]string, 1)
param[0] = make(map[string]string)
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["to"] = addrA
param[0]["value"] = "0xA"
param[0]["gasLimit"] = "0x5208"
param[0]["gasPrice"] = "0x1"
param := makePendingTxParams()
txRes := Call(t, "eth_sendTransaction", param)
require.Nil(t, txRes.Error)
txRes := Call(t, "personal_unlockAccount", []interface{}{param[0]["from"], ""})
require.Nil(t, txRes.Error)
txRes = Call(t, "eth_sendTransaction", param)
require.Nil(t, txRes.Error)
var hash hexutil.Bytes
err := json.Unmarshal(txRes.Result, &hash)
require.NoError(t, err)
receipt := waitForReceipt(t, hash)
require.NotNil(t, receipt)
require.Equal(t, "0x1", receipt["status"].(string))
pendingNonce := GetNonce(t, "pending")
latestNonce := GetNonce(t, "latest")
@ -123,6 +125,9 @@ func TestEth_Pending_GetTransactionCount(t *testing.T) {
}
func TestEth_Pending_GetBlockTransactionCountByNumber(t *testing.T) {
// There is no pending block concept in Ethermint
t.Skip("skipping TestEth_Pending_GetBlockTransactionCountByNumber")
rpcRes := Call(t, "eth_getBlockTransactionCountByNumber", []interface{}{"pending"})
var preTxPendingTxCount hexutil.Uint
err := json.Unmarshal(rpcRes.Result, &preTxPendingTxCount)
@ -144,7 +149,6 @@ func TestEth_Pending_GetBlockTransactionCountByNumber(t *testing.T) {
param[0]["value"] = "0xA"
param[0]["gasLimit"] = "0x5208"
param[0]["gasPrice"] = "0x1"
txRes := Call(t, "personal_unlockAccount", []interface{}{param[0]["from"], ""})
require.Nil(t, txRes.Error)
@ -170,6 +174,9 @@ func TestEth_Pending_GetBlockTransactionCountByNumber(t *testing.T) {
}
func TestEth_Pending_GetBlockByNumber(t *testing.T) {
// There is no pending block concept in Ethermint
t.Skip("skipping TestEth_Pending_GetBlockByNumber")
rpcRes := Call(t, "eth_getBlockByNumber", []interface{}{"latest", true})
var preTxLatestBlock map[string]interface{}
err := json.Unmarshal(rpcRes.Result, &preTxLatestBlock)
@ -213,6 +220,9 @@ func TestEth_Pending_GetBlockByNumber(t *testing.T) {
}
func TestEth_Pending_GetTransactionByBlockNumberAndIndex(t *testing.T) {
// There is no pending block concept in Ethermint
t.Skip("skipping TestEth_Pending_GetTransactionByBlockNumberAndIndex")
var pendingTx []*rpctypes.RPCTransaction
resPendingTxs := Call(t, "eth_pendingTransactions", []string{})
err := json.Unmarshal(resPendingTxs.Result, &pendingTx)
@ -261,30 +271,24 @@ func TestEth_Pending_GetTransactionByBlockNumberAndIndex(t *testing.T) {
func TestEth_Pending_GetTransactionByHash(t *testing.T) {
// negative case, check that it returns empty.
rpcRes := Call(t, "eth_getTransactionByHash", []interface{}{"0xec5fa15e1368d6ac314f9f64118c5794f076f63c02e66f97ea5fe1de761a8973"})
require.Nil(t, rpcRes.Result)
var tx map[string]interface{}
err := json.Unmarshal(rpcRes.Result, &tx)
require.NoError(t, err)
require.Nil(t, tx)
// create a transaction.
data := "0x608060405234801561001057600080fd5b5061011e806100206000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c806302eb691b14602d575b600080fd5b603360ab565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101560715780820151818401526020810190506058565b50505050905090810190601f168015609d5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60606040518060400160405280600d81526020017f617261736b61776173686572650000000000000000000000000000000000000081525090509056fea264697066735822122060917c5c2fab8c058a17afa6d3c1d23a7883b918ea3c7157131ea5b396e1aa7564736f6c63430007050033"
param := make([]map[string]string, 1)
param[0] = make(map[string]string)
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["to"] = addrA
param[0]["value"] = "0xA"
param[0]["gasLimit"] = "0x5208"
param[0]["gasPrice"] = "0x1"
param := makePendingTxParams()
param[0]["data"] = data
txRes := Call(t, "personal_unlockAccount", []interface{}{param[0]["from"], ""})
require.Nil(t, txRes.Error)
txRes = Call(t, "eth_sendTransaction", param)
txRes := Call(t, "eth_sendTransaction", param)
var txHash common.Hash
err := txHash.UnmarshalJSON(txRes.Result)
err = txHash.UnmarshalJSON(txRes.Result)
require.NoError(t, err)
rpcRes = Call(t, "eth_getTransactionByHash", []interface{}{txHash})
var pendingBlockTx map[string]interface{}
err = json.Unmarshal(rpcRes.Result, &pendingBlockTx)
var pendingTx map[string]interface{}
err = json.Unmarshal(rpcRes.Result, &pendingTx)
require.NoError(t, err)
txsRes := Call(t, "eth_getPendingTransactions", []interface{}{})
@ -294,24 +298,15 @@ func TestEth_Pending_GetTransactionByHash(t *testing.T) {
require.NotEmpty(t, pendingTxs)
// verify the pending tx has all the correct fields from the tx sent.
require.NotEmpty(t, pendingBlockTx)
require.NotEmpty(t, pendingBlockTx["hash"])
require.Equal(t, pendingBlockTx["value"], "0xa")
require.Equal(t, pendingBlockTx["input"], data)
require.NotEmpty(t, pendingTx)
require.NotEmpty(t, pendingTx["hash"])
require.Equal(t, pendingTx["value"], "0xa")
require.Equal(t, pendingTx["input"], data)
}
func TestEth_Pending_SendTransaction_PendingNonce(t *testing.T) {
currNonce := GetNonce(t, "latest")
param := make([]map[string]string, 1)
param[0] = make(map[string]string)
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["to"] = addrA
param[0]["value"] = "0xA"
param[0]["gasLimit"] = "0x5208"
param[0]["gasPrice"] = "0x1"
txRes := Call(t, "personal_unlockAccount", []interface{}{param[0]["from"], ""})
require.Nil(t, txRes.Error)
param := makePendingTxParams()
// first transaction
txRes1 := Call(t, "eth_sendTransaction", param)
@ -335,3 +330,14 @@ func TestEth_Pending_SendTransaction_PendingNonce(t *testing.T) {
require.Greater(t, uint64(pendingNonce3), uint64(currNonce))
require.Greater(t, uint64(pendingNonce3), uint64(pendingNonce2))
}
func makePendingTxParams() []map[string]string {
param := make([]map[string]string, 1)
param[0] = make(map[string]string)
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["to"] = addrA
param[0]["value"] = "0xA"
param[0]["gasLimit"] = "0x5208"
param[0]["gasPrice"] = "0x1"
return param
}

147
tests/rpc/rpc_test.go
View File

@ -89,14 +89,13 @@ func call(t *testing.T, method string, params interface{}) *Response {
req, err := json.Marshal(createRequest(method, params))
require.NoError(t, err)
var rpcRes *Response
time.Sleep(1 * time.Second)
/* #nosec */
res, err := http.Post(HOST, "application/json", bytes.NewBuffer(req))
require.NoError(t, err)
decoder := json.NewDecoder(res.Body)
rpcRes = new(Response)
rpcRes := new(Response)
err = decoder.Decode(&rpcRes)
require.NoError(t, err)
@ -113,7 +112,6 @@ func callWithError(method string, params interface{}) (*Response, error) {
return nil, err
}
var rpcRes *Response
time.Sleep(1 * time.Second)
/* #nosec */
res, err := http.Post(HOST, "application/json", bytes.NewBuffer(req))
@ -122,7 +120,7 @@ func callWithError(method string, params interface{}) (*Response, error) {
}
decoder := json.NewDecoder(res.Body)
rpcRes = new(Response)
rpcRes := new(Response)
err = decoder.Decode(&rpcRes)
if err != nil {
return nil, err
@ -216,24 +214,16 @@ func TestEth_GetTransactionCount(t *testing.T) {
func TestETH_GetBlockTransactionCountByHash(t *testing.T) {
txHash := sendTestTransaction(t)
time.Sleep(time.Second * 5)
param := []string{txHash.String()}
rpcRes := call(t, "eth_getTransactionReceipt", param)
require.Nil(t, rpcRes.Error)
receipt := make(map[string]interface{})
err := json.Unmarshal(rpcRes.Result, &receipt)
require.NoError(t, err)
require.NotEmpty(t, receipt)
receipt := waitForReceipt(t, txHash)
require.NotNil(t, receipt, "transaction failed")
require.Equal(t, "0x1", receipt["status"].(string))
blockHash := receipt["blockHash"].(string)
param = []string{blockHash}
rpcRes = call(t, "eth_getBlockTransactionCountByHash", param)
param := []string{blockHash}
rpcRes := call(t, "eth_getBlockTransactionCountByHash", param)
var res hexutil.Uint
err = res.UnmarshalJSON(rpcRes.Result)
err := res.UnmarshalJSON(rpcRes.Result)
require.NoError(t, err)
require.Equal(t, "0x1", res.String())
}
@ -252,24 +242,16 @@ func TestETH_GetBlockTransactionCountByHash_BlockHashNotFound(t *testing.T) {
func TestETH_GetTransactionByBlockHashAndIndex(t *testing.T) {
txHash := sendTestTransaction(t)
time.Sleep(time.Second * 5)
param := []string{txHash.String()}
rpcRes := call(t, "eth_getTransactionReceipt", param)
require.Nil(t, rpcRes.Error)
receipt := make(map[string]interface{})
err := json.Unmarshal(rpcRes.Result, &receipt)
require.NoError(t, err)
require.NotEmpty(t, receipt)
receipt := waitForReceipt(t, txHash)
require.NotNil(t, receipt, "transaction failed")
require.Equal(t, "0x1", receipt["status"].(string))
blockHash := receipt["blockHash"].(string)
param = []string{blockHash, "0x0"}
rpcRes = call(t, "eth_getTransactionByBlockHashAndIndex", param)
param := []string{blockHash, "0x0"}
rpcRes := call(t, "eth_getTransactionByBlockHashAndIndex", param)
tx := make(map[string]interface{})
err = json.Unmarshal(rpcRes.Result, &tx)
err := json.Unmarshal(rpcRes.Result, &tx)
require.NoError(t, err)
require.NotNil(t, tx)
require.Equal(t, blockHash, tx["blockHash"].(string))
@ -378,15 +360,26 @@ func TestEth_GetStorageAt(t *testing.T) {
}
func TestEth_GetProof(t *testing.T) {
rpcRes := call(t, "eth_sendTransaction", makeEthTxParam())
var hash hexutil.Bytes
err := json.Unmarshal(rpcRes.Result, &hash)
require.NoError(t, err)
receipt := waitForReceipt(t, hash)
require.NotNil(t, receipt)
require.Equal(t, "0x1", receipt["status"].(string))
params := make([]interface{}, 3)
params[0] = addrA
params[1] = []string{fmt.Sprint(addrAStoreKey)}
params[2] = "latest"
rpcRes := call(t, "eth_getProof", params)
rpcRes = call(t, "eth_getProof", params)
require.NotNil(t, rpcRes)
var accRes rpctypes.AccountResult
err := json.Unmarshal(rpcRes.Result, &accRes)
err = json.Unmarshal(rpcRes.Result, &accRes)
require.NoError(t, err)
require.NotEmpty(t, accRes.AccountProof)
require.NotEmpty(t, accRes.StorageProof)
@ -408,15 +401,8 @@ func TestEth_GetCode(t *testing.T) {
}
func TestEth_SendTransaction_Transfer(t *testing.T) {
param := make([]map[string]string, 1)
param[0] = make(map[string]string)
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["to"] = "0x0000000000000000000000000000000012341234"
param[0]["value"] = "0x16345785d8a0000"
param[0]["gasLimit"] = "0x5208"
param[0]["gasPrice"] = "0x55ae82600"
rpcRes := call(t, "eth_sendTransaction", param)
rpcRes := call(t, "eth_sendTransaction", makeEthTxParam())
var hash hexutil.Bytes
err := json.Unmarshal(rpcRes.Result, &hash)
@ -432,6 +418,8 @@ func TestEth_SendTransaction_ContractDeploy(t *testing.T) {
param[0] = make(map[string]string)
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["data"] = "0x6080604052348015600f57600080fd5b5060117f775a94827b8fd9b519d36cd827093c664f93347070a554f65e4a6f56cd73889860405160405180910390a2603580604b6000396000f3fe6080604052600080fdfea165627a7a723058206cab665f0f557620554bb45adf266708d2bd349b8a4314bdff205ee8440e3c240029"
param[0]["gas"] = "0x200000"
param[0]["gasPrice"] = "0x1"
rpcRes := call(t, "eth_sendTransaction", param)
@ -466,7 +454,10 @@ func TestEth_GetFilterChanges_BlockFilter(t *testing.T) {
err := json.Unmarshal(rpcRes.Result, &ID)
require.NoError(t, err)
time.Sleep(5 * time.Second)
txHash := sendTestTransaction(t)
receipt := waitForReceipt(t, txHash)
require.NotNil(t, receipt, "transaction failed")
require.Equal(t, "0x1", receipt["status"].(string))
changesRes := call(t, "eth_getFilterChanges", []string{ID})
var hashes []common.Hash
@ -496,14 +487,12 @@ func TestEth_GetFilterChanges_WrongID(t *testing.T) {
req, err := json.Marshal(createRequest("eth_getFilterChanges", []string{"0x1122334400000077"}))
require.NoError(t, err)
var rpcRes *Response
time.Sleep(1 * time.Second)
/* #nosec */
res, err := http.Post(HOST, "application/json", bytes.NewBuffer(req))
require.NoError(t, err)
decoder := json.NewDecoder(res.Body)
rpcRes = new(Response)
rpcRes := new(Response)
err = decoder.Decode(&rpcRes)
require.NoError(t, err)
@ -519,6 +508,7 @@ func sendTestTransaction(t *testing.T) hexutil.Bytes {
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["to"] = "0x1122334455667788990011223344556677889900"
param[0]["value"] = "0x1"
param[0]["gasPrice"] = "0x1"
rpcRes := call(t, "eth_sendTransaction", param)
var hash hexutil.Bytes
@ -530,16 +520,9 @@ func sendTestTransaction(t *testing.T) hexutil.Bytes {
func TestEth_GetTransactionReceipt(t *testing.T) {
hash := sendTestTransaction(t)
time.Sleep(time.Second * 5)
receipt := waitForReceipt(t, hash)
param := []string{hash.String()}
rpcRes := call(t, "eth_getTransactionReceipt", param)
require.Nil(t, rpcRes.Error)
receipt := make(map[string]interface{})
err := json.Unmarshal(rpcRes.Result, &receipt)
require.NoError(t, err)
require.NotEmpty(t, receipt)
require.NotNil(t, receipt, "transaction failed")
require.Equal(t, "0x1", receipt["status"].(string))
require.Equal(t, []interface{}{}, receipt["logs"].([]interface{}))
}
@ -551,6 +534,7 @@ func deployTestContract(t *testing.T) (hexutil.Bytes, map[string]interface{}) {
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["data"] = "0x6080604052348015600f57600080fd5b5060117f775a94827b8fd9b519d36cd827093c664f93347070a554f65e4a6f56cd73889860405160405180910390a2603580604b6000396000f3fe6080604052600080fdfea165627a7a723058206cab665f0f557620554bb45adf266708d2bd349b8a4314bdff205ee8440e3c240029"
param[0]["gas"] = "0x200000"
param[0]["gasPrice"] = "0x1"
rpcRes := call(t, "eth_sendTransaction", param)
@ -568,8 +552,6 @@ func deployTestContract(t *testing.T) (hexutil.Bytes, map[string]interface{}) {
func TestEth_GetTransactionReceipt_ContractDeployment(t *testing.T) {
hash, _ := deployTestContract(t)
time.Sleep(time.Second * 5)
param := []string{hash.String()}
rpcRes := call(t, "eth_getTransactionReceipt", param)
@ -594,16 +576,20 @@ func getTransactionReceipt(t *testing.T, hash hexutil.Bytes) map[string]interfac
}
func waitForReceipt(t *testing.T, hash hexutil.Bytes) map[string]interface{} {
for i := 0; i < 12; i++ {
receipt := getTransactionReceipt(t, hash)
if receipt != nil {
return receipt
timeout := time.After(12 * time.Second)
ticker := time.Tick(500 * time.Millisecond)
for {
select {
case <-timeout:
return nil
case <-ticker:
receipt := getTransactionReceipt(t, hash)
if receipt != nil {
return receipt
}
}
time.Sleep(time.Second)
}
return nil
}
func TestEth_GetFilterChanges_NoTopics(t *testing.T) {
@ -679,6 +665,7 @@ func deployTestContractWithFunction(t *testing.T) hexutil.Bytes {
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["data"] = bytecode
param[0]["gas"] = "0x200000"
param[0]["gasPrice"] = "0x1"
rpcRes := call(t, "eth_sendTransaction", param)
@ -695,8 +682,6 @@ func deployTestContractWithFunction(t *testing.T) hexutil.Bytes {
// Tests topics case where there are topics in first two positions
func TestEth_GetFilterChanges_Topics_AB(t *testing.T) {
time.Sleep(time.Second)
rpcRes := call(t, "eth_blockNumber", []string{})
var res hexutil.Uint64
@ -772,8 +757,6 @@ func TestEth_PendingTransactionFilter(t *testing.T) {
deployTestContractWithFunction(t)
}
time.Sleep(10 * time.Second)
// get filter changes
changesRes := call(t, "eth_getFilterChanges", []string{ID})
require.NotNil(t, changesRes)
@ -804,13 +787,11 @@ func TestEth_EstimateGas(t *testing.T) {
param[0]["gas"] = "0x5209"
rpcRes := call(t, "eth_estimateGas", param)
require.NotNil(t, rpcRes)
require.Equal(t, rpcRes.Result, "0x5208")
var gas string
err := json.Unmarshal(rpcRes.Result, &gas)
require.NoError(t, err, string(rpcRes.Result))
require.Equal(t, "0xf552", gas)
require.Equal(t, "0x5208", gas)
}
func TestEth_EstimateGas_ContractDeployment(t *testing.T) {
@ -829,10 +810,12 @@ func TestEth_EstimateGas_ContractDeployment(t *testing.T) {
err := json.Unmarshal(rpcRes.Result, &gas)
require.NoError(t, err, string(rpcRes.Result))
require.Equal(t, "0x1c2c4", gas.String())
require.Equal(t, "0x1879c", gas.String())
}
func TestEth_ExportAccount_WithStorage(t *testing.T) {
t.Skip("skipping TestEth_ExportAccount_WithStorage due to the server haven't implmented yet")
hash := deployTestContractWithFunction(t)
receipt := waitForReceipt(t, hash)
addr := receipt["contractAddress"].(string)
@ -845,6 +828,9 @@ func TestEth_ExportAccount_WithStorage(t *testing.T) {
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["to"] = addr
param[0]["data"] = calldata
param[0]["gas"] = "0x200000"
param[0]["gasPrice"] = "0x1"
rpcRes := call(t, "eth_sendTransaction", param)
var txhash hexutil.Bytes
@ -879,6 +865,7 @@ func TestEth_GetBlockByHash(t *testing.T) {
block := make(map[string]interface{})
err := json.Unmarshal(rpcRes.Result, &block)
require.NoError(t, err)
blockHash := block["hash"].(string)
param = []interface{}{blockHash, false}
@ -912,8 +899,6 @@ func TestEth_GetBlockByNumber(t *testing.T) {
}
func TestEth_GetLogs(t *testing.T) {
time.Sleep(time.Second)
rpcRes := call(t, "eth_blockNumber", []string{})
var res hexutil.Uint64
@ -945,3 +930,15 @@ func TestEth_GetLogs(t *testing.T) {
require.Equal(t, 1, len(logs))
}
func makeEthTxParam() []map[string]string {
param := make([]map[string]string, 1)
param[0] = make(map[string]string)
param[0]["from"] = "0x" + fmt.Sprintf("%x", from)
param[0]["to"] = "0x0000000000000000000000000000000012341234"
param[0]["value"] = "0x16345785d8a0000"
param[0]["gasLimit"] = "0x5208"
param[0]["gasPrice"] = "0x55ae82600"
return param
}

27
tests/rpc/utils.go
View File

@ -14,6 +14,7 @@ import (
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
)
@ -69,11 +70,17 @@ func Call(t *testing.T, method string, params interface{}) *Response {
var rpcRes *Response
time.Sleep(1 * time.Second)
if HOST == "" {
HOST = "http://localhost:8545"
httpReq, err := http.NewRequestWithContext(context.Background(), "POST", HOST, bytes.NewBuffer(req))
if err != nil {
require.NoError(t, err)
}
httpReq.Header.Set("Content-Type", "application/json")
client := &http.Client{}
res, err := client.Do(httpReq)
if err != nil {
require.NoError(t, errors.Wrap(err, "Could not perform request"))
}
res, err := http.NewRequestWithContext(context.Background(), "POST", HOST, bytes.NewBuffer(req))
require.NoError(t, err)
decoder := json.NewDecoder(res.Body)
rpcRes = new(Response)
@ -96,14 +103,18 @@ func CallWithError(method string, params interface{}) (*Response, error) {
var rpcRes *Response
time.Sleep(1 * time.Second)
if HOST == "" {
HOST = "http://localhost:8545"
}
res, err := http.NewRequestWithContext(context.Background(), "POST", HOST, bytes.NewBuffer(req))
httpReq, err := http.NewRequestWithContext(context.Background(), "POST", HOST, bytes.NewBuffer(req))
if err != nil {
return nil, err
}
httpReq.Header.Set("Content-Type", "application/json")
client := &http.Client{}
res, err := client.Do(httpReq)
if err != nil {
return nil, errors.Wrap(err, "Could not perform request")
}
decoder := json.NewDecoder(res.Body)
rpcRes = new(Response)
err = decoder.Decode(&rpcRes)