diff --git a/runtime/v2/go.sum b/runtime/v2/go.sum index 6bd06550bc..e0ba7dec6b 100644 --- a/runtime/v2/go.sum +++ b/runtime/v2/go.sum @@ -261,6 +261,8 @@ github.com/tidwall/btree v1.7.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EU github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= diff --git a/server/v2/go.sum b/server/v2/go.sum index 5450703ab5..5904ce7de9 100644 --- a/server/v2/go.sum +++ b/server/v2/go.sum @@ -323,6 +323,8 @@ github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqri github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= diff --git a/simapp/v2/go.sum b/simapp/v2/go.sum index 76a2e9ee7b..6043d71f27 100644 --- a/simapp/v2/go.sum +++ b/simapp/v2/go.sum @@ -856,6 +856,8 @@ go.opentelemetry.io/otel/trace v1.27.0/go.mod h1:6RiD1hkAprV4/q+yd2ln1HG9GoPx39S go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= diff --git a/store/v2/go.mod b/store/v2/go.mod index 134f54fcdd..d3f7762144 100644 --- a/store/v2/go.mod +++ b/store/v2/go.mod @@ -19,6 +19,7 @@ require ( github.com/spf13/cast v1.7.0 github.com/stretchr/testify v1.9.0 github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d + go.uber.org/mock v0.4.0 golang.org/x/exp v0.0.0-20231006140011-7918f672742d golang.org/x/sync v0.8.0 ) diff --git a/store/v2/go.sum b/store/v2/go.sum index 926a7a3edd..292afd6d53 100644 --- a/store/v2/go.sum +++ b/store/v2/go.sum @@ -220,6 +220,8 @@ github.com/tidwall/btree v1.7.0/go.mod h1:twD9XRA5jj9VUQGELzDO4HPQTNJsoWWfYEL+EU github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= diff --git a/store/v2/mock/db_mock.go b/store/v2/mock/db_mock.go new file mode 100644 index 0000000000..8014e48514 --- /dev/null +++ b/store/v2/mock/db_mock.go @@ -0,0 +1,406 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: ./types.go +// +// Generated by this command: +// +// mockgen -package mock -destination ./db_mock.go -source ./types.go +// + +// Package mock is a generated GoMock package. +package mock + +import ( + reflect "reflect" + + store "cosmossdk.io/core/store" + proof "cosmossdk.io/store/v2/proof" + gomock "go.uber.org/mock/gomock" +) + +// MockStateCommitter is a mock of StateCommitter interface. +type MockStateCommitter struct { + ctrl *gomock.Controller + recorder *MockStateCommitterMockRecorder +} + +// MockStateCommitterMockRecorder is the mock recorder for MockStateCommitter. +type MockStateCommitterMockRecorder struct { + mock *MockStateCommitter +} + +// NewMockStateCommitter creates a new mock instance. +func NewMockStateCommitter(ctrl *gomock.Controller) *MockStateCommitter { + mock := &MockStateCommitter{ctrl: ctrl} + mock.recorder = &MockStateCommitterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStateCommitter) EXPECT() *MockStateCommitterMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *MockStateCommitter) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockStateCommitterMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStateCommitter)(nil).Close)) +} + +// Commit mocks base method. +func (m *MockStateCommitter) Commit(version uint64) (*proof.CommitInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Commit", version) + ret0, _ := ret[0].(*proof.CommitInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Commit indicates an expected call of Commit. +func (mr *MockStateCommitterMockRecorder) Commit(version any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockStateCommitter)(nil).Commit), version) +} + +// Get mocks base method. +func (m *MockStateCommitter) Get(storeKey []byte, version uint64, key []byte) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", storeKey, version, key) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockStateCommitterMockRecorder) Get(storeKey, version, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStateCommitter)(nil).Get), storeKey, version, key) +} + +// GetCommitInfo mocks base method. +func (m *MockStateCommitter) GetCommitInfo(version uint64) (*proof.CommitInfo, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCommitInfo", version) + ret0, _ := ret[0].(*proof.CommitInfo) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCommitInfo indicates an expected call of GetCommitInfo. +func (mr *MockStateCommitterMockRecorder) GetCommitInfo(version any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitInfo", reflect.TypeOf((*MockStateCommitter)(nil).GetCommitInfo), version) +} + +// GetLatestVersion mocks base method. +func (m *MockStateCommitter) GetLatestVersion() (uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestVersion") + ret0, _ := ret[0].(uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestVersion indicates an expected call of GetLatestVersion. +func (mr *MockStateCommitterMockRecorder) GetLatestVersion() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestVersion", reflect.TypeOf((*MockStateCommitter)(nil).GetLatestVersion)) +} + +// GetProof mocks base method. +func (m *MockStateCommitter) GetProof(storeKey []byte, version uint64, key []byte) ([]proof.CommitmentOp, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetProof", storeKey, version, key) + ret0, _ := ret[0].([]proof.CommitmentOp) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProof indicates an expected call of GetProof. +func (mr *MockStateCommitterMockRecorder) GetProof(storeKey, version, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProof", reflect.TypeOf((*MockStateCommitter)(nil).GetProof), storeKey, version, key) +} + +// LoadVersion mocks base method. +func (m *MockStateCommitter) LoadVersion(targetVersion uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadVersion", targetVersion) + ret0, _ := ret[0].(error) + return ret0 +} + +// LoadVersion indicates an expected call of LoadVersion. +func (mr *MockStateCommitterMockRecorder) LoadVersion(targetVersion any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadVersion", reflect.TypeOf((*MockStateCommitter)(nil).LoadVersion), targetVersion) +} + +// LoadVersionAndUpgrade mocks base method. +func (m *MockStateCommitter) LoadVersionAndUpgrade(version uint64, upgrades *store.StoreUpgrades) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LoadVersionAndUpgrade", version, upgrades) + ret0, _ := ret[0].(error) + return ret0 +} + +// LoadVersionAndUpgrade indicates an expected call of LoadVersionAndUpgrade. +func (mr *MockStateCommitterMockRecorder) LoadVersionAndUpgrade(version, upgrades any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LoadVersionAndUpgrade", reflect.TypeOf((*MockStateCommitter)(nil).LoadVersionAndUpgrade), version, upgrades) +} + +// PausePruning mocks base method. +func (m *MockStateCommitter) PausePruning(pause bool) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "PausePruning", pause) +} + +// PausePruning indicates an expected call of PausePruning. +func (mr *MockStateCommitterMockRecorder) PausePruning(pause any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PausePruning", reflect.TypeOf((*MockStateCommitter)(nil).PausePruning), pause) +} + +// Prune mocks base method. +func (m *MockStateCommitter) Prune(version uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Prune", version) + ret0, _ := ret[0].(error) + return ret0 +} + +// Prune indicates an expected call of Prune. +func (mr *MockStateCommitterMockRecorder) Prune(version any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prune", reflect.TypeOf((*MockStateCommitter)(nil).Prune), version) +} + +// SetInitialVersion mocks base method. +func (m *MockStateCommitter) SetInitialVersion(version uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetInitialVersion", version) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetInitialVersion indicates an expected call of SetInitialVersion. +func (mr *MockStateCommitterMockRecorder) SetInitialVersion(version any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInitialVersion", reflect.TypeOf((*MockStateCommitter)(nil).SetInitialVersion), version) +} + +// WorkingCommitInfo mocks base method. +func (m *MockStateCommitter) WorkingCommitInfo(version uint64) *proof.CommitInfo { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WorkingCommitInfo", version) + ret0, _ := ret[0].(*proof.CommitInfo) + return ret0 +} + +// WorkingCommitInfo indicates an expected call of WorkingCommitInfo. +func (mr *MockStateCommitterMockRecorder) WorkingCommitInfo(version any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WorkingCommitInfo", reflect.TypeOf((*MockStateCommitter)(nil).WorkingCommitInfo), version) +} + +// WriteChangeset mocks base method. +func (m *MockStateCommitter) WriteChangeset(cs *store.Changeset) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteChangeset", cs) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteChangeset indicates an expected call of WriteChangeset. +func (mr *MockStateCommitterMockRecorder) WriteChangeset(cs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteChangeset", reflect.TypeOf((*MockStateCommitter)(nil).WriteChangeset), cs) +} + +// MockStateStorage is a mock of StateStorage interface. +type MockStateStorage struct { + ctrl *gomock.Controller + recorder *MockStateStorageMockRecorder +} + +// MockStateStorageMockRecorder is the mock recorder for MockStateStorage. +type MockStateStorageMockRecorder struct { + mock *MockStateStorage +} + +// NewMockStateStorage creates a new mock instance. +func NewMockStateStorage(ctrl *gomock.Controller) *MockStateStorage { + mock := &MockStateStorage{ctrl: ctrl} + mock.recorder = &MockStateStorageMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStateStorage) EXPECT() *MockStateStorageMockRecorder { + return m.recorder +} + +// ApplyChangeset mocks base method. +func (m *MockStateStorage) ApplyChangeset(version uint64, cs *store.Changeset) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ApplyChangeset", version, cs) + ret0, _ := ret[0].(error) + return ret0 +} + +// ApplyChangeset indicates an expected call of ApplyChangeset. +func (mr *MockStateStorageMockRecorder) ApplyChangeset(version, cs any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyChangeset", reflect.TypeOf((*MockStateStorage)(nil).ApplyChangeset), version, cs) +} + +// Close mocks base method. +func (m *MockStateStorage) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockStateStorageMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockStateStorage)(nil).Close)) +} + +// Get mocks base method. +func (m *MockStateStorage) Get(storeKey []byte, version uint64, key []byte) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", storeKey, version, key) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockStateStorageMockRecorder) Get(storeKey, version, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStateStorage)(nil).Get), storeKey, version, key) +} + +// GetLatestVersion mocks base method. +func (m *MockStateStorage) GetLatestVersion() (uint64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetLatestVersion") + ret0, _ := ret[0].(uint64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetLatestVersion indicates an expected call of GetLatestVersion. +func (mr *MockStateStorageMockRecorder) GetLatestVersion() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLatestVersion", reflect.TypeOf((*MockStateStorage)(nil).GetLatestVersion)) +} + +// Has mocks base method. +func (m *MockStateStorage) Has(storeKey []byte, version uint64, key []byte) (bool, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Has", storeKey, version, key) + ret0, _ := ret[0].(bool) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Has indicates an expected call of Has. +func (mr *MockStateStorageMockRecorder) Has(storeKey, version, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Has", reflect.TypeOf((*MockStateStorage)(nil).Has), storeKey, version, key) +} + +// Iterator mocks base method. +func (m *MockStateStorage) Iterator(storeKey []byte, version uint64, start, end []byte) (store.Iterator, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Iterator", storeKey, version, start, end) + ret0, _ := ret[0].(store.Iterator) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Iterator indicates an expected call of Iterator. +func (mr *MockStateStorageMockRecorder) Iterator(storeKey, version, start, end any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterator", reflect.TypeOf((*MockStateStorage)(nil).Iterator), storeKey, version, start, end) +} + +// PausePruning mocks base method. +func (m *MockStateStorage) PausePruning(pause bool) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "PausePruning", pause) +} + +// PausePruning indicates an expected call of PausePruning. +func (mr *MockStateStorageMockRecorder) PausePruning(pause any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PausePruning", reflect.TypeOf((*MockStateStorage)(nil).PausePruning), pause) +} + +// Prune mocks base method. +func (m *MockStateStorage) Prune(version uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Prune", version) + ret0, _ := ret[0].(error) + return ret0 +} + +// Prune indicates an expected call of Prune. +func (mr *MockStateStorageMockRecorder) Prune(version any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prune", reflect.TypeOf((*MockStateStorage)(nil).Prune), version) +} + +// PruneStoreKeys mocks base method. +func (m *MockStateStorage) PruneStoreKeys(storeKeys []string, version uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PruneStoreKeys", storeKeys, version) + ret0, _ := ret[0].(error) + return ret0 +} + +// PruneStoreKeys indicates an expected call of PruneStoreKeys. +func (mr *MockStateStorageMockRecorder) PruneStoreKeys(storeKeys, version any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PruneStoreKeys", reflect.TypeOf((*MockStateStorage)(nil).PruneStoreKeys), storeKeys, version) +} + +// ReverseIterator mocks base method. +func (m *MockStateStorage) ReverseIterator(storeKey []byte, version uint64, start, end []byte) (store.Iterator, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReverseIterator", storeKey, version, start, end) + ret0, _ := ret[0].(store.Iterator) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReverseIterator indicates an expected call of ReverseIterator. +func (mr *MockStateStorageMockRecorder) ReverseIterator(storeKey, version, start, end any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReverseIterator", reflect.TypeOf((*MockStateStorage)(nil).ReverseIterator), storeKey, version, start, end) +} + +// SetLatestVersion mocks base method. +func (m *MockStateStorage) SetLatestVersion(version uint64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetLatestVersion", version) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetLatestVersion indicates an expected call of SetLatestVersion. +func (mr *MockStateStorageMockRecorder) SetLatestVersion(version any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLatestVersion", reflect.TypeOf((*MockStateStorage)(nil).SetLatestVersion), version) +} diff --git a/store/v2/mock/mockgen.sh b/store/v2/mock/mockgen.sh new file mode 100755 index 0000000000..1b366cee20 --- /dev/null +++ b/store/v2/mock/mockgen.sh @@ -0,0 +1,4 @@ +#!/usr/bin/env bash + +mockgen_cmd="mockgen" +$mockgen_cmd -package mock -destination ./db_mock.go -source ./types.go \ No newline at end of file diff --git a/store/v2/mock/types.go b/store/v2/mock/types.go new file mode 100644 index 0000000000..95d623c839 --- /dev/null +++ b/store/v2/mock/types.go @@ -0,0 +1,19 @@ +package mock + +import "cosmossdk.io/store/v2" + +// StateCommitter is a mock of store.Committer +type StateCommitter interface { + store.Committer + store.Pruner + store.PausablePruner + store.UpgradeableStore +} + +// StateStorage is a mock of store.VersionedDatabase +type StateStorage interface { + store.VersionedDatabase + store.UpgradableDatabase + store.Pruner + store.PausablePruner +} diff --git a/store/v2/root/factory_test.go b/store/v2/root/factory_test.go new file mode 100644 index 0000000000..45fd34699b --- /dev/null +++ b/store/v2/root/factory_test.go @@ -0,0 +1,29 @@ +package root + +import ( + "testing" + + "github.com/stretchr/testify/require" + + coretesting "cosmossdk.io/core/testing" + "cosmossdk.io/store/v2/db" +) + +func TestFactory(t *testing.T) { + fop := FactoryOptions{ + Logger: coretesting.NewNopLogger(), + RootDir: t.TempDir(), + Options: DefaultStoreOptions(), + StoreKeys: storeKeys, + SCRawDB: db.NewMemDB(), + } + + f, err := CreateRootStore(&fop) + require.NoError(t, err) + require.NotNil(t, f) + + fop.Options.SCType = SCTypeIavlV2 + f, err = CreateRootStore(&fop) + require.Error(t, err) + require.Nil(t, f) +} diff --git a/store/v2/root/store_mock_test.go b/store/v2/root/store_mock_test.go new file mode 100644 index 0000000000..68956ab479 --- /dev/null +++ b/store/v2/root/store_mock_test.go @@ -0,0 +1,204 @@ +package root + +import ( + "errors" + "testing" + + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + + corestore "cosmossdk.io/core/store" + coretesting "cosmossdk.io/core/testing" + "cosmossdk.io/store/v2" + "cosmossdk.io/store/v2/metrics" + "cosmossdk.io/store/v2/mock" + "cosmossdk.io/store/v2/proof" + "cosmossdk.io/store/v2/pruning" +) + +func newTestRootStore(ss store.VersionedDatabase, sc store.Committer) *Store { + noopLog := coretesting.NewNopLogger() + pm := pruning.NewManager(sc.(store.Pruner), ss.(store.Pruner), nil, nil) + return &Store{ + logger: noopLog, + telemetry: metrics.Metrics{}, + initialVersion: 1, + stateStorage: ss, + stateCommitment: sc, + pruningManager: pm, + isMigrating: false, + } +} + +func TestGetLatestState(t *testing.T) { + ctrl := gomock.NewController(t) + ss := mock.NewMockStateStorage(ctrl) + sc := mock.NewMockStateCommitter(ctrl) + rs := newTestRootStore(ss, sc) + + // Get the latest version + sc.EXPECT().GetLatestVersion().Return(uint64(0), errors.New("error")) + _, err := rs.GetLatestVersion() + require.Error(t, err) + sc.EXPECT().GetLatestVersion().Return(uint64(1), nil) + v, err := rs.GetLatestVersion() + require.NoError(t, err) + require.Equal(t, uint64(1), v) +} + +func TestQuery(t *testing.T) { + ctrl := gomock.NewController(t) + ss := mock.NewMockStateStorage(ctrl) + sc := mock.NewMockStateCommitter(ctrl) + rs := newTestRootStore(ss, sc) + + // Query without Proof + ss.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, errors.New("error")) + _, err := rs.Query(nil, 0, nil, false) + require.Error(t, err) + ss.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil) + sc.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, errors.New("error")) + _, err = rs.Query(nil, 0, nil, false) + require.Error(t, err) + ss.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, nil) + sc.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Return([]byte("value"), nil) + v, err := rs.Query(nil, 0, nil, false) + require.NoError(t, err) + require.Equal(t, []byte("value"), v.Value) + ss.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Return([]byte("value"), nil) + v, err = rs.Query(nil, 0, nil, false) + require.NoError(t, err) + require.Equal(t, []byte("value"), v.Value) + + // Query with Proof + ss.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Return([]byte("value"), nil) + sc.EXPECT().GetProof(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, errors.New("error")) + v, err = rs.Query(nil, 0, nil, true) + require.Error(t, err) + + // Query with Migration + rs.isMigrating = true + sc.EXPECT().Get(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil, errors.New("error")) + _, err = rs.Query(nil, 0, nil, false) + require.Error(t, err) +} + +func TestLoadVersion(t *testing.T) { + ctrl := gomock.NewController(t) + ss := mock.NewMockStateStorage(ctrl) + sc := mock.NewMockStateCommitter(ctrl) + rs := newTestRootStore(ss, sc) + + // LoadLatestVersion + sc.EXPECT().GetLatestVersion().Return(uint64(0), errors.New("error")) + err := rs.LoadLatestVersion() + require.Error(t, err) + sc.EXPECT().GetLatestVersion().Return(uint64(1), nil) + sc.EXPECT().LoadVersion(uint64(1)).Return(errors.New("error")) + err = rs.LoadLatestVersion() + require.Error(t, err) + + // LoadVersion + sc.EXPECT().LoadVersion(gomock.Any()).Return(nil) + sc.EXPECT().GetCommitInfo(uint64(2)).Return(nil, errors.New("error")) + err = rs.LoadVersion(uint64(2)) + require.Error(t, err) + + // LoadVersionUpgrade + v := &corestore.StoreUpgrades{} + sc.EXPECT().LoadVersionAndUpgrade(uint64(2), v).Return(errors.New("error")) + err = rs.LoadVersionAndUpgrade(uint64(2), v) + require.Error(t, err) + sc.EXPECT().LoadVersionAndUpgrade(uint64(2), v).Return(nil) + sc.EXPECT().GetCommitInfo(uint64(2)).Return(nil, nil) + ss.EXPECT().PruneStoreKeys(gomock.Any(), uint64(2)).Return(errors.New("error")) + err = rs.LoadVersionAndUpgrade(uint64(2), v) + require.Error(t, err) + + // LoadVersionUpgrade with Migration + rs.isMigrating = true + err = rs.LoadVersionAndUpgrade(uint64(2), v) + require.Error(t, err) +} + +func TestWorkingHahs(t *testing.T) { + ctrl := gomock.NewController(t) + ss := mock.NewMockStateStorage(ctrl) + sc := mock.NewMockStateCommitter(ctrl) + rs := newTestRootStore(ss, sc) + + cs := corestore.NewChangeset() + // writeSC test + sc.EXPECT().WriteChangeset(cs).Return(errors.New("error")) + err := rs.writeSC(cs) + require.Error(t, err) + sc.EXPECT().WriteChangeset(cs).Return(nil) + sc.EXPECT().WorkingCommitInfo(gomock.Any()).Return(nil) + err = rs.writeSC(cs) + require.NoError(t, err) + + // WorkingHash test + sc.EXPECT().WriteChangeset(cs).Return(nil) + sc.EXPECT().WorkingCommitInfo(gomock.Any()).Return(nil) + ss.EXPECT().ApplyChangeset(gomock.Any(), cs).Return(errors.New("error")) + _, err = rs.WorkingHash(cs) + require.Error(t, err) + sc.EXPECT().WriteChangeset(cs).Return(nil) + sc.EXPECT().WorkingCommitInfo(gomock.Any()).Return(nil) + ss.EXPECT().ApplyChangeset(gomock.Any(), cs).Return(errors.New("error")) + _, err = rs.WorkingHash(cs) + require.Error(t, err) + sc.EXPECT().WriteChangeset(cs).Return(nil) + sc.EXPECT().WorkingCommitInfo(gomock.Any()).Return(&proof.CommitInfo{}) + ss.EXPECT().ApplyChangeset(gomock.Any(), cs).Return(nil) + _, err = rs.WorkingHash(cs) + require.NoError(t, err) +} + +func TestCommit(t *testing.T) { + ctrl := gomock.NewController(t) + ss := mock.NewMockStateStorage(ctrl) + sc := mock.NewMockStateCommitter(ctrl) + rs := newTestRootStore(ss, sc) + + cs := corestore.NewChangeset() + // test commitSC + rs.lastCommitInfo = &proof.CommitInfo{} + sc.EXPECT().Commit(gomock.Any()).Return(nil, errors.New("error")) + err := rs.commitSC() + require.Error(t, err) + sc.EXPECT().Commit(gomock.Any()).Return(&proof.CommitInfo{CommitHash: []byte("wrong hash"), StoreInfos: []proof.StoreInfo{{}}}, nil) // wrong hash + err = rs.commitSC() + require.Error(t, err) + + // Commit test + sc.EXPECT().WriteChangeset(cs).Return(errors.New("error")) + _, err = rs.Commit(cs) + require.Error(t, err) + sc.EXPECT().WriteChangeset(cs).Return(nil) + sc.EXPECT().WorkingCommitInfo(gomock.Any()).Return(&proof.CommitInfo{}) + sc.EXPECT().PausePruning(gomock.Any()).Return() + ss.EXPECT().PausePruning(gomock.Any()).Return() + ss.EXPECT().ApplyChangeset(gomock.Any(), cs).Return(nil) + sc.EXPECT().Commit(gomock.Any()).Return(nil, errors.New("error")) + _, err = rs.Commit(cs) + require.Error(t, err) + sc.EXPECT().WriteChangeset(cs).Return(nil) + sc.EXPECT().WorkingCommitInfo(gomock.Any()).Return(&proof.CommitInfo{}) + sc.EXPECT().PausePruning(gomock.Any()).Return() + ss.EXPECT().PausePruning(gomock.Any()).Return() + ss.EXPECT().ApplyChangeset(gomock.Any(), cs).Return(errors.New("error")) + sc.EXPECT().Commit(gomock.Any()).Return(&proof.CommitInfo{}, nil) + _, err = rs.Commit(cs) + require.Error(t, err) + sc.EXPECT().WriteChangeset(cs).Return(nil) + sc.EXPECT().WorkingCommitInfo(gomock.Any()).Return(&proof.CommitInfo{}) + sc.EXPECT().PausePruning(true).Return() + ss.EXPECT().PausePruning(true).Return() + ss.EXPECT().ApplyChangeset(gomock.Any(), cs).Return(nil) + sc.EXPECT().Commit(gomock.Any()).Return(&proof.CommitInfo{}, nil) + sc.EXPECT().PausePruning(false).Return() + ss.EXPECT().PausePruning(false).Return() + _, err = rs.Commit(cs) + require.NoError(t, err) +} diff --git a/store/v2/root/store_test.go b/store/v2/root/store_test.go index fe7552ee6b..fa4d25648a 100644 --- a/store/v2/root/store_test.go +++ b/store/v2/root/store_test.go @@ -373,10 +373,23 @@ func (s *RootStoreTestSuite) TestStateAt() { reader, err := ro.GetReader(testStoreKeyBytes) s.Require().NoError(err) + isExist, err := reader.Has([]byte(key)) + s.Require().NoError(err) + s.Require().True(isExist) result, err := reader.Get([]byte(key)) s.Require().NoError(err) s.Require().Equal([]byte(val), result) } + + // non-existent key + reader, err := ro.GetReader(testStoreKey2Bytes) + s.Require().NoError(err) + isExist, err := reader.Has([]byte("key")) + s.Require().NoError(err) + s.Require().False(isExist) + v, err := reader.Get([]byte("key")) + s.Require().NoError(err) + s.Require().Nil(v) } }