github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/cosmos-sdk/x/evidence/genesis_test.go (about)

     1  package evidence_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	abci "github.com/fibonacci-chain/fbc/libs/tendermint/abci/types"
     7  	"github.com/fibonacci-chain/fbc/libs/tendermint/crypto/ed25519"
     8  
     9  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/simapp"
    10  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    11  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/evidence"
    12  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/evidence/exported"
    13  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/evidence/internal/types"
    14  
    15  	"github.com/stretchr/testify/suite"
    16  )
    17  
    18  type GenesisTestSuite struct {
    19  	suite.Suite
    20  
    21  	ctx    sdk.Context
    22  	keeper evidence.Keeper
    23  }
    24  
    25  func (suite *GenesisTestSuite) SetupTest() {
    26  	checkTx := false
    27  	app := simapp.Setup(checkTx)
    28  
    29  	// get the app's codec and register custom testing types
    30  	cdc := app.Codec()
    31  	cdc.RegisterConcrete(types.TestEquivocationEvidence{}, "test/TestEquivocationEvidence", nil)
    32  
    33  	// recreate keeper in order to use custom testing types
    34  	evidenceKeeper := evidence.NewKeeper(
    35  		cdc, app.GetKey(evidence.StoreKey), app.GetSubspace(evidence.ModuleName), app.StakingKeeper, app.SlashingKeeper,
    36  	)
    37  	router := evidence.NewRouter()
    38  	router = router.AddRoute(types.TestEvidenceRouteEquivocation, types.TestEquivocationHandler(*evidenceKeeper))
    39  	evidenceKeeper.SetRouter(router)
    40  
    41  	suite.ctx = app.BaseApp.NewContext(checkTx, abci.Header{Height: 1})
    42  	suite.keeper = *evidenceKeeper
    43  }
    44  
    45  func (suite *GenesisTestSuite) TestInitGenesis_Valid() {
    46  	pk := ed25519.GenPrivKey()
    47  
    48  	testEvidence := make([]exported.Evidence, 100)
    49  	for i := 0; i < 100; i++ {
    50  		sv := types.TestVote{
    51  			ValidatorAddress: pk.PubKey().Address(),
    52  			Height:           int64(i),
    53  			Round:            0,
    54  		}
    55  		sig, err := pk.Sign(sv.SignBytes("test-chain"))
    56  		suite.NoError(err)
    57  		sv.Signature = sig
    58  
    59  		testEvidence[i] = types.TestEquivocationEvidence{
    60  			Power:      100,
    61  			TotalPower: 100000,
    62  			PubKey:     pk.PubKey(),
    63  			VoteA:      sv,
    64  			VoteB:      sv,
    65  		}
    66  	}
    67  
    68  	suite.NotPanics(func() {
    69  		evidence.InitGenesis(suite.ctx, suite.keeper, evidence.NewGenesisState(types.DefaultParams(), testEvidence))
    70  	})
    71  
    72  	for _, e := range testEvidence {
    73  		_, ok := suite.keeper.GetEvidence(suite.ctx, e.Hash())
    74  		suite.True(ok)
    75  	}
    76  }
    77  
    78  func (suite *GenesisTestSuite) TestInitGenesis_Invalid() {
    79  	pk := ed25519.GenPrivKey()
    80  
    81  	testEvidence := make([]exported.Evidence, 100)
    82  	for i := 0; i < 100; i++ {
    83  		sv := types.TestVote{
    84  			ValidatorAddress: pk.PubKey().Address(),
    85  			Height:           int64(i),
    86  			Round:            0,
    87  		}
    88  		sig, err := pk.Sign(sv.SignBytes("test-chain"))
    89  		suite.NoError(err)
    90  		sv.Signature = sig
    91  
    92  		testEvidence[i] = types.TestEquivocationEvidence{
    93  			Power:      100,
    94  			TotalPower: 100000,
    95  			PubKey:     pk.PubKey(),
    96  			VoteA:      sv,
    97  			VoteB:      types.TestVote{Height: 10, Round: 1},
    98  		}
    99  	}
   100  
   101  	suite.Panics(func() {
   102  		evidence.InitGenesis(suite.ctx, suite.keeper, evidence.NewGenesisState(types.DefaultParams(), testEvidence))
   103  	})
   104  
   105  	suite.Empty(suite.keeper.GetAllEvidence(suite.ctx))
   106  }
   107  
   108  func TestGenesisTestSuite(t *testing.T) {
   109  	suite.Run(t, new(GenesisTestSuite))
   110  }