tendermint/statesync/snapshots_test.go

package statesync

import (
	"testing"

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

	"github.com/tendermint/tendermint/p2p"
	"github.com/tendermint/tendermint/statesync/mocks"
)

func TestSnapshot_Key(t *testing.T) {
	testcases := map[string]struct {
		modify func(*snapshot)
	}{
		"new height":      {func(s *snapshot) { s.Height = 9 }},
		"new format":      {func(s *snapshot) { s.Format = 9 }},
		"new chunk count": {func(s *snapshot) { s.Chunks = 9 }},
		"new hash":        {func(s *snapshot) { s.Hash = []byte{9} }},
		"no metadata":     {func(s *snapshot) { s.Metadata = nil }},
	}
	for name, tc := range testcases {
		tc := tc
		t.Run(name, func(t *testing.T) {
			s := snapshot{
				Height:   3,
				Format:   1,
				Chunks:   7,
				Hash:     []byte{1, 2, 3},
				Metadata: []byte{255},
			}
			before := s.Key()
			tc.modify(&s)
			after := s.Key()
			require.NotEqual(t, before, after)
		})
	}
}

func TestSnapshotPool_Add(t *testing.T) {
	stateProvider := &mocks.StateProvider{}
	stateProvider.On("AppHash", mock.Anything, uint64(1)).Return([]byte("app_hash"), nil)

	peerID := p2p.NodeID("aa")

	// Adding to the pool should work
	pool := newSnapshotPool(stateProvider)
	added, err := pool.Add(peerID, &snapshot{
		Height: 1,
		Format: 1,
		Chunks: 1,
		Hash:   []byte{1},
	})
	require.NoError(t, err)
	require.True(t, added)

	// Adding again from a different peer should return false
	otherNodeID := p2p.NodeID("bb")
	added, err = pool.Add(otherNodeID, &snapshot{
		Height: 1,
		Format: 1,
		Chunks: 1,
		Hash:   []byte{1},
	})
	require.NoError(t, err)
	require.False(t, added)

	// The pool should have populated the snapshot with the trusted app hash
	snapshot := pool.Best()
	require.NotNil(t, snapshot)
	require.Equal(t, []byte("app_hash"), snapshot.trustedAppHash)

	stateProvider.AssertExpectations(t)
}

func TestSnapshotPool_GetPeer(t *testing.T) {
	stateProvider := &mocks.StateProvider{}
	stateProvider.On("AppHash", mock.Anything, mock.Anything).Return([]byte("app_hash"), nil)
	pool := newSnapshotPool(stateProvider)

	s := &snapshot{Height: 1, Format: 1, Chunks: 1, Hash: []byte{1}}

	peerAID := p2p.NodeID("aa")
	peerBID := p2p.NodeID("bb")

	_, err := pool.Add(peerAID, s)
	require.NoError(t, err)

	_, err = pool.Add(peerBID, s)
	require.NoError(t, err)

	_, err = pool.Add(peerAID, &snapshot{Height: 2, Format: 1, Chunks: 1, Hash: []byte{1}})
	require.NoError(t, err)

	// GetPeer currently picks a random peer, so lets run it until we've seen both.
	seenA := false
	seenB := false
	for !seenA || !seenB {
		peer := pool.GetPeer(s)
		if peer == peerAID {
			seenA = true
		}
		if peer == peerBID {
			seenB = true
		}
	}

	// GetPeer should return empty for an unknown snapshot
	peer := pool.GetPeer(&snapshot{Height: 9, Format: 9})
	require.EqualValues(t, "", peer)
}

func TestSnapshotPool_GetPeers(t *testing.T) {
	stateProvider := &mocks.StateProvider{}
	stateProvider.On("AppHash", mock.Anything, mock.Anything).Return([]byte("app_hash"), nil)
	pool := newSnapshotPool(stateProvider)

	s := &snapshot{Height: 1, Format: 1, Chunks: 1, Hash: []byte{1}}

	peerAID := p2p.NodeID("aa")
	peerBID := p2p.NodeID("bb")

	_, err := pool.Add(peerAID, s)
	require.NoError(t, err)

	_, err = pool.Add(peerBID, s)
	require.NoError(t, err)

	_, err = pool.Add(peerAID, &snapshot{Height: 2, Format: 1, Chunks: 1, Hash: []byte{2}})
	require.NoError(t, err)

	peers := pool.GetPeers(s)
	require.Len(t, peers, 2)
	require.Equal(t, peerAID, peers[0])
	require.EqualValues(t, peerBID, peers[1])
}

func TestSnapshotPool_Ranked_Best(t *testing.T) {
	stateProvider := &mocks.StateProvider{}
	stateProvider.On("AppHash", mock.Anything, mock.Anything).Return([]byte("app_hash"), nil)
	pool := newSnapshotPool(stateProvider)

	// snapshots in expected order (best to worst). Highest height wins, then highest format.
	// Snapshots with different chunk hashes are considered different, and the most peers is
	// tie-breaker.
	expectSnapshots := []struct {
		snapshot *snapshot
		peers    []p2p.NodeID
	}{
		{&snapshot{Height: 2, Format: 2, Chunks: 4, Hash: []byte{1, 3}}, []p2p.NodeID{"AA", "BB", "CC", "DD"}},
		{&snapshot{Height: 1, Format: 1, Chunks: 4, Hash: []byte{1, 2}}, []p2p.NodeID{"AA", "BB", "CC", "DD"}},
		{&snapshot{Height: 2, Format: 2, Chunks: 5, Hash: []byte{1, 2}}, []p2p.NodeID{"AA", "BB", "CC"}},
		{&snapshot{Height: 2, Format: 1, Chunks: 3, Hash: []byte{1, 2}}, []p2p.NodeID{"AA", "BB", "CC"}},
		{&snapshot{Height: 1, Format: 2, Chunks: 5, Hash: []byte{1, 2}}, []p2p.NodeID{"AA", "BB", "CC"}},
	}

	// Add snapshots in reverse order, to make sure the pool enforces some order.
	for i := len(expectSnapshots) - 1; i >= 0; i-- {
		for _, peerID := range expectSnapshots[i].peers {
			_, err := pool.Add(peerID, expectSnapshots[i].snapshot)
			require.NoError(t, err)
		}
	}

	// Ranked should return the snapshots in the same order
	ranked := pool.Ranked()
	require.Len(t, ranked, len(expectSnapshots))

	for i := range ranked {
		require.Equal(t, expectSnapshots[i].snapshot, ranked[i])
	}

	// Check that best snapshots are returned in expected order
	for i := range expectSnapshots {
		snapshot := expectSnapshots[i].snapshot
		require.Equal(t, snapshot, pool.Best())
		pool.Reject(snapshot)
	}

	require.Nil(t, pool.Best())
}

func TestSnapshotPool_Reject(t *testing.T) {
	stateProvider := &mocks.StateProvider{}
	stateProvider.On("AppHash", mock.Anything, mock.Anything).Return([]byte("app_hash"), nil)
	pool := newSnapshotPool(stateProvider)

	peerID := p2p.NodeID("aa")

	snapshots := []*snapshot{
		{Height: 2, Format: 2, Chunks: 1, Hash: []byte{1, 2}},
		{Height: 2, Format: 1, Chunks: 1, Hash: []byte{1, 2}},
		{Height: 1, Format: 2, Chunks: 1, Hash: []byte{1, 2}},
		{Height: 1, Format: 1, Chunks: 1, Hash: []byte{1, 2}},
	}
	for _, s := range snapshots {
		_, err := pool.Add(peerID, s)
		require.NoError(t, err)
	}

	pool.Reject(snapshots[0])
	require.Equal(t, snapshots[1:], pool.Ranked())

	added, err := pool.Add(peerID, snapshots[0])
	require.NoError(t, err)
	require.False(t, added)

	added, err = pool.Add(peerID, &snapshot{Height: 3, Format: 3, Chunks: 1, Hash: []byte{1}})
	require.NoError(t, err)
	require.True(t, added)
}

func TestSnapshotPool_RejectFormat(t *testing.T) {
	stateProvider := &mocks.StateProvider{}
	stateProvider.On("AppHash", mock.Anything, mock.Anything).Return([]byte("app_hash"), nil)
	pool := newSnapshotPool(stateProvider)

	peerID := p2p.NodeID("aa")

	snapshots := []*snapshot{
		{Height: 2, Format: 2, Chunks: 1, Hash: []byte{1, 2}},
		{Height: 2, Format: 1, Chunks: 1, Hash: []byte{1, 2}},
		{Height: 1, Format: 2, Chunks: 1, Hash: []byte{1, 2}},
		{Height: 1, Format: 1, Chunks: 1, Hash: []byte{1, 2}},
	}
	for _, s := range snapshots {
		_, err := pool.Add(peerID, s)
		require.NoError(t, err)
	}

	pool.RejectFormat(1)
	require.Equal(t, []*snapshot{snapshots[0], snapshots[2]}, pool.Ranked())

	added, err := pool.Add(peerID, &snapshot{Height: 3, Format: 1, Chunks: 1, Hash: []byte{1}})
	require.NoError(t, err)
	require.False(t, added)
	require.Equal(t, []*snapshot{snapshots[0], snapshots[2]}, pool.Ranked())

	added, err = pool.Add(peerID, &snapshot{Height: 3, Format: 3, Chunks: 1, Hash: []byte{1}})
	require.NoError(t, err)
	require.True(t, added)
}

func TestSnapshotPool_RejectPeer(t *testing.T) {
	stateProvider := &mocks.StateProvider{}
	stateProvider.On("AppHash", mock.Anything, mock.Anything).Return([]byte("app_hash"), nil)
	pool := newSnapshotPool(stateProvider)

	peerAID := p2p.NodeID("aa")
	peerBID := p2p.NodeID("bb")

	s1 := &snapshot{Height: 1, Format: 1, Chunks: 1, Hash: []byte{1}}
	s2 := &snapshot{Height: 2, Format: 1, Chunks: 1, Hash: []byte{2}}
	s3 := &snapshot{Height: 3, Format: 1, Chunks: 1, Hash: []byte{2}}

	_, err := pool.Add(peerAID, s1)
	require.NoError(t, err)

	_, err = pool.Add(peerAID, s2)
	require.NoError(t, err)

	_, err = pool.Add(peerBID, s2)
	require.NoError(t, err)

	_, err = pool.Add(peerBID, s3)
	require.NoError(t, err)

	pool.RejectPeer(peerAID)

	require.Empty(t, pool.GetPeers(s1))

	peers2 := pool.GetPeers(s2)
	require.Len(t, peers2, 1)
	require.Equal(t, peerBID, peers2[0])

	peers3 := pool.GetPeers(s2)
	require.Len(t, peers3, 1)
	require.Equal(t, peerBID, peers3[0])

	// it should no longer be possible to add the peer back
	_, err = pool.Add(peerAID, s1)
	require.NoError(t, err)
	require.Empty(t, pool.GetPeers(s1))
}

func TestSnapshotPool_RemovePeer(t *testing.T) {
	stateProvider := &mocks.StateProvider{}
	stateProvider.On("AppHash", mock.Anything, mock.Anything).Return([]byte("app_hash"), nil)
	pool := newSnapshotPool(stateProvider)

	peerAID := p2p.NodeID("aa")
	peerBID := p2p.NodeID("bb")

	s1 := &snapshot{Height: 1, Format: 1, Chunks: 1, Hash: []byte{1}}
	s2 := &snapshot{Height: 2, Format: 1, Chunks: 1, Hash: []byte{2}}

	_, err := pool.Add(peerAID, s1)
	require.NoError(t, err)

	_, err = pool.Add(peerAID, s2)
	require.NoError(t, err)

	_, err = pool.Add(peerBID, s1)
	require.NoError(t, err)

	pool.RemovePeer(peerAID)

	peers1 := pool.GetPeers(s1)
	require.Len(t, peers1, 1)
	require.Equal(t, peerBID, peers1[0])

	peers2 := pool.GetPeers(s2)
	require.Empty(t, peers2)

	// it should still be possible to add the peer back
	_, err = pool.Add(peerAID, s1)
	require.NoError(t, err)

	peers1 = pool.GetPeers(s1)
	require.Len(t, peers1, 2)
	require.Equal(t, peerAID, peers1[0])
	require.Equal(t, peerBID, peers1[1])
}