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

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