Update evidence tests

x/evidence/genesis_test.go

@@ -3,16 +3,16 @@ package evidence_test
 import (
 	"testing"
 
+	"github.com/stretchr/testify/suite"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto/ed25519"
+	"github.com/tendermint/tendermint/types/time"
 
 	"github.com/cosmos/cosmos-sdk/simapp"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/evidence"
 	"github.com/cosmos/cosmos-sdk/x/evidence/exported"
 	"github.com/cosmos/cosmos-sdk/x/evidence/types"
-
-	"github.com/stretchr/testify/suite"
 )
 
 type GenesisTestSuite struct {
@@ -26,42 +26,20 @@ func (suite *GenesisTestSuite) SetupTest() {
 	checkTx := false
 	app := simapp.Setup(checkTx)
 
-	// get the app's codec and register custom testing types
-	cdc := app.Codec()
-	cdc.RegisterConcrete(types.TestEquivocationEvidence{}, "test/TestEquivocationEvidence", nil)
-
-	// recreate keeper in order to use custom testing types
-	evidenceKeeper := evidence.NewKeeper(
-		types.ModuleCdc, app.GetKey(evidence.StoreKey), app.GetSubspace(evidence.ModuleName), app.StakingKeeper, app.SlashingKeeper,
-	)
-	router := evidence.NewRouter()
-	router = router.AddRoute(types.TestEvidenceRouteEquivocation, types.TestEquivocationHandler(*evidenceKeeper))
-	evidenceKeeper.SetRouter(router)
-
 	suite.ctx = app.BaseApp.NewContext(checkTx, abci.Header{Height: 1})
-	suite.keeper = *evidenceKeeper
+	suite.keeper = app.EvidenceKeeper
 }
 
 func (suite *GenesisTestSuite) TestInitGenesis_Valid() {
 	pk := ed25519.GenPrivKey()
 
-	testEvidence := make([]exported.EvidenceI, 100)
+	testEvidence := make([]exported.Evidence, 100)
 	for i := 0; i < 100; i++ {
-		sv := types.TestVote{
-			ValidatorAddress: pk.PubKey().Address(),
-			Height:           int64(i),
-			Round:            0,
-		}
-		sig, err := pk.Sign(sv.SignBytes("test-chain"))
-		suite.NoError(err)
-		sv.Signature = sig
-
-		testEvidence[i] = types.TestEquivocationEvidence{
-			Power:      100,
-			TotalPower: 100000,
-			PubKey:     pk.PubKey(),
-			VoteA:      sv,
-			VoteB:      sv,
+		testEvidence[i] = types.Equivocation{
+			Height:           int64(i + 1),
+			Power:            100,
+			Time:             time.Now().UTC(),
+			ConsensusAddress: pk.PubKey().Address().Bytes(),
 		}
 	}
 
@@ -78,23 +56,12 @@ func (suite *GenesisTestSuite) TestInitGenesis_Valid() {
 func (suite *GenesisTestSuite) TestInitGenesis_Invalid() {
 	pk := ed25519.GenPrivKey()
 
-	testEvidence := make([]exported.EvidenceI, 100)
+	testEvidence := make([]exported.Evidence, 100)
 	for i := 0; i < 100; i++ {
-		sv := types.TestVote{
-			ValidatorAddress: pk.PubKey().Address(),
-			Height:           int64(i),
-			Round:            0,
-		}
-		sig, err := pk.Sign(sv.SignBytes("test-chain"))
-		suite.NoError(err)
-		sv.Signature = sig
-
-		testEvidence[i] = types.TestEquivocationEvidence{
-			Power:      100,
-			TotalPower: 100000,
-			PubKey:     pk.PubKey(),
-			VoteA:      sv,
-			VoteB:      types.TestVote{Height: 10, Round: 1},
+		testEvidence[i] = types.Equivocation{
+			Power:            100,
+			Time:             time.Now().UTC(),
+			ConsensusAddress: pk.PubKey().Address().Bytes(),
 		}
 	}
 

x/evidence/handler.go

@@ -3,37 +3,44 @@ package evidence
 import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+	"github.com/cosmos/cosmos-sdk/x/evidence/exported"
 )
 
 func NewHandler(k Keeper) sdk.Handler {
 	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
 		ctx = ctx.WithEventManager(sdk.NewEventManager())
 
 		switch msg := msg.(type) {
-		case MsgSubmitEvidence:
-			return handleMsgSubmitEvidence(ctx, k, msg)
+		case MsgSubmitEvidenceBase:
+			return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "%T must be extended to support evidence", msg)
 
 		default:
+			msgSubEv, ok := msg.(exported.MsgSubmitEvidence)
+			if ok {
+				return handleMsgSubmitEvidence(ctx, k, msgSubEv)
+			}
+
 			return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized %s message type: %T", ModuleName, msg)
 		}
 	}
 }
 
-func handleMsgSubmitEvidence(ctx sdk.Context, k Keeper, msg MsgSubmitEvidence) (*sdk.Result, error) {
-	if err := k.SubmitEvidence(ctx, msg.Evidence); err != nil {
+func handleMsgSubmitEvidence(ctx sdk.Context, k Keeper, msg exported.MsgSubmitEvidence) (*sdk.Result, error) {
+	evidence := msg.GetEvidence()
+	if err := k.SubmitEvidence(ctx, evidence); err != nil {
 		return nil, err
 	}
 
 	ctx.EventManager().EmitEvent(
 		sdk.NewEvent(
 			sdk.EventTypeMessage,
 			sdk.NewAttribute(sdk.AttributeKeyModule, AttributeValueCategory),
-			sdk.NewAttribute(sdk.AttributeKeySender, msg.Submitter.String()),
+			sdk.NewAttribute(sdk.AttributeKeySender, msg.GetSubmitter().String()),
 		),
 	)
 
 	return &sdk.Result{
-		Data:   msg.Evidence.Hash(),
+		Data:   evidence.Hash(),
 		Events: ctx.EventManager().Events(),
 	}, nil
 }

x/evidence/handler_test.go

@@ -1,102 +1,118 @@
 package evidence_test
 
 import (
+	"fmt"
 	"testing"
+	"time"
+
+	"github.com/stretchr/testify/suite"
+	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/crypto/ed25519"
 
 	"github.com/cosmos/cosmos-sdk/simapp"
+	simappcodec "github.com/cosmos/cosmos-sdk/simapp/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/evidence"
+	"github.com/cosmos/cosmos-sdk/x/evidence/exported"
 	"github.com/cosmos/cosmos-sdk/x/evidence/types"
-
-	"github.com/stretchr/testify/suite"
-	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto/ed25519"
 )
 
 type HandlerTestSuite struct {
 	suite.Suite
 
-	ctx     sdk.Context
 	handler sdk.Handler
-	keeper  evidence.Keeper
+	app     *simapp.SimApp
+}
+
+func testEquivocationHandler(k interface{}) types.Handler {
+	return func(ctx sdk.Context, e exported.Evidence) error {
+		if err := e.ValidateBasic(); err != nil {
+			return err
+		}
+
+		ee, ok := e.(*types.Equivocation)
+		if !ok {
+			return fmt.Errorf("unexpected evidence type: %T", e)
+		}
+		if ee.Height%2 == 0 {
+			return fmt.Errorf("unexpected even evidence height: %d", ee.Height)
+		}
+
+		return nil
+	}
 }
 
 func (suite *HandlerTestSuite) SetupTest() {
 	checkTx := false
 	app := simapp.Setup(checkTx)
 
-	// get the app's codec and register custom testing types
-	cdc := app.Codec()
-	cdc.RegisterConcrete(types.TestEquivocationEvidence{}, "test/TestEquivocationEvidence", nil)
-
 	// recreate keeper in order to use custom testing types
 	evidenceKeeper := evidence.NewKeeper(
-		types.ModuleCdc, app.GetKey(evidence.StoreKey), app.GetSubspace(evidence.ModuleName), app.StakingKeeper, app.SlashingKeeper,
+		simappcodec.NewAppCodec(app.Codec()), app.GetKey(evidence.StoreKey),
+		app.GetSubspace(evidence.ModuleName), app.StakingKeeper, app.SlashingKeeper,
 	)
 	router := evidence.NewRouter()
-	router = router.AddRoute(types.TestEvidenceRouteEquivocation, types.TestEquivocationHandler(*evidenceKeeper))
+	router = router.AddRoute(types.RouteEquivocation, testEquivocationHandler(*evidenceKeeper))
 	evidenceKeeper.SetRouter(router)
 
-	suite.ctx = app.BaseApp.NewContext(checkTx, abci.Header{Height: 1})
+	app.EvidenceKeeper = *evidenceKeeper
+
 	suite.handler = evidence.NewHandler(*evidenceKeeper)
-	suite.keeper = *evidenceKeeper
+	suite.app = app
 }
 
-func (suite *HandlerTestSuite) TestMsgSubmitEvidence_Valid() {
+func (suite *HandlerTestSuite) TestMsgSubmitEvidence() {
 	pk := ed25519.GenPrivKey()
-	sv := types.TestVote{
-		ValidatorAddress: pk.PubKey().Address(),
-		Height:           11,
-		Round:            0,
-	}
-
-	sig, err := pk.Sign(sv.SignBytes(suite.ctx.ChainID()))
-	suite.NoError(err)
-	sv.Signature = sig
-
 	s := sdk.AccAddress("test")
-	e := types.TestEquivocationEvidence{
-		Power:      100,
-		TotalPower: 100000,
-		PubKey:     pk.PubKey(),
-		VoteA:      sv,
-		VoteB:      sv,
-	}
 
-	ctx := suite.ctx.WithIsCheckTx(false)
-	msg := evidence.NewMsgSubmitEvidence(e, s)
-	res, err := suite.handler(ctx, msg)
-	suite.NoError(err)
-	suite.NotNil(res)
-	suite.Equal(e.Hash().Bytes(), res.Data)
-}
-
-func (suite *HandlerTestSuite) TestMsgSubmitEvidence_Invalid() {
-	pk := ed25519.GenPrivKey()
-	sv := types.TestVote{
-		ValidatorAddress: pk.PubKey().Address(),
-		Height:           11,
-		Round:            0,
+	testCases := []struct {
+		msg       sdk.Msg
+		expectErr bool
+	}{
+		{
+			simappcodec.NewMsgSubmitEvidence(
+				&types.Equivocation{
+					Height:           11,
+					Time:             time.Now().UTC(),
+					Power:            100,
+					ConsensusAddress: pk.PubKey().Address().Bytes(),
+				},
+				s,
+			),
+			false,
+		},
+		{
+			simappcodec.NewMsgSubmitEvidence(
+				&types.Equivocation{
+					Height:           10,
+					Time:             time.Now().UTC(),
+					Power:            100,
+					ConsensusAddress: pk.PubKey().Address().Bytes(),
+				},
+				s,
+			),
+			true,
+		},
+		{
+			types.NewMsgSubmitEvidenceBase(s),
+			true,
+		},
 	}
 
-	sig, err := pk.Sign(sv.SignBytes(suite.ctx.ChainID()))
-	suite.NoError(err)
-	sv.Signature = sig
+	for i, tc := range testCases {
+		ctx := suite.app.BaseApp.NewContext(false, abci.Header{Height: suite.app.LastBlockHeight() + 1})
 
-	s := sdk.AccAddress("test")
-	e := types.TestEquivocationEvidence{
-		Power:      100,
-		TotalPower: 100000,
-		PubKey:     pk.PubKey(),
-		VoteA:      sv,
-		VoteB:      types.TestVote{Height: 10, Round: 1},
-	}
+		res, err := suite.handler(ctx, tc.msg)
+		if tc.expectErr {
+			suite.Require().Error(err, "expected error; tc #%d", i)
+		} else {
+			suite.Require().NoError(err, "unexpected error; tc #%d", i)
+			suite.Require().NotNil(res, "expected non-nil result; tc #%d", i)
 
-	ctx := suite.ctx.WithIsCheckTx(false)
-	msg := evidence.NewMsgSubmitEvidence(e, s)
-	res, err := suite.handler(ctx, msg)
-	suite.Error(err)
-	suite.Nil(res)
+			msg := tc.msg.(simappcodec.MsgSubmitEvidence)
+			suite.Require().Equal(msg.GetEvidence().Hash().Bytes(), res.Data, "invalid hash; tc #%d", i)
+		}
+	}
 }
 
 func TestHandlerTestSuite(t *testing.T) {