[Testing, Tooling] feat: implement in-memory networks

testutil/network/basenet/accounts.go

@@ -0,0 +1,199 @@
+package basenet
+
+import (
+ "encoding/json"
+ "fmt"
+ "testing"
+
+ "github.com/cosmos/cosmos-sdk/client/flags"
+ "github.com/cosmos/cosmos-sdk/crypto/keyring"
+ testcli "github.com/cosmos/cosmos-sdk/testutil/cli"
+ "github.com/cosmos/cosmos-sdk/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/stretchr/testify/require"
+
+ "github.com/pokt-network/poktroll/testutil/network"
+ "github.com/pokt-network/poktroll/testutil/testkeyring"
+ apptypes "github.com/pokt-network/poktroll/x/application/types"
+ gatewaytypes "github.com/pokt-network/poktroll/x/gateway/types"
+ sharedtypes "github.com/pokt-network/poktroll/x/shared/types"
+ suppliertypes "github.com/pokt-network/poktroll/x/supplier/types"
+)
+
+const warnNoModuleGenesisFmt = "WARN: no %s module genesis state found, if this is unexpected, ensure that genesis is populated before creating on-chain accounts"
+
+// CreateKeyringAccounts populates the Keyring associated with the in-memory
+// network with memnet.numKeyringAccounts() number of pre-generated accounts.
+func (memnet *BaseInMemoryNetwork) CreateKeyringAccounts(t *testing.T) {
+ t.Helper()
+
+ // Keyring MAY be provided setting InMemoryNetworkConfig#Keyring.
+ if memnet.Config.Keyring == nil {
+ t.Log("Keyring not initialized, using new in-memory keyring")
+
+ // Construct an in-memory keyring so that it can be populated and used prior
+ // to network start.
+ memnet.Config.Keyring = keyring.NewInMemory(memnet.Config.CosmosCfg.Codec)
+ } else {
+ t.Log("Keyring already initialized, using existing keyring")
+ }
+
+ // Create memnet.NumKeyringAccounts() number of accounts in the configured keyring.
+ accts := testkeyring.CreatePreGeneratedKeyringAccounts(
+ t, memnet.Config.Keyring, memnet.Config.GetNumKeyringAccounts(t),
+ )
+
+ // Assign the memnet's pre-generated accounts iterator to a new pre-generated
+ // accounts iterator containing only the accounts which were also created
+ // in the keyring.
+ memnet.PreGeneratedAccountIterator = testkeyring.NewPreGeneratedAccountIterator(accts...)
+}
+
+// FundOnChainAccounts creates on-chain accounts (i.e. auth module) for the sum of
+// the configured number of suppliers, applications, and gateways.
+func (memnet *BaseInMemoryNetwork) FundOnChainAccounts(t *testing.T) {
+ t.Helper()
+
+ // NB: while it may initially seem like the memnet#Fund<actor>Accounts() methods
+ // can be refactored into a generic function, this is not possible so long as the genesis
+ // state lists are passed directly & remain a slice of concrete types (as opposed to pointers).
+ // Under these conditions, a generic function would not be able to unmarshal the genesis state
+ // stored in the in-memory network because it is unmarshalling uses reflection, and it is not
+ // possible to reflect over a nil generic type value.
+
+ // Retrieve the supplier module's genesis state from cosmos-sdk in-memory network.
+ supplierGenesisState := network.GetGenesisState[*suppliertypes.GenesisState](t, suppliertypes.ModuleName, memnet)
+ if supplierGenesisState == nil {
+ t.Logf(warnNoModuleGenesisFmt, "supplier")
+ } else {
+ // Initialize on-chain accounts for genesis suppliers.
+ memnet.FundSupplierAccounts(t, supplierGenesisState.SupplierList...)
+
+ }
+
+ // Retrieve the application module's genesis state from cosmos-sdk in-memory network.
+ appGenesisState := network.GetGenesisState[*apptypes.GenesisState](t, apptypes.ModuleName, memnet)
+ if appGenesisState == nil {
+ t.Logf(warnNoModuleGenesisFmt, "application")
+ } else {
+ // Initialize on-chain accounts for genesis applications.
+ memnet.FundAppAccounts(t, appGenesisState.ApplicationList...)
+ }
+
+ // Retrieve the gateway module's genesis state from cosmos-sdk in-memory network.
+ gatewayGenesisState := network.GetGenesisState[*gatewaytypes.GenesisState](t, gatewaytypes.ModuleName, memnet)
+ if gatewayGenesisState == nil {
+ t.Logf(warnNoModuleGenesisFmt, "gateway")
+ } else {
+ // Initialize on-chain accounts for genesis gateways.
+ memnet.FundGatewayAccounts(t, gatewayGenesisState.GatewayList...)
+ }
+
+ // need to wait for the account to be initialized in the next block
+ require.NoError(t, memnet.GetNetwork(t).WaitForNextBlock())
+}
+
+// FundAddress initializes an Account address and sequence number with the auth module
+// by sending some tokens from the in-memory network validator, to the address provided.
+// This is a necessary prerequesite in order for the account with the given address
+// to be able to submit valid transactions (i.e. pay tx fees).
+// NOTE: It DOES NOT associate a public key with the account. This will happen when a tx
+// which is signed by the account is broadcast to the network for the first time.
+func (memnet *BaseInMemoryNetwork) FundAddress(
+ t *testing.T,
+ addr types.AccAddress,
+) {
+ t.Helper()
+
+ signerAccountNumber := 0
+ clientCtx := memnet.GetClientCtx(t)
+ net := memnet.GetNetwork(t)
+ val := net.Validators[0]
+
+ args := []string{
+ fmt.Sprintf("--%s=true", flags.FlagOffline),
+ fmt.Sprintf("--%s=%d", flags.FlagAccountNumber, signerAccountNumber),
+ fmt.Sprintf("--%s=%d", flags.FlagSequence, memnet.NextValidatorTxSequenceNumber(t)),
+
+ fmt.Sprintf("--%s=%s", flags.FlagFrom, val.Address.String()),
+ fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+ fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastSync),
+ fmt.Sprintf("--%s=%s", flags.FlagFees, memnet.NewBondDenomCoins(t, 10).String()),
+ }
+ amount := memnet.NewBondDenomCoins(t, 200)
+ responseRaw, err := testcli.MsgSendExec(clientCtx, val.Address, addr, amount, args...)
+ require.NoError(t, err)
+ var responseJSON map[string]interface{}
+ err = json.Unmarshal(responseRaw.Bytes(), &responseJSON)
+ require.NoError(t, err)
+ require.Equal(t, float64(0), responseJSON["code"], "code is not 0 in the response: %v", responseJSON)
+}
+
+// FundSupplierAccounts initializes account addresses and sequence numbers for,
+// each supplier in the given list, with the auth module by sending them some tokens
+// from the in-memory network validator, to the address provided. This is a necessary
+// prerequisite in order for the account with the given address to be able to submit
+// valid transactions (i.e. pay tx fees).
+// NOTE: It DOES NOT associate a public key with the account. This will happen when a tx
+// which is signed by the account is broadcast to the network for the first time.
+func (memnet *BaseInMemoryNetwork) FundSupplierAccounts(
+ t *testing.T,
+ supplierList ...sharedtypes.Supplier,
+) {
+ t.Helper()
+
+ net := memnet.GetNetwork(t)
+ require.NotNil(t, net, "in-memory cosmos testutil network not initialized yet, call #Start() first")
+
+ for _, supplier := range supplierList {
+ supplierAddr, err := types.AccAddressFromBech32(supplier.GetAddress())
+ require.NoError(t, err)
+ memnet.FundAddress(t, supplierAddr)
+ }
+}
+
+// FundAppAccounts initializes account addresses and sequence numbers for, each
+// application in the given list, with the auth module by sending them some tokens
+// from the in-memory network validator, to the address provided. This is a necessary
+// prerequisite in order for the account with the given address to be able to submit
+// valid transactions (i.e. pay tx fees).
+// NOTE: It DOES NOT associate a public key with the account. This will happen when a tx
+// which is signed by the account is broadcast to the network for the first time.
+func (memnet *BaseInMemoryNetwork) FundAppAccounts(
+ t *testing.T,
+ appList ...apptypes.Application,
+) {
+ t.Helper()
+
+ for _, application := range appList {
+ appAddr, err := types.AccAddressFromBech32(application.GetAddress())
+ require.NoError(t, err)
+ memnet.FundAddress(t, appAddr)
+ }
+}
+
+// FundGatewayAccounts initializes account addresses and sequence numbers for, each
+// gateway in the given list, with the auth module by sending them some tokens
+// from the in-memory network validator, to the address provided. This is a necessary
+// prerequisite in order for the account with the given address to be able to submit
+// valid transactions (i.e. pay tx fees).
+// NOTE: It DOES NOT associate a public key with the account. This will happen when a tx
+// which is signed by the account is broadcast to the network for the first time.
+func (memnet *BaseInMemoryNetwork) FundGatewayAccounts(
+ t *testing.T,
+ gatewayList ...gatewaytypes.Gateway,
+) {
+ t.Helper()
+
+ for _, gateway := range gatewayList {
+ gatewayAddr, err := types.AccAddressFromBech32(gateway.GetAddress())
+ require.NoError(t, err)
+ memnet.FundAddress(t, gatewayAddr)
+ }
+}
+
+func (memnet *BaseInMemoryNetwork) NewBondDenomCoins(t *testing.T, numCoins int64) sdk.Coins {
+ t.Helper()
+
+ return sdk.NewCoins(sdk.NewCoin(memnet.GetNetwork(t).Config.BondDenom, math.NewInt(numCoins)))
+}

testutil/network/basenet/network.go

@@ -0,0 +1,130 @@
+package basenet
+
+import (
+ "context"
+ "sync/atomic"
+ "testing"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ sdknetwork "github.com/cosmos/cosmos-sdk/testutil/network"
+ "github.com/stretchr/testify/require"
+
+ "github.com/pokt-network/poktroll/testutil/network"
+ "github.com/pokt-network/poktroll/testutil/testkeyring"
+)
+
+var _ network.InMemoryNetwork = (*BaseInMemoryNetwork)(nil)
+
+// BaseInMemoryNetwork is an "abstract" (i.e. partial) implementation, intended
+// to consolidate shared behavior between multiple ("concrete") InMemoryNetwork
+// implementations. These shared behaviors (methods) are accessible to any concrete
+// implementation which embeds BaseInMemoryNetwork.
+type BaseInMemoryNetwork struct {
+ Config network.InMemoryNetworkConfig
+ PreGeneratedAccountIterator *testkeyring.PreGeneratedAccountIterator
+ CosmosNetwork *sdknetwork.Network
+
+ // lastValidatorSeqNumber stores the last (most recently generated) account sequence number.
+ // NB: explicitly NOT using atomic.Int32 as it's usage doesn't compose well with anonymous
+ // literal declarations.
+ lastValidatorSeqNumber int32
+}
+
+// NewBaseInMemoryNetwork creates a new BaseInMemoryNetwork with the given
+// configuration and pre-generated accounts. Intended to be used in constructor
+// functions of structs that embed BaseInMemoryNetwork.
+func NewBaseInMemoryNetwork(
+ t *testing.T,
+ cfg *network.InMemoryNetworkConfig,
+ preGeneratedAccounts *testkeyring.PreGeneratedAccountIterator,
+) *BaseInMemoryNetwork {
+ t.Helper()
+
+ return &BaseInMemoryNetwork{
+ Config: *cfg,
+ PreGeneratedAccountIterator: preGeneratedAccounts,
+
+ // First functional account sequence number is 1. Starting at 0 so that
+ // callers can always use NextValidatorTxSequenceNumber() (no boundary condition).
+ lastValidatorSeqNumber: int32(0),
+ }
+}
+
+// InitializeDefaults sets the underlying cosmos-sdk testutil network config to
+// a reasonable default in case one was not provided with the InMemoryNetworkConfig.
+func (memnet *BaseInMemoryNetwork) InitializeDefaults(t *testing.T) {
+ if memnet.Config.CosmosCfg != nil {
+ t.Log("Cosmos config already initialized, using existing config")
+ return
+ }
+
+ t.Log("Cosmos config not initialized, using default config")
+ // Initialize a network config.
+ cfg := network.DefaultConfig()
+ memnet.Config.CosmosCfg = &cfg
+}
+
+// GetClientCtx returns the underlying cosmos-sdk testutil network's client context.
+func (memnet *BaseInMemoryNetwork) GetClientCtx(t *testing.T) client.Context {
+ t.Helper()
+
+ // Only the first validator's client context is populated.
+ // (see: https://pkg.go.dev/github.com/cosmos/cosmos-sdk/testutil/network#pkg-overview)
+ ctx := memnet.GetNetwork(t).Validators[0].ClientCtx
+
+ // TODO_NEXT(@bryanchriswhite): Ensure validator key is always available.
+
+ // Overwrite the client context's Keyring with the in-memory one that contains
+ // our pre-generated accounts.
+ return ctx.WithKeyring(memnet.Config.Keyring)
+}
+
+// GetConfig returns the InMemoryNetworkConfig which associated with a given
+// InMemoryNetwork instance.
+func (memnet *BaseInMemoryNetwork) GetConfig(t *testing.T) *network.InMemoryNetworkConfig {
+ t.Helper()
+
+ return &memnet.Config
+}
+
+// GetCosmosNetworkConfig returns the underlying cosmos-sdk testutil network config.
+// It requires that the config has been set, failing the test if not.
+func (memnet *BaseInMemoryNetwork) GetCosmosNetworkConfig(t *testing.T) *sdknetwork.Config {
+ t.Helper()
+
+ require.NotEmptyf(t, memnet.Config, "in-memory network config not set")
+ return memnet.Config.CosmosCfg
+}
+
+// GetNetwork returns the underlying cosmos-sdk testutil network instance.
+// It requires that the cosmos-sdk in-memory network has been set, failing the test if not.
+func (memnet *BaseInMemoryNetwork) GetNetwork(t *testing.T) *sdknetwork.Network {
+ t.Helper()
+
+ require.NotEmptyf(t, memnet.CosmosNetwork, "in-memory cosmos network not set")
+ return memnet.CosmosNetwork
+}
+
+// GetLastValidatorTxSequenceNumber returns the last (most recently generated) account sequence number.
+// It is safe for concurrent use.
+func (memnet *BaseInMemoryNetwork) GetLastValidatorTxSequenceNumber(t *testing.T) int {
+ t.Helper()
+
+ return int(atomic.LoadInt32(&memnet.lastValidatorSeqNumber))
+}
+
+// NextValidatorTxSequenceNumber increments the account sequence number and returns the new value.
+// It is safe for concurrent use.
+func (memnet *BaseInMemoryNetwork) NextValidatorTxSequenceNumber(t *testing.T) int {
+ t.Helper()
+
+ return int(atomic.AddInt32(&memnet.lastValidatorSeqNumber, 1))
+}
+
+// Start is a stub which is expected to be implemented by "concrete" InMemoryNetwork
+// implementations. As BaseInMemoryNetwork is intended to be an "abstract" implementation,
+// it is too general to define this behavior, leaving it up to embedders. As a result,
+// this function panics if it is called.
+func (memnet *BaseInMemoryNetwork) Start(_ context.Context, t *testing.T) {
+ panic("must be implemented by struct embedders")
+}