From 2f5e0dd6c8b6b9057b32b4f5504385a8d116c94a Mon Sep 17 00:00:00 2001 From: mcrakhman Date: Wed, 7 Jun 2023 11:30:27 +0200 Subject: [PATCH] WIP headsync tests revive --- .../mock_credentialprovider.go | 29 ++ commonspace/deletionstate/deletionstate.go | 2 +- .../mock_deletionstate/mock_deletionstate.go | 144 ++++++ commonspace/headsync/diffsyncer_test.go | 456 +++++++++--------- commonspace/headsync/headsync.go | 5 +- commonspace/headsync/headsync_test.go | 189 ++++++-- .../headsync/mock_headsync/mock_headsync.go | 9 +- .../mock_objectsync/mock_objectsync.go | 179 +++---- commonspace/objectsync/objectsync.go | 2 +- .../mock_objecttreebuilder.go | 99 ++++ commonspace/objecttreebuilder/treebuilder.go | 1 + .../mock_peermanager/mock_peermanager.go | 29 ++ .../requestmanager/requestmanager_test.go | 1 + .../mock_settingsstate/mock_settingsstate.go | 105 +--- .../mock_spacestorage/mock_spacestorage.go | 52 +- .../mock_spacesyncproto.go | 15 + 16 files changed, 839 insertions(+), 478 deletions(-) create mode 100644 commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go create mode 100644 commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go create mode 100644 commonspace/requestmanager/requestmanager_test.go diff --git a/commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go b/commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go index a1f8dd97..77faf28e 100644 --- a/commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go +++ b/commonspace/credentialprovider/mock_credentialprovider/mock_credentialprovider.go @@ -8,6 +8,7 @@ import ( context "context" reflect "reflect" + app "github.com/anyproto/any-sync/app" spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto" gomock "github.com/golang/mock/gomock" ) @@ -49,3 +50,31 @@ func (mr *MockCredentialProviderMockRecorder) GetCredential(arg0, arg1 interface mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCredential", reflect.TypeOf((*MockCredentialProvider)(nil).GetCredential), arg0, arg1) } + +// Init mocks base method. +func (m *MockCredentialProvider) 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 *MockCredentialProviderMockRecorder) Init(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockCredentialProvider)(nil).Init), arg0) +} + +// Name mocks base method. +func (m *MockCredentialProvider) 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 *MockCredentialProviderMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCredentialProvider)(nil).Name)) +} diff --git a/commonspace/deletionstate/deletionstate.go b/commonspace/deletionstate/deletionstate.go index 692ba627..f7d1d9a7 100644 --- a/commonspace/deletionstate/deletionstate.go +++ b/commonspace/deletionstate/deletionstate.go @@ -1,4 +1,4 @@ -//go:generate mockgen -destination mock_settingsstate/mock_settingsstate.go github.com/anyproto/any-sync/commonspace/settings/settingsstate ObjectDeletionState,StateBuilder,ChangeFactory +//go:generate mockgen -destination mock_deletionstate/mock_deletionstate.go github.com/anyproto/any-sync/commonspace/deletionstate ObjectDeletionState package deletionstate import ( diff --git a/commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go b/commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go new file mode 100644 index 00000000..c4e9fefb --- /dev/null +++ b/commonspace/deletionstate/mock_deletionstate/mock_deletionstate.go @@ -0,0 +1,144 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/anyproto/any-sync/commonspace/deletionstate (interfaces: ObjectDeletionState) + +// Package mock_deletionstate is a generated GoMock package. +package mock_deletionstate + +import ( + reflect "reflect" + + app "github.com/anyproto/any-sync/app" + deletionstate "github.com/anyproto/any-sync/commonspace/deletionstate" + gomock "github.com/golang/mock/gomock" +) + +// MockObjectDeletionState is a mock of ObjectDeletionState interface. +type MockObjectDeletionState struct { + ctrl *gomock.Controller + recorder *MockObjectDeletionStateMockRecorder +} + +// MockObjectDeletionStateMockRecorder is the mock recorder for MockObjectDeletionState. +type MockObjectDeletionStateMockRecorder struct { + mock *MockObjectDeletionState +} + +// NewMockObjectDeletionState creates a new mock instance. +func NewMockObjectDeletionState(ctrl *gomock.Controller) *MockObjectDeletionState { + mock := &MockObjectDeletionState{ctrl: ctrl} + mock.recorder = &MockObjectDeletionStateMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockObjectDeletionState) EXPECT() *MockObjectDeletionStateMockRecorder { + return m.recorder +} + +// Add mocks base method. +func (m *MockObjectDeletionState) Add(arg0 map[string]struct{}) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "Add", arg0) +} + +// Add indicates an expected call of Add. +func (mr *MockObjectDeletionStateMockRecorder) Add(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockObjectDeletionState)(nil).Add), arg0) +} + +// AddObserver mocks base method. +func (m *MockObjectDeletionState) AddObserver(arg0 deletionstate.StateUpdateObserver) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "AddObserver", arg0) +} + +// AddObserver indicates an expected call of AddObserver. +func (mr *MockObjectDeletionStateMockRecorder) AddObserver(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObserver", reflect.TypeOf((*MockObjectDeletionState)(nil).AddObserver), arg0) +} + +// Delete mocks base method. +func (m *MockObjectDeletionState) Delete(arg0 string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Delete indicates an expected call of Delete. +func (mr *MockObjectDeletionStateMockRecorder) Delete(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockObjectDeletionState)(nil).Delete), arg0) +} + +// Exists mocks base method. +func (m *MockObjectDeletionState) Exists(arg0 string) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Exists", arg0) + ret0, _ := ret[0].(bool) + return ret0 +} + +// Exists indicates an expected call of Exists. +func (mr *MockObjectDeletionStateMockRecorder) Exists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockObjectDeletionState)(nil).Exists), arg0) +} + +// Filter mocks base method. +func (m *MockObjectDeletionState) Filter(arg0 []string) []string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Filter", arg0) + ret0, _ := ret[0].([]string) + return ret0 +} + +// Filter indicates an expected call of Filter. +func (mr *MockObjectDeletionStateMockRecorder) Filter(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Filter", reflect.TypeOf((*MockObjectDeletionState)(nil).Filter), arg0) +} + +// GetQueued mocks base method. +func (m *MockObjectDeletionState) GetQueued() []string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetQueued") + ret0, _ := ret[0].([]string) + return ret0 +} + +// GetQueued indicates an expected call of GetQueued. +func (mr *MockObjectDeletionStateMockRecorder) GetQueued() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueued", reflect.TypeOf((*MockObjectDeletionState)(nil).GetQueued)) +} + +// Init mocks base method. +func (m *MockObjectDeletionState) 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 *MockObjectDeletionStateMockRecorder) Init(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockObjectDeletionState)(nil).Init), arg0) +} + +// Name mocks base method. +func (m *MockObjectDeletionState) 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 *MockObjectDeletionStateMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockObjectDeletionState)(nil).Name)) +} diff --git a/commonspace/headsync/diffsyncer_test.go b/commonspace/headsync/diffsyncer_test.go index fb1ad49c..d805c9f6 100644 --- a/commonspace/headsync/diffsyncer_test.go +++ b/commonspace/headsync/diffsyncer_test.go @@ -1,243 +1,235 @@ package headsync import ( - "bytes" - "context" - "fmt" - "github.com/anyproto/any-sync/app/ldiff" - "github.com/anyproto/any-sync/app/ldiff/mock_ldiff" - "github.com/anyproto/any-sync/app/logger" - "github.com/anyproto/any-sync/commonspace/credentialprovider/mock_credentialprovider" - "github.com/anyproto/any-sync/commonspace/object/acl/aclrecordproto" - "github.com/anyproto/any-sync/commonspace/object/acl/liststorage/mock_liststorage" - "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto" - mock_treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage/mock_treestorage" - "github.com/anyproto/any-sync/commonspace/object/treemanager/mock_treemanager" - "github.com/anyproto/any-sync/commonspace/peermanager/mock_peermanager" - "github.com/anyproto/any-sync/commonspace/settings/settingsstate/mock_settingsstate" - "github.com/anyproto/any-sync/commonspace/spacestorage/mock_spacestorage" - "github.com/anyproto/any-sync/commonspace/spacesyncproto" - "github.com/anyproto/any-sync/commonspace/spacesyncproto/mock_spacesyncproto" - "github.com/anyproto/any-sync/commonspace/syncstatus" - "github.com/anyproto/any-sync/net/peer" "github.com/golang/mock/gomock" - "github.com/libp2p/go-libp2p/core/sec" - "github.com/stretchr/testify/require" - "storj.io/drpc" "testing" - "time" ) -type pushSpaceRequestMatcher struct { - spaceId string - aclRootId string - settingsId string - credential []byte - spaceHeader *spacesyncproto.RawSpaceHeaderWithId +func (fx *headSyncFixture) initDiffSyncer(t *testing.T) { + fx.init(t) + fx.diffSyncer = newDiffSyncer(fx.headSync) + fx.deletionStateMock.EXPECT().AddObserver(gomock.Any()) + fx.treeManagerMock.EXPECT().NewTreeSyncer(fx.spaceState.SpaceId, fx.treeManagerMock).Return(fx.treeSyncerMock) + fx.diffSyncer.Init() } -func (p pushSpaceRequestMatcher) Matches(x interface{}) bool { - res, ok := x.(*spacesyncproto.SpacePushRequest) - if !ok { - return false - } - - return res.Payload.AclPayloadId == p.aclRootId && res.Payload.SpaceHeader == p.spaceHeader && res.Payload.SpaceSettingsPayloadId == p.settingsId && bytes.Equal(p.credential, res.Credential) +func TestDiffSyncer(t *testing.T) { + fx := newHeadSyncFixture(t) + fx.initDiffSyncer(t) + defer fx.stop() } -func (p pushSpaceRequestMatcher) String() string { - return "" -} - -type mockPeer struct{} - -func (m mockPeer) Addr() string { - return "" -} - -func (m mockPeer) TryClose(objectTTL time.Duration) (res bool, err error) { - return true, m.Close() -} - -func (m mockPeer) Id() string { - return "mockId" -} - -func (m mockPeer) LastUsage() time.Time { - return time.Time{} -} - -func (m mockPeer) Secure() sec.SecureConn { - return nil -} - -func (m mockPeer) UpdateLastUsage() { -} - -func (m mockPeer) Close() error { - return nil -} - -func (m mockPeer) Closed() <-chan struct{} { - return make(chan struct{}) -} - -func (m mockPeer) Invoke(ctx context.Context, rpc string, enc drpc.Encoding, in, out drpc.Message) error { - return nil -} - -func (m mockPeer) NewStream(ctx context.Context, rpc string, enc drpc.Encoding) (drpc.Stream, error) { - return nil, nil -} - -func newPushSpaceRequestMatcher( - spaceId string, - aclRootId string, - settingsId string, - credential []byte, - spaceHeader *spacesyncproto.RawSpaceHeaderWithId) *pushSpaceRequestMatcher { - return &pushSpaceRequestMatcher{ - spaceId: spaceId, - aclRootId: aclRootId, - settingsId: settingsId, - credential: credential, - spaceHeader: spaceHeader, - } -} - -func TestDiffSyncer_Sync(t *testing.T) { - // setup - ctx := context.Background() - ctrl := gomock.NewController(t) - defer ctrl.Finish() - - diffMock := mock_ldiff.NewMockDiff(ctrl) - peerManagerMock := mock_peermanager.NewMockPeerManager(ctrl) - cacheMock := mock_treemanager.NewMockTreeManager(ctrl) - stMock := mock_spacestorage.NewMockSpaceStorage(ctrl) - clientMock := mock_spacesyncproto.NewMockDRPCSpaceSyncClient(ctrl) - factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceSyncClient { - return clientMock - }) - treeSyncerMock := mock_treemanager.NewMockTreeSyncer(ctrl) - credentialProvider := mock_credentialprovider.NewMockCredentialProvider(ctrl) - delState := mock_settingsstate.NewMockObjectDeletionState(ctrl) - spaceId := "spaceId" - aclRootId := "aclRootId" - l := logger.NewNamed(spaceId) - diffSyncer := newDiffSyncer(spaceId, diffMock, peerManagerMock, cacheMock, stMock, factory, syncstatus.NewNoOpSyncStatus(), credentialProvider, l) - delState.EXPECT().AddObserver(gomock.Any()) - cacheMock.EXPECT().NewTreeSyncer(spaceId, gomock.Any()).Return(treeSyncerMock) - diffSyncer.Init(delState) - - t.Run("diff syncer sync", func(t *testing.T) { - mPeer := mockPeer{} - peerManagerMock.EXPECT(). - GetResponsiblePeers(gomock.Any()). - Return([]peer.Peer{mPeer}, nil) - diffMock.EXPECT(). - Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))). - Return([]string{"new"}, []string{"changed"}, nil, nil) - delState.EXPECT().Filter([]string{"new"}).Return([]string{"new"}).Times(1) - delState.EXPECT().Filter([]string{"changed"}).Return([]string{"changed"}).Times(1) - delState.EXPECT().Filter(nil).Return(nil).Times(1) - treeSyncerMock.EXPECT().SyncAll(gomock.Any(), mPeer.Id(), []string{"changed"}, []string{"new"}).Return(nil) - require.NoError(t, diffSyncer.Sync(ctx)) - }) - - t.Run("diff syncer sync conf error", func(t *testing.T) { - peerManagerMock.EXPECT(). - GetResponsiblePeers(gomock.Any()). - Return(nil, fmt.Errorf("some error")) - - require.Error(t, diffSyncer.Sync(ctx)) - }) - - t.Run("deletion state remove objects", func(t *testing.T) { - deletedId := "id" - delState.EXPECT().Exists(deletedId).Return(true) - - // this should not result in any mock being called - diffSyncer.UpdateHeads(deletedId, []string{"someHead"}) - }) - - t.Run("update heads updates diff", func(t *testing.T) { - newId := "newId" - newHeads := []string{"h1", "h2"} - hash := "hash" - diffMock.EXPECT().Set(ldiff.Element{ - Id: newId, - Head: concatStrings(newHeads), - }) - diffMock.EXPECT().Hash().Return(hash) - delState.EXPECT().Exists(newId).Return(false) - stMock.EXPECT().WriteSpaceHash(hash) - diffSyncer.UpdateHeads(newId, newHeads) - }) - - t.Run("diff syncer sync space missing", func(t *testing.T) { - aclStorageMock := mock_liststorage.NewMockListStorage(ctrl) - settingsStorage := mock_treestorage.NewMockTreeStorage(ctrl) - settingsId := "settingsId" - aclRoot := &aclrecordproto.RawAclRecordWithId{ - Id: aclRootId, - } - settingsRoot := &treechangeproto.RawTreeChangeWithId{ - Id: settingsId, - } - spaceHeader := &spacesyncproto.RawSpaceHeaderWithId{} - spaceSettingsId := "spaceSettingsId" - credential := []byte("credential") - - peerManagerMock.EXPECT(). - GetResponsiblePeers(gomock.Any()). - Return([]peer.Peer{mockPeer{}}, nil) - diffMock.EXPECT(). - Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))). - Return(nil, nil, nil, spacesyncproto.ErrSpaceMissing) - - stMock.EXPECT().AclStorage().Return(aclStorageMock, nil) - stMock.EXPECT().SpaceHeader().Return(spaceHeader, nil) - stMock.EXPECT().SpaceSettingsId().Return(spaceSettingsId) - stMock.EXPECT().TreeStorage(spaceSettingsId).Return(settingsStorage, nil) - - settingsStorage.EXPECT().Root().Return(settingsRoot, nil) - aclStorageMock.EXPECT(). - Root(). - Return(aclRoot, nil) - credentialProvider.EXPECT(). - GetCredential(gomock.Any(), spaceHeader). - Return(credential, nil) - clientMock.EXPECT(). - SpacePush(gomock.Any(), newPushSpaceRequestMatcher(spaceId, aclRootId, settingsId, credential, spaceHeader)). - Return(nil, nil) - peerManagerMock.EXPECT().SendPeer(gomock.Any(), "mockId", gomock.Any()) - - require.NoError(t, diffSyncer.Sync(ctx)) - }) - - t.Run("diff syncer sync unexpected", func(t *testing.T) { - peerManagerMock.EXPECT(). - GetResponsiblePeers(gomock.Any()). - Return([]peer.Peer{mockPeer{}}, nil) - diffMock.EXPECT(). - Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))). - Return(nil, nil, nil, spacesyncproto.ErrUnexpected) - - require.NoError(t, diffSyncer.Sync(ctx)) - }) - - t.Run("diff syncer sync space is deleted error", func(t *testing.T) { - mPeer := mockPeer{} - peerManagerMock.EXPECT(). - GetResponsiblePeers(gomock.Any()). - Return([]peer.Peer{mPeer}, nil) - diffMock.EXPECT(). - Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))). - Return(nil, nil, nil, spacesyncproto.ErrSpaceIsDeleted) - stMock.EXPECT().SpaceSettingsId().Return("settingsId") - treeSyncerMock.EXPECT().SyncAll(gomock.Any(), mPeer.Id(), []string{"settingsId"}, nil).Return(nil) - - require.NoError(t, diffSyncer.Sync(ctx)) - }) -} +// +//type pushSpaceRequestMatcher struct { +// spaceId string +// aclRootId string +// settingsId string +// credential []byte +// spaceHeader *spacesyncproto.RawSpaceHeaderWithId +//} +// +//func (p pushSpaceRequestMatcher) Matches(x interface{}) bool { +// res, ok := x.(*spacesyncproto.SpacePushRequest) +// if !ok { +// return false +// } +// +// return res.Payload.AclPayloadId == p.aclRootId && res.Payload.SpaceHeader == p.spaceHeader && res.Payload.SpaceSettingsPayloadId == p.settingsId && bytes.Equal(p.credential, res.Credential) +//} +// +//func (p pushSpaceRequestMatcher) String() string { +// return "" +//} +// +//type mockPeer struct{} +// +//func (m mockPeer) Addr() string { +// return "" +//} +// +//func (m mockPeer) TryClose(objectTTL time.Duration) (res bool, err error) { +// return true, m.Close() +//} +// +//func (m mockPeer) Id() string { +// return "mockId" +//} +// +//func (m mockPeer) LastUsage() time.Time { +// return time.Time{} +//} +// +//func (m mockPeer) Secure() sec.SecureConn { +// return nil +//} +// +//func (m mockPeer) UpdateLastUsage() { +//} +// +//func (m mockPeer) Close() error { +// return nil +//} +// +//func (m mockPeer) Closed() <-chan struct{} { +// return make(chan struct{}) +//} +// +//func (m mockPeer) Invoke(ctx context.Context, rpc string, enc drpc.Encoding, in, out drpc.Message) error { +// return nil +//} +// +//func (m mockPeer) NewStream(ctx context.Context, rpc string, enc drpc.Encoding) (drpc.Stream, error) { +// return nil, nil +//} +// +//func newPushSpaceRequestMatcher( +// spaceId string, +// aclRootId string, +// settingsId string, +// credential []byte, +// spaceHeader *spacesyncproto.RawSpaceHeaderWithId) *pushSpaceRequestMatcher { +// return &pushSpaceRequestMatcher{ +// spaceId: spaceId, +// aclRootId: aclRootId, +// settingsId: settingsId, +// credential: credential, +// spaceHeader: spaceHeader, +// } +//} +// +//func TestDiffSyncer_Sync(t *testing.T) { +// // setup +// ctx := context.Background() +// ctrl := gomock.NewController(t) +// defer ctrl.Finish() +// +// diffMock := mock_ldiff.NewMockDiff(ctrl) +// peerManagerMock := mock_peermanager.NewMockPeerManager(ctrl) +// cacheMock := mock_treemanager.NewMockTreeManager(ctrl) +// stMock := mock_spacestorage.NewMockSpaceStorage(ctrl) +// clientMock := mock_spacesyncproto.NewMockDRPCSpaceSyncClient(ctrl) +// factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceSyncClient { +// return clientMock +// }) +// treeSyncerMock := mock_treemanager.NewMockTreeSyncer(ctrl) +// credentialProvider := mock_credentialprovider.NewMockCredentialProvider(ctrl) +// delState := mock_settingsstate.NewMockObjectDeletionState(ctrl) +// spaceId := "spaceId" +// aclRootId := "aclRootId" +// l := logger.NewNamed(spaceId) +// diffSyncer := newDiffSyncer(spaceId, diffMock, peerManagerMock, cacheMock, stMock, factory, syncstatus.NewNoOpSyncStatus(), credentialProvider, l) +// delState.EXPECT().AddObserver(gomock.Any()) +// cacheMock.EXPECT().NewTreeSyncer(spaceId, gomock.Any()).Return(treeSyncerMock) +// diffSyncer.Init(delState) +// +// t.Run("diff syncer sync", func(t *testing.T) { +// mPeer := mockPeer{} +// peerManagerMock.EXPECT(). +// GetResponsiblePeers(gomock.Any()). +// Return([]peer.Peer{mPeer}, nil) +// diffMock.EXPECT(). +// Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))). +// Return([]string{"new"}, []string{"changed"}, nil, nil) +// delState.EXPECT().Filter([]string{"new"}).Return([]string{"new"}).Times(1) +// delState.EXPECT().Filter([]string{"changed"}).Return([]string{"changed"}).Times(1) +// delState.EXPECT().Filter(nil).Return(nil).Times(1) +// treeSyncerMock.EXPECT().SyncAll(gomock.Any(), mPeer.Id(), []string{"changed"}, []string{"new"}).Return(nil) +// require.NoError(t, diffSyncer.Sync(ctx)) +// }) +// +// t.Run("diff syncer sync conf error", func(t *testing.T) { +// peerManagerMock.EXPECT(). +// GetResponsiblePeers(gomock.Any()). +// Return(nil, fmt.Errorf("some error")) +// +// require.Error(t, diffSyncer.Sync(ctx)) +// }) +// +// t.Run("deletion state remove objects", func(t *testing.T) { +// deletedId := "id" +// delState.EXPECT().Exists(deletedId).Return(true) +// +// // this should not result in any mock being called +// diffSyncer.UpdateHeads(deletedId, []string{"someHead"}) +// }) +// +// t.Run("update heads updates diff", func(t *testing.T) { +// newId := "newId" +// newHeads := []string{"h1", "h2"} +// hash := "hash" +// diffMock.EXPECT().Set(ldiff.Element{ +// Id: newId, +// Head: concatStrings(newHeads), +// }) +// diffMock.EXPECT().Hash().Return(hash) +// delState.EXPECT().Exists(newId).Return(false) +// stMock.EXPECT().WriteSpaceHash(hash) +// diffSyncer.UpdateHeads(newId, newHeads) +// }) +// +// t.Run("diff syncer sync space missing", func(t *testing.T) { +// aclStorageMock := mock_liststorage.NewMockListStorage(ctrl) +// settingsStorage := mock_treestorage.NewMockTreeStorage(ctrl) +// settingsId := "settingsId" +// aclRoot := &aclrecordproto.RawAclRecordWithId{ +// Id: aclRootId, +// } +// settingsRoot := &treechangeproto.RawTreeChangeWithId{ +// Id: settingsId, +// } +// spaceHeader := &spacesyncproto.RawSpaceHeaderWithId{} +// spaceSettingsId := "spaceSettingsId" +// credential := []byte("credential") +// +// peerManagerMock.EXPECT(). +// GetResponsiblePeers(gomock.Any()). +// Return([]peer.Peer{mockPeer{}}, nil) +// diffMock.EXPECT(). +// Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))). +// Return(nil, nil, nil, spacesyncproto.ErrSpaceMissing) +// +// stMock.EXPECT().AclStorage().Return(aclStorageMock, nil) +// stMock.EXPECT().SpaceHeader().Return(spaceHeader, nil) +// stMock.EXPECT().SpaceSettingsId().Return(spaceSettingsId) +// stMock.EXPECT().TreeStorage(spaceSettingsId).Return(settingsStorage, nil) +// +// settingsStorage.EXPECT().Root().Return(settingsRoot, nil) +// aclStorageMock.EXPECT(). +// Root(). +// Return(aclRoot, nil) +// credentialProvider.EXPECT(). +// GetCredential(gomock.Any(), spaceHeader). +// Return(credential, nil) +// clientMock.EXPECT(). +// SpacePush(gomock.Any(), newPushSpaceRequestMatcher(spaceId, aclRootId, settingsId, credential, spaceHeader)). +// Return(nil, nil) +// peerManagerMock.EXPECT().SendPeer(gomock.Any(), "mockId", gomock.Any()) +// +// require.NoError(t, diffSyncer.Sync(ctx)) +// }) +// +// t.Run("diff syncer sync unexpected", func(t *testing.T) { +// peerManagerMock.EXPECT(). +// GetResponsiblePeers(gomock.Any()). +// Return([]peer.Peer{mockPeer{}}, nil) +// diffMock.EXPECT(). +// Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))). +// Return(nil, nil, nil, spacesyncproto.ErrUnexpected) +// +// require.NoError(t, diffSyncer.Sync(ctx)) +// }) +// +// t.Run("diff syncer sync space is deleted error", func(t *testing.T) { +// mPeer := mockPeer{} +// peerManagerMock.EXPECT(). +// GetResponsiblePeers(gomock.Any()). +// Return([]peer.Peer{mPeer}, nil) +// diffMock.EXPECT(). +// Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))). +// Return(nil, nil, nil, spacesyncproto.ErrSpaceIsDeleted) +// stMock.EXPECT().SpaceSettingsId().Return("settingsId") +// treeSyncerMock.EXPECT().SyncAll(gomock.Any(), mPeer.Id(), []string{"settingsId"}, nil).Return(nil) +// +// require.NoError(t, diffSyncer.Sync(ctx)) +// }) +//} diff --git a/commonspace/headsync/headsync.go b/commonspace/headsync/headsync.go index b838bd8b..18ed7357 100644 --- a/commonspace/headsync/headsync.go +++ b/commonspace/headsync/headsync.go @@ -1,3 +1,4 @@ +//go:generate mockgen -destination mock_headsync/mock_headsync.go github.com/anyproto/any-sync/commonspace/headsync DiffSyncer package headsync import ( @@ -65,6 +66,8 @@ func New() HeadSync { return &headSync{} } +var createDiffSyncer = newDiffSyncer + func (h *headSync) Init(a *app.App) (err error) { shared := a.MustComponent(spacestate.CName).(*spacestate.SpaceState) cfg := a.MustComponent("config").(config2.ConfigGetter) @@ -80,7 +83,7 @@ func (h *headSync) Init(a *app.App) (err error) { h.syncStatus = a.MustComponent(syncstatus.CName).(syncstatus.StatusService) h.treeManager = a.MustComponent(treemanager.CName).(treemanager.TreeManager) h.deletionState = a.MustComponent(deletionstate.CName).(deletionstate.ObjectDeletionState) - h.syncer = newDiffSyncer(h) + h.syncer = createDiffSyncer(h) sync := func(ctx context.Context) (err error) { // for clients cancelling the sync process if h.spaceIsDeleted.Load() && !h.configuration.IsResponsible(h.spaceId) { diff --git a/commonspace/headsync/headsync_test.go b/commonspace/headsync/headsync_test.go index ae2c419a..cdb4b293 100644 --- a/commonspace/headsync/headsync_test.go +++ b/commonspace/headsync/headsync_test.go @@ -1,71 +1,164 @@ package headsync import ( - "github.com/anyproto/any-sync/app/ldiff" - "github.com/anyproto/any-sync/app/ldiff/mock_ldiff" - "github.com/anyproto/any-sync/app/logger" + "context" + "github.com/anyproto/any-sync/app" + "github.com/anyproto/any-sync/commonspace/config" + "github.com/anyproto/any-sync/commonspace/credentialprovider" + "github.com/anyproto/any-sync/commonspace/credentialprovider/mock_credentialprovider" + "github.com/anyproto/any-sync/commonspace/deletionstate" + "github.com/anyproto/any-sync/commonspace/deletionstate/mock_deletionstate" "github.com/anyproto/any-sync/commonspace/headsync/mock_headsync" "github.com/anyproto/any-sync/commonspace/object/tree/treestorage/mock_treestorage" - "github.com/anyproto/any-sync/commonspace/settings/settingsstate/mock_settingsstate" + "github.com/anyproto/any-sync/commonspace/object/treemanager" + "github.com/anyproto/any-sync/commonspace/object/treemanager/mock_treemanager" + "github.com/anyproto/any-sync/commonspace/peermanager" + "github.com/anyproto/any-sync/commonspace/peermanager/mock_peermanager" + "github.com/anyproto/any-sync/commonspace/spacestate" + "github.com/anyproto/any-sync/commonspace/spacestorage" "github.com/anyproto/any-sync/commonspace/spacestorage/mock_spacestorage" - "github.com/anyproto/any-sync/util/periodicsync/mock_periodicsync" + "github.com/anyproto/any-sync/commonspace/syncstatus" + "github.com/anyproto/any-sync/nodeconf" + "github.com/anyproto/any-sync/nodeconf/mock_nodeconf" "github.com/golang/mock/gomock" + "github.com/stretchr/testify/require" + "sync/atomic" "testing" ) -func TestDiffService(t *testing.T) { - ctrl := gomock.NewController(t) - defer ctrl.Finish() +type mockConfig struct { +} - spaceId := "spaceId" - l := logger.NewNamed("sync") - pSyncMock := mock_periodicsync.NewMockPeriodicSync(ctrl) - storageMock := mock_spacestorage.NewMockSpaceStorage(ctrl) - treeStorageMock := mock_treestorage.NewMockTreeStorage(ctrl) - diffMock := mock_ldiff.NewMockDiff(ctrl) - syncer := mock_headsync.NewMockDiffSyncer(ctrl) - delState := mock_settingsstate.NewMockObjectDeletionState(ctrl) - syncPeriod := 1 - initId := "initId" +func (m mockConfig) Init(a *app.App) (err error) { + return nil +} - service := &headSync{ - spaceId: spaceId, - storage: storageMock, - periodicSync: pSyncMock, - syncer: syncer, - diff: diffMock, - log: l, - syncPeriod: syncPeriod, +func (m mockConfig) Name() (name string) { + return "config" +} + +func (m mockConfig) GetSpace() config.Config { + return config.Config{} +} + +type headSyncFixture struct { + spaceState *spacestate.SpaceState + ctrl *gomock.Controller + app *app.App + + configurationMock *mock_nodeconf.MockService + storageMock *mock_spacestorage.MockSpaceStorage + peerManagerMock *mock_peermanager.MockPeerManager + credentialProviderMock *mock_credentialprovider.MockCredentialProvider + syncStatus syncstatus.StatusService + treeManagerMock *mock_treemanager.MockTreeManager + deletionStateMock *mock_deletionstate.MockObjectDeletionState + diffSyncerMock *mock_headsync.MockDiffSyncer + treeSyncerMock *mock_treemanager.MockTreeSyncer + headSync *headSync + diffSyncer DiffSyncer +} + +func newHeadSyncFixture(t *testing.T) *headSyncFixture { + spaceState := &spacestate.SpaceState{ + SpaceId: "spaceId", + SpaceIsDeleted: &atomic.Bool{}, } + ctrl := gomock.NewController(t) + configurationMock := mock_nodeconf.NewMockService(ctrl) + configurationMock.EXPECT().Name().AnyTimes().Return(nodeconf.CName) + storageMock := mock_spacestorage.NewMockSpaceStorage(ctrl) + storageMock.EXPECT().Name().AnyTimes().Return(spacestorage.CName) + peerManagerMock := mock_peermanager.NewMockPeerManager(ctrl) + peerManagerMock.EXPECT().Name().AnyTimes().Return(peermanager.CName) + credentialProviderMock := mock_credentialprovider.NewMockCredentialProvider(ctrl) + credentialProviderMock.EXPECT().Name().AnyTimes().Return(credentialprovider.CName) + syncStatus := syncstatus.NewNoOpSyncStatus() + treeManagerMock := mock_treemanager.NewMockTreeManager(ctrl) + treeManagerMock.EXPECT().Name().AnyTimes().Return(treemanager.CName) + deletionStateMock := mock_deletionstate.NewMockObjectDeletionState(ctrl) + deletionStateMock.EXPECT().Name().AnyTimes().Return(deletionstate.CName) + diffSyncerMock := mock_headsync.NewMockDiffSyncer(ctrl) + treeSyncerMock := mock_treemanager.NewMockTreeSyncer(ctrl) + hs := &headSync{} + a := &app.App{} + a.Register(spaceState). + Register(mockConfig{}). + Register(configurationMock). + Register(storageMock). + Register(peerManagerMock). + Register(credentialProviderMock). + Register(syncStatus). + Register(treeManagerMock). + Register(deletionStateMock). + Register(hs) + return &headSyncFixture{ + spaceState: spaceState, + ctrl: ctrl, + app: a, + configurationMock: configurationMock, + storageMock: storageMock, + peerManagerMock: peerManagerMock, + credentialProviderMock: credentialProviderMock, + syncStatus: syncStatus, + treeManagerMock: treeManagerMock, + deletionStateMock: deletionStateMock, + headSync: hs, + diffSyncerMock: diffSyncerMock, + treeSyncerMock: treeSyncerMock, + } +} - t.Run("init", func(t *testing.T) { - storageMock.EXPECT().TreeStorage(initId).Return(treeStorageMock, nil) - treeStorageMock.EXPECT().Heads().Return([]string{"h1", "h2"}, nil) - syncer.EXPECT().Init(delState) - diffMock.EXPECT().Set(ldiff.Element{ - Id: initId, - Head: "h1h2", - }) - hash := "123" - diffMock.EXPECT().Hash().Return(hash) - storageMock.EXPECT().WriteSpaceHash(hash) - pSyncMock.EXPECT().Run() - service.Init([]string{initId}, delState) +func (fx *headSyncFixture) init(t *testing.T) { + createDiffSyncer = func(hs *headSync) DiffSyncer { + return fx.diffSyncerMock + } + fx.diffSyncerMock.EXPECT().Init() + err := fx.headSync.Init(fx.app) + require.NoError(t, err) +} + +func (fx *headSyncFixture) stop() { + fx.ctrl.Finish() +} + +func TestHeadSync(t *testing.T) { + ctx := context.Background() + + t.Run("run close", func(t *testing.T) { + fx := newHeadSyncFixture(t) + fx.init(t) + defer fx.stop() + + ids := []string{"id1"} + treeMock := mock_treestorage.NewMockTreeStorage(fx.ctrl) + fx.storageMock.EXPECT().StoredIds().Return(ids, nil) + fx.storageMock.EXPECT().TreeStorage(ids[0]).Return(treeMock, nil) + treeMock.EXPECT().Heads().Return([]string{"h1"}, nil) + fx.storageMock.EXPECT().WriteSpaceHash(gomock.Any()).Return(nil) + fx.diffSyncerMock.EXPECT().Sync(gomock.Any()).Return(nil) + fx.diffSyncerMock.EXPECT().Close().Return(nil) + err := fx.headSync.Run(ctx) + require.NoError(t, err) + err = fx.headSync.Close(ctx) + require.NoError(t, err) }) t.Run("update heads", func(t *testing.T) { - syncer.EXPECT().UpdateHeads(initId, []string{"h1", "h2"}) - service.UpdateHeads(initId, []string{"h1", "h2"}) + fx := newHeadSyncFixture(t) + fx.init(t) + defer fx.stop() + + fx.diffSyncerMock.EXPECT().UpdateHeads("id1", []string{"h1"}) + fx.headSync.UpdateHeads("id1", []string{"h1"}) }) t.Run("remove objects", func(t *testing.T) { - syncer.EXPECT().RemoveObjects([]string{"h1", "h2"}) - service.RemoveObjects([]string{"h1", "h2"}) - }) + fx := newHeadSyncFixture(t) + fx.init(t) + defer fx.stop() - t.Run("close", func(t *testing.T) { - pSyncMock.EXPECT().Close() - syncer.EXPECT().Close() - service.Close() + fx.diffSyncerMock.EXPECT().RemoveObjects([]string{"id1"}) + fx.headSync.RemoveObjects([]string{"id1"}) }) } diff --git a/commonspace/headsync/mock_headsync/mock_headsync.go b/commonspace/headsync/mock_headsync/mock_headsync.go index 7df2fe64..46b16aab 100644 --- a/commonspace/headsync/mock_headsync/mock_headsync.go +++ b/commonspace/headsync/mock_headsync/mock_headsync.go @@ -8,7 +8,6 @@ import ( context "context" reflect "reflect" - settingsstate "github.com/anyproto/any-sync/commonspace/settings/settingsstate" gomock "github.com/golang/mock/gomock" ) @@ -50,15 +49,15 @@ func (mr *MockDiffSyncerMockRecorder) Close() *gomock.Call { } // Init mocks base method. -func (m *MockDiffSyncer) Init(arg0 settingsstate.ObjectDeletionState) { +func (m *MockDiffSyncer) Init() { m.ctrl.T.Helper() - m.ctrl.Call(m, "Init", arg0) + m.ctrl.Call(m, "Init") } // Init indicates an expected call of Init. -func (mr *MockDiffSyncerMockRecorder) Init(arg0 interface{}) *gomock.Call { +func (mr *MockDiffSyncerMockRecorder) Init() *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockDiffSyncer)(nil).Init), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockDiffSyncer)(nil).Init)) } // RemoveObjects mocks base method. diff --git a/commonspace/objectsync/mock_objectsync/mock_objectsync.go b/commonspace/objectsync/mock_objectsync/mock_objectsync.go index e11f04a9..2858c6f9 100644 --- a/commonspace/objectsync/mock_objectsync/mock_objectsync.go +++ b/commonspace/objectsync/mock_objectsync/mock_objectsync.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/anyproto/any-sync/commonspace/objectsync (interfaces: SyncClient) +// Source: github.com/anyproto/any-sync/commonspace/objectsync (interfaces: ObjectSync) // Package mock_objectsync is a generated GoMock package. package mock_objectsync @@ -7,131 +7,146 @@ package mock_objectsync import ( context "context" reflect "reflect" + time "time" - objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree" - treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto" + app "github.com/anyproto/any-sync/app" + objectsync "github.com/anyproto/any-sync/commonspace/objectsync" spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto" gomock "github.com/golang/mock/gomock" ) -// MockSyncClient is a mock of SyncClient interface. -type MockSyncClient struct { +// MockObjectSync is a mock of ObjectSync interface. +type MockObjectSync struct { ctrl *gomock.Controller - recorder *MockSyncClientMockRecorder + recorder *MockObjectSyncMockRecorder } -// MockSyncClientMockRecorder is the mock recorder for MockSyncClient. -type MockSyncClientMockRecorder struct { - mock *MockSyncClient +// MockObjectSyncMockRecorder is the mock recorder for MockObjectSync. +type MockObjectSyncMockRecorder struct { + mock *MockObjectSync } -// NewMockSyncClient creates a new mock instance. -func NewMockSyncClient(ctrl *gomock.Controller) *MockSyncClient { - mock := &MockSyncClient{ctrl: ctrl} - mock.recorder = &MockSyncClientMockRecorder{mock} +// NewMockObjectSync creates a new mock instance. +func NewMockObjectSync(ctrl *gomock.Controller) *MockObjectSync { + mock := &MockObjectSync{ctrl: ctrl} + mock.recorder = &MockObjectSyncMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSyncClient) EXPECT() *MockSyncClientMockRecorder { +func (m *MockObjectSync) EXPECT() *MockObjectSyncMockRecorder { return m.recorder } -// Broadcast mocks base method. -func (m *MockSyncClient) Broadcast(arg0 context.Context, arg1 *treechangeproto.TreeSyncMessage) { +// Close mocks base method. +func (m *MockObjectSync) Close(arg0 context.Context) error { m.ctrl.T.Helper() - m.ctrl.Call(m, "Broadcast", arg0, arg1) -} - -// Broadcast indicates an expected call of Broadcast. -func (mr *MockSyncClientMockRecorder) Broadcast(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockSyncClient)(nil).Broadcast), arg0, arg1) -} - -// CreateFullSyncRequest mocks base method. -func (m *MockSyncClient) CreateFullSyncRequest(arg0 objecttree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateFullSyncRequest", arg0, arg1, arg2) - ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateFullSyncRequest indicates an expected call of CreateFullSyncRequest. -func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncRequest), arg0, arg1, arg2) -} - -// CreateFullSyncResponse mocks base method. -func (m *MockSyncClient) CreateFullSyncResponse(arg0 objecttree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateFullSyncResponse", arg0, arg1, arg2) - ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateFullSyncResponse indicates an expected call of CreateFullSyncResponse. -func (mr *MockSyncClientMockRecorder) CreateFullSyncResponse(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncResponse", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncResponse), arg0, arg1, arg2) -} - -// CreateHeadUpdate mocks base method. -func (m *MockSyncClient) CreateHeadUpdate(arg0 objecttree.ObjectTree, arg1 []*treechangeproto.RawTreeChangeWithId) *treechangeproto.TreeSyncMessage { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateHeadUpdate", arg0, arg1) - ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage) + ret := m.ctrl.Call(m, "Close", arg0) + ret0, _ := ret[0].(error) return ret0 } -// CreateHeadUpdate indicates an expected call of CreateHeadUpdate. -func (mr *MockSyncClientMockRecorder) CreateHeadUpdate(arg0, arg1 interface{}) *gomock.Call { +// Close indicates an expected call of Close. +func (mr *MockObjectSyncMockRecorder) Close(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockSyncClient)(nil).CreateHeadUpdate), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockObjectSync)(nil).Close), arg0) } -// CreateNewTreeRequest mocks base method. -func (m *MockSyncClient) CreateNewTreeRequest() *treechangeproto.TreeSyncMessage { +// CloseThread mocks base method. +func (m *MockObjectSync) CloseThread(arg0 string) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNewTreeRequest") - ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage) + ret := m.ctrl.Call(m, "CloseThread", arg0) + ret0, _ := ret[0].(error) return ret0 } -// CreateNewTreeRequest indicates an expected call of CreateNewTreeRequest. -func (mr *MockSyncClientMockRecorder) CreateNewTreeRequest() *gomock.Call { +// CloseThread indicates an expected call of CloseThread. +func (mr *MockObjectSyncMockRecorder) CloseThread(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNewTreeRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateNewTreeRequest)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseThread", reflect.TypeOf((*MockObjectSync)(nil).CloseThread), arg0) } -// SendSync mocks base method. -func (m *MockSyncClient) SendSync(arg0 context.Context, arg1, arg2 string, arg3 *treechangeproto.TreeSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) { +// HandleMessage mocks base method. +func (m *MockObjectSync) HandleMessage(arg0 context.Context, arg1 objectsync.HandleMessage) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendSync", arg0, arg1, arg2, arg3) + ret := m.ctrl.Call(m, "HandleMessage", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// HandleMessage indicates an expected call of HandleMessage. +func (mr *MockObjectSyncMockRecorder) HandleMessage(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockObjectSync)(nil).HandleMessage), arg0, arg1) +} + +// HandleRequest mocks base method. +func (m *MockObjectSync) HandleRequest(arg0 context.Context, arg1 *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HandleRequest", arg0, arg1) ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage) ret1, _ := ret[1].(error) return ret0, ret1 } -// SendSync indicates an expected call of SendSync. -func (mr *MockSyncClientMockRecorder) SendSync(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { +// HandleRequest indicates an expected call of HandleRequest. +func (mr *MockObjectSyncMockRecorder) HandleRequest(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendSync", reflect.TypeOf((*MockSyncClient)(nil).SendSync), arg0, arg1, arg2, arg3) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRequest", reflect.TypeOf((*MockObjectSync)(nil).HandleRequest), arg0, arg1) } -// SendWithReply mocks base method. -func (m *MockSyncClient) SendWithReply(arg0 context.Context, arg1, arg2 string, arg3 *treechangeproto.TreeSyncMessage, arg4 string) error { +// Init mocks base method. +func (m *MockObjectSync) Init(arg0 *app.App) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendWithReply", arg0, arg1, arg2, arg3, arg4) + ret := m.ctrl.Call(m, "Init", arg0) ret0, _ := ret[0].(error) return ret0 } -// SendWithReply indicates an expected call of SendWithReply. -func (mr *MockSyncClientMockRecorder) SendWithReply(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { +// Init indicates an expected call of Init. +func (mr *MockObjectSyncMockRecorder) Init(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendWithReply", reflect.TypeOf((*MockSyncClient)(nil).SendWithReply), arg0, arg1, arg2, arg3, arg4) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockObjectSync)(nil).Init), arg0) +} + +// LastUsage mocks base method. +func (m *MockObjectSync) LastUsage() time.Time { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LastUsage") + ret0, _ := ret[0].(time.Time) + return ret0 +} + +// LastUsage indicates an expected call of LastUsage. +func (mr *MockObjectSyncMockRecorder) LastUsage() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastUsage", reflect.TypeOf((*MockObjectSync)(nil).LastUsage)) +} + +// Name mocks base method. +func (m *MockObjectSync) 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 *MockObjectSyncMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockObjectSync)(nil).Name)) +} + +// Run mocks base method. +func (m *MockObjectSync) 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 *MockObjectSyncMockRecorder) Run(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockObjectSync)(nil).Run), arg0) } diff --git a/commonspace/objectsync/objectsync.go b/commonspace/objectsync/objectsync.go index 386cbb15..d2febaee 100644 --- a/commonspace/objectsync/objectsync.go +++ b/commonspace/objectsync/objectsync.go @@ -1,4 +1,4 @@ -//go:generate mockgen -destination mock_objectsync/mock_objectsync.go github.com/anyproto/any-sync/commonspace/objectsync SyncClient +//go:generate mockgen -destination mock_objectsync/mock_objectsync.go github.com/anyproto/any-sync/commonspace/objectsync ObjectSync package objectsync import ( diff --git a/commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go b/commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go new file mode 100644 index 00000000..d7cca965 --- /dev/null +++ b/commonspace/objecttreebuilder/mock_objecttreebuilder/mock_objecttreebuilder.go @@ -0,0 +1,99 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/anyproto/any-sync/commonspace/objecttreebuilder (interfaces: TreeBuilder) + +// Package mock_objecttreebuilder is a generated GoMock package. +package mock_objecttreebuilder + +import ( + context "context" + reflect "reflect" + + objecttree "github.com/anyproto/any-sync/commonspace/object/tree/objecttree" + updatelistener "github.com/anyproto/any-sync/commonspace/object/tree/synctree/updatelistener" + treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage" + objecttreebuilder "github.com/anyproto/any-sync/commonspace/objecttreebuilder" + gomock "github.com/golang/mock/gomock" +) + +// MockTreeBuilder is a mock of TreeBuilder interface. +type MockTreeBuilder struct { + ctrl *gomock.Controller + recorder *MockTreeBuilderMockRecorder +} + +// MockTreeBuilderMockRecorder is the mock recorder for MockTreeBuilder. +type MockTreeBuilderMockRecorder struct { + mock *MockTreeBuilder +} + +// NewMockTreeBuilder creates a new mock instance. +func NewMockTreeBuilder(ctrl *gomock.Controller) *MockTreeBuilder { + mock := &MockTreeBuilder{ctrl: ctrl} + mock.recorder = &MockTreeBuilderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockTreeBuilder) EXPECT() *MockTreeBuilderMockRecorder { + return m.recorder +} + +// BuildHistoryTree mocks base method. +func (m *MockTreeBuilder) BuildHistoryTree(arg0 context.Context, arg1 string, arg2 objecttreebuilder.HistoryTreeOpts) (objecttree.HistoryTree, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BuildHistoryTree", arg0, arg1, arg2) + ret0, _ := ret[0].(objecttree.HistoryTree) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BuildHistoryTree indicates an expected call of BuildHistoryTree. +func (mr *MockTreeBuilderMockRecorder) BuildHistoryTree(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildHistoryTree", reflect.TypeOf((*MockTreeBuilder)(nil).BuildHistoryTree), arg0, arg1, arg2) +} + +// BuildTree mocks base method. +func (m *MockTreeBuilder) BuildTree(arg0 context.Context, arg1 string, arg2 objecttreebuilder.BuildTreeOpts) (objecttree.ObjectTree, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BuildTree", arg0, arg1, arg2) + ret0, _ := ret[0].(objecttree.ObjectTree) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BuildTree indicates an expected call of BuildTree. +func (mr *MockTreeBuilderMockRecorder) BuildTree(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildTree", reflect.TypeOf((*MockTreeBuilder)(nil).BuildTree), arg0, arg1, arg2) +} + +// CreateTree mocks base method. +func (m *MockTreeBuilder) CreateTree(arg0 context.Context, arg1 objecttree.ObjectTreeCreatePayload) (treestorage.TreeStorageCreatePayload, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateTree", arg0, arg1) + ret0, _ := ret[0].(treestorage.TreeStorageCreatePayload) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateTree indicates an expected call of CreateTree. +func (mr *MockTreeBuilderMockRecorder) CreateTree(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTree", reflect.TypeOf((*MockTreeBuilder)(nil).CreateTree), arg0, arg1) +} + +// PutTree mocks base method. +func (m *MockTreeBuilder) PutTree(arg0 context.Context, arg1 treestorage.TreeStorageCreatePayload, arg2 updatelistener.UpdateListener) (objecttree.ObjectTree, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutTree", arg0, arg1, arg2) + ret0, _ := ret[0].(objecttree.ObjectTree) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutTree indicates an expected call of PutTree. +func (mr *MockTreeBuilderMockRecorder) PutTree(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutTree", reflect.TypeOf((*MockTreeBuilder)(nil).PutTree), arg0, arg1, arg2) +} diff --git a/commonspace/objecttreebuilder/treebuilder.go b/commonspace/objecttreebuilder/treebuilder.go index 15f9bdbf..058efe16 100644 --- a/commonspace/objecttreebuilder/treebuilder.go +++ b/commonspace/objecttreebuilder/treebuilder.go @@ -1,3 +1,4 @@ +//go:generate mockgen -destination mock_objecttreebuilder/mock_objecttreebuilder.go github.com/anyproto/any-sync/commonspace/objecttreebuilder TreeBuilder package objecttreebuilder import ( diff --git a/commonspace/peermanager/mock_peermanager/mock_peermanager.go b/commonspace/peermanager/mock_peermanager/mock_peermanager.go index a77e0ab1..210fb319 100644 --- a/commonspace/peermanager/mock_peermanager/mock_peermanager.go +++ b/commonspace/peermanager/mock_peermanager/mock_peermanager.go @@ -8,6 +8,7 @@ import ( context "context" reflect "reflect" + app "github.com/anyproto/any-sync/app" spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto" peer "github.com/anyproto/any-sync/net/peer" gomock "github.com/golang/mock/gomock" @@ -65,6 +66,34 @@ func (mr *MockPeerManagerMockRecorder) GetResponsiblePeers(arg0 interface{}) *go return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResponsiblePeers", reflect.TypeOf((*MockPeerManager)(nil).GetResponsiblePeers), arg0) } +// Init mocks base method. +func (m *MockPeerManager) 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 *MockPeerManagerMockRecorder) Init(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockPeerManager)(nil).Init), arg0) +} + +// Name mocks base method. +func (m *MockPeerManager) 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 *MockPeerManagerMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockPeerManager)(nil).Name)) +} + // SendPeer mocks base method. func (m *MockPeerManager) SendPeer(arg0 context.Context, arg1 string, arg2 *spacesyncproto.ObjectSyncMessage) error { m.ctrl.T.Helper() diff --git a/commonspace/requestmanager/requestmanager_test.go b/commonspace/requestmanager/requestmanager_test.go new file mode 100644 index 00000000..e5e89798 --- /dev/null +++ b/commonspace/requestmanager/requestmanager_test.go @@ -0,0 +1 @@ +package requestmanager diff --git a/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go b/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go index 0bc9bf23..2bb898cf 100644 --- a/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go +++ b/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/anyproto/any-sync/commonspace/settings/settingsstate (interfaces: ObjectDeletionState,StateBuilder,ChangeFactory) +// Source: github.com/anyproto/any-sync/commonspace/settings/settingsstate (interfaces: StateBuilder,ChangeFactory) // Package mock_settingsstate is a generated GoMock package. package mock_settingsstate @@ -12,109 +12,6 @@ import ( gomock "github.com/golang/mock/gomock" ) -// MockObjectDeletionState is a mock of ObjectDeletionState interface. -type MockObjectDeletionState struct { - ctrl *gomock.Controller - recorder *MockObjectDeletionStateMockRecorder -} - -// MockObjectDeletionStateMockRecorder is the mock recorder for MockObjectDeletionState. -type MockObjectDeletionStateMockRecorder struct { - mock *MockObjectDeletionState -} - -// NewMockObjectDeletionState creates a new mock instance. -func NewMockObjectDeletionState(ctrl *gomock.Controller) *MockObjectDeletionState { - mock := &MockObjectDeletionState{ctrl: ctrl} - mock.recorder = &MockObjectDeletionStateMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockObjectDeletionState) EXPECT() *MockObjectDeletionStateMockRecorder { - return m.recorder -} - -// Add mocks base method. -func (m *MockObjectDeletionState) Add(arg0 map[string]struct{}) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Add", arg0) -} - -// Add indicates an expected call of Add. -func (mr *MockObjectDeletionStateMockRecorder) Add(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockObjectDeletionState)(nil).Add), arg0) -} - -// AddObserver mocks base method. -func (m *MockObjectDeletionState) AddObserver(arg0 settingsstate.StateUpdateObserver) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "AddObserver", arg0) -} - -// AddObserver indicates an expected call of AddObserver. -func (mr *MockObjectDeletionStateMockRecorder) AddObserver(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddObserver", reflect.TypeOf((*MockObjectDeletionState)(nil).AddObserver), arg0) -} - -// Delete mocks base method. -func (m *MockObjectDeletionState) Delete(arg0 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// Delete indicates an expected call of Delete. -func (mr *MockObjectDeletionStateMockRecorder) Delete(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockObjectDeletionState)(nil).Delete), arg0) -} - -// Exists mocks base method. -func (m *MockObjectDeletionState) Exists(arg0 string) bool { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Exists", arg0) - ret0, _ := ret[0].(bool) - return ret0 -} - -// Exists indicates an expected call of Exists. -func (mr *MockObjectDeletionStateMockRecorder) Exists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockObjectDeletionState)(nil).Exists), arg0) -} - -// Filter mocks base method. -func (m *MockObjectDeletionState) Filter(arg0 []string) []string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Filter", arg0) - ret0, _ := ret[0].([]string) - return ret0 -} - -// Filter indicates an expected call of Filter. -func (mr *MockObjectDeletionStateMockRecorder) Filter(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Filter", reflect.TypeOf((*MockObjectDeletionState)(nil).Filter), arg0) -} - -// GetQueued mocks base method. -func (m *MockObjectDeletionState) GetQueued() []string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetQueued") - ret0, _ := ret[0].([]string) - return ret0 -} - -// GetQueued indicates an expected call of GetQueued. -func (mr *MockObjectDeletionStateMockRecorder) GetQueued() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueued", reflect.TypeOf((*MockObjectDeletionState)(nil).GetQueued)) -} - // MockStateBuilder is a mock of StateBuilder interface. type MockStateBuilder struct { ctrl *gomock.Controller diff --git a/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go b/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go index a8410488..bc7f448c 100644 --- a/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go +++ b/commonspace/spacestorage/mock_spacestorage/mock_spacestorage.go @@ -5,8 +5,10 @@ package mock_spacestorage import ( + context "context" reflect "reflect" + app "github.com/anyproto/any-sync/app" liststorage "github.com/anyproto/any-sync/commonspace/object/acl/liststorage" treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto" treestorage "github.com/anyproto/any-sync/commonspace/object/tree/treestorage" @@ -53,17 +55,17 @@ func (mr *MockSpaceStorageMockRecorder) AclStorage() *gomock.Call { } // Close mocks base method. -func (m *MockSpaceStorage) Close() error { +func (m *MockSpaceStorage) Close(arg0 context.Context) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Close") + ret := m.ctrl.Call(m, "Close", arg0) ret0, _ := ret[0].(error) return ret0 } // Close indicates an expected call of Close. -func (mr *MockSpaceStorageMockRecorder) Close() *gomock.Call { +func (mr *MockSpaceStorageMockRecorder) Close(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSpaceStorage)(nil).Close)) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSpaceStorage)(nil).Close), arg0) } // CreateTreeStorage mocks base method. @@ -110,6 +112,20 @@ func (mr *MockSpaceStorageMockRecorder) Id() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockSpaceStorage)(nil).Id)) } +// Init mocks base method. +func (m *MockSpaceStorage) 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 *MockSpaceStorageMockRecorder) Init(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpaceStorage)(nil).Init), arg0) +} + // IsSpaceDeleted mocks base method. func (m *MockSpaceStorage) IsSpaceDeleted() (bool, error) { m.ctrl.T.Helper() @@ -125,6 +141,20 @@ func (mr *MockSpaceStorageMockRecorder) IsSpaceDeleted() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSpaceDeleted", reflect.TypeOf((*MockSpaceStorage)(nil).IsSpaceDeleted)) } +// Name mocks base method. +func (m *MockSpaceStorage) 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 *MockSpaceStorageMockRecorder) Name() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockSpaceStorage)(nil).Name)) +} + // ReadSpaceHash mocks base method. func (m *MockSpaceStorage) ReadSpaceHash() (string, error) { m.ctrl.T.Helper() @@ -140,6 +170,20 @@ func (mr *MockSpaceStorageMockRecorder) ReadSpaceHash() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadSpaceHash", reflect.TypeOf((*MockSpaceStorage)(nil).ReadSpaceHash)) } +// Run mocks base method. +func (m *MockSpaceStorage) 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 *MockSpaceStorageMockRecorder) Run(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSpaceStorage)(nil).Run), arg0) +} + // SetSpaceDeleted mocks base method. func (m *MockSpaceStorage) SetSpaceDeleted() error { m.ctrl.T.Helper() diff --git a/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go b/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go index db8313a2..8d8a1111 100644 --- a/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go +++ b/commonspace/spacesyncproto/mock_spacesyncproto/mock_spacesyncproto.go @@ -65,6 +65,21 @@ func (mr *MockDRPCSpaceSyncClientMockRecorder) HeadSync(arg0, arg1 interface{}) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadSync", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).HeadSync), arg0, arg1) } +// ObjectSync mocks base method. +func (m *MockDRPCSpaceSyncClient) ObjectSync(arg0 context.Context, arg1 *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectSync", arg0, arg1) + ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ObjectSync indicates an expected call of ObjectSync. +func (mr *MockDRPCSpaceSyncClientMockRecorder) ObjectSync(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectSync", reflect.TypeOf((*MockDRPCSpaceSyncClient)(nil).ObjectSync), arg0, arg1) +} + // ObjectSyncStream mocks base method. func (m *MockDRPCSpaceSyncClient) ObjectSyncStream(arg0 context.Context) (spacesyncproto.DRPCSpaceSync_ObjectSyncStreamClient, error) { m.ctrl.T.Helper()