style: address forced type assertions in tests

app/upgrades/v15/upgrade_test.go

@@ -178,7 +178,7 @@ func (suite *UpgradeTestSuite) TestRegisterOsmoIonMetadata() {
 	bankKeeper := suite.App.BankKeeper
 
 	// meta data should not be found pre-registration of meta data
-	uosmoMetadata, found := suite.App.BankKeeper.GetDenomMetaData(ctx, "uosmo")
+	_, found := suite.App.BankKeeper.GetDenomMetaData(ctx, "uosmo")
 	suite.Require().False(found)
 
 	uionMetadata, found := suite.App.BankKeeper.GetDenomMetaData(ctx, "uion")
@@ -187,7 +187,7 @@ func (suite *UpgradeTestSuite) TestRegisterOsmoIonMetadata() {
 	// system under test.
 	v15.RegisterOsmoIonMetadata(ctx, *bankKeeper)
 
-	uosmoMetadata, found = suite.App.BankKeeper.GetDenomMetaData(ctx, "uosmo")
+	uosmoMetadata, found := suite.App.BankKeeper.GetDenomMetaData(ctx, "uosmo")
 	suite.Require().True(found)
 
 	uionMetadata, found = suite.App.BankKeeper.GetDenomMetaData(ctx, "uion")

tests/e2e/e2e_test.go

@@ -192,11 +192,11 @@ func (s *IntegrationTestSuite) TestConcentratedLiquidity() {
 	s.Require().NoError(err)
 
 	var (
-		denom0      string  = "uion"
-		denom1      string  = "uosmo"
-		tickSpacing uint64  = 100
-		swapFee             = "0.001" // 0.1%
-		swapFeeDec  sdk.Dec = sdk.MustNewDecFromStr("0.001")
+		denom0             = "uion"
+		denom1             = "uosmo"
+		tickSpacing uint64 = 100
+		swapFee            = "0.001" // 0.1%
+		swapFeeDec         = sdk.MustNewDecFromStr("0.001")
 	)
 
 	// Get the permisionless pool creation parameter.
@@ -1056,12 +1056,34 @@ func (s *IntegrationTestSuite) TestIBCWasmHooks() {
 	var response map[string]interface{}
 	s.Require().Eventually(func() bool {
 		response, err = nodeA.QueryWasmSmartObject(contractAddr, fmt.Sprintf(`{"get_total_funds": {"addr": "%s"}}`, senderBech32))
-		totalFunds := response["total_funds"].([]interface{})[0]
-		amount := totalFunds.(map[string]interface{})["amount"].(string)
-		denom := totalFunds.(map[string]interface{})["denom"].(string)
+		if err != nil {
+			return false
+		}
+
+		totalFundsIface, ok := response["total_funds"].([]interface{})
+		if !ok || len(totalFundsIface) == 0 {
+			return false
+		}
+
+		totalFunds, ok := totalFundsIface[0].(map[string]interface{})
+		if !ok {
+			return false
+		}
+
+		amount, ok := totalFunds["amount"].(string)
+		if !ok {
+			return false
+		}
+
+		denom, ok := totalFunds["denom"].(string)
+		if !ok {
+			return false
+		}
+
 		// check if denom contains "uosmo"
-		return err == nil && amount == strconv.FormatInt(transferAmount, 10) && strings.Contains(denom, "ibc")
+		return amount == strconv.FormatInt(transferAmount, 10) && strings.Contains(denom, "ibc")
 	},
+
 		15*time.Second,
 		10*time.Millisecond,
 	)
@@ -1108,8 +1130,11 @@ func (s *IntegrationTestSuite) TestPacketForwarding() {
 		if err != nil {
 			return false
 		}
-		count := response["count"].(float64)
-		return err == nil && count == 0
+		countValue, ok := response["count"].(float64)
+		if !ok {
+			return false
+		}
+		return err == nil && countValue == 0
 	},
 		15*time.Second,
 		10*time.Millisecond,

tests/ibc-hooks/ibc_middleware_test.go

@@ -1049,11 +1049,25 @@ func (suite *HooksTestSuite) TestCrosschainSwaps() {
 	var responseJson map[string]interface{}
 	err = json.Unmarshal(res, &responseJson)
 	suite.Require().NoError(err)
-	suite.Require().Len(responseJson["sent_amount"].(string), 3) // Not using exact amount in case calculations change
-	suite.Require().Equal(responseJson["denom"].(string), "token1")
-	suite.Require().Equal(responseJson["channel_id"].(string), "channel-0")
-	suite.Require().Equal(responseJson["receiver"].(string), suite.chainB.SenderAccount.GetAddress().String())
-	suite.Require().Equal(responseJson["packet_sequence"].(float64), 1.0)
+	sentAmount, ok := responseJson["sent_amount"].(string)
+	suite.Require().True(ok)
+	suite.Require().Len(sentAmount, 3) // Not using exact amount in case calculations change
+
+	denom, ok := responseJson["denom"].(string)
+	suite.Require().True(ok)
+	suite.Require().Equal(denom, "token1")
+
+	channelID, ok := responseJson["channel_id"].(string)
+	suite.Require().True(ok)
+	suite.Require().Equal(channelID, "channel-0")
+
+	receiver, ok := responseJson["receiver"].(string)
+	suite.Require().True(ok)
+	suite.Require().Equal(receiver, suite.chainB.SenderAccount.GetAddress().String())
+
+	packetSequence, ok := responseJson["packet_sequence"].(float64)
+	suite.Require().True(ok)
+	suite.Require().Equal(packetSequence, 1.0)
 
 	balanceSender2 := osmosisApp.BankKeeper.GetBalance(suite.chainA.GetContext(), owner, "token0")
 	suite.Require().Equal(int64(1000), balanceSender.Amount.Sub(balanceSender2.Amount).Int64())

x/concentrated-liquidity/lp_test.go

@@ -1137,7 +1137,10 @@ func (s *KeeperTestSuite) TestSendCoinsBetweenPoolAndUser() {
 			// store pool interface
 			poolI, err := s.App.ConcentratedLiquidityKeeper.GetPoolById(s.Ctx, 1)
 			s.Require().NoError(err)
-			concentratedPool := poolI.(types.ConcentratedPoolExtension)
+			concentratedPool, ok := poolI.(types.ConcentratedPoolExtension)
+			if !ok {
+				s.FailNow("poolI is not a ConcentratedPoolExtension")
+			}
 
 			// fund pool address and user address
 			s.FundAcc(poolI.GetAddress(), sdk.NewCoins(sdk.NewCoin("eth", sdk.NewInt(10000000000000)), sdk.NewCoin("usdc", sdk.NewInt(1000000000000))))
@@ -1363,21 +1366,22 @@ func (s *KeeperTestSuite) TestUpdatePosition() {
 				// validate if pool liquidity has been updated properly
 				poolI, err := s.App.ConcentratedLiquidityKeeper.GetPoolById(s.Ctx, tc.poolId)
 				s.Require().NoError(err)
-				concentratedPool := poolI.(types.ConcentratedPoolExtension)
+				concentratedPool, ok := poolI.(types.ConcentratedPoolExtension)
+				if !ok {
+					s.FailNow("poolI is not a ConcentratedPoolExtension")
+				}
 				s.Require().Equal(tc.expectedPoolLiquidity, concentratedPool.GetLiquidity())
 			}
 		})
 	}
 }
 
 func (s *KeeperTestSuite) TestInitializeInitialPositionForPool() {
-	var (
-		sqrt = func(x int64) sdk.Dec {
-			sqrt, err := sdk.NewDec(x).ApproxSqrt()
-			s.Require().NoError(err)
-			return sqrt
-		}
-	)
+	sqrt := func(x int64) sdk.Dec {
+		sqrt, err := sdk.NewDec(x).ApproxSqrt()
+		s.Require().NoError(err)
+		return sqrt
+	}
 
 	type sendTest struct {
 		amount0Desired        sdk.Int

x/concentrated-liquidity/pool_test.go

@@ -15,7 +15,10 @@ import (
 func (s *KeeperTestSuite) TestInitializePool() {
 	// Create a valid PoolI from a valid ConcentratedPoolExtension
 	validConcentratedPool := s.PrepareConcentratedPool()
-	validPoolI := validConcentratedPool.(poolmanagertypes.PoolI)
+	validPoolI, ok := validConcentratedPool.(poolmanagertypes.PoolI)
+	if !ok {
+		s.FailNow("validConcentratedPool is not a PoolI")
+	}
 
 	// Create a concentrated liquidity pool with unauthorized tick spacing
 	invalidTickSpacing := uint64(25)
@@ -209,7 +212,10 @@ func (s *KeeperTestSuite) TestPoolIToConcentratedPool() {
 
 	// Create default CL pool
 	concentratedPool := s.PrepareConcentratedPool()
-	poolI := concentratedPool.(poolmanagertypes.PoolI)
+	poolI, ok := concentratedPool.(poolmanagertypes.PoolI)
+	if !ok {
+		s.Fail("failed to cast pool to PoolI")
+	}
 
 	// Ensure no error occurs when converting to ConcentratedPool
 	_, err := cl.ConvertPoolInterfaceToConcentrated(poolI)

x/gamm/keeper/swap_test.go

@@ -210,20 +210,26 @@ func (suite *KeeperTestSuite) TestCalcOutAmtGivenIn() {
 			suite.SetupTest()
 			keeper := suite.App.GAMMKeeper
 			ctx := suite.Ctx
-
 			var pool poolmanagertypes.PoolI
 			if test.param.poolType == "balancer" {
 				poolId := suite.PrepareBalancerPool()
 				poolExt, err := suite.App.GAMMKeeper.GetPool(suite.Ctx, poolId)
 				suite.NoError(err)
-				pool = poolExt.(poolmanagertypes.PoolI)
+				poolI, ok := poolExt.(poolmanagertypes.PoolI)
+				if !ok {
+					suite.FailNow("failed to cast pool to poolI")
+				}
+				pool = poolI
 			} else if test.param.poolType == "stableswap" {
 				poolId := suite.PrepareBasicStableswapPool()
 				poolExt, err := suite.App.GAMMKeeper.GetPool(suite.Ctx, poolId)
 				suite.NoError(err)
-				pool = poolExt.(poolmanagertypes.PoolI)
+				poolI, ok := poolExt.(poolmanagertypes.PoolI)
+				if !ok {
+					suite.FailNow("failed to cast pool to poolI")
+				}
+				pool = poolI
 			}
-
 			swapFee := pool.GetSwapFee(suite.Ctx)
 
 			_, err := keeper.CalcOutAmtGivenIn(ctx, pool, test.param.tokenIn, test.param.tokenOutDenom, swapFee)
@@ -283,12 +289,23 @@ func (suite *KeeperTestSuite) TestCalcInAmtGivenOut() {
 				poolId := suite.PrepareBalancerPool()
 				poolExt, err := suite.App.GAMMKeeper.GetPool(suite.Ctx, poolId)
 				suite.NoError(err)
-				pool = poolExt.(poolmanagertypes.PoolI)
+				poolI, ok := poolExt.(poolmanagertypes.PoolI)
+				if !ok {
+					suite.FailNow("failed to cast pool to poolI")
+				}
+
+				pool = poolI
+
 			} else if test.param.poolType == "stableswap" {
 				poolId := suite.PrepareBasicStableswapPool()
 				poolExt, err := suite.App.GAMMKeeper.GetPool(suite.Ctx, poolId)
 				suite.NoError(err)
-				pool = poolExt.(poolmanagertypes.PoolI)
+				poolI, ok := poolExt.(poolmanagertypes.PoolI)
+				if !ok {
+					suite.FailNow("failed to cast pool to poolI")
+				}
+
+				pool = poolI
 			}
 
 			swapFee := pool.GetSwapFee(suite.Ctx)

x/ibc-rate-limit/types/params_test.go

@@ -59,18 +59,21 @@ func TestValidateParams(t *testing.T) {
 
 	for name, tc := range testCases {
 		t.Run(name, func(t *testing.T) {
+			addr, ok := tc.addr.(string)
+			require.True(t, ok, "unexpected type of address")
+
 			params := Params{
-				ContractAddress: tc.addr.(string),
+				ContractAddress: addr,
 			}
+
 			err := params.Validate()
 
 			// Assertions.
 			if !tc.expected {
 				require.Error(t, err)
-				return
+			} else {
+				require.NoError(t, err)
 			}
-
-			require.NoError(t, err)
 		})
 	}
 }

x/incentives/keeper/suite_test.go

@@ -1,8 +1,8 @@
 package keeper_test
 
 import (
+	"crypto/rand"
 	"fmt"
-	"math/rand"
 	"time"
 
 	"github.com/osmosis-labs/osmosis/v15/x/incentives/types"

x/mint/keeper/keeper_test.go

@@ -236,7 +236,9 @@ func (suite *KeeperTestSuite) TestDistributeMintedCoin() {
 			suite.Require().NoError(err)
 
 			// validate that AfterDistributeMintedCoin hook was called once.
-			suite.Require().Equal(1, mintKeeper.GetMintHooksUnsafe().(*mintHooksMock).hookCallCount)
+			hooks, ok := mintKeeper.GetMintHooksUnsafe().(*mintHooksMock)
+			suite.Require().True(ok, "unexpected type of mint hooks")
+			suite.Require().Equal(1, hooks.hookCallCount)
 
 			// validate distributions to fee collector.
 			feeCollectorBalanceAmount := bankKeeper.GetBalance(ctx, accountKeeper.GetModuleAddress(authtypes.FeeCollectorName), sdk.DefaultBondDenom).Amount.ToDec()

x/poolmanager/client/cli/cli_test.go

@@ -530,7 +530,13 @@ func (s *IntegrationTestSuite) TestNewCreatePoolCmd() {
 				err = clientCtx.Codec.UnmarshalJSON(out.Bytes(), tc.respType)
 				s.Require().NoError(err, out.String())
 
-				txResp := tc.respType.(*sdk.TxResponse)
+				var txResp *sdk.TxResponse
+				switch resp := tc.respType.(type) {
+				case *sdk.TxResponse:
+					txResp = resp
+				default:
+					s.T().Fatalf("unexpected response type: %T", tc.respType)
+				}
 				s.Require().Equal(tc.expectedCode, txResp.Code, out.String())
 			}
 		})

x/protorev/keeper/protorev_test.go

@@ -102,9 +102,9 @@ func (suite *KeeperTestSuite) TestGetPoolForDenomPair() {
 
 	// Should be able to delete all pools for a base denom
 	suite.App.ProtoRevKeeper.DeleteAllPoolsForBaseDenom(suite.Ctx, "Atom")
-	pool, err = suite.App.ProtoRevKeeper.GetPoolForDenomPair(suite.Ctx, "Atom", types.OsmosisDenomination)
+	_, err = suite.App.ProtoRevKeeper.GetPoolForDenomPair(suite.Ctx, "Atom", types.OsmosisDenomination)
 	suite.Require().Error(err)
-	pool, err = suite.App.ProtoRevKeeper.GetPoolForDenomPair(suite.Ctx, "Atom", "weth")
+	_, err = suite.App.ProtoRevKeeper.GetPoolForDenomPair(suite.Ctx, "Atom", "weth")
 	suite.Require().Error(err)
 
 	// Other denoms should still exist

x/protorev/types/gov_test.go

@@ -39,7 +39,9 @@ func (suite *GovTestSuite) TestEnableProposal() {
 
 	for _, tc := range testCases {
 		proposal := types.NewSetProtoRevEnabledProposal("title", "description", tc.enabled)
-		suite.Require().Equal(tc.enabled, proposal.(*types.SetProtoRevEnabledProposal).Enabled)
+		setProtoRevEnabledProposal, ok := proposal.(*types.SetProtoRevEnabledProposal)
+		suite.Require().True(ok, "proposal is not a SetProtoRevEnabledProposal")
+		suite.Require().Equal(tc.enabled, setProtoRevEnabledProposal.Enabled)
 	}
 }
 

x/twap/api_test.go

@@ -81,7 +81,7 @@ var (
 		sdk.ZeroDec(),                // TODO: choose correct
 	)
 
-	spotPriceError = errors.New("twap: error in pool spot price occurred between start and end time, twap result may be faulty")
+	errSpotPrice = errors.New("twap: error in pool spot price occurred between start and end time, twap result may be faulty")
 )
 
 func (s *TestSuite) TestGetBeginBlockAccumulatorRecord() {
@@ -311,23 +311,23 @@ func (s *TestSuite) TestGetArithmeticTwap() {
 			ctxTime:      tPlusOneMin,
 			input:        makeSimpleTwapInput(baseTime, tPlusOneMin, baseQuoteBA),
 			expTwap:      sdk.NewDec(10),
-			expectError:  spotPriceError,
+			expectError:  errSpotPrice,
 			expectSpErr:  baseTime,
 		},
 		"spot price error in record at record time (start time > record time)": {
 			recordsToSet: []types.TwapRecord{withLastErrTime(baseRecord, baseTime)},
 			ctxTime:      tPlusOneMin,
 			input:        makeSimpleTwapInput(tPlusOne, tPlusOneMin, baseQuoteBA),
 			expTwap:      sdk.NewDec(10),
-			expectError:  spotPriceError,
+			expectError:  errSpotPrice,
 			expectSpErr:  baseTime,
 		},
 		"spot price error in record after record time": {
 			recordsToSet: []types.TwapRecord{withLastErrTime(baseRecord, tPlusOne)},
 			ctxTime:      tPlusOneMin,
 			input:        makeSimpleTwapInput(baseTime, tPlusOneMin, baseQuoteBA),
 			expTwap:      sdk.NewDec(10),
-			expectError:  spotPriceError,
+			expectError:  errSpotPrice,
 			expectSpErr:  baseTime,
 		},
 		// should error, since start time may have been used to interpolate this value
@@ -336,15 +336,15 @@ func (s *TestSuite) TestGetArithmeticTwap() {
 			ctxTime:      tPlusOneMin,
 			input:        makeSimpleTwapInput(baseTime, tPlusOne, baseQuoteBA),
 			expTwap:      sdk.NewDec(10),
-			expectError:  spotPriceError,
+			expectError:  errSpotPrice,
 			expectSpErr:  baseTime,
 		},
 		"spot price error exactly at end time": {
 			recordsToSet: []types.TwapRecord{withLastErrTime(baseRecord, tPlusOne)},
 			ctxTime:      tPlusOneMin,
 			input:        makeSimpleTwapInput(baseTime, tPlusOne, baseQuoteBA),
 			expTwap:      sdk.NewDec(10),
-			expectError:  spotPriceError,
+			expectError:  errSpotPrice,
 			expectSpErr:  baseTime,
 		},
 		// should not happen, but if it did would error
@@ -353,7 +353,7 @@ func (s *TestSuite) TestGetArithmeticTwap() {
 			ctxTime:      tPlusOneMin,
 			input:        makeSimpleTwapInput(baseTime, tPlusOne, baseQuoteBA),
 			expTwap:      sdk.NewDec(10),
-			expectError:  spotPriceError,
+			expectError:  errSpotPrice,
 			expectSpErr:  baseTime,
 		},
 	}
@@ -754,7 +754,7 @@ func (s *TestSuite) TestGetArithmeticTwapToNow() {
 			ctxTime:       tPlusOneMin,
 			input:         makeSimpleTwapInput(tPlusOne, tPlusOneMin, baseQuoteBA),
 			expTwap:       sdk.NewDec(10),
-			expectedError: spotPriceError,
+			expectedError: errSpotPrice,
 		},
 	}
 	for name, test := range tests {