add comments to tests

Author: strykerin

interchaintest/basic_test.go

@@ -13,52 +13,64 @@ import (
 	"go.uber.org/zap/zaptest"
 )
 
+// TestBasicChain is a fundamental test that verifies the basic functionality of a single chain.
+// This test ensures that:
+// 1. The chain can be properly initialized and started
+// 2. The chain has the correct configuration (denom, chain ID, gas prices)
+// 3. Users can be created and funded with tokens
+// 4. The balance query functionality works correctly
 func TestBasicChain(t *testing.T) {
 	ctx := context.Background()
 	rep := testreporter.NewNopReporter()
 	eRep := rep.RelayerExecReporter(t)
+	// Set up Docker environment for the test
 	client, network := interchaintest.DockerSetup(t)
 
+	// Create a chain factory with our default chain specification
 	cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{
 		&DefaultChainSpec,
 	})
 
+	// Initialize the chains from the factory
 	chains, err := cf.Chains(t.Name())
 	require.NoError(t, err)
 
+	// Get the first chain from the list (we only have one in this test)
 	chain := chains[0].(*cosmos.CosmosChain)
 
-	// Setup Interchain
+	// Setup Interchain environment with our single chain
 	ic := interchaintest.NewInterchain().
 		AddChain(chain)
 
+	// Build the interchain environment
 	require.NoError(t, ic.Build(ctx, eRep, interchaintest.InterchainBuildOptions{
 		TestName:         t.Name(),
 		Client:           client,
 		NetworkID:        network,
 		SkipPathCreation: false,
 	}))
+	// Clean up resources when the test completes
 	t.Cleanup(func() {
 		_ = ic.Close()
 	})
 
+	// Create and fund a test user with 10 million tokens
 	amt := math.NewInt(10_000_000)
 	users := interchaintest.GetAndFundTestUsers(t, ctx, "default", amt,
 		chain,
 	)
 	user := users[0]
 
 	t.Run("validate configuration", func(t *testing.T) {
-		// Check that the chain is configured correctly
+		// Check that the chain is configured correctly with the expected values
 		require.Equal(t, chain.Config().Denom, "npush")
 		require.Equal(t, chain.Config().ChainID, "localchain-1")
 		require.Equal(t, chain.Config().GasPrices, "0npush")
 	})
 	t.Run("validate funding", func(t *testing.T) {
+		// Verify that the user was properly funded with the expected amount
 		bal, err := chain.BankQueryBalance(ctx, user.FormattedAddress(), chain.Config().Denom)
 		require.NoError(t, err)
 		require.EqualValues(t, amt, bal)
-
 	})
-
 }

interchaintest/cosmwasm_test.go

@@ -13,86 +13,121 @@ import (
 	"go.uber.org/zap/zaptest"
 )
 
+// GetCountResponse represents the response structure from the CosmWasm contract's get_count query
 type GetCountResponse struct {
 	// {"data":{"count":0}}
 	Data *GetCountObj `json:"data"`
 }
 
+// GetCountObj holds the actual count value from the contract's state
 type GetCountObj struct {
 	Count int64 `json:"count"`
 }
 
+// TestCosmWasmIntegration verifies that CosmWasm smart contracts can be deployed and executed on the chain.
+// This test ensures that:
+// 1. A chain with CosmWasm support can be properly initialized
+// 2. A CosmWasm contract can be stored on the chain
+// 3. The contract can be instantiated with initial state
+// 4. Contract execution (state changes) works correctly
+// 5. Contract queries return the expected results
 func TestCosmWasmIntegration(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
 	rep := testreporter.NewNopReporter()
 	eRep := rep.RelayerExecReporter(t)
+	// Set up Docker environment for the test
 	client, network := interchaintest.DockerSetup(t)
 
+	// Create a chain factory with our default chain specification
 	cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{
 		&DefaultChainSpec,
 	})
 
+	// Initialize the chain from the factory
 	chains, err := cf.Chains(t.Name())
 	require.NoError(t, err)
 
+	// Get the chain from the list (we only have one in this test)
 	chain := chains[0].(*cosmos.CosmosChain)
 
-	// Setup Interchain
+	// Setup Interchain environment with our single chain
 	ic := interchaintest.NewInterchain().
 		AddChain(chain)
 
+	// Build the interchain environment
 	require.NoError(t, ic.Build(ctx, eRep, interchaintest.InterchainBuildOptions{
 		TestName:         t.Name(),
 		Client:           client,
 		NetworkID:        network,
 		SkipPathCreation: false,
 	}))
+	// Clean up resources when the test completes
 	t.Cleanup(func() {
 		_ = ic.Close()
 	})
 
+	// Create and fund a test user
 	users := interchaintest.GetAndFundTestUsers(t, ctx, t.Name(), GenesisFundsAmount, chain)
 	user := users[0]
 
+	// Execute the standard CosmWasm test flow
 	StdExecute(t, ctx, chain, user)
 }
 
+// StdExecute performs a standard flow of CosmWasm operations:
+// 1. Uploads a contract to the chain
+// 2. Instantiates the contract with initial state
+// 3. Executes a transaction on the contract to increment the counter
+// 4. Queries the contract to verify the state change
 func StdExecute(t *testing.T, ctx context.Context, chain *cosmos.CosmosChain, user ibc.Wallet) (contractAddr string) {
+	// Upload and instantiate the contract with initial count of 0
 	_, contractAddr = SetupContract(t, ctx, chain, user.KeyName(), "contracts/cw_template.wasm", `{"count":0}`)
+
+	// Execute the increment operation on the contract
 	chain.ExecuteContract(ctx, user.KeyName(), contractAddr, `{"increment":{}}`, "--fees", "10000"+chain.Config().Denom)
 
+	// Query the contract to verify the count was incremented
 	var res GetCountResponse
 	err := SmartQueryString(t, ctx, chain, contractAddr, `{"get_count":{}}`, &res)
 	require.NoError(t, err)
 
+	// Verify the count is now 1 after the increment operation
 	require.Equal(t, int64(1), res.Data.Count)
 
 	return contractAddr
 }
 
+// SmartQueryString performs a query on a CosmWasm contract and unmarshals the result into the provided response object
 func SmartQueryString(t *testing.T, ctx context.Context, chain *cosmos.CosmosChain, contractAddr, queryMsg string, res interface{}) error {
+	// Convert the query string to a JSON map for the chain's QueryContract method
 	var jsonMap map[string]interface{}
 	if err := json.Unmarshal([]byte(queryMsg), &jsonMap); err != nil {
 		t.Fatal(err)
 	}
+	// Execute the query and unmarshal the result into the provided response object
 	err := chain.QueryContract(ctx, contractAddr, jsonMap, &res)
 	return err
 }
 
+// SetupContract uploads a CosmWasm contract to the chain and instantiates it
+// Returns the code ID and contract address
 func SetupContract(t *testing.T, ctx context.Context, chain *cosmos.CosmosChain, keyname string, fileLoc string, message string, extraFlags ...string) (codeId, contract string) {
+	// Store the contract on the chain
 	codeId, err := chain.StoreContract(ctx, keyname, fileLoc)
 	if err != nil {
 		t.Fatal(err)
 	}
 
+	// Determine if we need to add the --no-admin flag
 	needsNoAdminFlag := true
 	for _, flag := range extraFlags {
 		if flag == "--admin" {
 			needsNoAdminFlag = false
 		}
 	}
 
+	// Instantiate the contract with the provided message
 	contractAddr, err := chain.InstantiateContract(ctx, keyname, codeId, message, needsNoAdminFlag, extraFlags...)
 	if err != nil {
 		t.Fatal(err)

interchaintest/ibc_rate_limit_test.go

@@ -16,6 +16,12 @@ import (
 	"go.uber.org/zap/zaptest"
 )
 
+// TestIBCRateLimit verifies that the IBC rate limiting functionality works correctly.
+// This test ensures that:
+// 1. Two chains can be properly initialized and connected via IBC
+// 2. The rate limit module can be configured to blacklist specific denominations
+// 3. Transfers of blacklisted denominations are properly rejected
+// 4. The error message correctly indicates that the denomination is blacklisted
 func TestIBCRateLimit(t *testing.T) {
 	if testing.Short() {
 		t.Skip()
@@ -25,68 +31,76 @@ func TestIBCRateLimit(t *testing.T) {
 	ctx := context.Background()
 	rep := testreporter.NewNopReporter()
 	eRep := rep.RelayerExecReporter(t)
+	// Set up Docker environment for the test
 	client, network := interchaintest.DockerSetup(t)
 
+	// Configure the first chain with the chain's native denom blacklisted in the rate limit module
 	cs := &DefaultChainSpec
 	cs.ModifyGenesis = cosmos.ModifyGenesis([]cosmos.GenesisKV{cosmos.NewGenesisKV("app_state.ratelimit.blacklisted_denoms", []string{cs.Denom})})
 
+	// Create a chain factory with two chain specifications
 	cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{
 		cs,
 		&SecondDefaultChainSpec,
 	})
 
+	// Initialize the chains from the factory
 	chains, err := cf.Chains(t.Name())
 	require.NoError(t, err)
 
+	// Get references to both chains
 	chain := chains[0].(*cosmos.CosmosChain)
 	secondary := chains[1].(*cosmos.CosmosChain)
 
-	// Relayer Factory
+	// Set up the relayer for IBC communication between chains
 	r := interchaintest.NewBuiltinRelayerFactory(
 		ibc.CosmosRly,
 		zaptest.NewLogger(t, zaptest.Level(zapcore.DebugLevel)),
 		interchaintestrelayer.CustomDockerImage(RelayerRepo, RelayerVersion, "100:1000"),
 		interchaintestrelayer.StartupFlags("--processor", "events", "--block-history", "200"),
 	).Build(t, client, network)
 
+	// Create the interchain environment with both chains and the relayer
 	ic := interchaintest.NewInterchain().
 		AddChain(chain).
 		AddChain(secondary).
 		AddRelayer(r, "relayer")
 
+	// Add an IBC link between the two chains
 	ic = ic.AddLink(interchaintest.InterchainLink{
 		Chain1:  chain,
 		Chain2:  secondary,
 		Relayer: r,
 		Path:    ibcPath,
 	})
 
-	// Build interchain
+	// Build the interchain environment
 	require.NoError(t, ic.Build(ctx, eRep, interchaintest.InterchainBuildOptions{
 		TestName:         t.Name(),
 		Client:           client,
 		NetworkID:        network,
 		SkipPathCreation: false,
 	}))
 
-	// Create and Fund User Wallets
+	// Create and fund test users on both chains
 	fundAmount := math.NewInt(10_000_000)
 	users := interchaintest.GetAndFundTestUsers(t, ctx, "default", fundAmount, chain, secondary)
 	userA, userB := users[0], users[1]
 
+	// Verify initial balance of userA
 	userAInitial, err := chain.GetBalance(ctx, userA.FormattedAddress(), chain.Config().Denom)
 	fmt.Println("userAInitial", userAInitial)
 	require.NoError(t, err)
 	require.True(t, userAInitial.Equal(fundAmount))
 
-	// Get Channel ID
+	// Get the IBC channel ID for chainA
 	aInfo, err := r.GetChannels(ctx, eRep, chain.Config().ChainID)
 	require.NoError(t, err)
 	aChannelID, err := getTransferChannel(aInfo)
 	require.NoError(t, err)
 	fmt.Println("aChannelID", aChannelID)
 
-	// Send Transaction
+	// Prepare the IBC transfer from chainA to chainB
 	amountToSend := math.NewInt(1_000_000)
 	dstAddress := userB.FormattedAddress()
 	transfer := ibc.WalletAmount{
@@ -95,7 +109,7 @@ func TestIBCRateLimit(t *testing.T) {
 		Amount:  amountToSend,
 	}
 
-	// Validate transfer error occurs
+	// Attempt the IBC transfer and verify it fails due to the blacklisted denom
 	_, err = chain.SendIBCTransfer(ctx, aChannelID, userA.KeyName(), transfer, ibc.TransferOptions{})
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "denom is blacklisted")