fix tests

tests/integration/setup.go

@@ -284,7 +284,7 @@ func initConsumerChain(
 	err = bundle.Path.EndpointA.UpdateClient()
 	s.Require().NoError(err)
 
-	if consumerId == "0" {
+	if consumerId == icstestingutils.FirstConsumerID {
 		// Support tests that were written before multiple consumers were supported.
 		firstBundle := s.getFirstBundle()
 		s.consumerApp = firstBundle.App

testutil/keeper/unit_test_helpers.go

@@ -262,9 +262,8 @@ func TestProviderStateIsCleanedAfterConsumerChainIsStopped(t *testing.T, ctx sdk
 	require.Empty(t, acks)
 
 	// in case the chain was successfully stopped, it should not contain a Top N associated to it
-	powerShapingParameters, err := providerKeeper.GetConsumerPowerShapingParameters(ctx, consumerId)
-	require.NoError(t, err)
-	require.Zero(t, powerShapingParameters.Top_N)
+	_, err := providerKeeper.GetConsumerPowerShapingParameters(ctx, consumerId)
+	require.Error(t, err)
 
 	// test key assignment state is cleaned
 	require.Empty(t, providerKeeper.GetAllValidatorConsumerPubKeys(ctx, &consumerId))

x/ccv/provider/keeper/grpc_query_test.go

@@ -117,6 +117,10 @@ func TestQueryConsumerValidators(t *testing.T) {
 	// set the consumer to the "registered" phase
 	pk.SetConsumerPhase(ctx, consumerId, types.ConsumerPhase_CONSUMER_PHASE_REGISTERED)
 
+	// set power shaping params
+	err = pk.SetConsumerPowerShapingParameters(ctx, consumerId, types.PowerShapingParameters{})
+	require.NoError(t, err)
+
 	// expect empty valset
 	testkeeper.SetupMocksForLastBondedValidatorsExpectation(mocks.MockStakingKeeper, 0, []stakingtypes.Validator{}, 1) // -1 to allow the calls "AnyTimes"
 	res, err := pk.QueryConsumerValidators(ctx, &req)
@@ -300,13 +304,15 @@ func TestQueryConsumerChainsValidatorHasToValidate(t *testing.T) {
 	}
 
 	// set up some consumer chains
-	consumerChains := []string{"chain1", "chain2", "chain3", "chain4"}
-	for _, cc := range consumerChains {
-		pk.SetConsumerClientId(ctx, cc, "clientID")
+	consumerIDs := []string{"1", "23", "456", "6789"}
+	for _, cID := range consumerIDs {
+		pk.SetConsumerClientId(ctx, cID, "clientID")
+		err := pk.SetConsumerPowerShapingParameters(ctx, cID, types.PowerShapingParameters{})
+		require.NoError(t, err)
 	}
 
-	// set `providerAddr` as a consumer validator on "chain1"
-	pk.SetConsumerValidator(ctx, "chain1", types.ConsensusValidator{
+	// set `providerAddr` as a consumer validator on first consumer chain
+	pk.SetConsumerValidator(ctx, consumerIDs[0], types.ConsensusValidator{
 		ProviderConsAddr: providerAddr.ToSdkConsAddr(),
 		Power:            1,
 		PublicKey: &crypto.PublicKey{
@@ -316,17 +322,18 @@ func TestQueryConsumerChainsValidatorHasToValidate(t *testing.T) {
 		},
 	})
 
-	// set `providerAddr` as an opted-in validator on "chain3"
-	pk.SetOptedIn(ctx, "chain3", providerAddr)
+	// set `providerAddr` as an opted-in validator on third consumer chain
+	pk.SetOptedIn(ctx, consumerIDs[2], providerAddr)
 
 	// set max provider consensus vals to include all validators
 	params := pk.GetParams(ctx)
 	params.MaxProviderConsensusValidators = 3
 	pk.SetParams(ctx, params)
 
-	// `providerAddr` has to validate "chain1" because it is a consumer validator in this chain, as well as "chain3"
-	// because it opted in, in "chain3" and `providerAddr` belongs to the bonded validators
-	expectedChains := []string{"chain1", "chain3"}
+	// `providerAddr` has to validate
+	// - first consumer because it is a consumer validator in this chain,
+	// - third consumer because it opted in
+	expectedChains := []string{consumerIDs[0], consumerIDs[2]}
 
 	res, err := pk.QueryConsumerChainsValidatorHasToValidate(ctx, &req)
 	require.NoError(t, err)
@@ -606,7 +613,10 @@ func TestQueryConsumerChains(t *testing.T) {
 			Metadata:           types.ConsumerMetadata{Name: chainID},
 		}
 		pk.SetConsumerPhase(ctx, cID, c.Phase)
-		pk.SetConsumerMetadata(ctx, cID, c.Metadata)
+		err := pk.SetConsumerMetadata(ctx, cID, c.Metadata)
+		require.NoError(t, err)
+		err = pk.SetConsumerPowerShapingParameters(ctx, cID, types.PowerShapingParameters{})
+		require.NoError(t, err)
 		pk.SetConsumerChainId(ctx, cID, chainID)
 
 		consumerIds[i] = cID

x/ccv/provider/keeper/partial_set_security_test.go

@@ -109,19 +109,26 @@ func TestHandleOptOut(t *testing.T) {
 	providerKeeper, ctx, ctrl, _ := testkeeper.GetProviderKeeperAndCtx(t, testkeeper.NewInMemKeeperParams(t))
 	defer ctrl.Finish()
 
+	consumerId := "consumerId"
+
 	providerAddr := types.NewProviderConsAddress([]byte("providerAddr"))
 
 	// trying to opt out from a not running chain returns an error
 	require.Error(t, providerKeeper.HandleOptOut(ctx, "unknownChainID", providerAddr))
 
-	// set a consumer client so that the chain is considered running
-	providerKeeper.SetConsumerClientId(ctx, "consumerId", "clientID")
+	// set the phase and power shaping params
+	providerKeeper.SetConsumerPhase(ctx, consumerId, types.ConsumerPhase_CONSUMER_PHASE_LAUNCHED)
+	err := providerKeeper.SetConsumerPowerShapingParameters(ctx, consumerId, types.PowerShapingParameters{})
+	require.NoError(t, err)
 
 	// if validator (`providerAddr`) is already opted in, then an opt-out would remove this validator
-	providerKeeper.SetOptedIn(ctx, "consumerId", providerAddr)
-	require.True(t, providerKeeper.IsOptedIn(ctx, "consumerId", providerAddr))
-	providerKeeper.HandleOptOut(ctx, "consumerId", providerAddr)
-	require.False(t, providerKeeper.IsOptedIn(ctx, "consumerId", providerAddr))
+	providerKeeper.SetOptedIn(ctx, consumerId, providerAddr)
+	require.True(t, providerKeeper.IsOptedIn(ctx, consumerId, providerAddr))
+	err = providerKeeper.AppendOptedInConsumerId(ctx, providerAddr, consumerId)
+	require.NoError(t, err)
+	err = providerKeeper.HandleOptOut(ctx, consumerId, providerAddr)
+	require.NoError(t, err)
+	require.False(t, providerKeeper.IsOptedIn(ctx, consumerId, providerAddr))
 }
 
 func TestHandleOptOutFromTopNChain(t *testing.T) {
@@ -130,14 +137,15 @@ func TestHandleOptOutFromTopNChain(t *testing.T) {
 
 	consumerId := "consumerId"
 
-	// set a consumer client so that the chain is considered running
-	providerKeeper.SetConsumerClientId(ctx, consumerId, "clientID")
+	// set the phase
+	providerKeeper.SetConsumerPhase(ctx, consumerId, types.ConsumerPhase_CONSUMER_PHASE_LAUNCHED)
 
 	// set the chain as Top 50 and create 4 validators with 10%, 20%, 30%, and 40% of the total voting power
 	// respectively
-	providerKeeper.SetConsumerPowerShapingParameters(ctx, consumerId, types.PowerShapingParameters{
+	err := providerKeeper.SetConsumerPowerShapingParameters(ctx, consumerId, types.PowerShapingParameters{
 		Top_N: 50,
 	})
+	require.NoError(t, err)
 	valA := createStakingValidator(ctx, mocks, 1, 1) // 10% of the total voting power (can opt out)
 	valAConsAddr, _ := valA.GetConsAddr()
 	mocks.MockStakingKeeper.EXPECT().GetValidatorByConsAddr(ctx, valAConsAddr).Return(valA, nil).AnyTimes()
@@ -160,13 +168,17 @@ func TestHandleOptOutFromTopNChain(t *testing.T) {
 
 	// opt in all validators
 	providerKeeper.SetOptedIn(ctx, consumerId, types.NewProviderConsAddress(valAConsAddr))
-	providerKeeper.AppendOptedInConsumerId(ctx, types.NewProviderConsAddress(valAConsAddr), consumerId)
+	err = providerKeeper.AppendOptedInConsumerId(ctx, types.NewProviderConsAddress(valAConsAddr), consumerId)
+	require.NoError(t, err)
 	providerKeeper.SetOptedIn(ctx, consumerId, types.NewProviderConsAddress(valBConsAddr))
-	providerKeeper.AppendOptedInConsumerId(ctx, types.NewProviderConsAddress(valBConsAddr), consumerId)
+	err = providerKeeper.AppendOptedInConsumerId(ctx, types.NewProviderConsAddress(valBConsAddr), consumerId)
+	require.NoError(t, err)
 	providerKeeper.SetOptedIn(ctx, consumerId, types.NewProviderConsAddress(valCConsAddr))
-	providerKeeper.AppendOptedInConsumerId(ctx, types.NewProviderConsAddress(valCConsAddr), consumerId)
+	err = providerKeeper.AppendOptedInConsumerId(ctx, types.NewProviderConsAddress(valCConsAddr), consumerId)
+	require.NoError(t, err)
 	providerKeeper.SetOptedIn(ctx, consumerId, types.NewProviderConsAddress(valDConsAddr))
-	providerKeeper.AppendOptedInConsumerId(ctx, types.NewProviderConsAddress(valDConsAddr), consumerId)
+	err = providerKeeper.AppendOptedInConsumerId(ctx, types.NewProviderConsAddress(valDConsAddr), consumerId)
+	require.NoError(t, err)
 
 	// validators A and B can opt out because they belong the bottom 30% of validators
 	require.NoError(t, providerKeeper.HandleOptOut(ctx, consumerId, types.NewProviderConsAddress(valAConsAddr)))
@@ -179,7 +191,8 @@ func TestHandleOptOutFromTopNChain(t *testing.T) {
 
 	// opting out a validator that cannot be found from a Top N chain should also return an error
 	notFoundValidator := createStakingValidator(ctx, mocks, 5, 5)
-	notFoundValidatorConsAddr, _ := notFoundValidator.GetConsAddr()
+	notFoundValidatorConsAddr, err := notFoundValidator.GetConsAddr()
+	require.NoError(t, err)
 	mocks.MockStakingKeeper.EXPECT().GetValidatorByConsAddr(ctx, notFoundValidatorConsAddr).
 		Return(stakingtypes.Validator{}, stakingtypes.ErrNoValidatorFound)
 	require.Error(t, providerKeeper.HandleOptOut(ctx, consumerId, types.NewProviderConsAddress(notFoundValidatorConsAddr)))
@@ -391,7 +404,7 @@ func TestCanValidateChain(t *testing.T) {
 
 	// with no allowlist or denylist, the validator has to be opted in, in order to consider it
 	powerShapingParameters, err := providerKeeper.GetConsumerPowerShapingParameters(ctx, consumerID)
-	require.NoError(t, err)
+	require.Error(t, err)
 	require.False(t, providerKeeper.CanValidateChain(ctx, consumerID, providerAddr, powerShapingParameters.Top_N, 0))
 
 	// with TopN chains, the validator can be considered,
@@ -454,7 +467,7 @@ func TestCapValidatorSet(t *testing.T) {
 	validators := []types.ConsensusValidator{validatorA, validatorB, validatorC}
 
 	powerShapingParameters, err := providerKeeper.GetConsumerPowerShapingParameters(ctx, "consumerId")
-	require.NoError(t, err)
+	require.Error(t, err)
 	consumerValidators := providerKeeper.CapValidatorSet(ctx, powerShapingParameters, validators)
 	require.Equal(t, validators, consumerValidators)
 
@@ -544,7 +557,7 @@ func TestCapValidatorsPower(t *testing.T) {
 
 	// no capping takes place because validators power-cap is not set
 	powerShapingParameters, err := providerKeeper.GetConsumerPowerShapingParameters(ctx, "consumerId")
-	require.NoError(t, err)
+	require.Error(t, err)
 	cappedValidators := providerKeeper.CapValidatorsPower(ctx, powerShapingParameters.ValidatorsPowerCap, validators)
 	sortValidators(validators)
 	sortValidators(cappedValidators)

x/ccv/provider/keeper/proposal_test.go

@@ -348,6 +348,7 @@ func TestMakeConsumerGenesis(t *testing.T) {
 	providerKeeper.SetConsumerChainId(ctx, "0", "testchain1")
 	providerKeeper.SetConsumerMetadata(ctx, "0", consumerMetadata)
 	providerKeeper.SetConsumerInitializationParameters(ctx, "0", initializationParameters)
+	providerKeeper.SetConsumerPowerShapingParameters(ctx, "0", providertypes.PowerShapingParameters{})
 
 	actualGenesis, _, err := providerKeeper.MakeConsumerGenesis(ctx, "0")
 	require.NoError(t, err)

x/ccv/provider/keeper/relay_test.go

@@ -120,6 +120,10 @@ func TestQueueVSCPacketsDoesNotResetConsumerValidatorsHeights(t *testing.T) {
 	// validator for the first time after the `QueueVSCPackets` call.
 	providerKeeper.SetOptedIn(ctx, "consumerId", providertypes.NewProviderConsAddress(valBConsAddr))
 
+	// set power shaping params
+	err := providerKeeper.SetConsumerPowerShapingParameters(ctx, "consumerId", providertypes.PowerShapingParameters{})
+	require.NoError(t, err)
+
 	providerKeeper.QueueVSCPackets(ctx)
 
 	// the height of consumer validator A should not be modified because A was already a consumer validator

x/ccv/provider/migrations/v5/migration_test.go

@@ -16,15 +16,14 @@ func TestMigrateParams(t *testing.T) {
 	provKeeper.SetConsumerClientId(ctx, "chainID", "clientID")
 
 	// initially top N should not exist
-	powerShapingParameters, err := provKeeper.GetConsumerPowerShapingParameters(ctx, "chainID")
-	require.NoError(t, err)
-	require.Zero(t, powerShapingParameters.Top_N)
+	_, err := provKeeper.GetConsumerPowerShapingParameters(ctx, "chainID")
+	require.Error(t, err)
 
 	// migrate
 	MigrateTopNForRegisteredChains(ctx, provKeeper)
 
 	// after migration, top N should be 95
-	powerShapingParameters, err = provKeeper.GetConsumerPowerShapingParameters(ctx, "chainID")
+	powerShapingParameters, err := provKeeper.GetConsumerPowerShapingParameters(ctx, "chainID")
 	require.NoError(t, err)
 	require.Equal(t, uint32(95), powerShapingParameters.Top_N)
 }