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.
162 lines
4.4 KiB
162 lines
4.4 KiB
package e2e_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"math/rand"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/tendermint/tendermint/rpc/client/http"
|
|
e2e "github.com/tendermint/tendermint/test/e2e/pkg"
|
|
"github.com/tendermint/tendermint/types"
|
|
)
|
|
|
|
// Tests that any initial state given in genesis has made it into the app.
|
|
func TestApp_InitialState(t *testing.T) {
|
|
testNode(t, func(t *testing.T, node e2e.Node) {
|
|
if len(node.Testnet.InitialState) == 0 {
|
|
return
|
|
}
|
|
|
|
client, err := node.Client()
|
|
require.NoError(t, err)
|
|
for k, v := range node.Testnet.InitialState {
|
|
resp, err := client.ABCIQuery(ctx, "", []byte(k))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, k, string(resp.Response.Key))
|
|
assert.Equal(t, v, string(resp.Response.Value))
|
|
}
|
|
})
|
|
}
|
|
|
|
// Tests that the app hash (as reported by the app) matches the last
|
|
// block and the node sync status.
|
|
func TestApp_Hash(t *testing.T) {
|
|
testNode(t, func(t *testing.T, node e2e.Node) {
|
|
client, err := node.Client()
|
|
require.NoError(t, err)
|
|
info, err := client.ABCIInfo(ctx)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, info.Response.LastBlockAppHash, "expected app to return app hash")
|
|
|
|
status, err := client.Status(ctx)
|
|
require.NoError(t, err)
|
|
|
|
block, err := client.Block(ctx, &info.Response.LastBlockHeight)
|
|
require.NoError(t, err)
|
|
|
|
if info.Response.LastBlockHeight == block.Block.Height {
|
|
require.EqualValues(t, info.Response.LastBlockAppHash, block.Block.AppHash.Bytes(),
|
|
"app hash does not match last block's app hash")
|
|
}
|
|
|
|
require.True(t, status.SyncInfo.LatestBlockHeight >= info.Response.LastBlockHeight,
|
|
"status out of sync with application")
|
|
})
|
|
}
|
|
|
|
// Tests that we can set a value and retrieve it.
|
|
func TestApp_Tx(t *testing.T) {
|
|
type broadcastFunc func(context.Context, types.Tx) error
|
|
|
|
testCases := []struct {
|
|
Name string
|
|
WaitTime time.Duration
|
|
BroadcastTx func(client *http.HTTP) broadcastFunc
|
|
ShouldSkip bool
|
|
}{
|
|
{
|
|
Name: "Sync",
|
|
WaitTime: time.Minute,
|
|
BroadcastTx: func(client *http.HTTP) broadcastFunc {
|
|
return func(ctx context.Context, tx types.Tx) error {
|
|
_, err := client.BroadcastTxSync(ctx, tx)
|
|
return err
|
|
}
|
|
},
|
|
},
|
|
{
|
|
Name: "Commit",
|
|
WaitTime: 15 * time.Second,
|
|
// TODO: turn this check back on if it can
|
|
// return reliably. Currently these calls have
|
|
// a hard timeout of 10s (server side
|
|
// configured). The Sync check is probably
|
|
// safe.
|
|
ShouldSkip: true,
|
|
BroadcastTx: func(client *http.HTTP) broadcastFunc {
|
|
return func(ctx context.Context, tx types.Tx) error {
|
|
_, err := client.BroadcastTxCommit(ctx, tx)
|
|
return err
|
|
}
|
|
},
|
|
},
|
|
{
|
|
Name: "Async",
|
|
WaitTime: 90 * time.Second,
|
|
// TODO: turn this check back on if there's a
|
|
// way to avoid failures in the case that the
|
|
// transaction doesn't make it into the
|
|
// mempool. (retries?)
|
|
ShouldSkip: true,
|
|
BroadcastTx: func(client *http.HTTP) broadcastFunc {
|
|
return func(ctx context.Context, tx types.Tx) error {
|
|
_, err := client.BroadcastTxAsync(ctx, tx)
|
|
return err
|
|
}
|
|
},
|
|
},
|
|
}
|
|
|
|
for idx, test := range testCases {
|
|
if test.ShouldSkip {
|
|
continue
|
|
}
|
|
t.Run(test.Name, func(t *testing.T) {
|
|
// testNode calls t.Parallel as well, so we should
|
|
// have a copy of the
|
|
test := testCases[idx]
|
|
testNode(t, func(t *testing.T, node e2e.Node) {
|
|
client, err := node.Client()
|
|
require.NoError(t, err)
|
|
|
|
// Generate a random value, to prevent duplicate tx errors when
|
|
// manually running the test multiple times for a testnet.
|
|
bz := make([]byte, 32)
|
|
_, err = rand.Read(bz)
|
|
require.NoError(t, err)
|
|
|
|
key := fmt.Sprintf("testapp-tx-%v", node.Name)
|
|
value := fmt.Sprintf("%x", bz)
|
|
tx := types.Tx(fmt.Sprintf("%v=%v", key, value))
|
|
|
|
require.NoError(t, test.BroadcastTx(client)(ctx, tx))
|
|
|
|
hash := tx.Hash()
|
|
|
|
require.Eventuallyf(t, func() bool {
|
|
txResp, err := client.Tx(ctx, hash, false)
|
|
return err == nil && bytes.Equal(txResp.Tx, tx)
|
|
},
|
|
test.WaitTime, // timeout
|
|
time.Second, // interval
|
|
"submitted tx %X wasn't committed after %v",
|
|
hash, test.WaitTime,
|
|
)
|
|
|
|
abciResp, err := client.ABCIQuery(ctx, "", []byte(key))
|
|
require.NoError(t, err)
|
|
assert.Equal(t, key, string(abciResp.Response.Key))
|
|
assert.Equal(t, value, string(abciResp.Response.Value))
|
|
})
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|