diff --git a/commonspace/settings/deleter_test.go b/commonspace/settings/deleter_test.go index fc33a168..3606225b 100644 --- a/commonspace/settings/deleter_test.go +++ b/commonspace/settings/deleter_test.go @@ -14,7 +14,7 @@ func TestDeleter_Delete(t *testing.T) { ctrl := gomock.NewController(t) treeGetter := mock_treegetter.NewMockTreeGetter(ctrl) st := mock_spacestorage.NewMockSpaceStorage(ctrl) - delState := mock_settingsstate.NewMockDeletionState(ctrl) + delState := mock_settingsstate.NewMockObjectDeletionState(ctrl) deleter := newDeleter(st, delState, treeGetter) diff --git a/commonspace/settings/idprovider.go b/commonspace/settings/idprovider.go deleted file mode 100644 index d681e0d7..00000000 --- a/commonspace/settings/idprovider.go +++ /dev/null @@ -1,58 +0,0 @@ -package settings - -import ( - "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree" - "github.com/anytypeio/any-sync/commonspace/spacesyncproto" - "github.com/gogo/protobuf/proto" -) - -type DeletedIdsProvider interface { - ProvideIds(tr objecttree.ObjectTree, startId string) (ids []string, lastId string, err error) -} - -type provider struct{} - -func (p *provider) processChange(change *objecttree.Change, rootId, startId string, ids []string) []string { - // ignoring root change which has empty model or startId change - if change.Model == nil || (change.Id == startId && startId != "") { - return ids - } - - deleteChange := change.Model.(*spacesyncproto.SettingsData) - // getting data from snapshot if we start from it - if change.Id == rootId { - ids = deleteChange.Snapshot.DeletedIds - return ids - } - - // otherwise getting data from content - for _, cnt := range deleteChange.Content { - if cnt.GetObjectDelete() != nil { - ids = append(ids, cnt.GetObjectDelete().GetId()) - } - } - return ids -} - -func (p *provider) ProvideIds(tr objecttree.ObjectTree, startId string) (ids []string, lastId string, err error) { - rootId := tr.Root().Id - process := func(change *objecttree.Change) bool { - lastId = change.Id - ids = p.processChange(change, rootId, startId, ids) - return true - } - convert := func(decrypted []byte) (res any, err error) { - deleteChange := &spacesyncproto.SettingsData{} - err = proto.Unmarshal(decrypted, deleteChange) - if err != nil { - return nil, err - } - return deleteChange, nil - } - - if startId == "" { - startId = rootId - } - err = tr.IterateFrom(startId, convert, process) - return -} diff --git a/commonspace/settings/idprovider_test.go b/commonspace/settings/idprovider_test.go deleted file mode 100644 index 6a64b78b..00000000 --- a/commonspace/settings/idprovider_test.go +++ /dev/null @@ -1,93 +0,0 @@ -package settings - -import ( - "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree" - "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree/mock_objecttree" - "github.com/anytypeio/any-sync/commonspace/spacesyncproto" - "github.com/golang/mock/gomock" - "github.com/stretchr/testify/require" - "testing" -) - -func TestProvider_ProcessChange(t *testing.T) { - //ctrl := gomock.NewController(t) - //objTree := mock_tree.NewMockObjectTree(ctrl) - prov := &provider{} - //defer ctrl.Finish() - - t.Run("empty model", func(t *testing.T) { - ch := &objecttree.Change{} - startId := "startId" - rootId := "rootId" - ids := []string{startId} - otherIds := prov.processChange(ch, rootId, startId, ids) - require.Equal(t, []string{startId}, otherIds) - }) - - t.Run("changeId is equal to startId", func(t *testing.T) { - ch := &objecttree.Change{} - ch.Model = &spacesyncproto.SettingsData{} - ch.Id = "startId" - - startId := "startId" - rootId := "rootId" - ids := []string{startId} - otherIds := prov.processChange(ch, rootId, startId, ids) - require.Equal(t, []string{startId}, otherIds) - }) - - t.Run("changeId is equal to rootId, startId is empty", func(t *testing.T) { - ch := &objecttree.Change{} - ch.Model = &spacesyncproto.SettingsData{ - Snapshot: &spacesyncproto.SpaceSettingsSnapshot{ - DeletedIds: []string{"id1", "id2"}, - }, - } - ch.Id = "rootId" - - startId := "" - rootId := "rootId" - otherIds := prov.processChange(ch, rootId, startId, nil) - require.Equal(t, []string{"id1", "id2"}, otherIds) - }) - - t.Run("changeId is equal to rootId, startId is empty", func(t *testing.T) { - ch := &objecttree.Change{} - ch.Model = &spacesyncproto.SettingsData{ - Content: []*spacesyncproto.SpaceSettingsContent{ - {Value: &spacesyncproto.SpaceSettingsContent_ObjectDelete{ - ObjectDelete: &spacesyncproto.ObjectDelete{Id: "id1"}, - }}, - }, - } - ch.Id = "someId" - - startId := "startId" - rootId := "rootId" - otherIds := prov.processChange(ch, rootId, startId, nil) - require.Equal(t, []string{"id1"}, otherIds) - }) -} - -func TestProvider_ProvideIds(t *testing.T) { - ctrl := gomock.NewController(t) - objTree := mock_objecttree.NewMockObjectTree(ctrl) - prov := &provider{} - defer ctrl.Finish() - - t.Run("startId is empty", func(t *testing.T) { - ch := &objecttree.Change{Id: "rootId"} - objTree.EXPECT().Root().Return(ch) - objTree.EXPECT().IterateFrom("rootId", gomock.Any(), gomock.Any()).Return(nil) - _, _, err := prov.ProvideIds(objTree, "") - require.NoError(t, err) - }) - - t.Run("startId is not empty", func(t *testing.T) { - ch := &objecttree.Change{Id: "rootId"} - objTree.EXPECT().Root().Return(ch) - objTree.EXPECT().IterateFrom("startId", gomock.Any(), gomock.Any()).Return(nil) - _, _, err := prov.ProvideIds(objTree, "startId") - require.NoError(t, err) - }) -} diff --git a/commonspace/settings/mock_settings/mock_settings.go b/commonspace/settings/mock_settings/mock_settings.go index 5b54ee41..086547b2 100644 --- a/commonspace/settings/mock_settings/mock_settings.go +++ b/commonspace/settings/mock_settings/mock_settings.go @@ -1,53 +1,52 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/anytypeio/any-sync/commonspace/settings (interfaces: DeletedIdsProvider,Deleter) +// Source: github.com/anytypeio/any-sync/commonspace/settings (interfaces: DeletionManager,Deleter) // Package mock_settings is a generated GoMock package. package mock_settings import ( + context "context" reflect "reflect" - objecttree "github.com/anytypeio/any-sync/commonspace/object/tree/objecttree" + settingsstate "github.com/anytypeio/any-sync/commonspace/settings/settingsstate" gomock "github.com/golang/mock/gomock" ) -// MockDeletedIdsProvider is a mock of DeletedIdsProvider interface. -type MockDeletedIdsProvider struct { +// MockDeletionManager is a mock of DeletionManager interface. +type MockDeletionManager struct { ctrl *gomock.Controller - recorder *MockDeletedIdsProviderMockRecorder + recorder *MockDeletionManagerMockRecorder } -// MockDeletedIdsProviderMockRecorder is the mock recorder for MockDeletedIdsProvider. -type MockDeletedIdsProviderMockRecorder struct { - mock *MockDeletedIdsProvider +// MockDeletionManagerMockRecorder is the mock recorder for MockDeletionManager. +type MockDeletionManagerMockRecorder struct { + mock *MockDeletionManager } -// NewMockDeletedIdsProvider creates a new mock instance. -func NewMockDeletedIdsProvider(ctrl *gomock.Controller) *MockDeletedIdsProvider { - mock := &MockDeletedIdsProvider{ctrl: ctrl} - mock.recorder = &MockDeletedIdsProviderMockRecorder{mock} +// NewMockDeletionManager creates a new mock instance. +func NewMockDeletionManager(ctrl *gomock.Controller) *MockDeletionManager { + mock := &MockDeletionManager{ctrl: ctrl} + mock.recorder = &MockDeletionManagerMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDeletedIdsProvider) EXPECT() *MockDeletedIdsProviderMockRecorder { +func (m *MockDeletionManager) EXPECT() *MockDeletionManagerMockRecorder { return m.recorder } -// ProvideIds mocks base method. -func (m *MockDeletedIdsProvider) ProvideIds(arg0 objecttree.ObjectTree, arg1 string) ([]string, string, error) { +// UpdateState mocks base method. +func (m *MockDeletionManager) UpdateState(arg0 context.Context, arg1 *settingsstate.State) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvideIds", arg0, arg1) - ret0, _ := ret[0].([]string) - ret1, _ := ret[1].(string) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 + ret := m.ctrl.Call(m, "UpdateState", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 } -// ProvideIds indicates an expected call of ProvideIds. -func (mr *MockDeletedIdsProviderMockRecorder) ProvideIds(arg0, arg1 interface{}) *gomock.Call { +// UpdateState indicates an expected call of UpdateState. +func (mr *MockDeletionManagerMockRecorder) UpdateState(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvideIds", reflect.TypeOf((*MockDeletedIdsProvider)(nil).ProvideIds), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateState", reflect.TypeOf((*MockDeletionManager)(nil).UpdateState), arg0, arg1) } // MockDeleter is a mock of Deleter interface. diff --git a/commonspace/settings/settings.go b/commonspace/settings/settings.go index ef51bc4f..f195cc15 100644 --- a/commonspace/settings/settings.go +++ b/commonspace/settings/settings.go @@ -1,4 +1,4 @@ -//go:generate mockgen -destination mock_settings/mock_settings.go github.com/anytypeio/any-sync/commonspace/settings DeletedIdsProvider,Deleter +//go:generate mockgen -destination mock_settings/mock_settings.go github.com/anytypeio/any-sync/commonspace/settings DeletionManager,Deleter package settings import ( @@ -136,7 +136,7 @@ func NewSettingsObject(deps Deps, spaceId string) (obj SettingsObject) { func (s *settingsObject) updateIds(tr objecttree.ObjectTree) { var err error - s.state, err = s.builder.Build(tr, s.state, isUpdate) + s.state, err = s.builder.Build(tr, s.state) if err != nil { log.Error("failed to build state", zap.Error(err)) return diff --git a/commonspace/settings/settings_test.go b/commonspace/settings/settings_test.go index cc87b428..184e1ea3 100644 --- a/commonspace/settings/settings_test.go +++ b/commonspace/settings/settings_test.go @@ -8,9 +8,11 @@ import ( "github.com/anytypeio/any-sync/commonspace/object/tree/synctree" "github.com/anytypeio/any-sync/commonspace/object/tree/synctree/mock_synctree" "github.com/anytypeio/any-sync/commonspace/object/tree/synctree/updatelistener" + "github.com/anytypeio/any-sync/commonspace/object/tree/treechangeproto" "github.com/anytypeio/any-sync/commonspace/object/treegetter/mock_treegetter" - "github.com/anytypeio/any-sync/commonspace/settings/settingsstate/mock_settingsstate" "github.com/anytypeio/any-sync/commonspace/settings/mock_settings" + "github.com/anytypeio/any-sync/commonspace/settings/settingsstate" + "github.com/anytypeio/any-sync/commonspace/settings/settingsstate/mock_settingsstate" "github.com/anytypeio/any-sync/commonspace/spacestorage/mock_spacestorage" "github.com/anytypeio/any-sync/util/keys/asymmetric/signingkey" "github.com/golang/mock/gomock" @@ -40,17 +42,19 @@ func (t *testSyncTreeMock) Unlock() { } type settingsFixture struct { - spaceId string - docId string - doc *settingsObject - ctrl *gomock.Controller - treeGetter *mock_treegetter.MockTreeGetter - spaceStorage *mock_spacestorage.MockSpaceStorage - provider *mock_settings.MockDeletedIdsProvider - deleter *mock_settings.MockDeleter - syncTree *mock_synctree.MockSyncTree - delState *mock_settingsstate.MockDeletionState - account *mock_accountservice.MockService + spaceId string + docId string + doc *settingsObject + ctrl *gomock.Controller + treeGetter *mock_treegetter.MockTreeGetter + spaceStorage *mock_spacestorage.MockSpaceStorage + stateBuilder *mock_settingsstate.MockStateBuilder + deletionManager *mock_settings.MockDeletionManager + changeFactory *mock_settingsstate.MockChangeFactory + deleter *mock_settings.MockDeleter + syncTree *mock_synctree.MockSyncTree + delState *mock_settingsstate.MockObjectDeletionState + account *mock_accountservice.MockService } func newSettingsFixture(t *testing.T) *settingsFixture { @@ -61,8 +65,10 @@ func newSettingsFixture(t *testing.T) *settingsFixture { acc := mock_accountservice.NewMockService(ctrl) treeGetter := mock_treegetter.NewMockTreeGetter(ctrl) st := mock_spacestorage.NewMockSpaceStorage(ctrl) - delState := mock_settingsstate.NewMockDeletionState(ctrl) - prov := mock_settings.NewMockDeletedIdsProvider(ctrl) + delState := mock_settingsstate.NewMockObjectDeletionState(ctrl) + delManager := mock_settings.NewMockDeletionManager(ctrl) + stateBuilder := mock_settingsstate.NewMockStateBuilder(ctrl) + changeFactory := mock_settingsstate.NewMockChangeFactory(ctrl) syncTree := mock_synctree.NewMockSyncTree(ctrl) del := mock_settings.NewMockDeleter(ctrl) @@ -79,22 +85,26 @@ func newSettingsFixture(t *testing.T) *settingsFixture { TreeGetter: treeGetter, Store: st, DeletionState: delState, - prov: prov, + delManager: delManager, + changeFactory: changeFactory, + builder: stateBuilder, del: del, } doc := NewSettingsObject(deps, spaceId).(*settingsObject) return &settingsFixture{ - spaceId: spaceId, - docId: objectId, - doc: doc, - ctrl: ctrl, - treeGetter: treeGetter, - spaceStorage: st, - provider: prov, - deleter: del, - syncTree: syncTree, - account: acc, - delState: delState, + spaceId: spaceId, + docId: objectId, + doc: doc, + ctrl: ctrl, + treeGetter: treeGetter, + spaceStorage: st, + stateBuilder: stateBuilder, + changeFactory: changeFactory, + deletionManager: delManager, + deleter: del, + syncTree: syncTree, + account: acc, + delState: delState, } } @@ -133,7 +143,8 @@ func TestSettingsObject_DeleteObject(t *testing.T) { fx.delState.EXPECT().Exists(delId).Return(false) fx.spaceStorage.EXPECT().TreeStorage(delId).Return(nil, nil) res := []byte("settingsData") - fx.delState.EXPECT().CreateDeleteChange(delId, false).Return(res, nil) + fx.doc.state = &settingsstate.State{LastIteratedId: "someId"} + fx.changeFactory.EXPECT().CreateObjectDeleteChange(delId, fx.doc.state, false).Return(res, nil) accountData := &accountdata.AccountData{ Identity: []byte("id"), @@ -150,14 +161,10 @@ func TestSettingsObject_DeleteObject(t *testing.T) { IsEncrypted: false, }).Return(objecttree.AddResult{}, nil) - lastChangeId := "someId" - retIds := []string{"id1", "id2"} - fx.doc.lastChangeId = lastChangeId - fx.provider.EXPECT().ProvideIds(gomock.Not(nil), lastChangeId).Return(retIds, retIds[len(retIds)-1], nil) - fx.delState.EXPECT().Add(retIds).Return(nil) + fx.stateBuilder.EXPECT().Build(fx.doc, fx.doc.state).Return(fx.doc.state, nil) + fx.deletionManager.EXPECT().UpdateState(gomock.Any(), fx.doc.state).Return(nil) err = fx.doc.DeleteObject(delId) require.NoError(t, err) - require.Equal(t, retIds[len(retIds)-1], fx.doc.lastChangeId) fx.syncTree.EXPECT().Close().Return(nil) err = fx.doc.Close() @@ -175,16 +182,83 @@ func TestSettingsObject_Rebuild(t *testing.T) { require.NoError(t, err) time.Sleep(100 * time.Millisecond) - lastChangeId := "someId" - retIds := []string{"id1", "id2"} - fx.doc.lastChangeId = lastChangeId - fx.provider.EXPECT().ProvideIds(gomock.Not(nil), "").Return(retIds, retIds[len(retIds)-1], nil) - fx.delState.EXPECT().Add(retIds).Return(nil) + newSt := &settingsstate.State{} + fx.doc.state = &settingsstate.State{} + fx.stateBuilder.EXPECT().Build(fx.doc, nil).Return(newSt, nil) + fx.deletionManager.EXPECT().UpdateState(gomock.Any(), newSt).Return(nil) fx.doc.Rebuild(fx.doc) - require.Equal(t, retIds[len(retIds)-1], fx.doc.lastChangeId) +} - fx.syncTree.EXPECT().Close().Return(nil) - err = fx.doc.Close() +func TestSettingsObject_Update(t *testing.T) { + fx := newSettingsFixture(t) + defer fx.stop() + + fx.spaceStorage.EXPECT().SpaceSettingsId().Return(fx.docId) + fx.deleter.EXPECT().Delete() + + err := fx.doc.Init(context.Background()) + require.NoError(t, err) + time.Sleep(100 * time.Millisecond) + + fx.doc.state = &settingsstate.State{} + fx.stateBuilder.EXPECT().Build(fx.doc, fx.doc.state).Return(fx.doc.state, nil) + fx.deletionManager.EXPECT().UpdateState(gomock.Any(), fx.doc.state).Return(nil) + + fx.doc.Update(fx.doc) +} + +func TestSettingsObject_DeleteSpace(t *testing.T) { + fx := newSettingsFixture(t) + defer fx.stop() + + fx.spaceStorage.EXPECT().SpaceSettingsId().Return(fx.docId) + fx.deleter.EXPECT().Delete() + + err := fx.doc.Init(context.Background()) + require.NoError(t, err) + time.Sleep(100 * time.Millisecond) + + deleterId := "delId" + rawCh := &treechangeproto.RawTreeChangeWithId{ + RawChange: []byte{1}, + Id: "id", + } + changeFactory := settingsstate.NewChangeFactory() + delChange, _ := changeFactory.CreateSpaceDeleteChange(deleterId, &settingsstate.State{}, false) + + fx.syncTree.EXPECT().UnpackChange(rawCh).Return(delChange, nil) + fx.syncTree.EXPECT().AddRawChanges(gomock.Any(), objecttree.RawChangesPayload{ + NewHeads: []string{rawCh.Id}, + RawChanges: []*treechangeproto.RawTreeChangeWithId{rawCh}, + }).Return(objecttree.AddResult{ + Heads: []string{rawCh.Id}, + }, nil) + + err = fx.doc.DeleteSpace(context.Background(), deleterId, rawCh) require.NoError(t, err) } + +func TestSettingsObject_DeleteSpaceIncorrectPeerId(t *testing.T) { + fx := newSettingsFixture(t) + defer fx.stop() + + fx.spaceStorage.EXPECT().SpaceSettingsId().Return(fx.docId) + fx.deleter.EXPECT().Delete() + + err := fx.doc.Init(context.Background()) + require.NoError(t, err) + time.Sleep(100 * time.Millisecond) + + deleterId := "delId" + rawCh := &treechangeproto.RawTreeChangeWithId{ + RawChange: []byte{1}, + Id: "id", + } + changeFactory := settingsstate.NewChangeFactory() + delChange, _ := changeFactory.CreateSpaceDeleteChange("otherId", &settingsstate.State{}, false) + + fx.syncTree.EXPECT().UnpackChange(rawCh).Return(delChange, nil) + err = fx.doc.DeleteSpace(context.Background(), deleterId, rawCh) + require.Equal(t, err, ErrIncorrectDeleteChange) +} diff --git a/commonspace/settings/settingsstate/deletionstate.go b/commonspace/settings/settingsstate/deletionstate.go index c28dca63..a65152de 100644 --- a/commonspace/settings/settingsstate/deletionstate.go +++ b/commonspace/settings/settingsstate/deletionstate.go @@ -1,4 +1,4 @@ -//go:generate mockgen -destination mock_settingsstate/mock_settingsstate.go github.com/anytypeio/any-sync/commonspace/settings/settingsstate ObjectDeletionState,StateBuilder +//go:generate mockgen -destination mock_settingsstate/mock_settingsstate.go github.com/anytypeio/any-sync/commonspace/settings/settingsstate ObjectDeletionState,StateBuilder,ChangeFactory package settingsstate import ( diff --git a/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go b/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go index 65e72c96..948f72c4 100644 --- a/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go +++ b/commonspace/settings/settingsstate/mock_settingsstate/mock_settingsstate.go @@ -1,5 +1,5 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: github.com/anytypeio/any-sync/commonspace/settings/settingsstate (interfaces: ObjectDeletionState,StateBuilder) +// Source: github.com/anytypeio/any-sync/commonspace/settings/settingsstate (interfaces: ObjectDeletionState,StateBuilder,ChangeFactory) // Package mock_settingsstate is a generated GoMock package. package mock_settingsstate @@ -158,3 +158,56 @@ func (mr *MockStateBuilderMockRecorder) Build(arg0, arg1 interface{}) *gomock.Ca mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockStateBuilder)(nil).Build), arg0, arg1) } + +// MockChangeFactory is a mock of ChangeFactory interface. +type MockChangeFactory struct { + ctrl *gomock.Controller + recorder *MockChangeFactoryMockRecorder +} + +// MockChangeFactoryMockRecorder is the mock recorder for MockChangeFactory. +type MockChangeFactoryMockRecorder struct { + mock *MockChangeFactory +} + +// NewMockChangeFactory creates a new mock instance. +func NewMockChangeFactory(ctrl *gomock.Controller) *MockChangeFactory { + mock := &MockChangeFactory{ctrl: ctrl} + mock.recorder = &MockChangeFactoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockChangeFactory) EXPECT() *MockChangeFactoryMockRecorder { + return m.recorder +} + +// CreateObjectDeleteChange mocks base method. +func (m *MockChangeFactory) CreateObjectDeleteChange(arg0 string, arg1 *settingsstate.State, arg2 bool) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateObjectDeleteChange", arg0, arg1, arg2) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateObjectDeleteChange indicates an expected call of CreateObjectDeleteChange. +func (mr *MockChangeFactoryMockRecorder) CreateObjectDeleteChange(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateObjectDeleteChange", reflect.TypeOf((*MockChangeFactory)(nil).CreateObjectDeleteChange), arg0, arg1, arg2) +} + +// CreateSpaceDeleteChange mocks base method. +func (m *MockChangeFactory) CreateSpaceDeleteChange(arg0 string, arg1 *settingsstate.State, arg2 bool) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateSpaceDeleteChange", arg0, arg1, arg2) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateSpaceDeleteChange indicates an expected call of CreateSpaceDeleteChange. +func (mr *MockChangeFactoryMockRecorder) CreateSpaceDeleteChange(arg0, arg1, arg2 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpaceDeleteChange", reflect.TypeOf((*MockChangeFactory)(nil).CreateSpaceDeleteChange), arg0, arg1, arg2) +}