From 9412bcd82aa9837f01394063266c430027c2ce78 Mon Sep 17 00:00:00 2001 From: atheeshp <59333759+atheeshp@users.noreply.github.com> Date: Mon, 22 Aug 2022 18:07:05 +0530 Subject: [PATCH] feat: x/group tests to mocks (#12864) ## Description Closes: #12763 --- ### Author Checklist *All items are required. Please add a note to the item if the item is not applicable and please add links to any relevant follow up issues.* I have... - [ ] included the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] added `!` to the type prefix if API or client breaking change - [ ] targeted the correct branch (see [PR Targeting](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#pr-targeting)) - [ ] provided a link to the relevant issue or specification - [ ] followed the guidelines for [building modules](https://github.com/cosmos/cosmos-sdk/blob/main/docs/building-modules) - [ ] included the necessary unit and integration [tests](https://github.com/cosmos/cosmos-sdk/blob/main/CONTRIBUTING.md#testing) - [ ] added a changelog entry to `CHANGELOG.md` - [ ] included comments for [documenting Go code](https://blog.golang.org/godoc) - [ ] updated the relevant documentation or specification - [ ] reviewed "Files changed" and left comments if necessary - [ ] confirmed all CI checks have passed ### Reviewers Checklist *All items are required. Please add a note if the item is not applicable and please add your handle next to the items reviewed if you only reviewed selected items.* I have... - [ ] confirmed the correct [type prefix](https://github.com/commitizen/conventional-commit-types/blob/v3.0.0/index.json) in the PR title - [ ] confirmed `!` in the type prefix if API or client breaking change - [ ] confirmed all author checklist items have been addressed - [ ] reviewed state machine logic - [ ] reviewed API design and naming - [ ] reviewed documentation is accurate - [ ] reviewed tests and test coverage - [ ] manually tested (if applicable) --- scripts/mockgen.sh | 1 + store/v2alpha1/dbadapter/store_test.go | 6 +- tests/mocks/db/types.go | 168 +++---- tests/mocks/types_module_module.go | 484 ++++++++++++++++++--- testutil/sims/address_helpers.go | 2 +- types/module/module_test.go | 11 +- x/gov/migrations/v3/store_test.go | 2 +- x/group/keeper/genesis_test.go | 55 ++- x/group/keeper/grpc_query_test.go | 62 ++- x/group/keeper/keeper.go | 5 + x/group/keeper/keeper_test.go | 284 +++++++++--- x/group/simulation/operations_test.go | 3 - x/group/testutil/expected_keepers.go | 25 ++ x/group/testutil/expected_keepers_mocks.go | 202 +++++++++ 14 files changed, 1045 insertions(+), 265 deletions(-) create mode 100644 x/group/testutil/expected_keepers.go create mode 100644 x/group/testutil/expected_keepers_mocks.go diff --git a/scripts/mockgen.sh b/scripts/mockgen.sh index 6c6be4a74f..f0b02b5d4d 100755 --- a/scripts/mockgen.sh +++ b/scripts/mockgen.sh @@ -19,5 +19,6 @@ $mockgen_cmd -source=x/auth/types/expected_keepers.go -package testutil -destina $mockgen_cmd -source=x/auth/ante/expected_keepers.go -package testutil -destination x/auth/ante/testutil/expected_keepers_mocks.go $mockgen_cmd -source=x/authz/expected_keepers.go -package testutil -destination x/authz/testutil/expected_keepers_mocks.go $mockgen_cmd -source=x/bank/types/expected_keepers.go -package testutil -destination x/bank/testutil/expected_keepers_mocks.go +$mockgen_cmd -source=x/group/testutil/expected_keepers.go -package testutil -destination x/group/testutil/expected_keepers_mocks.go $mockgen_cmd -source=x/evidence/types/expected_keepers.go -package testutil -destination x/evidence/testutil/expected_keepers_mocks.go $mockgen_cmd -source=x/slashing/types/expected_keepers.go -package testutil -destination x/slashing/testutil/expected_keepers_mocks.go diff --git a/store/v2alpha1/dbadapter/store_test.go b/store/v2alpha1/dbadapter/store_test.go index 9bfa68518a..8cce25d005 100644 --- a/store/v2alpha1/dbadapter/store_test.go +++ b/store/v2alpha1/dbadapter/store_test.go @@ -20,7 +20,7 @@ func TestAccessors(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() - mockDB := mocks.NewMockDBReadWriter(mockCtrl) + mockDB := mocks.NewMockReadWriter(mockCtrl) store := dbadapter.Store{mockDB} key := []byte("test") value := []byte("testvalue") @@ -64,7 +64,7 @@ func TestIterators(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() - mockDB := mocks.NewMockDBReadWriter(mockCtrl) + mockDB := mocks.NewMockReadWriter(mockCtrl) store := dbadapter.Store{mockDB} key := []byte("test") value := []byte("testvalue") @@ -91,7 +91,7 @@ func TestIterators(t *testing.T) { func TestCacheWraps(t *testing.T) { mockCtrl := gomock.NewController(t) - mockDB := mocks.NewMockDBReadWriter(mockCtrl) + mockDB := mocks.NewMockReadWriter(mockCtrl) store := dbadapter.Store{mockDB} cacheWrapper := store.CacheWrap() diff --git a/tests/mocks/db/types.go b/tests/mocks/db/types.go index 7b9429b592..b50f70fdc5 100644 --- a/tests/mocks/db/types.go +++ b/tests/mocks/db/types.go @@ -177,31 +177,31 @@ func (mr *MockConnectionMockRecorder) Writer() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Writer", reflect.TypeOf((*MockConnection)(nil).Writer)) } -// MockDBReader is a mock of DBReader interface. -type MockDBReader struct { +// MockReader is a mock of Reader interface. +type MockReader struct { ctrl *gomock.Controller - recorder *MockDBReaderMockRecorder + recorder *MockReaderMockRecorder } -// MockDBReaderMockRecorder is the mock recorder for MockDBReader. -type MockDBReaderMockRecorder struct { - mock *MockDBReader +// MockReaderMockRecorder is the mock recorder for MockReader. +type MockReaderMockRecorder struct { + mock *MockReader } -// NewMockDBReader creates a new mock instance. -func NewMockDBReader(ctrl *gomock.Controller) *MockDBReader { - mock := &MockDBReader{ctrl: ctrl} - mock.recorder = &MockDBReaderMockRecorder{mock} +// NewMockReader creates a new mock instance. +func NewMockReader(ctrl *gomock.Controller) *MockReader { + mock := &MockReader{ctrl: ctrl} + mock.recorder = &MockReaderMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDBReader) EXPECT() *MockDBReaderMockRecorder { +func (m *MockReader) EXPECT() *MockReaderMockRecorder { return m.recorder } // Discard mocks base method. -func (m *MockDBReader) Discard() error { +func (m *MockReader) Discard() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Discard") ret0, _ := ret[0].(error) @@ -209,13 +209,13 @@ func (m *MockDBReader) Discard() error { } // Discard indicates an expected call of Discard. -func (mr *MockDBReaderMockRecorder) Discard() *gomock.Call { +func (mr *MockReaderMockRecorder) Discard() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockDBReader)(nil).Discard)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockReader)(nil).Discard)) } // Get mocks base method. -func (m *MockDBReader) Get(arg0 []byte) ([]byte, error) { +func (m *MockReader) Get(arg0 []byte) ([]byte, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Get", arg0) ret0, _ := ret[0].([]byte) @@ -224,13 +224,13 @@ func (m *MockDBReader) Get(arg0 []byte) ([]byte, error) { } // Get indicates an expected call of Get. -func (mr *MockDBReaderMockRecorder) Get(arg0 interface{}) *gomock.Call { +func (mr *MockReaderMockRecorder) Get(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDBReader)(nil).Get), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockReader)(nil).Get), arg0) } // Has mocks base method. -func (m *MockDBReader) Has(key []byte) (bool, error) { +func (m *MockReader) Has(key []byte) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Has", key) ret0, _ := ret[0].(bool) @@ -239,13 +239,13 @@ func (m *MockDBReader) Has(key []byte) (bool, error) { } // Has indicates an expected call of Has. -func (mr *MockDBReaderMockRecorder) Has(key interface{}) *gomock.Call { +func (mr *MockReaderMockRecorder) Has(key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockDBReader)(nil).Has), key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockReader)(nil).Has), key) } // Iterator mocks base method. -func (m *MockDBReader) Iterator(start, end []byte) (db.Iterator, error) { +func (m *MockReader) Iterator(start, end []byte) (db.Iterator, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Iterator", start, end) ret0, _ := ret[0].(db.Iterator) @@ -254,13 +254,13 @@ func (m *MockDBReader) Iterator(start, end []byte) (db.Iterator, error) { } // Iterator indicates an expected call of Iterator. -func (mr *MockDBReaderMockRecorder) Iterator(start, end interface{}) *gomock.Call { +func (mr *MockReaderMockRecorder) Iterator(start, end interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockDBReader)(nil).Iterator), start, end) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockReader)(nil).Iterator), start, end) } // ReverseIterator mocks base method. -func (m *MockDBReader) ReverseIterator(start, end []byte) (db.Iterator, error) { +func (m *MockReader) ReverseIterator(start, end []byte) (db.Iterator, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReverseIterator", start, end) ret0, _ := ret[0].(db.Iterator) @@ -269,36 +269,36 @@ func (m *MockDBReader) ReverseIterator(start, end []byte) (db.Iterator, error) { } // ReverseIterator indicates an expected call of ReverseIterator. -func (mr *MockDBReaderMockRecorder) ReverseIterator(start, end interface{}) *gomock.Call { +func (mr *MockReaderMockRecorder) ReverseIterator(start, end interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockDBReader)(nil).ReverseIterator), start, end) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockReader)(nil).ReverseIterator), start, end) } -// MockDBWriter is a mock of DBWriter interface. -type MockDBWriter struct { +// MockWriter is a mock of Writer interface. +type MockWriter struct { ctrl *gomock.Controller - recorder *MockDBWriterMockRecorder + recorder *MockWriterMockRecorder } -// MockDBWriterMockRecorder is the mock recorder for MockDBWriter. -type MockDBWriterMockRecorder struct { - mock *MockDBWriter +// MockWriterMockRecorder is the mock recorder for MockWriter. +type MockWriterMockRecorder struct { + mock *MockWriter } -// NewMockDBWriter creates a new mock instance. -func NewMockDBWriter(ctrl *gomock.Controller) *MockDBWriter { - mock := &MockDBWriter{ctrl: ctrl} - mock.recorder = &MockDBWriterMockRecorder{mock} +// NewMockWriter creates a new mock instance. +func NewMockWriter(ctrl *gomock.Controller) *MockWriter { + mock := &MockWriter{ctrl: ctrl} + mock.recorder = &MockWriterMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDBWriter) EXPECT() *MockDBWriterMockRecorder { +func (m *MockWriter) EXPECT() *MockWriterMockRecorder { return m.recorder } // Commit mocks base method. -func (m *MockDBWriter) Commit() error { +func (m *MockWriter) Commit() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Commit") ret0, _ := ret[0].(error) @@ -306,13 +306,13 @@ func (m *MockDBWriter) Commit() error { } // Commit indicates an expected call of Commit. -func (mr *MockDBWriterMockRecorder) Commit() *gomock.Call { +func (mr *MockWriterMockRecorder) Commit() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockDBWriter)(nil).Commit)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockWriter)(nil).Commit)) } // Delete mocks base method. -func (m *MockDBWriter) Delete(arg0 []byte) error { +func (m *MockWriter) Delete(arg0 []byte) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0) ret0, _ := ret[0].(error) @@ -320,13 +320,13 @@ func (m *MockDBWriter) Delete(arg0 []byte) error { } // Delete indicates an expected call of Delete. -func (mr *MockDBWriterMockRecorder) Delete(arg0 interface{}) *gomock.Call { +func (mr *MockWriterMockRecorder) Delete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDBWriter)(nil).Delete), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockWriter)(nil).Delete), arg0) } // Discard mocks base method. -func (m *MockDBWriter) Discard() error { +func (m *MockWriter) Discard() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Discard") ret0, _ := ret[0].(error) @@ -334,13 +334,13 @@ func (m *MockDBWriter) Discard() error { } // Discard indicates an expected call of Discard. -func (mr *MockDBWriterMockRecorder) Discard() *gomock.Call { +func (mr *MockWriterMockRecorder) Discard() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockDBWriter)(nil).Discard)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockWriter)(nil).Discard)) } // Set mocks base method. -func (m *MockDBWriter) Set(arg0, arg1 []byte) error { +func (m *MockWriter) Set(arg0, arg1 []byte) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Set", arg0, arg1) ret0, _ := ret[0].(error) @@ -348,36 +348,36 @@ func (m *MockDBWriter) Set(arg0, arg1 []byte) error { } // Set indicates an expected call of Set. -func (mr *MockDBWriterMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockWriterMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDBWriter)(nil).Set), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockWriter)(nil).Set), arg0, arg1) } -// MockDBReadWriter is a mock of DBReadWriter interface. -type MockDBReadWriter struct { +// MockReadWriter is a mock of ReadWriter interface. +type MockReadWriter struct { ctrl *gomock.Controller - recorder *MockDBReadWriterMockRecorder + recorder *MockReadWriterMockRecorder } -// MockDBReadWriterMockRecorder is the mock recorder for MockDBReadWriter. -type MockDBReadWriterMockRecorder struct { - mock *MockDBReadWriter +// MockReadWriterMockRecorder is the mock recorder for MockReadWriter. +type MockReadWriterMockRecorder struct { + mock *MockReadWriter } -// NewMockDBReadWriter creates a new mock instance. -func NewMockDBReadWriter(ctrl *gomock.Controller) *MockDBReadWriter { - mock := &MockDBReadWriter{ctrl: ctrl} - mock.recorder = &MockDBReadWriterMockRecorder{mock} +// NewMockReadWriter creates a new mock instance. +func NewMockReadWriter(ctrl *gomock.Controller) *MockReadWriter { + mock := &MockReadWriter{ctrl: ctrl} + mock.recorder = &MockReadWriterMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDBReadWriter) EXPECT() *MockDBReadWriterMockRecorder { +func (m *MockReadWriter) EXPECT() *MockReadWriterMockRecorder { return m.recorder } // Commit mocks base method. -func (m *MockDBReadWriter) Commit() error { +func (m *MockReadWriter) Commit() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Commit") ret0, _ := ret[0].(error) @@ -385,13 +385,13 @@ func (m *MockDBReadWriter) Commit() error { } // Commit indicates an expected call of Commit. -func (mr *MockDBReadWriterMockRecorder) Commit() *gomock.Call { +func (mr *MockReadWriterMockRecorder) Commit() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockDBReadWriter)(nil).Commit)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockReadWriter)(nil).Commit)) } // Delete mocks base method. -func (m *MockDBReadWriter) Delete(arg0 []byte) error { +func (m *MockReadWriter) Delete(arg0 []byte) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Delete", arg0) ret0, _ := ret[0].(error) @@ -399,13 +399,13 @@ func (m *MockDBReadWriter) Delete(arg0 []byte) error { } // Delete indicates an expected call of Delete. -func (mr *MockDBReadWriterMockRecorder) Delete(arg0 interface{}) *gomock.Call { +func (mr *MockReadWriterMockRecorder) Delete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDBReadWriter)(nil).Delete), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockReadWriter)(nil).Delete), arg0) } // Discard mocks base method. -func (m *MockDBReadWriter) Discard() error { +func (m *MockReadWriter) Discard() error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Discard") ret0, _ := ret[0].(error) @@ -413,13 +413,13 @@ func (m *MockDBReadWriter) Discard() error { } // Discard indicates an expected call of Discard. -func (mr *MockDBReadWriterMockRecorder) Discard() *gomock.Call { +func (mr *MockReadWriterMockRecorder) Discard() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockDBReadWriter)(nil).Discard)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Discard", reflect.TypeOf((*MockReadWriter)(nil).Discard)) } // Get mocks base method. -func (m *MockDBReadWriter) Get(arg0 []byte) ([]byte, error) { +func (m *MockReadWriter) Get(arg0 []byte) ([]byte, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Get", arg0) ret0, _ := ret[0].([]byte) @@ -428,13 +428,13 @@ func (m *MockDBReadWriter) Get(arg0 []byte) ([]byte, error) { } // Get indicates an expected call of Get. -func (mr *MockDBReadWriterMockRecorder) Get(arg0 interface{}) *gomock.Call { +func (mr *MockReadWriterMockRecorder) Get(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDBReadWriter)(nil).Get), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockReadWriter)(nil).Get), arg0) } // Has mocks base method. -func (m *MockDBReadWriter) Has(key []byte) (bool, error) { +func (m *MockReadWriter) Has(key []byte) (bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Has", key) ret0, _ := ret[0].(bool) @@ -443,13 +443,13 @@ func (m *MockDBReadWriter) Has(key []byte) (bool, error) { } // Has indicates an expected call of Has. -func (mr *MockDBReadWriterMockRecorder) Has(key interface{}) *gomock.Call { +func (mr *MockReadWriterMockRecorder) Has(key interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockDBReadWriter)(nil).Has), key) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockReadWriter)(nil).Has), key) } // Iterator mocks base method. -func (m *MockDBReadWriter) Iterator(start, end []byte) (db.Iterator, error) { +func (m *MockReadWriter) Iterator(start, end []byte) (db.Iterator, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Iterator", start, end) ret0, _ := ret[0].(db.Iterator) @@ -458,13 +458,13 @@ func (m *MockDBReadWriter) Iterator(start, end []byte) (db.Iterator, error) { } // Iterator indicates an expected call of Iterator. -func (mr *MockDBReadWriterMockRecorder) Iterator(start, end interface{}) *gomock.Call { +func (mr *MockReadWriterMockRecorder) Iterator(start, end interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockDBReadWriter)(nil).Iterator), start, end) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockReadWriter)(nil).Iterator), start, end) } // ReverseIterator mocks base method. -func (m *MockDBReadWriter) ReverseIterator(start, end []byte) (db.Iterator, error) { +func (m *MockReadWriter) ReverseIterator(start, end []byte) (db.Iterator, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ReverseIterator", start, end) ret0, _ := ret[0].(db.Iterator) @@ -473,13 +473,13 @@ func (m *MockDBReadWriter) ReverseIterator(start, end []byte) (db.Iterator, erro } // ReverseIterator indicates an expected call of ReverseIterator. -func (mr *MockDBReadWriterMockRecorder) ReverseIterator(start, end interface{}) *gomock.Call { +func (mr *MockReadWriterMockRecorder) ReverseIterator(start, end interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockDBReadWriter)(nil).ReverseIterator), start, end) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockReadWriter)(nil).ReverseIterator), start, end) } // Set mocks base method. -func (m *MockDBReadWriter) Set(arg0, arg1 []byte) error { +func (m *MockReadWriter) Set(arg0, arg1 []byte) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Set", arg0, arg1) ret0, _ := ret[0].(error) @@ -487,9 +487,9 @@ func (m *MockDBReadWriter) Set(arg0, arg1 []byte) error { } // Set indicates an expected call of Set. -func (mr *MockDBReadWriterMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call { +func (mr *MockReadWriterMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDBReadWriter)(nil).Set), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockReadWriter)(nil).Set), arg0, arg1) } // MockIterator is a mock of Iterator interface. diff --git a/tests/mocks/types_module_module.go b/tests/mocks/types_module_module.go index 5a07c7563d..afda108bcf 100644 --- a/tests/mocks/types_module_module.go +++ b/tests/mocks/types_module_module.go @@ -328,18 +328,6 @@ func (m *MockAppModule) EXPECT() *MockAppModuleMockRecorder { return m.recorder } -// BeginBlock mocks base method. -func (m *MockAppModule) BeginBlock(arg0 types0.Context, arg1 types1.RequestBeginBlock) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "BeginBlock", arg0, arg1) -} - -// BeginBlock indicates an expected call of BeginBlock. -func (mr *MockAppModuleMockRecorder) BeginBlock(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockAppModule)(nil).BeginBlock), arg0, arg1) -} - // ConsensusVersion mocks base method. func (m *MockAppModule) ConsensusVersion() uint64 { m.ctrl.T.Helper() @@ -368,20 +356,6 @@ func (mr *MockAppModuleMockRecorder) DefaultGenesis(arg0 interface{}) *gomock.Ca return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultGenesis", reflect.TypeOf((*MockAppModule)(nil).DefaultGenesis), arg0) } -// EndBlock mocks base method. -func (m *MockAppModule) EndBlock(arg0 types0.Context, arg1 types1.RequestEndBlock) []types1.ValidatorUpdate { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EndBlock", arg0, arg1) - ret0, _ := ret[0].([]types1.ValidatorUpdate) - return ret0 -} - -// EndBlock indicates an expected call of EndBlock. -func (mr *MockAppModuleMockRecorder) EndBlock(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndBlock", reflect.TypeOf((*MockAppModule)(nil).EndBlock), arg0, arg1) -} - // ExportGenesis mocks base method. func (m *MockAppModule) ExportGenesis(arg0 types0.Context, arg1 codec.JSONCodec) json.RawMessage { m.ctrl.T.Helper() @@ -438,20 +412,6 @@ func (mr *MockAppModuleMockRecorder) InitGenesis(arg0, arg1, arg2 interface{}) * return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGenesis", reflect.TypeOf((*MockAppModule)(nil).InitGenesis), arg0, arg1, arg2) } -// LegacyQuerierHandler mocks base method. -func (m *MockAppModule) LegacyQuerierHandler(arg0 *codec.LegacyAmino) types0.Querier { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LegacyQuerierHandler", arg0) - ret0, _ := ret[0].(types0.Querier) - return ret0 -} - -// LegacyQuerierHandler indicates an expected call of LegacyQuerierHandler. -func (mr *MockAppModuleMockRecorder) LegacyQuerierHandler(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LegacyQuerierHandler", reflect.TypeOf((*MockAppModule)(nil).LegacyQuerierHandler), arg0) -} - // Name mocks base method. func (m *MockAppModule) Name() string { m.ctrl.T.Helper() @@ -466,20 +426,6 @@ func (mr *MockAppModuleMockRecorder) Name() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockAppModule)(nil).Name)) } -// QuerierRoute mocks base method. -func (m *MockAppModule) QuerierRoute() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "QuerierRoute") - ret0, _ := ret[0].(string) - return ret0 -} - -// QuerierRoute indicates an expected call of QuerierRoute. -func (mr *MockAppModuleMockRecorder) QuerierRoute() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QuerierRoute", reflect.TypeOf((*MockAppModule)(nil).QuerierRoute)) -} - // RegisterGRPCGatewayRoutes mocks base method. func (m *MockAppModule) RegisterGRPCGatewayRoutes(arg0 client.Context, arg1 *runtime.ServeMux) { m.ctrl.T.Helper() @@ -540,20 +486,6 @@ func (mr *MockAppModuleMockRecorder) RegisterServices(arg0 interface{}) *gomock. return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterServices", reflect.TypeOf((*MockAppModule)(nil).RegisterServices), arg0) } -// Route mocks base method. -func (m *MockAppModule) Route() types0.Route { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Route") - ret0, _ := ret[0].(types0.Route) - return ret0 -} - -// Route indicates an expected call of Route. -func (mr *MockAppModuleMockRecorder) Route() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Route", reflect.TypeOf((*MockAppModule)(nil).Route)) -} - // ValidateGenesis mocks base method. func (m *MockAppModule) ValidateGenesis(arg0 codec.JSONCodec, arg1 client.TxEncodingConfig, arg2 json.RawMessage) error { m.ctrl.T.Helper() @@ -567,3 +499,419 @@ func (mr *MockAppModuleMockRecorder) ValidateGenesis(arg0, arg1, arg2 interface{ mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateGenesis", reflect.TypeOf((*MockAppModule)(nil).ValidateGenesis), arg0, arg1, arg2) } + +// MockBeginBlockAppModule is a mock of BeginBlockAppModule interface. +type MockBeginBlockAppModule struct { + ctrl *gomock.Controller + recorder *MockBeginBlockAppModuleMockRecorder +} + +// MockBeginBlockAppModuleMockRecorder is the mock recorder for MockBeginBlockAppModule. +type MockBeginBlockAppModuleMockRecorder struct { + mock *MockBeginBlockAppModule +} + +// NewMockBeginBlockAppModule creates a new mock instance. +func NewMockBeginBlockAppModule(ctrl *gomock.Controller) *MockBeginBlockAppModule { + mock := &MockBeginBlockAppModule{ctrl: ctrl} + mock.recorder = &MockBeginBlockAppModuleMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBeginBlockAppModule) EXPECT() *MockBeginBlockAppModuleMockRecorder { + return m.recorder +} + +// BeginBlock mocks base method. +func (m *MockBeginBlockAppModule) BeginBlock(arg0 types0.Context, arg1 types1.RequestBeginBlock) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "BeginBlock", arg0, arg1) +} + +// BeginBlock indicates an expected call of BeginBlock. +func (mr *MockBeginBlockAppModuleMockRecorder) BeginBlock(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeginBlock", reflect.TypeOf((*MockBeginBlockAppModule)(nil).BeginBlock), arg0, arg1) +} + +// ConsensusVersion mocks base method. +func (m *MockBeginBlockAppModule) ConsensusVersion() uint64 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsensusVersion") + ret0, _ := ret[0].(uint64) + return ret0 +} + +// ConsensusVersion indicates an expected call of ConsensusVersion. +func (mr *MockBeginBlockAppModuleMockRecorder) ConsensusVersion() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusVersion", reflect.TypeOf((*MockBeginBlockAppModule)(nil).ConsensusVersion)) +} + +// DefaultGenesis mocks base method. +func (m *MockBeginBlockAppModule) DefaultGenesis(arg0 codec.JSONCodec) json.RawMessage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DefaultGenesis", arg0) + ret0, _ := ret[0].(json.RawMessage) + return ret0 +} + +// DefaultGenesis indicates an expected call of DefaultGenesis. +func (mr *MockBeginBlockAppModuleMockRecorder) DefaultGenesis(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultGenesis", reflect.TypeOf((*MockBeginBlockAppModule)(nil).DefaultGenesis), arg0) +} + +// ExportGenesis mocks base method. +func (m *MockBeginBlockAppModule) ExportGenesis(arg0 types0.Context, arg1 codec.JSONCodec) json.RawMessage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportGenesis", arg0, arg1) + ret0, _ := ret[0].(json.RawMessage) + return ret0 +} + +// ExportGenesis indicates an expected call of ExportGenesis. +func (mr *MockBeginBlockAppModuleMockRecorder) ExportGenesis(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportGenesis", reflect.TypeOf((*MockBeginBlockAppModule)(nil).ExportGenesis), arg0, arg1) +} + +// GetQueryCmd mocks base method. +func (m *MockBeginBlockAppModule) GetQueryCmd() *cobra.Command { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryCmd") + ret0, _ := ret[0].(*cobra.Command) + return ret0 +} + +// GetQueryCmd indicates an expected call of GetQueryCmd. +func (mr *MockBeginBlockAppModuleMockRecorder) GetQueryCmd() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryCmd", reflect.TypeOf((*MockBeginBlockAppModule)(nil).GetQueryCmd)) +} + +// GetTxCmd mocks base method. +func (m *MockBeginBlockAppModule) GetTxCmd() *cobra.Command { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTxCmd") + ret0, _ := ret[0].(*cobra.Command) + return ret0 +} + +// GetTxCmd indicates an expected call of GetTxCmd. +func (mr *MockBeginBlockAppModuleMockRecorder) GetTxCmd() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxCmd", reflect.TypeOf((*MockBeginBlockAppModule)(nil).GetTxCmd)) +} + +// InitGenesis mocks base method. +func (m *MockBeginBlockAppModule) InitGenesis(arg0 types0.Context, arg1 codec.JSONCodec, arg2 json.RawMessage) []types1.ValidatorUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InitGenesis", arg0, arg1, arg2) + ret0, _ := ret[0].([]types1.ValidatorUpdate) + return ret0 +} + +// InitGenesis indicates an expected call of InitGenesis. +func (mr *MockBeginBlockAppModuleMockRecorder) InitGenesis(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGenesis", reflect.TypeOf((*MockBeginBlockAppModule)(nil).InitGenesis), arg0, arg1, arg2) +} + +// Name mocks base method. +func (m *MockBeginBlockAppModule) Name() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) + return ret0 +} + +// Name indicates an expected call of Name. +func (mr *MockBeginBlockAppModuleMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockBeginBlockAppModule)(nil).Name)) +} + +// RegisterGRPCGatewayRoutes mocks base method. +func (m *MockBeginBlockAppModule) RegisterGRPCGatewayRoutes(arg0 client.Context, arg1 *runtime.ServeMux) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterGRPCGatewayRoutes", arg0, arg1) +} + +// RegisterGRPCGatewayRoutes indicates an expected call of RegisterGRPCGatewayRoutes. +func (mr *MockBeginBlockAppModuleMockRecorder) RegisterGRPCGatewayRoutes(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGRPCGatewayRoutes", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterGRPCGatewayRoutes), arg0, arg1) +} + +// RegisterInterfaces mocks base method. +func (m *MockBeginBlockAppModule) RegisterInterfaces(arg0 types.InterfaceRegistry) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterInterfaces", arg0) +} + +// RegisterInterfaces indicates an expected call of RegisterInterfaces. +func (mr *MockBeginBlockAppModuleMockRecorder) RegisterInterfaces(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInterfaces", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterInterfaces), arg0) +} + +// RegisterInvariants mocks base method. +func (m *MockBeginBlockAppModule) RegisterInvariants(arg0 types0.InvariantRegistry) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterInvariants", arg0) +} + +// RegisterInvariants indicates an expected call of RegisterInvariants. +func (mr *MockBeginBlockAppModuleMockRecorder) RegisterInvariants(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInvariants", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterInvariants), arg0) +} + +// RegisterLegacyAminoCodec mocks base method. +func (m *MockBeginBlockAppModule) RegisterLegacyAminoCodec(arg0 *codec.LegacyAmino) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterLegacyAminoCodec", arg0) +} + +// RegisterLegacyAminoCodec indicates an expected call of RegisterLegacyAminoCodec. +func (mr *MockBeginBlockAppModuleMockRecorder) RegisterLegacyAminoCodec(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterLegacyAminoCodec", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterLegacyAminoCodec), arg0) +} + +// RegisterServices mocks base method. +func (m *MockBeginBlockAppModule) RegisterServices(arg0 module.Configurator) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterServices", arg0) +} + +// RegisterServices indicates an expected call of RegisterServices. +func (mr *MockBeginBlockAppModuleMockRecorder) RegisterServices(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterServices", reflect.TypeOf((*MockBeginBlockAppModule)(nil).RegisterServices), arg0) +} + +// ValidateGenesis mocks base method. +func (m *MockBeginBlockAppModule) ValidateGenesis(arg0 codec.JSONCodec, arg1 client.TxEncodingConfig, arg2 json.RawMessage) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ValidateGenesis", arg0, arg1, arg2) + ret0, _ := ret[0].(error) + return ret0 +} + +// ValidateGenesis indicates an expected call of ValidateGenesis. +func (mr *MockBeginBlockAppModuleMockRecorder) ValidateGenesis(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateGenesis", reflect.TypeOf((*MockBeginBlockAppModule)(nil).ValidateGenesis), arg0, arg1, arg2) +} + +// MockEndBlockAppModule is a mock of EndBlockAppModule interface. +type MockEndBlockAppModule struct { + ctrl *gomock.Controller + recorder *MockEndBlockAppModuleMockRecorder +} + +// MockEndBlockAppModuleMockRecorder is the mock recorder for MockEndBlockAppModule. +type MockEndBlockAppModuleMockRecorder struct { + mock *MockEndBlockAppModule +} + +// NewMockEndBlockAppModule creates a new mock instance. +func NewMockEndBlockAppModule(ctrl *gomock.Controller) *MockEndBlockAppModule { + mock := &MockEndBlockAppModule{ctrl: ctrl} + mock.recorder = &MockEndBlockAppModuleMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockEndBlockAppModule) EXPECT() *MockEndBlockAppModuleMockRecorder { + return m.recorder +} + +// ConsensusVersion mocks base method. +func (m *MockEndBlockAppModule) ConsensusVersion() uint64 { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsensusVersion") + ret0, _ := ret[0].(uint64) + return ret0 +} + +// ConsensusVersion indicates an expected call of ConsensusVersion. +func (mr *MockEndBlockAppModuleMockRecorder) ConsensusVersion() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusVersion", reflect.TypeOf((*MockEndBlockAppModule)(nil).ConsensusVersion)) +} + +// DefaultGenesis mocks base method. +func (m *MockEndBlockAppModule) DefaultGenesis(arg0 codec.JSONCodec) json.RawMessage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DefaultGenesis", arg0) + ret0, _ := ret[0].(json.RawMessage) + return ret0 +} + +// DefaultGenesis indicates an expected call of DefaultGenesis. +func (mr *MockEndBlockAppModuleMockRecorder) DefaultGenesis(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultGenesis", reflect.TypeOf((*MockEndBlockAppModule)(nil).DefaultGenesis), arg0) +} + +// EndBlock mocks base method. +func (m *MockEndBlockAppModule) EndBlock(arg0 types0.Context, arg1 types1.RequestEndBlock) []types1.ValidatorUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EndBlock", arg0, arg1) + ret0, _ := ret[0].([]types1.ValidatorUpdate) + return ret0 +} + +// EndBlock indicates an expected call of EndBlock. +func (mr *MockEndBlockAppModuleMockRecorder) EndBlock(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EndBlock", reflect.TypeOf((*MockEndBlockAppModule)(nil).EndBlock), arg0, arg1) +} + +// ExportGenesis mocks base method. +func (m *MockEndBlockAppModule) ExportGenesis(arg0 types0.Context, arg1 codec.JSONCodec) json.RawMessage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExportGenesis", arg0, arg1) + ret0, _ := ret[0].(json.RawMessage) + return ret0 +} + +// ExportGenesis indicates an expected call of ExportGenesis. +func (mr *MockEndBlockAppModuleMockRecorder) ExportGenesis(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportGenesis", reflect.TypeOf((*MockEndBlockAppModule)(nil).ExportGenesis), arg0, arg1) +} + +// GetQueryCmd mocks base method. +func (m *MockEndBlockAppModule) GetQueryCmd() *cobra.Command { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueryCmd") + ret0, _ := ret[0].(*cobra.Command) + return ret0 +} + +// GetQueryCmd indicates an expected call of GetQueryCmd. +func (mr *MockEndBlockAppModuleMockRecorder) GetQueryCmd() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryCmd", reflect.TypeOf((*MockEndBlockAppModule)(nil).GetQueryCmd)) +} + +// GetTxCmd mocks base method. +func (m *MockEndBlockAppModule) GetTxCmd() *cobra.Command { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTxCmd") + ret0, _ := ret[0].(*cobra.Command) + return ret0 +} + +// GetTxCmd indicates an expected call of GetTxCmd. +func (mr *MockEndBlockAppModuleMockRecorder) GetTxCmd() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTxCmd", reflect.TypeOf((*MockEndBlockAppModule)(nil).GetTxCmd)) +} + +// InitGenesis mocks base method. +func (m *MockEndBlockAppModule) InitGenesis(arg0 types0.Context, arg1 codec.JSONCodec, arg2 json.RawMessage) []types1.ValidatorUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InitGenesis", arg0, arg1, arg2) + ret0, _ := ret[0].([]types1.ValidatorUpdate) + return ret0 +} + +// InitGenesis indicates an expected call of InitGenesis. +func (mr *MockEndBlockAppModuleMockRecorder) InitGenesis(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitGenesis", reflect.TypeOf((*MockEndBlockAppModule)(nil).InitGenesis), arg0, arg1, arg2) +} + +// Name mocks base method. +func (m *MockEndBlockAppModule) Name() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Name") + ret0, _ := ret[0].(string) + return ret0 +} + +// Name indicates an expected call of Name. +func (mr *MockEndBlockAppModuleMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockEndBlockAppModule)(nil).Name)) +} + +// RegisterGRPCGatewayRoutes mocks base method. +func (m *MockEndBlockAppModule) RegisterGRPCGatewayRoutes(arg0 client.Context, arg1 *runtime.ServeMux) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterGRPCGatewayRoutes", arg0, arg1) +} + +// RegisterGRPCGatewayRoutes indicates an expected call of RegisterGRPCGatewayRoutes. +func (mr *MockEndBlockAppModuleMockRecorder) RegisterGRPCGatewayRoutes(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterGRPCGatewayRoutes", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterGRPCGatewayRoutes), arg0, arg1) +} + +// RegisterInterfaces mocks base method. +func (m *MockEndBlockAppModule) RegisterInterfaces(arg0 types.InterfaceRegistry) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterInterfaces", arg0) +} + +// RegisterInterfaces indicates an expected call of RegisterInterfaces. +func (mr *MockEndBlockAppModuleMockRecorder) RegisterInterfaces(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInterfaces", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterInterfaces), arg0) +} + +// RegisterInvariants mocks base method. +func (m *MockEndBlockAppModule) RegisterInvariants(arg0 types0.InvariantRegistry) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterInvariants", arg0) +} + +// RegisterInvariants indicates an expected call of RegisterInvariants. +func (mr *MockEndBlockAppModuleMockRecorder) RegisterInvariants(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInvariants", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterInvariants), arg0) +} + +// RegisterLegacyAminoCodec mocks base method. +func (m *MockEndBlockAppModule) RegisterLegacyAminoCodec(arg0 *codec.LegacyAmino) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterLegacyAminoCodec", arg0) +} + +// RegisterLegacyAminoCodec indicates an expected call of RegisterLegacyAminoCodec. +func (mr *MockEndBlockAppModuleMockRecorder) RegisterLegacyAminoCodec(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterLegacyAminoCodec", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterLegacyAminoCodec), arg0) +} + +// RegisterServices mocks base method. +func (m *MockEndBlockAppModule) RegisterServices(arg0 module.Configurator) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "RegisterServices", arg0) +} + +// RegisterServices indicates an expected call of RegisterServices. +func (mr *MockEndBlockAppModuleMockRecorder) RegisterServices(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterServices", reflect.TypeOf((*MockEndBlockAppModule)(nil).RegisterServices), arg0) +} + +// ValidateGenesis mocks base method. +func (m *MockEndBlockAppModule) ValidateGenesis(arg0 codec.JSONCodec, arg1 client.TxEncodingConfig, arg2 json.RawMessage) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ValidateGenesis", arg0, arg1, arg2) + ret0, _ := ret[0].(error) + return ret0 +} + +// ValidateGenesis indicates an expected call of ValidateGenesis. +func (mr *MockEndBlockAppModuleMockRecorder) ValidateGenesis(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateGenesis", reflect.TypeOf((*MockEndBlockAppModule)(nil).ValidateGenesis), arg0, arg1, arg2) +} diff --git a/testutil/sims/address_helpers.go b/testutil/sims/address_helpers.go index 9e0a4023bf..a76086375a 100644 --- a/testutil/sims/address_helpers.go +++ b/testutil/sims/address_helpers.go @@ -59,7 +59,7 @@ func initAccountWithCoins(bankKeeper bankkeeper.Keeper, ctx sdk.Context, addr sd } } -// createIncrementalAccounts is a strategy used by addTestAddrs() in order to generated addresses in ascending order. +// CreateIncrementalAccounts is a strategy used by addTestAddrs() in order to generated addresses in ascending order. func CreateIncrementalAccounts(accNum int) []sdk.AccAddress { var addresses []sdk.AccAddress var buffer bytes.Buffer diff --git a/types/module/module_test.go b/types/module/module_test.go index 2f52b0dbbc..6247ab3628 100644 --- a/types/module/module_test.go +++ b/types/module/module_test.go @@ -12,7 +12,6 @@ import ( "github.com/tendermint/tendermint/libs/log" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" - "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/tests/mocks" @@ -29,8 +28,6 @@ func TestBasicManager(t *testing.T) { interfaceRegistry := types.NewInterfaceRegistry() cdc := codec.NewProtoCodec(interfaceRegistry) - clientCtx := client.Context{} - clientCtx = clientCtx.WithLegacyAmino(legacyAmino) wantDefaultGenesis := map[string]json.RawMessage{"mockAppModuleBasic1": json.RawMessage(``)} mockAppModuleBasic1 := mocks.NewMockAppModuleBasic(mockCtrl) @@ -208,8 +205,8 @@ func TestManager_BeginBlock(t *testing.T) { mockCtrl := gomock.NewController(t) t.Cleanup(mockCtrl.Finish) - mockAppModule1 := mocks.NewMockAppModule(mockCtrl) - mockAppModule2 := mocks.NewMockAppModule(mockCtrl) + mockAppModule1 := mocks.NewMockBeginBlockAppModule(mockCtrl) + mockAppModule2 := mocks.NewMockBeginBlockAppModule(mockCtrl) mockAppModule1.EXPECT().Name().Times(2).Return("module1") mockAppModule2.EXPECT().Name().Times(2).Return("module2") mm := module.NewManager(mockAppModule1, mockAppModule2) @@ -227,8 +224,8 @@ func TestManager_EndBlock(t *testing.T) { mockCtrl := gomock.NewController(t) t.Cleanup(mockCtrl.Finish) - mockAppModule1 := mocks.NewMockAppModule(mockCtrl) - mockAppModule2 := mocks.NewMockAppModule(mockCtrl) + mockAppModule1 := mocks.NewMockEndBlockAppModule(mockCtrl) + mockAppModule2 := mocks.NewMockEndBlockAppModule(mockCtrl) mockAppModule1.EXPECT().Name().Times(2).Return("module1") mockAppModule2.EXPECT().Name().Times(2).Return("module2") mm := module.NewManager(mockAppModule1, mockAppModule2) diff --git a/x/gov/migrations/v3/store_test.go b/x/gov/migrations/v3/store_test.go index ce5448cbca..eaac29d72e 100644 --- a/x/gov/migrations/v3/store_test.go +++ b/x/gov/migrations/v3/store_test.go @@ -10,7 +10,7 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" "github.com/cosmos/cosmos-sdk/x/gov" - v1gov "github.com/cosmos/cosmos-sdk/x/gov/migrations/v1" + v1gov "github.com/cosmos/cosmos-sdk/x/gov/migrations/v1" v3gov "github.com/cosmos/cosmos-sdk/x/gov/migrations/v3" v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" diff --git a/x/group/keeper/genesis_test.go b/x/group/keeper/genesis_test.go index 25c1323f7b..557b94838e 100644 --- a/x/group/keeper/genesis_test.go +++ b/x/group/keeper/genesis_test.go @@ -6,31 +6,32 @@ import ( "testing" "time" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/suite" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + "github.com/tendermint/tendermint/libs/log" + "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/codec" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" - "github.com/cosmos/cosmos-sdk/runtime" - simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" + "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" "github.com/cosmos/cosmos-sdk/x/group" "github.com/cosmos/cosmos-sdk/x/group/keeper" - "github.com/cosmos/cosmos-sdk/x/group/testutil" + "github.com/cosmos/cosmos-sdk/x/group/module" + grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil" ) type GenesisTestSuite struct { suite.Suite - app *runtime.App - ctx context.Context - sdkCtx sdk.Context - keeper keeper.Keeper - cdc *codec.ProtoCodec - interfaceRegistry codectypes.InterfaceRegistry + ctx context.Context + sdkCtx sdk.Context + keeper keeper.Keeper + cdc *codec.ProtoCodec } func TestGenesisTestSuite(t *testing.T) { @@ -44,18 +45,30 @@ var ( memberAddr = sdk.AccAddress(memberPub.Address()) ) -func (s *GenesisTestSuite) SetupSuite() { - app, err := simtestutil.SetupAtGenesis( - testutil.AppConfig, - &s.interfaceRegistry, - &s.keeper, - ) - s.Require().NoError(err) +func (s *GenesisTestSuite) SetupTest() { + key := sdk.NewKVStoreKey(group.StoreKey) + testCtx := testutil.DefaultContextWithDB(s.T(), key, sdk.NewTransientStoreKey("transient_test")) + encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{}) - s.app = app - s.sdkCtx = app.BaseApp.NewUncachedContext(false, tmproto.Header{}) - s.cdc = codec.NewProtoCodec(s.interfaceRegistry) + ctrl := gomock.NewController(s.T()) + accountKeeper := grouptestutil.NewMockAccountKeeper(ctrl) + accountKeeper.EXPECT().GetAccount(gomock.Any(), accAddr).Return(authtypes.NewBaseAccountWithAddress(accAddr)).AnyTimes() + accountKeeper.EXPECT().GetAccount(gomock.Any(), memberAddr).Return(authtypes.NewBaseAccountWithAddress(memberAddr)).AnyTimes() + + bApp := baseapp.NewBaseApp( + "group", + log.NewNopLogger(), + testCtx.DB, + encCfg.TxConfig.TxDecoder(), + ) + + banktypes.RegisterInterfaces(encCfg.InterfaceRegistry) + + s.sdkCtx = testCtx.Ctx + s.cdc = codec.NewProtoCodec(encCfg.InterfaceRegistry) s.ctx = sdk.WrapSDKContext(s.sdkCtx) + + s.keeper = keeper.NewKeeper(key, s.cdc, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig()) } func (s *GenesisTestSuite) TestInitExportGenesis() { diff --git a/x/group/keeper/grpc_query_test.go b/x/group/keeper/grpc_query_test.go index eb24ea59be..b9b7d4461f 100644 --- a/x/group/keeper/grpc_query_test.go +++ b/x/group/keeper/grpc_query_test.go @@ -8,45 +8,63 @@ import ( codectypes "github.com/cosmos/cosmos-sdk/codec/types" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" sdk "github.com/cosmos/cosmos-sdk/types" - bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" "github.com/cosmos/cosmos-sdk/x/group" groupkeeper "github.com/cosmos/cosmos-sdk/x/group/keeper" - "github.com/cosmos/cosmos-sdk/x/group/testutil" - stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + "github.com/cosmos/cosmos-sdk/x/group/module" + "github.com/golang/mock/gomock" + "github.com/tendermint/tendermint/libs/log" + + grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil" + "github.com/stretchr/testify/require" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + + "github.com/cosmos/cosmos-sdk/testutil" ) func TestQueryGroupsByMember(t *testing.T) { var ( - bankKeeper bankkeeper.Keeper groupKeeper groupkeeper.Keeper - stakingKeeper *stakingkeeper.Keeper interfaceRegistry codectypes.InterfaceRegistry ) - app, err := simtestutil.Setup( - testutil.AppConfig, - &interfaceRegistry, - &bankKeeper, - &groupKeeper, - &stakingKeeper, - ) - require.NoError(t, err) - ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry) - group.RegisterQueryServer(queryHelper, groupKeeper) - queryClient := group.NewQueryClient(queryHelper) + key := sdk.NewKVStoreKey(group.StoreKey) + testCtx := testutil.DefaultContextWithDB(t, key, sdk.NewTransientStoreKey("transient_test")) + encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{}) + + ctx := testCtx.Ctx + sdkCtx := sdk.WrapSDKContext(ctx) - addrs := simtestutil.AddTestAddrsIncremental(bankKeeper, stakingKeeper, ctx, 6, sdk.NewInt(30000000)) + bApp := baseapp.NewBaseApp( + "group", + log.NewNopLogger(), + testCtx.DB, + encCfg.TxConfig.TxDecoder(), + ) + + banktypes.RegisterInterfaces(encCfg.InterfaceRegistry) + + addrs := simtestutil.CreateIncrementalAccounts(6) + ctrl := gomock.NewController(t) + accountKeeper := grouptestutil.NewMockAccountKeeper(ctrl) + accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[0]).Return(authtypes.NewBaseAccountWithAddress(addrs[0])).AnyTimes() + accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[1]).Return(authtypes.NewBaseAccountWithAddress(addrs[1])).AnyTimes() + accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[2]).Return(authtypes.NewBaseAccountWithAddress(addrs[2])).AnyTimes() + accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[3]).Return(authtypes.NewBaseAccountWithAddress(addrs[3])).AnyTimes() + accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[4]).Return(authtypes.NewBaseAccountWithAddress(addrs[4])).AnyTimes() + accountKeeper.EXPECT().GetAccount(gomock.Any(), addrs[5]).Return(authtypes.NewBaseAccountWithAddress(addrs[5])).AnyTimes() + + groupKeeper = groupkeeper.NewKeeper(key, encCfg.Codec, bApp.MsgServiceRouter(), accountKeeper, group.DefaultConfig()) // Initial group, group policy and balance setup members := []group.MemberRequest{ {Address: addrs[2].String(), Weight: "1"}, {Address: addrs[3].String(), Weight: "2"}, } - _, err = groupKeeper.CreateGroup(sdkCtx, &group.MsgCreateGroup{ + _, err := groupKeeper.CreateGroup(sdkCtx, &group.MsgCreateGroup{ Admin: addrs[0].String(), Members: members, }) @@ -61,6 +79,10 @@ func TestQueryGroupsByMember(t *testing.T) { }) require.NoError(t, err) + queryHelper := baseapp.NewQueryServerTestHelper(ctx, interfaceRegistry) + group.RegisterQueryServer(queryHelper, groupKeeper) + queryClient := group.NewQueryClient(queryHelper) + // not part of any group resp, err := queryClient.GroupsByMember(context.Background(), &group.QueryGroupsByMemberRequest{ Address: addrs[5].String(), diff --git a/x/group/keeper/keeper.go b/x/group/keeper/keeper.go index d7ea4157ef..234a0ba359 100644 --- a/x/group/keeper/keeper.go +++ b/x/group/keeper/keeper.go @@ -223,6 +223,11 @@ func (k Keeper) GetGroupSequence(ctx sdk.Context) uint64 { return k.groupTable.Sequence().CurVal(ctx.KVStore(k.key)) } +// GetGroupPolicySeq returns the current value of the group policy table sequence +func (k Keeper) GetGroupPolicySeq(ctx sdk.Context) uint64 { + return k.groupPolicySeq.CurVal(ctx.KVStore(k.key)) +} + // proposalsByVPEnd returns all proposals whose voting_period_end is after the `endTime` time argument. func (k Keeper) proposalsByVPEnd(ctx sdk.Context, endTime time.Time) (proposals []group.Proposal, err error) { timeBytes := sdk.FormatTimeBytes(endTime) diff --git a/x/group/keeper/keeper_test.go b/x/group/keeper/keeper_test.go index d3fe68a249..a673900837 100644 --- a/x/group/keeper/keeper_test.go +++ b/x/group/keeper/keeper_test.go @@ -3,71 +3,91 @@ package keeper_test import ( "bytes" "context" + "encoding/binary" + "fmt" "sort" "strings" "testing" "time" + "github.com/golang/mock/gomock" "github.com/stretchr/testify/suite" - tmproto "github.com/tendermint/tendermint/proto/tendermint/types" + "github.com/tendermint/tendermint/libs/log" tmtime "github.com/tendermint/tendermint/types/time" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" - "github.com/cosmos/cosmos-sdk/runtime" + "github.com/cosmos/cosmos-sdk/baseapp" + "github.com/cosmos/cosmos-sdk/testutil" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" "github.com/cosmos/cosmos-sdk/testutil/testdata" sdk "github.com/cosmos/cosmos-sdk/types" - bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper" - "github.com/cosmos/cosmos-sdk/x/bank/testutil" + "github.com/cosmos/cosmos-sdk/types/address" + moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil" + authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + "github.com/cosmos/cosmos-sdk/x/bank" banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" "github.com/cosmos/cosmos-sdk/x/group" "github.com/cosmos/cosmos-sdk/x/group/internal/math" "github.com/cosmos/cosmos-sdk/x/group/keeper" "github.com/cosmos/cosmos-sdk/x/group/module" grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil" - stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" + minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" ) type TestSuite struct { suite.Suite - app *runtime.App - sdkCtx sdk.Context - ctx context.Context - addrs []sdk.AccAddress - groupID uint64 - groupPolicyAddr sdk.AccAddress - policy group.DecisionPolicy - groupKeeper keeper.Keeper - blockTime time.Time - bankKeeper bankkeeper.Keeper - stakingKeeper *stakingkeeper.Keeper - interfaceRegistry codectypes.InterfaceRegistry + sdkCtx sdk.Context + ctx context.Context + addrs []sdk.AccAddress + groupID uint64 + groupPolicyAddr sdk.AccAddress + policy group.DecisionPolicy + groupKeeper keeper.Keeper + blockTime time.Time + bankKeeper *grouptestutil.MockBankKeeper + accountKeeper *grouptestutil.MockAccountKeeper } func (s *TestSuite) SetupTest() { - app, err := simtestutil.Setup( - grouptestutil.AppConfig, - &s.interfaceRegistry, - &s.bankKeeper, - &s.stakingKeeper, - &s.groupKeeper, - ) - s.Require().NoError(err) - ctx := app.BaseApp.NewContext(false, tmproto.Header{}) - s.blockTime = tmtime.Now() - ctx = ctx.WithBlockHeader(tmproto.Header{Time: s.blockTime}) + key := sdk.NewKVStoreKey(group.StoreKey) - s.app = app - s.sdkCtx = ctx - s.ctx = sdk.WrapSDKContext(ctx) - s.addrs = simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, ctx, 6, sdk.NewInt(30000000)) + testCtx := testutil.DefaultContextWithDB(s.T(), key, sdk.NewTransientStoreKey("transient_test")) + encCfg := moduletestutil.MakeTestEncodingConfig(module.AppModuleBasic{}, bank.AppModuleBasic{}) + s.addrs = simtestutil.CreateIncrementalAccounts(6) + + // setup gomock and initialize some globally expected executions + ctrl := gomock.NewController(s.T()) + s.accountKeeper = grouptestutil.NewMockAccountKeeper(ctrl) + s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[0]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[0])).AnyTimes() + s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[1]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[1])).AnyTimes() + s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[2]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[2])).AnyTimes() + s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[3]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[3])).AnyTimes() + s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[4]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[4])).AnyTimes() + s.accountKeeper.EXPECT().GetAccount(gomock.Any(), s.addrs[5]).Return(authtypes.NewBaseAccountWithAddress(s.addrs[5])).AnyTimes() + s.bankKeeper = grouptestutil.NewMockBankKeeper(ctrl) + + bApp := baseapp.NewBaseApp( + "group", + log.NewNopLogger(), + testCtx.DB, + encCfg.TxConfig.TxDecoder(), + ) + bApp.SetInterfaceRegistry(encCfg.InterfaceRegistry) + banktypes.RegisterMsgServer(bApp.MsgServiceRouter(), s.bankKeeper) + + config := group.DefaultConfig() + s.groupKeeper = keeper.NewKeeper(key, encCfg.Codec, bApp.MsgServiceRouter(), s.accountKeeper, config) + s.ctx = testCtx.Ctx.WithBlockTime(s.blockTime) + s.sdkCtx = sdk.UnwrapSDKContext(s.ctx) // Initial group, group policy and balance setup members := []group.MemberRequest{ {Address: s.addrs[4].String(), Weight: "1"}, {Address: s.addrs[1].String(), Weight: "2"}, } + + s.setNextAccount() + groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{ Admin: s.addrs[0].String(), Members: members, @@ -86,13 +106,42 @@ func (s *TestSuite) SetupTest() { } err = policyReq.SetDecisionPolicy(policy) s.Require().NoError(err) + s.setNextAccount() + policyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq) s.Require().NoError(err) s.policy = policy addr, err := sdk.AccAddressFromBech32(policyRes.Address) s.Require().NoError(err) s.groupPolicyAddr = addr - s.Require().NoError(testutil.FundAccount(s.bankKeeper, s.sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)})) + + s.bankKeeper.EXPECT().MintCoins(s.sdkCtx, minttypes.ModuleName, sdk.Coins{sdk.NewInt64Coin("test", 100000)}).Return(nil).AnyTimes() + s.bankKeeper.MintCoins(s.sdkCtx, minttypes.ModuleName, sdk.Coins{sdk.NewInt64Coin("test", 100000)}) + s.bankKeeper.EXPECT().SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}).Return(nil).AnyTimes() + s.bankKeeper.SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)}) +} + +func (s TestSuite) setNextAccount() { + nextAccVal := s.groupKeeper.GetGroupPolicySeq(s.sdkCtx) + 1 + buf := make([]byte, 8) + binary.BigEndian.PutUint64(buf, nextAccVal) + + var accountAddr sdk.AccAddress + parentAcc := address.Module(group.ModuleName, []byte{keeper.GroupPolicyTablePrefix}) + accountAddr = address.Derive(parentAcc, buf) + s.accountKeeper.EXPECT().GetAccount(gomock.Any(), accountAddr).Return(nil).AnyTimes() + s.accountKeeper.EXPECT().NewAccount(gomock.Any(), &authtypes.ModuleAccount{ + BaseAccount: &authtypes.BaseAccount{ + Address: accountAddr.String(), + }, + Name: accountAddr.String(), + }).Return(authtypes.NewModuleAccount(authtypes.NewBaseAccountWithAddress(accountAddr), accountAddr.String())).AnyTimes() + s.accountKeeper.EXPECT().SetAccount(gomock.Any(), &authtypes.ModuleAccount{ + BaseAccount: &authtypes.BaseAccount{ + Address: accountAddr.String(), + }, + Name: accountAddr.String(), + }).Return().AnyTimes() } func TestKeeperTestSuite(t *testing.T) { @@ -107,7 +156,7 @@ func (s *TestSuite) TestCreateGroupWithLotsOfMembers() { } func (s *TestSuite) createGroupAndGetMembers(numMembers int) []*group.GroupMember { - addressPool := simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, s.sdkCtx, numMembers, sdk.NewInt(30000000)) + addressPool := simtestutil.CreateIncrementalAccounts(numMembers) members := make([]group.MemberRequest, numMembers) for i := 0; i < len(members); i++ { members[i] = group.MemberRequest{ @@ -722,6 +771,8 @@ func (s *TestSuite) TestCreateGroupWithPolicy() { addr5 := addrs[4] addr6 := addrs[5] + s.setNextAccount() + members := []group.MemberRequest{{ Address: addr5.String(), Weight: "1", @@ -733,6 +784,7 @@ func (s *TestSuite) TestCreateGroupWithPolicy() { specs := map[string]struct { req *group.MsgCreateGroupWithPolicy policy group.DecisionPolicy + malleate func() expErr bool expErrMsg string }{ @@ -742,6 +794,9 @@ func (s *TestSuite) TestCreateGroupWithPolicy() { Members: members, GroupPolicyAsAdmin: false, }, + malleate: func() { + s.setNextAccount() + }, policy: group.NewThresholdDecisionPolicy( "1", time.Second, @@ -754,6 +809,9 @@ func (s *TestSuite) TestCreateGroupWithPolicy() { Members: members, GroupPolicyAsAdmin: true, }, + malleate: func() { + s.setNextAccount() + }, policy: group.NewThresholdDecisionPolicy( "1", time.Second, @@ -831,6 +889,9 @@ func (s *TestSuite) TestCreateGroupWithPolicy() { Members: members, GroupPolicyAsAdmin: false, }, + malleate: func() { + s.setNextAccount() + }, policy: group.NewThresholdDecisionPolicy( "10", time.Second, @@ -843,6 +904,7 @@ func (s *TestSuite) TestCreateGroupWithPolicy() { for msg, spec := range specs { spec := spec s.Run(msg, func() { + s.setNextAccount() err := spec.req.SetDecisionPolicy(spec.policy) s.Require().NoError(err) @@ -916,6 +978,7 @@ func (s *TestSuite) TestCreateGroupPolicy() { addr1 := addrs[0] addr4 := addrs[3] + s.setNextAccount() groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{ Admin: addr1.String(), Members: nil, @@ -1035,6 +1098,8 @@ func (s *TestSuite) TestCreateGroupPolicy() { err := spec.req.SetDecisionPolicy(spec.policy) s.Require().NoError(err) + s.setNextAccount() + res, err := s.groupKeeper.CreateGroupPolicy(s.ctx, spec.req) if spec.expErr { s.Require().Error(err) @@ -1080,6 +1145,7 @@ func (s *TestSuite) TestUpdateGroupPolicyAdmin() { time.Second, 0, ) + s.setNextAccount() groupPolicyAddr, myGroupID := s.createGroupAndGroupPolicy(admin, nil, policy) specs := map[string]struct { @@ -1168,6 +1234,8 @@ func (s *TestSuite) TestUpdateGroupPolicyMetadata() { time.Second, 0, ) + + s.setNextAccount() groupPolicyAddr, myGroupID := s.createGroupAndGroupPolicy(admin, nil, policy) specs := map[string]struct { @@ -1247,6 +1315,8 @@ func (s *TestSuite) TestUpdateGroupPolicyDecisionPolicy() { time.Second, 0, ) + + s.setNextAccount() groupPolicyAddr, myGroupID := s.createGroupAndGroupPolicy(admin, nil, policy) specs := map[string]struct { @@ -1296,6 +1366,7 @@ func (s *TestSuite) TestUpdateGroupPolicyDecisionPolicy() { }, "correct data with percentage decision policy": { preRun: func(admin sdk.AccAddress) (string, uint64) { + s.setNextAccount() return s.createGroupAndGroupPolicy(admin, nil, policy) }, req: &group.MsgUpdateGroupPolicyDecisionPolicy{ @@ -1357,6 +1428,7 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() { addr2 := addrs[1] admin := addr2 + groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{ Admin: admin.String(), Members: nil, @@ -1391,6 +1463,8 @@ func (s *TestSuite) TestGroupPoliciesByAdminOrGroup() { } err := req.SetDecisionPolicy(policies[i]) s.Require().NoError(err) + + s.setNextAccount() res, err := s.groupKeeper.CreateGroupPolicy(s.ctx, req) s.Require().NoError(err) @@ -1481,6 +1555,8 @@ func (s *TestSuite) TestSubmitProposal() { ) err := policyReq.SetDecisionPolicy(policy) s.Require().NoError(err) + + s.setNextAccount() bigThresholdRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq) s.Require().NoError(err) bigThresholdAddr := bigThresholdRes.Address @@ -1502,6 +1578,7 @@ func (s *TestSuite) TestSubmitProposal() { expProposal group.Proposal expErr bool postRun func(sdkCtx sdk.Context) + preRun func(msg []sdk.Msg) }{ "all good with minimal fields set": { req: &group.MsgSubmitProposal{ @@ -1596,6 +1673,11 @@ func (s *TestSuite) TestSubmitProposal() { postRun: func(sdkCtx sdk.Context) {}, }, "with try exec": { + preRun: func(msgs []sdk.Msg) { + for i := 0; i < len(msgs); i++ { + s.bankKeeper.EXPECT().Send(gomock.Any(), msgs[i]).Return(nil, nil) + } + }, req: &group.MsgSubmitProposal{ GroupPolicyAddress: accountAddr.String(), Proposers: []string{addr2.String()}, @@ -1614,6 +1696,9 @@ func (s *TestSuite) TestSubmitProposal() { ExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_SUCCESS, }, postRun: func(sdkCtx sdk.Context) { + s.bankKeeper.EXPECT().GetAllBalances(sdkCtx, accountAddr).Return(sdk.NewCoins(sdk.NewInt64Coin("test", 9900))) + s.bankKeeper.EXPECT().GetAllBalances(sdkCtx, addr2).Return(sdk.NewCoins(sdk.NewInt64Coin("test", 100))) + fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, accountAddr) s.Require().Contains(fromBalances, sdk.NewInt64Coin("test", 9900)) toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr2) @@ -1647,6 +1732,10 @@ func (s *TestSuite) TestSubmitProposal() { err := spec.req.SetMsgs(spec.msgs) s.Require().NoError(err) + if spec.preRun != nil { + spec.preRun(spec.msgs) + } + res, err := s.groupKeeper.SubmitProposal(s.ctx, spec.req) if spec.expErr { s.Require().Error(err) @@ -1784,6 +1873,7 @@ func (s *TestSuite) TestVote() { {Address: addr4.String(), Weight: "1"}, {Address: addr3.String(), Weight: "2"}, } + groupRes, err := s.groupKeeper.CreateGroup(s.ctx, &group.MsgCreateGroup{ Admin: addr1.String(), Members: members, @@ -1802,6 +1892,8 @@ func (s *TestSuite) TestVote() { } err = policyReq.SetDecisionPolicy(policy) s.Require().NoError(err) + + s.setNextAccount() policyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq) s.Require().NoError(err) accountAddr := policyRes.Address @@ -1809,18 +1901,20 @@ func (s *TestSuite) TestVote() { s.Require().NoError(err) s.Require().NotNil(groupPolicy) - s.Require().NoError(testutil.FundAccount(s.bankKeeper, s.sdkCtx, groupPolicy, sdk.Coins{sdk.NewInt64Coin("test", 10000)})) + s.bankKeeper.EXPECT().SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, groupPolicy, sdk.Coins{sdk.NewInt64Coin("test", 10000)}).Return(nil).AnyTimes() + s.Require().NoError(s.bankKeeper.SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, groupPolicy, sdk.Coins{sdk.NewInt64Coin("test", 10000)})) req := &group.MsgSubmitProposal{ GroupPolicyAddress: accountAddr, Proposers: []string{addr4.String()}, Messages: nil, } - err = req.SetMsgs([]sdk.Msg{&banktypes.MsgSend{ + msg := &banktypes.MsgSend{ FromAddress: accountAddr, ToAddress: addr5.String(), Amount: sdk.Coins{sdk.NewInt64Coin("test", 100)}, - }}) + } + err = req.SetMsgs([]sdk.Msg{msg}) s.Require().NoError(err) proposalRes, err := s.groupKeeper.SubmitProposal(s.ctx, req) @@ -1886,7 +1980,13 @@ func (s *TestSuite) TestVote() { isFinal: true, expProposalStatus: group.PROPOSAL_STATUS_ACCEPTED, expExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_SUCCESS, + doBefore: func(ctx context.Context) { + s.bankKeeper.EXPECT().Send(gomock.Any(), msg).Return(nil, nil) + }, postRun: func(sdkCtx sdk.Context) { + s.bankKeeper.EXPECT().GetAllBalances(gomock.Any(), groupPolicy).Return(sdk.NewCoins(sdk.NewInt64Coin("test", 9900))) + s.bankKeeper.EXPECT().GetAllBalances(gomock.Any(), addr5).Return(sdk.NewCoins(sdk.NewInt64Coin("test", 100))) + fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, groupPolicy) s.Require().Contains(fromBalances, sdk.NewInt64Coin("test", 9900)) toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr5) @@ -2063,6 +2163,8 @@ func (s *TestSuite) TestVote() { Option: group.VOTE_OPTION_NO, }, doBefore: func(ctx context.Context) { + s.bankKeeper.EXPECT().Send(gomock.Any(), msg).Return(nil, nil) + _, err := s.groupKeeper.Vote(ctx, &group.MsgVote{ ProposalId: myProposalID, Voter: addr3.String(), @@ -2112,8 +2214,6 @@ func (s *TestSuite) TestVote() { } s.Require().NoError(err) - s.Require().NoError(err) - if !(spec.expExecutorResult == group.PROPOSAL_EXECUTOR_RESULT_SUCCESS) { // vote is stored and all data persisted res, err := s.groupKeeper.VoteByProposalVoter(ctx, &group.QueryVoteByProposalVoterRequest{ @@ -2200,6 +2300,8 @@ func (s *TestSuite) TestVote() { 0, ) require.NoError(reqCreate.SetDecisionPolicy(policy)) + s.setNextAccount() + result, err := s.groupKeeper.CreateGroupWithPolicy(s.ctx, reqCreate) require.NoError(err) require.NotNil(result) @@ -2273,6 +2375,7 @@ func (s *TestSuite) TestExecProposal() { }{ "proposal executed when accepted": { setupProposal: func(ctx context.Context) uint64 { + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil) msgs := []sdk.Msg{msgSend1} return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES) }, @@ -2285,6 +2388,8 @@ func (s *TestSuite) TestExecProposal() { "proposal with multiple messages executed when accepted": { setupProposal: func(ctx context.Context) uint64 { msgs := []sdk.Msg{msgSend1, msgSend1} + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil).MaxTimes(2) + return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES) }, expProposalStatus: group.PROPOSAL_STATUS_ACCEPTED, @@ -2335,6 +2440,7 @@ func (s *TestSuite) TestExecProposal() { "prevent double execution when successful": { setupProposal: func(ctx context.Context) uint64 { myProposalID := submitProposalAndVote(ctx, s, []sdk.Msg{msgSend1}, proposers, group.VOTE_OPTION_YES) + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil) _, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID}) s.Require().NoError(err) @@ -2350,6 +2456,9 @@ func (s *TestSuite) TestExecProposal() { "rollback all msg updates on failure": { setupProposal: func(ctx context.Context) uint64 { msgs := []sdk.Msg{msgSend1, msgSend2} + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil) + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, fmt.Errorf("error")) + return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES) }, expProposalStatus: group.PROPOSAL_STATUS_ACCEPTED, @@ -2360,10 +2469,12 @@ func (s *TestSuite) TestExecProposal() { msgs := []sdk.Msg{msgSend2} myProposalID := submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES) + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, fmt.Errorf("error")) _, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID}) + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, nil) + s.Require().NoError(err) - sdkCtx := sdk.UnwrapSDKContext(ctx) - s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)})) + s.Require().NoError(s.bankKeeper.SendCoinsFromModuleToAccount(s.sdkCtx, minttypes.ModuleName, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10000)})) return myProposalID }, @@ -2407,6 +2518,9 @@ func (s *TestSuite) TestExecProposal() { } if spec.expBalance { + s.bankKeeper.EXPECT().GetAllBalances(sdkCtx, s.groupPolicyAddr).Return(sdk.Coins{spec.expFromBalances}) + s.bankKeeper.EXPECT().GetAllBalances(sdkCtx, addr2).Return(sdk.Coins{spec.expToBalances}) + fromBalances := s.bankKeeper.GetAllBalances(sdkCtx, s.groupPolicyAddr) s.Require().Contains(fromBalances, spec.expFromBalances) toBalances := s.bankKeeper.GetAllBalances(sdkCtx, addr2) @@ -2421,16 +2535,6 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() { addr1 := addrs[0] addr2 := addrs[1] - msgSend1 := &banktypes.MsgSend{ - FromAddress: s.groupPolicyAddr.String(), - ToAddress: addr2.String(), - Amount: sdk.Coins{sdk.NewInt64Coin("test", 100)}, - } - msgSend2 := &banktypes.MsgSend{ - FromAddress: s.groupPolicyAddr.String(), - ToAddress: addr2.String(), - Amount: sdk.Coins{sdk.NewInt64Coin("test", 10001)}, - } proposers := []string{addr2.String()} specs := map[string]struct { srcBlockTime time.Time @@ -2441,7 +2545,13 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() { }{ "proposal pruned after executor result success": { setupProposal: func(ctx context.Context) uint64 { + msgSend1 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 101)}, + } msgs := []sdk.Msg{msgSend1} + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil) return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES) }, expErrMsg: "load proposal: not found", @@ -2449,6 +2559,13 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() { }, "proposal with multiple messages pruned when executed with result success": { setupProposal: func(ctx context.Context) uint64 { + msgSend1 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 102)}, + } + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, nil).MaxTimes(2) + msgs := []sdk.Msg{msgSend1, msgSend1} return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES) }, @@ -2457,6 +2574,11 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() { }, "proposal not pruned when not executed and rejected": { setupProposal: func(ctx context.Context) uint64 { + msgSend1 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 103)}, + } msgs := []sdk.Msg{msgSend1} return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_NO) }, @@ -2464,12 +2586,22 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() { }, "open proposal is not pruned which must not fail ": { setupProposal: func(ctx context.Context) uint64 { + msgSend1 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 104)}, + } return submitProposal(ctx, s, []sdk.Msg{msgSend1}, proposers) }, expExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_NOT_RUN, }, "proposal not pruned with group modified before tally": { setupProposal: func(ctx context.Context) uint64 { + msgSend1 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 105)}, + } myProposalID := submitProposal(ctx, s, []sdk.Msg{msgSend1}, proposers) // then modify group @@ -2484,6 +2616,12 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() { }, "proposal not pruned with group policy modified before tally": { setupProposal: func(ctx context.Context) uint64 { + msgSend1 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 106)}, + } + myProposalID := submitProposal(ctx, s, []sdk.Msg{msgSend1}, proposers) _, err := s.groupKeeper.UpdateGroupPolicyMetadata(ctx, &group.MsgUpdateGroupPolicyMetadata{ Admin: addr1.String(), @@ -2498,21 +2636,43 @@ func (s *TestSuite) TestExecPrunedProposalsAndVotes() { }, "proposal exists when rollback all msg updates on failure": { setupProposal: func(ctx context.Context) uint64 { + msgSend1 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 107)}, + } + + msgSend2 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 10002)}, + } + msgs := []sdk.Msg{msgSend1, msgSend2} + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend1).Return(nil, fmt.Errorf("error")) + return submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES) }, expExecutorResult: group.PROPOSAL_EXECUTOR_RESULT_FAILURE, }, "pruned when proposal is executable when failed before": { setupProposal: func(ctx context.Context) uint64 { + msgSend2 := &banktypes.MsgSend{ + FromAddress: s.groupPolicyAddr.String(), + ToAddress: addr2.String(), + Amount: sdk.Coins{sdk.NewInt64Coin("test", 10003)}, + } + msgs := []sdk.Msg{msgSend2} + myProposalID := submitProposalAndVote(ctx, s, msgs, proposers, group.VOTE_OPTION_YES) - _, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID}) - s.Require().NoError(err) - sdkCtx := sdk.UnwrapSDKContext(ctx) - s.Require().NoError(testutil.FundAccount(s.bankKeeper, sdkCtx, s.groupPolicyAddr, sdk.Coins{sdk.NewInt64Coin("test", 10002)})) + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, fmt.Errorf("error")) + _, err := s.groupKeeper.Exec(ctx, &group.MsgExec{Executor: addr1.String(), ProposalId: myProposalID}) + s.bankKeeper.EXPECT().Send(gomock.Any(), msgSend2).Return(nil, nil) + + s.Require().NoError(err) return myProposalID }, expErrMsg: "load proposal: not found", @@ -2702,7 +2862,7 @@ func (s *TestSuite) TestProposalsByVPEnd() { } func (s *TestSuite) TestLeaveGroup() { - addrs := simtestutil.AddTestAddrsIncremental(s.bankKeeper, s.stakingKeeper, s.sdkCtx, 7, sdk.NewInt(30000000)) + addrs := simtestutil.CreateIncrementalAccounts(7) admin1 := addrs[0] member1 := addrs[1] @@ -2735,6 +2895,7 @@ func (s *TestSuite) TestLeaveGroup() { time.Hour, time.Hour, ) + s.setNextAccount() _, groupID1 := s.createGroupAndGroupPolicy(admin1, members, policy) members = []group.MemberRequest{ @@ -2744,6 +2905,8 @@ func (s *TestSuite) TestLeaveGroup() { Metadata: "metadata", }, } + + s.setNextAccount() _, groupID2 := s.createGroupAndGroupPolicy(admin2, members, nil) members = []group.MemberRequest{ @@ -2763,6 +2926,8 @@ func (s *TestSuite) TestLeaveGroup() { Windows: &group.DecisionPolicyWindows{VotingPeriod: time.Hour}, } + s.setNextAccount() + _, groupID3 := s.createGroupAndGroupPolicy(admin3, members, policy) testCases := []struct { name string @@ -2896,6 +3061,9 @@ func (s *TestSuite) TestPruneProposals() { policy := group.NewThresholdDecisionPolicy("100", time.Microsecond, time.Microsecond) err := policyReq.SetDecisionPolicy(policy) s.Require().NoError(err) + + s.setNextAccount() + _, err = s.groupKeeper.CreateGroupPolicy(s.ctx, policyReq) s.Require().NoError(err) @@ -2976,6 +3144,8 @@ func (s *TestSuite) createGroupAndGroupPolicy( err = groupPolicy.SetDecisionPolicy(policy) s.Require().NoError(err) + s.setNextAccount() + groupPolicyRes, err := s.groupKeeper.CreateGroupPolicy(s.ctx, groupPolicy) s.Require().NoError(err) policyAddr = groupPolicyRes.Address diff --git a/x/group/simulation/operations_test.go b/x/group/simulation/operations_test.go index 914585e823..03aad72057 100644 --- a/x/group/simulation/operations_test.go +++ b/x/group/simulation/operations_test.go @@ -23,7 +23,6 @@ import ( groupkeeper "github.com/cosmos/cosmos-sdk/x/group/keeper" "github.com/cosmos/cosmos-sdk/x/group/simulation" grouptestutil "github.com/cosmos/cosmos-sdk/x/group/testutil" - stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper" ) type SimTestSuite struct { @@ -35,7 +34,6 @@ type SimTestSuite struct { interfaceRegistry codectypes.InterfaceRegistry accountKeeper authkeeper.AccountKeeper bankKeeper bankkeeper.Keeper - stakingKeeper *stakingkeeper.Keeper groupKeeper groupkeeper.Keeper } @@ -46,7 +44,6 @@ func (suite *SimTestSuite) SetupTest() { &suite.interfaceRegistry, &suite.accountKeeper, &suite.bankKeeper, - &suite.stakingKeeper, &suite.groupKeeper, ) suite.Require().NoError(err) diff --git a/x/group/testutil/expected_keepers.go b/x/group/testutil/expected_keepers.go new file mode 100644 index 0000000000..bec2cba833 --- /dev/null +++ b/x/group/testutil/expected_keepers.go @@ -0,0 +1,25 @@ +// This file only used to generate mocks + +package testutil + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + bank "github.com/cosmos/cosmos-sdk/x/bank/types" + "github.com/cosmos/cosmos-sdk/x/group" +) + +// extends `AccountKeeper` from expected_keepers. +type AccountKeeper interface { + group.AccountKeeper +} + +// extends `BankKeeper` from expected_keepers. +// extends bank `MsgServer` to mock `Send` and to register handlers in MsgServiceRouter +type BankKeeper interface { + group.BankKeeper + bank.MsgServer + + MintCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error + SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error + GetAllBalances(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins +} diff --git a/x/group/testutil/expected_keepers_mocks.go b/x/group/testutil/expected_keepers_mocks.go new file mode 100644 index 0000000000..54584b0e9d --- /dev/null +++ b/x/group/testutil/expected_keepers_mocks.go @@ -0,0 +1,202 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: x/group/testutil/expected_keepers.go + +// Package testutil is a generated GoMock package. +package testutil + +import ( + context "context" + reflect "reflect" + + types "github.com/cosmos/cosmos-sdk/types" + types0 "github.com/cosmos/cosmos-sdk/x/auth/types" + types1 "github.com/cosmos/cosmos-sdk/x/bank/types" + gomock "github.com/golang/mock/gomock" +) + +// MockAccountKeeper is a mock of AccountKeeper interface. +type MockAccountKeeper struct { + ctrl *gomock.Controller + recorder *MockAccountKeeperMockRecorder +} + +// MockAccountKeeperMockRecorder is the mock recorder for MockAccountKeeper. +type MockAccountKeeperMockRecorder struct { + mock *MockAccountKeeper +} + +// NewMockAccountKeeper creates a new mock instance. +func NewMockAccountKeeper(ctrl *gomock.Controller) *MockAccountKeeper { + mock := &MockAccountKeeper{ctrl: ctrl} + mock.recorder = &MockAccountKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAccountKeeper) EXPECT() *MockAccountKeeperMockRecorder { + return m.recorder +} + +// GetAccount mocks base method. +func (m *MockAccountKeeper) GetAccount(arg0 types.Context, arg1 types.AccAddress) types0.AccountI { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccount", arg0, arg1) + ret0, _ := ret[0].(types0.AccountI) + return ret0 +} + +// GetAccount indicates an expected call of GetAccount. +func (mr *MockAccountKeeperMockRecorder) GetAccount(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).GetAccount), arg0, arg1) +} + +// NewAccount mocks base method. +func (m *MockAccountKeeper) NewAccount(arg0 types.Context, arg1 types0.AccountI) types0.AccountI { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NewAccount", arg0, arg1) + ret0, _ := ret[0].(types0.AccountI) + return ret0 +} + +// NewAccount indicates an expected call of NewAccount. +func (mr *MockAccountKeeperMockRecorder) NewAccount(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAccount", reflect.TypeOf((*MockAccountKeeper)(nil).NewAccount), arg0, arg1) +} + +// SetAccount mocks base method. +func (m *MockAccountKeeper) SetAccount(arg0 types.Context, arg1 types0.AccountI) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetAccount", arg0, arg1) +} + +// SetAccount indicates an expected call of SetAccount. +func (mr *MockAccountKeeperMockRecorder) SetAccount(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).SetAccount), arg0, arg1) +} + +// MockBankKeeper is a mock of BankKeeper interface. +type MockBankKeeper struct { + ctrl *gomock.Controller + recorder *MockBankKeeperMockRecorder +} + +// MockBankKeeperMockRecorder is the mock recorder for MockBankKeeper. +type MockBankKeeperMockRecorder struct { + mock *MockBankKeeper +} + +// NewMockBankKeeper creates a new mock instance. +func NewMockBankKeeper(ctrl *gomock.Controller) *MockBankKeeper { + mock := &MockBankKeeper{ctrl: ctrl} + mock.recorder = &MockBankKeeperMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBankKeeper) EXPECT() *MockBankKeeperMockRecorder { + return m.recorder +} + +// GetAllBalances mocks base method. +func (m *MockBankKeeper) GetAllBalances(ctx types.Context, addr types.AccAddress) types.Coins { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAllBalances", ctx, addr) + ret0, _ := ret[0].(types.Coins) + return ret0 +} + +// GetAllBalances indicates an expected call of GetAllBalances. +func (mr *MockBankKeeperMockRecorder) GetAllBalances(ctx, addr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBalances", reflect.TypeOf((*MockBankKeeper)(nil).GetAllBalances), ctx, addr) +} + +// MintCoins mocks base method. +func (m *MockBankKeeper) MintCoins(ctx types.Context, moduleName string, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MintCoins", ctx, moduleName, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// MintCoins indicates an expected call of MintCoins. +func (mr *MockBankKeeperMockRecorder) MintCoins(ctx, moduleName, amt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintCoins", reflect.TypeOf((*MockBankKeeper)(nil).MintCoins), ctx, moduleName, amt) +} + +// MultiSend mocks base method. +func (m *MockBankKeeper) MultiSend(arg0 context.Context, arg1 *types1.MsgMultiSend) (*types1.MsgMultiSendResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MultiSend", arg0, arg1) + ret0, _ := ret[0].(*types1.MsgMultiSendResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MultiSend indicates an expected call of MultiSend. +func (mr *MockBankKeeperMockRecorder) MultiSend(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MultiSend", reflect.TypeOf((*MockBankKeeper)(nil).MultiSend), arg0, arg1) +} + +// Send mocks base method. +func (m *MockBankKeeper) Send(arg0 context.Context, arg1 *types1.MsgSend) (*types1.MsgSendResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0, arg1) + ret0, _ := ret[0].(*types1.MsgSendResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Send indicates an expected call of Send. +func (mr *MockBankKeeperMockRecorder) Send(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockBankKeeper)(nil).Send), arg0, arg1) +} + +// SendCoinsFromModuleToAccount mocks base method. +func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx types.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendCoinsFromModuleToAccount indicates an expected call of SendCoinsFromModuleToAccount. +func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt) +} + +// SpendableCoins mocks base method. +func (m *MockBankKeeper) SpendableCoins(ctx types.Context, addr types.AccAddress) types.Coins { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SpendableCoins", ctx, addr) + ret0, _ := ret[0].(types.Coins) + return ret0 +} + +// SpendableCoins indicates an expected call of SpendableCoins. +func (mr *MockBankKeeperMockRecorder) SpendableCoins(ctx, addr interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpendableCoins", reflect.TypeOf((*MockBankKeeper)(nil).SpendableCoins), ctx, addr) +} + +// UpdateParams mocks base method. +func (m *MockBankKeeper) UpdateParams(arg0 context.Context, arg1 *types1.MsgUpdateParams) (*types1.MsgUpdateParamsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateParams", arg0, arg1) + ret0, _ := ret[0].(*types1.MsgUpdateParamsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateParams indicates an expected call of UpdateParams. +func (mr *MockBankKeeperMockRecorder) UpdateParams(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateParams", reflect.TypeOf((*MockBankKeeper)(nil).UpdateParams), arg0, arg1) +}