From b24f79645dfaab5d3079ca4f8032ecbf7a6fa6ef Mon Sep 17 00:00:00 2001 From: mcrakhman Date: Mon, 28 Nov 2022 16:54:31 +0100 Subject: [PATCH] Improve interfaces for synctree, generate mocks --- common/account/mock_account/mock_account.go | 78 +++++ common/account/service.go | 1 + .../settingsdocument/idprovider.go | 3 +- .../mock_settingsdocument.go | 51 +++ .../settingsdocument/settingsdocument.go | 19 +- common/commonspace/space.go | 9 +- .../synctree/mock_synctree/mock_synctree.go | 313 +++++++++++++++++- common/commonspace/synctree/syncclient.go | 2 +- common/commonspace/synctree/synctree.go | 47 +-- common/commonspace/synctree/synctree_test.go | 4 +- 10 files changed, 489 insertions(+), 38 deletions(-) create mode 100644 common/account/mock_account/mock_account.go create mode 100644 common/commonspace/settingsdocument/mock_settingsdocument/mock_settingsdocument.go diff --git a/common/account/mock_account/mock_account.go b/common/account/mock_account/mock_account.go new file mode 100644 index 00000000..6f6d3b54 --- /dev/null +++ b/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)) +} diff --git a/common/account/service.go b/common/account/service.go index ab009a51..23b279b2 100644 --- a/common/account/service.go +++ b/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 ( diff --git a/common/commonspace/settingsdocument/idprovider.go b/common/commonspace/settingsdocument/idprovider.go index bc64da57..56fccab6 100644 --- a/common/commonspace/settingsdocument/idprovider.go +++ b/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) } diff --git a/common/commonspace/settingsdocument/mock_settingsdocument/mock_settingsdocument.go b/common/commonspace/settingsdocument/mock_settingsdocument/mock_settingsdocument.go new file mode 100644 index 00000000..4a8a58d8 --- /dev/null +++ b/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) +} diff --git a/common/commonspace/settingsdocument/settingsdocument.go b/common/commonspace/settingsdocument/settingsdocument.go index c9359321..64d07987 100644 --- a/common/commonspace/settingsdocument/settingsdocument.go +++ b/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 - synchandler.SyncHandler + synctree.SyncTree 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) { diff --git a/common/commonspace/space.go b/common/commonspace/space.go index 9a1f39ff..78085be4 100644 --- a/common/commonspace/space.go +++ b/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, diff --git a/common/commonspace/synctree/mock_synctree/mock_synctree.go b/common/commonspace/synctree/mock_synctree/mock_synctree.go index 914a6ec1..8f726e61 100644 --- a/common/commonspace/synctree/mock_synctree/mock_synctree.go +++ b/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)) +} diff --git a/common/commonspace/synctree/syncclient.go b/common/commonspace/synctree/syncclient.go index d8a721ec..506447ee 100644 --- a/common/commonspace/synctree/syncclient.go +++ b/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 ( diff --git a/common/commonspace/synctree/synctree.go b/common/commonspace/synctree/synctree.go index 32008d1c..bb96836c 100644 --- a/common/commonspace/synctree/synctree.go +++ b/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) { - t, err = createDerivedObjectTree(deps.Payload, deps.AclList, deps.SpaceStorage.CreateTreeStorage) +func DeriveSyncTree(ctx context.Context, deps CreateDeps) (t SyncTree, err error) { + 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{ - ObjectTree: t, + syncTree := &syncTree{ + 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) { - t, err = createObjectTree(deps.Payload, deps.AclList, deps.SpaceStorage.CreateTreeStorage) +func CreateSyncTree(ctx context.Context, deps CreateDeps) (t SyncTree, err error) { + 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{ - ObjectTree: t, + syncTree := &syncTree{ + 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) { - t, err = buildObjectTree(deps.TreeStorage, deps.AclList) +func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t SyncTree, err error) { + 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{ - ObjectTree: t, + syncTree := &syncTree{ + 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 } diff --git a/common/commonspace/synctree/synctree_test.go b/common/commonspace/synctree/synctree_test.go index e14433cb..df852e07 100644 --- a/common/commonspace/synctree/synctree_test.go +++ b/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,