feat: Default configs sms provider (#3187)

* feat: sms config

* feat: twilio as sms provider

* feat:sms projection

* feat: sms queries

* feat: sms queries test

* feat: sms configs

* feat: sms configs sql file

* fix merge

* fix: rename from to sendername

* fix: proto comments

* fix: token as crypto

* fix: tests

* fix: sms config sender name to sender number

* fix: sms config sender name to sender number

* Update email.go

* Update channel.go

* Update V1.111__settings.sql

Co-authored-by: Livio Amstutz <livio.a@gmail.com>

internal/command/command.go

@@ -32,6 +32,7 @@ type Commands struct {
 
 	idpConfigSecretCrypto crypto.EncryptionAlgorithm
 	smtpPasswordCrypto    crypto.EncryptionAlgorithm
+	smsCrypto             crypto.EncryptionAlgorithm
 
 	userPasswordAlg             crypto.HashAlgorithm
 	machineKeySize              int
@@ -60,8 +61,9 @@ func StartCommands(
 	staticStore static.Storage,
 	authZRepo authz_repo.Repository,
 	keyConfig *crypto.KeyConfig,
-	smtpPasswordEncAlg crypto.EncryptionAlgorithm,
 	webAuthN webauthn_helper.Config,
+	smtpPasswordEncAlg crypto.EncryptionAlgorithm,
+	smsHashAlg crypto.EncryptionAlgorithm,
 ) (repo *Commands, err error) {
 	repo = &Commands{
 		eventstore:         es,
@@ -73,6 +75,7 @@ func StartCommands(
 		privateKeyLifetime: defaults.KeyConfig.PrivateKeyLifetime,
 		publicKeyLifetime:  defaults.KeyConfig.PublicKeyLifetime,
 		smtpPasswordCrypto: smtpPasswordEncAlg,
+		smsCrypto:          smsHashAlg,
 	}
 	iam_repo.RegisterEventMappers(repo.eventstore)
 	org.RegisterEventMappers(repo.eventstore)

internal/command/sms_config.go

@@ -0,0 +1,207 @@
+package command
+
+import (
+	"context"
+
+	"github.com/caos/zitadel/internal/crypto"
+	"github.com/caos/zitadel/internal/domain"
+	caos_errs "github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/notification/channels/twilio"
+	"github.com/caos/zitadel/internal/repository/iam"
+)
+
+func (c *Commands) AddSMSConfigTwilio(ctx context.Context, config *twilio.TwilioConfig) (string, *domain.ObjectDetails, error) {
+	id, err := c.idGenerator.Next()
+	if err != nil {
+		return "", nil, err
+	}
+	smsConfigWriteModel, err := c.getSMSConfig(ctx, id)
+	if err != nil {
+		return "", nil, err
+	}
+
+	var token *crypto.CryptoValue
+	if config.Token != "" {
+		token, err = crypto.Encrypt([]byte(config.Token), c.smsCrypto)
+		if err != nil {
+			return "", nil, err
+		}
+	}
+
+	iamAgg := IAMAggregateFromWriteModel(&smsConfigWriteModel.WriteModel)
+	pushedEvents, err := c.eventstore.Push(ctx, iam.NewSMSConfigTwilioAddedEvent(
+		ctx,
+		iamAgg,
+		id,
+		config.SID,
+		config.SenderNumber,
+		token))
+	if err != nil {
+		return "", nil, err
+	}
+	err = AppendAndReduce(smsConfigWriteModel, pushedEvents...)
+	if err != nil {
+		return "", nil, err
+	}
+	return id, writeModelToObjectDetails(&smsConfigWriteModel.WriteModel), nil
+}
+
+func (c *Commands) ChangeSMSConfigTwilio(ctx context.Context, id string, config *twilio.TwilioConfig) (*domain.ObjectDetails, error) {
+	if id == "" {
+		return nil, caos_errs.ThrowInvalidArgument(nil, "SMS-e9jwf", "Errors.IDMissing")
+	}
+	smsConfigWriteModel, err := c.getSMSConfig(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if !smsConfigWriteModel.State.Exists() || smsConfigWriteModel.Twilio == nil {
+		return nil, caos_errs.ThrowNotFound(nil, "COMMAND-2m9fw", "Errors.SMSConfig.NotFound")
+	}
+	iamAgg := IAMAggregateFromWriteModel(&smsConfigWriteModel.WriteModel)
+
+	changedEvent, hasChanged, err := smsConfigWriteModel.NewChangedEvent(
+		ctx,
+		iamAgg,
+		id,
+		config.SID,
+		config.SenderNumber)
+	if err != nil {
+		return nil, err
+	}
+	if !hasChanged {
+		return nil, caos_errs.ThrowPreconditionFailed(nil, "COMMAND-jf9wk", "Errors.NoChangesFound")
+	}
+	pushedEvents, err := c.eventstore.Push(ctx, changedEvent)
+	if err != nil {
+		return nil, err
+	}
+	err = AppendAndReduce(smsConfigWriteModel, pushedEvents...)
+	if err != nil {
+		return nil, err
+	}
+	return writeModelToObjectDetails(&smsConfigWriteModel.WriteModel), nil
+}
+
+func (c *Commands) ChangeSMSConfigTwilioToken(ctx context.Context, id, token string) (*domain.ObjectDetails, error) {
+	smsConfigWriteModel, err := c.getSMSConfig(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if !smsConfigWriteModel.State.Exists() || smsConfigWriteModel.Twilio == nil {
+		return nil, caos_errs.ThrowNotFound(nil, "COMMAND-fj9wf", "Errors.SMSConfig.NotFound")
+	}
+	iamAgg := IAMAggregateFromWriteModel(&smsConfigWriteModel.WriteModel)
+	newtoken, err := crypto.Encrypt([]byte(token), c.smsCrypto)
+	if err != nil {
+		return nil, err
+	}
+	pushedEvents, err := c.eventstore.Push(ctx, iam.NewSMSConfigTokenChangedEvent(
+		ctx,
+		iamAgg,
+		id,
+		newtoken))
+	if err != nil {
+		return nil, err
+	}
+	err = AppendAndReduce(smsConfigWriteModel, pushedEvents...)
+	if err != nil {
+		return nil, err
+	}
+	return writeModelToObjectDetails(&smsConfigWriteModel.WriteModel), nil
+}
+
+func (c *Commands) ActivateSMSConfigTwilio(ctx context.Context, id string) (*domain.ObjectDetails, error) {
+	if id == "" {
+		return nil, caos_errs.ThrowInvalidArgument(nil, "SMS-dn93n", "Errors.IDMissing")
+	}
+	smsConfigWriteModel, err := c.getSMSConfig(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	if !smsConfigWriteModel.State.Exists() || smsConfigWriteModel.Twilio == nil {
+		return nil, caos_errs.ThrowNotFound(nil, "COMMAND-sn9we", "Errors.SMSConfig.NotFound")
+	}
+	if smsConfigWriteModel.State == domain.SMSConfigStateActive {
+		return nil, caos_errs.ThrowNotFound(nil, "COMMAND-sn9we", "Errors.SMSConfig.AlreadyActive")
+	}
+	iamAgg := IAMAggregateFromWriteModel(&smsConfigWriteModel.WriteModel)
+	pushedEvents, err := c.eventstore.Push(ctx, iam.NewSMSConfigTwilioActivatedEvent(
+		ctx,
+		iamAgg,
+		id))
+	if err != nil {
+		return nil, err
+	}
+	err = AppendAndReduce(smsConfigWriteModel, pushedEvents...)
+	if err != nil {
+		return nil, err
+	}
+	return writeModelToObjectDetails(&smsConfigWriteModel.WriteModel), nil
+}
+
+func (c *Commands) DeactivateSMSConfigTwilio(ctx context.Context, id string) (*domain.ObjectDetails, error) {
+	if id == "" {
+		return nil, caos_errs.ThrowInvalidArgument(nil, "SMS-frkwf", "Errors.IDMissing")
+	}
+	smsConfigWriteModel, err := c.getSMSConfig(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if !smsConfigWriteModel.State.Exists() || smsConfigWriteModel.Twilio == nil {
+		return nil, caos_errs.ThrowNotFound(nil, "COMMAND-s39Kg", "Errors.SMSConfig.NotFound")
+	}
+	if smsConfigWriteModel.State == domain.SMSConfigStateInactive {
+		return nil, caos_errs.ThrowNotFound(nil, "COMMAND-dm9e3", "Errors.SMSConfig.AlreadyDeactivated")
+	}
+
+	iamAgg := IAMAggregateFromWriteModel(&smsConfigWriteModel.WriteModel)
+	pushedEvents, err := c.eventstore.Push(ctx, iam.NewSMSConfigDeactivatedEvent(
+		ctx,
+		iamAgg,
+		id))
+	if err != nil {
+		return nil, err
+	}
+	err = AppendAndReduce(smsConfigWriteModel, pushedEvents...)
+	if err != nil {
+		return nil, err
+	}
+	return writeModelToObjectDetails(&smsConfigWriteModel.WriteModel), nil
+}
+
+func (c *Commands) RemoveSMSConfigTwilio(ctx context.Context, id string) (*domain.ObjectDetails, error) {
+	if id == "" {
+		return nil, caos_errs.ThrowInvalidArgument(nil, "SMS-3j9fs", "Errors.IDMissing")
+	}
+	smsConfigWriteModel, err := c.getSMSConfig(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if !smsConfigWriteModel.State.Exists() || smsConfigWriteModel.Twilio == nil {
+		return nil, caos_errs.ThrowNotFound(nil, "COMMAND-sn9we", "Errors.SMSConfig.NotFound")
+	}
+
+	iamAgg := IAMAggregateFromWriteModel(&smsConfigWriteModel.WriteModel)
+	pushedEvents, err := c.eventstore.Push(ctx, iam.NewSMSConfigRemovedEvent(
+		ctx,
+		iamAgg,
+		id))
+	if err != nil {
+		return nil, err
+	}
+	err = AppendAndReduce(smsConfigWriteModel, pushedEvents...)
+	if err != nil {
+		return nil, err
+	}
+	return writeModelToObjectDetails(&smsConfigWriteModel.WriteModel), nil
+}
+func (c *Commands) getSMSConfig(ctx context.Context, id string) (_ *IAMSMSConfigWriteModel, err error) {
+	writeModel := NewIAMSMSConfigWriteModel(id)
+	err = c.eventstore.FilterToQueryReducer(ctx, writeModel)
+	if err != nil {
+		return nil, err
+	}
+
+	return writeModel, nil
+}

internal/command/sms_config_model.go

@@ -0,0 +1,119 @@
+package command
+
+import (
+	"context"
+
+	"github.com/caos/zitadel/internal/crypto"
+	"github.com/caos/zitadel/internal/domain"
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/repository/iam"
+)
+
+type IAMSMSConfigWriteModel struct {
+	eventstore.WriteModel
+
+	ID     string
+	Twilio *TwilioConfig
+	State  domain.SMSConfigState
+}
+
+type TwilioConfig struct {
+	SID          string
+	Token        *crypto.CryptoValue
+	SenderNumber string
+}
+
+func NewIAMSMSConfigWriteModel(id string) *IAMSMSConfigWriteModel {
+	return &IAMSMSConfigWriteModel{
+		WriteModel: eventstore.WriteModel{
+			AggregateID:   domain.IAMID,
+			ResourceOwner: domain.IAMID,
+		},
+		ID: id,
+	}
+}
+
+func (wm *IAMSMSConfigWriteModel) Reduce() error {
+	for _, event := range wm.Events {
+		switch e := event.(type) {
+		case *iam.SMSConfigTwilioAddedEvent:
+			if wm.ID != e.ID {
+				continue
+			}
+			wm.Twilio = &TwilioConfig{
+				SID:          e.SID,
+				Token:        e.Token,
+				SenderNumber: e.SenderNumber,
+			}
+			wm.State = domain.SMSConfigStateInactive
+		case *iam.SMSConfigTwilioChangedEvent:
+			if wm.ID != e.ID {
+				continue
+			}
+			if e.SID != nil {
+				wm.Twilio.SID = *e.SID
+			}
+			if e.SenderNumber != nil {
+				wm.Twilio.SenderNumber = *e.SenderNumber
+			}
+		case *iam.SMSConfigTwilioTokenChangedEvent:
+			if wm.ID != e.ID {
+				continue
+			}
+			wm.Twilio.Token = e.Token
+		case *iam.SMSConfigActivatedEvent:
+			if wm.ID != e.ID {
+				continue
+			}
+			wm.State = domain.SMSConfigStateActive
+		case *iam.SMSConfigDeactivatedEvent:
+			if wm.ID != e.ID {
+				continue
+			}
+			wm.State = domain.SMSConfigStateInactive
+		case *iam.SMSConfigRemovedEvent:
+			if wm.ID != e.ID {
+				continue
+			}
+			wm.Twilio = nil
+			wm.State = domain.SMSConfigStateRemoved
+		}
+	}
+	return wm.WriteModel.Reduce()
+}
+func (wm *IAMSMSConfigWriteModel) Query() *eventstore.SearchQueryBuilder {
+	return eventstore.NewSearchQueryBuilder(eventstore.ColumnsEvent).
+		ResourceOwner(wm.ResourceOwner).
+		AddQuery().
+		AggregateTypes(iam.AggregateType).
+		AggregateIDs(wm.AggregateID).
+		EventTypes(
+			iam.SMSConfigTwilioAddedEventType,
+			iam.SMSConfigTwilioChangedEventType,
+			iam.SMSConfigTwilioTokenChangedEventType,
+			iam.SMSConfigActivatedEventType,
+			iam.SMSConfigDeactivatedEventType,
+			iam.SMSConfigRemovedEventType).
+		Builder()
+}
+
+func (wm *IAMSMSConfigWriteModel) NewChangedEvent(ctx context.Context, aggregate *eventstore.Aggregate, id, sid, senderNumber string) (*iam.SMSConfigTwilioChangedEvent, bool, error) {
+	changes := make([]iam.SMSConfigTwilioChanges, 0)
+	var err error
+
+	if wm.Twilio.SID != sid {
+		changes = append(changes, iam.ChangeSMSConfigTwilioSID(sid))
+	}
+	if wm.Twilio.SenderNumber != senderNumber {
+		changes = append(changes, iam.ChangeSMSConfigTwilioSenderNumber(senderNumber))
+	}
+
+	if len(changes) == 0 {
+		return nil, false, nil
+	}
+	changeEvent, err := iam.NewSMSConfigTwilioChangedEvent(ctx, aggregate, id, changes)
+	if err != nil {
+		return nil, false, err
+	}
+	return changeEvent, true, nil
+}

internal/command/sms_config_test.go

@@ -0,0 +1,605 @@
+package command
+
+import (
+	"context"
+	"testing"
+
+	"github.com/caos/zitadel/internal/crypto"
+	"github.com/caos/zitadel/internal/domain"
+	caos_errs "github.com/caos/zitadel/internal/errors"
+	"github.com/caos/zitadel/internal/eventstore"
+	"github.com/caos/zitadel/internal/eventstore/repository"
+	"github.com/caos/zitadel/internal/id"
+	id_mock "github.com/caos/zitadel/internal/id/mock"
+	"github.com/caos/zitadel/internal/notification/channels/twilio"
+	"github.com/caos/zitadel/internal/repository/iam"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCommandSide_AddSMSConfigTwilio(t *testing.T) {
+	type fields struct {
+		eventstore  *eventstore.Eventstore
+		idGenerator id.Generator
+		alg         crypto.EncryptionAlgorithm
+	}
+	type args struct {
+		ctx context.Context
+		sms *twilio.TwilioConfig
+	}
+	type res struct {
+		want *domain.ObjectDetails
+		err  func(error) bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		res    res
+	}{
+		{
+			name: "add sms config twilio, ok",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(),
+					expectPush(
+						[]*repository.Event{
+							eventFromEventPusher(iam.NewSMSConfigTwilioAddedEvent(
+								context.Background(),
+								&iam.NewAggregate().Aggregate,
+								"providerid",
+								"sid",
+								"senderName",
+								&crypto.CryptoValue{
+									CryptoType: crypto.TypeEncryption,
+									Algorithm:  "enc",
+									KeyID:      "id",
+									Crypted:    []byte("token"),
+								},
+							),
+							),
+						},
+					),
+				),
+				idGenerator: id_mock.NewIDGeneratorExpectIDs(t, "providerid"),
+				alg:         crypto.CreateMockEncryptionAlg(gomock.NewController(t)),
+			},
+			args: args{
+				ctx: context.Background(),
+				sms: &twilio.TwilioConfig{
+					SID:          "sid",
+					Token:        "token",
+					SenderNumber: "senderName",
+				},
+			},
+			res: res{
+				want: &domain.ObjectDetails{
+					ResourceOwner: "IAM",
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &Commands{
+				eventstore:  tt.fields.eventstore,
+				idGenerator: tt.fields.idGenerator,
+				smsCrypto:   tt.fields.alg,
+			}
+			_, got, err := r.AddSMSConfigTwilio(tt.args.ctx, tt.args.sms)
+			if tt.res.err == nil {
+				assert.NoError(t, err)
+			}
+			if tt.res.err != nil && !tt.res.err(err) {
+				t.Errorf("got wrong err: %v ", err)
+			}
+			if tt.res.err == nil {
+				assert.Equal(t, tt.res.want, got)
+			}
+		})
+	}
+}
+
+func TestCommandSide_ChangeSMSConfigTwilio(t *testing.T) {
+	type fields struct {
+		eventstore *eventstore.Eventstore
+	}
+	type args struct {
+		ctx context.Context
+		id  string
+		sms *twilio.TwilioConfig
+	}
+	type res struct {
+		want *domain.ObjectDetails
+		err  func(error) bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		res    res
+	}{
+		{
+			name: "id empty, precondition error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				sms: &twilio.TwilioConfig{},
+			},
+			res: res{
+				err: caos_errs.IsErrorInvalidArgument,
+			},
+		},
+		{
+			name: "sms not existing, not found error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				sms: &twilio.TwilioConfig{},
+				id:  "id",
+			},
+			res: res{
+				err: caos_errs.IsNotFound,
+			},
+		},
+		{
+			name: "no changes, precondition error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(
+						eventFromEventPusher(
+							iam.NewSMSConfigTwilioAddedEvent(
+								context.Background(),
+								&iam.NewAggregate().Aggregate,
+								"providerid",
+								"sid",
+								"senderName",
+								&crypto.CryptoValue{
+									CryptoType: crypto.TypeEncryption,
+									Algorithm:  "enc",
+									KeyID:      "id",
+									Crypted:    []byte("token"),
+								},
+							),
+						),
+					),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				sms: &twilio.TwilioConfig{
+					SID:          "sid",
+					Token:        "token",
+					SenderNumber: "senderName",
+				},
+				id: "providerid",
+			},
+			res: res{
+				err: caos_errs.IsPreconditionFailed,
+			},
+		},
+		{
+			name: "sms config twilio change, ok",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(
+						eventFromEventPusher(
+							iam.NewSMSConfigTwilioAddedEvent(
+								context.Background(),
+								&iam.NewAggregate().Aggregate,
+								"providerid",
+								"sid",
+								"token",
+								&crypto.CryptoValue{
+									CryptoType: crypto.TypeEncryption,
+									Algorithm:  "enc",
+									KeyID:      "id",
+									Crypted:    []byte("token"),
+								},
+							),
+						),
+					),
+					expectPush(
+						[]*repository.Event{
+							eventFromEventPusher(
+								newSMSConfigTwilioChangedEvent(
+									context.Background(),
+									"providerid",
+									"sid2",
+									"senderName2",
+								),
+							),
+						},
+					),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				sms: &twilio.TwilioConfig{
+					SID:          "sid2",
+					Token:        "token2",
+					SenderNumber: "senderName2",
+				},
+				id: "providerid",
+			},
+			res: res{
+				want: &domain.ObjectDetails{
+					ResourceOwner: "IAM",
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &Commands{
+				eventstore: tt.fields.eventstore,
+			}
+			got, err := r.ChangeSMSConfigTwilio(tt.args.ctx, tt.args.id, tt.args.sms)
+			if tt.res.err == nil {
+				assert.NoError(t, err)
+			}
+			if tt.res.err != nil && !tt.res.err(err) {
+				t.Errorf("got wrong err: %v ", err)
+			}
+			if tt.res.err == nil {
+				assert.Equal(t, tt.res.want, got)
+			}
+		})
+	}
+}
+
+func TestCommandSide_ActivateSMSConfigTwilio(t *testing.T) {
+	type fields struct {
+		eventstore *eventstore.Eventstore
+	}
+	type args struct {
+		ctx context.Context
+		id  string
+	}
+	type res struct {
+		want *domain.ObjectDetails
+		err  func(error) bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		res    res
+	}{
+		{
+			name: "id empty, invalid error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+			},
+			res: res{
+				err: caos_errs.IsErrorInvalidArgument,
+			},
+		},
+		{
+			name: "sms not existing, not found error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				id:  "id",
+			},
+			res: res{
+				err: caos_errs.IsNotFound,
+			},
+		},
+		{
+			name: "sms config twilio activate, ok",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(
+						eventFromEventPusher(
+							iam.NewSMSConfigTwilioAddedEvent(
+								context.Background(),
+								&iam.NewAggregate().Aggregate,
+								"providerid",
+								"sid",
+								"sender-name",
+								&crypto.CryptoValue{},
+							),
+						),
+					),
+					expectPush(
+						[]*repository.Event{
+							eventFromEventPusher(
+								iam.NewSMSConfigTwilioActivatedEvent(
+									context.Background(),
+									&iam.NewAggregate().Aggregate,
+									"providerid",
+								),
+							),
+						},
+					),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				id:  "providerid",
+			},
+			res: res{
+				want: &domain.ObjectDetails{
+					ResourceOwner: "IAM",
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &Commands{
+				eventstore: tt.fields.eventstore,
+			}
+			got, err := r.ActivateSMSConfigTwilio(tt.args.ctx, tt.args.id)
+			if tt.res.err == nil {
+				assert.NoError(t, err)
+			}
+			if tt.res.err != nil && !tt.res.err(err) {
+				t.Errorf("got wrong err: %v ", err)
+			}
+			if tt.res.err == nil {
+				assert.Equal(t, tt.res.want, got)
+			}
+		})
+	}
+}
+
+func TestCommandSide_DeactivateSMSConfigTwilio(t *testing.T) {
+	type fields struct {
+		eventstore *eventstore.Eventstore
+	}
+	type args struct {
+		ctx context.Context
+		id  string
+	}
+	type res struct {
+		want *domain.ObjectDetails
+		err  func(error) bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		res    res
+	}{
+		{
+			name: "id empty, invalid error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+			},
+			res: res{
+				err: caos_errs.IsErrorInvalidArgument,
+			},
+		},
+		{
+			name: "sms not existing, not found error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				id:  "id",
+			},
+			res: res{
+				err: caos_errs.IsNotFound,
+			},
+		},
+		{
+			name: "sms config twilio deactivate, ok",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(
+						eventFromEventPusher(
+							iam.NewSMSConfigTwilioAddedEvent(
+								context.Background(),
+								&iam.NewAggregate().Aggregate,
+								"providerid",
+								"sid",
+								"sender-name",
+								&crypto.CryptoValue{},
+							),
+						),
+						eventFromEventPusher(
+							iam.NewSMSConfigTwilioActivatedEvent(
+								context.Background(),
+								&iam.NewAggregate().Aggregate,
+								"providerid",
+							),
+						),
+					),
+					expectPush(
+						[]*repository.Event{
+							eventFromEventPusher(
+								iam.NewSMSConfigDeactivatedEvent(
+									context.Background(),
+									&iam.NewAggregate().Aggregate,
+									"providerid",
+								),
+							),
+						},
+					),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				id:  "providerid",
+			},
+			res: res{
+				want: &domain.ObjectDetails{
+					ResourceOwner: "IAM",
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &Commands{
+				eventstore: tt.fields.eventstore,
+			}
+			got, err := r.DeactivateSMSConfigTwilio(tt.args.ctx, tt.args.id)
+			if tt.res.err == nil {
+				assert.NoError(t, err)
+			}
+			if tt.res.err != nil && !tt.res.err(err) {
+				t.Errorf("got wrong err: %v ", err)
+			}
+			if tt.res.err == nil {
+				assert.Equal(t, tt.res.want, got)
+			}
+		})
+	}
+}
+
+func TestCommandSide_RemoveSMSConfigTwilio(t *testing.T) {
+	type fields struct {
+		eventstore *eventstore.Eventstore
+	}
+	type args struct {
+		ctx context.Context
+		id  string
+	}
+	type res struct {
+		want *domain.ObjectDetails
+		err  func(error) bool
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		res    res
+	}{
+		{
+			name: "id empty, invalid error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+			},
+			res: res{
+				err: caos_errs.IsErrorInvalidArgument,
+			},
+		},
+		{
+			name: "sms not existing, not found error",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				id:  "id",
+			},
+			res: res{
+				err: caos_errs.IsNotFound,
+			},
+		},
+		{
+			name: "sms config twilio remove, ok",
+			fields: fields{
+				eventstore: eventstoreExpect(
+					t,
+					expectFilter(
+						eventFromEventPusher(
+							iam.NewSMSConfigTwilioAddedEvent(
+								context.Background(),
+								&iam.NewAggregate().Aggregate,
+								"providerid",
+								"sid",
+								"sender-name",
+								&crypto.CryptoValue{},
+							),
+						),
+					),
+					expectPush(
+						[]*repository.Event{
+							eventFromEventPusher(
+								iam.NewSMSConfigRemovedEvent(
+									context.Background(),
+									&iam.NewAggregate().Aggregate,
+									"providerid",
+								),
+							),
+						},
+					),
+				),
+			},
+			args: args{
+				ctx: context.Background(),
+				id:  "providerid",
+			},
+			res: res{
+				want: &domain.ObjectDetails{
+					ResourceOwner: "IAM",
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := &Commands{
+				eventstore: tt.fields.eventstore,
+			}
+			got, err := r.RemoveSMSConfigTwilio(tt.args.ctx, tt.args.id)
+			if tt.res.err == nil {
+				assert.NoError(t, err)
+			}
+			if tt.res.err != nil && !tt.res.err(err) {
+				t.Errorf("got wrong err: %v ", err)
+			}
+			if tt.res.err == nil {
+				assert.Equal(t, tt.res.want, got)
+			}
+		})
+	}
+}
+
+func newSMSConfigTwilioChangedEvent(ctx context.Context, id, sid, senderName string) *iam.SMSConfigTwilioChangedEvent {
+	changes := []iam.SMSConfigTwilioChanges{
+		iam.ChangeSMSConfigTwilioSID(sid),
+		iam.ChangeSMSConfigTwilioSenderNumber(senderName),
+	}
+	event, _ := iam.NewSMSConfigTwilioChangedEvent(ctx,
+		&iam.NewAggregate().Aggregate,
+		id,
+		changes,
+	)
+	return event
+}