Test Genesis

x/clock/genesis.go

@@ -35,7 +35,26 @@ func GetGenesisStateFromAppState(cdc codec.Codec, appState map[string]json.RawMe
 }
 
 func ValidateGenesis(data types.GenesisState) error {
-	return data.Params.Validate()
+	err := data.Params.Validate()
+	if err != nil {
+		return err
+	}
+
+	// Validate contracts
+	for _, addr := range data.ContractAddresses {
+		if _, err := sdk.AccAddressFromBech32(addr); err != nil {
+			return err
+		}
+	}
+
+	// Validate jailed contracts
+	for _, addr := range data.JailedContractAddresses {
+		if _, err := sdk.AccAddressFromBech32(addr); err != nil {
+			return err
+		}
+	}
+
+	return nil
 }
 
 // InitGenesis import module genesis
@@ -44,13 +63,25 @@ func InitGenesis(
 	k keeper.Keeper,
 	data types.GenesisState,
 ) {
+	// Validate init contents
 	if err := ValidateGenesis(data); err != nil {
 		panic(err)
 	}
 
+	// Set params
 	if err := k.SetParams(ctx, data.Params); err != nil {
 		panic(err)
 	}
+
+	// Register unjailed contracts
+	for _, addr := range data.ContractAddresses {
+		k.SetClockContract(ctx, addr, false)
+	}
+
+	// Register jailed contracts
+	for _, addr := range data.JailedContractAddresses {
+		k.SetClockContract(ctx, addr, true)
+	}
 }
 
 // ExportGenesis export module state

x/clock/genesis_test.go

@@ -45,65 +45,87 @@ func (suite *GenesisTestSuite) TestClockInitGenesis() {
 	defaultParams := types.DefaultParams()
 
 	testCases := []struct {
-		name     string
-		genesis  types.GenesisState
-		expPanic bool
+		name    string
+		genesis types.GenesisState
+		success bool
 	}{
 		{
-			"default genesis",
+			"Success - Default Genesis",
 			*clock.DefaultGenesisState(),
-			false,
+			true,
 		},
 		{
-			"custom genesis - none",
+			"Success - Custom Genesis",
 			types.GenesisState{
 				Params: types.Params{
 					ContractGasLimit: defaultParams.ContractGasLimit,
 				},
 				ContractAddresses:       []string(nil),
 				JailedContractAddresses: []string(nil),
 			},
-			false,
+			true,
 		},
 		{
-			"custom genesis - incorrect addr",
+			"Fail - Incorrect Contract Address",
 			types.GenesisState{
 				Params: types.Params{
 					ContractGasLimit: defaultParams.ContractGasLimit,
 				},
 				ContractAddresses:       []string{"incorrectaddr"},
 				JailedContractAddresses: []string(nil),
 			},
-			true,
+			false,
 		},
 		{
-			"custom genesis - only one addr allowed",
+			"Fail - Incorrect Jailed Contract Address",
+			types.GenesisState{
+				Params: types.Params{
+					ContractGasLimit: defaultParams.ContractGasLimit,
+				},
+				ContractAddresses:       []string(nil),
+				JailedContractAddresses: []string{"incorrectaddr"},
+			},
+			false,
+		},
+		{
+			"Fail - Incorrect Invalid Contracts",
 			types.GenesisState{
 				Params: types.Params{
 					ContractGasLimit: defaultParams.ContractGasLimit,
 				},
 				ContractAddresses:       []string{addr.String(), addr2.String()},
 				JailedContractAddresses: []string(nil),
 			},
-			false,
+			true,
+		},
+		{
+			"Fail - Incorrect Jailed Invalid Contracts",
+			types.GenesisState{
+				Params: types.Params{
+					ContractGasLimit: defaultParams.ContractGasLimit,
+				},
+				ContractAddresses:       []string(nil),
+				JailedContractAddresses: []string{addr.String(), addr2.String()},
+			},
+			true,
 		},
 	}
 
 	for _, tc := range testCases {
 		suite.Run(fmt.Sprintf("Case %s", tc.name), func() {
 			suite.SetupTest() // reset
 
-			if tc.expPanic {
-				suite.Require().Panics(func() {
-					clock.InitGenesis(suite.ctx, suite.app.AppKeepers.ClockKeeper, tc.genesis)
-				})
-			} else {
+			if tc.success {
 				suite.Require().NotPanics(func() {
 					clock.InitGenesis(suite.ctx, suite.app.AppKeepers.ClockKeeper, tc.genesis)
 				})
 
 				params := suite.app.AppKeepers.ClockKeeper.GetParams(suite.ctx)
 				suite.Require().Equal(tc.genesis.Params, params)
+			} else {
+				suite.Require().Panics(func() {
+					clock.InitGenesis(suite.ctx, suite.app.AppKeepers.ClockKeeper, tc.genesis)
+				})
 			}
 		})
 	}