add e2e tests

Author: strykerin

interchaintest/basic_test.go

@@ -13,46 +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 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/blocktime_test.go

@@ -0,0 +1,128 @@
+package e2e
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"cosmossdk.io/math"
+	"github.com/strangelove-ventures/interchaintest/v8"
+	"github.com/strangelove-ventures/interchaintest/v8/chain/cosmos"
+	"github.com/strangelove-ventures/interchaintest/v8/testreporter"
+	"github.com/strangelove-ventures/interchaintest/v8/testutil"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap/zaptest"
+)
+
+// TestBlockTimeConfiguration verifies that the blockchain respects a custom block time parameter.
+// This test ensures that:
+// 1. The chain can be properly initialized with a custom block time
+// 2. Blocks are produced at approximately the configured interval
+// 3. The actual block production time is close to the configured block time
+func TestBlockTimeConfiguration(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)
+
+	// Set a custom block time (2 seconds instead of default)
+	customBlockTime := 2 * time.Second
+
+	// Create a modified chain spec with custom block time
+	// Note: We need to modify the genesis to set the block time
+	chainSpec := DefaultChainSpec
+
+	// Create a copy of the default genesis and add our custom block time
+	genesisKVs := make([]cosmos.GenesisKV, len(DefaultGenesis))
+	copy(genesisKVs, DefaultGenesis)
+
+	// Add the block time configuration to the genesis
+	genesisKVs = append(genesisKVs,
+		cosmos.NewGenesisKV("consensus.params.block.time_iota_ms", "2000")) // 2000ms = 2s
+
+	// Set the modified genesis
+	chainSpec.ModifyGenesis = cosmos.ModifyGenesis(genesisKVs)
+
+	// Create a chain factory with our modified chain specification
+	cf := interchaintest.NewBuiltinChainFactory(zaptest.NewLogger(t), []*interchaintest.ChainSpec{
+		&chainSpec,
+	})
+
+	// 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 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: true,
+	}))
+
+	// 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]
+
+	// 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)
+
+	// Get the current block height
+	height, err := chain.Height(ctx)
+	require.NoError(t, err)
+	startHeight := height
+
+	// Record the start time
+	startTime := time.Now()
+
+	// Wait for a specific number of blocks to be produced
+	numBlocksToWait := 5
+	err = testutil.WaitForBlocks(ctx, numBlocksToWait, chain)
+	require.NoError(t, err)
+
+	// Get the new block height
+	height, err = chain.Height(ctx)
+	require.NoError(t, err)
+	endHeight := height
+
+	// Calculate the elapsed time
+	elapsedTime := time.Since(startTime)
+
+	// Calculate the actual number of blocks produced
+	blocksProduced := endHeight - startHeight
+
+	// Calculate the average time per block
+	avgTimePerBlock := elapsedTime / time.Duration(blocksProduced)
+
+	// Verify that the average block time is close to the configured block time
+	// Allow for a 50% margin of error to account for network delays and other factors
+	maxAllowedDeviation := time.Duration(float64(customBlockTime) * 0.5)
+
+	t.Logf("Configured block time: %v", customBlockTime)
+	t.Logf("Actual average block time: %v", avgTimePerBlock)
+	t.Logf("Blocks produced: %d", blocksProduced)
+	t.Logf("Elapsed time: %v", elapsedTime)
+
+	// Check if the average block time is within the acceptable range
+	require.InDelta(t, customBlockTime.Seconds(), avgTimePerBlock.Seconds(),
+		maxAllowedDeviation.Seconds(),
+		"Average block time (%v) is not close enough to configured block time (%v)",
+		avgTimePerBlock, customBlockTime)
+}

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)