github.com/okex/exchain@v1.8.0/libs/tendermint/lite/proxy/query_test.go

package proxy

import (
	"fmt"
	"os"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/okex/exchain/libs/tendermint/abci/example/kvstore"
	cfg "github.com/okex/exchain/libs/tendermint/config"
	"github.com/okex/exchain/libs/tendermint/crypto/merkle"
	"github.com/okex/exchain/libs/tendermint/lite"
	certclient "github.com/okex/exchain/libs/tendermint/lite/client"
	nm "github.com/okex/exchain/libs/tendermint/node"
	"github.com/okex/exchain/libs/tendermint/rpc/client"
	rpclocal "github.com/okex/exchain/libs/tendermint/rpc/client/local"
	rpctest "github.com/okex/exchain/libs/tendermint/rpc/test"
	"github.com/okex/exchain/libs/tendermint/types"
)

var node *nm.Node
var chainID = "tendermint_test" // TODO use from config.
//nolint:unused
var waitForEventTimeout = 5 * time.Second

// TODO fix tests!!

func TestMain(m *testing.M) {
	app := kvstore.NewApplication()
	node = rpctest.StartTendermint(app)

	code := m.Run()

	rpctest.StopTendermint(node)
	os.Exit(code)
}

func kvstoreTx(k, v []byte) []byte {
	return []byte(fmt.Sprintf("%s=%s", k, v))
}

// TODO: enable it after general proof format has been adapted
// in abci/examples/kvstore.go
//nolint:unused,deadcode
func _TestAppProofs(t *testing.T) {
	assert, require := assert.New(t), require.New(t)

	prt := defaultProofRuntime()
	cl := rpclocal.New(node)
	client.WaitForHeight(cl, 1, nil)

	// This sets up our trust on the node based on some past point.
	source := certclient.NewProvider(chainID, cl)
	seed, err := source.LatestFullCommit(chainID, 1, 1)
	require.NoError(err, "%#v", err)
	cert := lite.NewBaseVerifier(chainID, seed.Height(), seed.Validators)

	// Wait for tx confirmation.
	done := make(chan int64)
	go func() {
		evtTyp := types.EventTx
		_, err = client.WaitForOneEvent(cl, evtTyp, waitForEventTimeout)
		require.Nil(err, "%#v", err)
		close(done)
	}()

	// Submit a transaction.
	k := []byte("my-key")
	v := []byte("my-value")
	tx := kvstoreTx(k, v)
	br, err := cl.BroadcastTxCommit(tx)
	require.NoError(err, "%#v", err)
	require.EqualValues(0, br.CheckTx.Code, "%#v", br.CheckTx)
	require.EqualValues(0, br.DeliverTx.Code)
	brh := br.Height

	// Fetch latest after tx commit.
	<-done
	latest, err := source.LatestFullCommit(chainID, 1, 1<<63-1)
	require.NoError(err, "%#v", err)
	rootHash := latest.SignedHeader.AppHash
	if rootHash == nil {
		// Fetch one block later, AppHash hasn't been committed yet.
		// TODO find a way to avoid doing this.
		client.WaitForHeight(cl, latest.SignedHeader.Height+1, nil)
		latest, err = source.LatestFullCommit(chainID, latest.SignedHeader.Height+1, 1<<63-1)
		require.NoError(err, "%#v", err)
		rootHash = latest.SignedHeader.AppHash
	}
	require.NotNil(rootHash)

	// verify a query before the tx block has no data (and valid non-exist proof)
	bs, height, proof, err := GetWithProof(prt, k, brh-1, cl, cert)
	require.NoError(err, "%#v", err)
	require.NotNil(proof)
	require.Equal(height, brh-1)
	// require.NotNil(proof)
	// TODO: Ensure that *some* keys will be there, ensuring that proof is nil,
	// (currently there's a race condition)
	// and ensure that proof proves absence of k.
	require.Nil(bs)

	// but given that block it is good
	bs, height, proof, err = GetWithProof(prt, k, brh, cl, cert)
	require.NoError(err, "%#v", err)
	require.NotNil(proof)
	require.Equal(height, brh)

	assert.EqualValues(v, bs)
	err = prt.VerifyValue(proof, rootHash, string(k), bs) // XXX key encoding
	assert.NoError(err, "%#v", err)

	// Test non-existing key.
	missing := []byte("my-missing-key")
	bs, _, proof, err = GetWithProof(prt, missing, 0, cl, cert)
	require.NoError(err)
	require.Nil(bs)
	require.NotNil(proof)
	err = prt.VerifyAbsence(proof, rootHash, string(missing)) // XXX VerifyAbsence(), keyencoding
	assert.NoError(err, "%#v", err)
	err = prt.VerifyAbsence(proof, rootHash, string(k)) // XXX VerifyAbsence(), keyencoding
	assert.Error(err, "%#v", err)
}

func TestTxProofs(t *testing.T) {
	setMocConfig(100)
	assert, require := assert.New(t), require.New(t)

	cl := rpclocal.New(node)
	client.WaitForHeight(cl, 1, nil)

	tx := kvstoreTx([]byte("key-a"), []byte("value-a"))
	br, err := cl.BroadcastTxCommit(tx)
	require.NoError(err, "%#v", err)
	require.EqualValues(0, br.CheckTx.Code, "%#v", br.CheckTx)
	require.EqualValues(0, br.DeliverTx.Code)
	brh := br.Height

	source := certclient.NewProvider(chainID, cl)
	seed, err := source.LatestFullCommit(chainID, brh-2, brh-2)
	require.NoError(err, "%#v", err)
	cert := lite.NewBaseVerifier(chainID, seed.Height(), seed.Validators)

	time.Sleep(1 * time.Second)
	// First let's make sure a bogus transaction hash returns a valid non-existence proof.
	key := types.Tx([]byte("bogus")).Hash(brh)
	_, err = cl.Tx(key, true)
	require.NotNil(err)
	require.Contains(err.Error(), "not found")

	// Now let's check with the real tx root hash.
	key = types.Tx(tx).Hash(brh)
	res, err := cl.Tx(key, true)
	require.NoError(err, "%#v", err)
	require.NotNil(res)
	keyHash := merkle.SimpleHashFromByteSlices([][]byte{key})
	err = res.Proof.Validate(keyHash, brh)
	assert.NoError(err, "%#v", err)

	commit, err := GetCertifiedCommit(br.Height, cl, cert)
	require.Nil(err, "%#v", err)
	require.Equal(res.Proof.RootHash, commit.Header.DataHash)
}

func setMocConfig(clientNum int) {
	moc := cfg.MockDynamicConfig{}
	moc.SetMaxSubscriptionClients(100)

	cfg.SetDynamicConfig(moc)
}