1
0
Fork 0
mirror of https://github.com/anyproto/anytype-heart.git synced 2025-06-11 02:13:41 +09:00

GO-2548 wip

This commit is contained in:
mcrakhman 2023-12-19 15:34:51 +01:00
parent 16bfe62192
commit a690b42248
No known key found for this signature in database
GPG key ID: DED12CFEF5B8396B
7 changed files with 1314 additions and 131 deletions

View file

@ -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:

View file

@ -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
}

View file

@ -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
}

View file

@ -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
}

View file

@ -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 {

View file

@ -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()
}

View file

@ -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
}