zitadel/internal/org/repository/eventsourcing/org_test.go

package eventsourcing

import (
	"context"
	"github.com/caos/zitadel/internal/org/repository/eventsourcing/model"
	"testing"

	"github.com/caos/zitadel/internal/api/auth"
	"github.com/caos/zitadel/internal/errors"
	es_models "github.com/caos/zitadel/internal/eventstore/models"
	org_model "github.com/caos/zitadel/internal/org/model"
)

func Test_isReservedValidation(t *testing.T) {
	type res struct {
		isErr              func(error) bool
		agggregateSequence uint64
	}
	type args struct {
		aggregate *es_models.Aggregate
		eventType es_models.EventType
		Events    []*es_models.Event
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no events success",
			args: args{
				aggregate: &es_models.Aggregate{},
				eventType: "object.reserved",
				Events:    []*es_models.Event{},
			},
			res: res{
				isErr:              nil,
				agggregateSequence: 0,
			},
		},
		{
			name: "not reseved success",
			args: args{
				aggregate: &es_models.Aggregate{},
				eventType: "object.reserved",
				Events: []*es_models.Event{
					{
						AggregateID:   "asdf",
						AggregateType: "org",
						Sequence:      45,
						Type:          "object.released",
					},
				},
			},
			res: res{
				isErr:              nil,
				agggregateSequence: 45,
			},
		},
		{
			name: "reseved error",
			args: args{
				aggregate: &es_models.Aggregate{},
				eventType: "object.reserved",
				Events: []*es_models.Event{
					{
						AggregateID:   "asdf",
						AggregateType: "org",
						Sequence:      45,
						Type:          "object.reserved",
					},
				},
			},
			res: res{
				isErr:              errors.IsPreconditionFailed,
				agggregateSequence: 0,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			validate := isEventValidation(tt.args.aggregate, tt.args.eventType)

			err := validate(tt.args.Events...)

			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got: %v", err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got: %v", err)
			}
			if err == nil && tt.args.aggregate.PreviousSequence != tt.res.agggregateSequence {
				t.Errorf("expected sequence %d got %d", tt.res.agggregateSequence, tt.args.aggregate.PreviousSequence)
			}
		})
	}
}

func aggregateWithPrecondition() *es_models.Aggregate {
	return nil
}

func Test_uniqueNameAggregate(t *testing.T) {
	type res struct {
		expected *es_models.Aggregate
		isErr    func(error) bool
	}
	type args struct {
		ctx        context.Context
		aggCreator *es_models.AggregateCreator
		orgName    string
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no org name error",
			args: args{
				ctx:        auth.NewMockContext("orgID", "userID"),
				aggCreator: es_models.NewAggregateCreator("test"),
				orgName:    "",
			},
			res: res{
				expected: nil,
				isErr:    errors.IsPreconditionFailed,
			},
		},
		{
			name: "aggregate created",
			args: args{
				ctx:        auth.NewMockContext("orgID", "userID"),
				aggCreator: es_models.NewAggregateCreator("test"),
				orgName:    "asdf",
			},
			res: res{
				expected: aggregateWithPrecondition(),
				isErr:    nil,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := reservedUniqueNameAggregate(tt.args.ctx, tt.args.aggCreator, "", tt.args.orgName)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got: %v", err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && (got.Precondition == nil || got.Precondition.Query == nil || got.Precondition.Validation == nil) {
				t.Errorf("precondition is not set correctly")
			}
		})
	}
}

func Test_uniqueDomainAggregate(t *testing.T) {
	type res struct {
		expected *es_models.Aggregate
		isErr    func(error) bool
	}
	type args struct {
		ctx        context.Context
		aggCreator *es_models.AggregateCreator
		orgDomain  string
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no org domain error",
			args: args{
				ctx:        auth.NewMockContext("orgID", "userID"),
				aggCreator: es_models.NewAggregateCreator("test"),
				orgDomain:  "",
			},
			res: res{
				expected: nil,
				isErr:    errors.IsPreconditionFailed,
			},
		},
		{
			name: "aggregate created",
			args: args{
				ctx:        auth.NewMockContext("orgID", "userID"),
				aggCreator: es_models.NewAggregateCreator("test"),
				orgDomain:  "asdf",
			},
			res: res{
				expected: aggregateWithPrecondition(),
				isErr:    nil,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := reservedUniqueDomainAggregate(tt.args.ctx, tt.args.aggCreator, "", tt.args.orgDomain)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got: %v", err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && (got.Precondition == nil || got.Precondition.Query == nil || got.Precondition.Validation == nil) {
				t.Errorf("precondition is not set correctly")
			}
		})
	}
}

func TestOrgReactivateAggregate(t *testing.T) {
	type res struct {
		isErr func(error) bool
	}
	type args struct {
		aggCreator *es_models.AggregateCreator
		org        *model.Org
		ctx        context.Context
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "correct",
			args: args{
				aggCreator: es_models.NewAggregateCreator("test"),
				ctx:        auth.NewMockContext("org", "user"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "orgID",
						Sequence:    2,
					},
					State: int32(org_model.OrgStateInactive),
				},
			},
		},
		{
			name: "already active error",
			args: args{
				aggCreator: es_models.NewAggregateCreator("test"),
				ctx:        auth.NewMockContext("org", "user"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "orgID",
						Sequence:    2,
					},
					State: int32(org_model.OrgStateActive),
				},
			},
			res: res{
				isErr: errors.IsErrorInvalidArgument,
			},
		},
		{
			name: "org nil error",
			args: args{
				aggCreator: es_models.NewAggregateCreator("test"),
				ctx:        auth.NewMockContext("org", "user"),
				org:        nil,
			},
			res: res{
				isErr: errors.IsPreconditionFailed,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			aggregateCreator := orgReactivateAggregate(tt.args.aggCreator, tt.args.org)
			aggregate, err := aggregateCreator(tt.args.ctx)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got: %v", err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && aggregate == nil {
				t.Error("aggregate must not be nil")
			}
		})
	}
}

func TestOrgDeactivateAggregate(t *testing.T) {
	type res struct {
		isErr func(error) bool
	}
	type args struct {
		aggCreator *es_models.AggregateCreator
		org        *model.Org
		ctx        context.Context
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "correct",
			args: args{
				aggCreator: es_models.NewAggregateCreator("test"),
				ctx:        auth.NewMockContext("org", "user"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "orgID",
						Sequence:    2,
					},
					State: int32(org_model.OrgStateActive),
				},
			},
		},
		{
			name: "already inactive error",
			args: args{
				aggCreator: es_models.NewAggregateCreator("test"),
				ctx:        auth.NewMockContext("org", "user"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "orgID",
						Sequence:    2,
					},
					State: int32(org_model.OrgStateInactive),
				},
			},
			res: res{
				isErr: errors.IsErrorInvalidArgument,
			},
		},
		{
			name: "org nil error",
			args: args{
				aggCreator: es_models.NewAggregateCreator("test"),
				ctx:        auth.NewMockContext("org", "user"),
				org:        nil,
			},
			res: res{
				isErr: errors.IsPreconditionFailed,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			aggregateCreator := orgDeactivateAggregate(tt.args.aggCreator, tt.args.org)
			aggregate, err := aggregateCreator(tt.args.ctx)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got: %v", err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && aggregate == nil {
				t.Error("aggregate must not be nil")
			}
		})
	}
}

func TestOrgUpdateAggregates(t *testing.T) {
	type res struct {
		aggregateCount int
		isErr          func(error) bool
	}
	type args struct {
		ctx        context.Context
		aggCreator *es_models.AggregateCreator
		existing   *model.Org
		updated    *model.Org
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no existing org error",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				existing:   nil,
				updated:    &model.Org{},
			},
			res: res{
				aggregateCount: 0,
				isErr:          errors.IsPreconditionFailed,
			},
		},
		{
			name: "no updated org error",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				existing:   &model.Org{},
				updated:    nil,
			},
			res: res{
				aggregateCount: 0,
				isErr:          errors.IsPreconditionFailed,
			},
		},
		{
			name: "no changes",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				existing:   &model.Org{},
				updated:    &model.Org{},
			},
			res: res{
				aggregateCount: 0,
				isErr:          errors.IsPreconditionFailed,
			},
		},
		{
			name: "name changed",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				existing: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
					Name: "coas",
				},
				updated: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
					Name: "caos",
				},
			},
			res: res{
				aggregateCount: 3,
				isErr:          nil,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := OrgUpdateAggregates(tt.args.ctx, tt.args.aggCreator, tt.args.existing, tt.args.updated)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got: %v", err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && len(got) != tt.res.aggregateCount {
				t.Errorf("OrgUpdateAggregates() aggregate count = %d, wanted count %d", len(got), tt.res.aggregateCount)
			}
		})
	}
}

func TestOrgCreatedAggregates(t *testing.T) {
	type res struct {
		aggregateCount int
		isErr          func(error) bool
	}
	type args struct {
		ctx        context.Context
		aggCreator *es_models.AggregateCreator
		org        *model.Org
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no org error",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				org:        nil,
			},
			res: res{
				aggregateCount: 0,
				isErr:          errors.IsPreconditionFailed,
			},
		},
		{
			name: "org successful",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
					Name: "caos",
				},
			},
			res: res{
				aggregateCount: 2,
				isErr:          nil,
			},
		},
		{
			name: "org with domain successful",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
					Name: "caos",
					Domains: []*model.OrgDomain{&model.OrgDomain{
						Domain: "caos.ch",
					}},
				},
			},
			res: res{
				aggregateCount: 2,
				isErr:          nil,
			},
		},
		{
			name: "no name error",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
				},
			},
			res: res{
				aggregateCount: 2,
				isErr:          errors.IsPreconditionFailed,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := orgCreatedAggregates(tt.args.ctx, tt.args.aggCreator, tt.args.org)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got %T: %v", err, err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && len(got) != tt.res.aggregateCount {
				t.Errorf("OrgUpdateAggregates() aggregate count = %d, wanted count %d", len(got), tt.res.aggregateCount)
			}
		})
	}
}

func TestOrgDomainAddedAggregates(t *testing.T) {
	type res struct {
		eventCount int
		eventType  es_models.EventType
		isErr      func(error) bool
	}
	type args struct {
		ctx        context.Context
		aggCreator *es_models.AggregateCreator
		org        *model.Org
		domain     *model.OrgDomain
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no domain error",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
			},
			res: res{
				isErr: errors.IsPreconditionFailed,
			},
		},
		{
			name: "domain successful",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
				},
				domain: &model.OrgDomain{
					Domain: "caos.ch",
				},
			},
			res: res{
				eventCount: 1,
				eventType:  model.OrgDomainAdded,
				isErr:      nil,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			agg := OrgDomainAddedAggregate(tt.args.aggCreator, tt.args.org, tt.args.domain)
			got, err := agg(tt.args.ctx)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got %T: %v", err, err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}

			if tt.res.isErr == nil && got.Events[0].Type != tt.res.eventType {
				t.Errorf("OrgDomainAddedAggregate() event type = %v, wanted count %v", got.Events[0].Type, tt.res.eventType)
			}
			if tt.res.isErr == nil && len(got.Events) != tt.res.eventCount {
				t.Errorf("OrgDomainAddedAggregate() event count = %v, wanted count %v", len(got.Events), tt.res.eventCount)
			}
		})
	}
}

func TestOrgDomainVerifiedAggregates(t *testing.T) {
	type res struct {
		aggregateCount int
		isErr          func(error) bool
	}
	type args struct {
		ctx        context.Context
		aggCreator *es_models.AggregateCreator
		org        *model.Org
		domain     *model.OrgDomain
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no domain error",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
			},
			res: res{
				isErr: errors.IsPreconditionFailed,
			},
		},
		{
			name: "domain successful",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
				},
				domain: &model.OrgDomain{
					Domain: "caos.ch",
				},
			},
			res: res{
				aggregateCount: 2,
				isErr:          nil,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			agg := OrgDomainVerifiedAggregate(tt.args.aggCreator, tt.args.org, tt.args.domain)
			got, err := agg(tt.args.ctx)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got %T: %v", err, err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && len(got) != tt.res.aggregateCount {
				t.Errorf("OrgDomainVerifiedAggregate() aggregate count = %d, wanted count %d", len(got), tt.res.aggregateCount)
			}
		})
	}
}

func TestOrgDomainSetPrimaryAggregates(t *testing.T) {
	type res struct {
		eventsCount int
		eventType   es_models.EventType
		isErr       func(error) bool
	}
	type args struct {
		ctx        context.Context
		aggCreator *es_models.AggregateCreator
		org        *model.Org
		domain     *model.OrgDomain
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no domain error",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
			},
			res: res{
				isErr: errors.IsPreconditionFailed,
			},
		},
		{
			name: "domain successful",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
				},
				domain: &model.OrgDomain{
					Domain: "caos.ch",
				},
			},
			res: res{
				eventsCount: 1,
				eventType:   model.OrgDomainPrimarySet,
				isErr:       nil,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			agg := OrgDomainSetPrimaryAggregate(tt.args.aggCreator, tt.args.org, tt.args.domain)
			got, err := agg(tt.args.ctx)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got %T: %v", err, err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && got.Events[0].Type != tt.res.eventType {
				t.Errorf("OrgDomainSetPrimaryAggregate() event type = %v, wanted count %v", got.Events[0].Type, tt.res.eventType)
			}
			if tt.res.isErr == nil && len(got.Events) != tt.res.eventsCount {
				t.Errorf("OrgDomainSetPrimaryAggregate() event count = %d, wanted count %d", len(got.Events), tt.res.eventsCount)
			}
		})
	}
}

func TestOrgDomainRemovedAggregates(t *testing.T) {
	type res struct {
		aggregateCount int
		isErr          func(error) bool
	}
	type args struct {
		ctx        context.Context
		aggCreator *es_models.AggregateCreator
		org        *model.Org
		domain     *model.OrgDomain
	}
	tests := []struct {
		name string
		args args
		res  res
	}{
		{
			name: "no domain error",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
			},
			res: res{
				aggregateCount: 0,
				isErr:          errors.IsPreconditionFailed,
			},
		},
		{
			name: "domain successful",
			args: args{
				ctx:        auth.NewMockContext("org", "user"),
				aggCreator: es_models.NewAggregateCreator("test"),
				org: &model.Org{
					ObjectRoot: es_models.ObjectRoot{
						AggregateID: "sdaf",
						Sequence:    5,
					},
				},
				domain: &model.OrgDomain{
					Domain: "caos.ch",
				},
			},
			res: res{
				aggregateCount: 2,
				isErr:          nil,
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := OrgDomainRemovedAggregate(tt.args.ctx, tt.args.aggCreator, tt.args.org, tt.args.domain)
			if tt.res.isErr == nil && err != nil {
				t.Errorf("no error expected got %T: %v", err, err)
			}
			if tt.res.isErr != nil && !tt.res.isErr(err) {
				t.Errorf("wrong error got %T: %v", err, err)
			}
			if tt.res.isErr == nil && len(got) != tt.res.aggregateCount {
				t.Errorf("OrgDomainRemovedAggregate() aggregate count = %d, wanted count %d", len(got), tt.res.aggregateCount)
			}
		})
	}
}