WIP headsync tests revive

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))
+}

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 (

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))
+}

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 {
+func (fx *headSyncFixture) initDiffSyncer(t *testing.T) {
-	spaceId     string
+	fx.init(t)
-	aclRootId   string
+	fx.diffSyncer = newDiffSyncer(fx.headSync)
-	settingsId  string
+	fx.deletionStateMock.EXPECT().AddObserver(gomock.Any())
-	credential  []byte
+	fx.treeManagerMock.EXPECT().NewTreeSyncer(fx.spaceState.SpaceId, fx.treeManagerMock).Return(fx.treeSyncerMock)
-	spaceHeader *spacesyncproto.RawSpaceHeaderWithId
+	fx.diffSyncer.Init()
 }
 
-func (p pushSpaceRequestMatcher) Matches(x interface{}) bool {
+func TestDiffSyncer(t *testing.T) {
-	res, ok := x.(*spacesyncproto.SpacePushRequest)
+	fx := newHeadSyncFixture(t)
-	if !ok {
+	fx.initDiffSyncer(t)
-		return false
+	defer fx.stop()
-	}
-
-	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 pushSpaceRequestMatcher struct {
-}
+//	spaceId     string
-
+//	aclRootId   string
-type mockPeer struct{}
+//	settingsId  string
-
+//	credential  []byte
-func (m mockPeer) Addr() string {
+//	spaceHeader *spacesyncproto.RawSpaceHeaderWithId
-	return ""
+//}
-}
+//
-
+//func (p pushSpaceRequestMatcher) Matches(x interface{}) bool {
-func (m mockPeer) TryClose(objectTTL time.Duration) (res bool, err error) {
+//	res, ok := x.(*spacesyncproto.SpacePushRequest)
-	return true, m.Close()
+//	if !ok {
-}
+//		return false
-
+//	}
-func (m mockPeer) Id() string {
+//
-	return "mockId"
+//	return res.Payload.AclPayloadId == p.aclRootId && res.Payload.SpaceHeader == p.spaceHeader && res.Payload.SpaceSettingsPayloadId == p.settingsId && bytes.Equal(p.credential, res.Credential)
-}
+//}
-
+//
-func (m mockPeer) LastUsage() time.Time {
+//func (p pushSpaceRequestMatcher) String() string {
-	return time.Time{}
+//	return ""
-}
+//}
-
+//
-func (m mockPeer) Secure() sec.SecureConn {
+//type mockPeer struct{}
-	return nil
+//
-}
+//func (m mockPeer) Addr() string {
-
+//	return ""
-func (m mockPeer) UpdateLastUsage() {
+//}
-}
+//
-
+//func (m mockPeer) TryClose(objectTTL time.Duration) (res bool, err error) {
-func (m mockPeer) Close() error {
+//	return true, m.Close()
-	return nil
+//}
-}
+//
-
+//func (m mockPeer) Id() string {
-func (m mockPeer) Closed() <-chan struct{} {
+//	return "mockId"
-	return make(chan struct{})
+//}
-}
+//
-
+//func (m mockPeer) LastUsage() time.Time {
-func (m mockPeer) Invoke(ctx context.Context, rpc string, enc drpc.Encoding, in, out drpc.Message) error {
+//	return time.Time{}
-	return nil
+//}
-}
+//
-
+//func (m mockPeer) Secure() sec.SecureConn {
-func (m mockPeer) NewStream(ctx context.Context, rpc string, enc drpc.Encoding) (drpc.Stream, error) {
+//	return nil
-	return nil, nil
+//}
-}
+//
-
+//func (m mockPeer) UpdateLastUsage() {
-func newPushSpaceRequestMatcher(
+//}
-	spaceId string,
+//
-	aclRootId string,
+//func (m mockPeer) Close() error {
-	settingsId string,
+//	return nil
-	credential []byte,
+//}
-	spaceHeader *spacesyncproto.RawSpaceHeaderWithId) *pushSpaceRequestMatcher {
+//
-	return &pushSpaceRequestMatcher{
+//func (m mockPeer) Closed() <-chan struct{} {
-		spaceId:     spaceId,
+//	return make(chan struct{})
-		aclRootId:   aclRootId,
+//}
-		settingsId:  settingsId,
+//
-		credential:  credential,
+//func (m mockPeer) Invoke(ctx context.Context, rpc string, enc drpc.Encoding, in, out drpc.Message) error {
-		spaceHeader: spaceHeader,
+//	return nil
-	}
+//}
-}
+//
-
+//func (m mockPeer) NewStream(ctx context.Context, rpc string, enc drpc.Encoding) (drpc.Stream, error) {
-func TestDiffSyncer_Sync(t *testing.T) {
+//	return nil, nil
-	// setup
+//}
-	ctx := context.Background()
+//
-	ctrl := gomock.NewController(t)
+//func newPushSpaceRequestMatcher(
-	defer ctrl.Finish()
+//	spaceId string,
-
+//	aclRootId string,
-	diffMock := mock_ldiff.NewMockDiff(ctrl)
+//	settingsId string,
-	peerManagerMock := mock_peermanager.NewMockPeerManager(ctrl)
+//	credential []byte,
-	cacheMock := mock_treemanager.NewMockTreeManager(ctrl)
+//	spaceHeader *spacesyncproto.RawSpaceHeaderWithId) *pushSpaceRequestMatcher {
-	stMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
+//	return &pushSpaceRequestMatcher{
-	clientMock := mock_spacesyncproto.NewMockDRPCSpaceSyncClient(ctrl)
+//		spaceId:     spaceId,
-	factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceSyncClient {
+//		aclRootId:   aclRootId,
-		return clientMock
+//		settingsId:  settingsId,
-	})
+//		credential:  credential,
-	treeSyncerMock := mock_treemanager.NewMockTreeSyncer(ctrl)
+//		spaceHeader: spaceHeader,
-	credentialProvider := mock_credentialprovider.NewMockCredentialProvider(ctrl)
+//	}
-	delState := mock_settingsstate.NewMockObjectDeletionState(ctrl)
+//}
-	spaceId := "spaceId"
+//
-	aclRootId := "aclRootId"
+//func TestDiffSyncer_Sync(t *testing.T) {
-	l := logger.NewNamed(spaceId)
+//	// setup
-	diffSyncer := newDiffSyncer(spaceId, diffMock, peerManagerMock, cacheMock, stMock, factory, syncstatus.NewNoOpSyncStatus(), credentialProvider, l)
+//	ctx := context.Background()
-	delState.EXPECT().AddObserver(gomock.Any())
+//	ctrl := gomock.NewController(t)
-	cacheMock.EXPECT().NewTreeSyncer(spaceId, gomock.Any()).Return(treeSyncerMock)
+//	defer ctrl.Finish()
-	diffSyncer.Init(delState)
+//
-
+//	diffMock := mock_ldiff.NewMockDiff(ctrl)
-	t.Run("diff syncer sync", func(t *testing.T) {
+//	peerManagerMock := mock_peermanager.NewMockPeerManager(ctrl)
-		mPeer := mockPeer{}
+//	cacheMock := mock_treemanager.NewMockTreeManager(ctrl)
-		peerManagerMock.EXPECT().
+//	stMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
-			GetResponsiblePeers(gomock.Any()).
+//	clientMock := mock_spacesyncproto.NewMockDRPCSpaceSyncClient(ctrl)
-			Return([]peer.Peer{mPeer}, nil)
+//	factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceSyncClient {
-		diffMock.EXPECT().
+//		return clientMock
-			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
+//	})
-			Return([]string{"new"}, []string{"changed"}, nil, nil)
+//	treeSyncerMock := mock_treemanager.NewMockTreeSyncer(ctrl)
-		delState.EXPECT().Filter([]string{"new"}).Return([]string{"new"}).Times(1)
+//	credentialProvider := mock_credentialprovider.NewMockCredentialProvider(ctrl)
-		delState.EXPECT().Filter([]string{"changed"}).Return([]string{"changed"}).Times(1)
+//	delState := mock_settingsstate.NewMockObjectDeletionState(ctrl)
-		delState.EXPECT().Filter(nil).Return(nil).Times(1)
+//	spaceId := "spaceId"
-		treeSyncerMock.EXPECT().SyncAll(gomock.Any(), mPeer.Id(), []string{"changed"}, []string{"new"}).Return(nil)
+//	aclRootId := "aclRootId"
-		require.NoError(t, diffSyncer.Sync(ctx))
+//	l := logger.NewNamed(spaceId)
-	})
+//	diffSyncer := newDiffSyncer(spaceId, diffMock, peerManagerMock, cacheMock, stMock, factory, syncstatus.NewNoOpSyncStatus(), credentialProvider, l)
-
+//	delState.EXPECT().AddObserver(gomock.Any())
-	t.Run("diff syncer sync conf error", func(t *testing.T) {
+//	cacheMock.EXPECT().NewTreeSyncer(spaceId, gomock.Any()).Return(treeSyncerMock)
-		peerManagerMock.EXPECT().
+//	diffSyncer.Init(delState)
-			GetResponsiblePeers(gomock.Any()).
+//
-			Return(nil, fmt.Errorf("some error"))
+//	t.Run("diff syncer sync", func(t *testing.T) {
-
+//		mPeer := mockPeer{}
-		require.Error(t, diffSyncer.Sync(ctx))
+//		peerManagerMock.EXPECT().
-	})
+//			GetResponsiblePeers(gomock.Any()).
-
+//			Return([]peer.Peer{mPeer}, nil)
-	t.Run("deletion state remove objects", func(t *testing.T) {
+//		diffMock.EXPECT().
-		deletedId := "id"
+//			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
-		delState.EXPECT().Exists(deletedId).Return(true)
+//			Return([]string{"new"}, []string{"changed"}, nil, nil)
-
+//		delState.EXPECT().Filter([]string{"new"}).Return([]string{"new"}).Times(1)
-		// this should not result in any mock being called
+//		delState.EXPECT().Filter([]string{"changed"}).Return([]string{"changed"}).Times(1)
-		diffSyncer.UpdateHeads(deletedId, []string{"someHead"})
+//		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("update heads updates diff", func(t *testing.T) {
+//	})
-		newId := "newId"
+//
-		newHeads := []string{"h1", "h2"}
+//	t.Run("diff syncer sync conf error", func(t *testing.T) {
-		hash := "hash"
+//		peerManagerMock.EXPECT().
-		diffMock.EXPECT().Set(ldiff.Element{
+//			GetResponsiblePeers(gomock.Any()).
-			Id:   newId,
+//			Return(nil, fmt.Errorf("some error"))
-			Head: concatStrings(newHeads),
+//
-		})
+//		require.Error(t, diffSyncer.Sync(ctx))
-		diffMock.EXPECT().Hash().Return(hash)
+//	})
-		delState.EXPECT().Exists(newId).Return(false)
+//
-		stMock.EXPECT().WriteSpaceHash(hash)
+//	t.Run("deletion state remove objects", func(t *testing.T) {
-		diffSyncer.UpdateHeads(newId, newHeads)
+//		deletedId := "id"
-	})
+//		delState.EXPECT().Exists(deletedId).Return(true)
-
+//
-	t.Run("diff syncer sync space missing", func(t *testing.T) {
+//		// this should not result in any mock being called
-		aclStorageMock := mock_liststorage.NewMockListStorage(ctrl)
+//		diffSyncer.UpdateHeads(deletedId, []string{"someHead"})
-		settingsStorage := mock_treestorage.NewMockTreeStorage(ctrl)
+//	})
-		settingsId := "settingsId"
+//
-		aclRoot := &aclrecordproto.RawAclRecordWithId{
+//	t.Run("update heads updates diff", func(t *testing.T) {
-			Id: aclRootId,
+//		newId := "newId"
-		}
+//		newHeads := []string{"h1", "h2"}
-		settingsRoot := &treechangeproto.RawTreeChangeWithId{
+//		hash := "hash"
-			Id: settingsId,
+//		diffMock.EXPECT().Set(ldiff.Element{
-		}
+//			Id:   newId,
-		spaceHeader := &spacesyncproto.RawSpaceHeaderWithId{}
+//			Head: concatStrings(newHeads),
-		spaceSettingsId := "spaceSettingsId"
+//		})
-		credential := []byte("credential")
+//		diffMock.EXPECT().Hash().Return(hash)
-
+//		delState.EXPECT().Exists(newId).Return(false)
-		peerManagerMock.EXPECT().
+//		stMock.EXPECT().WriteSpaceHash(hash)
-			GetResponsiblePeers(gomock.Any()).
+//		diffSyncer.UpdateHeads(newId, newHeads)
-			Return([]peer.Peer{mockPeer{}}, nil)
+//	})
-		diffMock.EXPECT().
+//
-			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
+//	t.Run("diff syncer sync space missing", func(t *testing.T) {
-			Return(nil, nil, nil, spacesyncproto.ErrSpaceMissing)
+//		aclStorageMock := mock_liststorage.NewMockListStorage(ctrl)
-
+//		settingsStorage := mock_treestorage.NewMockTreeStorage(ctrl)
-		stMock.EXPECT().AclStorage().Return(aclStorageMock, nil)
+//		settingsId := "settingsId"
-		stMock.EXPECT().SpaceHeader().Return(spaceHeader, nil)
+//		aclRoot := &aclrecordproto.RawAclRecordWithId{
-		stMock.EXPECT().SpaceSettingsId().Return(spaceSettingsId)
+//			Id: aclRootId,
-		stMock.EXPECT().TreeStorage(spaceSettingsId).Return(settingsStorage, nil)
+//		}
-
+//		settingsRoot := &treechangeproto.RawTreeChangeWithId{
-		settingsStorage.EXPECT().Root().Return(settingsRoot, nil)
+//			Id: settingsId,
-		aclStorageMock.EXPECT().
+//		}
-			Root().
+//		spaceHeader := &spacesyncproto.RawSpaceHeaderWithId{}
-			Return(aclRoot, nil)
+//		spaceSettingsId := "spaceSettingsId"
-		credentialProvider.EXPECT().
+//		credential := []byte("credential")
-			GetCredential(gomock.Any(), spaceHeader).
+//
-			Return(credential, nil)
+//		peerManagerMock.EXPECT().
-		clientMock.EXPECT().
+//			GetResponsiblePeers(gomock.Any()).
-			SpacePush(gomock.Any(), newPushSpaceRequestMatcher(spaceId, aclRootId, settingsId, credential, spaceHeader)).
+//			Return([]peer.Peer{mockPeer{}}, nil)
-			Return(nil, nil)
+//		diffMock.EXPECT().
-		peerManagerMock.EXPECT().SendPeer(gomock.Any(), "mockId", gomock.Any())
+//			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
-
+//			Return(nil, nil, nil, spacesyncproto.ErrSpaceMissing)
-		require.NoError(t, diffSyncer.Sync(ctx))
+//
-	})
+//		stMock.EXPECT().AclStorage().Return(aclStorageMock, nil)
-
+//		stMock.EXPECT().SpaceHeader().Return(spaceHeader, nil)
-	t.Run("diff syncer sync unexpected", func(t *testing.T) {
+//		stMock.EXPECT().SpaceSettingsId().Return(spaceSettingsId)
-		peerManagerMock.EXPECT().
+//		stMock.EXPECT().TreeStorage(spaceSettingsId).Return(settingsStorage, nil)
-			GetResponsiblePeers(gomock.Any()).
+//
-			Return([]peer.Peer{mockPeer{}}, nil)
+//		settingsStorage.EXPECT().Root().Return(settingsRoot, nil)
-		diffMock.EXPECT().
+//		aclStorageMock.EXPECT().
-			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
+//			Root().
-			Return(nil, nil, nil, spacesyncproto.ErrUnexpected)
+//			Return(aclRoot, nil)
-
+//		credentialProvider.EXPECT().
-		require.NoError(t, diffSyncer.Sync(ctx))
+//			GetCredential(gomock.Any(), spaceHeader).
-	})
+//			Return(credential, nil)
-
+//		clientMock.EXPECT().
-	t.Run("diff syncer sync space is deleted error", func(t *testing.T) {
+//			SpacePush(gomock.Any(), newPushSpaceRequestMatcher(spaceId, aclRootId, settingsId, credential, spaceHeader)).
-		mPeer := mockPeer{}
+//			Return(nil, nil)
-		peerManagerMock.EXPECT().
+//		peerManagerMock.EXPECT().SendPeer(gomock.Any(), "mockId", gomock.Any())
-			GetResponsiblePeers(gomock.Any()).
+//
-			Return([]peer.Peer{mPeer}, nil)
+//		require.NoError(t, diffSyncer.Sync(ctx))
-		diffMock.EXPECT().
+//	})
-			Diff(gomock.Any(), gomock.Eq(NewRemoteDiff(spaceId, clientMock))).
+//
-			Return(nil, nil, nil, spacesyncproto.ErrSpaceIsDeleted)
+//	t.Run("diff syncer sync unexpected", func(t *testing.T) {
-		stMock.EXPECT().SpaceSettingsId().Return("settingsId")
+//		peerManagerMock.EXPECT().
-		treeSyncerMock.EXPECT().SyncAll(gomock.Any(), mPeer.Id(), []string{"settingsId"}, nil).Return(nil)
+//			GetResponsiblePeers(gomock.Any()).
-
+//			Return([]peer.Peer{mockPeer{}}, nil)
-		require.NoError(t, diffSyncer.Sync(ctx))
+//		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))
+//	})
+//}

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) {

commonspace/headsync/headsync_test.go

@@ -1,71 +1,164 @@
 package headsync
 
 import (
-	"github.com/anyproto/any-sync/app/ldiff"
+	"context"
-	"github.com/anyproto/any-sync/app/ldiff/mock_ldiff"
+	"github.com/anyproto/any-sync/app"
-	"github.com/anyproto/any-sync/app/logger"
+	"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) {
+type mockConfig struct {
-	ctrl := gomock.NewController(t)
+}
-	defer ctrl.Finish()
 
-	spaceId := "spaceId"
+func (m mockConfig) Init(a *app.App) (err error) {
-	l := logger.NewNamed("sync")
+	return nil
-	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"
 
-	service := &headSync{
+func (m mockConfig) Name() (name string) {
-		spaceId:      spaceId,
+	return "config"
-		storage:      storageMock,
+}
-		periodicSync: pSyncMock,
+
-		syncer:       syncer,
+func (m mockConfig) GetSpace() config.Config {
-		diff:         diffMock,
+	return config.Config{}
-		log:          l,
+}
-		syncPeriod:   syncPeriod,
+
+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) {
+func (fx *headSyncFixture) init(t *testing.T) {
-		storageMock.EXPECT().TreeStorage(initId).Return(treeStorageMock, nil)
+	createDiffSyncer = func(hs *headSync) DiffSyncer {
-		treeStorageMock.EXPECT().Heads().Return([]string{"h1", "h2"}, nil)
+		return fx.diffSyncerMock
-		syncer.EXPECT().Init(delState)
+	}
-		diffMock.EXPECT().Set(ldiff.Element{
+	fx.diffSyncerMock.EXPECT().Init()
-			Id:   initId,
+	err := fx.headSync.Init(fx.app)
-			Head: "h1h2",
+	require.NoError(t, err)
-		})
+}
-		hash := "123"
+
-		diffMock.EXPECT().Hash().Return(hash)
+func (fx *headSyncFixture) stop() {
-		storageMock.EXPECT().WriteSpaceHash(hash)
+	fx.ctrl.Finish()
-		pSyncMock.EXPECT().Run()
+}
-		service.Init([]string{initId}, delState)
+
+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"})
+		fx := newHeadSyncFixture(t)
-		service.UpdateHeads(initId, []string{"h1", "h2"})
+		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"})
+		fx := newHeadSyncFixture(t)
-		service.RemoveObjects([]string{"h1", "h2"})
+		fx.init(t)
-	})
+		defer fx.stop()
 
-	t.Run("close", func(t *testing.T) {
+		fx.diffSyncerMock.EXPECT().RemoveObjects([]string{"id1"})
-		pSyncMock.EXPECT().Close()
+		fx.headSync.RemoveObjects([]string{"id1"})
-		syncer.EXPECT().Close()
-		service.Close()
 	})
 }

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.

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"
+	app "github.com/anyproto/any-sync/app"
-	treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
+	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.
+// MockObjectSync is a mock of ObjectSync interface.
-type MockSyncClient struct {
+type MockObjectSync struct {
 	ctrl     *gomock.Controller
-	recorder *MockSyncClientMockRecorder
+	recorder *MockObjectSyncMockRecorder
 }
 
-// MockSyncClientMockRecorder is the mock recorder for MockSyncClient.
+// MockObjectSyncMockRecorder is the mock recorder for MockObjectSync.
-type MockSyncClientMockRecorder struct {
+type MockObjectSyncMockRecorder struct {
-	mock *MockSyncClient
+	mock *MockObjectSync
 }
 
-// NewMockSyncClient creates a new mock instance.
+// NewMockObjectSync creates a new mock instance.
-func NewMockSyncClient(ctrl *gomock.Controller) *MockSyncClient {
+func NewMockObjectSync(ctrl *gomock.Controller) *MockObjectSync {
-	mock := &MockSyncClient{ctrl: ctrl}
+	mock := &MockObjectSync{ctrl: ctrl}
-	mock.recorder = &MockSyncClientMockRecorder{mock}
+	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.
+// Close mocks base method.
-func (m *MockSyncClient) Broadcast(arg0 context.Context, arg1 *treechangeproto.TreeSyncMessage) {
+func (m *MockObjectSync) Close(arg0 context.Context) error {
 	m.ctrl.T.Helper()
-	m.ctrl.Call(m, "Broadcast", arg0, arg1)
+	ret := m.ctrl.Call(m, "Close", arg0)
-}
+	ret0, _ := ret[0].(error)
-
-// 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)
 	return ret0
 }
 
-// CreateHeadUpdate indicates an expected call of CreateHeadUpdate.
+// Close indicates an expected call of Close.
-func (mr *MockSyncClientMockRecorder) CreateHeadUpdate(arg0, arg1 interface{}) *gomock.Call {
+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.
+// CloseThread mocks base method.
-func (m *MockSyncClient) CreateNewTreeRequest() *treechangeproto.TreeSyncMessage {
+func (m *MockObjectSync) CloseThread(arg0 string) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "CreateNewTreeRequest")
+	ret := m.ctrl.Call(m, "CloseThread", arg0)
-	ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage)
+	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// CreateNewTreeRequest indicates an expected call of CreateNewTreeRequest.
+// CloseThread indicates an expected call of CloseThread.
-func (mr *MockSyncClientMockRecorder) CreateNewTreeRequest() *gomock.Call {
+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.
+// HandleMessage mocks base method.
-func (m *MockSyncClient) SendSync(arg0 context.Context, arg1, arg2 string, arg3 *treechangeproto.TreeSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) {
+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.
+// HandleRequest indicates an expected call of HandleRequest.
-func (mr *MockSyncClientMockRecorder) SendSync(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+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.
+// Init mocks base method.
-func (m *MockSyncClient) SendWithReply(arg0 context.Context, arg1, arg2 string, arg3 *treechangeproto.TreeSyncMessage, arg4 string) error {
+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.
+// Init indicates an expected call of Init.
-func (mr *MockSyncClientMockRecorder) SendWithReply(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+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)
 }

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 (

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)
+}

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 (

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()

commonspace/requestmanager/requestmanager_test.go

@@ -0,0 +1 @@
+package requestmanager

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

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()

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()