diff --git a/.mockery.yaml b/.mockery.yaml index fb22b4bc4..d61015f96 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -58,6 +58,13 @@ packages: github.com/anyproto/anytype-heart/space/internal/techspace: interfaces: TechSpace: + github.com/anyproto/anytype-heart/space/spacefactory: + interfaces: + SpaceFactory: + github.com/anyproto/anytype-heart/space/internal/spacecontroller: + interfaces: + SpaceController: + DeleteController: github.com/anyproto/anytype-heart/space: interfaces: Service: diff --git a/core/subscription/mock_subscription/mock_subscription.go b/core/subscription/mock_subscription/mock_subscription.go new file mode 100644 index 000000000..dd7db4abe --- /dev/null +++ b/core/subscription/mock_subscription/mock_subscription.go @@ -0,0 +1,294 @@ +// Code generated by mockery v2.38.0. DO NOT EDIT. + +package mock_subscription + +import ( + mock "github.com/stretchr/testify/mock" + + types "github.com/gogo/protobuf/types" +) + +// Mocksubscription is an autogenerated mock type for the subscription type +type Mocksubscription struct { + mock.Mock +} + +type Mocksubscription_Expecter struct { + mock *mock.Mock +} + +func (_m *Mocksubscription) EXPECT() *Mocksubscription_Expecter { + return &Mocksubscription_Expecter{mock: &_m.Mock} +} + +// close provides a mock function with given fields: +func (_m *Mocksubscription) close() { + _m.Called() +} + +// Mocksubscription_close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'close' +type Mocksubscription_close_Call struct { + *mock.Call +} + +// close is a helper method to define mock.On call +func (_e *Mocksubscription_Expecter) close() *Mocksubscription_close_Call { + return &Mocksubscription_close_Call{Call: _e.mock.On("close")} +} + +func (_c *Mocksubscription_close_Call) Run(run func()) *Mocksubscription_close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Mocksubscription_close_Call) Return() *Mocksubscription_close_Call { + _c.Call.Return() + return _c +} + +func (_c *Mocksubscription_close_Call) RunAndReturn(run func()) *Mocksubscription_close_Call { + _c.Call.Return(run) + return _c +} + +// counters provides a mock function with given fields: +func (_m *Mocksubscription) counters() (int, int) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for counters") + } + + var r0 int + var r1 int + if rf, ok := ret.Get(0).(func() (int, int)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + if rf, ok := ret.Get(1).(func() int); ok { + r1 = rf() + } else { + r1 = ret.Get(1).(int) + } + + return r0, r1 +} + +// Mocksubscription_counters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'counters' +type Mocksubscription_counters_Call struct { + *mock.Call +} + +// counters is a helper method to define mock.On call +func (_e *Mocksubscription_Expecter) counters() *Mocksubscription_counters_Call { + return &Mocksubscription_counters_Call{Call: _e.mock.On("counters")} +} + +func (_c *Mocksubscription_counters_Call) Run(run func()) *Mocksubscription_counters_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Mocksubscription_counters_Call) Return(prev int, next int) *Mocksubscription_counters_Call { + _c.Call.Return(prev, next) + return _c +} + +func (_c *Mocksubscription_counters_Call) RunAndReturn(run func() (int, int)) *Mocksubscription_counters_Call { + _c.Call.Return(run) + return _c +} + +// getActiveRecords provides a mock function with given fields: +func (_m *Mocksubscription) getActiveRecords() []*types.Struct { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for getActiveRecords") + } + + var r0 []*types.Struct + if rf, ok := ret.Get(0).(func() []*types.Struct); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*types.Struct) + } + } + + return r0 +} + +// Mocksubscription_getActiveRecords_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'getActiveRecords' +type Mocksubscription_getActiveRecords_Call struct { + *mock.Call +} + +// getActiveRecords is a helper method to define mock.On call +func (_e *Mocksubscription_Expecter) getActiveRecords() *Mocksubscription_getActiveRecords_Call { + return &Mocksubscription_getActiveRecords_Call{Call: _e.mock.On("getActiveRecords")} +} + +func (_c *Mocksubscription_getActiveRecords_Call) Run(run func()) *Mocksubscription_getActiveRecords_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Mocksubscription_getActiveRecords_Call) Return(res []*types.Struct) *Mocksubscription_getActiveRecords_Call { + _c.Call.Return(res) + return _c +} + +func (_c *Mocksubscription_getActiveRecords_Call) RunAndReturn(run func() []*types.Struct) *Mocksubscription_getActiveRecords_Call { + _c.Call.Return(run) + return _c +} + +// hasDep provides a mock function with given fields: +func (_m *Mocksubscription) hasDep() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for hasDep") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// Mocksubscription_hasDep_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'hasDep' +type Mocksubscription_hasDep_Call struct { + *mock.Call +} + +// hasDep is a helper method to define mock.On call +func (_e *Mocksubscription_Expecter) hasDep() *Mocksubscription_hasDep_Call { + return &Mocksubscription_hasDep_Call{Call: _e.mock.On("hasDep")} +} + +func (_c *Mocksubscription_hasDep_Call) Run(run func()) *Mocksubscription_hasDep_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *Mocksubscription_hasDep_Call) Return(_a0 bool) *Mocksubscription_hasDep_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *Mocksubscription_hasDep_Call) RunAndReturn(run func() bool) *Mocksubscription_hasDep_Call { + _c.Call.Return(run) + return _c +} + +// init provides a mock function with given fields: entries +func (_m *Mocksubscription) init(entries []*subscription.entry) error { + ret := _m.Called(entries) + + if len(ret) == 0 { + panic("no return value specified for init") + } + + var r0 error + if rf, ok := ret.Get(0).(func([]*subscription.entry) error); ok { + r0 = rf(entries) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Mocksubscription_init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'init' +type Mocksubscription_init_Call struct { + *mock.Call +} + +// init is a helper method to define mock.On call +// - entries []*subscription.entry +func (_e *Mocksubscription_Expecter) init(entries interface{}) *Mocksubscription_init_Call { + return &Mocksubscription_init_Call{Call: _e.mock.On("init", entries)} +} + +func (_c *Mocksubscription_init_Call) Run(run func(entries []*subscription.entry)) *Mocksubscription_init_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]*subscription.entry)) + }) + return _c +} + +func (_c *Mocksubscription_init_Call) Return(err error) *Mocksubscription_init_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Mocksubscription_init_Call) RunAndReturn(run func([]*subscription.entry) error) *Mocksubscription_init_Call { + _c.Call.Return(run) + return _c +} + +// onChange provides a mock function with given fields: ctx +func (_m *Mocksubscription) onChange(ctx *subscription.opCtx) { + _m.Called(ctx) +} + +// Mocksubscription_onChange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'onChange' +type Mocksubscription_onChange_Call struct { + *mock.Call +} + +// onChange is a helper method to define mock.On call +// - ctx *subscription.opCtx +func (_e *Mocksubscription_Expecter) onChange(ctx interface{}) *Mocksubscription_onChange_Call { + return &Mocksubscription_onChange_Call{Call: _e.mock.On("onChange", ctx)} +} + +func (_c *Mocksubscription_onChange_Call) Run(run func(ctx *subscription.opCtx)) *Mocksubscription_onChange_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*subscription.opCtx)) + }) + return _c +} + +func (_c *Mocksubscription_onChange_Call) Return() *Mocksubscription_onChange_Call { + _c.Call.Return() + return _c +} + +func (_c *Mocksubscription_onChange_Call) RunAndReturn(run func(*subscription.opCtx)) *Mocksubscription_onChange_Call { + _c.Call.Return(run) + return _c +} + +// NewMocksubscription creates a new instance of Mocksubscription. 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 NewMocksubscription(t interface { + mock.TestingT + Cleanup(func()) +}) *Mocksubscription { + mock := &Mocksubscription{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/space/internal/spacecontroller/mock_spacecontroller/mock_DeleteController.go b/space/internal/spacecontroller/mock_spacecontroller/mock_DeleteController.go new file mode 100644 index 000000000..611a214f9 --- /dev/null +++ b/space/internal/spacecontroller/mock_spacecontroller/mock_DeleteController.go @@ -0,0 +1,82 @@ +// Code generated by mockery v2.38.0. DO NOT EDIT. + +package mock_spacecontroller + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// MockDeleteController is an autogenerated mock type for the DeleteController type +type MockDeleteController struct { + mock.Mock +} + +type MockDeleteController_Expecter struct { + mock *mock.Mock +} + +func (_m *MockDeleteController) EXPECT() *MockDeleteController_Expecter { + return &MockDeleteController_Expecter{mock: &_m.Mock} +} + +// Delete provides a mock function with given fields: ctx +func (_m *MockDeleteController) Delete(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Delete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockDeleteController_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete' +type MockDeleteController_Delete_Call struct { + *mock.Call +} + +// Delete is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockDeleteController_Expecter) Delete(ctx interface{}) *MockDeleteController_Delete_Call { + return &MockDeleteController_Delete_Call{Call: _e.mock.On("Delete", ctx)} +} + +func (_c *MockDeleteController_Delete_Call) Run(run func(ctx context.Context)) *MockDeleteController_Delete_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockDeleteController_Delete_Call) Return(_a0 error) *MockDeleteController_Delete_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeleteController_Delete_Call) RunAndReturn(run func(context.Context) error) *MockDeleteController_Delete_Call { + _c.Call.Return(run) + return _c +} + +// NewMockDeleteController creates a new instance of MockDeleteController. 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 NewMockDeleteController(t interface { + mock.TestingT + Cleanup(func()) +}) *MockDeleteController { + mock := &MockDeleteController{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/space/internal/spacecontroller/mock_spacecontroller/mock_SpaceController.go b/space/internal/spacecontroller/mock_spacecontroller/mock_SpaceController.go new file mode 100644 index 000000000..807e2b9df --- /dev/null +++ b/space/internal/spacecontroller/mock_spacecontroller/mock_SpaceController.go @@ -0,0 +1,362 @@ +// Code generated by mockery v2.38.0. DO NOT EDIT. + +package mock_spacecontroller + +import ( + context "context" + + mode "github.com/anyproto/anytype-heart/space/internal/spaceprocess/mode" + mock "github.com/stretchr/testify/mock" + + spaceinfo "github.com/anyproto/anytype-heart/space/spaceinfo" +) + +// MockSpaceController is an autogenerated mock type for the SpaceController type +type MockSpaceController struct { + mock.Mock +} + +type MockSpaceController_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSpaceController) EXPECT() *MockSpaceController_Expecter { + return &MockSpaceController_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function with given fields: ctx +func (_m *MockSpaceController) Close(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Close") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceController_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type MockSpaceController_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockSpaceController_Expecter) Close(ctx interface{}) *MockSpaceController_Close_Call { + return &MockSpaceController_Close_Call{Call: _e.mock.On("Close", ctx)} +} + +func (_c *MockSpaceController_Close_Call) Run(run func(ctx context.Context)) *MockSpaceController_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockSpaceController_Close_Call) Return(_a0 error) *MockSpaceController_Close_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSpaceController_Close_Call) RunAndReturn(run func(context.Context) error) *MockSpaceController_Close_Call { + _c.Call.Return(run) + return _c +} + +// Current provides a mock function with given fields: +func (_m *MockSpaceController) Current() interface{} { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Current") + } + + var r0 interface{} + if rf, ok := ret.Get(0).(func() interface{}); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interface{}) + } + } + + return r0 +} + +// MockSpaceController_Current_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Current' +type MockSpaceController_Current_Call struct { + *mock.Call +} + +// Current is a helper method to define mock.On call +func (_e *MockSpaceController_Expecter) Current() *MockSpaceController_Current_Call { + return &MockSpaceController_Current_Call{Call: _e.mock.On("Current")} +} + +func (_c *MockSpaceController_Current_Call) Run(run func()) *MockSpaceController_Current_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSpaceController_Current_Call) Return(_a0 interface{}) *MockSpaceController_Current_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSpaceController_Current_Call) RunAndReturn(run func() interface{}) *MockSpaceController_Current_Call { + _c.Call.Return(run) + return _c +} + +// Mode provides a mock function with given fields: +func (_m *MockSpaceController) Mode() mode.Mode { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Mode") + } + + var r0 mode.Mode + if rf, ok := ret.Get(0).(func() mode.Mode); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(mode.Mode) + } + + return r0 +} + +// MockSpaceController_Mode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Mode' +type MockSpaceController_Mode_Call struct { + *mock.Call +} + +// Mode is a helper method to define mock.On call +func (_e *MockSpaceController_Expecter) Mode() *MockSpaceController_Mode_Call { + return &MockSpaceController_Mode_Call{Call: _e.mock.On("Mode")} +} + +func (_c *MockSpaceController_Mode_Call) Run(run func()) *MockSpaceController_Mode_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSpaceController_Mode_Call) Return(_a0 mode.Mode) *MockSpaceController_Mode_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSpaceController_Mode_Call) RunAndReturn(run func() mode.Mode) *MockSpaceController_Mode_Call { + _c.Call.Return(run) + return _c +} + +// SpaceId provides a mock function with given fields: +func (_m *MockSpaceController) SpaceId() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for SpaceId") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSpaceController_SpaceId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpaceId' +type MockSpaceController_SpaceId_Call struct { + *mock.Call +} + +// SpaceId is a helper method to define mock.On call +func (_e *MockSpaceController_Expecter) SpaceId() *MockSpaceController_SpaceId_Call { + return &MockSpaceController_SpaceId_Call{Call: _e.mock.On("SpaceId")} +} + +func (_c *MockSpaceController_SpaceId_Call) Run(run func()) *MockSpaceController_SpaceId_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSpaceController_SpaceId_Call) Return(_a0 string) *MockSpaceController_SpaceId_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSpaceController_SpaceId_Call) RunAndReturn(run func() string) *MockSpaceController_SpaceId_Call { + _c.Call.Return(run) + return _c +} + +// Start provides a mock function with given fields: ctx +func (_m *MockSpaceController) Start(ctx context.Context) error { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Start") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = rf(ctx) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceController_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type MockSpaceController_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockSpaceController_Expecter) Start(ctx interface{}) *MockSpaceController_Start_Call { + return &MockSpaceController_Start_Call{Call: _e.mock.On("Start", ctx)} +} + +func (_c *MockSpaceController_Start_Call) Run(run func(ctx context.Context)) *MockSpaceController_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockSpaceController_Start_Call) Return(_a0 error) *MockSpaceController_Start_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSpaceController_Start_Call) RunAndReturn(run func(context.Context) error) *MockSpaceController_Start_Call { + _c.Call.Return(run) + return _c +} + +// UpdateRemoteStatus provides a mock function with given fields: ctx, status +func (_m *MockSpaceController) UpdateRemoteStatus(ctx context.Context, status spaceinfo.RemoteStatus) error { + ret := _m.Called(ctx, status) + + if len(ret) == 0 { + panic("no return value specified for UpdateRemoteStatus") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, spaceinfo.RemoteStatus) error); ok { + r0 = rf(ctx, status) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceController_UpdateRemoteStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRemoteStatus' +type MockSpaceController_UpdateRemoteStatus_Call struct { + *mock.Call +} + +// UpdateRemoteStatus is a helper method to define mock.On call +// - ctx context.Context +// - status spaceinfo.RemoteStatus +func (_e *MockSpaceController_Expecter) UpdateRemoteStatus(ctx interface{}, status interface{}) *MockSpaceController_UpdateRemoteStatus_Call { + return &MockSpaceController_UpdateRemoteStatus_Call{Call: _e.mock.On("UpdateRemoteStatus", ctx, status)} +} + +func (_c *MockSpaceController_UpdateRemoteStatus_Call) Run(run func(ctx context.Context, status spaceinfo.RemoteStatus)) *MockSpaceController_UpdateRemoteStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(spaceinfo.RemoteStatus)) + }) + return _c +} + +func (_c *MockSpaceController_UpdateRemoteStatus_Call) Return(_a0 error) *MockSpaceController_UpdateRemoteStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSpaceController_UpdateRemoteStatus_Call) RunAndReturn(run func(context.Context, spaceinfo.RemoteStatus) error) *MockSpaceController_UpdateRemoteStatus_Call { + _c.Call.Return(run) + return _c +} + +// UpdateStatus provides a mock function with given fields: ctx, status +func (_m *MockSpaceController) UpdateStatus(ctx context.Context, status spaceinfo.AccountStatus) error { + ret := _m.Called(ctx, status) + + if len(ret) == 0 { + panic("no return value specified for UpdateStatus") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, spaceinfo.AccountStatus) error); ok { + r0 = rf(ctx, status) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceController_UpdateStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateStatus' +type MockSpaceController_UpdateStatus_Call struct { + *mock.Call +} + +// UpdateStatus is a helper method to define mock.On call +// - ctx context.Context +// - status spaceinfo.AccountStatus +func (_e *MockSpaceController_Expecter) UpdateStatus(ctx interface{}, status interface{}) *MockSpaceController_UpdateStatus_Call { + return &MockSpaceController_UpdateStatus_Call{Call: _e.mock.On("UpdateStatus", ctx, status)} +} + +func (_c *MockSpaceController_UpdateStatus_Call) Run(run func(ctx context.Context, status spaceinfo.AccountStatus)) *MockSpaceController_UpdateStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(spaceinfo.AccountStatus)) + }) + return _c +} + +func (_c *MockSpaceController_UpdateStatus_Call) Return(_a0 error) *MockSpaceController_UpdateStatus_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSpaceController_UpdateStatus_Call) RunAndReturn(run func(context.Context, spaceinfo.AccountStatus) error) *MockSpaceController_UpdateStatus_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSpaceController creates a new instance of MockSpaceController. 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 NewMockSpaceController(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSpaceController { + mock := &MockSpaceController{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/space/metadata.go b/space/metadata.go index 6532f1670..6cb37f86c 100644 --- a/space/metadata.go +++ b/space/metadata.go @@ -12,6 +12,8 @@ import ( const anytypeMetadataPath = "m/SLIP-0021/anytype/account/metadata" +var deriveMetadata = deriveAccountMetadata + func deriveAccountMetadata(acc crypto.PrivKey) ([]byte, error) { symKey, err := deriveAccountEncKey(acc) if err != nil { diff --git a/space/service_test.go b/space/service_test.go index 73d1f9170..afa332574 100644 --- a/space/service_test.go +++ b/space/service_test.go @@ -1,133 +1,84 @@ package space -//import ( -// "context" -// "testing" -// -// "github.com/anyproto/any-sync/app" -// "github.com/anyproto/any-sync/commonspace/mock_commonspace" -// "github.com/anyproto/any-sync/commonspace/object/treesyncer/mock_treesyncer" -// "github.com/stretchr/testify/mock" -// "github.com/stretchr/testify/require" -// "go.uber.org/mock/gomock" -// -// "github.com/anyproto/anytype-heart/core/block/object/objectcache/mock_objectcache" -// "github.com/anyproto/anytype-heart/core/domain" -// "github.com/anyproto/anytype-heart/space/internal/techspace/mock_techspace" -// "github.com/anyproto/anytype-heart/space/spacecore" -// "github.com/anyproto/anytype-heart/space/spacecore/mock_spacecore" -// "github.com/anyproto/anytype-heart/space/spaceinfo" -// "github.com/anyproto/anytype-heart/tests/testutil" -//) -// -//var ctx = context.Background() -// -//const ( -// testPersonalSpaceID = "personal.id" -//) -// -//// TODO Revive tests -//func xTestService_Init(t *testing.T) { -// t.Run("existing account", func(t *testing.T) { -// fx := newFixture(t, false) -// defer fx.finish(t) -// }) -// t.Run("new account", func(t *testing.T) { -// fx := newFixture(t, true) -// defer fx.finish(t) -// }) -// -//} -// -//type indexerStub struct { -//} -// -//func (i *indexerStub) ReindexMarketplaceSpace(space Space) error { -// return nil -//} -// -//func (i *indexerStub) ReindexSpace(space Space) error { -// return nil -//} -// -//func (i *indexerStub) Init(a *app.App) (err error) { -// return nil -//} -// -//func (i *indexerStub) Name() (name string) { -// return "indexerStub" -//} -// -//func newFixture(t *testing.T, newAccount bool) *fixture { -// ctrl := gomock.NewController(t) -// fx := &fixture{ -// service: New().(*service), -// a: new(app.App), -// ctrl: ctrl, -// objectCache: mock_objectcache.NewMockCache(t), -// spaceCore: mock_spacecore.NewMockSpaceCoreService(t), -// installer: NewMockbundledObjectsInstaller(t), -// isNewAccount: NewMockisNewAccount(t), -// techSpace: mock_techspace.NewMockTechSpace(t), -// personalSpace: mock_commonspace.NewMockSpace(ctrl), -// } -// fx.a.Register(&indexerStub{}). -// Register(testutil.PrepareMock(ctx, fx.a, fx.spaceCore)). -// Register(testutil.PrepareMock(ctx, fx.a, fx.installer)). -// Register(testutil.PrepareMock(ctx, fx.a, fx.isNewAccount)). -// Register(fx.service) -// -// fx.isNewAccount.EXPECT().IsNewAccount().Return(newAccount) -// fx.personalSpace.EXPECT().Id().AnyTimes().Return(testPersonalSpaceID) -// -// fx.expectRun(newAccount) -// -// require.NoError(t, fx.a.Start(ctx)) -// -// return fx -//} -// -//type fixture struct { -// *service -// a *app.App -// objectCache *mock_objectcache.MockCache -// spaceCore *mock_spacecore.MockSpaceCoreService -// installer *MockbundledObjectsInstaller -// ctrl *gomock.Controller -// isNewAccount *MockisNewAccount -// techSpace *mock_techspace.MockTechSpace -// personalSpace *mock_commonspace.MockSpace -//} -// -//func (fx *fixture) expectRun(newAccount bool) { -// fx.spaceCore.EXPECT().DeriveID(mock.Anything, spacecore.SpaceType).Return(testPersonalSpaceID, nil) -// -// if newAccount { -// fx.spaceCore.EXPECT().Derive(mock.Anything, spacecore.SpaceType).Return(&spacecore.AnySpace{Space: fx.personalSpace}, nil) -// // fx.objectCache.EXPECT().DeriveTreeObject(mock.Anything, testPersonalSpaceID, mock.Anything).Return(nil, nil) -// fx.techSpace.EXPECT().SpaceViewCreate(mock.Anything, testPersonalSpaceID, nil).Return(nil) -// } -// // startLoad -// fx.techSpace.EXPECT().SpaceViewExists(mock.Anything, testPersonalSpaceID).Return(true, nil) -// fx.techSpace.EXPECT().SetLocalInfo(mock.Anything, mock.Anything).Return(nil) -// // wait load -// fx.spaceCore.EXPECT().Get(mock.Anything, testPersonalSpaceID).Return(&spacecore.AnySpace{Space: fx.personalSpace}, nil) -// fx.techSpace.EXPECT().SetLocalInfo(mock.Anything, spaceinfo.SpaceLocalInfo{ -// SpaceID: testPersonalSpaceID, -// LocalStatus: spaceinfo.LocalStatusOk, -// RemoteStatus: spaceinfo.RemoteStatusUnknown, -// }).Return(nil) -// -// // space init -// // fx.objectCache.EXPECT().DeriveObjectID(mock.Anything, testPersonalSpaceID, mock.Anything).Return("derived", nil) -// fx.objectCache.EXPECT().GetObject(mock.Anything, domain.FullID{ObjectID: "derived", SpaceID: testPersonalSpaceID}).Return(nil, nil) -// fx.installer.EXPECT().InstallBundledObjects(mock.Anything, testPersonalSpaceID, mock.Anything).Return(nil, nil, nil) -// ts := mock_treesyncer.NewMockTreeSyncer(fx.ctrl) -// ts.EXPECT().StartSync() -// fx.personalSpace.EXPECT().TreeSyncer().Return(ts) -//} -// -//func (fx *fixture) finish(t *testing.T) { -// require.NoError(t, fx.a.Close(ctx)) -// fx.ctrl.Finish() -//} +import ( + "context" + "testing" + + "github.com/anyproto/any-sync/accountservice/mock_accountservice" + "github.com/anyproto/any-sync/app" + "github.com/anyproto/any-sync/coordinator/coordinatorclient/mock_coordinatorclient" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + + "github.com/anyproto/anytype-heart/space/spacecore/mock_spacecore" + "github.com/anyproto/anytype-heart/space/spacefactory/mock_spacefactory" + "github.com/anyproto/anytype-heart/tests/testutil" +) + +var ctx = context.Background() + +const ( + testPersonalSpaceID = "personal.12345" +) + +// TODO Revive tests +func TestService_Init(t *testing.T) { + t.Run("existing account", func(t *testing.T) { + fx := newFixture(t, false) + defer fx.finish(t) + }) + t.Run("new account", func(t *testing.T) { + fx := newFixture(t, true) + defer fx.finish(t) + }) + +} + +func newFixture(t *testing.T, newAccount bool) *fixture { + ctrl := gomock.NewController(t) + fx := &fixture{ + service: New().(*service), + a: new(app.App), + ctrl: ctrl, + spaceCore: mock_spacecore.NewMockSpaceCoreService(t), + accountService: mock_accountservice.NewMockService(ctrl), + coordClient: mock_coordinatorclient.NewMockCoordinatorClient(ctrl), + factory: mock_spacefactory.NewMockSpaceFactory(t), + isNewAccount: NewMockisNewAccount(t), + } + fx.a.Register(testutil.PrepareMock(ctx, fx.a, fx.spaceCore)). + Register(testutil.PrepareMock(ctx, fx.a, fx.coordClient)). + Register(testutil.PrepareMock(ctx, fx.a, fx.accountService)). + Register(testutil.PrepareMock(ctx, fx.a, fx.isNewAccount)). + Register(testutil.PrepareMock(ctx, fx.a, fx.factory)). + Register(fx.service) + + fx.isNewAccount.EXPECT().IsNewAccount().Return(newAccount) + fx.spaceCore.EXPECT().DeriveID(mock.Anything, mock.Anything).Return(testPersonalSpaceID, nil) + fx.expectRun(newAccount) + + require.NoError(t, fx.a.Start(ctx)) + + return fx +} + +type fixture struct { + *service + a *app.App + factory *mock_spacefactory.MockSpaceFactory + spaceCore *mock_spacecore.MockSpaceCoreService + accountService *mock_accountservice.MockService + coordClient *mock_coordinatorclient.MockCoordinatorClient + ctrl *gomock.Controller + isNewAccount *MockisNewAccount +} + +func (fx *fixture) expectRun(newAccount bool) { + return +} + +func (fx *fixture) finish(t *testing.T) { + require.NoError(t, fx.a.Close(ctx)) + fx.ctrl.Finish() +} diff --git a/space/spacefactory/mock_spacefactory/mock_SpaceFactory.go b/space/spacefactory/mock_spacefactory/mock_SpaceFactory.go new file mode 100644 index 000000000..b5e6a10cc --- /dev/null +++ b/space/spacefactory/mock_spacefactory/mock_SpaceFactory.go @@ -0,0 +1,485 @@ +// Code generated by mockery v2.38.0. DO NOT EDIT. + +package mock_spacefactory + +import ( + context "context" + + app "github.com/anyproto/any-sync/app" + clientspace "github.com/anyproto/anytype-heart/space/clientspace" + + mock "github.com/stretchr/testify/mock" + + spacecontroller "github.com/anyproto/anytype-heart/space/internal/spacecontroller" + + spaceinfo "github.com/anyproto/anytype-heart/space/spaceinfo" +) + +// MockSpaceFactory is an autogenerated mock type for the SpaceFactory type +type MockSpaceFactory struct { + mock.Mock +} + +type MockSpaceFactory_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSpaceFactory) EXPECT() *MockSpaceFactory_Expecter { + return &MockSpaceFactory_Expecter{mock: &_m.Mock} +} + +// CreateAndSetTechSpace provides a mock function with given fields: ctx +func (_m *MockSpaceFactory) CreateAndSetTechSpace(ctx context.Context) (*clientspace.TechSpace, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for CreateAndSetTechSpace") + } + + var r0 *clientspace.TechSpace + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (*clientspace.TechSpace, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) *clientspace.TechSpace); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*clientspace.TechSpace) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceFactory_CreateAndSetTechSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAndSetTechSpace' +type MockSpaceFactory_CreateAndSetTechSpace_Call struct { + *mock.Call +} + +// CreateAndSetTechSpace is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockSpaceFactory_Expecter) CreateAndSetTechSpace(ctx interface{}) *MockSpaceFactory_CreateAndSetTechSpace_Call { + return &MockSpaceFactory_CreateAndSetTechSpace_Call{Call: _e.mock.On("CreateAndSetTechSpace", ctx)} +} + +func (_c *MockSpaceFactory_CreateAndSetTechSpace_Call) Run(run func(ctx context.Context)) *MockSpaceFactory_CreateAndSetTechSpace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockSpaceFactory_CreateAndSetTechSpace_Call) Return(_a0 *clientspace.TechSpace, _a1 error) *MockSpaceFactory_CreateAndSetTechSpace_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSpaceFactory_CreateAndSetTechSpace_Call) RunAndReturn(run func(context.Context) (*clientspace.TechSpace, error)) *MockSpaceFactory_CreateAndSetTechSpace_Call { + _c.Call.Return(run) + return _c +} + +// CreateMarketplaceSpace provides a mock function with given fields: ctx +func (_m *MockSpaceFactory) CreateMarketplaceSpace(ctx context.Context) (spacecontroller.SpaceController, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for CreateMarketplaceSpace") + } + + var r0 spacecontroller.SpaceController + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (spacecontroller.SpaceController, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) spacecontroller.SpaceController); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(spacecontroller.SpaceController) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceFactory_CreateMarketplaceSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMarketplaceSpace' +type MockSpaceFactory_CreateMarketplaceSpace_Call struct { + *mock.Call +} + +// CreateMarketplaceSpace is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockSpaceFactory_Expecter) CreateMarketplaceSpace(ctx interface{}) *MockSpaceFactory_CreateMarketplaceSpace_Call { + return &MockSpaceFactory_CreateMarketplaceSpace_Call{Call: _e.mock.On("CreateMarketplaceSpace", ctx)} +} + +func (_c *MockSpaceFactory_CreateMarketplaceSpace_Call) Run(run func(ctx context.Context)) *MockSpaceFactory_CreateMarketplaceSpace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockSpaceFactory_CreateMarketplaceSpace_Call) Return(sp spacecontroller.SpaceController, err error) *MockSpaceFactory_CreateMarketplaceSpace_Call { + _c.Call.Return(sp, err) + return _c +} + +func (_c *MockSpaceFactory_CreateMarketplaceSpace_Call) RunAndReturn(run func(context.Context) (spacecontroller.SpaceController, error)) *MockSpaceFactory_CreateMarketplaceSpace_Call { + _c.Call.Return(run) + return _c +} + +// CreatePersonalSpace provides a mock function with given fields: ctx +func (_m *MockSpaceFactory) CreatePersonalSpace(ctx context.Context) (spacecontroller.SpaceController, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for CreatePersonalSpace") + } + + var r0 spacecontroller.SpaceController + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (spacecontroller.SpaceController, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) spacecontroller.SpaceController); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(spacecontroller.SpaceController) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceFactory_CreatePersonalSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreatePersonalSpace' +type MockSpaceFactory_CreatePersonalSpace_Call struct { + *mock.Call +} + +// CreatePersonalSpace is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockSpaceFactory_Expecter) CreatePersonalSpace(ctx interface{}) *MockSpaceFactory_CreatePersonalSpace_Call { + return &MockSpaceFactory_CreatePersonalSpace_Call{Call: _e.mock.On("CreatePersonalSpace", ctx)} +} + +func (_c *MockSpaceFactory_CreatePersonalSpace_Call) Run(run func(ctx context.Context)) *MockSpaceFactory_CreatePersonalSpace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockSpaceFactory_CreatePersonalSpace_Call) Return(sp spacecontroller.SpaceController, err error) *MockSpaceFactory_CreatePersonalSpace_Call { + _c.Call.Return(sp, err) + return _c +} + +func (_c *MockSpaceFactory_CreatePersonalSpace_Call) RunAndReturn(run func(context.Context) (spacecontroller.SpaceController, error)) *MockSpaceFactory_CreatePersonalSpace_Call { + _c.Call.Return(run) + return _c +} + +// CreateShareableSpace provides a mock function with given fields: ctx, id +func (_m *MockSpaceFactory) CreateShareableSpace(ctx context.Context, id string) (spacecontroller.SpaceController, error) { + ret := _m.Called(ctx, id) + + if len(ret) == 0 { + panic("no return value specified for CreateShareableSpace") + } + + var r0 spacecontroller.SpaceController + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (spacecontroller.SpaceController, error)); ok { + return rf(ctx, id) + } + if rf, ok := ret.Get(0).(func(context.Context, string) spacecontroller.SpaceController); ok { + r0 = rf(ctx, id) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(spacecontroller.SpaceController) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = rf(ctx, id) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceFactory_CreateShareableSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateShareableSpace' +type MockSpaceFactory_CreateShareableSpace_Call struct { + *mock.Call +} + +// CreateShareableSpace is a helper method to define mock.On call +// - ctx context.Context +// - id string +func (_e *MockSpaceFactory_Expecter) CreateShareableSpace(ctx interface{}, id interface{}) *MockSpaceFactory_CreateShareableSpace_Call { + return &MockSpaceFactory_CreateShareableSpace_Call{Call: _e.mock.On("CreateShareableSpace", ctx, id)} +} + +func (_c *MockSpaceFactory_CreateShareableSpace_Call) Run(run func(ctx context.Context, id string)) *MockSpaceFactory_CreateShareableSpace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockSpaceFactory_CreateShareableSpace_Call) Return(sp spacecontroller.SpaceController, err error) *MockSpaceFactory_CreateShareableSpace_Call { + _c.Call.Return(sp, err) + return _c +} + +func (_c *MockSpaceFactory_CreateShareableSpace_Call) RunAndReturn(run func(context.Context, string) (spacecontroller.SpaceController, error)) *MockSpaceFactory_CreateShareableSpace_Call { + _c.Call.Return(run) + return _c +} + +// Init provides a mock function with given fields: a +func (_m *MockSpaceFactory) Init(a *app.App) error { + ret := _m.Called(a) + + if len(ret) == 0 { + panic("no return value specified for Init") + } + + var r0 error + if rf, ok := ret.Get(0).(func(*app.App) error); ok { + r0 = rf(a) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockSpaceFactory_Init_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Init' +type MockSpaceFactory_Init_Call struct { + *mock.Call +} + +// Init is a helper method to define mock.On call +// - a *app.App +func (_e *MockSpaceFactory_Expecter) Init(a interface{}) *MockSpaceFactory_Init_Call { + return &MockSpaceFactory_Init_Call{Call: _e.mock.On("Init", a)} +} + +func (_c *MockSpaceFactory_Init_Call) Run(run func(a *app.App)) *MockSpaceFactory_Init_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*app.App)) + }) + return _c +} + +func (_c *MockSpaceFactory_Init_Call) Return(err error) *MockSpaceFactory_Init_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockSpaceFactory_Init_Call) RunAndReturn(run func(*app.App) error) *MockSpaceFactory_Init_Call { + _c.Call.Return(run) + return _c +} + +// Name provides a mock function with given fields: +func (_m *MockSpaceFactory) Name() string { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Name") + } + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSpaceFactory_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name' +type MockSpaceFactory_Name_Call struct { + *mock.Call +} + +// Name is a helper method to define mock.On call +func (_e *MockSpaceFactory_Expecter) Name() *MockSpaceFactory_Name_Call { + return &MockSpaceFactory_Name_Call{Call: _e.mock.On("Name")} +} + +func (_c *MockSpaceFactory_Name_Call) Run(run func()) *MockSpaceFactory_Name_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSpaceFactory_Name_Call) Return(name string) *MockSpaceFactory_Name_Call { + _c.Call.Return(name) + return _c +} + +func (_c *MockSpaceFactory_Name_Call) RunAndReturn(run func() string) *MockSpaceFactory_Name_Call { + _c.Call.Return(run) + return _c +} + +// NewPersonalSpace provides a mock function with given fields: ctx +func (_m *MockSpaceFactory) NewPersonalSpace(ctx context.Context) (spacecontroller.SpaceController, error) { + ret := _m.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for NewPersonalSpace") + } + + var r0 spacecontroller.SpaceController + var r1 error + if rf, ok := ret.Get(0).(func(context.Context) (spacecontroller.SpaceController, error)); ok { + return rf(ctx) + } + if rf, ok := ret.Get(0).(func(context.Context) spacecontroller.SpaceController); ok { + r0 = rf(ctx) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(spacecontroller.SpaceController) + } + } + + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(ctx) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceFactory_NewPersonalSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewPersonalSpace' +type MockSpaceFactory_NewPersonalSpace_Call struct { + *mock.Call +} + +// NewPersonalSpace is a helper method to define mock.On call +// - ctx context.Context +func (_e *MockSpaceFactory_Expecter) NewPersonalSpace(ctx interface{}) *MockSpaceFactory_NewPersonalSpace_Call { + return &MockSpaceFactory_NewPersonalSpace_Call{Call: _e.mock.On("NewPersonalSpace", ctx)} +} + +func (_c *MockSpaceFactory_NewPersonalSpace_Call) Run(run func(ctx context.Context)) *MockSpaceFactory_NewPersonalSpace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context)) + }) + return _c +} + +func (_c *MockSpaceFactory_NewPersonalSpace_Call) Return(_a0 spacecontroller.SpaceController, _a1 error) *MockSpaceFactory_NewPersonalSpace_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSpaceFactory_NewPersonalSpace_Call) RunAndReturn(run func(context.Context) (spacecontroller.SpaceController, error)) *MockSpaceFactory_NewPersonalSpace_Call { + _c.Call.Return(run) + return _c +} + +// NewShareableSpace provides a mock function with given fields: ctx, id, status +func (_m *MockSpaceFactory) NewShareableSpace(ctx context.Context, id string, status spaceinfo.AccountStatus) (spacecontroller.SpaceController, error) { + ret := _m.Called(ctx, id, status) + + if len(ret) == 0 { + panic("no return value specified for NewShareableSpace") + } + + var r0 spacecontroller.SpaceController + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string, spaceinfo.AccountStatus) (spacecontroller.SpaceController, error)); ok { + return rf(ctx, id, status) + } + if rf, ok := ret.Get(0).(func(context.Context, string, spaceinfo.AccountStatus) spacecontroller.SpaceController); ok { + r0 = rf(ctx, id, status) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(spacecontroller.SpaceController) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, string, spaceinfo.AccountStatus) error); ok { + r1 = rf(ctx, id, status) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSpaceFactory_NewShareableSpace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewShareableSpace' +type MockSpaceFactory_NewShareableSpace_Call struct { + *mock.Call +} + +// NewShareableSpace is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - status spaceinfo.AccountStatus +func (_e *MockSpaceFactory_Expecter) NewShareableSpace(ctx interface{}, id interface{}, status interface{}) *MockSpaceFactory_NewShareableSpace_Call { + return &MockSpaceFactory_NewShareableSpace_Call{Call: _e.mock.On("NewShareableSpace", ctx, id, status)} +} + +func (_c *MockSpaceFactory_NewShareableSpace_Call) Run(run func(ctx context.Context, id string, status spaceinfo.AccountStatus)) *MockSpaceFactory_NewShareableSpace_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string), args[2].(spaceinfo.AccountStatus)) + }) + return _c +} + +func (_c *MockSpaceFactory_NewShareableSpace_Call) Return(_a0 spacecontroller.SpaceController, _a1 error) *MockSpaceFactory_NewShareableSpace_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSpaceFactory_NewShareableSpace_Call) RunAndReturn(run func(context.Context, string, spaceinfo.AccountStatus) (spacecontroller.SpaceController, error)) *MockSpaceFactory_NewShareableSpace_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSpaceFactory creates a new instance of MockSpaceFactory. 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 NewMockSpaceFactory(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSpaceFactory { + mock := &MockSpaceFactory{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}