You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
351 lines
9.3 KiB
351 lines
9.3 KiB
package rpctest
|
|
|
|
import (
|
|
"bytes"
|
|
crand "crypto/rand"
|
|
"fmt"
|
|
"math/rand"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
abci "github.com/tendermint/abci/types"
|
|
"github.com/tendermint/go-wire/data"
|
|
. "github.com/tendermint/tmlibs/common"
|
|
|
|
"github.com/tendermint/tendermint/rpc/core"
|
|
ctypes "github.com/tendermint/tendermint/rpc/core/types"
|
|
rpc "github.com/tendermint/tendermint/rpc/lib/client"
|
|
"github.com/tendermint/tendermint/state/txindex/null"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Test the HTTP client
|
|
// These tests assume the dummy app
|
|
//--------------------------------------------------------------------------------
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// status
|
|
|
|
func TestURIStatus(t *testing.T) {
|
|
testStatus(t, GetURIClient())
|
|
}
|
|
|
|
func TestJSONStatus(t *testing.T) {
|
|
testStatus(t, GetJSONClient())
|
|
}
|
|
|
|
func testStatus(t *testing.T, client rpc.HTTPClient) {
|
|
moniker := GetConfig().Moniker
|
|
result := new(ctypes.ResultStatus)
|
|
_, err := client.Call("status", map[string]interface{}{}, result)
|
|
require.Nil(t, err)
|
|
assert.Equal(t, moniker, status.NodeInfo.Moniker)
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// broadcast tx sync
|
|
|
|
// random bytes (excluding byte('='))
|
|
func randBytes(t *testing.T) []byte {
|
|
n := rand.Intn(10) + 2
|
|
buf := make([]byte, n)
|
|
_, err := crand.Read(buf)
|
|
require.Nil(t, err)
|
|
return bytes.Replace(buf, []byte("="), []byte{100}, -1)
|
|
}
|
|
|
|
func TestURIBroadcastTxSync(t *testing.T) {
|
|
testBroadcastTxSync(t, GetURIClient())
|
|
}
|
|
|
|
func TestJSONBroadcastTxSync(t *testing.T) {
|
|
testBroadcastTxSync(t, GetJSONClient())
|
|
}
|
|
|
|
func testBroadcastTxSync(t *testing.T, client rpc.HTTPClient) {
|
|
mem := node.MempoolReactor().Mempool
|
|
initMemSize := mem.Size()
|
|
result := new(ctypes.ResultBroadcastTx)
|
|
tx := randBytes(t)
|
|
_, err := client.Call("broadcast_tx_sync", map[string]interface{}{"tx": tx}, result)
|
|
require.Nil(t, err)
|
|
|
|
require.Equal(t, abci.CodeType_OK, result.Code)
|
|
require.Equal(t, initMemSize+1, mem.Size())
|
|
txs := mem.Reap(1)
|
|
require.EqualValues(t, tx, txs[0])
|
|
mem.Flush()
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// query
|
|
|
|
func testTxKV(t *testing.T) ([]byte, []byte, types.Tx) {
|
|
k := randBytes(t)
|
|
v := randBytes(t)
|
|
return k, v, types.Tx(Fmt("%s=%s", k, v))
|
|
}
|
|
|
|
func sendTx(t *testing.T, client rpc.HTTPClient) ([]byte, []byte) {
|
|
result := new(ctypes.ResultBroadcastTxCommit)
|
|
k, v, tx := testTxKV(t)
|
|
_, err := client.Call("broadcast_tx_commit", map[string]interface{}{"tx": tx}, result)
|
|
require.Nil(t, err)
|
|
require.NotNil(t, 0, result.DeliverTx, "%#v", result)
|
|
require.EqualValues(t, 0, result.CheckTx.Code, "%#v", result)
|
|
require.EqualValues(t, 0, result.DeliverTx.Code, "%#v", result)
|
|
return k, v
|
|
}
|
|
|
|
func TestURIABCIQuery(t *testing.T) {
|
|
testABCIQuery(t, GetURIClient())
|
|
}
|
|
|
|
func TestJSONABCIQuery(t *testing.T) {
|
|
testABCIQuery(t, GetJSONClient())
|
|
}
|
|
|
|
func testABCIQuery(t *testing.T, client rpc.HTTPClient) {
|
|
k, _ := sendTx(t, client)
|
|
time.Sleep(time.Millisecond * 500)
|
|
result := new(ctypes.ResultABCIQuery)
|
|
_, err := client.Call("abci_query",
|
|
map[string]interface{}{"path": "", "data": data.Bytes(k), "prove": false}, result)
|
|
require.Nil(t, err)
|
|
|
|
require.EqualValues(t, 0, result.Code)
|
|
|
|
// XXX: specific to value returned by the dummy
|
|
require.NotEqual(t, 0, len(result.Value))
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// broadcast tx commit
|
|
|
|
func TestURIBroadcastTxCommit(t *testing.T) {
|
|
testBroadcastTxCommit(t, GetURIClient())
|
|
}
|
|
|
|
func TestJSONBroadcastTxCommit(t *testing.T) {
|
|
testBroadcastTxCommit(t, GetJSONClient())
|
|
}
|
|
|
|
func testBroadcastTxCommit(t *testing.T, client rpc.HTTPClient) {
|
|
require := require.New(t)
|
|
|
|
result := new(ctypes.ResultBroadcastTxCommit)
|
|
tx := randBytes(t)
|
|
_, err := client.Call("broadcast_tx_commit", map[string]interface{}{"tx": tx}, result)
|
|
require.Nil(err)
|
|
|
|
checkTx := result.CheckTx
|
|
require.Equal(abci.CodeType_OK, checkTx.Code)
|
|
deliverTx := result.DeliverTx
|
|
require.Equal(abci.CodeType_OK, deliverTx.Code)
|
|
mem := node.MempoolReactor().Mempool
|
|
require.Equal(0, mem.Size())
|
|
// TODO: find tx in block
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// query tx
|
|
|
|
func TestURITx(t *testing.T) {
|
|
testTx(t, GetURIClient(), true)
|
|
|
|
core.SetTxIndexer(&null.TxIndex{})
|
|
testTx(t, GetJSONClient(), false)
|
|
core.SetTxIndexer(node.ConsensusState().GetState().TxIndexer)
|
|
}
|
|
|
|
func TestJSONTx(t *testing.T) {
|
|
testTx(t, GetJSONClient(), true)
|
|
|
|
core.SetTxIndexer(&null.TxIndex{})
|
|
testTx(t, GetJSONClient(), false)
|
|
core.SetTxIndexer(node.ConsensusState().GetState().TxIndexer)
|
|
}
|
|
|
|
func testTx(t *testing.T, client rpc.HTTPClient, withIndexer bool) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
// first we broadcast a tx
|
|
result := new(ctypes.ResultBroadcastTxCommit)
|
|
txBytes := randBytes(t)
|
|
tx := types.Tx(txBytes)
|
|
_, err := client.Call("broadcast_tx_commit", map[string]interface{}{"tx": txBytes}, result)
|
|
require.Nil(err)
|
|
|
|
checkTx := result.CheckTx
|
|
require.Equal(abci.CodeType_OK, checkTx.Code)
|
|
deliverTx := result.DeliverTx
|
|
require.Equal(abci.CodeType_OK, deliverTx.Code)
|
|
mem := node.MempoolReactor().Mempool
|
|
require.Equal(0, mem.Size())
|
|
|
|
txHash := tx.Hash()
|
|
txHash2 := types.Tx("a different tx").Hash()
|
|
|
|
cases := []struct {
|
|
valid bool
|
|
hash []byte
|
|
prove bool
|
|
}{
|
|
// only valid if correct hash provided
|
|
{true, txHash, false},
|
|
{true, txHash, true},
|
|
{false, txHash2, false},
|
|
{false, txHash2, true},
|
|
{false, nil, false},
|
|
{false, nil, true},
|
|
}
|
|
|
|
for i, tc := range cases {
|
|
idx := fmt.Sprintf("%d", i)
|
|
|
|
// now we query for the tx.
|
|
// since there's only one tx, we know index=0.
|
|
result2 := new(ctypes.ResultTx)
|
|
query := map[string]interface{}{
|
|
"hash": tc.hash,
|
|
"prove": tc.prove,
|
|
}
|
|
_, err = client.Call("tx", query, result2)
|
|
valid := (withIndexer && tc.valid)
|
|
if !valid {
|
|
require.NotNil(err, idx)
|
|
} else {
|
|
require.Nil(err, idx)
|
|
assert.Equal(tx, result2.Tx, idx)
|
|
assert.Equal(result.Height, result2.Height, idx)
|
|
assert.Equal(0, result2.Index, idx)
|
|
assert.Equal(abci.CodeType_OK, result2.TxResult.Code, idx)
|
|
// time to verify the proof
|
|
proof := result2.Proof
|
|
if tc.prove && assert.Equal(tx, proof.Data, idx) {
|
|
assert.True(proof.Proof.Verify(proof.Index, proof.Total, tx.Hash(), proof.RootHash), idx)
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
// Test the websocket service
|
|
|
|
var wsTyp = "JSONRPC"
|
|
|
|
// make a simple connection to the server
|
|
func TestWSConnect(t *testing.T) {
|
|
wsc := GetWSClient()
|
|
wsc.Stop()
|
|
}
|
|
|
|
// receive a new block message
|
|
func TestWSNewBlock(t *testing.T) {
|
|
wsc := GetWSClient()
|
|
eid := types.EventStringNewBlock()
|
|
require.Nil(t, wsc.Subscribe(eid))
|
|
|
|
defer func() {
|
|
require.Nil(t, wsc.Unsubscribe(eid))
|
|
wsc.Stop()
|
|
}()
|
|
waitForEvent(t, wsc, eid, true, func() {}, func(eid string, b interface{}) error {
|
|
// fmt.Println("Check:", b)
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// receive a few new block messages in a row, with increasing height
|
|
func TestWSBlockchainGrowth(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping test in short mode.")
|
|
}
|
|
wsc := GetWSClient()
|
|
eid := types.EventStringNewBlock()
|
|
require.Nil(t, wsc.Subscribe(eid))
|
|
|
|
defer func() {
|
|
require.Nil(t, wsc.Unsubscribe(eid))
|
|
wsc.Stop()
|
|
}()
|
|
|
|
// listen for NewBlock, ensure height increases by 1
|
|
|
|
var initBlockN int
|
|
for i := 0; i < 3; i++ {
|
|
waitForEvent(t, wsc, eid, true, func() {}, func(eid string, eventData interface{}) error {
|
|
block := eventData.(types.TMEventData).Unwrap().(types.EventDataNewBlock).Block
|
|
if i == 0 {
|
|
initBlockN = block.Header.Height
|
|
} else {
|
|
if block.Header.Height != initBlockN+i {
|
|
return fmt.Errorf("Expected block %d, got block %d", initBlockN+i, block.Header.Height)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWSTxEvent(t *testing.T) {
|
|
require := require.New(t)
|
|
wsc := GetWSClient()
|
|
tx := randBytes(t)
|
|
|
|
// listen for the tx I am about to submit
|
|
eid := types.EventStringTx(types.Tx(tx))
|
|
require.Nil(wsc.Subscribe(eid))
|
|
|
|
defer func() {
|
|
require.Nil(wsc.Unsubscribe(eid))
|
|
wsc.Stop()
|
|
}()
|
|
|
|
// send an tx
|
|
result := new(ctypes.ResultBroadcastTx)
|
|
_, err := GetJSONClient().Call("broadcast_tx_sync", map[string]interface{}{"tx": tx}, result)
|
|
require.Nil(err)
|
|
|
|
waitForEvent(t, wsc, eid, true, func() {}, func(eid string, b interface{}) error {
|
|
evt, ok := b.(types.TMEventData).Unwrap().(types.EventDataTx)
|
|
require.True(ok, "Got wrong event type: %#v", b)
|
|
require.Equal(tx, []byte(evt.Tx), "Returned different tx")
|
|
require.Equal(abci.CodeType_OK, evt.Code)
|
|
return nil
|
|
})
|
|
}
|
|
|
|
/* TODO: this with dummy app..
|
|
func TestWSDoubleFire(t *testing.T) {
|
|
if testing.Short() {
|
|
t.Skip("skipping test in short mode.")
|
|
}
|
|
con := newWSCon(t)
|
|
eid := types.EventStringAccInput(user[0].Address)
|
|
subscribe(t, con, eid)
|
|
defer func() {
|
|
unsubscribe(t, con, eid)
|
|
con.Close()
|
|
}()
|
|
amt := int64(100)
|
|
toAddr := user[1].Address
|
|
// broadcast the transaction, wait to hear about it
|
|
waitForEvent(t, con, eid, true, func() {
|
|
tx := makeDefaultSendTxSigned(t, wsTyp, toAddr, amt)
|
|
broadcastTx(t, wsTyp, tx)
|
|
}, func(eid string, b []byte) error {
|
|
return nil
|
|
})
|
|
// but make sure we don't hear about it twice
|
|
waitForEvent(t, con, eid, false, func() {
|
|
}, func(eid string, b []byte) error {
|
|
return nil
|
|
})
|
|
}*/
|