Add mock to write diffservice tests

Makefile

@@ -33,4 +33,9 @@ proto:
 
 build:
 	@$(eval FLAGS := $$(shell govvv -flags -pkg github.com/anytypeio/go-anytype-infrastructure-experiments/app))
-	go build -v -o bin/anytype-node -ldflags "$(FLAGS)" cmd/node/node.go
+	go build -v -o bin/anytype-node -ldflags "$(FLAGS)" cmd/node/node.go
+
+test-deps:
+	@echo 'Generating test mocks...'
+	@go install github.com/golang/mock/mockgen
+	@go generate ./...

common/commonspace/cache/treecache.go

@@ -1,3 +1,4 @@
+//go:generate mockgen -package cache -destination treecache_mock.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/cache TreeCache
 package cache
 
 import (

common/commonspace/cache/treecache_mock.go

@@ -0,0 +1,107 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/cache (interfaces: TreeCache)
+
+// Package cache is a generated GoMock package.
+package cache
+
+import (
+	context "context"
+	reflect "reflect"
+
+	app "github.com/anytypeio/go-anytype-infrastructure-experiments/app"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockTreeCache is a mock of TreeCache interface.
+type MockTreeCache struct {
+	ctrl     *gomock.Controller
+	recorder *MockTreeCacheMockRecorder
+}
+
+// MockTreeCacheMockRecorder is the mock recorder for MockTreeCache.
+type MockTreeCacheMockRecorder struct {
+	mock *MockTreeCache
+}
+
+// NewMockTreeCache creates a new mock instance.
+func NewMockTreeCache(ctrl *gomock.Controller) *MockTreeCache {
+	mock := &MockTreeCache{ctrl: ctrl}
+	mock.recorder = &MockTreeCacheMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockTreeCache) EXPECT() *MockTreeCacheMockRecorder {
+	return m.recorder
+}
+
+// Close mocks base method.
+func (m *MockTreeCache) Close(arg0 context.Context) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Close", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Close indicates an expected call of Close.
+func (mr *MockTreeCacheMockRecorder) Close(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockTreeCache)(nil).Close), arg0)
+}
+
+// GetTree mocks base method.
+func (m *MockTreeCache) GetTree(arg0 context.Context, arg1, arg2 string) (TreeResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTree", arg0, arg1, arg2)
+	ret0, _ := ret[0].(TreeResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTree indicates an expected call of GetTree.
+func (mr *MockTreeCacheMockRecorder) GetTree(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTree", reflect.TypeOf((*MockTreeCache)(nil).GetTree), arg0, arg1, arg2)
+}
+
+// Init mocks base method.
+func (m *MockTreeCache) 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 *MockTreeCacheMockRecorder) Init(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockTreeCache)(nil).Init), arg0)
+}
+
+// Name mocks base method.
+func (m *MockTreeCache) 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 *MockTreeCacheMockRecorder) Name() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockTreeCache)(nil).Name))
+}
+
+// Run mocks base method.
+func (m *MockTreeCache) 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 *MockTreeCacheMockRecorder) Run(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockTreeCache)(nil).Run), arg0)
+}

common/commonspace/diffservice/diffsyncer_test.go

@@ -0,0 +1,34 @@
+package diffservice
+
+import (
+	"context"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/cache"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
+	"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ldiff"
+	"github.com/golang/mock/gomock"
+	"storj.io/drpc"
+	"testing"
+)
+
+func TestDiffSyncer_Sync(t *testing.T) {
+	// setup
+	ctx := context.Background()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	diffMock := ldiff.NewMockDiff(ctrl)
+	nconfMock := nodeconf.NewMockConfiguration(ctrl)
+	cacheMock := cache.NewMockTreeCache(ctrl)
+	stMock := storage.NewMockSpaceStorage(ctrl)
+	clientMock := spacesyncproto.NewMockDRPCSpaceClient(ctrl)
+	factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceClient {
+		return clientMock
+	})
+	spaceId := "spaceId"
+	l := logger.NewNamed(spaceId)
+	diffSyncer := newDiffSyncer(spaceId, diffMock, nconfMock, cacheMock, stMock, factory, l)
+	diffSyncer.Sync(ctx)
+}

common/commonspace/spacesyncproto/drpcspaceclient_mock.go

@@ -0,0 +1,95 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto (interfaces: DRPCSpaceClient)
+
+// Package spacesyncproto is a generated GoMock package.
+package spacesyncproto
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+	drpc "storj.io/drpc"
+)
+
+// MockDRPCSpaceClient is a mock of DRPCSpaceClient interface.
+type MockDRPCSpaceClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockDRPCSpaceClientMockRecorder
+}
+
+// MockDRPCSpaceClientMockRecorder is the mock recorder for MockDRPCSpaceClient.
+type MockDRPCSpaceClientMockRecorder struct {
+	mock *MockDRPCSpaceClient
+}
+
+// NewMockDRPCSpaceClient creates a new mock instance.
+func NewMockDRPCSpaceClient(ctrl *gomock.Controller) *MockDRPCSpaceClient {
+	mock := &MockDRPCSpaceClient{ctrl: ctrl}
+	mock.recorder = &MockDRPCSpaceClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDRPCSpaceClient) EXPECT() *MockDRPCSpaceClientMockRecorder {
+	return m.recorder
+}
+
+// DRPCConn mocks base method.
+func (m *MockDRPCSpaceClient) DRPCConn() drpc.Conn {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DRPCConn")
+	ret0, _ := ret[0].(drpc.Conn)
+	return ret0
+}
+
+// DRPCConn indicates an expected call of DRPCConn.
+func (mr *MockDRPCSpaceClientMockRecorder) DRPCConn() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DRPCConn", reflect.TypeOf((*MockDRPCSpaceClient)(nil).DRPCConn))
+}
+
+// HeadSync mocks base method.
+func (m *MockDRPCSpaceClient) HeadSync(arg0 context.Context, arg1 *HeadSyncRequest) (*HeadSyncResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HeadSync", arg0, arg1)
+	ret0, _ := ret[0].(*HeadSyncResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HeadSync indicates an expected call of HeadSync.
+func (mr *MockDRPCSpaceClientMockRecorder) HeadSync(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadSync", reflect.TypeOf((*MockDRPCSpaceClient)(nil).HeadSync), arg0, arg1)
+}
+
+// PushSpace mocks base method.
+func (m *MockDRPCSpaceClient) PushSpace(arg0 context.Context, arg1 *PushSpaceRequest) (*PushSpaceResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PushSpace", arg0, arg1)
+	ret0, _ := ret[0].(*PushSpaceResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PushSpace indicates an expected call of PushSpace.
+func (mr *MockDRPCSpaceClientMockRecorder) PushSpace(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushSpace", reflect.TypeOf((*MockDRPCSpaceClient)(nil).PushSpace), arg0, arg1)
+}
+
+// Stream mocks base method.
+func (m *MockDRPCSpaceClient) Stream(arg0 context.Context) (DRPCSpace_StreamClient, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Stream", arg0)
+	ret0, _ := ret[0].(DRPCSpace_StreamClient)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Stream indicates an expected call of Stream.
+func (mr *MockDRPCSpaceClientMockRecorder) Stream(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockDRPCSpaceClient)(nil).Stream), arg0)
+}

common/commonspace/spacesyncproto/spacesync.go

@@ -1,3 +1,4 @@
+//go:generate mockgen -package spacesyncproto -destination drpcspaceclient_mock.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto DRPCSpaceClient
 package spacesyncproto
 
 import (

common/commonspace/storage/storage.go

@@ -1,3 +1,4 @@
+//go:generate mockgen -package storage -destination storage_mock.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage SpaceStorageProvider,SpaceStorage
 package storage
 
 import (

common/commonspace/storage/storage_mock.go

@@ -0,0 +1,193 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage (interfaces: SpaceStorageProvider,SpaceStorage)
+
+// Package storage is a generated GoMock package.
+package storage
+
+import (
+	reflect "reflect"
+
+	app "github.com/anytypeio/go-anytype-infrastructure-experiments/app"
+	spacesyncproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
+	storage0 "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockSpaceStorageProvider is a mock of SpaceStorageProvider interface.
+type MockSpaceStorageProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockSpaceStorageProviderMockRecorder
+}
+
+// MockSpaceStorageProviderMockRecorder is the mock recorder for MockSpaceStorageProvider.
+type MockSpaceStorageProviderMockRecorder struct {
+	mock *MockSpaceStorageProvider
+}
+
+// NewMockSpaceStorageProvider creates a new mock instance.
+func NewMockSpaceStorageProvider(ctrl *gomock.Controller) *MockSpaceStorageProvider {
+	mock := &MockSpaceStorageProvider{ctrl: ctrl}
+	mock.recorder = &MockSpaceStorageProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockSpaceStorageProvider) EXPECT() *MockSpaceStorageProviderMockRecorder {
+	return m.recorder
+}
+
+// CreateSpaceStorage mocks base method.
+func (m *MockSpaceStorageProvider) CreateSpaceStorage(arg0 SpaceStorageCreatePayload) (SpaceStorage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSpaceStorage", arg0)
+	ret0, _ := ret[0].(SpaceStorage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateSpaceStorage indicates an expected call of CreateSpaceStorage.
+func (mr *MockSpaceStorageProviderMockRecorder) CreateSpaceStorage(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpaceStorage", reflect.TypeOf((*MockSpaceStorageProvider)(nil).CreateSpaceStorage), arg0)
+}
+
+// Init mocks base method.
+func (m *MockSpaceStorageProvider) 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 *MockSpaceStorageProviderMockRecorder) Init(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpaceStorageProvider)(nil).Init), arg0)
+}
+
+// Name mocks base method.
+func (m *MockSpaceStorageProvider) 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 *MockSpaceStorageProviderMockRecorder) Name() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockSpaceStorageProvider)(nil).Name))
+}
+
+// SpaceStorage mocks base method.
+func (m *MockSpaceStorageProvider) SpaceStorage(arg0 string) (SpaceStorage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SpaceStorage", arg0)
+	ret0, _ := ret[0].(SpaceStorage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SpaceStorage indicates an expected call of SpaceStorage.
+func (mr *MockSpaceStorageProviderMockRecorder) SpaceStorage(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceStorage", reflect.TypeOf((*MockSpaceStorageProvider)(nil).SpaceStorage), arg0)
+}
+
+// MockSpaceStorage is a mock of SpaceStorage interface.
+type MockSpaceStorage struct {
+	ctrl     *gomock.Controller
+	recorder *MockSpaceStorageMockRecorder
+}
+
+// MockSpaceStorageMockRecorder is the mock recorder for MockSpaceStorage.
+type MockSpaceStorageMockRecorder struct {
+	mock *MockSpaceStorage
+}
+
+// NewMockSpaceStorage creates a new mock instance.
+func NewMockSpaceStorage(ctrl *gomock.Controller) *MockSpaceStorage {
+	mock := &MockSpaceStorage{ctrl: ctrl}
+	mock.recorder = &MockSpaceStorageMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockSpaceStorage) EXPECT() *MockSpaceStorageMockRecorder {
+	return m.recorder
+}
+
+// ACLStorage mocks base method.
+func (m *MockSpaceStorage) ACLStorage() (storage0.ListStorage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ACLStorage")
+	ret0, _ := ret[0].(storage0.ListStorage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ACLStorage indicates an expected call of ACLStorage.
+func (mr *MockSpaceStorageMockRecorder) ACLStorage() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLStorage", reflect.TypeOf((*MockSpaceStorage)(nil).ACLStorage))
+}
+
+// CreateTreeStorage mocks base method.
+func (m *MockSpaceStorage) CreateTreeStorage(arg0 storage0.TreeStorageCreatePayload) (storage0.TreeStorage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTreeStorage", arg0)
+	ret0, _ := ret[0].(storage0.TreeStorage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTreeStorage indicates an expected call of CreateTreeStorage.
+func (mr *MockSpaceStorageMockRecorder) CreateTreeStorage(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).CreateTreeStorage), arg0)
+}
+
+// SpaceHeader mocks base method.
+func (m *MockSpaceStorage) SpaceHeader() (*spacesyncproto.SpaceHeader, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SpaceHeader")
+	ret0, _ := ret[0].(*spacesyncproto.SpaceHeader)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SpaceHeader indicates an expected call of SpaceHeader.
+func (mr *MockSpaceStorageMockRecorder) SpaceHeader() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpaceHeader", reflect.TypeOf((*MockSpaceStorage)(nil).SpaceHeader))
+}
+
+// StoredIds mocks base method.
+func (m *MockSpaceStorage) StoredIds() ([]string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StoredIds")
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StoredIds indicates an expected call of StoredIds.
+func (mr *MockSpaceStorageMockRecorder) StoredIds() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoredIds", reflect.TypeOf((*MockSpaceStorage)(nil).StoredIds))
+}
+
+// TreeStorage mocks base method.
+func (m *MockSpaceStorage) TreeStorage(arg0 string) (storage0.TreeStorage, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TreeStorage", arg0)
+	ret0, _ := ret[0].(storage0.TreeStorage)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TreeStorage indicates an expected call of TreeStorage.
+func (mr *MockSpaceStorageMockRecorder) TreeStorage(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeStorage", reflect.TypeOf((*MockSpaceStorage)(nil).TreeStorage), arg0)
+}

common/nodeconf/configuration.go

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

common/nodeconf/configuration_mock.go

@@ -0,0 +1,123 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf (interfaces: Configuration)
+
+// Package nodeconf is a generated GoMock package.
+package nodeconf
+
+import (
+	context "context"
+	reflect "reflect"
+
+	peer "github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/peer"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockConfiguration is a mock of Configuration interface.
+type MockConfiguration struct {
+	ctrl     *gomock.Controller
+	recorder *MockConfigurationMockRecorder
+}
+
+// MockConfigurationMockRecorder is the mock recorder for MockConfiguration.
+type MockConfigurationMockRecorder struct {
+	mock *MockConfiguration
+}
+
+// NewMockConfiguration creates a new mock instance.
+func NewMockConfiguration(ctrl *gomock.Controller) *MockConfiguration {
+	mock := &MockConfiguration{ctrl: ctrl}
+	mock.recorder = &MockConfigurationMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockConfiguration) EXPECT() *MockConfigurationMockRecorder {
+	return m.recorder
+}
+
+// AllPeers mocks base method.
+func (m *MockConfiguration) AllPeers(arg0 context.Context, arg1 string) ([]peer.Peer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AllPeers", arg0, arg1)
+	ret0, _ := ret[0].([]peer.Peer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AllPeers indicates an expected call of AllPeers.
+func (mr *MockConfigurationMockRecorder) AllPeers(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllPeers", reflect.TypeOf((*MockConfiguration)(nil).AllPeers), arg0, arg1)
+}
+
+// Id mocks base method.
+func (m *MockConfiguration) 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 *MockConfigurationMockRecorder) Id() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockConfiguration)(nil).Id))
+}
+
+// IsResponsible mocks base method.
+func (m *MockConfiguration) IsResponsible(arg0 string) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsResponsible", arg0)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// IsResponsible indicates an expected call of IsResponsible.
+func (mr *MockConfigurationMockRecorder) IsResponsible(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResponsible", reflect.TypeOf((*MockConfiguration)(nil).IsResponsible), arg0)
+}
+
+// NodeIds mocks base method.
+func (m *MockConfiguration) NodeIds(arg0 string) []string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NodeIds", arg0)
+	ret0, _ := ret[0].([]string)
+	return ret0
+}
+
+// NodeIds indicates an expected call of NodeIds.
+func (mr *MockConfigurationMockRecorder) NodeIds(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NodeIds", reflect.TypeOf((*MockConfiguration)(nil).NodeIds), arg0)
+}
+
+// OnePeer mocks base method.
+func (m *MockConfiguration) OnePeer(arg0 context.Context, arg1 string) (peer.Peer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OnePeer", arg0, arg1)
+	ret0, _ := ret[0].(peer.Peer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// OnePeer indicates an expected call of OnePeer.
+func (mr *MockConfigurationMockRecorder) OnePeer(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnePeer", reflect.TypeOf((*MockConfiguration)(nil).OnePeer), arg0, arg1)
+}
+
+// ResponsiblePeers mocks base method.
+func (m *MockConfiguration) ResponsiblePeers(arg0 context.Context, arg1 string) ([]peer.Peer, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResponsiblePeers", arg0, arg1)
+	ret0, _ := ret[0].([]peer.Peer)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ResponsiblePeers indicates an expected call of ResponsiblePeers.
+func (mr *MockConfigurationMockRecorder) ResponsiblePeers(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResponsiblePeers", reflect.TypeOf((*MockConfiguration)(nil).ResponsiblePeers), arg0, arg1)
+}

go.mod

@@ -12,7 +12,7 @@ require (
 	github.com/ipfs/go-cid v0.1.0
 	github.com/libp2p/go-libp2p v0.20.3
 	github.com/libp2p/go-libp2p-core v0.16.1
-	github.com/mr-tron/base58 v1.2.0
+	github.com/minio/sha256-simd v1.0.0
 	github.com/multiformats/go-multibase v0.0.3
 	github.com/multiformats/go-multihash v0.1.0
 	github.com/stretchr/testify v1.8.0
@@ -33,11 +33,12 @@ require (
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
 	github.com/fogleman/gg v1.3.0 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
+	github.com/golang/mock v1.6.0 // indirect
 	github.com/klauspost/cpuid/v2 v2.0.12 // indirect
 	github.com/libp2p/go-buffer-pool v0.0.2 // indirect
 	github.com/libp2p/go-openssl v0.0.7 // indirect
 	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 // indirect
-	github.com/minio/sha256-simd v1.0.0 // indirect
+	github.com/mr-tron/base58 v1.2.0 // indirect
 	github.com/multiformats/go-base32 v0.0.3 // indirect
 	github.com/multiformats/go-base36 v0.1.0 // indirect
 	github.com/multiformats/go-multiaddr v0.5.0 // indirect
@@ -51,7 +52,10 @@ require (
 	go.uber.org/multierr v1.8.0 // indirect
 	golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 // indirect
 	golang.org/x/image v0.0.0-20200119044424-58c23975cae1 // indirect
+	golang.org/x/mod v0.4.2 // indirect
 	golang.org/x/sys v0.0.0-20220422013727-9388b58f7150 // indirect
+	golang.org/x/tools v0.1.5 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	lukechampine.com/blake3 v1.1.6 // indirect

go.sum

@@ -32,6 +32,8 @@ github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c=
 github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U=
 github.com/huandu/skiplist v1.2.0 h1:gox56QD77HzSC0w+Ws3MH3iie755GBJU1OER3h5VsYw=
@@ -141,6 +143,7 @@ golang.org/x/image v0.0.0-20200119044424-58c23975cae1/go.mod h1:FeLwcggjj3mMvU+o
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
@@ -173,10 +176,13 @@ golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.5 h1:ouewzE6p+/VEB31YYnTbEJdi8pFqKp4P4n85vwo3DHA=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

pkg/acl/list/list.go

@@ -1,3 +1,4 @@
+//go:generate mockgen -package list -destination list_mock.go github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list ACLList
 package list
 
 import (

pkg/acl/list/list_mock.go

@@ -0,0 +1,221 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list (interfaces: ACLList)
+
+// Package list is a generated GoMock package.
+package list
+
+import (
+	reflect "reflect"
+
+	aclrecordproto "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclrecordproto"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockACLList is a mock of ACLList interface.
+type MockACLList struct {
+	ctrl     *gomock.Controller
+	recorder *MockACLListMockRecorder
+}
+
+// MockACLListMockRecorder is the mock recorder for MockACLList.
+type MockACLListMockRecorder struct {
+	mock *MockACLList
+}
+
+// NewMockACLList creates a new mock instance.
+func NewMockACLList(ctrl *gomock.Controller) *MockACLList {
+	mock := &MockACLList{ctrl: ctrl}
+	mock.recorder = &MockACLListMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockACLList) EXPECT() *MockACLListMockRecorder {
+	return m.recorder
+}
+
+// ACLState mocks base method.
+func (m *MockACLList) ACLState() *ACLState {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ACLState")
+	ret0, _ := ret[0].(*ACLState)
+	return ret0
+}
+
+// ACLState indicates an expected call of ACLState.
+func (mr *MockACLListMockRecorder) ACLState() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLState", reflect.TypeOf((*MockACLList)(nil).ACLState))
+}
+
+// Close mocks base method.
+func (m *MockACLList) 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 *MockACLListMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockACLList)(nil).Close))
+}
+
+// Get mocks base method.
+func (m *MockACLList) Get(arg0 string) (*ACLRecord, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Get", arg0)
+	ret0, _ := ret[0].(*ACLRecord)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Get indicates an expected call of Get.
+func (mr *MockACLListMockRecorder) Get(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockACLList)(nil).Get), arg0)
+}
+
+// Head mocks base method.
+func (m *MockACLList) Head() *ACLRecord {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Head")
+	ret0, _ := ret[0].(*ACLRecord)
+	return ret0
+}
+
+// Head indicates an expected call of Head.
+func (mr *MockACLListMockRecorder) Head() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockACLList)(nil).Head))
+}
+
+// ID mocks base method.
+func (m *MockACLList) 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 *MockACLListMockRecorder) ID() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockACLList)(nil).ID))
+}
+
+// IsAfter mocks base method.
+func (m *MockACLList) IsAfter(arg0, arg1 string) (bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IsAfter", arg0, arg1)
+	ret0, _ := ret[0].(bool)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// IsAfter indicates an expected call of IsAfter.
+func (mr *MockACLListMockRecorder) IsAfter(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAfter", reflect.TypeOf((*MockACLList)(nil).IsAfter), arg0, arg1)
+}
+
+// Iterate mocks base method.
+func (m *MockACLList) Iterate(arg0 func(*ACLRecord) bool) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Iterate", arg0)
+}
+
+// Iterate indicates an expected call of Iterate.
+func (mr *MockACLListMockRecorder) Iterate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockACLList)(nil).Iterate), arg0)
+}
+
+// IterateFrom mocks base method.
+func (m *MockACLList) IterateFrom(arg0 string, arg1 func(*ACLRecord) bool) {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "IterateFrom", arg0, arg1)
+}
+
+// IterateFrom indicates an expected call of IterateFrom.
+func (mr *MockACLListMockRecorder) IterateFrom(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockACLList)(nil).IterateFrom), arg0, arg1)
+}
+
+// Lock mocks base method.
+func (m *MockACLList) Lock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Lock")
+}
+
+// Lock indicates an expected call of Lock.
+func (mr *MockACLListMockRecorder) Lock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockACLList)(nil).Lock))
+}
+
+// RLock mocks base method.
+func (m *MockACLList) RLock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RLock")
+}
+
+// RLock indicates an expected call of RLock.
+func (mr *MockACLListMockRecorder) RLock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RLock", reflect.TypeOf((*MockACLList)(nil).RLock))
+}
+
+// RUnlock mocks base method.
+func (m *MockACLList) RUnlock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RUnlock")
+}
+
+// RUnlock indicates an expected call of RUnlock.
+func (mr *MockACLListMockRecorder) RUnlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RUnlock", reflect.TypeOf((*MockACLList)(nil).RUnlock))
+}
+
+// Records mocks base method.
+func (m *MockACLList) Records() []*ACLRecord {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Records")
+	ret0, _ := ret[0].([]*ACLRecord)
+	return ret0
+}
+
+// Records indicates an expected call of Records.
+func (mr *MockACLListMockRecorder) Records() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Records", reflect.TypeOf((*MockACLList)(nil).Records))
+}
+
+// Root mocks base method.
+func (m *MockACLList) Root() *aclrecordproto.ACLRoot {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Root")
+	ret0, _ := ret[0].(*aclrecordproto.ACLRoot)
+	return ret0
+}
+
+// Root indicates an expected call of Root.
+func (mr *MockACLListMockRecorder) Root() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockACLList)(nil).Root))
+}
+
+// Unlock mocks base method.
+func (m *MockACLList) Unlock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Unlock")
+}
+
+// Unlock indicates an expected call of Unlock.
+func (mr *MockACLListMockRecorder) Unlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockACLList)(nil).Unlock))
+}

pkg/acl/tree/objecttree.go

@@ -1,3 +1,4 @@
+//go:generate mockgen -package tree -destination objecttree_mock.go github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree ObjectTree
 package tree
 
 import (

pkg/acl/tree/objecttree_mock.go

@@ -0,0 +1,290 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree (interfaces: ObjectTree)
+
+// Package tree is a generated GoMock package.
+package tree
+
+import (
+	context "context"
+	reflect "reflect"
+
+	storage "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
+	treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treechangeproto"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockObjectTree is a mock of ObjectTree interface.
+type MockObjectTree struct {
+	ctrl     *gomock.Controller
+	recorder *MockObjectTreeMockRecorder
+}
+
+// MockObjectTreeMockRecorder is the mock recorder for MockObjectTree.
+type MockObjectTreeMockRecorder struct {
+	mock *MockObjectTree
+}
+
+// NewMockObjectTree creates a new mock instance.
+func NewMockObjectTree(ctrl *gomock.Controller) *MockObjectTree {
+	mock := &MockObjectTree{ctrl: ctrl}
+	mock.recorder = &MockObjectTreeMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockObjectTree) EXPECT() *MockObjectTreeMockRecorder {
+	return m.recorder
+}
+
+// AddContent mocks base method.
+func (m *MockObjectTree) AddContent(arg0 context.Context, arg1 SignableChangeContent) (AddResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
+	ret0, _ := ret[0].(AddResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddContent indicates an expected call of AddContent.
+func (mr *MockObjectTreeMockRecorder) AddContent(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddContent", reflect.TypeOf((*MockObjectTree)(nil).AddContent), arg0, arg1)
+}
+
+// AddRawChanges mocks base method.
+func (m *MockObjectTree) AddRawChanges(arg0 context.Context, arg1 ...*treechangeproto.RawTreeChangeWithId) (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].(AddResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddRawChanges indicates an expected call of AddRawChanges.
+func (mr *MockObjectTreeMockRecorder) 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((*MockObjectTree)(nil).AddRawChanges), varargs...)
+}
+
+// ChangesAfterCommonSnapshot mocks base method.
+func (m *MockObjectTree) 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 *MockObjectTreeMockRecorder) ChangesAfterCommonSnapshot(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangesAfterCommonSnapshot", reflect.TypeOf((*MockObjectTree)(nil).ChangesAfterCommonSnapshot), arg0, arg1)
+}
+
+// Close mocks base method.
+func (m *MockObjectTree) 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 *MockObjectTreeMockRecorder) Close() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockObjectTree)(nil).Close))
+}
+
+// DebugDump mocks base method.
+func (m *MockObjectTree) 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 *MockObjectTreeMockRecorder) DebugDump() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugDump", reflect.TypeOf((*MockObjectTree)(nil).DebugDump))
+}
+
+// HasChange mocks base method.
+func (m *MockObjectTree) HasChange(arg0 string) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HasChange", arg0)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// HasChange indicates an expected call of HasChange.
+func (mr *MockObjectTreeMockRecorder) HasChange(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasChange", reflect.TypeOf((*MockObjectTree)(nil).HasChange), arg0)
+}
+
+// Header mocks base method.
+func (m *MockObjectTree) 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 *MockObjectTreeMockRecorder) Header() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockObjectTree)(nil).Header))
+}
+
+// Heads mocks base method.
+func (m *MockObjectTree) 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 *MockObjectTreeMockRecorder) Heads() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Heads", reflect.TypeOf((*MockObjectTree)(nil).Heads))
+}
+
+// ID mocks base method.
+func (m *MockObjectTree) 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 *MockObjectTreeMockRecorder) ID() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockObjectTree)(nil).ID))
+}
+
+// Iterate mocks base method.
+func (m *MockObjectTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*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 *MockObjectTreeMockRecorder) Iterate(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockObjectTree)(nil).Iterate), arg0, arg1)
+}
+
+// IterateFrom mocks base method.
+func (m *MockObjectTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*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 *MockObjectTreeMockRecorder) IterateFrom(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockObjectTree)(nil).IterateFrom), arg0, arg1, arg2)
+}
+
+// Lock mocks base method.
+func (m *MockObjectTree) Lock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Lock")
+}
+
+// Lock indicates an expected call of Lock.
+func (mr *MockObjectTreeMockRecorder) Lock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockObjectTree)(nil).Lock))
+}
+
+// RLock mocks base method.
+func (m *MockObjectTree) RLock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RLock")
+}
+
+// RLock indicates an expected call of RLock.
+func (mr *MockObjectTreeMockRecorder) RLock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RLock", reflect.TypeOf((*MockObjectTree)(nil).RLock))
+}
+
+// RUnlock mocks base method.
+func (m *MockObjectTree) RUnlock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "RUnlock")
+}
+
+// RUnlock indicates an expected call of RUnlock.
+func (mr *MockObjectTreeMockRecorder) RUnlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RUnlock", reflect.TypeOf((*MockObjectTree)(nil).RUnlock))
+}
+
+// Root mocks base method.
+func (m *MockObjectTree) Root() *Change {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Root")
+	ret0, _ := ret[0].(*Change)
+	return ret0
+}
+
+// Root indicates an expected call of Root.
+func (mr *MockObjectTreeMockRecorder) Root() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockObjectTree)(nil).Root))
+}
+
+// SnapshotPath mocks base method.
+func (m *MockObjectTree) 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 *MockObjectTreeMockRecorder) SnapshotPath() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SnapshotPath", reflect.TypeOf((*MockObjectTree)(nil).SnapshotPath))
+}
+
+// Storage mocks base method.
+func (m *MockObjectTree) 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 *MockObjectTreeMockRecorder) Storage() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Storage", reflect.TypeOf((*MockObjectTree)(nil).Storage))
+}
+
+// Unlock mocks base method.
+func (m *MockObjectTree) Unlock() {
+	m.ctrl.T.Helper()
+	m.ctrl.Call(m, "Unlock")
+}
+
+// Unlock indicates an expected call of Unlock.
+func (mr *MockObjectTreeMockRecorder) Unlock() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockObjectTree)(nil).Unlock))
+}

pkg/ldiff/diff.go

@@ -1,3 +1,4 @@
+//go:generate mockgen -package ldiff -destination diff_mock.go github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ldiff Diff,Remote
 // Package ldiff provides a container of elements with fixed id and changeable content.
 // Diff can calculate the difference with another diff container (you can make it remote) with minimum hops and traffic.
 package ldiff

pkg/ldiff/diff_mock.go

@@ -0,0 +1,135 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ldiff (interfaces: Diff,Remote)
+
+// Package ldiff is a generated GoMock package.
+package ldiff
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockDiff is a mock of Diff interface.
+type MockDiff struct {
+	ctrl     *gomock.Controller
+	recorder *MockDiffMockRecorder
+}
+
+// MockDiffMockRecorder is the mock recorder for MockDiff.
+type MockDiffMockRecorder struct {
+	mock *MockDiff
+}
+
+// NewMockDiff creates a new mock instance.
+func NewMockDiff(ctrl *gomock.Controller) *MockDiff {
+	mock := &MockDiff{ctrl: ctrl}
+	mock.recorder = &MockDiffMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDiff) EXPECT() *MockDiffMockRecorder {
+	return m.recorder
+}
+
+// Diff mocks base method.
+func (m *MockDiff) Diff(arg0 context.Context, arg1 Remote) ([]string, []string, []string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Diff", arg0, arg1)
+	ret0, _ := ret[0].([]string)
+	ret1, _ := ret[1].([]string)
+	ret2, _ := ret[2].([]string)
+	ret3, _ := ret[3].(error)
+	return ret0, ret1, ret2, ret3
+}
+
+// Diff indicates an expected call of Diff.
+func (mr *MockDiffMockRecorder) Diff(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Diff", reflect.TypeOf((*MockDiff)(nil).Diff), arg0, arg1)
+}
+
+// Ranges mocks base method.
+func (m *MockDiff) Ranges(arg0 context.Context, arg1 []Range, arg2 []RangeResult) ([]RangeResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Ranges", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]RangeResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Ranges indicates an expected call of Ranges.
+func (mr *MockDiffMockRecorder) Ranges(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ranges", reflect.TypeOf((*MockDiff)(nil).Ranges), arg0, arg1, arg2)
+}
+
+// RemoveId mocks base method.
+func (m *MockDiff) RemoveId(arg0 string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RemoveId", arg0)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveId indicates an expected call of RemoveId.
+func (mr *MockDiffMockRecorder) RemoveId(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveId", reflect.TypeOf((*MockDiff)(nil).RemoveId), arg0)
+}
+
+// Set mocks base method.
+func (m *MockDiff) Set(arg0 ...Element) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{}
+	for _, a := range arg0 {
+		varargs = append(varargs, a)
+	}
+	m.ctrl.Call(m, "Set", varargs...)
+}
+
+// Set indicates an expected call of Set.
+func (mr *MockDiffMockRecorder) Set(arg0 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDiff)(nil).Set), arg0...)
+}
+
+// MockRemote is a mock of Remote interface.
+type MockRemote struct {
+	ctrl     *gomock.Controller
+	recorder *MockRemoteMockRecorder
+}
+
+// MockRemoteMockRecorder is the mock recorder for MockRemote.
+type MockRemoteMockRecorder struct {
+	mock *MockRemote
+}
+
+// NewMockRemote creates a new mock instance.
+func NewMockRemote(ctrl *gomock.Controller) *MockRemote {
+	mock := &MockRemote{ctrl: ctrl}
+	mock.recorder = &MockRemoteMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRemote) EXPECT() *MockRemoteMockRecorder {
+	return m.recorder
+}
+
+// Ranges mocks base method.
+func (m *MockRemote) Ranges(arg0 context.Context, arg1 []Range, arg2 []RangeResult) ([]RangeResult, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Ranges", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]RangeResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Ranges indicates an expected call of Ranges.
+func (mr *MockRemoteMockRecorder) Ranges(arg0, arg1, arg2 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ranges", reflect.TypeOf((*MockRemote)(nil).Ranges), arg0, arg1, arg2)
+}