Improve interfaces for synctree, generate mocks

common/account/mock_account/mock_account.go

@@ -0,0 +1,78 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/account (interfaces: Service)
+
+// Package mock_account is a generated GoMock package.
+package mock_account
+
+import (
+	reflect "reflect"
+
+	app "github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
+	account "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockService is a mock of Service interface.
+type MockService struct {
+	ctrl     *gomock.Controller
+	recorder *MockServiceMockRecorder
+}
+
+// MockServiceMockRecorder is the mock recorder for MockService.
+type MockServiceMockRecorder struct {
+	mock *MockService
+}
+
+// NewMockService creates a new mock instance.
+func NewMockService(ctrl *gomock.Controller) *MockService {
+	mock := &MockService{ctrl: ctrl}
+	mock.recorder = &MockServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockService) EXPECT() *MockServiceMockRecorder {
+	return m.recorder
+}
+
+// Account mocks base method.
+func (m *MockService) Account() *account.AccountData {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Account")
+	ret0, _ := ret[0].(*account.AccountData)
+	return ret0
+}
+
+// Account indicates an expected call of Account.
+func (mr *MockServiceMockRecorder) Account() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Account", reflect.TypeOf((*MockService)(nil).Account))
+}
+
+// Init mocks base method.
+func (m *MockService) 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 *MockServiceMockRecorder) Init(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockService)(nil).Init), arg0)
+}
+
+// Name mocks base method.
+func (m *MockService) 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 *MockServiceMockRecorder) Name() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockService)(nil).Name))
+}

common/account/service.go

@@ -1,3 +1,4 @@
+//go:generate mockgen -destination mock_account/mock_account.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/account Service
 package account
 
 import (

common/commonspace/settingsdocument/idprovider.go

@@ -1,3 +1,4 @@
+//go:generate mockgen -destination mock_settingsdocument/mock_settingsdocument.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settingsdocument DeletedIdsProvider
 package settingsdocument
 
 import (
@@ -6,7 +7,7 @@ import (
 	"github.com/gogo/protobuf/proto"
 )
 
-type deletedIdsProvider interface {
+type DeletedIdsProvider interface {
 	ProvideIds(tr tree.ObjectTree, startId string) (ids []string, lastId string, err error)
 }
 

common/commonspace/settingsdocument/mock_settingsdocument/mock_settingsdocument.go

@@ -0,0 +1,51 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settingsdocument (interfaces: DeletedIdsProvider)
+
+// Package mock_settingsdocument is a generated GoMock package.
+package mock_settingsdocument
+
+import (
+	reflect "reflect"
+
+	tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockDeletedIdsProvider is a mock of DeletedIdsProvider interface.
+type MockDeletedIdsProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockDeletedIdsProviderMockRecorder
+}
+
+// MockDeletedIdsProviderMockRecorder is the mock recorder for MockDeletedIdsProvider.
+type MockDeletedIdsProviderMockRecorder struct {
+	mock *MockDeletedIdsProvider
+}
+
+// NewMockDeletedIdsProvider creates a new mock instance.
+func NewMockDeletedIdsProvider(ctrl *gomock.Controller) *MockDeletedIdsProvider {
+	mock := &MockDeletedIdsProvider{ctrl: ctrl}
+	mock.recorder = &MockDeletedIdsProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDeletedIdsProvider) EXPECT() *MockDeletedIdsProviderMockRecorder {
+	return m.recorder
+}
+
+// ProvideIds mocks base method.
+func (m *MockDeletedIdsProvider) ProvideIds(arg0 tree.ObjectTree, arg1 string) ([]string, string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ProvideIds", arg0, arg1)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(string)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ProvideIds indicates an expected call of ProvideIds.
+func (mr *MockDeletedIdsProviderMockRecorder) ProvideIds(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvideIds", reflect.TypeOf((*MockDeletedIdsProvider)(nil).ProvideIds), arg0, arg1)
+}

common/commonspace/settingsdocument/settingsdocument.go

@@ -7,7 +7,7 @@ import (
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settingsdocument/deletionstate"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
 	spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
-	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice/synchandler"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
 	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
@@ -17,12 +17,12 @@ import (
 var log = logger.NewNamed("commonspace.settingsdocument")
 
 type SettingsDocument interface {
-	tree.ObjectTree
+	synctree.SyncTree
 	Init(ctx context.Context) (err error)
 	DeleteObject(id string) (err error)
 }
 
-type BuildTreeFunc func(ctx context.Context, id string, listener updatelistener.UpdateListener) (t tree.ObjectTree, err error)
+type BuildTreeFunc func(ctx context.Context, id string, listener updatelistener.UpdateListener) (t synctree.SyncTree, err error)
 
 type Deps struct {
 	BuildFunc     BuildTreeFunc
@@ -31,17 +31,16 @@ type Deps struct {
 	Store         spacestorage.SpaceStorage
 	DeletionState *deletionstate.DeletionState
 	// prov exists mainly for the ease of testing
-	prov deletedIdsProvider
+	prov DeletedIdsProvider
 }
 
 type settingsDocument struct {
-	tree.ObjectTree
+	synctree.SyncTree
-	synchandler.SyncHandler
 	account    account.Service
 	spaceId    string
 	treeGetter treegetter.TreeGetter
 	store      spacestorage.SpaceStorage
-	prov       deletedIdsProvider
+	prov       DeletedIdsProvider
 	buildFunc  BuildTreeFunc
 	loop       *deleteLoop
 
@@ -100,19 +99,17 @@ func (s *settingsDocument) Rebuild(tr tree.ObjectTree) {
 }
 
 func (s *settingsDocument) Init(ctx context.Context) (err error) {
-	s.ObjectTree, err = s.buildFunc(ctx, s.store.SpaceSettingsId(), s)
+	s.SyncTree, err = s.buildFunc(ctx, s.store.SpaceSettingsId(), s)
 	if err != nil {
 		return
 	}
-	// this is needed, so we would easily convert the object to synchandler interface in objectgetter
-	s.SyncHandler = s.ObjectTree.(synchandler.SyncHandler)
 	s.loop.Run()
 	return
 }
 
 func (s *settingsDocument) Close() error {
 	s.loop.Close()
-	return s.ObjectTree.Close()
+	return s.SyncTree.Close()
 }
 
 func (s *settingsDocument) DeleteObject(id string) (err error) {

common/commonspace/space.go

@@ -154,7 +154,14 @@ func (s *space) Init(ctx context.Context) (err error) {
 
 	deletionState := deletionstate.NewDeletionState(s.storage)
 	deps := settingsdocument.Deps{
-		BuildFunc:     s.BuildTree,
+		BuildFunc: func(ctx context.Context, id string, listener updatelistener.UpdateListener) (t synctree.SyncTree, err error) {
+			res, err := s.BuildTree(ctx, id, listener)
+			if err != nil {
+				return
+			}
+			t = res.(synctree.SyncTree)
+			return
+		},
 		Account:       s.account,
 		TreeGetter:    s.cache,
 		Store:         s.storage,

common/commonspace/synctree/mock_synctree/mock_synctree.go

@@ -1,12 +1,15 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree (interfaces: SyncClient)
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree (interfaces: SyncClient,SyncTree)
 
 // Package mock_synctree is a generated GoMock package.
 package mock_synctree
 
 import (
+	context "context"
 	reflect "reflect"
 
+	spacesyncproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
+	storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
 	tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
 	treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
 	gomock "github.com/golang/mock/gomock"
@@ -134,3 +137,311 @@ func (mr *MockSyncClientMockRecorder) SendAsync(arg0, arg1, arg2 interface{}) *g
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendAsync", reflect.TypeOf((*MockSyncClient)(nil).SendAsync), arg0, arg1, arg2)
 }
+
+// MockSyncTree is a mock of SyncTree interface.
+type MockSyncTree struct {
+	ctrl     *gomock.Controller
+	recorder *MockSyncTreeMockRecorder
+}
+
+// MockSyncTreeMockRecorder is the mock recorder for MockSyncTree.
+type MockSyncTreeMockRecorder struct {
+	mock *MockSyncTree
+}
+
+// NewMockSyncTree creates a new mock instance.
+func NewMockSyncTree(ctrl *gomock.Controller) *MockSyncTree {
+	mock := &MockSyncTree{ctrl: ctrl}
+	mock.recorder = &MockSyncTreeMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockSyncTree) EXPECT() *MockSyncTreeMockRecorder {
+	return m.recorder
+}
+
+// AddContent mocks base method.
+func (m *MockSyncTree) AddContent(arg0 context.Context, arg1 tree.SignableChangeContent) (tree.AddResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
+	ret0, _ := ret[0].(tree.AddResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddContent indicates an expected call of AddContent.
+func (mr *MockSyncTreeMockRecorder) AddContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockSyncTree)(nil).AddContent), arg0, arg1)
+}
+
+// AddRawChanges mocks base method.
+func (m *MockSyncTree) AddRawChanges(arg0 context.Context, arg1 ...*treechangeproto.RawTreeChangeWithId) (tree.AddResult, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0}
+	for _, a := range arg1 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AddRawChanges", varargs...)
+	ret0, _ := ret[0].(tree.AddResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddRawChanges indicates an expected call of AddRawChanges.
+func (mr *MockSyncTreeMockRecorder) AddRawChanges(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChanges", reflect.TypeOf((*MockSyncTree)(nil).AddRawChanges), varargs...)
+}
+
+// ChangesAfterCommonSnapshot mocks base method.
+func (m *MockSyncTree) ChangesAfterCommonSnapshot(arg0, arg1 []string) ([]*treechangeproto.RawTreeChangeWithId, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChangesAfterCommonSnapshot", arg0, arg1)
+	ret0, _ := ret[0].([]*treechangeproto.RawTreeChangeWithId)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ChangesAfterCommonSnapshot indicates an expected call of ChangesAfterCommonSnapshot.
+func (mr *MockSyncTreeMockRecorder) ChangesAfterCommonSnapshot(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshot", reflect.TypeOf((*MockSyncTree)(nil).ChangesAfterCommonSnapshot), arg0, arg1)
+}
+
+// Close mocks base method.
+func (m *MockSyncTree) Close() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Close")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Close indicates an expected call of Close.
+func (mr *MockSyncTreeMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSyncTree)(nil).Close))
+}
+
+// DebugDump mocks base method.
+func (m *MockSyncTree) DebugDump() (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DebugDump")
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DebugDump indicates an expected call of DebugDump.
+func (mr *MockSyncTreeMockRecorder) DebugDump() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugDump", reflect.TypeOf((*MockSyncTree)(nil).DebugDump))
+}
+
+// Delete mocks base method.
+func (m *MockSyncTree) Delete() error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete")
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Delete indicates an expected call of Delete.
+func (mr *MockSyncTreeMockRecorder) Delete() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSyncTree)(nil).Delete))
+}
+
+// HandleMessage mocks base method.
+func (m *MockSyncTree) HandleMessage(arg0 context.Context, arg1 string, arg2 *spacesyncproto.ObjectSyncMessage) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HandleMessage", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// HandleMessage indicates an expected call of HandleMessage.
+func (mr *MockSyncTreeMockRecorder) HandleMessage(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockSyncTree)(nil).HandleMessage), arg0, arg1, arg2)
+}
+
+// HasChanges mocks base method.
+func (m *MockSyncTree) HasChanges(arg0 ...string) bool {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{}
+	for _, a := range arg0 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HasChanges", varargs...)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// HasChanges indicates an expected call of HasChanges.
+func (mr *MockSyncTreeMockRecorder) HasChanges(arg0 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasChanges", reflect.TypeOf((*MockSyncTree)(nil).HasChanges), arg0...)
+}
+
+// Header mocks base method.
+func (m *MockSyncTree) Header() *treechangeproto.RawTreeChangeWithId {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Header")
+	ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
+	return ret0
+}
+
+// Header indicates an expected call of Header.
+func (mr *MockSyncTreeMockRecorder) Header() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockSyncTree)(nil).Header))
+}
+
+// Heads mocks base method.
+func (m *MockSyncTree) Heads() []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Heads")
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// Heads indicates an expected call of Heads.
+func (mr *MockSyncTreeMockRecorder) Heads() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Heads", reflect.TypeOf((*MockSyncTree)(nil).Heads))
+}
+
+// ID mocks base method.
+func (m *MockSyncTree) ID() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ID")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// ID indicates an expected call of ID.
+func (mr *MockSyncTreeMockRecorder) ID() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockSyncTree)(nil).ID))
+}
+
+// Iterate mocks base method.
+func (m *MockSyncTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*tree.Change) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Iterate", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Iterate indicates an expected call of Iterate.
+func (mr *MockSyncTreeMockRecorder) Iterate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockSyncTree)(nil).Iterate), arg0, arg1)
+}
+
+// IterateFrom mocks base method.
+func (m *MockSyncTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*tree.Change) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IterateFrom", arg0, arg1, arg2)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IterateFrom indicates an expected call of IterateFrom.
+func (mr *MockSyncTreeMockRecorder) IterateFrom(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockSyncTree)(nil).IterateFrom), arg0, arg1, arg2)
+}
+
+// Lock mocks base method.
+func (m *MockSyncTree) Lock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Lock")
+}
+
+// Lock indicates an expected call of Lock.
+func (mr *MockSyncTreeMockRecorder) Lock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockSyncTree)(nil).Lock))
+}
+
+// RLock mocks base method.
+func (m *MockSyncTree) RLock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RLock")
+}
+
+// RLock indicates an expected call of RLock.
+func (mr *MockSyncTreeMockRecorder) RLock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RLock", reflect.TypeOf((*MockSyncTree)(nil).RLock))
+}
+
+// RUnlock mocks base method.
+func (m *MockSyncTree) RUnlock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RUnlock")
+}
+
+// RUnlock indicates an expected call of RUnlock.
+func (mr *MockSyncTreeMockRecorder) RUnlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RUnlock", reflect.TypeOf((*MockSyncTree)(nil).RUnlock))
+}
+
+// Root mocks base method.
+func (m *MockSyncTree) Root() *tree.Change {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Root")
+	ret0, _ := ret[0].(*tree.Change)
+	return ret0
+}
+
+// Root indicates an expected call of Root.
+func (mr *MockSyncTreeMockRecorder) Root() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockSyncTree)(nil).Root))
+}
+
+// SnapshotPath mocks base method.
+func (m *MockSyncTree) SnapshotPath() []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SnapshotPath")
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// SnapshotPath indicates an expected call of SnapshotPath.
+func (mr *MockSyncTreeMockRecorder) SnapshotPath() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SnapshotPath", reflect.TypeOf((*MockSyncTree)(nil).SnapshotPath))
+}
+
+// Storage mocks base method.
+func (m *MockSyncTree) Storage() storage.TreeStorage {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Storage")
+	ret0, _ := ret[0].(storage.TreeStorage)
+	return ret0
+}
+
+// Storage indicates an expected call of Storage.
+func (mr *MockSyncTreeMockRecorder) Storage() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Storage", reflect.TypeOf((*MockSyncTree)(nil).Storage))
+}
+
+// Unlock mocks base method.
+func (m *MockSyncTree) Unlock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Unlock")
+}
+
+// Unlock indicates an expected call of Unlock.
+func (mr *MockSyncTreeMockRecorder) Unlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockSyncTree)(nil).Unlock))
+}

common/commonspace/synctree/syncclient.go

@@ -1,4 +1,4 @@
-//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree SyncClient
+//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree SyncClient,SyncTree
 package synctree
 
 import (

common/commonspace/synctree/synctree.go

@@ -23,8 +23,13 @@ var (
 	ErrSyncTreeDeleted = errors.New("sync tree is deleted")
 )
 
+type SyncTree interface {
+	tree.ObjectTree
+	synchandler.SyncHandler
+}
+
 // SyncTree sends head updates to sync service and also sends new changes to update listener
-type SyncTree struct {
+type syncTree struct {
 	tree.ObjectTree
 	synchandler.SyncHandler
 	syncClient SyncClient
@@ -62,8 +67,8 @@ type BuildDeps struct {
 	TreeStorage    storage.TreeStorage
 }
 
-func DeriveSyncTree(ctx context.Context, deps CreateDeps) (t tree.ObjectTree, err error) {
+func DeriveSyncTree(ctx context.Context, deps CreateDeps) (t SyncTree, err error) {
-	t, err = createDerivedObjectTree(deps.Payload, deps.AclList, deps.SpaceStorage.CreateTreeStorage)
+	objTree, err := createDerivedObjectTree(deps.Payload, deps.AclList, deps.SpaceStorage.CreateTreeStorage)
 	if err != nil {
 		return
 	}
@@ -73,8 +78,8 @@ func DeriveSyncTree(ctx context.Context, deps CreateDeps) (t tree.ObjectTree, er
 		deps.HeadNotifiable,
 		sharedFactory,
 		deps.Configuration)
-	syncTree := &SyncTree{
+	syncTree := &syncTree{
-		ObjectTree: t,
+		ObjectTree: objTree,
 		syncClient: syncClient,
 		listener:   deps.Listener,
 	}
@@ -92,8 +97,8 @@ func DeriveSyncTree(ctx context.Context, deps CreateDeps) (t tree.ObjectTree, er
 	return
 }
 
-func CreateSyncTree(ctx context.Context, deps CreateDeps) (t tree.ObjectTree, err error) {
+func CreateSyncTree(ctx context.Context, deps CreateDeps) (t SyncTree, err error) {
-	t, err = createObjectTree(deps.Payload, deps.AclList, deps.SpaceStorage.CreateTreeStorage)
+	objTree, err := createObjectTree(deps.Payload, deps.AclList, deps.SpaceStorage.CreateTreeStorage)
 	if err != nil {
 		return
 	}
@@ -103,8 +108,8 @@ func CreateSyncTree(ctx context.Context, deps CreateDeps) (t tree.ObjectTree, er
 		deps.HeadNotifiable,
 		GetRequestFactory(),
 		deps.Configuration)
-	syncTree := &SyncTree{
+	syncTree := &syncTree{
-		ObjectTree: t,
+		ObjectTree: objTree,
 		syncClient: syncClient,
 		listener:   deps.Listener,
 	}
@@ -123,7 +128,7 @@ func CreateSyncTree(ctx context.Context, deps CreateDeps) (t tree.ObjectTree, er
 	return
 }
 
-func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t tree.ObjectTree, err error) {
+func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t SyncTree, err error) {
 	getTreeRemote := func() (msg *treechangeproto.TreeSyncMessage, err error) {
 		peerId, err := peer.CtxPeerId(ctx)
 		if err != nil {
@@ -187,8 +192,8 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
 	return buildSyncTree(ctx, true, deps)
 }
 
-func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t tree.ObjectTree, err error) {
+func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t SyncTree, err error) {
-	t, err = buildObjectTree(deps.TreeStorage, deps.AclList)
+	objTree, err := buildObjectTree(deps.TreeStorage, deps.AclList)
 	if err != nil {
 		return
 	}
@@ -198,8 +203,8 @@ func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t tr
 		deps.HeadNotifiable,
 		GetRequestFactory(),
 		deps.Configuration)
-	syncTree := &SyncTree{
+	syncTree := &syncTree{
-		ObjectTree: t,
+		ObjectTree: objTree,
 		syncClient: syncClient,
 		listener:   deps.Listener,
 	}
@@ -224,21 +229,21 @@ func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t tr
 	return
 }
 
-func (s *SyncTree) IterateFrom(id string, convert tree.ChangeConvertFunc, iterate tree.ChangeIterateFunc) (err error) {
+func (s *syncTree) IterateFrom(id string, convert tree.ChangeConvertFunc, iterate tree.ChangeIterateFunc) (err error) {
 	if err = s.checkAlive(); err != nil {
 		return
 	}
 	return s.ObjectTree.IterateFrom(id, convert, iterate)
 }
 
-func (s *SyncTree) Iterate(convert tree.ChangeConvertFunc, iterate tree.ChangeIterateFunc) (err error) {
+func (s *syncTree) Iterate(convert tree.ChangeConvertFunc, iterate tree.ChangeIterateFunc) (err error) {
 	if err = s.checkAlive(); err != nil {
 		return
 	}
 	return s.ObjectTree.Iterate(convert, iterate)
 }
 
-func (s *SyncTree) AddContent(ctx context.Context, content tree.SignableChangeContent) (res tree.AddResult, err error) {
+func (s *syncTree) AddContent(ctx context.Context, content tree.SignableChangeContent) (res tree.AddResult, err error) {
 	if err = s.checkAlive(); err != nil {
 		return
 	}
@@ -251,7 +256,7 @@ func (s *SyncTree) AddContent(ctx context.Context, content tree.SignableChangeCo
 	return
 }
 
-func (s *SyncTree) AddRawChanges(ctx context.Context, changes ...*treechangeproto.RawTreeChangeWithId) (res tree.AddResult, err error) {
+func (s *syncTree) AddRawChanges(ctx context.Context, changes ...*treechangeproto.RawTreeChangeWithId) (res tree.AddResult, err error) {
 	if err = s.checkAlive(); err != nil {
 		return
 	}
@@ -276,7 +281,7 @@ func (s *SyncTree) AddRawChanges(ctx context.Context, changes ...*treechangeprot
 	return
 }
 
-func (s *SyncTree) Delete() (err error) {
+func (s *syncTree) Delete() (err error) {
 	log.With("id", s.ID()).Debug("deleting sync tree")
 	s.Lock()
 	defer s.Unlock()
@@ -291,7 +296,7 @@ func (s *SyncTree) Delete() (err error) {
 	return
 }
 
-func (s *SyncTree) Close() (err error) {
+func (s *syncTree) Close() (err error) {
 	log.With("id", s.ID()).Debug("closing sync tree")
 	s.Lock()
 	defer s.Unlock()
@@ -302,7 +307,7 @@ func (s *SyncTree) Close() (err error) {
 	return
 }
 
-func (s *SyncTree) checkAlive() (err error) {
+func (s *syncTree) checkAlive() (err error) {
 	if s.isClosed {
 		err = ErrSyncTreeClosed
 	}

common/commonspace/synctree/synctree_test.go

@@ -27,7 +27,7 @@ type syncTreeMatcher struct {
 }
 
 func (s syncTreeMatcher) Matches(x interface{}) bool {
-	t, ok := x.(*SyncTree)
+	t, ok := x.(*syncTree)
 	if !ok {
 		return false
 	}
@@ -118,7 +118,7 @@ func Test_BuildSyncTree(t *testing.T) {
 	updateListenerMock := mock_updatelistener.NewMockUpdateListener(ctrl)
 	syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
 	objTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
-	tr := &SyncTree{
+	tr := &syncTree{
 		ObjectTree:  objTreeMock,
 		SyncHandler: nil,
 		syncClient:  syncClientMock,