diff --git a/core/block/source/store.go b/core/block/source/store.go index e55c85650..6ef271fba 100644 --- a/core/block/source/store.go +++ b/core/block/source/store.go @@ -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) } diff --git a/space/techspace/mock_techspace/mock_TechSpace.go b/space/techspace/mock_techspace/mock_TechSpace.go index 65d0cd163..6064ce1bc 100644 --- a/space/techspace/mock_techspace/mock_TechSpace.go +++ b/space/techspace/mock_techspace/mock_TechSpace.go @@ -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 } diff --git a/space/techspace/techspace_test.go b/space/techspace/techspace_test.go index f5ca4e865..d012df896 100644 --- a/space/techspace/techspace_test.go +++ b/space/techspace/techspace_test.go @@ -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