diff --git a/backend/v3/domain/organization.go b/backend/v3/domain/organization.go index 7baa8debcb..b37733ec95 100644 --- a/backend/v3/domain/organization.go +++ b/backend/v3/domain/organization.go @@ -7,16 +7,18 @@ import ( "github.com/zitadel/zitadel/backend/v3/storage/database" ) -var State []string = []string{ - "ACTIVE", - "INACTIVE", -} +type State string + +const ( + Active State = "ACTIVE" + Inactive State = "INACTIVE" +) type Organization struct { ID string `json:"id,omitempty" db:"id"` Name string `json:"name,omitempty" db:"name"` InstanceID string `json:"instance_id,omitempty" db:"instance_id"` - State string `json:"state,omitempty" db:"state"` + State State `json:"state,omitempty" db:"state"` CreatedAt time.Time `json:"created_at,omitempty" db:"created_at"` UpdatedAt time.Time `json:"updated_at,omitempty" db:"updated_at"` DeletedAt *time.Time `json:"deleted_at,omitempty" db:"deleted_at"` @@ -52,6 +54,7 @@ type organizationConditions interface { type organizationChanges interface { // SetName sets the name column. SetName(name string) database.Change + SetState(state State) database.Change } // OrganizationRepository is the interface for the instance repository. diff --git a/backend/v3/storage/database/dialect/postgres/migration/002_organization_table/up.sql b/backend/v3/storage/database/dialect/postgres/migration/002_organization_table/up.sql index 502734f43c..d66db79e88 100644 --- a/backend/v3/storage/database/dialect/postgres/migration/002_organization_table/up.sql +++ b/backend/v3/storage/database/dialect/postgres/migration/002_organization_table/up.sql @@ -4,9 +4,9 @@ CREATE TYPE zitadel.organization_state AS ENUM ( ); CREATE TABLE zitadel.organizations( - id TEXT NOT NULL PRIMARY KEY, - name TEXT NOT NULL, - instance_id TEXT NOT NULL, + id TEXT NOT NULL CHECK (id <> '') PRIMARY KEY, + name TEXT NOT NULL CHECK (name <> ''), + instance_id TEXT NOT NULL CHECK (instance_id <> ''), state zitadel.organization_state NOT NULL, created_at TIMESTAMPTZ DEFAULT NOW(), updated_at TIMESTAMPTZ DEFAULT NOW(), diff --git a/backend/v3/storage/database/events_testing/organization_test.go b/backend/v3/storage/database/events_testing/organization_test.go index d2d2447632..41eea54531 100644 --- a/backend/v3/storage/database/events_testing/organization_test.go +++ b/backend/v3/storage/database/events_testing/organization_test.go @@ -37,13 +37,11 @@ func TestServer_TestOrganizationAddReduces(t *testing.T) { ) require.NoError(t, err) - activeState := domain.State[0] - // event org.added require.NotNil(t, organization.ID) require.Equal(t, orgName, organization.Name) require.NotNil(t, organization.InstanceID) - require.Equal(t, activeState, organization.State) + require.Equal(t, domain.Active, organization.State) assert.WithinRange(t, organization.CreatedAt, beforeCreate, afterCreate) assert.WithinRange(t, organization.UpdatedAt, beforeCreate, afterCreate) require.Nil(t, organization.DeletedAt) @@ -107,11 +105,9 @@ func TestServer_TestOrganizationDeactivateReduces(t *testing.T) { ) require.NoError(t, err) - deactiveState := domain.State[1] - // event org.deactivate require.Equal(t, orgName, organization.Name) - require.Equal(t, deactiveState, organization.State) + require.Equal(t, domain.Inactive, organization.State) assert.WithinRange(t, organization.UpdatedAt, beforeCreate, afterCreate) }, retryDuration, tick) } @@ -144,11 +140,9 @@ func TestServer_TestOrganizationActivateReduces(t *testing.T) { ) require.NoError(t, err) - deactiveState := domain.State[1] - // event org.reactivate require.Equal(t, orgName, organization.Name) - require.Equal(t, deactiveState, organization.State) + require.Equal(t, domain.Inactive, organization.State) assert.WithinRange(t, organization.UpdatedAt, beforeCreate, afterCreate) }, retryDuration, tick) } diff --git a/backend/v3/storage/database/repository/instance.go b/backend/v3/storage/database/repository/instance.go index 44ff0e7112..545aa0b21d 100644 --- a/backend/v3/storage/database/repository/instance.go +++ b/backend/v3/storage/database/repository/instance.go @@ -76,16 +76,16 @@ func (i *instance) Create(ctx context.Context, instance *domain.Instance) error // constraint violation if pgErr.Code == "23514" { if pgErr.ConstraintName == "instances_name_check" { - return errors.New("instnace name not provided") + return errors.New("instance name not provided") } if pgErr.ConstraintName == "instances_id_check" { - return errors.New("instnace id not provided") + return errors.New("instance id not provided") } } // duplicate if pgErr.Code == "23505" { if pgErr.ConstraintName == "instances_pkey" { - return errors.New("instnace id already exists") + return errors.New("instance id already exists") } } } diff --git a/backend/v3/storage/database/repository/instance_test.go b/backend/v3/storage/database/repository/instance_test.go index 107cc81002..40cb1b9422 100644 --- a/backend/v3/storage/database/repository/instance_test.go +++ b/backend/v3/storage/database/repository/instance_test.go @@ -54,7 +54,7 @@ func TestCreateInstance(t *testing.T) { } return instance }(), - err: errors.New("instnace name not provided"), + err: errors.New("instance name not provided"), }, { name: "adding same instance twice", @@ -78,7 +78,7 @@ func TestCreateInstance(t *testing.T) { assert.NoError(t, err) return &inst }, - err: errors.New("instnace id already exists"), + err: errors.New("instance id already exists"), }, { name: "adding instance with no id", @@ -96,7 +96,7 @@ func TestCreateInstance(t *testing.T) { } return instance }(), - err: errors.New("instnace id not provided"), + err: errors.New("instance id not provided"), }, } for _, tt := range tests { diff --git a/backend/v3/storage/database/repository/org.go b/backend/v3/storage/database/repository/org.go index c7ea29e085..d0832246a0 100644 --- a/backend/v3/storage/database/repository/org.go +++ b/backend/v3/storage/database/repository/org.go @@ -88,16 +88,19 @@ func (o *org) Create(ctx context.Context, organization *domain.Organization) err // constraint violation if pgErr.Code == "23514" { if pgErr.ConstraintName == "organizations_name_check" { - return errors.New("instnace name not provided") + return errors.New("organization name not provided") } if pgErr.ConstraintName == "organizations_id_check" { - return errors.New("instnace id not provided") + return errors.New("organization id not provided") + } + if pgErr.ConstraintName == "organizations_instance_id_check" { + return errors.New("instance id not provided") } } // duplicate if pgErr.Code == "23505" { if pgErr.ConstraintName == "organizations_pkey" { - return errors.New("instnace id already exists") + return errors.New("organization id already exists") } } } @@ -137,8 +140,13 @@ func (o org) Delete(ctx context.Context, condition database.Condition) error { // ------------------------------------------------------------- // SetName implements [domain.organizationChanges]. -func (i org) SetName(name string) database.Change { - return database.NewChange(i.NameColumn(), name) +func (o org) SetName(name string) database.Change { + return database.NewChange(o.NameColumn(), name) +} + +// SetState implements [domain.organizationChanges]. +func (i org) SetState(state domain.State) database.Change { + return database.NewChange(i.StateColumn(), state) } // ------------------------------------------------------------- diff --git a/backend/v3/storage/database/repository/org_test.go b/backend/v3/storage/database/repository/org_test.go index 1877a29458..11069db03b 100644 --- a/backend/v3/storage/database/repository/org_test.go +++ b/backend/v3/storage/database/repository/org_test.go @@ -1,10 +1,743 @@ package repository_test -// iraq: I had to comment out so that the UTs would pass -// TestBla is an example and can be removed later -// func TestBla(t *testing.T) { -// var count int -// err := pool.QueryRow(context.Background(), "select count(*) from zitadel.instances").Scan(&count) -// assert.NoError(t, err) -// assert.Equal(t, 0, count) +import ( + "context" + "errors" + "testing" + "time" + + "github.com/brianvoe/gofakeit/v6" + "github.com/stretchr/testify/assert" + + "github.com/zitadel/zitadel/backend/v3/domain" + "github.com/zitadel/zitadel/backend/v3/storage/database" + "github.com/zitadel/zitadel/backend/v3/storage/database/repository" +) + +func TestCreateOrganization(t *testing.T) { + tests := []struct { + name string + testFunc func() *domain.Organization + organization domain.Organization + err error + }{ + { + name: "happy path", + organization: func() domain.Organization { + organizationId := gofakeit.Name() + organizationName := gofakeit.Name() + instanceId := gofakeit.Name() + organization := domain.Organization{ + ID: organizationId, + Name: organizationName, + InstanceID: instanceId, + State: domain.Active, + } + return organization + }(), + }, + { + name: "create organization wihtout name", + organization: func() domain.Organization { + organizationId := gofakeit.Name() + // organizationName := gofakeit.Name() + instanceId := gofakeit.Name() + organization := domain.Organization{ + ID: organizationId, + Name: "", + InstanceID: instanceId, + State: domain.Active, + } + return organization + }(), + err: errors.New("organization name not provided"), + }, + { + name: "adding same organization twice", + testFunc: func() *domain.Organization { + organizationRepo := repository.OrgRepository(pool) + organizationId := gofakeit.Name() + organizationName := gofakeit.Name() + instanceId := gofakeit.Name() + + ctx := context.Background() + inst := domain.Organization{ + ID: organizationId, + Name: organizationName, + InstanceID: instanceId, + State: domain.Active, + } + + err := organizationRepo.Create(ctx, &inst) + assert.NoError(t, err) + return &inst + }, + err: errors.New("organization id already exists"), + }, + { + name: "adding organization with no id", + organization: func() domain.Organization { + // organizationId := gofakeit.Name() + organizationName := gofakeit.Name() + instanceId := gofakeit.Name() + organization := domain.Organization{ + // ID: organizationId, + Name: organizationName, + InstanceID: instanceId, + State: domain.Active, + } + return organization + }(), + err: errors.New("organization id not provided"), + }, + { + name: "adding organization with no instance id", + organization: func() domain.Organization { + organizationId := gofakeit.Name() + organizationName := gofakeit.Name() + organization := domain.Organization{ + ID: organizationId, + Name: organizationName, + // InstanceID: instanceId, + State: domain.Active, + } + return organization + }(), + err: errors.New("instance id not provided"), + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ctx := context.Background() + + var organization *domain.Organization + if tt.testFunc != nil { + organization = tt.testFunc() + } else { + organization = &tt.organization + } + organizationRepo := repository.OrgRepository(pool) + + // create organization + beforeCreate := time.Now() + err := organizationRepo.Create(ctx, organization) + assert.Equal(t, tt.err, err) + if err != nil { + return + } + afterCreate := time.Now() + + // check organization values + organization, err = organizationRepo.Get(ctx, + organizationRepo.NameCondition(database.TextOperationEqual, organization.Name), + ) + assert.NoError(t, err) + + assert.Equal(t, tt.organization.ID, organization.ID) + assert.Equal(t, tt.organization.Name, organization.Name) + assert.Equal(t, tt.organization.InstanceID, organization.InstanceID) + assert.Equal(t, tt.organization.State, organization.State) + assert.WithinRange(t, organization.CreatedAt, beforeCreate, afterCreate) + assert.WithinRange(t, organization.UpdatedAt, beforeCreate, afterCreate) + assert.Nil(t, organization.DeletedAt) + }) + } +} + +func TestUpdateOrganization(t *testing.T) { + organizationRepo := repository.OrgRepository(pool) + tests := []struct { + name string + testFunc func() *domain.Organization + update []database.Change + rowsAffected int64 + }{ + { + name: "happy path update name", + testFunc: func() *domain.Organization { + organizationId := gofakeit.Name() + organizationName := gofakeit.Name() + instanceId := gofakeit.Name() + + ctx := context.Background() + org := domain.Organization{ + ID: organizationId, + Name: organizationName, + InstanceID: instanceId, + State: domain.Active, + } + + // create organization + err := organizationRepo.Create(ctx, &org) + assert.NoError(t, err) + + // update with updated value + org.Name = "new_name" + return &org + }, + update: []database.Change{organizationRepo.SetName("new_name")}, + rowsAffected: 1, + }, + { + name: "happy path change state", + testFunc: func() *domain.Organization { + organizationId := gofakeit.Name() + organizationName := gofakeit.Name() + instanceId := gofakeit.Name() + + ctx := context.Background() + org := domain.Organization{ + ID: organizationId, + Name: organizationName, + InstanceID: instanceId, + State: domain.Active, + } + + // create organization + err := organizationRepo.Create(ctx, &org) + assert.NoError(t, err) + + // update with updated value + org.State = domain.Inactive + return &org + }, + update: []database.Change{organizationRepo.SetState(domain.Inactive)}, + rowsAffected: 1, + }, + // { + // name: "update non existent organization", + // testFunc: func() *domain.Organization { + // organizationId := gofakeit.Name() + + // org := domain.Organization{ + // ID: organizationId, + // } + // return &org + // }, + // rowsAffected: 0, + // }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + beforeUpdate := time.Now() + + ctx := context.Background() + organizationRepo := repository.OrgRepository(pool) + + createdOrg := tt.testFunc() + + // update org + rowsAffected, err := organizationRepo.Update(ctx, + organizationRepo.IDCondition(createdOrg.ID), + tt.update..., + ) + afterUpdate := time.Now() + assert.NoError(t, err) + + assert.Equal(t, tt.rowsAffected, rowsAffected) + + if rowsAffected == 0 { + return + } + + // check organization values + organization, err := organizationRepo.Get(ctx, + organizationRepo.IDCondition(createdOrg.ID), + ) + assert.NoError(t, err) + + assert.Equal(t, createdOrg.ID, organization.ID) + assert.Equal(t, createdOrg.Name, organization.Name) + assert.Equal(t, createdOrg.State, organization.State) + assert.WithinRange(t, organization.UpdatedAt, beforeUpdate, afterUpdate) + assert.Nil(t, organization.DeletedAt) + }) + } +} + +// func TestGetOrganization(t *testing.T) { +// organizationRepo := repository.OrgRepository(pool) +// type test struct { +// name string +// testFunc func() *domain.Organization +// conditionClauses []database.Condition +// noOrganizationReturned bool +// } + +// tests := []test{ +// func() test { +// organizationId := gofakeit.Name() +// return test{ +// name: "happy path get using id", +// testFunc: func() *domain.Organization { +// organizationName := gofakeit.Name() + +// ctx := context.Background() +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) +// return &inst +// }, +// conditionClauses: []database.Condition{organizationRepo.IDCondition(organizationId)}, +// } +// }(), +// func() test { +// organizationName := gofakeit.Name() +// return test{ +// name: "happy path get using name", +// testFunc: func() *domain.Organization { +// organizationId := gofakeit.Name() + +// ctx := context.Background() +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) +// return &inst +// }, +// conditionClauses: []database.Condition{organizationRepo.NameCondition(database.TextOperationEqual, organizationName)}, +// } +// }(), +// { +// name: "get non existent organization", +// testFunc: func() *domain.Organization { +// organizationId := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// } +// return &inst +// }, +// conditionClauses: []database.Condition{organizationRepo.NameCondition(database.TextOperationEqual, "non-existent-organization-name")}, +// noOrganizationReturned: true, +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// ctx := context.Background() +// organizationRepo := repository.OrgRepository(pool) + +// var organization *domain.Organization +// if tt.testFunc != nil { +// organization = tt.testFunc() +// } + +// // check organization values +// returnedOrganization, err := organizationRepo.Get(ctx, +// tt.conditionClauses..., +// ) +// assert.NoError(t, err) +// if tt.noOrganizationReturned { +// assert.Nil(t, returnedOrganization) +// return +// } + +// assert.Equal(t, returnedOrganization.ID, organization.ID) +// assert.Equal(t, returnedOrganization.Name, organization.Name) +// assert.Equal(t, returnedOrganization.DefaultOrgID, organization.DefaultOrgID) +// assert.Equal(t, returnedOrganization.IAMProjectID, organization.IAMProjectID) +// assert.Equal(t, returnedOrganization.ConsoleClientID, organization.ConsoleClientID) +// assert.Equal(t, returnedOrganization.ConsoleAppID, organization.ConsoleAppID) +// assert.Equal(t, returnedOrganization.DefaultLanguage, organization.DefaultLanguage) +// assert.NoError(t, err) +// }) +// } +// } + +// func TestListOrganization(t *testing.T) { +// type test struct { +// name string +// testFunc func() ([]*domain.Organization, database.PoolTest, func()) +// conditionClauses []database.Condition +// noOrganizationReturned bool +// } +// tests := []test{ +// { +// name: "happy path single organization no filter", +// testFunc: func() ([]*domain.Organization, database.PoolTest, func()) { +// ctx := context.Background() +// // create new db to make sure no organizations exist +// pool, stop, err := newEmbeededDB() +// assert.NoError(t, err) + +// organizationRepo := repository.OrgRepository(pool) +// noOfOrganizations := 1 +// organizations := make([]*domain.Organization, noOfOrganizations) +// for i := range noOfOrganizations { + +// organizationId := gofakeit.Name() +// organizationName := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) + +// organizations[i] = &inst +// } + +// return organizations, pool, stop +// }, +// }, +// { +// name: "happy path multiple organization no filter", +// testFunc: func() ([]*domain.Organization, database.PoolTest, func()) { +// ctx := context.Background() +// // create new db to make sure no organizations exist +// pool, stop, err := newEmbeededDB() +// assert.NoError(t, err) + +// organizationRepo := repository.OrgRepository(pool) +// noOfOrganizations := 5 +// organizations := make([]*domain.Organization, noOfOrganizations) +// for i := range noOfOrganizations { + +// organizationId := gofakeit.Name() +// organizationName := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) + +// organizations[i] = &inst +// } + +// return organizations, pool, stop +// }, +// }, +// func() test { +// organizationRepo := repository.OrgRepository(pool) +// organizationId := gofakeit.Name() +// return test{ +// name: "organization filter on id", +// testFunc: func() ([]*domain.Organization, database.PoolTest, func()) { +// ctx := context.Background() + +// noOfOrganizations := 1 +// organizations := make([]*domain.Organization, noOfOrganizations) +// for i := range noOfOrganizations { + +// organizationName := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) + +// organizations[i] = &inst +// } + +// return organizations, nil, nil +// }, +// conditionClauses: []database.Condition{organizationRepo.IDCondition(organizationId)}, +// } +// }(), +// func() test { +// organizationRepo := repository.OrgRepository(pool) +// organizationName := gofakeit.Name() +// return test{ +// name: "multiple organization filter on name", +// testFunc: func() ([]*domain.Organization, database.PoolTest, func()) { +// ctx := context.Background() + +// noOfOrganizations := 5 +// organizations := make([]*domain.Organization, noOfOrganizations) +// for i := range noOfOrganizations { + +// organizationId := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) + +// organizations[i] = &inst +// } + +// return organizations, nil, nil +// }, +// conditionClauses: []database.Condition{organizationRepo.NameCondition(database.TextOperationEqual, organizationName)}, +// } +// }(), +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// ctx := context.Background() + +// var organizations []*domain.Organization + +// pool := pool +// if tt.testFunc != nil { +// var stop func() +// var pool_ database.PoolTest +// organizations, pool_, stop = tt.testFunc() +// if pool_ != nil { +// pool = pool_ +// defer stop() +// } +// } +// organizationRepo := repository.OrgRepository(pool) + +// // check organization values +// returnedOrganizations, err := organizationRepo.List(ctx, +// tt.conditionClauses..., +// ) +// assert.NoError(t, err) +// if tt.noOrganizationReturned { +// assert.Nil(t, returnedOrganizations) +// return +// } + +// assert.Equal(t, len(organizations), len(returnedOrganizations)) +// for i, organization := range organizations { +// assert.Equal(t, returnedOrganizations[i].ID, organization.ID) +// assert.Equal(t, returnedOrganizations[i].Name, organization.Name) +// assert.Equal(t, returnedOrganizations[i].DefaultOrgID, organization.DefaultOrgID) +// assert.Equal(t, returnedOrganizations[i].IAMProjectID, organization.IAMProjectID) +// assert.Equal(t, returnedOrganizations[i].ConsoleClientID, organization.ConsoleClientID) +// assert.Equal(t, returnedOrganizations[i].ConsoleAppID, organization.ConsoleAppID) +// assert.Equal(t, returnedOrganizations[i].DefaultLanguage, organization.DefaultLanguage) +// assert.NoError(t, err) +// } +// }) +// } +// } + +// func TestDeleteOrganization(t *testing.T) { +// type test struct { +// name string +// testFunc func() +// conditionClauses database.Condition +// } +// tests := []test{ +// func() test { +// organizationRepo := repository.OrgRepository(pool) +// organizationId := gofakeit.Name() +// return test{ +// name: "happy path delete single organization filter id", +// testFunc: func() { +// ctx := context.Background() + +// noOfOrganizations := 1 +// organizations := make([]*domain.Organization, noOfOrganizations) +// for i := range noOfOrganizations { + +// organizationName := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) + +// organizations[i] = &inst +// } +// }, +// conditionClauses: organizationRepo.IDCondition(organizationId), +// } +// }(), +// func() test { +// organizationRepo := repository.OrgRepository(pool) +// organizationName := gofakeit.Name() +// return test{ +// name: "happy path delete single organization filter name", +// testFunc: func() { +// ctx := context.Background() + +// noOfOrganizations := 1 +// organizations := make([]*domain.Organization, noOfOrganizations) +// for i := range noOfOrganizations { + +// organizationId := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) + +// organizations[i] = &inst +// } +// }, +// conditionClauses: organizationRepo.NameCondition(database.TextOperationEqual, organizationName), +// } +// }(), +// func() test { +// organizationRepo := repository.OrgRepository(pool) +// non_existent_organization_name := gofakeit.Name() +// return test{ +// name: "delete non existent organization", +// conditionClauses: organizationRepo.NameCondition(database.TextOperationEqual, non_existent_organization_name), +// } +// }(), +// func() test { +// organizationRepo := repository.OrgRepository(pool) +// organizationName := gofakeit.Name() +// return test{ +// name: "multiple organization filter on name", +// testFunc: func() { +// ctx := context.Background() + +// noOfOrganizations := 5 +// organizations := make([]*domain.Organization, noOfOrganizations) +// for i := range noOfOrganizations { + +// organizationId := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) + +// organizations[i] = &inst +// } +// }, +// conditionClauses: organizationRepo.NameCondition(database.TextOperationEqual, organizationName), +// } +// }(), +// func() test { +// organizationRepo := repository.OrgRepository(pool) +// organizationName := gofakeit.Name() +// return test{ +// name: "deleted already deleted organization", +// testFunc: func() { +// ctx := context.Background() + +// noOfOrganizations := 1 +// organizations := make([]*domain.Organization, noOfOrganizations) +// for i := range noOfOrganizations { + +// organizationId := gofakeit.Name() + +// inst := domain.Organization{ +// ID: organizationId, +// Name: organizationName, +// DefaultOrgID: "defaultOrgId", +// IAMProjectID: "iamProject", +// ConsoleClientID: "consoleCLient", +// ConsoleAppID: "consoleApp", +// DefaultLanguage: "defaultLanguage", +// } + +// // create organization +// err := organizationRepo.Create(ctx, &inst) +// assert.NoError(t, err) + +// organizations[i] = &inst +// } + +// // delete organization +// err := organizationRepo.Delete(ctx, +// organizationRepo.NameCondition(database.TextOperationEqual, organizationName), +// ) +// assert.NoError(t, err) +// }, +// conditionClauses: organizationRepo.NameCondition(database.TextOperationEqual, organizationName), +// } +// }(), +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// ctx := context.Background() +// organizationRepo := repository.OrgRepository(pool) + +// if tt.testFunc != nil { +// tt.testFunc() +// } + +// // delete organization +// err := organizationRepo.Delete(ctx, +// tt.conditionClauses, +// ) +// assert.NoError(t, err) + +// // check organization was deleted +// organization, err := organizationRepo.Get(ctx, +// tt.conditionClauses, +// ) +// assert.NoError(t, err) +// assert.Nil(t, organization) +// }) +// } // } diff --git a/internal/query/projection/org_relational.go b/internal/query/projection/org_relational.go index dca44e8622..49faef5577 100644 --- a/internal/query/projection/org_relational.go +++ b/internal/query/projection/org_relational.go @@ -96,16 +96,13 @@ func (p *orgRelationalProjection) reduceOrgRelationalAdded(event eventstore.Even return nil, zerrors.ThrowInvalidArgumentf(nil, "HANDL-uYq5R", "reduce.wrong.event.type %s", org.OrgAddedEventType) } - // need to convert old state (int) to new state (enum) - state := repoDomain.State[domain.OrgStateActive-1] - return handler.NewCreateStatement( e, []handler.Column{ handler.NewCol(OrgColumnID, e.Aggregate().ID), handler.NewCol(OrgColumnName, e.Name), handler.NewCol(OrgColumnInstanceID, e.Aggregate().InstanceID), - handler.NewCol(State, state), + handler.NewCol(State, repoDomain.Active), handler.NewCol(CreatedAt, e.CreationDate()), handler.NewCol(UpdatedAt, e.CreationDate()), }, @@ -139,12 +136,10 @@ func (p *orgRelationalProjection) reduceOrgRelationalDeactivated(event eventstor return nil, zerrors.ThrowInvalidArgumentf(nil, "HANDL-BApK5", "reduce.wrong.event.type %s", org.OrgDeactivatedEventType) } - // need to convert old state (int) to new state (enum) - state := repoDomain.State[domain.OrgStateInactive-1] return handler.NewUpdateStatement( e, []handler.Column{ - handler.NewCol(State, state), + handler.NewCol(State, repoDomain.Inactive), handler.NewCol(UpdatedAt, e.CreationDate()), }, []handler.Condition{