diff --git a/.mockery.yaml b/.mockery.yaml index f2cc0260e..aa85066c2 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -44,3 +44,12 @@ packages: github.com/anyproto/anytype-heart/core/block/object/objectcache: interfaces: Cache: + github.com/anyproto/anytype-heart/core/indexer: + interfaces: + Indexer: + github.com/anyproto/anytype-heart/space/spacecore: + interfaces: + SpaceCoreService: + github.com/anyproto/anytype-heart/space: + interfaces: + bundledObjectsInstaller: diff --git a/core/indexer/mock_indexer/mock_Indexer.go b/core/indexer/mock_indexer/mock_Indexer.go new file mode 100644 index 000000000..cb6c8b1a9 --- /dev/null +++ b/core/indexer/mock_indexer/mock_Indexer.go @@ -0,0 +1,420 @@ +// Code generated by mockery v2.34.1. DO NOT EDIT. + +package mock_indexer + +import ( + context "context" + + app "github.com/anyproto/any-sync/app" + mock "github.com/stretchr/testify/mock" + + smartblock "github.com/anyproto/anytype-heart/core/block/editor/smartblock" +) + +// MockIndexer is an autogenerated mock type for the Indexer type +type MockIndexer struct { + mock.Mock +} + +type MockIndexer_Expecter struct { + mock *mock.Mock +} + +func (_m *MockIndexer) EXPECT() *MockIndexer_Expecter { + return &MockIndexer_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function with given fields: ctx +func (_m *MockIndexer) Close(ctx context.Context) error { + ret := _m.Called(ctx) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockIndexer_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockIndexer_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockIndexer_Expecter) Close(ctx interface{}) *MockIndexer_Close_Call { + return &MockIndexer_Close_Call{Call: _e.mock.On("Close", ctx)} +} + +func (_c *MockIndexer_Close_Call) Run(run func(ctx context.Context)) *MockIndexer_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockIndexer_Close_Call) Return(err error) *MockIndexer_Close_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockIndexer_Close_Call) RunAndReturn(run func(context.Context) error) *MockIndexer_Close_Call { + _c.Call.Return(run) + return _c +} + +// ForceFTIndex provides a mock function with given fields: +func (_m *MockIndexer) ForceFTIndex() { + _m.Called() +} + +// MockIndexer_ForceFTIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForceFTIndex' +type MockIndexer_ForceFTIndex_Call struct { + *mock.Call +} + +// ForceFTIndex is a helper method to define mock.On call +func (_e *MockIndexer_Expecter) ForceFTIndex() *MockIndexer_ForceFTIndex_Call { + return &MockIndexer_ForceFTIndex_Call{Call: _e.mock.On("ForceFTIndex")} +} + +func (_c *MockIndexer_ForceFTIndex_Call) Run(run func()) *MockIndexer_ForceFTIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIndexer_ForceFTIndex_Call) Return() *MockIndexer_ForceFTIndex_Call { + _c.Call.Return() + return _c +} + +func (_c *MockIndexer_ForceFTIndex_Call) RunAndReturn(run func()) *MockIndexer_ForceFTIndex_Call { + _c.Call.Return(run) + return _c +} + +// Index provides a mock function with given fields: ctx, info, options +func (_m *MockIndexer) Index(ctx context.Context, info smartblock.DocInfo, options ...smartblock.IndexOption) error { + _va := make([]interface{}, len(options)) + for _i := range options { + _va[_i] = options[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, info) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, smartblock.DocInfo, ...smartblock.IndexOption) error); ok { + r0 = rf(ctx, info, options...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockIndexer_Index_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Index' +type MockIndexer_Index_Call struct { + *mock.Call +} + +// Index is a helper method to define mock.On call +// - ctx context.Context +// - info smartblock.DocInfo +// - options ...smartblock.IndexOption +func (_e *MockIndexer_Expecter) Index(ctx interface{}, info interface{}, options ...interface{}) *MockIndexer_Index_Call { + return &MockIndexer_Index_Call{Call: _e.mock.On("Index", + append([]interface{}{ctx, info}, options...)...)} +} + +func (_c *MockIndexer_Index_Call) Run(run func(ctx context.Context, info smartblock.DocInfo, options ...smartblock.IndexOption)) *MockIndexer_Index_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]smartblock.IndexOption, len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(smartblock.IndexOption) + } + } + run(args[0].(context.Context), args[1].(smartblock.DocInfo), variadicArgs...) + }) + return _c +} + +func (_c *MockIndexer_Index_Call) Return(_a0 error) *MockIndexer_Index_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIndexer_Index_Call) RunAndReturn(run func(context.Context, smartblock.DocInfo, ...smartblock.IndexOption) error) *MockIndexer_Index_Call { + _c.Call.Return(run) + return _c +} + +// Init provides a mock function with given fields: a +func (_m *MockIndexer) Init(a *app.App) error { + ret := _m.Called(a) + + var r0 error + if rf, ok := ret.Get(0).(func(*app.App) error); ok { + r0 = rf(a) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockIndexer_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init' +type MockIndexer_Init_Call struct { + *mock.Call +} + +// Init is a helper method to define mock.On call +// - a *app.App +func (_e *MockIndexer_Expecter) Init(a interface{}) *MockIndexer_Init_Call { + return &MockIndexer_Init_Call{Call: _e.mock.On("Init", a)} +} + +func (_c *MockIndexer_Init_Call) Run(run func(a *app.App)) *MockIndexer_Init_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.App)) + }) + return _c +} + +func (_c *MockIndexer_Init_Call) Return(err error) *MockIndexer_Init_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockIndexer_Init_Call) RunAndReturn(run func(*app.App) error) *MockIndexer_Init_Call { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with given fields: +func (_m *MockIndexer) Name() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockIndexer_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type MockIndexer_Name_Call struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *MockIndexer_Expecter) Name() *MockIndexer_Name_Call { + return &MockIndexer_Name_Call{Call: _e.mock.On("Name")} +} + +func (_c *MockIndexer_Name_Call) Run(run func()) *MockIndexer_Name_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIndexer_Name_Call) Return(name string) *MockIndexer_Name_Call { + _c.Call.Return(name) + return _c +} + +func (_c *MockIndexer_Name_Call) RunAndReturn(run func() string) *MockIndexer_Name_Call { + _c.Call.Return(run) + return _c +} + +// ReindexCommonObjects provides a mock function with given fields: +func (_m *MockIndexer) ReindexCommonObjects() error { + ret := _m.Called() + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockIndexer_ReindexCommonObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReindexCommonObjects' +type MockIndexer_ReindexCommonObjects_Call struct { + *mock.Call +} + +// ReindexCommonObjects is a helper method to define mock.On call +func (_e *MockIndexer_Expecter) ReindexCommonObjects() *MockIndexer_ReindexCommonObjects_Call { + return &MockIndexer_ReindexCommonObjects_Call{Call: _e.mock.On("ReindexCommonObjects")} +} + +func (_c *MockIndexer_ReindexCommonObjects_Call) Run(run func()) *MockIndexer_ReindexCommonObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIndexer_ReindexCommonObjects_Call) Return(_a0 error) *MockIndexer_ReindexCommonObjects_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIndexer_ReindexCommonObjects_Call) RunAndReturn(run func() error) *MockIndexer_ReindexCommonObjects_Call { + _c.Call.Return(run) + return _c +} + +// ReindexSpace provides a mock function with given fields: spaceID +func (_m *MockIndexer) ReindexSpace(spaceID string) error { + ret := _m.Called(spaceID) + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(spaceID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockIndexer_ReindexSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReindexSpace' +type MockIndexer_ReindexSpace_Call struct { + *mock.Call +} + +// ReindexSpace is a helper method to define mock.On call +// - spaceID string +func (_e *MockIndexer_Expecter) ReindexSpace(spaceID interface{}) *MockIndexer_ReindexSpace_Call { + return &MockIndexer_ReindexSpace_Call{Call: _e.mock.On("ReindexSpace", spaceID)} +} + +func (_c *MockIndexer_ReindexSpace_Call) Run(run func(spaceID string)) *MockIndexer_ReindexSpace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string)) + }) + return _c +} + +func (_c *MockIndexer_ReindexSpace_Call) Return(_a0 error) *MockIndexer_ReindexSpace_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIndexer_ReindexSpace_Call) RunAndReturn(run func(string) error) *MockIndexer_ReindexSpace_Call { + _c.Call.Return(run) + return _c +} + +// Run provides a mock function with given fields: ctx +func (_m *MockIndexer) Run(ctx context.Context) error { + ret := _m.Called(ctx) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockIndexer_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type MockIndexer_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockIndexer_Expecter) Run(ctx interface{}) *MockIndexer_Run_Call { + return &MockIndexer_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *MockIndexer_Run_Call) Run(run func(ctx context.Context)) *MockIndexer_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockIndexer_Run_Call) Return(err error) *MockIndexer_Run_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockIndexer_Run_Call) RunAndReturn(run func(context.Context) error) *MockIndexer_Run_Call { + _c.Call.Return(run) + return _c +} + +// StartFullTextIndex provides a mock function with given fields: +func (_m *MockIndexer) StartFullTextIndex() error { + ret := _m.Called() + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockIndexer_StartFullTextIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartFullTextIndex' +type MockIndexer_StartFullTextIndex_Call struct { + *mock.Call +} + +// StartFullTextIndex is a helper method to define mock.On call +func (_e *MockIndexer_Expecter) StartFullTextIndex() *MockIndexer_StartFullTextIndex_Call { + return &MockIndexer_StartFullTextIndex_Call{Call: _e.mock.On("StartFullTextIndex")} +} + +func (_c *MockIndexer_StartFullTextIndex_Call) Run(run func()) *MockIndexer_StartFullTextIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockIndexer_StartFullTextIndex_Call) Return(_a0 error) *MockIndexer_StartFullTextIndex_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockIndexer_StartFullTextIndex_Call) RunAndReturn(run func() error) *MockIndexer_StartFullTextIndex_Call { + _c.Call.Return(run) + return _c +} + +// NewMockIndexer creates a new instance of MockIndexer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockIndexer(t interface { + mock.TestingT + Cleanup(func()) +}) *MockIndexer { + mock := &MockIndexer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/space/mock_space/mock_bundledObjectsInstaller.go b/space/mock_space/mock_bundledObjectsInstaller.go new file mode 100644 index 000000000..d6e9f1d81 --- /dev/null +++ b/space/mock_space/mock_bundledObjectsInstaller.go @@ -0,0 +1,186 @@ +// Code generated by mockery v2.34.1. DO NOT EDIT. + +package mock_space + +import ( + context "context" + + app "github.com/anyproto/any-sync/app" + types "github.com/gogo/protobuf/types" + mock "github.com/stretchr/testify/mock" +) + +// MockbundledObjectsInstaller is an autogenerated mock type for the bundledObjectsInstaller type +type MockbundledObjectsInstaller struct { + mock.Mock +} + +type MockbundledObjectsInstaller_Expecter struct { + mock *mock.Mock +} + +func (_m *MockbundledObjectsInstaller) EXPECT() *MockbundledObjectsInstaller_Expecter { + return &MockbundledObjectsInstaller_Expecter{mock: &_m.Mock} +} + +// Init provides a mock function with given fields: a +func (_m *MockbundledObjectsInstaller) Init(a *app.App) error { + ret := _m.Called(a) + + var r0 error + if rf, ok := ret.Get(0).(func(*app.App) error); ok { + r0 = rf(a) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockbundledObjectsInstaller_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init' +type MockbundledObjectsInstaller_Init_Call struct { + *mock.Call +} + +// Init is a helper method to define mock.On call +// - a *app.App +func (_e *MockbundledObjectsInstaller_Expecter) Init(a interface{}) *MockbundledObjectsInstaller_Init_Call { + return &MockbundledObjectsInstaller_Init_Call{Call: _e.mock.On("Init", a)} +} + +func (_c *MockbundledObjectsInstaller_Init_Call) Run(run func(a *app.App)) *MockbundledObjectsInstaller_Init_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.App)) + }) + return _c +} + +func (_c *MockbundledObjectsInstaller_Init_Call) Return(err error) *MockbundledObjectsInstaller_Init_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockbundledObjectsInstaller_Init_Call) RunAndReturn(run func(*app.App) error) *MockbundledObjectsInstaller_Init_Call { + _c.Call.Return(run) + return _c +} + +// InstallBundledObjects provides a mock function with given fields: ctx, spaceID, ids +func (_m *MockbundledObjectsInstaller) InstallBundledObjects(ctx context.Context, spaceID string, ids []string) ([]string, []*types.Struct, error) { + ret := _m.Called(ctx, spaceID, ids) + + var r0 []string + var r1 []*types.Struct + var r2 error + if rf, ok := ret.Get(0).(func(context.Context, string, []string) ([]string, []*types.Struct, error)); ok { + return rf(ctx, spaceID, ids) + } + if rf, ok := ret.Get(0).(func(context.Context, string, []string) []string); ok { + r0 = rf(ctx, spaceID, ids) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, []string) []*types.Struct); ok { + r1 = rf(ctx, spaceID, ids) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).([]*types.Struct) + } + } + + if rf, ok := ret.Get(2).(func(context.Context, string, []string) error); ok { + r2 = rf(ctx, spaceID, ids) + } else { + r2 = ret.Error(2) + } + + return r0, r1, r2 +} + +// MockbundledObjectsInstaller_InstallBundledObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InstallBundledObjects' +type MockbundledObjectsInstaller_InstallBundledObjects_Call struct { + *mock.Call +} + +// InstallBundledObjects is a helper method to define mock.On call +// - ctx context.Context +// - spaceID string +// - ids []string +func (_e *MockbundledObjectsInstaller_Expecter) InstallBundledObjects(ctx interface{}, spaceID interface{}, ids interface{}) *MockbundledObjectsInstaller_InstallBundledObjects_Call { + return &MockbundledObjectsInstaller_InstallBundledObjects_Call{Call: _e.mock.On("InstallBundledObjects", ctx, spaceID, ids)} +} + +func (_c *MockbundledObjectsInstaller_InstallBundledObjects_Call) Run(run func(ctx context.Context, spaceID string, ids []string)) *MockbundledObjectsInstaller_InstallBundledObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].([]string)) + }) + return _c +} + +func (_c *MockbundledObjectsInstaller_InstallBundledObjects_Call) Return(_a0 []string, _a1 []*types.Struct, _a2 error) *MockbundledObjectsInstaller_InstallBundledObjects_Call { + _c.Call.Return(_a0, _a1, _a2) + return _c +} + +func (_c *MockbundledObjectsInstaller_InstallBundledObjects_Call) RunAndReturn(run func(context.Context, string, []string) ([]string, []*types.Struct, error)) *MockbundledObjectsInstaller_InstallBundledObjects_Call { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with given fields: +func (_m *MockbundledObjectsInstaller) Name() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockbundledObjectsInstaller_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type MockbundledObjectsInstaller_Name_Call struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *MockbundledObjectsInstaller_Expecter) Name() *MockbundledObjectsInstaller_Name_Call { + return &MockbundledObjectsInstaller_Name_Call{Call: _e.mock.On("Name")} +} + +func (_c *MockbundledObjectsInstaller_Name_Call) Run(run func()) *MockbundledObjectsInstaller_Name_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockbundledObjectsInstaller_Name_Call) Return(name string) *MockbundledObjectsInstaller_Name_Call { + _c.Call.Return(name) + return _c +} + +func (_c *MockbundledObjectsInstaller_Name_Call) RunAndReturn(run func() string) *MockbundledObjectsInstaller_Name_Call { + _c.Call.Return(run) + return _c +} + +// NewMockbundledObjectsInstaller creates a new instance of MockbundledObjectsInstaller. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockbundledObjectsInstaller(t interface { + mock.TestingT + Cleanup(func()) +}) *MockbundledObjectsInstaller { + mock := &MockbundledObjectsInstaller{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/space/service.go b/space/service.go index b62b3b0ee..a0db99b25 100644 --- a/space/service.go +++ b/space/service.go @@ -32,6 +32,7 @@ type spaceIndexer interface { type bundledObjectsInstaller interface { InstallBundledObjects(ctx context.Context, spaceID string, ids []string) ([]string, []*types.Struct, error) + app.Component } type SpaceService interface { @@ -63,6 +64,8 @@ type service struct { ctxCancel context.CancelFunc repKey uint64 + + wakeUpViewsCh chan struct{} } func (s *service) Init(a *app.App) (err error) { @@ -94,7 +97,14 @@ func (s *service) Run(ctx context.Context) (err error) { return } s.techSpace = newTechSpace(s, techSpaceCore) - go s.techSpace.wakeUpViews(s.ctx) + + s.wakeUpViewsCh = make(chan struct{}) + go func() { + defer close(s.wakeUpViewsCh) + if e := s.techSpace.wakeUpViews(s.ctx); e != nil { + log.Warn("wakeUpViews error", zap.Error(e)) + } + }() err = s.indexer.ReindexCommonObjects() if err != nil { diff --git a/space/service_test.go b/space/service_test.go index 91e5eaf69..4c835973c 100644 --- a/space/service_test.go +++ b/space/service_test.go @@ -1,11 +1,87 @@ package space -import "testing" +import ( + "context" + "testing" + + "github.com/anyproto/any-sync/app" + "github.com/anyproto/any-sync/commonspace/mock_commonspace" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + + "github.com/anyproto/anytype-heart/core/block/object/objectcache" + "github.com/anyproto/anytype-heart/core/block/object/objectcache/mock_objectcache" + "github.com/anyproto/anytype-heart/core/indexer/mock_indexer" + "github.com/anyproto/anytype-heart/space/mock_space" + "github.com/anyproto/anytype-heart/space/spacecore" + "github.com/anyproto/anytype-heart/space/spacecore/mock_spacecore" + "github.com/anyproto/anytype-heart/tests/testutil" +) + +var ctx = context.Background() + +const ( + testPersonalSpaceID = "personal.id" +) + +func TestService_Init(t *testing.T) { + fx := newFixture(t) + defer fx.finish(t) +} func newFixture(t *testing.T) *fixture { - fx := &fixture{} + ctrl := gomock.NewController(t) + fx := &fixture{ + service: New().(*service), + a: new(app.App), + ctrl: ctrl, + objectCache: mock_objectcache.NewMockCache(t), + indexer: mock_indexer.NewMockIndexer(t), + spaceCore: mock_spacecore.NewMockSpaceCoreService(t), + installer: mock_space.NewMockbundledObjectsInstaller(t), + personalSpace: mock_commonspace.NewMockSpace(ctrl), + } + + fx.objectCache.EXPECT().Name().Return(objectcache.CName).Maybe() + fx.objectCache.EXPECT().Init(mock.Anything).Maybe() + fx.objectCache.EXPECT().Run(mock.Anything).Maybe() + fx.objectCache.EXPECT().Close(mock.Anything).Maybe() + + fx.a.Register(testutil.PrepareMock(fx.a, fx.objectCache)). + Register(testutil.PrepareMock(fx.a, fx.indexer)). + Register(testutil.PrepareMock(fx.a, fx.spaceCore)). + Register(testutil.PrepareMock(fx.a, fx.installer)). + Register(fx.service) + + fx.expectRun() + + require.NoError(t, fx.a.Start(ctx)) + return fx } type fixture struct { + *service + objectCache *mock_objectcache.MockCache + indexer *mock_indexer.MockIndexer + spaceCore *mock_spacecore.MockSpaceCoreService + installer *mock_space.MockbundledObjectsInstaller + a *app.App + ctrl *gomock.Controller + personalSpace *mock_commonspace.MockSpace +} + +func (fx *fixture) expectRun() { + fx.spaceCore.EXPECT().DeriveID(ctx, spacecore.SpaceType).Return(testPersonalSpaceID, nil) + fx.spaceCore.EXPECT().Derive(ctx, spacecore.TechSpaceType).Return(&spacecore.AnySpace{Space: fx.personalSpace}, nil) + fx.indexer.EXPECT().ReindexCommonObjects() +} + +func (fx *fixture) finish(t *testing.T) { + if fx.wakeUpViewsCh != nil { + <-fx.wakeUpViewsCh + } + require.NoError(t, fx.a.Close(ctx)) + fx.ctrl.Finish() } diff --git a/space/spacecore/mock_space/commonspace_space_mock.go b/space/spacecore/mock_space/commonspace_space_mock.go deleted file mode 100644 index daf12051f..000000000 --- a/space/spacecore/mock_space/commonspace_space_mock.go +++ /dev/null @@ -1,293 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/anyproto/any-sync/commonspace (interfaces: Space) -// -// Generated by this command: -// -// mockgen -package mock_space -destination ./mock_space/commonspace_space_mock.go github.com/anyproto/any-sync/commonspace Space -// -// Package mock_space is a generated GoMock package. -package mock_space - -import ( - context "context" - reflect "reflect" - time "time" - - commonspace "github.com/anyproto/any-sync/commonspace" - headsync "github.com/anyproto/any-sync/commonspace/headsync" - syncacl "github.com/anyproto/any-sync/commonspace/object/acl/syncacl" - treesyncer "github.com/anyproto/any-sync/commonspace/object/treesyncer" - objectsync "github.com/anyproto/any-sync/commonspace/objectsync" - objecttreebuilder "github.com/anyproto/any-sync/commonspace/objecttreebuilder" - spacestorage "github.com/anyproto/any-sync/commonspace/spacestorage" - spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto" - syncstatus "github.com/anyproto/any-sync/commonspace/syncstatus" - peer "github.com/anyproto/any-sync/net/peer" - gomock "go.uber.org/mock/gomock" -) - -// MockSpace is a mock of Space interface. -type MockSpace struct { - ctrl *gomock.Controller - recorder *MockSpaceMockRecorder -} - -// MockSpaceMockRecorder is the mock recorder for MockSpace. -type MockSpaceMockRecorder struct { - mock *MockSpace -} - -// NewMockSpace creates a new mock instance. -func NewMockSpace(ctrl *gomock.Controller) *MockSpace { - mock := &MockSpace{ctrl: ctrl} - mock.recorder = &MockSpaceMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSpace) EXPECT() *MockSpaceMockRecorder { - return m.recorder -} - -// Acl mocks base method. -func (m *MockSpace) Acl() syncacl.SyncAcl { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Acl") - ret0, _ := ret[0].(syncacl.SyncAcl) - return ret0 -} - -// Acl indicates an expected call of Acl. -func (mr *MockSpaceMockRecorder) Acl() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Acl", reflect.TypeOf((*MockSpace)(nil).Acl)) -} - -// Close mocks base method. -func (m *MockSpace) 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 *MockSpaceMockRecorder) Close() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSpace)(nil).Close)) -} - -// DebugAllHeads mocks base method. -func (m *MockSpace) DebugAllHeads() []headsync.TreeHeads { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DebugAllHeads") - ret0, _ := ret[0].([]headsync.TreeHeads) - return ret0 -} - -// DebugAllHeads indicates an expected call of DebugAllHeads. -func (mr *MockSpaceMockRecorder) DebugAllHeads() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugAllHeads", reflect.TypeOf((*MockSpace)(nil).DebugAllHeads)) -} - -// DeleteTree mocks base method. -func (m *MockSpace) DeleteTree(arg0 context.Context, arg1 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTree", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteTree indicates an expected call of DeleteTree. -func (mr *MockSpaceMockRecorder) DeleteTree(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTree", reflect.TypeOf((*MockSpace)(nil).DeleteTree), arg0, arg1) -} - -// Description mocks base method. -func (m *MockSpace) Description() (commonspace.SpaceDescription, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Description") - ret0, _ := ret[0].(commonspace.SpaceDescription) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Description indicates an expected call of Description. -func (mr *MockSpaceMockRecorder) Description() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Description", reflect.TypeOf((*MockSpace)(nil).Description)) -} - -// GetNodePeers mocks base method. -func (m *MockSpace) GetNodePeers(arg0 context.Context) ([]peer.Peer, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNodePeers", arg0) - ret0, _ := ret[0].([]peer.Peer) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetNodePeers indicates an expected call of GetNodePeers. -func (mr *MockSpaceMockRecorder) GetNodePeers(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodePeers", reflect.TypeOf((*MockSpace)(nil).GetNodePeers), arg0) -} - -// HandleMessage mocks base method. -func (m *MockSpace) HandleMessage(arg0 context.Context, arg1 objectsync.HandleMessage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HandleMessage", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// HandleMessage indicates an expected call of HandleMessage. -func (mr *MockSpaceMockRecorder) HandleMessage(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockSpace)(nil).HandleMessage), arg0, arg1) -} - -// HandleRangeRequest mocks base method. -func (m *MockSpace) HandleRangeRequest(arg0 context.Context, arg1 *spacesyncproto.HeadSyncRequest) (*spacesyncproto.HeadSyncResponse, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HandleRangeRequest", arg0, arg1) - ret0, _ := ret[0].(*spacesyncproto.HeadSyncResponse) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// HandleRangeRequest indicates an expected call of HandleRangeRequest. -func (mr *MockSpaceMockRecorder) HandleRangeRequest(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRangeRequest", reflect.TypeOf((*MockSpace)(nil).HandleRangeRequest), arg0, arg1) -} - -// HandleSyncRequest mocks base method. -func (m *MockSpace) HandleSyncRequest(arg0 context.Context, arg1 *spacesyncproto.ObjectSyncMessage) (*spacesyncproto.ObjectSyncMessage, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HandleSyncRequest", arg0, arg1) - ret0, _ := ret[0].(*spacesyncproto.ObjectSyncMessage) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// HandleSyncRequest indicates an expected call of HandleSyncRequest. -func (mr *MockSpaceMockRecorder) HandleSyncRequest(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleSyncRequest", reflect.TypeOf((*MockSpace)(nil).HandleSyncRequest), arg0, arg1) -} - -// Id mocks base method. -func (m *MockSpace) 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 *MockSpaceMockRecorder) Id() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockSpace)(nil).Id)) -} - -// Init mocks base method. -func (m *MockSpace) Init(arg0 context.Context) 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 *MockSpaceMockRecorder) Init(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpace)(nil).Init), arg0) -} - -// Storage mocks base method. -func (m *MockSpace) Storage() spacestorage.SpaceStorage { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Storage") - ret0, _ := ret[0].(spacestorage.SpaceStorage) - return ret0 -} - -// Storage indicates an expected call of Storage. -func (mr *MockSpaceMockRecorder) Storage() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Storage", reflect.TypeOf((*MockSpace)(nil).Storage)) -} - -// StoredIds mocks base method. -func (m *MockSpace) StoredIds() []string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StoredIds") - ret0, _ := ret[0].([]string) - return ret0 -} - -// StoredIds indicates an expected call of StoredIds. -func (mr *MockSpaceMockRecorder) StoredIds() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StoredIds", reflect.TypeOf((*MockSpace)(nil).StoredIds)) -} - -// SyncStatus mocks base method. -func (m *MockSpace) SyncStatus() syncstatus.StatusUpdater { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SyncStatus") - ret0, _ := ret[0].(syncstatus.StatusUpdater) - return ret0 -} - -// SyncStatus indicates an expected call of SyncStatus. -func (mr *MockSpaceMockRecorder) SyncStatus() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncStatus", reflect.TypeOf((*MockSpace)(nil).SyncStatus)) -} - -// TreeBuilder mocks base method. -func (m *MockSpace) TreeBuilder() objecttreebuilder.TreeBuilder { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TreeBuilder") - ret0, _ := ret[0].(objecttreebuilder.TreeBuilder) - return ret0 -} - -// TreeBuilder indicates an expected call of TreeBuilder. -func (mr *MockSpaceMockRecorder) TreeBuilder() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeBuilder", reflect.TypeOf((*MockSpace)(nil).TreeBuilder)) -} - -// TreeSyncer mocks base method. -func (m *MockSpace) TreeSyncer() treesyncer.TreeSyncer { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TreeSyncer") - ret0, _ := ret[0].(treesyncer.TreeSyncer) - return ret0 -} - -// TreeSyncer indicates an expected call of TreeSyncer. -func (mr *MockSpaceMockRecorder) TreeSyncer() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TreeSyncer", reflect.TypeOf((*MockSpace)(nil).TreeSyncer)) -} - -// TryClose mocks base method. -func (m *MockSpace) TryClose(arg0 time.Duration) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TryClose", arg0) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TryClose indicates an expected call of TryClose. -func (mr *MockSpaceMockRecorder) TryClose(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryClose", reflect.TypeOf((*MockSpace)(nil).TryClose), arg0) -} diff --git a/space/spacecore/mock_space/service_mock.go b/space/spacecore/mock_space/service_mock.go deleted file mode 100644 index 5d9050261..000000000 --- a/space/spacecore/mock_space/service_mock.go +++ /dev/null @@ -1,202 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/anyproto/anytype-heart/space/spacecore (interfaces: SpaceCoreService) -// -// Generated by this command: -// -// mockgen -package mock_space -destination ./mock_space/service_mock.go github.com/anyproto/anytype-heart/space/spacecore SpaceCoreService -// -// Package mock_space is a generated GoMock package. -package mock_space - -import ( - context "context" - reflect "reflect" - - app "github.com/anyproto/any-sync/app" - streampool "github.com/anyproto/any-sync/net/streampool" - gomock "go.uber.org/mock/gomock" - - spacecore "github.com/anyproto/anytype-heart/space/spacecore" -) - -// MockSpaceCoreService is a mock of SpaceCoreService interface. -type MockSpaceCoreService struct { - ctrl *gomock.Controller - recorder *MockSpaceCoreServiceMockRecorder -} - -// MockSpaceCoreServiceMockRecorder is the mock recorder for MockSpaceCoreService. -type MockSpaceCoreServiceMockRecorder struct { - mock *MockSpaceCoreService -} - -// NewMockSpaceCoreService creates a new mock instance. -func NewMockSpaceCoreService(ctrl *gomock.Controller) *MockSpaceCoreService { - mock := &MockSpaceCoreService{ctrl: ctrl} - mock.recorder = &MockSpaceCoreServiceMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSpaceCoreService) EXPECT() *MockSpaceCoreServiceMockRecorder { - return m.recorder -} - -// Close mocks base method. -func (m *MockSpaceCoreService) 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 *MockSpaceCoreServiceMockRecorder) Close(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSpaceCoreService)(nil).Close), arg0) -} - -// Create mocks base method. -func (m *MockSpaceCoreService) Create(arg0 context.Context, arg1 uint64) (*spacecore.AnySpace, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1) - ret0, _ := ret[0].(*spacecore.AnySpace) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Create indicates an expected call of Create. -func (mr *MockSpaceCoreServiceMockRecorder) Create(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSpaceCoreService)(nil).Create), arg0, arg1) -} - -// Delete mocks base method. -func (m *MockSpaceCoreService) Delete(arg0 context.Context, arg1 string) (spacecore.NetworkStatus, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", arg0, arg1) - ret0, _ := ret[0].(spacecore.NetworkStatus) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Delete indicates an expected call of Delete. -func (mr *MockSpaceCoreServiceMockRecorder) Delete(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSpaceCoreService)(nil).Delete), arg0, arg1) -} - -// Derive mocks base method. -func (m *MockSpaceCoreService) Derive(arg0 context.Context, arg1 string) (*spacecore.AnySpace, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Derive", arg0, arg1) - ret0, _ := ret[0].(*spacecore.AnySpace) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Derive indicates an expected call of Derive. -func (mr *MockSpaceCoreServiceMockRecorder) Derive(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Derive", reflect.TypeOf((*MockSpaceCoreService)(nil).Derive), arg0, arg1) -} - -// DeriveID mocks base method. -func (m *MockSpaceCoreService) DeriveID(arg0 context.Context, arg1 string) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeriveID", arg0, arg1) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeriveID indicates an expected call of DeriveID. -func (mr *MockSpaceCoreServiceMockRecorder) DeriveID(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveID", reflect.TypeOf((*MockSpaceCoreService)(nil).DeriveID), arg0, arg1) -} - -// Get mocks base method. -func (m *MockSpaceCoreService) Get(arg0 context.Context, arg1 string) (*spacecore.AnySpace, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", arg0, arg1) - ret0, _ := ret[0].(*spacecore.AnySpace) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Get indicates an expected call of Get. -func (mr *MockSpaceCoreServiceMockRecorder) Get(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSpaceCoreService)(nil).Get), arg0, arg1) -} - -// Init mocks base method. -func (m *MockSpaceCoreService) 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 *MockSpaceCoreServiceMockRecorder) Init(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSpaceCoreService)(nil).Init), arg0) -} - -// Name mocks base method. -func (m *MockSpaceCoreService) 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 *MockSpaceCoreServiceMockRecorder) Name() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockSpaceCoreService)(nil).Name)) -} - -// RevertDeletion mocks base method. -func (m *MockSpaceCoreService) RevertDeletion(arg0 context.Context, arg1 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RevertDeletion", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// RevertDeletion indicates an expected call of RevertDeletion. -func (mr *MockSpaceCoreServiceMockRecorder) RevertDeletion(arg0, arg1 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevertDeletion", reflect.TypeOf((*MockSpaceCoreService)(nil).RevertDeletion), arg0, arg1) -} - -// Run mocks base method. -func (m *MockSpaceCoreService) 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 *MockSpaceCoreServiceMockRecorder) Run(arg0 any) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSpaceCoreService)(nil).Run), arg0) -} - -// StreamPool mocks base method. -func (m *MockSpaceCoreService) StreamPool() streampool.StreamPool { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StreamPool") - ret0, _ := ret[0].(streampool.StreamPool) - return ret0 -} - -// StreamPool indicates an expected call of StreamPool. -func (mr *MockSpaceCoreServiceMockRecorder) StreamPool() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamPool", reflect.TypeOf((*MockSpaceCoreService)(nil).StreamPool)) -} diff --git a/space/spacecore/mock_spacecore/mock_SpaceCoreService.go b/space/spacecore/mock_spacecore/mock_SpaceCoreService.go new file mode 100644 index 000000000..a48d56cdf --- /dev/null +++ b/space/spacecore/mock_spacecore/mock_SpaceCoreService.go @@ -0,0 +1,564 @@ +// Code generated by mockery v2.34.1. DO NOT EDIT. + +package mock_spacecore + +import ( + context "context" + + app "github.com/anyproto/any-sync/app" + streampool "github.com/anyproto/any-sync/net/streampool" + mock "github.com/stretchr/testify/mock" + + spacecore "github.com/anyproto/anytype-heart/space/spacecore" +) + +// MockSpaceCoreService is an autogenerated mock type for the SpaceCoreService type +type MockSpaceCoreService struct { + mock.Mock +} + +type MockSpaceCoreService_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSpaceCoreService) EXPECT() *MockSpaceCoreService_Expecter { + return &MockSpaceCoreService_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function with given fields: ctx +func (_m *MockSpaceCoreService) Close(ctx context.Context) error { + ret := _m.Called(ctx) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceCoreService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockSpaceCoreService_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockSpaceCoreService_Expecter) Close(ctx interface{}) *MockSpaceCoreService_Close_Call { + return &MockSpaceCoreService_Close_Call{Call: _e.mock.On("Close", ctx)} +} + +func (_c *MockSpaceCoreService_Close_Call) Run(run func(ctx context.Context)) *MockSpaceCoreService_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockSpaceCoreService_Close_Call) Return(err error) *MockSpaceCoreService_Close_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockSpaceCoreService_Close_Call) RunAndReturn(run func(context.Context) error) *MockSpaceCoreService_Close_Call { + _c.Call.Return(run) + return _c +} + +// Create provides a mock function with given fields: ctx, replicationKey +func (_m *MockSpaceCoreService) Create(ctx context.Context, replicationKey uint64) (*spacecore.AnySpace, error) { + ret := _m.Called(ctx, replicationKey) + + var r0 *spacecore.AnySpace + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, uint64) (*spacecore.AnySpace, error)); ok { + return rf(ctx, replicationKey) + } + if rf, ok := ret.Get(0).(func(context.Context, uint64) *spacecore.AnySpace); ok { + r0 = rf(ctx, replicationKey) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*spacecore.AnySpace) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, uint64) error); ok { + r1 = rf(ctx, replicationKey) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceCoreService_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type MockSpaceCoreService_Create_Call struct { + *mock.Call +} + +// Create is a helper method to define mock.On call +// - ctx context.Context +// - replicationKey uint64 +func (_e *MockSpaceCoreService_Expecter) Create(ctx interface{}, replicationKey interface{}) *MockSpaceCoreService_Create_Call { + return &MockSpaceCoreService_Create_Call{Call: _e.mock.On("Create", ctx, replicationKey)} +} + +func (_c *MockSpaceCoreService_Create_Call) Run(run func(ctx context.Context, replicationKey uint64)) *MockSpaceCoreService_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(uint64)) + }) + return _c +} + +func (_c *MockSpaceCoreService_Create_Call) Return(_a0 *spacecore.AnySpace, _a1 error) *MockSpaceCoreService_Create_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSpaceCoreService_Create_Call) RunAndReturn(run func(context.Context, uint64) (*spacecore.AnySpace, error)) *MockSpaceCoreService_Create_Call { + _c.Call.Return(run) + return _c +} + +// Delete provides a mock function with given fields: ctx, spaceID +func (_m *MockSpaceCoreService) Delete(ctx context.Context, spaceID string) (spacecore.NetworkStatus, error) { + ret := _m.Called(ctx, spaceID) + + var r0 spacecore.NetworkStatus + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (spacecore.NetworkStatus, error)); ok { + return rf(ctx, spaceID) + } + if rf, ok := ret.Get(0).(func(context.Context, string) spacecore.NetworkStatus); ok { + r0 = rf(ctx, spaceID) + } else { + r0 = ret.Get(0).(spacecore.NetworkStatus) + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, spaceID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceCoreService_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockSpaceCoreService_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +// - spaceID string +func (_e *MockSpaceCoreService_Expecter) Delete(ctx interface{}, spaceID interface{}) *MockSpaceCoreService_Delete_Call { + return &MockSpaceCoreService_Delete_Call{Call: _e.mock.On("Delete", ctx, spaceID)} +} + +func (_c *MockSpaceCoreService_Delete_Call) Run(run func(ctx context.Context, spaceID string)) *MockSpaceCoreService_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockSpaceCoreService_Delete_Call) Return(payload spacecore.NetworkStatus, err error) *MockSpaceCoreService_Delete_Call { + _c.Call.Return(payload, err) + return _c +} + +func (_c *MockSpaceCoreService_Delete_Call) RunAndReturn(run func(context.Context, string) (spacecore.NetworkStatus, error)) *MockSpaceCoreService_Delete_Call { + _c.Call.Return(run) + return _c +} + +// Derive provides a mock function with given fields: ctx, spaceType +func (_m *MockSpaceCoreService) Derive(ctx context.Context, spaceType string) (*spacecore.AnySpace, error) { + ret := _m.Called(ctx, spaceType) + + var r0 *spacecore.AnySpace + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (*spacecore.AnySpace, error)); ok { + return rf(ctx, spaceType) + } + if rf, ok := ret.Get(0).(func(context.Context, string) *spacecore.AnySpace); ok { + r0 = rf(ctx, spaceType) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*spacecore.AnySpace) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, spaceType) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceCoreService_Derive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Derive' +type MockSpaceCoreService_Derive_Call struct { + *mock.Call +} + +// Derive is a helper method to define mock.On call +// - ctx context.Context +// - spaceType string +func (_e *MockSpaceCoreService_Expecter) Derive(ctx interface{}, spaceType interface{}) *MockSpaceCoreService_Derive_Call { + return &MockSpaceCoreService_Derive_Call{Call: _e.mock.On("Derive", ctx, spaceType)} +} + +func (_c *MockSpaceCoreService_Derive_Call) Run(run func(ctx context.Context, spaceType string)) *MockSpaceCoreService_Derive_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockSpaceCoreService_Derive_Call) Return(space *spacecore.AnySpace, err error) *MockSpaceCoreService_Derive_Call { + _c.Call.Return(space, err) + return _c +} + +func (_c *MockSpaceCoreService_Derive_Call) RunAndReturn(run func(context.Context, string) (*spacecore.AnySpace, error)) *MockSpaceCoreService_Derive_Call { + _c.Call.Return(run) + return _c +} + +// DeriveID provides a mock function with given fields: ctx, spaceType +func (_m *MockSpaceCoreService) DeriveID(ctx context.Context, spaceType string) (string, error) { + ret := _m.Called(ctx, spaceType) + + var r0 string + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok { + return rf(ctx, spaceType) + } + if rf, ok := ret.Get(0).(func(context.Context, string) string); ok { + r0 = rf(ctx, spaceType) + } else { + r0 = ret.Get(0).(string) + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, spaceType) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceCoreService_DeriveID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeriveID' +type MockSpaceCoreService_DeriveID_Call struct { + *mock.Call +} + +// DeriveID is a helper method to define mock.On call +// - ctx context.Context +// - spaceType string +func (_e *MockSpaceCoreService_Expecter) DeriveID(ctx interface{}, spaceType interface{}) *MockSpaceCoreService_DeriveID_Call { + return &MockSpaceCoreService_DeriveID_Call{Call: _e.mock.On("DeriveID", ctx, spaceType)} +} + +func (_c *MockSpaceCoreService_DeriveID_Call) Run(run func(ctx context.Context, spaceType string)) *MockSpaceCoreService_DeriveID_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockSpaceCoreService_DeriveID_Call) Return(id string, err error) *MockSpaceCoreService_DeriveID_Call { + _c.Call.Return(id, err) + return _c +} + +func (_c *MockSpaceCoreService_DeriveID_Call) RunAndReturn(run func(context.Context, string) (string, error)) *MockSpaceCoreService_DeriveID_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function with given fields: ctx, id +func (_m *MockSpaceCoreService) Get(ctx context.Context, id string) (*spacecore.AnySpace, error) { + ret := _m.Called(ctx, id) + + var r0 *spacecore.AnySpace + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (*spacecore.AnySpace, error)); ok { + return rf(ctx, id) + } + if rf, ok := ret.Get(0).(func(context.Context, string) *spacecore.AnySpace); ok { + r0 = rf(ctx, id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*spacecore.AnySpace) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceCoreService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockSpaceCoreService_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockSpaceCoreService_Expecter) Get(ctx interface{}, id interface{}) *MockSpaceCoreService_Get_Call { + return &MockSpaceCoreService_Get_Call{Call: _e.mock.On("Get", ctx, id)} +} + +func (_c *MockSpaceCoreService_Get_Call) Run(run func(ctx context.Context, id string)) *MockSpaceCoreService_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockSpaceCoreService_Get_Call) Return(_a0 *spacecore.AnySpace, _a1 error) *MockSpaceCoreService_Get_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSpaceCoreService_Get_Call) RunAndReturn(run func(context.Context, string) (*spacecore.AnySpace, error)) *MockSpaceCoreService_Get_Call { + _c.Call.Return(run) + return _c +} + +// Init provides a mock function with given fields: a +func (_m *MockSpaceCoreService) Init(a *app.App) error { + ret := _m.Called(a) + + var r0 error + if rf, ok := ret.Get(0).(func(*app.App) error); ok { + r0 = rf(a) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceCoreService_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init' +type MockSpaceCoreService_Init_Call struct { + *mock.Call +} + +// Init is a helper method to define mock.On call +// - a *app.App +func (_e *MockSpaceCoreService_Expecter) Init(a interface{}) *MockSpaceCoreService_Init_Call { + return &MockSpaceCoreService_Init_Call{Call: _e.mock.On("Init", a)} +} + +func (_c *MockSpaceCoreService_Init_Call) Run(run func(a *app.App)) *MockSpaceCoreService_Init_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.App)) + }) + return _c +} + +func (_c *MockSpaceCoreService_Init_Call) Return(err error) *MockSpaceCoreService_Init_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockSpaceCoreService_Init_Call) RunAndReturn(run func(*app.App) error) *MockSpaceCoreService_Init_Call { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with given fields: +func (_m *MockSpaceCoreService) Name() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSpaceCoreService_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type MockSpaceCoreService_Name_Call struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *MockSpaceCoreService_Expecter) Name() *MockSpaceCoreService_Name_Call { + return &MockSpaceCoreService_Name_Call{Call: _e.mock.On("Name")} +} + +func (_c *MockSpaceCoreService_Name_Call) Run(run func()) *MockSpaceCoreService_Name_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSpaceCoreService_Name_Call) Return(name string) *MockSpaceCoreService_Name_Call { + _c.Call.Return(name) + return _c +} + +func (_c *MockSpaceCoreService_Name_Call) RunAndReturn(run func() string) *MockSpaceCoreService_Name_Call { + _c.Call.Return(run) + return _c +} + +// RevertDeletion provides a mock function with given fields: ctx, spaceID +func (_m *MockSpaceCoreService) RevertDeletion(ctx context.Context, spaceID string) error { + ret := _m.Called(ctx, spaceID) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { + r0 = rf(ctx, spaceID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceCoreService_RevertDeletion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevertDeletion' +type MockSpaceCoreService_RevertDeletion_Call struct { + *mock.Call +} + +// RevertDeletion is a helper method to define mock.On call +// - ctx context.Context +// - spaceID string +func (_e *MockSpaceCoreService_Expecter) RevertDeletion(ctx interface{}, spaceID interface{}) *MockSpaceCoreService_RevertDeletion_Call { + return &MockSpaceCoreService_RevertDeletion_Call{Call: _e.mock.On("RevertDeletion", ctx, spaceID)} +} + +func (_c *MockSpaceCoreService_RevertDeletion_Call) Run(run func(ctx context.Context, spaceID string)) *MockSpaceCoreService_RevertDeletion_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockSpaceCoreService_RevertDeletion_Call) Return(err error) *MockSpaceCoreService_RevertDeletion_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockSpaceCoreService_RevertDeletion_Call) RunAndReturn(run func(context.Context, string) error) *MockSpaceCoreService_RevertDeletion_Call { + _c.Call.Return(run) + return _c +} + +// Run provides a mock function with given fields: ctx +func (_m *MockSpaceCoreService) Run(ctx context.Context) error { + ret := _m.Called(ctx) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceCoreService_Run_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Run' +type MockSpaceCoreService_Run_Call struct { + *mock.Call +} + +// Run is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockSpaceCoreService_Expecter) Run(ctx interface{}) *MockSpaceCoreService_Run_Call { + return &MockSpaceCoreService_Run_Call{Call: _e.mock.On("Run", ctx)} +} + +func (_c *MockSpaceCoreService_Run_Call) Run(run func(ctx context.Context)) *MockSpaceCoreService_Run_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockSpaceCoreService_Run_Call) Return(err error) *MockSpaceCoreService_Run_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockSpaceCoreService_Run_Call) RunAndReturn(run func(context.Context) error) *MockSpaceCoreService_Run_Call { + _c.Call.Return(run) + return _c +} + +// StreamPool provides a mock function with given fields: +func (_m *MockSpaceCoreService) StreamPool() streampool.StreamPool { + ret := _m.Called() + + var r0 streampool.StreamPool + if rf, ok := ret.Get(0).(func() streampool.StreamPool); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(streampool.StreamPool) + } + } + + return r0 +} + +// MockSpaceCoreService_StreamPool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StreamPool' +type MockSpaceCoreService_StreamPool_Call struct { + *mock.Call +} + +// StreamPool is a helper method to define mock.On call +func (_e *MockSpaceCoreService_Expecter) StreamPool() *MockSpaceCoreService_StreamPool_Call { + return &MockSpaceCoreService_StreamPool_Call{Call: _e.mock.On("StreamPool")} +} + +func (_c *MockSpaceCoreService_StreamPool_Call) Run(run func()) *MockSpaceCoreService_StreamPool_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSpaceCoreService_StreamPool_Call) Return(_a0 streampool.StreamPool) *MockSpaceCoreService_StreamPool_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSpaceCoreService_StreamPool_Call) RunAndReturn(run func() streampool.StreamPool) *MockSpaceCoreService_StreamPool_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSpaceCoreService creates a new instance of MockSpaceCoreService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSpaceCoreService(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSpaceCoreService { + mock := &MockSpaceCoreService{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/space/spacecore/service.go b/space/spacecore/service.go index d4f2018cc..b40ec2880 100644 --- a/space/spacecore/service.go +++ b/space/spacecore/service.go @@ -55,8 +55,6 @@ type PoolManager interface { StreamPeerPool() pool.Pool } -//go:generate mockgen -package mock_space -destination ./mock_space/service_mock.go github.com/anyproto/anytype-heart/space/spacecore SpaceCoreService -//go:generate mockgen -package mock_space -destination ./mock_space/commonspace_space_mock.go github.com/anyproto/any-sync/commonspace Space type SpaceCoreService interface { Create(ctx context.Context, replicationKey uint64) (*AnySpace, error) Derive(ctx context.Context, spaceType string) (space *AnySpace, err error)