anyproto/anytype-heart
1
0
Fork 0
mirror of https://github.com/anyproto/anytype-heart.git synced 2025-06-09 09:35:00 +09:00
Code Activity

GO-5418: Refactor

Browse source
This commit is contained in:
Sergey 2025-04-10 15:33:34 +02:00
parent a6a046e5a2
commit 571bc0f393
No known key found for this signature in database
GPG key ID: 3B6BEF79160221C6
3 changed files with 121 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

18
core/block/source/store.go
View file

@ -104,18 +104,25 @@ func (s *store) initDiffManagers(ctx context.Context) error {
return fmt.Errorf("get value: %w", err)
}
for _, val := range vals {
var seenHeads []string
err = json.Unmarshal(val.Data, &seenHeads)
seenHeads, err := unmarshalSeenHeads(val.Data)
if err != nil {
return fmt.Errorf("unmarshal seen heads: %w", err)
}
manager.diffManager.Remove(seenHeads)
fmt.Println("LOAD SEEN HEADS", s.seenHeadsKey(name), seenHeads)
}
}
return nil
}
func unmarshalSeenHeads(raw []byte) ([]string, error) {
var seenHeads []string
err := json.Unmarshal(raw, &seenHeads)
if err != nil {
return nil, err
}
return seenHeads, nil
}
func (s *store) InitDiffManager(ctx context.Context, name string, seenHeads []string) (err error) {
manager, ok := s.diffManagers[name]
if !ok {
@ -142,9 +149,7 @@ func (s *store) InitDiffManager(ctx context.Context, name string, seenHeads []st
}
err = s.keyValueService.SubscribeForUserScopedKey(s.seenHeadsKey(name), name, func(key string, val keyvalueservice.Value) {
fmt.Println("RECV", key, string(val.Data))
var newSeenHeads []string
err = json.Unmarshal(val.Data, &newSeenHeads)
newSeenHeads, err := unmarshalSeenHeads(val.Data)
if err != nil {
log.Errorf("subscribe for seenHeads: %s: %v", name, err)
return
@ -332,7 +337,6 @@ func (s *store) StoreSeenHeads(ctx context.Context, name string) error {
return fmt.Errorf("marshal seen heads: %w", err)
}
fmt.Println("SAVE SEEN HEADS", s.seenHeadsKey(name), seenHeads)
return s.keyValueService.SetUserScopedKey(ctx, s.seenHeadsKey(name), raw)
}

119
space/techspace/mock_techspace/mock_TechSpace.go
View file

@ -10,6 +10,10 @@ import (
domain "github.com/anyproto/anytype-heart/core/domain"
keyvalueobserver "github.com/anyproto/anytype-heart/space/spacecore/keyvalueobserver"
keyvaluestorage "github.com/anyproto/any-sync/commonspace/object/keyvalue/keyvaluestorage"
mock "github.com/stretchr/testify/mock"
objectcache "github.com/anyproto/anytype-heart/core/block/object/objectcache"
@ -333,6 +337,100 @@ func (_c *MockTechSpace_Init_Call) RunAndReturn(run func(*app.App) error) *MockT
return _c
}
// KeyValueObserver provides a mock function with given fields:
func (_m *MockTechSpace) KeyValueObserver() keyvalueobserver.Observer {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for KeyValueObserver")
}
var r0 keyvalueobserver.Observer
if rf, ok := ret.Get(0).(func() keyvalueobserver.Observer); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(keyvalueobserver.Observer)
}
}
return r0
}
// MockTechSpace_KeyValueObserver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'KeyValueObserver'
type MockTechSpace_KeyValueObserver_Call struct {
*mock.Call
}
// KeyValueObserver is a helper method to define mock.On call
func (_e *MockTechSpace_Expecter) KeyValueObserver() *MockTechSpace_KeyValueObserver_Call {
return &MockTechSpace_KeyValueObserver_Call{Call: _e.mock.On("KeyValueObserver")}
}
func (_c *MockTechSpace_KeyValueObserver_Call) Run(run func()) *MockTechSpace_KeyValueObserver_Call {
_c.Call.Run(func(args mock.Arguments) {
run()
})
return _c
}
func (_c *MockTechSpace_KeyValueObserver_Call) Return(_a0 keyvalueobserver.Observer) *MockTechSpace_KeyValueObserver_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockTechSpace_KeyValueObserver_Call) RunAndReturn(run func() keyvalueobserver.Observer) *MockTechSpace_KeyValueObserver_Call {
_c.Call.Return(run)
return _c
}
// KeyValueStore provides a mock function with given fields:
func (_m *MockTechSpace) KeyValueStore() keyvaluestorage.Storage {
ret := _m.Called()
if len(ret) == 0 {
panic("no return value specified for KeyValueStore")
}
var r0 keyvaluestorage.Storage
if rf, ok := ret.Get(0).(func() keyvaluestorage.Storage); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(keyvaluestorage.Storage)
}
}
return r0
}
// MockTechSpace_KeyValueStore_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'KeyValueStore'
type MockTechSpace_KeyValueStore_Call struct {
*mock.Call
}
// KeyValueStore is a helper method to define mock.On call
func (_e *MockTechSpace_Expecter) KeyValueStore() *MockTechSpace_KeyValueStore_Call {
return &MockTechSpace_KeyValueStore_Call{Call: _e.mock.On("KeyValueStore")}
}
func (_c *MockTechSpace_KeyValueStore_Call) Run(run func()) *MockTechSpace_KeyValueStore_Call {
_c.Call.Run(func(args mock.Arguments) {
run()
})
return _c
}
func (_c *MockTechSpace_KeyValueStore_Call) Return(_a0 keyvaluestorage.Storage) *MockTechSpace_KeyValueStore_Call {
_c.Call.Return(_a0)
return _c
}
func (_c *MockTechSpace_KeyValueStore_Call) RunAndReturn(run func() keyvaluestorage.Storage) *MockTechSpace_KeyValueStore_Call {
_c.Call.Return(run)
return _c
}
// Name provides a mock function with given fields:
func (_m *MockTechSpace) Name() string {
ret := _m.Called()
@ -378,17 +476,17 @@ func (_c *MockTechSpace_Name_Call) RunAndReturn(run func() string) *MockTechSpac
return _c
}
// Run provides a mock function with given fields: techCoreSpace, objectCache, create
func (_m *MockTechSpace) Run(techCoreSpace commonspace.Space, objectCache objectcache.Cache, create bool) error {
ret := _m.Called(techCoreSpace, objectCache, create)
// Run provides a mock function with given fields: techCoreSpace, objectCache, kvObserver, create
func (_m *MockTechSpace) Run(techCoreSpace commonspace.Space, objectCache objectcache.Cache, kvObserver keyvalueobserver.Observer, create bool) error {
ret := _m.Called(techCoreSpace, objectCache, kvObserver, create)
if len(ret) == 0 {
panic("no return value specified for Run")
}
var r0 error
if rf, ok := ret.Get(0).(func(commonspace.Space, objectcache.Cache, bool) error); ok {
r0 = rf(techCoreSpace, objectCache, create)
if rf, ok := ret.Get(0).(func(commonspace.Space, objectcache.Cache, keyvalueobserver.Observer, bool) error); ok {
r0 = rf(techCoreSpace, objectCache, kvObserver, create)
} else {
r0 = ret.Error(0)
}
@ -404,14 +502,15 @@ type MockTechSpace_Run_Call struct {
// Run is a helper method to define mock.On call
// - techCoreSpace commonspace.Space
// - objectCache objectcache.Cache
// - kvObserver keyvalueobserver.Observer
// - create bool
func (_e *MockTechSpace_Expecter) Run(techCoreSpace interface{}, objectCache interface{}, create interface{}) *MockTechSpace_Run_Call {
return &MockTechSpace_Run_Call{Call: _e.mock.On("Run", techCoreSpace, objectCache, create)}
func (_e *MockTechSpace_Expecter) Run(techCoreSpace interface{}, objectCache interface{}, kvObserver interface{}, create interface{}) *MockTechSpace_Run_Call {
return &MockTechSpace_Run_Call{Call: _e.mock.On("Run", techCoreSpace, objectCache, kvObserver, create)}
}
func (_c *MockTechSpace_Run_Call) Run(run func(techCoreSpace commonspace.Space, objectCache objectcache.Cache, create bool)) *MockTechSpace_Run_Call {
func (_c *MockTechSpace_Run_Call) Run(run func(techCoreSpace commonspace.Space, objectCache objectcache.Cache, kvObserver keyvalueobserver.Observer, create bool)) *MockTechSpace_Run_Call {
_c.Call.Run(func(args mock.Arguments) {
run(args[0].(commonspace.Space), args[1].(objectcache.Cache), args[2].(bool))
run(args[0].(commonspace.Space), args[1].(objectcache.Cache), args[2].(keyvalueobserver.Observer), args[3].(bool))
})
return _c
}
@ -421,7 +520,7 @@ func (_c *MockTechSpace_Run_Call) Return(err error) *MockTechSpace_Run_Call {
return _c
}
func (_c *MockTechSpace_Run_Call) RunAndReturn(run func(commonspace.Space, objectcache.Cache, bool) error) *MockTechSpace_Run_Call {
func (_c *MockTechSpace_Run_Call) RunAndReturn(run func(commonspace.Space, objectcache.Cache, keyvalueobserver.Observer, bool) error) *MockTechSpace_Run_Call {
_c.Call.Return(run)
return _c
}

2
space/techspace/techspace_test.go
View file

@ -358,7 +358,7 @@ func newFixture(t *testing.T, storeIDs []string) *fixture {
return nil, nil
}).Times(1)
require.NoError(t, fx.a.Start(ctx))
err := fx.TechSpace.Run(fx.techCore, fx.objectCache, false)
err := fx.TechSpace.Run(fx.techCore, fx.objectCache, nil, false)
require.NoError(t, err)
// do not cancel wakeUpIds func