From b9c942410337323281a56bde66bed061eed3c1e0 Mon Sep 17 00:00:00 2001 From: mcrakhman Date: Fri, 30 Sep 2022 13:49:31 +0200 Subject: [PATCH] Add mock to write diffservice tests --- Makefile | 7 +- common/commonspace/cache/treecache.go | 1 + common/commonspace/cache/treecache_mock.go | 107 +++++++ .../diffservice/diffsyncer_test.go | 34 ++ .../spacesyncproto/drpcspaceclient_mock.go | 95 ++++++ .../commonspace/spacesyncproto/spacesync.go | 1 + common/commonspace/storage/storage.go | 1 + common/commonspace/storage/storage_mock.go | 193 ++++++++++++ common/nodeconf/configuration.go | 1 + common/nodeconf/configuration_mock.go | 123 ++++++++ go.mod | 8 +- go.sum | 6 + pkg/acl/list/list.go | 1 + pkg/acl/list/list_mock.go | 221 +++++++++++++ pkg/acl/tree/objecttree.go | 1 + pkg/acl/tree/objecttree_mock.go | 290 ++++++++++++++++++ pkg/ldiff/diff.go | 1 + pkg/ldiff/diff_mock.go | 135 ++++++++ 18 files changed, 1223 insertions(+), 3 deletions(-) create mode 100644 common/commonspace/cache/treecache_mock.go create mode 100644 common/commonspace/diffservice/diffsyncer_test.go create mode 100644 common/commonspace/spacesyncproto/drpcspaceclient_mock.go create mode 100644 common/commonspace/storage/storage_mock.go create mode 100644 common/nodeconf/configuration_mock.go create mode 100644 pkg/acl/list/list_mock.go create mode 100644 pkg/acl/tree/objecttree_mock.go create mode 100644 pkg/ldiff/diff_mock.go diff --git a/Makefile b/Makefile index 53ddd25b..ab14b8c4 100644 --- a/Makefile +++ b/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 \ No newline at end of file + 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 ./... \ No newline at end of file diff --git a/common/commonspace/cache/treecache.go b/common/commonspace/cache/treecache.go index 9983231f..4f72f0fd 100644 --- a/common/commonspace/cache/treecache.go +++ b/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 ( diff --git a/common/commonspace/cache/treecache_mock.go b/common/commonspace/cache/treecache_mock.go new file mode 100644 index 00000000..1a42b411 --- /dev/null +++ b/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) +} diff --git a/common/commonspace/diffservice/diffsyncer_test.go b/common/commonspace/diffservice/diffsyncer_test.go new file mode 100644 index 00000000..af199c54 --- /dev/null +++ b/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) +} diff --git a/common/commonspace/spacesyncproto/drpcspaceclient_mock.go b/common/commonspace/spacesyncproto/drpcspaceclient_mock.go new file mode 100644 index 00000000..4e8fd108 --- /dev/null +++ b/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) +} diff --git a/common/commonspace/spacesyncproto/spacesync.go b/common/commonspace/spacesyncproto/spacesync.go index d06102c4..e7924694 100644 --- a/common/commonspace/spacesyncproto/spacesync.go +++ b/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 ( diff --git a/common/commonspace/storage/storage.go b/common/commonspace/storage/storage.go index add06e08..60d852e6 100644 --- a/common/commonspace/storage/storage.go +++ b/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 ( diff --git a/common/commonspace/storage/storage_mock.go b/common/commonspace/storage/storage_mock.go new file mode 100644 index 00000000..c671fbad --- /dev/null +++ b/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) +} diff --git a/common/nodeconf/configuration.go b/common/nodeconf/configuration.go index 597d1018..cb169103 100644 --- a/common/nodeconf/configuration.go +++ b/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 ( diff --git a/common/nodeconf/configuration_mock.go b/common/nodeconf/configuration_mock.go new file mode 100644 index 00000000..c84e1848 --- /dev/null +++ b/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) +} diff --git a/go.mod b/go.mod index 9c60aa54..65064b7d 100644 --- a/go.mod +++ b/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 diff --git a/go.sum b/go.sum index 34c05834..8982483e 100644 --- a/go.sum +++ b/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= diff --git a/pkg/acl/list/list.go b/pkg/acl/list/list.go index 46a48681..0e2a31ed 100644 --- a/pkg/acl/list/list.go +++ b/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 ( diff --git a/pkg/acl/list/list_mock.go b/pkg/acl/list/list_mock.go new file mode 100644 index 00000000..215ca59e --- /dev/null +++ b/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)) +} diff --git a/pkg/acl/tree/objecttree.go b/pkg/acl/tree/objecttree.go index bb342070..95348feb 100644 --- a/pkg/acl/tree/objecttree.go +++ b/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 ( diff --git a/pkg/acl/tree/objecttree_mock.go b/pkg/acl/tree/objecttree_mock.go new file mode 100644 index 00000000..5632850d --- /dev/null +++ b/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)) +} diff --git a/pkg/ldiff/diff.go b/pkg/ldiff/diff.go index 6f276afd..10346e45 100644 --- a/pkg/ldiff/diff.go +++ b/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 diff --git a/pkg/ldiff/diff_mock.go b/pkg/ldiff/diff_mock.go new file mode 100644 index 00000000..e750af44 --- /dev/null +++ b/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) +}