Add some basic tests for settings

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)
 

commonspace/settings/idprovider.go

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

commonspace/settings/idprovider_test.go

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

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.
+// MockDeletionManager is a mock of DeletionManager interface.
-type MockDeletedIdsProvider struct {
+type MockDeletionManager struct {
 	ctrl     *gomock.Controller
-	recorder *MockDeletedIdsProviderMockRecorder
+	recorder *MockDeletionManagerMockRecorder
 }
 
-// MockDeletedIdsProviderMockRecorder is the mock recorder for MockDeletedIdsProvider.
+// MockDeletionManagerMockRecorder is the mock recorder for MockDeletionManager.
-type MockDeletedIdsProviderMockRecorder struct {
+type MockDeletionManagerMockRecorder struct {
-	mock *MockDeletedIdsProvider
+	mock *MockDeletionManager
 }
 
-// NewMockDeletedIdsProvider creates a new mock instance.
+// NewMockDeletionManager creates a new mock instance.
-func NewMockDeletedIdsProvider(ctrl *gomock.Controller) *MockDeletedIdsProvider {
+func NewMockDeletionManager(ctrl *gomock.Controller) *MockDeletionManager {
-	mock := &MockDeletedIdsProvider{ctrl: ctrl}
+	mock := &MockDeletionManager{ctrl: ctrl}
-	mock.recorder = &MockDeletedIdsProviderMockRecorder{mock}
+	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.
+// UpdateState mocks base method.
-func (m *MockDeletedIdsProvider) ProvideIds(arg0 objecttree.ObjectTree, arg1 string) ([]string, string, error) {
+func (m *MockDeletionManager) UpdateState(arg0 context.Context, arg1 *settingsstate.State) error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ProvideIds", arg0, arg1)
+	ret := m.ctrl.Call(m, "UpdateState", arg0, arg1)
-	ret0, _ := ret[0].([]string)
+	ret0, _ := ret[0].(error)
-	ret1, _ := ret[1].(string)
+	return ret0
-	ret2, _ := ret[2].(error)
-	return ret0, ret1, ret2
 }
 
-// ProvideIds indicates an expected call of ProvideIds.
+// UpdateState indicates an expected call of UpdateState.
-func (mr *MockDeletedIdsProviderMockRecorder) ProvideIds(arg0, arg1 interface{}) *gomock.Call {
+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.

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

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
+	spaceId         string
-	docId        string
+	docId           string
-	doc          *settingsObject
+	doc             *settingsObject
-	ctrl         *gomock.Controller
+	ctrl            *gomock.Controller
-	treeGetter   *mock_treegetter.MockTreeGetter
+	treeGetter      *mock_treegetter.MockTreeGetter
-	spaceStorage *mock_spacestorage.MockSpaceStorage
+	spaceStorage    *mock_spacestorage.MockSpaceStorage
-	provider     *mock_settings.MockDeletedIdsProvider
+	stateBuilder    *mock_settingsstate.MockStateBuilder
-	deleter      *mock_settings.MockDeleter
+	deletionManager *mock_settings.MockDeletionManager
-	syncTree     *mock_synctree.MockSyncTree
+	changeFactory   *mock_settingsstate.MockChangeFactory
-	delState     *mock_settingsstate.MockDeletionState
+	deleter         *mock_settings.MockDeleter
-	account      *mock_accountservice.MockService
+	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)
+	delState := mock_settingsstate.NewMockObjectDeletionState(ctrl)
-	prov := mock_settings.NewMockDeletedIdsProvider(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,
+		spaceId:         spaceId,
-		docId:        objectId,
+		docId:           objectId,
-		doc:          doc,
+		doc:             doc,
-		ctrl:         ctrl,
+		ctrl:            ctrl,
-		treeGetter:   treeGetter,
+		treeGetter:      treeGetter,
-		spaceStorage: st,
+		spaceStorage:    st,
-		provider:     prov,
+		stateBuilder:    stateBuilder,
-		deleter:      del,
+		changeFactory:   changeFactory,
-		syncTree:     syncTree,
+		deletionManager: delManager,
-		account:      acc,
+		deleter:         del,
-		delState:     delState,
+		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"
+	fx.stateBuilder.EXPECT().Build(fx.doc, fx.doc.state).Return(fx.doc.state, nil)
-	retIds := []string{"id1", "id2"}
+	fx.deletionManager.EXPECT().UpdateState(gomock.Any(), fx.doc.state).Return(nil)
-	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)
 	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"
+	newSt := &settingsstate.State{}
-	retIds := []string{"id1", "id2"}
+	fx.doc.state = &settingsstate.State{}
-	fx.doc.lastChangeId = lastChangeId
+	fx.stateBuilder.EXPECT().Build(fx.doc, nil).Return(newSt, nil)
-	fx.provider.EXPECT().ProvideIds(gomock.Not(nil), "").Return(retIds, retIds[len(retIds)-1], nil)
+	fx.deletionManager.EXPECT().UpdateState(gomock.Any(), newSt).Return(nil)
-	fx.delState.EXPECT().Add(retIds).Return(nil)
 
 	fx.doc.Rebuild(fx.doc)
-	require.Equal(t, retIds[len(retIds)-1], fx.doc.lastChangeId)
+}
 
-	fx.syncTree.EXPECT().Close().Return(nil)
+func TestSettingsObject_Update(t *testing.T) {
-	err = fx.doc.Close()
+	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)
+}

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 (

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)
+}