From 09e496061a149ecf65f336ec27b495e4e98b2bee Mon Sep 17 00:00:00 2001 From: mcrakhman Date: Wed, 9 Oct 2024 15:32:30 +0200 Subject: [PATCH] GO-3631 Add more test for account recover etc --- .../mock_detailservice/mock_Service.go | 120 ------------------ space/service_test.go | 54 +++++++- .../mock_spacecore/mock_SpaceCoreService.go | 57 +++++++++ 3 files changed, 110 insertions(+), 121 deletions(-) diff --git a/core/block/detailservice/mock_detailservice/mock_Service.go b/core/block/detailservice/mock_detailservice/mock_Service.go index 2c0338b67..ad1cdf4ed 100644 --- a/core/block/detailservice/mock_detailservice/mock_Service.go +++ b/core/block/detailservice/mock_detailservice/mock_Service.go @@ -17,8 +17,6 @@ import ( session "github.com/anyproto/anytype-heart/core/session" - smartblock "github.com/anyproto/anytype-heart/core/block/editor/smartblock" - types "github.com/gogo/protobuf/types" ) @@ -35,124 +33,6 @@ func (_m *MockService) EXPECT() *MockService_Expecter { return &MockService_Expecter{mock: &_m.Mock} } -// GetObject provides a mock function with given fields: ctx, objectID -func (_m *MockService) GetObject(ctx context.Context, objectID string) (smartblock.SmartBlock, error) { - ret := _m.Called(ctx, objectID) - - if len(ret) == 0 { - panic("no return value specified for GetObject") - } - - var r0 smartblock.SmartBlock - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string) (smartblock.SmartBlock, error)); ok { - return rf(ctx, objectID) - } - if rf, ok := ret.Get(0).(func(context.Context, string) smartblock.SmartBlock); ok { - r0 = rf(ctx, objectID) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(smartblock.SmartBlock) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, string) error); ok { - r1 = rf(ctx, objectID) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockService_GetObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObject' -type MockService_GetObject_Call struct { - *mock.Call -} - -// GetObject is a helper method to define mock.On call -// - ctx context.Context -// - objectID string -func (_e *MockService_Expecter) GetObject(ctx interface{}, objectID interface{}) *MockService_GetObject_Call { - return &MockService_GetObject_Call{Call: _e.mock.On("GetObject", ctx, objectID)} -} - -func (_c *MockService_GetObject_Call) Run(run func(ctx context.Context, objectID string)) *MockService_GetObject_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(string)) - }) - return _c -} - -func (_c *MockService_GetObject_Call) Return(sb smartblock.SmartBlock, err error) *MockService_GetObject_Call { - _c.Call.Return(sb, err) - return _c -} - -func (_c *MockService_GetObject_Call) RunAndReturn(run func(context.Context, string) (smartblock.SmartBlock, error)) *MockService_GetObject_Call { - _c.Call.Return(run) - return _c -} - -// GetObjectByFullID provides a mock function with given fields: ctx, id -func (_m *MockService) GetObjectByFullID(ctx context.Context, id domain.FullID) (smartblock.SmartBlock, error) { - ret := _m.Called(ctx, id) - - if len(ret) == 0 { - panic("no return value specified for GetObjectByFullID") - } - - var r0 smartblock.SmartBlock - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, domain.FullID) (smartblock.SmartBlock, error)); ok { - return rf(ctx, id) - } - if rf, ok := ret.Get(0).(func(context.Context, domain.FullID) smartblock.SmartBlock); ok { - r0 = rf(ctx, id) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(smartblock.SmartBlock) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, domain.FullID) error); ok { - r1 = rf(ctx, id) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockService_GetObjectByFullID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectByFullID' -type MockService_GetObjectByFullID_Call struct { - *mock.Call -} - -// GetObjectByFullID is a helper method to define mock.On call -// - ctx context.Context -// - id domain.FullID -func (_e *MockService_Expecter) GetObjectByFullID(ctx interface{}, id interface{}) *MockService_GetObjectByFullID_Call { - return &MockService_GetObjectByFullID_Call{Call: _e.mock.On("GetObjectByFullID", ctx, id)} -} - -func (_c *MockService_GetObjectByFullID_Call) Run(run func(ctx context.Context, id domain.FullID)) *MockService_GetObjectByFullID_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(domain.FullID)) - }) - return _c -} - -func (_c *MockService_GetObjectByFullID_Call) Return(sb smartblock.SmartBlock, err error) *MockService_GetObjectByFullID_Call { - _c.Call.Return(sb, err) - return _c -} - -func (_c *MockService_GetObjectByFullID_Call) RunAndReturn(run func(context.Context, domain.FullID) (smartblock.SmartBlock, error)) *MockService_GetObjectByFullID_Call { - _c.Call.Return(run) - return _c -} - // Init provides a mock function with given fields: a func (_m *MockService) Init(a *app.App) error { ret := _m.Called(a) diff --git a/space/service_test.go b/space/service_test.go index 2cf02c217..c7469445b 100644 --- a/space/service_test.go +++ b/space/service_test.go @@ -75,9 +75,61 @@ func TestService_Init(t *testing.T) { t.Run("new account", func(t *testing.T) { newFixture(t, nil) }) - t.Run("old account", func(t *testing.T) { + t.Run("old account, analytics id migrated", func(t *testing.T) { newFixture(t, func(t *testing.T, fx *fixture) { fx.factory.EXPECT().LoadAndSetTechSpace(mock.Anything).Return(&clientspace.TechSpace{TechSpace: fx.techSpace}, nil) + accObject := mock_techspace.NewMockAccountObject(t) + accObject.EXPECT().GetAnalyticsId().Return("analyticsId", nil) + fx.techSpace.EXPECT().DoAccountObject(mock.Anything, mock.Anything).RunAndReturn(func(ctx2 context.Context, f func(techspace.AccountObject) error) error { + return f(accObject) + }) + fx.techSpace.EXPECT().WakeUpViews() + }) + }) + t.Run("old account, analytics id not migrated", func(t *testing.T) { + newFixture(t, func(t *testing.T, fx *fixture) { + fx.factory.EXPECT().LoadAndSetTechSpace(mock.Anything).Return(&clientspace.TechSpace{TechSpace: fx.techSpace}, nil) + accObject := mock_techspace.NewMockAccountObject(t) + accObject.EXPECT().GetAnalyticsId().Return("", nil) + fx.techSpace.EXPECT().DoAccountObject(mock.Anything, mock.Anything).RunAndReturn(func(ctx2 context.Context, f func(techspace.AccountObject) error) error { + return f(accObject) + }) + prCtrl := mock_spacecontroller.NewMockSpaceController(t) + fx.factory.EXPECT().NewPersonalSpace(mock.Anything, mock.Anything).Return(prCtrl, nil) + prCtrl.EXPECT().Close(mock.Anything).Return(nil) + fx.techSpace.EXPECT().WakeUpViews() + }) + }) + t.Run("old account, no internet, then internet appeared", func(t *testing.T) { + newFixture(t, func(t *testing.T, fx *fixture) { + fx.factory.EXPECT().LoadAndSetTechSpace(mock.Anything).Return(nil, context.DeadlineExceeded).Times(1) + fx.spaceCore.EXPECT().StorageExistsLocally(mock.Anything, fx.spaceId).Return(false, nil) + fx.factory.EXPECT().LoadAndSetTechSpace(mock.Anything).Return(&clientspace.TechSpace{TechSpace: fx.techSpace}, nil) + accObject := mock_techspace.NewMockAccountObject(t) + accObject.EXPECT().GetAnalyticsId().Return("", nil) + fx.techSpace.EXPECT().DoAccountObject(mock.Anything, mock.Anything).RunAndReturn(func(ctx2 context.Context, f func(techspace.AccountObject) error) error { + return f(accObject) + }) + prCtrl := mock_spacecontroller.NewMockSpaceController(t) + fx.factory.EXPECT().NewPersonalSpace(mock.Anything, mock.Anything).Return(prCtrl, nil) + prCtrl.EXPECT().Close(mock.Anything).Return(nil) + fx.techSpace.EXPECT().WakeUpViews() + }) + }) + t.Run("old account, no internet, but personal space exists", func(t *testing.T) { + newFixture(t, func(t *testing.T, fx *fixture) { + fx.factory.EXPECT().LoadAndSetTechSpace(mock.Anything).Return(nil, context.DeadlineExceeded).Times(1) + fx.spaceCore.EXPECT().StorageExistsLocally(mock.Anything, fx.spaceId).Return(true, nil) + fx.spaceCore.EXPECT().Get(mock.Anything, fx.spaceId).Return(nil, nil) + fx.factory.EXPECT().CreateAndSetTechSpace(mock.Anything).Return(&clientspace.TechSpace{TechSpace: fx.techSpace}, nil) + prCtrl := mock_spacecontroller.NewMockSpaceController(t) + fx.factory.EXPECT().NewPersonalSpace(mock.Anything, mock.Anything).Return(prCtrl, nil) + prCtrl.EXPECT().Close(mock.Anything).Return(nil) + accObject := mock_techspace.NewMockAccountObject(t) + accObject.EXPECT().GetAnalyticsId().Return("", nil) + fx.techSpace.EXPECT().DoAccountObject(mock.Anything, mock.Anything).RunAndReturn(func(ctx2 context.Context, f func(techspace.AccountObject) error) error { + return f(accObject) + }) fx.techSpace.EXPECT().WakeUpViews() }) }) diff --git a/space/spacecore/mock_spacecore/mock_SpaceCoreService.go b/space/spacecore/mock_spacecore/mock_SpaceCoreService.go index 4e34b9f13..5c419a897 100644 --- a/space/spacecore/mock_spacecore/mock_SpaceCoreService.go +++ b/space/spacecore/mock_spacecore/mock_SpaceCoreService.go @@ -596,6 +596,63 @@ func (_c *MockSpaceCoreService_Run_Call) RunAndReturn(run func(context.Context) return _c } +// StorageExistsLocally provides a mock function with given fields: ctx, spaceID +func (_m *MockSpaceCoreService) StorageExistsLocally(ctx context.Context, spaceID string) (bool, error) { + ret := _m.Called(ctx, spaceID) + + if len(ret) == 0 { + panic("no return value specified for StorageExistsLocally") + } + + var r0 bool + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, string) (bool, error)); ok { + return rf(ctx, spaceID) + } + if rf, ok := ret.Get(0).(func(context.Context, string) bool); ok { + r0 = rf(ctx, spaceID) + } else { + r0 = ret.Get(0).(bool) + } + + 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_StorageExistsLocally_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StorageExistsLocally' +type MockSpaceCoreService_StorageExistsLocally_Call struct { + *mock.Call +} + +// StorageExistsLocally is a helper method to define mock.On call +// - ctx context.Context +// - spaceID string +func (_e *MockSpaceCoreService_Expecter) StorageExistsLocally(ctx interface{}, spaceID interface{}) *MockSpaceCoreService_StorageExistsLocally_Call { + return &MockSpaceCoreService_StorageExistsLocally_Call{Call: _e.mock.On("StorageExistsLocally", ctx, spaceID)} +} + +func (_c *MockSpaceCoreService_StorageExistsLocally_Call) Run(run func(ctx context.Context, spaceID string)) *MockSpaceCoreService_StorageExistsLocally_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(string)) + }) + return _c +} + +func (_c *MockSpaceCoreService_StorageExistsLocally_Call) Return(exists bool, err error) *MockSpaceCoreService_StorageExistsLocally_Call { + _c.Call.Return(exists, err) + return _c +} + +func (_c *MockSpaceCoreService_StorageExistsLocally_Call) RunAndReturn(run func(context.Context, string) (bool, error)) *MockSpaceCoreService_StorageExistsLocally_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 {