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.
277 lines
7.5 KiB
277 lines
7.5 KiB
package client_test
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/tendermint/merkleeyes/iavl" //TODO use tendermint/iavl ?
|
|
"github.com/tendermint/tendermint/rpc/client"
|
|
rpctest "github.com/tendermint/tendermint/rpc/test"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
func getHTTPClient() *client.HTTP {
|
|
rpcAddr := rpctest.GetConfig().RPC.ListenAddress
|
|
return client.NewHTTP(rpcAddr, "/websocket")
|
|
}
|
|
|
|
func getLocalClient() client.Local {
|
|
return client.NewLocal(node)
|
|
}
|
|
|
|
// GetClients returns a slice of clients for table-driven tests
|
|
func GetClients() []client.Client {
|
|
return []client.Client{
|
|
getHTTPClient(),
|
|
getLocalClient(),
|
|
}
|
|
}
|
|
|
|
// Make sure status is correct (we connect properly)
|
|
func TestStatus(t *testing.T) {
|
|
for i, c := range GetClients() {
|
|
moniker := rpctest.GetConfig().Moniker
|
|
status, err := c.Status()
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
assert.Equal(t, moniker, status.NodeInfo.Moniker)
|
|
}
|
|
}
|
|
|
|
// Make sure info is correct (we connect properly)
|
|
func TestInfo(t *testing.T) {
|
|
for i, c := range GetClients() {
|
|
// status, err := c.Status()
|
|
// require.Nil(t, err, "%+v", err)
|
|
info, err := c.ABCIInfo()
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
// TODO: this is not correct - fix merkleeyes!
|
|
// assert.EqualValues(t, status.LatestBlockHeight, info.Response.LastBlockHeight)
|
|
assert.True(t, strings.Contains(info.Response.Data, "size"))
|
|
}
|
|
}
|
|
|
|
func TestNetInfo(t *testing.T) {
|
|
for i, c := range GetClients() {
|
|
nc, ok := c.(client.NetworkClient)
|
|
require.True(t, ok, "%d", i)
|
|
netinfo, err := nc.NetInfo()
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
assert.True(t, netinfo.Listening)
|
|
assert.Equal(t, 0, len(netinfo.Peers))
|
|
}
|
|
}
|
|
|
|
func TestDumpConsensusState(t *testing.T) {
|
|
for i, c := range GetClients() {
|
|
// FIXME: fix server so it doesn't panic on invalid input
|
|
nc, ok := c.(client.NetworkClient)
|
|
require.True(t, ok, "%d", i)
|
|
cons, err := nc.DumpConsensusState()
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
assert.NotEmpty(t, cons.RoundState)
|
|
assert.Empty(t, cons.PeerRoundStates)
|
|
}
|
|
}
|
|
|
|
func TestGenesisAndValidators(t *testing.T) {
|
|
for i, c := range GetClients() {
|
|
|
|
// make sure this is the right genesis file
|
|
gen, err := c.Genesis()
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
// get the genesis validator
|
|
require.Equal(t, 1, len(gen.Genesis.Validators))
|
|
gval := gen.Genesis.Validators[0]
|
|
|
|
// get the current validators
|
|
vals, err := c.Validators(nil)
|
|
require.Nil(t, err, "%d: %+v", i, err)
|
|
require.Equal(t, 1, len(vals.Validators))
|
|
val := vals.Validators[0]
|
|
|
|
// make sure the current set is also the genesis set
|
|
assert.Equal(t, gval.Power, val.VotingPower)
|
|
assert.Equal(t, gval.PubKey, val.PubKey)
|
|
}
|
|
}
|
|
|
|
// Make some app checks
|
|
func TestAppCalls(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
for i, c := range GetClients() {
|
|
|
|
// get an offset of height to avoid racing and guessing
|
|
s, err := c.Status()
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
// sh is start height or status height
|
|
sh := s.LatestBlockHeight
|
|
|
|
// look for the future
|
|
h := sh + 2
|
|
_, err = c.Block(&h)
|
|
assert.NotNil(err) // no block yet
|
|
|
|
// write something
|
|
k, v, tx := MakeTxKV()
|
|
bres, err := c.BroadcastTxCommit(tx)
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
require.True(bres.DeliverTx.Code.IsOK())
|
|
txh := bres.Height
|
|
apph := txh + 1 // this is where the tx will be applied to the state
|
|
|
|
// wait before querying
|
|
client.WaitForHeight(c, apph, nil)
|
|
qres, err := c.ABCIQuery("/key", k, false)
|
|
if assert.Nil(err) && assert.True(qres.Code.IsOK()) {
|
|
// assert.Equal(k, data.GetKey()) // only returned for proofs
|
|
assert.EqualValues(v, qres.Value)
|
|
}
|
|
|
|
// make sure we can lookup the tx with proof
|
|
// ptx, err := c.Tx(bres.Hash, true)
|
|
ptx, err := c.Tx(bres.Hash, true)
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
assert.Equal(txh, ptx.Height)
|
|
assert.EqualValues(tx, ptx.Tx)
|
|
|
|
// and we can even check the block is added
|
|
block, err := c.Block(&apph)
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
appHash := block.BlockMeta.Header.AppHash
|
|
assert.True(len(appHash) > 0)
|
|
assert.EqualValues(apph, block.BlockMeta.Header.Height)
|
|
|
|
// check blockchain info, now that we know there is info
|
|
// TODO: is this commented somewhere that they are returned
|
|
// in order of descending height???
|
|
info, err := c.BlockchainInfo(apph, apph)
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
assert.True(info.LastHeight >= apph)
|
|
if assert.Equal(1, len(info.BlockMetas)) {
|
|
lastMeta := info.BlockMetas[0]
|
|
assert.EqualValues(apph, lastMeta.Header.Height)
|
|
bMeta := block.BlockMeta
|
|
assert.Equal(bMeta.Header.AppHash, lastMeta.Header.AppHash)
|
|
assert.Equal(bMeta.BlockID, lastMeta.BlockID)
|
|
}
|
|
|
|
// and get the corresponding commit with the same apphash
|
|
commit, err := c.Commit(&apph)
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
cappHash := commit.Header.AppHash
|
|
assert.Equal(appHash, cappHash)
|
|
assert.NotNil(commit.Commit)
|
|
|
|
// compare the commits (note Commit(2) has commit from Block(3))
|
|
h = apph - 1
|
|
commit2, err := c.Commit(&h)
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
assert.Equal(block.Block.LastCommit, commit2.Commit)
|
|
|
|
// and we got a proof that works!
|
|
pres, err := c.ABCIQuery("/key", k, true)
|
|
if assert.Nil(err) && assert.True(pres.Code.IsOK()) {
|
|
proof, err := iavl.ReadProof(pres.Proof)
|
|
if assert.Nil(err) {
|
|
key := pres.Key
|
|
value := pres.Value
|
|
assert.EqualValues(appHash, proof.RootHash)
|
|
valid := proof.Verify(key, value, appHash)
|
|
assert.True(valid)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBroadcastTxSync(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
mempool := node.MempoolReactor().Mempool
|
|
initMempoolSize := mempool.Size()
|
|
|
|
for i, c := range GetClients() {
|
|
_, _, tx := MakeTxKV()
|
|
bres, err := c.BroadcastTxSync(tx)
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
require.True(bres.Code.IsOK())
|
|
|
|
require.Equal(initMempoolSize+1, mempool.Size())
|
|
|
|
txs := mempool.Reap(1)
|
|
require.EqualValues(tx, txs[0])
|
|
mempool.Flush()
|
|
}
|
|
}
|
|
|
|
func TestBroadcastTxCommit(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
mempool := node.MempoolReactor().Mempool
|
|
for i, c := range GetClients() {
|
|
_, _, tx := MakeTxKV()
|
|
bres, err := c.BroadcastTxCommit(tx)
|
|
require.Nil(err, "%d: %+v", i, err)
|
|
require.True(bres.CheckTx.Code.IsOK())
|
|
require.True(bres.DeliverTx.Code.IsOK())
|
|
|
|
require.Equal(0, mempool.Size())
|
|
}
|
|
}
|
|
|
|
func TestTx(t *testing.T) {
|
|
assert, require := assert.New(t), require.New(t)
|
|
|
|
// first we broadcast a tx
|
|
c := getHTTPClient()
|
|
_, _, tx := MakeTxKV()
|
|
bres, err := c.BroadcastTxCommit(tx)
|
|
require.Nil(err, "%+v", err)
|
|
|
|
txHeight := bres.Height
|
|
txHash := bres.Hash
|
|
|
|
anotherTxHash := 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, anotherTxHash, false},
|
|
{false, anotherTxHash, true},
|
|
{false, nil, false},
|
|
{false, nil, true},
|
|
}
|
|
|
|
for i, c := range GetClients() {
|
|
for j, tc := range cases {
|
|
t.Logf("client %d, case %d", i, j)
|
|
|
|
// now we query for the tx.
|
|
// since there's only one tx, we know index=0.
|
|
ptx, err := c.Tx(tc.hash, tc.prove)
|
|
|
|
if !tc.valid {
|
|
require.NotNil(err)
|
|
} else {
|
|
require.Nil(err, "%+v", err)
|
|
assert.Equal(txHeight, ptx.Height)
|
|
assert.EqualValues(tx, ptx.Tx)
|
|
assert.Equal(0, ptx.Index)
|
|
assert.True(ptx.TxResult.Code.IsOK())
|
|
|
|
// time to verify the proof
|
|
proof := ptx.Proof
|
|
if tc.prove && assert.EqualValues(tx, proof.Data) {
|
|
assert.True(proof.Proof.Verify(proof.Index, proof.Total, txHash, proof.RootHash))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|