Fix codecov: `statesync: improve e2e test outcomes (backport #6378) (…

…#6380)`

config/config_test.go

@@ -126,6 +126,35 @@ func TestMempoolConfigValidateBasic(t *testing.T) {
 func TestStateSyncConfigValidateBasic(t *testing.T) {
 	cfg := TestStateSyncConfig()
 	require.NoError(t, cfg.ValidateBasic())
+
+	testVerify := func(expectedError string) {
+		actual := cfg.ValidateBasic()
+		require.Error(t, actual)
+		require.Equal(t, expectedError, actual.Error())
+	}
+
+	// Enabled
+	cfg.Enable = true
+	testVerify("rpc_servers is required")
+	cfg.RPCServers = []string{""}
+	testVerify("at least two rpc_servers entries is required")
+	cfg.RPCServers = []string{"", ""}
+	testVerify("found empty rpc_servers entry")
+	cfg.RPCServers = []string{"a", "b"}
+	cfg.DiscoveryTime = 1 * time.Second
+	testVerify("discovery time must be 0s or greater than five seconds")
+	cfg.DiscoveryTime = 0
+	cfg.TrustPeriod = 0
+	testVerify("trusted_period is required")
+	cfg.TrustPeriod = 1
+	testVerify("trusted_height is required")
+	cfg.TrustHeight = 1
+	testVerify("trusted_hash is required")
+	cfg.TrustHash = "0"
+	testVerify("invalid trusted_hash: encoding/hex: odd length hex string")
+	cfg.TrustHash = "00"
+	// Success with Enabled
+	require.NoError(t, cfg.ValidateBasic())
 }
 
 func TestFastSyncConfigValidateBasic(t *testing.T) {

statesync/reactor_test.go

@@ -4,6 +4,16 @@ import (
 	"testing"
 	"time"
 
+	"github.com/line/ostracon/config"
+	"github.com/line/ostracon/libs/log"
+	tmstate "github.com/line/ostracon/proto/ostracon/state"
+	tmversion "github.com/line/ostracon/proto/ostracon/version"
+	"github.com/line/ostracon/proxy"
+	sm "github.com/line/ostracon/state"
+	"github.com/line/ostracon/statesync/mocks"
+	"github.com/line/ostracon/types"
+	"github.com/line/ostracon/version"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
@@ -155,3 +165,152 @@ func TestReactor_Receive_SnapshotsRequest(t *testing.T) {
 		})
 	}
 }
+
+func makeTestStateSyncReactor(
+	t *testing.T, appHash string, height int64, snapshot *snapshot, chunks []*chunk) *Reactor {
+	connSnapshot := makeMockAppConnSnapshot(appHash, snapshot, chunks)
+	connQuery := makeMockAppConnQuery(appHash, height)
+
+	p2pConfig := config.DefaultP2PConfig()
+	p2pConfig.PexReactor = true
+	p2pConfig.AllowDuplicateIP = true
+
+	name := "STATE_SYNC_REACTOR_FOR_TEST"
+	size := 2
+	reactors := make([]*Reactor, size)
+	initSwitch := func(i int, s *p2p.Switch, config *config.P2PConfig) *p2p.Switch {
+		logger := log.TestingLogger()
+		reactors[i] = NewReactor(connSnapshot, connQuery, true, 1000)
+		reactors[i].SetLogger(logger)
+		reactors[i].SetSwitch(s)
+
+		s.AddReactor(name, reactors[i])
+		s.SetLogger(logger)
+		return s
+	}
+	switches := p2p.MakeConnectedSwitches(p2pConfig, size, initSwitch, p2p.Connect2Switches)
+
+	t.Cleanup(func() {
+		for i := 0; i < size; i++ {
+			if err := switches[i].Stop(); err != nil {
+				t.Error(err)
+			}
+		}
+	})
+
+	return reactors[0]
+}
+
+func makeMockAppConnSnapshot(appHash string, snapshot *snapshot, chunks []*chunk) *proxymocks.AppConnSnapshot {
+	connSnapshot := &proxymocks.AppConnSnapshot{}
+
+	connSnapshot.On("OfferSnapshotSync", abci.RequestOfferSnapshot{
+		Snapshot: &abci.Snapshot{
+			Height: snapshot.Height,
+			Format: snapshot.Format,
+			Chunks: snapshot.Chunks,
+			Hash:   snapshot.Hash,
+		},
+		AppHash: []byte(appHash),
+	}).Return(&abci.ResponseOfferSnapshot{Result: abci.ResponseOfferSnapshot_ACCEPT}, nil)
+
+	connSnapshot.On("ListSnapshotsSync", abci.RequestListSnapshots{}).Return(&abci.ResponseListSnapshots{
+		Snapshots: []*abci.Snapshot{{
+			Height:   snapshot.Height,
+			Format:   snapshot.Format,
+			Chunks:   snapshot.Chunks,
+			Hash:     snapshot.Hash,
+			Metadata: snapshot.Metadata,
+		}},
+	}, nil)
+
+	index := len(chunks)
+	for i := 0; i < index; i++ {
+		connSnapshot.On("ApplySnapshotChunkSync",
+			mock.Anything).Return(&abci.ResponseApplySnapshotChunk{Result: abci.ResponseApplySnapshotChunk_ACCEPT}, nil)
+		connSnapshot.On("LoadSnapshotChunkSync", abci.RequestLoadSnapshotChunk{
+			Height: chunks[i].Height, Format: chunks[i].Format, Chunk: chunks[i].Index,
+		}).Return(&abci.ResponseLoadSnapshotChunk{Chunk: chunks[i].Chunk}, nil)
+	}
+
+	return connSnapshot
+}
+
+func makeMockAppConnQuery(appHash string, height int64) *proxymocks.AppConnQuery {
+	connQuery := &proxymocks.AppConnQuery{}
+	connQuery.On("InfoSync", proxy.RequestInfo).Return(&abci.ResponseInfo{
+		AppVersion:       9,
+		LastBlockHeight:  height,
+		LastBlockAppHash: []byte(appHash),
+	}, nil)
+	return connQuery
+}
+
+func makeTestStateAndCommit(appHash string, height int64) (sm.State, *types.Commit) {
+	blockHash := "block_hash"
+
+	state := sm.State{
+		ChainID: "chain",
+		Version: tmstate.Version{
+			Consensus: tmversion.Consensus{
+				Block: version.BlockProtocol,
+				App:   0,
+			},
+
+			Software: version.OCCoreSemVer,
+		},
+
+		LastBlockHeight: height,
+		LastBlockID:     types.BlockID{Hash: []byte(blockHash)},
+		LastBlockTime:   time.Now(),
+		LastResultsHash: []byte("last_results_hash"),
+		AppHash:         []byte(appHash),
+
+		LastVoters:     &types.VoterSet{},
+		Validators:     &types.ValidatorSet{},
+		Voters:         &types.VoterSet{},
+		NextValidators: &types.ValidatorSet{},
+		VoterParams:    types.DefaultVoterParams(),
+
+		ConsensusParams:                  *types.DefaultConsensusParams(),
+		LastHeightConsensusParamsChanged: 1,
+	}
+
+	commit := &types.Commit{BlockID: types.BlockID{Hash: []byte(blockHash)}}
+
+	return state, commit
+}
+
+func makeMockStateProvider(appHash string, height uint64) *mocks.StateProvider {
+	state, commit := makeTestStateAndCommit(appHash, int64(height))
+
+	stateProvider := &mocks.StateProvider{}
+	stateProvider.On("AppHash", mock.Anything, mock.Anything).Return([]byte(appHash), nil)
+	stateProvider.On("State", mock.Anything, height).Return(state, nil)
+	stateProvider.On("Commit", mock.Anything, height).Return(commit, nil)
+	return stateProvider
+}
+
+func TestSync(t *testing.T) {
+	// prepare
+	height, format := uint64(1), uint32(1)
+	appHash := "app_hash"
+
+	chunks := []*chunk{
+		{Height: height, Format: format, Index: 0, Chunk: []byte{1, 1, 0}},
+		{Height: height, Format: format, Index: 1, Chunk: []byte{1, 1, 1}},
+		{Height: height, Format: format, Index: 2, Chunk: []byte{1, 1, 2}},
+	}
+	snapshot := &snapshot{Height: height, Format: format, Chunks: uint32(len(chunks)), Hash: []byte{1, 2, 3}}
+	reactor := makeTestStateSyncReactor(t, appHash, int64(height), snapshot, chunks)
+	stateProvider := makeMockStateProvider(appHash, height)
+
+	// test
+	state, previousState, commit, err := reactor.Sync(stateProvider, 5*time.Second)
+
+	// verify
+	require.NoError(t, err)
+	require.NotNil(t, state)
+	require.NotNil(t, previousState)
+	require.NotNil(t, commit)
+}