github.com/okex/exchain@v1.8.0/libs/tendermint/evidence/pool_test.go (about)

     1  package evidence
     2  
     3  import (
     4  	"os"
     5  	"sync"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  
    11  	dbm "github.com/okex/exchain/libs/tm-db"
    12  
    13  	sm "github.com/okex/exchain/libs/tendermint/state"
    14  	"github.com/okex/exchain/libs/tendermint/types"
    15  	tmtime "github.com/okex/exchain/libs/tendermint/types/time"
    16  )
    17  
    18  func TestMain(m *testing.M) {
    19  	types.RegisterMockEvidences(cdc)
    20  
    21  	code := m.Run()
    22  	os.Exit(code)
    23  }
    24  
    25  func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
    26  	stateDB := dbm.NewMemDB()
    27  
    28  	// create validator set and state
    29  	valSet := &types.ValidatorSet{
    30  		Validators: []*types.Validator{
    31  			{Address: valAddr},
    32  		},
    33  	}
    34  	state := sm.State{
    35  		LastBlockHeight:             0,
    36  		LastBlockTime:               tmtime.Now(),
    37  		Validators:                  valSet,
    38  		NextValidators:              valSet.CopyIncrementProposerPriority(1),
    39  		LastHeightValidatorsChanged: 1,
    40  		ConsensusParams: types.ConsensusParams{
    41  			Evidence: types.EvidenceParams{
    42  				MaxAgeNumBlocks: 10000,
    43  				MaxAgeDuration:  48 * time.Hour,
    44  			},
    45  		},
    46  	}
    47  
    48  	// save all states up to height
    49  	for i := int64(0); i < height; i++ {
    50  		state.LastBlockHeight = i
    51  		sm.SaveState(stateDB, state)
    52  	}
    53  
    54  	return stateDB
    55  }
    56  
    57  func TestEvidencePool(t *testing.T) {
    58  
    59  	var (
    60  		valAddr      = []byte("val1")
    61  		height       = int64(100002)
    62  		stateDB      = initializeValidatorState(valAddr, height)
    63  		evidenceDB   = dbm.NewMemDB()
    64  		pool         = NewPool(stateDB, evidenceDB)
    65  		evidenceTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
    66  	)
    67  
    68  	goodEvidence := types.NewMockEvidence(height, time.Now(), 0, valAddr)
    69  	badEvidence := types.NewMockEvidence(1, evidenceTime, 0, valAddr)
    70  
    71  	// bad evidence
    72  	err := pool.AddEvidence(badEvidence)
    73  	assert.Error(t, err)
    74  	// err: evidence created at 2019-01-01 00:00:00 +0000 UTC has expired. Evidence can not be older than: ...
    75  
    76  	var wg sync.WaitGroup
    77  	wg.Add(1)
    78  	go func() {
    79  		<-pool.EvidenceWaitChan()
    80  		wg.Done()
    81  	}()
    82  
    83  	err = pool.AddEvidence(goodEvidence)
    84  	assert.NoError(t, err)
    85  	wg.Wait()
    86  
    87  	assert.Equal(t, 1, pool.evidenceList.Len())
    88  
    89  	// if we send it again, it shouldnt add and return an error
    90  	err = pool.AddEvidence(goodEvidence)
    91  	assert.Error(t, err)
    92  	assert.Equal(t, 1, pool.evidenceList.Len())
    93  }
    94  
    95  func TestEvidencePoolIsCommitted(t *testing.T) {
    96  	// Initialization:
    97  	var (
    98  		valAddr       = []byte("validator_address")
    99  		height        = int64(42)
   100  		lastBlockTime = time.Now()
   101  		stateDB       = initializeValidatorState(valAddr, height)
   102  		evidenceDB    = dbm.NewMemDB()
   103  		pool          = NewPool(stateDB, evidenceDB)
   104  	)
   105  
   106  	// evidence not seen yet:
   107  	evidence := types.NewMockEvidence(height, time.Now(), 0, valAddr)
   108  	assert.False(t, pool.IsCommitted(evidence))
   109  
   110  	// evidence seen but not yet committed:
   111  	assert.NoError(t, pool.AddEvidence(evidence))
   112  	assert.False(t, pool.IsCommitted(evidence))
   113  
   114  	// evidence seen and committed:
   115  	pool.MarkEvidenceAsCommitted(height, lastBlockTime, []types.Evidence{evidence})
   116  	assert.True(t, pool.IsCommitted(evidence))
   117  }
   118  
   119  func TestAddEvidence(t *testing.T) {
   120  
   121  	var (
   122  		valAddr      = []byte("val1")
   123  		height       = int64(100002)
   124  		stateDB      = initializeValidatorState(valAddr, height)
   125  		evidenceDB   = dbm.NewMemDB()
   126  		pool         = NewPool(stateDB, evidenceDB)
   127  		evidenceTime = time.Date(2019, 1, 1, 0, 0, 0, 0, time.UTC)
   128  	)
   129  
   130  	testCases := []struct {
   131  		evHeight      int64
   132  		evTime        time.Time
   133  		expErr        bool
   134  		evDescription string
   135  	}{
   136  		{height, time.Now(), false, "valid evidence"},
   137  		{height, evidenceTime, false, "valid evidence (despite old time)"},
   138  		{int64(1), time.Now(), false, "valid evidence (despite old height)"},
   139  		{int64(1), evidenceTime, true,
   140  			"evidence from height 1 (created at: 2019-01-01 00:00:00 +0000 UTC) is too old"},
   141  	}
   142  
   143  	for _, tc := range testCases {
   144  		tc := tc
   145  		ev := types.NewMockEvidence(tc.evHeight, tc.evTime, 0, valAddr)
   146  		err := pool.AddEvidence(ev)
   147  		if tc.expErr {
   148  			assert.Error(t, err)
   149  		}
   150  	}
   151  }