test: implement simulation functions

.github/workflows/test.yml

@@ -88,3 +88,16 @@ jobs:
  - uses: codecov/[email protected]
  with:
  file: ./coverage.txt
+
+ test-simulation:
+ runs-on: ubuntu-latest
+ timeout-minutes: 15
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions/[email protected]
+ with:
+ go-version: 1.15
+ - name: Display go version
+ run: go version
+ - name: Testing simulation
+ run: make test-sim-nondeterminism

Makefile

@@ -7,6 +7,7 @@ BINDIR ?= $(GOPATH)/bin
 DOCKER := $(shell which docker)
 DOCKER_BUF := $(DOCKER) run --rm -v $(CURDIR):/workspace --workdir /workspace bufbuild/buf
 BUILDDIR ?= $(CURDIR)/build
+SIMAPP = ./app
 
 export GO111MODULE = on
 
@@ -154,6 +155,24 @@ benchmark:
 
 .PHONY: test test-all test-unit test-race test-cover test-build
 
+test-sim-nondeterminism:
+ @echo "Running non-determinism test..."
+ @go test -mod=readonly $(SIMAPP) -run TestAppStateDeterminism -Enabled=true \
+ -NumBlocks=100 -BlockSize=200 -Commit=true -Period=0 -v -timeout 24h
+
+test-sim-import-export: runsim
+ @echo "Running application import/export simulation. This may take several minutes..."
+ @$(BINDIR)/runsim -Jobs=4 -SimAppPkg=$(SIMAPP) -ExitOnFail 10 5 TestAppImportExport
+
+test-sim-after-import: runsim
+ @echo "Running application simulation-after-import. This may take several minutes..."
+ @$(BINDIR)/runsim -Jobs=4 -SimAppPkg=$(SIMAPP) -ExitOnFail 10 5 TestAppSimulationAfterImport
+
+.PHONY: \
+test-sim-nondeterminism \
+test-sim-import-export \
+test-sim-after-import 
+
 ###############################################################################
 ### Localnet ###
 ###############################################################################

app/app.go

@@ -113,9 +113,9 @@ var (
  mint.AppModuleBasic{},
  distr.AppModuleBasic{},
  gov.NewAppModuleBasic(
- paramsclient.ProposalHandler, distrclient.ProposalHandler, upgradeclient.ProposalHandler, upgradeclient.CancelProposalHandler,
+ paramsclient.ProposalHandler, distrclient.ProposalHandler,
+ upgradeclient.ProposalHandler, upgradeclient.CancelProposalHandler,
  farmingclient.ProposalHandler,
- // todo: farming proposal handler
  ),
  params.AppModuleBasic{},
  crisis.AppModuleBasic{},
@@ -137,7 +137,7 @@ var (
  stakingtypes.BondedPoolName: {authtypes.Burner, authtypes.Staking},
  stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking},
  govtypes.ModuleName: {authtypes.Burner},
- farmingtypes.ModuleName: nil,
+ farmingtypes.ModuleName: {authtypes.Minter},
  // todo: farming Staking Reserve Coin TBD
  }
 )
@@ -580,6 +580,15 @@ func RegisterSwaggerAPI(ctx client.Context, rtr *mux.Router) {
  rtr.PathPrefix("/swagger/").Handler(http.StripPrefix("/swagger/", staticServer))
 }
 
+// GetMaccPerms returns a copy of the module account permissions
+func GetMaccPerms() map[string][]string {
+ dupMaccPerms := make(map[string][]string)
+ for k, v := range maccPerms {
+ dupMaccPerms[k] = v
+ }
+ return dupMaccPerms
+}
+
 // initParamsKeeper init params keeper and its subspaces
 func initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino *codec.LegacyAmino, key, tkey sdk.StoreKey) paramskeeper.Keeper {
  paramsKeeper := paramskeeper.NewKeeper(appCodec, legacyAmino, key, tkey)

app/app_test.go

@@ -5,17 +5,51 @@ import (
  "os"
  "testing"
 
+ "github.com/golang/mock/gomock"
  "github.com/stretchr/testify/require"
+
+ "github.com/cosmos/cosmos-sdk/baseapp"
+ "github.com/cosmos/cosmos-sdk/tests/mocks"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/cosmos/cosmos-sdk/types/module"
+ "github.com/cosmos/cosmos-sdk/x/auth"
+ "github.com/cosmos/cosmos-sdk/x/auth/vesting"
+ authzmodule "github.com/cosmos/cosmos-sdk/x/authz/module"
+ "github.com/cosmos/cosmos-sdk/x/bank"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ "github.com/cosmos/cosmos-sdk/x/capability"
+ "github.com/cosmos/cosmos-sdk/x/crisis"
+ "github.com/cosmos/cosmos-sdk/x/distribution"
+ "github.com/cosmos/cosmos-sdk/x/evidence"
+ feegrantmodule "github.com/cosmos/cosmos-sdk/x/feegrant/module"
+ "github.com/cosmos/cosmos-sdk/x/genutil"
+ "github.com/cosmos/cosmos-sdk/x/gov"
+ "github.com/cosmos/cosmos-sdk/x/mint"
+ "github.com/cosmos/cosmos-sdk/x/params"
+ "github.com/cosmos/cosmos-sdk/x/slashing"
+ "github.com/cosmos/cosmos-sdk/x/staking"
+ "github.com/cosmos/cosmos-sdk/x/upgrade"
  abci "github.com/tendermint/tendermint/abci/types"
  "github.com/tendermint/tendermint/libs/log"
+ tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
  dbm "github.com/tendermint/tm-db"
+
+ "github.com/tendermint/farming/x/farming"
 )
 
-func TestSimAppExport(t *testing.T) {
+func TestSimAppExportAndBlockedAddrs(t *testing.T) {
  encCfg := MakeTestEncodingConfig()
  db := dbm.NewMemDB()
  app := NewFarmingApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encCfg, EmptyAppOptions{})
 
+ for acc := range maccPerms {
+ require.True(
+ t,
+ app.BankKeeper.BlockedAddr(app.AccountKeeper.GetModuleAddress(acc)),
+ "ensure that blocked addresses are properly set in bank keeper",
+ )
+ }
+
  genesisState := NewDefaultGenesisState(encCfg.Marshaler)
  stateBytes, err := json.MarshalIndent(genesisState, "", " ")
  require.NoError(t, err)
@@ -29,8 +63,209 @@ func TestSimAppExport(t *testing.T) {
  )
  app.Commit()
 
- res, err := app.ExportAppStateAndValidators(false, []string{})
+ // Making a new app object with the db, so that initchain hasn't been called
+ app2 := NewFarmingApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encCfg, EmptyAppOptions{})
+ res, err := app2.ExportAppStateAndValidators(false, []string{})
  require.NoError(t, err, "ExportAppStateAndValidators should not have an error")
+
  _, err = res.AppState.MarshalJSON()
  require.NoError(t, err)
 }
+
+func TestGetMaccPerms(t *testing.T) {
+ dup := GetMaccPerms()
+ require.Equal(t, maccPerms, dup, "duplicated module account permissions differed from actual module account permissions")
+}
+
+func TestRunMigrations(t *testing.T) {
+ db := dbm.NewMemDB()
+ encCfg := MakeTestEncodingConfig()
+ logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
+ app := NewFarmingApp(logger, db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encCfg, EmptyAppOptions{})
+
+ // Create a new baseapp and configurator for the purpose of this test.
+ bApp := baseapp.NewBaseApp(appName, logger, db, encCfg.TxConfig.TxDecoder())
+ bApp.SetCommitMultiStoreTracer(nil)
+ bApp.SetInterfaceRegistry(encCfg.InterfaceRegistry)
+ app.BaseApp = bApp
+ app.configurator = module.NewConfigurator(app.appCodec, app.MsgServiceRouter(), app.GRPCQueryRouter())
+
+ // We register all modules on the Configurator, except x/bank. x/bank will
+ // serve as the test subject on which we run the migration tests.
+ //
+ // The loop below is the same as calling `RegisterServices` on
+ // ModuleManager, except that we skip x/bank.
+ for _, module := range app.mm.Modules {
+ if module.Name() == banktypes.ModuleName {
+ continue
+ }
+
+ module.RegisterServices(app.configurator)
+ }
+
+ // Initialize the chain
+ app.InitChain(abci.RequestInitChain{})
+ app.Commit()
+
+ testCases := []struct {
+ name string
+ moduleName string
+ forVersion uint64
+ expRegErr bool // errors while registering migration
+ expRegErrMsg string
+ expRunErr bool // errors while running migration
+ expRunErrMsg string
+ expCalled int
+ }{
+ {
+ "cannot register migration for version 0",
+ "bank", 0,
+ true, "module migration versions should start at 1: invalid version", false, "", 0,
+ },
+ {
+ "throws error on RunMigrations if no migration registered for bank",
+ "", 1,
+ false, "", true, "no migrations found for module bank: not found", 0,
+ },
+ {
+ "can register and run migration handler for x/bank",
+ "bank", 1,
+ false, "", false, "", 1,
+ },
+ {
+ "cannot register migration handler for same module & forVersion",
+ "bank", 1,
+ true, "another migration for module bank and version 1 already exists: internal logic error", false, "", 0,
+ },
+ }
+
+ for _, tc := range testCases {
+ t.Run(tc.name, func(t *testing.T) {
+ var err error
+
+ // Since it's very hard to test actual in-place store migrations in
+ // tests (due to the difficulty of maintaining multiple versions of a
+ // module), we're just testing here that the migration logic is
+ // called.
+ called := 0
+
+ if tc.moduleName != "" {
+ // Register migration for module from version `forVersion` to `forVersion+1`.
+ err = app.configurator.RegisterMigration(tc.moduleName, tc.forVersion, func(sdk.Context) error {
+ called++
+
+ return nil
+ })
+
+ if tc.expRegErr {
+ require.EqualError(t, err, tc.expRegErrMsg)
+
+ return
+ }
+ }
+ require.NoError(t, err)
+
+ // Run migrations only for bank. That's why we put the initial
+ // version for bank as 1, and for all other modules, we put as
+ // their latest ConsensusVersion.
+ _, err = app.mm.RunMigrations(
+ app.NewContext(true, tmproto.Header{Height: app.LastBlockHeight()}), app.configurator,
+ module.VersionMap{
+ "bank": 1,
+ "auth": auth.AppModule{}.ConsensusVersion(),
+ "authz": authzmodule.AppModule{}.ConsensusVersion(),
+ "staking": staking.AppModule{}.ConsensusVersion(),
+ "mint": mint.AppModule{}.ConsensusVersion(),
+ "distribution": distribution.AppModule{}.ConsensusVersion(),
+ "slashing": slashing.AppModule{}.ConsensusVersion(),
+ "gov": gov.AppModule{}.ConsensusVersion(),
+ "params": params.AppModule{}.ConsensusVersion(),
+ "upgrade": upgrade.AppModule{}.ConsensusVersion(),
+ "vesting": vesting.AppModule{}.ConsensusVersion(),
+ "feegrant": feegrantmodule.AppModule{}.ConsensusVersion(),
+ "evidence": evidence.AppModule{}.ConsensusVersion(),
+ "crisis": crisis.AppModule{}.ConsensusVersion(),
+ "genutil": genutil.AppModule{}.ConsensusVersion(),
+ "capability": capability.AppModule{}.ConsensusVersion(),
+ "farming": farming.AppModule{}.ConsensusVersion(),
+ },
+ )
+ if tc.expRunErr {
+ require.EqualError(t, err, tc.expRunErrMsg)
+ } else {
+ require.NoError(t, err)
+ // Make sure bank's migration is called.
+ require.Equal(t, tc.expCalled, called)
+ }
+ })
+ }
+}
+
+func TestInitGenesisOnMigration(t *testing.T) {
+ db := dbm.NewMemDB()
+ encCfg := MakeTestEncodingConfig()
+ logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
+ app := NewFarmingApp(logger, db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encCfg, EmptyAppOptions{})
+ ctx := app.NewContext(true, tmproto.Header{Height: app.LastBlockHeight()})
+
+ // Create a mock module. This module will serve as the new module we're
+ // adding during a migration.
+ mockCtrl := gomock.NewController(t)
+ t.Cleanup(mockCtrl.Finish)
+ mockModule := mocks.NewMockAppModule(mockCtrl)
+ mockDefaultGenesis := json.RawMessage(`{"key": "value"}`)
+ mockModule.EXPECT().DefaultGenesis(gomock.Eq(app.appCodec)).Times(1).Return(mockDefaultGenesis)
+ mockModule.EXPECT().InitGenesis(gomock.Eq(ctx), gomock.Eq(app.appCodec), gomock.Eq(mockDefaultGenesis)).Times(1).Return(nil)
+ mockModule.EXPECT().ConsensusVersion().Times(1).Return(uint64(0))
+
+ app.mm.Modules["mock"] = mockModule
+
+ // Run migrations only for "mock" module. We exclude it from
+ // the VersionMap to simulate upgrading with a new module.
+ _, err := app.mm.RunMigrations(ctx, app.configurator,
+ module.VersionMap{
+ "bank": bank.AppModule{}.ConsensusVersion(),
+ "auth": auth.AppModule{}.ConsensusVersion(),
+ "authz": authzmodule.AppModule{}.ConsensusVersion(),
+ "staking": staking.AppModule{}.ConsensusVersion(),
+ "mint": mint.AppModule{}.ConsensusVersion(),
+ "distribution": distribution.AppModule{}.ConsensusVersion(),
+ "slashing": slashing.AppModule{}.ConsensusVersion(),
+ "gov": gov.AppModule{}.ConsensusVersion(),
+ "params": params.AppModule{}.ConsensusVersion(),
+ "upgrade": upgrade.AppModule{}.ConsensusVersion(),
+ "vesting": vesting.AppModule{}.ConsensusVersion(),
+ "feegrant": feegrantmodule.AppModule{}.ConsensusVersion(),
+ "evidence": evidence.AppModule{}.ConsensusVersion(),
+ "crisis": crisis.AppModule{}.ConsensusVersion(),
+ "genutil": genutil.AppModule{}.ConsensusVersion(),
+ "capability": capability.AppModule{}.ConsensusVersion(),
+ "farming": farming.AppModule{}.ConsensusVersion(),
+ },
+ )
+ require.NoError(t, err)
+}
+
+func TestUpgradeStateOnGenesis(t *testing.T) {
+ encCfg := MakeTestEncodingConfig()
+ db := dbm.NewMemDB()
+ app := NewFarmingApp(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), db, nil, true, map[int64]bool{}, DefaultNodeHome, 0, encCfg, EmptyAppOptions{})
+ genesisState := NewDefaultGenesisState(encCfg.Marshaler)
+ stateBytes, err := json.MarshalIndent(genesisState, "", " ")
+ require.NoError(t, err)
+
+ // Initialize the chain
+ app.InitChain(
+ abci.RequestInitChain{
+ Validators: []abci.ValidatorUpdate{},
+ AppStateBytes: stateBytes,
+ },
+ )
+
+ // make sure the upgrade keeper has version map in state
+ ctx := app.NewContext(false, tmproto.Header{})
+ vm := app.UpgradeKeeper.GetModuleVersionMap(ctx)
+ for v, i := range app.mm.Modules {
+ require.Equal(t, vm[v], i.ConsensusVersion())
+ }
+}

app/params/weights.go

@@ -1,10 +1,10 @@
 package params
 
 const (
- // TODO: farming determine the weights
- DefaultWeightMsgCreateFixedAmountPlan int = 0
- DefaultWeightMsgCreateRatioPlan int = 0
- DefaultWeightMsgStake int = 0
- DefaultWeightMsgUnstake int = 0
- DefaultWeightMsgHarvest int = 0
+ // farming module simulation operation weights for messages
+ DefaultWeightMsgCreateFixedAmountPlan int = 10
+ DefaultWeightMsgCreateRatioPlan int = 10
+ DefaultWeightMsgStake int = 85
+ DefaultWeightMsgUnstake int = 30
+ DefaultWeightMsgHarvest int = 30
 )