TheArchive/zitadel
1
0
Fork 0
mirror of https://github.com/zitadel/zitadel.git synced 2025-08-11 15:37:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix repo

Browse Source
This commit is contained in:
adlerhurst
2025-08-05 16:57:05 +02:00
parent 5a75e9d558
commit caf4090db9
5 changed files with 152 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
backend/v3/domain/organization.go
View File

@@ -78,12 +78,7 @@ func (cmd *CreateOrganizationCommand) Execute(ctx context.Context, opts *Command
} }
defer func() { err = close(ctx, err) }() defer func() { err = close(ctx, err) }()
err = orgRepo(opts.DB).Create(ctx, &Organization{ err = orgRepo(opts.DB).Create(ctx, cmd)
ID: cmd.ID,
Name: cmd.Name,
InstanceID: cmd.InstanceID,
State: OrgStateActive,
})
if err != nil { if err != nil {
return err return err
} }

2
backend/v3/domain/organization_repository.go
View File

@@ -15,7 +15,7 @@ type OrganizationRepository interface {
Get(ctx context.Context, opts ...database.QueryOption) (*Organization, error) Get(ctx context.Context, opts ...database.QueryOption) (*Organization, error)
List(ctx context.Context, opts ...database.QueryOption) ([]*Organization, error) List(ctx context.Context, opts ...database.QueryOption) ([]*Organization, error)
Create(ctx context.Context, instance *Organization) error Create(ctx context.Context, org *CreateOrganizationCommand) error
Update(ctx context.Context, condition database.Condition, changes ...database.Change) (int64, error) Update(ctx context.Context, condition database.Condition, changes ...database.Change) (int64, error)
Delete(ctx context.Context, condition database.Condition) (int64, error) Delete(ctx context.Context, condition database.Condition) (int64, error)

8
backend/v3/storage/database/repository/org.go
View File

@@ -91,15 +91,15 @@ func (o *org) joinDomains() database.QueryOption {
const createOrganizationStmt = `INSERT INTO zitadel.organizations (id, name, instance_id, state)` + const createOrganizationStmt = `INSERT INTO zitadel.organizations (id, name, instance_id, state)` +
` VALUES ($1, $2, $3, $4)` + ` VALUES ($1, $2, $3, $4)` +
` RETURNING created_at, updated_at` ` RETURNING created_at`
// Create implements [domain.OrganizationRepository]. // Create implements [domain.OrganizationRepository].
func (o *org) Create(ctx context.Context, organization *domain.Organization) error { func (o *org) Create(ctx context.Context, organization *domain.CreateOrganizationCommand) error {
builder := database.StatementBuilder{} builder := database.StatementBuilder{}
builder.AppendArgs(organization.ID, organization.Name, organization.InstanceID, organization.State) builder.AppendArgs(organization.ID, organization.Name, organization.InstanceID, domain.OrgStateActive)
builder.WriteString(createOrganizationStmt) builder.WriteString(createOrganizationStmt)
return o.client.QueryRow(ctx, builder.String(), builder.Args()...).Scan(&organization.CreatedAt, &organization.UpdatedAt) return o.client.QueryRow(ctx, builder.String(), builder.Args()...).Scan(&organization.CreatedAt)
} }
// Update implements [domain.OrganizationRepository]. // Update implements [domain.OrganizationRepository].

15
backend/v3/storage/database/repository/org_domain_test.go
View File

@@ -32,11 +32,10 @@ func TestAddOrganizationDomain(t *testing.T) {
// create organization // create organization
orgID := gofakeit.UUID() orgID := gofakeit.UUID()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: orgID, ID: orgID,
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceID, InstanceID: instanceID,
State: domain.OrgStateActive,
} }
tests := []struct { tests := []struct {
@@ -218,11 +217,10 @@ func TestGetOrganizationDomain(t *testing.T) {
// create organization // create organization
orgID := gofakeit.UUID() orgID := gofakeit.UUID()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: orgID, ID: orgID,
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceID, InstanceID: instanceID,
State: domain.OrgStateActive,
} }
tx, err := pool.Begin(t.Context(), nil) tx, err := pool.Begin(t.Context(), nil)
@@ -376,11 +374,10 @@ func TestListOrganizationDomains(t *testing.T) {
// create organization // create organization
orgID := gofakeit.UUID() orgID := gofakeit.UUID()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: orgID, ID: orgID,
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceID, InstanceID: instanceID,
State: domain.OrgStateActive,
} }
tx, err := pool.Begin(t.Context(), nil) tx, err := pool.Begin(t.Context(), nil)
@@ -512,11 +509,10 @@ func TestUpdateOrganizationDomain(t *testing.T) {
// create organization // create organization
orgID := gofakeit.UUID() orgID := gofakeit.UUID()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: orgID, ID: orgID,
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceID, InstanceID: instanceID,
State: domain.OrgStateActive,
} }
tx, err := pool.Begin(t.Context(), nil) tx, err := pool.Begin(t.Context(), nil)
@@ -646,11 +642,10 @@ func TestRemoveOrganizationDomain(t *testing.T) {
// create organization // create organization
orgID := gofakeit.UUID() orgID := gofakeit.UUID()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: orgID, ID: orgID,
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceID, InstanceID: instanceID,
State: domain.OrgStateActive,
} }
tx, err := pool.Begin(t.Context(), nil) tx, err := pool.Begin(t.Context(), nil)

240
backend/v3/storage/database/repository/org_test.go
View File

@@ -32,34 +32,32 @@ func TestCreateOrganization(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
testFunc func(ctx context.Context, t *testing.T) *domain.Organization testFunc func(ctx context.Context, t *testing.T) *domain.CreateOrganizationCommand
organization domain.Organization organization domain.CreateOrganizationCommand
err error err error
}{ }{
{ {
name: "happy path", name: "happy path",
organization: func() domain.Organization { organization: func() domain.CreateOrganizationCommand {
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
return organization return organization
}(), }(),
}, },
{ {
name: "create organization without name", name: "create organization without name",
organization: func() domain.Organization { organization: func() domain.CreateOrganizationCommand {
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
// organizationName := gofakeit.Name() // organizationName := gofakeit.Name()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: "", Name: "",
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
return organization return organization
}(), }(),
@@ -67,16 +65,15 @@ func TestCreateOrganization(t *testing.T) {
}, },
{ {
name: "adding org with same id twice", name: "adding org with same id twice",
testFunc: func(ctx context.Context, t *testing.T) *domain.Organization { testFunc: func(ctx context.Context, t *testing.T) *domain.CreateOrganizationCommand {
organizationRepo := repository.OrganizationRepository(pool) organizationRepo := repository.OrganizationRepository(pool)
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
@@ -89,16 +86,15 @@ func TestCreateOrganization(t *testing.T) {
}, },
{ {
name: "adding org with same name twice", name: "adding org with same name twice",
testFunc: func(ctx context.Context, t *testing.T) *domain.Organization { testFunc: func(ctx context.Context, t *testing.T) *domain.CreateOrganizationCommand {
organizationRepo := repository.OrganizationRepository(pool) organizationRepo := repository.OrganizationRepository(pool)
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
@@ -111,8 +107,8 @@ func TestCreateOrganization(t *testing.T) {
}, },
func() struct { func() struct {
name string name string
testFunc func(ctx context.Context, t *testing.T) *domain.Organization testFunc func(ctx context.Context, t *testing.T) *domain.CreateOrganizationCommand
organization domain.Organization organization domain.CreateOrganizationCommand
err error err error
} { } {
orgID := gofakeit.Name() orgID := gofakeit.Name()
@@ -120,12 +116,12 @@ func TestCreateOrganization(t *testing.T) {
return struct { return struct {
name string name string
testFunc func(ctx context.Context, t *testing.T) *domain.Organization testFunc func(ctx context.Context, t *testing.T) *domain.CreateOrganizationCommand
organization domain.Organization organization domain.CreateOrganizationCommand
err error err error
}{ }{
name: "adding org with same name, different instance", name: "adding org with same name, different instance",
testFunc: func(ctx context.Context, t *testing.T) *domain.Organization { testFunc: func(ctx context.Context, t *testing.T) *domain.CreateOrganizationCommand {
// create instance // create instance
instId := gofakeit.Name() instId := gofakeit.Name()
instance := domain.Instance{ instance := domain.Instance{
@@ -143,11 +139,10 @@ func TestCreateOrganization(t *testing.T) {
organizationRepo := repository.OrganizationRepository(pool) organizationRepo := repository.OrganizationRepository(pool)
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: organizationName, Name: organizationName,
InstanceID: instId, InstanceID: instId,
State: domain.OrgStateActive,
} }
err = organizationRepo.Create(ctx, &org) err = organizationRepo.Create(ctx, &org)
@@ -159,24 +154,22 @@ func TestCreateOrganization(t *testing.T) {
org.InstanceID = instanceId org.InstanceID = instanceId
return &org return &org
}, },
organization: domain.Organization{ organization: domain.CreateOrganizationCommand{
ID: orgID, ID: orgID,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
}, },
} }
}(), }(),
{ {
name: "adding organization with no id", name: "adding organization with no id",
organization: func() domain.Organization { organization: func() domain.CreateOrganizationCommand {
// organizationId := gofakeit.Name() // organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
// ID: organizationId, // ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
return organization return organization
}(), }(),
@@ -184,13 +177,13 @@ func TestCreateOrganization(t *testing.T) {
}, },
{ {
name: "adding organization with no instance id", name: "adding organization with no instance id",
organization: func() domain.Organization { organization: func() domain.CreateOrganizationCommand {
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
State: domain.OrgStateActive, InstanceID: "",
} }
return organization return organization
}(), }(),
@@ -198,14 +191,13 @@ func TestCreateOrganization(t *testing.T) {
}, },
{ {
name: "adding organization with non existent instance id", name: "adding organization with non existent instance id",
organization: func() domain.Organization { organization: func() domain.CreateOrganizationCommand {
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
organization := domain.Organization{ organization := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: gofakeit.Name(), InstanceID: gofakeit.Name(),
State: domain.OrgStateActive,
} }
return organization return organization
}(), }(),
@@ -216,17 +208,17 @@ func TestCreateOrganization(t *testing.T) {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
ctx := context.Background() ctx := context.Background()
var organization *domain.Organization var command *domain.CreateOrganizationCommand
if tt.testFunc != nil { if tt.testFunc != nil {
organization = tt.testFunc(ctx, t) command = tt.testFunc(ctx, t)
} else { } else {
organization = &tt.organization command = &tt.organization
} }
organizationRepo := repository.OrganizationRepository(pool) organizationRepo := repository.OrganizationRepository(pool)
// create organization // create organization
beforeCreate := time.Now() beforeCreate := time.Now()
err = organizationRepo.Create(ctx, organization) err = organizationRepo.Create(ctx, command)
assert.ErrorIs(t, err, tt.err) assert.ErrorIs(t, err, tt.err)
if err != nil { if err != nil {
return return
@@ -234,11 +226,11 @@ func TestCreateOrganization(t *testing.T) {
afterCreate := time.Now() afterCreate := time.Now()
// check organization values // check organization values
organization, err = organizationRepo.Get(ctx, organization, err := organizationRepo.Get(ctx,
database.WithCondition( database.WithCondition(
database.And( database.And(
organizationRepo.IDCondition(organization.ID), organizationRepo.IDCondition(command.ID),
organizationRepo.InstanceIDCondition(organization.InstanceID), organizationRepo.InstanceIDCondition(command.InstanceID),
), ),
), ),
) )
@@ -247,7 +239,7 @@ func TestCreateOrganization(t *testing.T) {
assert.Equal(t, tt.organization.ID, organization.ID) assert.Equal(t, tt.organization.ID, organization.ID)
assert.Equal(t, tt.organization.Name, organization.Name) assert.Equal(t, tt.organization.Name, organization.Name)
assert.Equal(t, tt.organization.InstanceID, organization.InstanceID) assert.Equal(t, tt.organization.InstanceID, organization.InstanceID)
assert.Equal(t, tt.organization.State, organization.State) assert.Equal(t, domain.OrgStateActive, organization.State)
assert.WithinRange(t, organization.CreatedAt, beforeCreate, afterCreate) assert.WithinRange(t, organization.CreatedAt, beforeCreate, afterCreate)
assert.WithinRange(t, organization.UpdatedAt, beforeCreate, afterCreate) assert.WithinRange(t, organization.UpdatedAt, beforeCreate, afterCreate)
}) })
@@ -283,20 +275,22 @@ func TestUpdateOrganization(t *testing.T) {
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
// update with updated value return &domain.Organization{
org.Name = "new_name" ID: org.ID,
return &org Name: "new_name",
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
}, },
update: []database.Change{organizationRepo.SetName("new_name")}, update: []database.Change{organizationRepo.SetName("new_name")},
rowsAffected: 1, rowsAffected: 1,
@@ -307,18 +301,17 @@ func TestUpdateOrganization(t *testing.T) {
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
// delete instance // delete organization
_, err = organizationRepo.Delete(ctx, _, err = organizationRepo.Delete(ctx,
database.And( database.And(
organizationRepo.IDCondition(org.ID), organizationRepo.IDCondition(org.ID),
@@ -327,7 +320,11 @@ func TestUpdateOrganization(t *testing.T) {
) )
require.NoError(t, err) require.NoError(t, err)
return &org return &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
}
}, },
update: []database.Change{organizationRepo.SetName("new_name")}, update: []database.Change{organizationRepo.SetName("new_name")},
rowsAffected: 0, rowsAffected: 0,
@@ -338,20 +335,22 @@ func TestUpdateOrganization(t *testing.T) {
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
// update with updated value return &domain.Organization{
org.State = domain.OrgStateInactive ID: org.ID,
return &org Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateInactive,
}
}, },
update: []database.Change{organizationRepo.SetState(domain.OrgStateInactive)}, update: []database.Change{organizationRepo.SetState(domain.OrgStateInactive)},
rowsAffected: 1, rowsAffected: 1,
@@ -359,12 +358,10 @@ func TestUpdateOrganization(t *testing.T) {
{ {
name: "update non existent organization", name: "update non existent organization",
testFunc: func(ctx context.Context, t *testing.T) *domain.Organization { testFunc: func(ctx context.Context, t *testing.T) *domain.Organization {
organizationId := gofakeit.Name()
org := domain.Organization{ return &domain.Organization{
ID: organizationId, ID: gofakeit.UUID(),
} }
return &org
}, },
update: []database.Change{organizationRepo.SetName("new_name")}, update: []database.Change{organizationRepo.SetName("new_name")},
rowsAffected: 0, rowsAffected: 0,
@@ -435,11 +432,10 @@ func TestGetOrganization(t *testing.T) {
// create organization // create organization
// this org is created as an additional org which should NOT // this org is created as an additional org which should NOT
// be returned in the results of the tests // be returned in the results of the tests
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
err = orgRepo.Create(t.Context(), &org) err = orgRepo.Create(t.Context(), &org)
require.NoError(t, err) require.NoError(t, err)
@@ -459,18 +455,22 @@ func TestGetOrganization(t *testing.T) {
testFunc: func(ctx context.Context, t *testing.T) *domain.Organization { testFunc: func(ctx context.Context, t *testing.T) *domain.Organization {
organizationName := gofakeit.Name() organizationName := gofakeit.Name()
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := orgRepo.Create(ctx, &org) err := orgRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
return &org return &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
}, },
condition: orgRepo.IDCondition(organizationId), condition: orgRepo.IDCondition(organizationId),
} }
@@ -482,18 +482,22 @@ func TestGetOrganization(t *testing.T) {
testFunc: func(ctx context.Context, t *testing.T) *domain.Organization { testFunc: func(ctx context.Context, t *testing.T) *domain.Organization {
organizationId := gofakeit.Name() organizationId := gofakeit.Name()
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := orgRepo.Create(ctx, &org) err := orgRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
return &org return &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
}, },
condition: orgRepo.NameCondition(database.TextOperationEqual, organizationName), condition: orgRepo.NameCondition(database.TextOperationEqual, organizationName),
} }
@@ -501,11 +505,7 @@ func TestGetOrganization(t *testing.T) {
{ {
name: "get non existent organization", name: "get non existent organization",
testFunc: func(ctx context.Context, t *testing.T) *domain.Organization { testFunc: func(ctx context.Context, t *testing.T) *domain.Organization {
org := domain.Organization{ return new(domain.Organization)
ID: "non existent org",
Name: "non existent org",
}
return &org
}, },
condition: orgRepo.NameCondition(database.TextOperationEqual, "non-existent-instance-name"), condition: orgRepo.NameCondition(database.TextOperationEqual, "non-existent-instance-name"),
err: new(database.NoRowFoundError), err: new(database.NoRowFoundError),
@@ -585,18 +585,22 @@ func TestListOrganization(t *testing.T) {
organizations := make([]*domain.Organization, noOfOrganizations) organizations := make([]*domain.Organization, noOfOrganizations)
for i := range noOfOrganizations { for i := range noOfOrganizations {
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
organizations[i] = &org organizations[i] = &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
} }
return organizations return organizations
@@ -609,18 +613,22 @@ func TestListOrganization(t *testing.T) {
organizations := make([]*domain.Organization, noOfOrganizations) organizations := make([]*domain.Organization, noOfOrganizations)
for i := range noOfOrganizations { for i := range noOfOrganizations {
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
organizations[i] = &org organizations[i] = &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
} }
return organizations return organizations
@@ -634,11 +642,10 @@ func TestListOrganization(t *testing.T) {
// create organization // create organization
// this org is created as an additional org which should NOT // this org is created as an additional org which should NOT
// be returned in the results of this test case // be returned in the results of this test case
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
err = organizationRepo.Create(ctx, &org) err = organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
@@ -647,18 +654,22 @@ func TestListOrganization(t *testing.T) {
organizations := make([]*domain.Organization, noOfOrganizations) organizations := make([]*domain.Organization, noOfOrganizations)
for i := range noOfOrganizations { for i := range noOfOrganizations {
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
organizations[i] = &org organizations[i] = &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
} }
return organizations return organizations
@@ -672,11 +683,10 @@ func TestListOrganization(t *testing.T) {
// create organization // create organization
// this org is created as an additional org which should NOT // this org is created as an additional org which should NOT
// be returned in the results of this test case // be returned in the results of this test case
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
err = organizationRepo.Create(ctx, &org) err = organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
@@ -685,18 +695,31 @@ func TestListOrganization(t *testing.T) {
organizations := make([]*domain.Organization, noOfOrganizations) organizations := make([]*domain.Organization, noOfOrganizations)
for i := range noOfOrganizations { for i := range noOfOrganizations {
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateInactive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
changedRows, err := organizationRepo.Update(ctx,
database.And(
organizationRepo.IDCondition(org.ID),
organizationRepo.InstanceIDCondition(org.InstanceID),
),
organizationRepo.SetState(domain.OrgStateInactive),
)
require.NoError(t, err)
require.Equal(t, int64(1), changedRows)
organizations[i] = &org organizations[i] = &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateInactive,
}
} }
return organizations return organizations
@@ -726,11 +749,10 @@ func TestListOrganization(t *testing.T) {
// create organization // create organization
// this org is created as an additional org which should NOT // this org is created as an additional org which should NOT
// be returned in the results of this test case // be returned in the results of this test case
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId_1, InstanceID: instanceId_1,
State: domain.OrgStateActive,
} }
err = organizationRepo.Create(ctx, &org) err = organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
@@ -752,18 +774,22 @@ func TestListOrganization(t *testing.T) {
organizations := make([]*domain.Organization, noOfOrganizations) organizations := make([]*domain.Organization, noOfOrganizations)
for i := range noOfOrganizations { for i := range noOfOrganizations {
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId_2, InstanceID: instanceId_2,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
organizations[i] = &org organizations[i] = &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
} }
return organizations return organizations
@@ -841,18 +867,22 @@ func TestDeleteOrganization(t *testing.T) {
organizations := make([]*domain.Organization, noOfOrganizations) organizations := make([]*domain.Organization, noOfOrganizations)
for i := range noOfOrganizations { for i := range noOfOrganizations {
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: organizationId, ID: organizationId,
Name: gofakeit.Name(), Name: gofakeit.Name(),
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
organizations[i] = &org organizations[i] = &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
} }
}, },
condition: organizationRepo.IDCondition(organizationId), condition: organizationRepo.IDCondition(organizationId),
@@ -869,18 +899,22 @@ func TestDeleteOrganization(t *testing.T) {
organizations := make([]*domain.Organization, noOfOrganizations) organizations := make([]*domain.Organization, noOfOrganizations)
for i := range noOfOrganizations { for i := range noOfOrganizations {
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
organizations[i] = &org organizations[i] = &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
} }
}, },
condition: organizationRepo.NameCondition(database.TextOperationEqual, organizationName), condition: organizationRepo.NameCondition(database.TextOperationEqual, organizationName),
@@ -905,18 +939,22 @@ func TestDeleteOrganization(t *testing.T) {
organizations := make([]*domain.Organization, noOfOrganizations) organizations := make([]*domain.Organization, noOfOrganizations)
for i := range noOfOrganizations { for i := range noOfOrganizations {
org := domain.Organization{ org := domain.CreateOrganizationCommand{
ID: gofakeit.Name(), ID: gofakeit.Name(),
Name: organizationName, Name: organizationName,
InstanceID: instanceId, InstanceID: instanceId,
State: domain.OrgStateActive,
} }
// create organization // create organization
err := organizationRepo.Create(ctx, &org) err := organizationRepo.Create(ctx, &org)
require.NoError(t, err) require.NoError(t, err)
organizations[i] = &org organizations[i] = &domain.Organization{
ID: org.ID,
Name: org.Name,
InstanceID: org.InstanceID,
State: domain.OrgStateActive,
}
} }
// delete organization // delete organization