From 47b75137c84654752890bd127b56f29f6bda371e Mon Sep 17 00:00:00 2001 From: Mikhail Rakhmanov Date: Fri, 11 Apr 2025 23:04:16 +0200 Subject: [PATCH] Gen storage and fix tests --- commonspace/headsync/headsync_test.go | 14 ++ .../mock_commonspace/mock_commonspace.go | 15 ++ .../mock_keyvaluestorage.go | 144 +++++++++++++++ .../keyvalue/keyvaluestorage/storage.go | 1 + .../keyvalue/kvinterfaces/interfaces.go | 1 + .../mock_kvinterfaces/mock_kvinterfaces.go | 171 ++++++++++++++++++ .../mock_spacesyncproto.go | 30 +++ .../sync/objectsync/objectsync_test.go | 6 + 8 files changed, 382 insertions(+) create mode 100644 commonspace/object/keyvalue/keyvaluestorage/mock_keyvaluestorage/mock_keyvaluestorage.go create mode 100644 commonspace/object/keyvalue/kvinterfaces/mock_kvinterfaces/mock_kvinterfaces.go diff --git a/commonspace/headsync/headsync_test.go b/commonspace/headsync/headsync_test.go index 597b85e4..a0d88636 100644 --- a/commonspace/headsync/headsync_test.go +++ b/commonspace/headsync/headsync_test.go @@ -22,6 +22,9 @@ import ( "github.com/anyproto/any-sync/commonspace/object/acl/list" "github.com/anyproto/any-sync/commonspace/object/acl/syncacl" "github.com/anyproto/any-sync/commonspace/object/acl/syncacl/mock_syncacl" + "github.com/anyproto/any-sync/commonspace/object/keyvalue/keyvaluestorage/mock_keyvaluestorage" + "github.com/anyproto/any-sync/commonspace/object/keyvalue/kvinterfaces" + "github.com/anyproto/any-sync/commonspace/object/keyvalue/kvinterfaces/mock_kvinterfaces" "github.com/anyproto/any-sync/commonspace/object/treemanager" "github.com/anyproto/any-sync/commonspace/object/treemanager/mock_treemanager" "github.com/anyproto/any-sync/commonspace/object/treesyncer" @@ -34,6 +37,7 @@ import ( "github.com/anyproto/any-sync/commonspace/spacesyncproto/mock_spacesyncproto" "github.com/anyproto/any-sync/nodeconf" "github.com/anyproto/any-sync/nodeconf/mock_nodeconf" + "github.com/anyproto/any-sync/testutil/anymock" ) type mockConfig struct { @@ -57,6 +61,8 @@ type headSyncFixture struct { app *app.App configurationMock *mock_nodeconf.MockService + kvMock *mock_kvinterfaces.MockKeyValueService + defStoreMock *mock_keyvaluestorage.MockStorage storageMock *mock_spacestorage.MockSpaceStorage peerManagerMock *mock_peermanager.MockPeerManager credentialProviderMock *mock_credentialprovider.MockCredentialProvider @@ -96,6 +102,11 @@ func newHeadSyncFixture(t *testing.T) *headSyncFixture { treeSyncerMock := mock_treesyncer.NewMockTreeSyncer(ctrl) headStorage := mock_headstorage.NewMockHeadStorage(ctrl) stateStorage := mock_statestorage.NewMockStateStorage(ctrl) + kvMock := mock_kvinterfaces.NewMockKeyValueService(ctrl) + anymock.ExpectComp(kvMock.EXPECT(), kvinterfaces.CName) + defStore := mock_keyvaluestorage.NewMockStorage(ctrl) + kvMock.EXPECT().DefaultStore().Return(defStore).AnyTimes() + defStore.EXPECT().Id().Return("store").AnyTimes() storageMock.EXPECT().HeadStorage().AnyTimes().Return(headStorage) storageMock.EXPECT().StateStorage().AnyTimes().Return(stateStorage) treeSyncerMock.EXPECT().Name().AnyTimes().Return(treesyncer.CName) @@ -108,6 +119,7 @@ func newHeadSyncFixture(t *testing.T) *headSyncFixture { a := &app.App{} a.Register(spaceState). Register(aclMock). + Register(kvMock). Register(mockConfig{}). Register(configurationMock). Register(storageMock). @@ -121,6 +133,8 @@ func newHeadSyncFixture(t *testing.T) *headSyncFixture { spaceState: spaceState, ctrl: ctrl, app: a, + kvMock: kvMock, + defStoreMock: defStore, configurationMock: configurationMock, storageMock: storageMock, diffContainerMock: diffContainerMock, diff --git a/commonspace/mock_commonspace/mock_commonspace.go b/commonspace/mock_commonspace/mock_commonspace.go index 4d414ddf..652ccdc0 100644 --- a/commonspace/mock_commonspace/mock_commonspace.go +++ b/commonspace/mock_commonspace/mock_commonspace.go @@ -17,6 +17,7 @@ import ( aclclient "github.com/anyproto/any-sync/commonspace/acl/aclclient" headsync "github.com/anyproto/any-sync/commonspace/headsync" syncacl "github.com/anyproto/any-sync/commonspace/object/acl/syncacl" + kvinterfaces "github.com/anyproto/any-sync/commonspace/object/keyvalue/kvinterfaces" treesyncer "github.com/anyproto/any-sync/commonspace/object/treesyncer" objecttreebuilder "github.com/anyproto/any-sync/commonspace/objecttreebuilder" spacestorage "github.com/anyproto/any-sync/commonspace/spacestorage" @@ -222,6 +223,20 @@ func (mr *MockSpaceMockRecorder) Init(arg0 any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpace)(nil).Init), arg0) } +// KeyValue mocks base method. +func (m *MockSpace) KeyValue() kvinterfaces.KeyValueService { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "KeyValue") + ret0, _ := ret[0].(kvinterfaces.KeyValueService) + return ret0 +} + +// KeyValue indicates an expected call of KeyValue. +func (mr *MockSpaceMockRecorder) KeyValue() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyValue", reflect.TypeOf((*MockSpace)(nil).KeyValue)) +} + // Storage mocks base method. func (m *MockSpace) Storage() spacestorage.SpaceStorage { m.ctrl.T.Helper() diff --git a/commonspace/object/keyvalue/keyvaluestorage/mock_keyvaluestorage/mock_keyvaluestorage.go b/commonspace/object/keyvalue/keyvaluestorage/mock_keyvaluestorage/mock_keyvaluestorage.go new file mode 100644 index 00000000..548d61f1 --- /dev/null +++ b/commonspace/object/keyvalue/keyvaluestorage/mock_keyvaluestorage/mock_keyvaluestorage.go @@ -0,0 +1,144 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/anyproto/any-sync/commonspace/object/keyvalue/keyvaluestorage (interfaces: Storage) +// +// Generated by this command: +// +// mockgen -destination mock_keyvaluestorage/mock_keyvaluestorage.go github.com/anyproto/any-sync/commonspace/object/keyvalue/keyvaluestorage Storage +// +// Package mock_keyvaluestorage is a generated GoMock package. +package mock_keyvaluestorage + +import ( + context "context" + reflect "reflect" + + innerstorage "github.com/anyproto/any-sync/commonspace/object/keyvalue/keyvaluestorage/innerstorage" + spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto" + gomock "go.uber.org/mock/gomock" +) + +// MockStorage is a mock of Storage interface. +type MockStorage struct { + ctrl *gomock.Controller + recorder *MockStorageMockRecorder +} + +// MockStorageMockRecorder is the mock recorder for MockStorage. +type MockStorageMockRecorder struct { + mock *MockStorage +} + +// NewMockStorage creates a new mock instance. +func NewMockStorage(ctrl *gomock.Controller) *MockStorage { + mock := &MockStorage{ctrl: ctrl} + mock.recorder = &MockStorageMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStorage) EXPECT() *MockStorageMockRecorder { + return m.recorder +} + +// GetAll mocks base method. +func (m *MockStorage) GetAll(arg0 context.Context, arg1 string, arg2 func(func(innerstorage.KeyValue) ([]byte, error), []innerstorage.KeyValue) error) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAll", arg0, arg1, arg2) + ret0, _ := ret[0].(error) + return ret0 +} + +// GetAll indicates an expected call of GetAll. +func (mr *MockStorageMockRecorder) GetAll(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAll", reflect.TypeOf((*MockStorage)(nil).GetAll), arg0, arg1, arg2) +} + +// Id mocks base method. +func (m *MockStorage) Id() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Id") + ret0, _ := ret[0].(string) + return ret0 +} + +// Id indicates an expected call of Id. +func (mr *MockStorageMockRecorder) Id() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockStorage)(nil).Id)) +} + +// InnerStorage mocks base method. +func (m *MockStorage) InnerStorage() innerstorage.KeyValueStorage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InnerStorage") + ret0, _ := ret[0].(innerstorage.KeyValueStorage) + return ret0 +} + +// InnerStorage indicates an expected call of InnerStorage. +func (mr *MockStorageMockRecorder) InnerStorage() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InnerStorage", reflect.TypeOf((*MockStorage)(nil).InnerStorage)) +} + +// Iterate mocks base method. +func (m *MockStorage) Iterate(arg0 context.Context, arg1 func(func(innerstorage.KeyValue) ([]byte, error), string, []innerstorage.KeyValue) (bool, error)) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Iterate", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// Iterate indicates an expected call of Iterate. +func (mr *MockStorageMockRecorder) Iterate(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockStorage)(nil).Iterate), arg0, arg1) +} + +// Prepare mocks base method. +func (m *MockStorage) Prepare() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Prepare") + ret0, _ := ret[0].(error) + return ret0 +} + +// Prepare indicates an expected call of Prepare. +func (mr *MockStorageMockRecorder) Prepare() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockStorage)(nil).Prepare)) +} + +// Set mocks base method. +func (m *MockStorage) Set(arg0 context.Context, arg1 string, arg2 []byte) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", arg0, arg1, arg2) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockStorageMockRecorder) Set(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStorage)(nil).Set), arg0, arg1, arg2) +} + +// SetRaw mocks base method. +func (m *MockStorage) SetRaw(arg0 context.Context, arg1 ...*spacesyncproto.StoreKeyValue) error { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetRaw", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetRaw indicates an expected call of SetRaw. +func (mr *MockStorageMockRecorder) SetRaw(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRaw", reflect.TypeOf((*MockStorage)(nil).SetRaw), varargs...) +} diff --git a/commonspace/object/keyvalue/keyvaluestorage/storage.go b/commonspace/object/keyvalue/keyvaluestorage/storage.go index 7d03075c..9f8caf13 100644 --- a/commonspace/object/keyvalue/keyvaluestorage/storage.go +++ b/commonspace/object/keyvalue/keyvaluestorage/storage.go @@ -1,3 +1,4 @@ +//go:generate mockgen -destination mock_keyvaluestorage/mock_keyvaluestorage.go github.com/anyproto/any-sync/commonspace/object/keyvalue/keyvaluestorage Storage package keyvaluestorage import ( diff --git a/commonspace/object/keyvalue/kvinterfaces/interfaces.go b/commonspace/object/keyvalue/kvinterfaces/interfaces.go index 6bc34e13..ce0ea4b3 100644 --- a/commonspace/object/keyvalue/kvinterfaces/interfaces.go +++ b/commonspace/object/keyvalue/kvinterfaces/interfaces.go @@ -1,3 +1,4 @@ +//go:generate mockgen -destination mock_kvinterfaces/mock_kvinterfaces.go github.com/anyproto/any-sync/commonspace/object/keyvalue/kvinterfaces KeyValueService package kvinterfaces import ( diff --git a/commonspace/object/keyvalue/kvinterfaces/mock_kvinterfaces/mock_kvinterfaces.go b/commonspace/object/keyvalue/kvinterfaces/mock_kvinterfaces/mock_kvinterfaces.go new file mode 100644 index 00000000..93026984 --- /dev/null +++ b/commonspace/object/keyvalue/kvinterfaces/mock_kvinterfaces/mock_kvinterfaces.go @@ -0,0 +1,171 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/anyproto/any-sync/commonspace/object/keyvalue/kvinterfaces (interfaces: KeyValueService) +// +// Generated by this command: +// +// mockgen -destination mock_kvinterfaces/mock_kvinterfaces.go github.com/anyproto/any-sync/commonspace/object/keyvalue/kvinterfaces KeyValueService +// +// Package mock_kvinterfaces is a generated GoMock package. +package mock_kvinterfaces + +import ( + context "context" + reflect "reflect" + + app "github.com/anyproto/any-sync/app" + keyvaluestorage "github.com/anyproto/any-sync/commonspace/object/keyvalue/keyvaluestorage" + spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto" + peer "github.com/anyproto/any-sync/net/peer" + gomock "go.uber.org/mock/gomock" + drpc "storj.io/drpc" +) + +// MockKeyValueService is a mock of KeyValueService interface. +type MockKeyValueService struct { + ctrl *gomock.Controller + recorder *MockKeyValueServiceMockRecorder +} + +// MockKeyValueServiceMockRecorder is the mock recorder for MockKeyValueService. +type MockKeyValueServiceMockRecorder struct { + mock *MockKeyValueService +} + +// NewMockKeyValueService creates a new mock instance. +func NewMockKeyValueService(ctrl *gomock.Controller) *MockKeyValueService { + mock := &MockKeyValueService{ctrl: ctrl} + mock.recorder = &MockKeyValueServiceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockKeyValueService) EXPECT() *MockKeyValueServiceMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *MockKeyValueService) Close(arg0 context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockKeyValueServiceMockRecorder) Close(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockKeyValueService)(nil).Close), arg0) +} + +// DefaultStore mocks base method. +func (m *MockKeyValueService) DefaultStore() keyvaluestorage.Storage { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DefaultStore") + ret0, _ := ret[0].(keyvaluestorage.Storage) + return ret0 +} + +// DefaultStore indicates an expected call of DefaultStore. +func (mr *MockKeyValueServiceMockRecorder) DefaultStore() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultStore", reflect.TypeOf((*MockKeyValueService)(nil).DefaultStore)) +} + +// HandleMessage mocks base method. +func (m *MockKeyValueService) HandleMessage(arg0 context.Context, arg1 drpc.Message) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleMessage", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// HandleMessage indicates an expected call of HandleMessage. +func (mr *MockKeyValueServiceMockRecorder) HandleMessage(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockKeyValueService)(nil).HandleMessage), arg0, arg1) +} + +// HandleStoreDiffRequest mocks base method. +func (m *MockKeyValueService) HandleStoreDiffRequest(arg0 context.Context, arg1 *spacesyncproto.StoreDiffRequest) (*spacesyncproto.StoreDiffResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleStoreDiffRequest", arg0, arg1) + ret0, _ := ret[0].(*spacesyncproto.StoreDiffResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// HandleStoreDiffRequest indicates an expected call of HandleStoreDiffRequest. +func (mr *MockKeyValueServiceMockRecorder) HandleStoreDiffRequest(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStoreDiffRequest", reflect.TypeOf((*MockKeyValueService)(nil).HandleStoreDiffRequest), arg0, arg1) +} + +// HandleStoreElementsRequest mocks base method. +func (m *MockKeyValueService) HandleStoreElementsRequest(arg0 context.Context, arg1 spacesyncproto.DRPCSpaceSync_StoreElementsStream) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleStoreElementsRequest", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// HandleStoreElementsRequest indicates an expected call of HandleStoreElementsRequest. +func (mr *MockKeyValueServiceMockRecorder) HandleStoreElementsRequest(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStoreElementsRequest", reflect.TypeOf((*MockKeyValueService)(nil).HandleStoreElementsRequest), arg0, arg1) +} + +// Init mocks base method. +func (m *MockKeyValueService) Init(arg0 *app.App) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Init", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Init indicates an expected call of Init. +func (mr *MockKeyValueServiceMockRecorder) Init(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockKeyValueService)(nil).Init), arg0) +} + +// Name mocks base method. +func (m *MockKeyValueService) 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 *MockKeyValueServiceMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockKeyValueService)(nil).Name)) +} + +// Run mocks base method. +func (m *MockKeyValueService) Run(arg0 context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Run", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Run indicates an expected call of Run. +func (mr *MockKeyValueServiceMockRecorder) Run(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockKeyValueService)(nil).Run), arg0) +} + +// SyncWithPeer mocks base method. +func (m *MockKeyValueService) SyncWithPeer(arg0 peer.Peer) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SyncWithPeer", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SyncWithPeer indicates an expected call of SyncWithPeer. +func (mr *MockKeyValueServiceMockRecorder) SyncWithPeer(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWithPeer", reflect.TypeOf((*MockKeyValueService)(nil).SyncWithPeer), arg0) +} diff --git a/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go b/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go index edd75aff..082e823e 100644 --- a/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go +++ b/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go @@ -173,3 +173,33 @@ func (mr *MockDRPCSpaceSyncClientMockRecorder) SpacePush(arg0, arg1 any) *gomock mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpacePush", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).SpacePush), arg0, arg1) } + +// StoreDiff mocks base method. +func (m *MockDRPCSpaceSyncClient) StoreDiff(arg0 context.Context, arg1 *spacesyncproto.StoreDiffRequest) (*spacesyncproto.StoreDiffResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StoreDiff", arg0, arg1) + ret0, _ := ret[0].(*spacesyncproto.StoreDiffResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StoreDiff indicates an expected call of StoreDiff. +func (mr *MockDRPCSpaceSyncClientMockRecorder) StoreDiff(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreDiff", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).StoreDiff), arg0, arg1) +} + +// StoreElements mocks base method. +func (m *MockDRPCSpaceSyncClient) StoreElements(arg0 context.Context) (spacesyncproto.DRPCSpaceSync_StoreElementsClient, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StoreElements", arg0) + ret0, _ := ret[0].(spacesyncproto.DRPCSpaceSync_StoreElementsClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StoreElements indicates an expected call of StoreElements. +func (mr *MockDRPCSpaceSyncClientMockRecorder) StoreElements(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoreElements", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).StoreElements), arg0) +} diff --git a/commonspace/sync/objectsync/objectsync_test.go b/commonspace/sync/objectsync/objectsync_test.go index eb104d5d..f3a61e38 100644 --- a/commonspace/sync/objectsync/objectsync_test.go +++ b/commonspace/sync/objectsync/objectsync_test.go @@ -10,6 +10,8 @@ import ( "go.uber.org/mock/gomock" "github.com/anyproto/any-sync/app" + "github.com/anyproto/any-sync/commonspace/object/keyvalue/kvinterfaces" + "github.com/anyproto/any-sync/commonspace/object/keyvalue/kvinterfaces/mock_kvinterfaces" "github.com/anyproto/any-sync/commonspace/object/tree/synctree" "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto" "github.com/anyproto/any-sync/commonspace/object/treemanager" @@ -159,6 +161,7 @@ func TestObjectSync_ApplyRequest(t *testing.T) { type fixture struct { *objectSync objectManager *mock_objectmanager.MockObjectManager + keyValue *mock_kvinterfaces.MockKeyValueService pool *mock_pool.MockService a *app.App ctrl *gomock.Controller @@ -171,13 +174,16 @@ func newFixture(t *testing.T) *fixture { fx.ctrl = gomock.NewController(t) fx.objectManager = mock_objectmanager.NewMockObjectManager(fx.ctrl) fx.pool = mock_pool.NewMockService(fx.ctrl) + fx.keyValue = mock_kvinterfaces.NewMockKeyValueService(fx.ctrl) anymock.ExpectComp(fx.objectManager.EXPECT(), treemanager.CName) anymock.ExpectComp(fx.pool.EXPECT(), pool.CName) + anymock.ExpectComp(fx.keyValue.EXPECT(), kvinterfaces.CName) fx.objectSync = &objectSync{} spaceState := &spacestate.SpaceState{SpaceId: "spaceId"} fx.a.Register(fx.objectManager). Register(spaceState). Register(fx.pool). + Register(fx.keyValue). Register(syncstatus.NewNoOpSyncStatus()). Register(fx.objectSync) require.NoError(t, fx.a.Start(context.Background()))