feat(domain): Organization APIs with relational tables (#10704)

# Which Problems Are Solved

This PR implements the endpoints listed in #10445 using relational
tables.

- [x] UpdateOrganization
- [x] ListOrganizations
- [x] DeleteOrganization
- [x] DeactivateOrganization
- [x] ActivateOrganization

# How the Problems Are Solved

- **UpdateOrganization:** Implemented logic for `Validate()`,
`Execute()` and `Events()`. On CQRS side, updating an organization emits
events related to the organization and its domains. Separate commanders
have been made for the domain events so that their logic is run
accordingly and we keep separation of concerns. Implementation of the
domains is left to its own ticket.

Because some domain-related data is changed during the organization
update, its original values are saved as pointers inside
[UpdateOrgCommand](https://github.com/zitadel/zitadel/blob/4f87cd8d0cfd75f290aa13c342e4939cecebef73/backend/v3/domain/org_update.go#L20).

These variables will be then used as input for the domain commanders
(that will run after the update organization one).
- **ListOrganizations:** Implemented logic for `Validate()`,
`Execute()`. Utility methods have been made to parse the input queries.
This commander is used both by the v2 and v2beta endpoint, so a
translation layer has been put in place to translate all v2beta requests
into v2. The commander strictly handles v2 request only.

The translation layer between v2beta and v2 APIs was made so to make it
simple to remove it once the v2beta APIs will be removed (a simple
deletion should suffice). A `converter` package [is
shipped](https://github.com/zitadel/zitadel/blob/4f87cd8d0cfd75f290aa13c342e4939cecebef73/backend/v3/api/org/v2/convert/README.md#L5)
as well with instruction for removal. TODOs have been put in place all
over the code to indicate that the related piece of code needs to be
removed once v2beta -> v2 transition is complete.
- **DeleteOrganization:** Implemented logic for `Validate()`,
`Execute()` and `Events()`. The `Events()` method is mostly incomplete
as it requires a lot of data that is currently not retrievable due to
the lack of their relational tables.
- **DeactivateOrganization** and **ActivateOrganization**: Implemented
logic for `Validate()`, `Execute()` and `Events()`. No notable remarks.

👉 All endpoints return matching errors to the CQRS counterpart: this way
allows re-using the integration tests and

👉 All endpoints have been unit-tested through DB mocking

👉 A bunch of TODOs have been put in place for future reworks that are
needed (e.g. `Update()` method on repository should also return a
timestamp)

# Additional Changes

- A test utility method to allow mocking query options have been made.
This was necessary because `database.QueryOption` is a function and the
only comparison possible with functions is `nil` check. So, to mock
this, `database.QueryOption` is converted first to `database.QueryOpts`.
See 2276742adaef1998ea4844e1f0dca2079e45ccfb

- A `BaseCommand` has been created with the idea to collect methods that
are going to be needed by other commands. For the moment, it only offers
a method to convert query text operations from gRPC to `domain` model.
See bb85456dd101282fa76d2e2ad165eed4c8ef61b9

- SQL operations have been reworked to allow for queries using
`ContainsIgnoreCase`, `EndsWithIgnoreCase` and other `IgnoreCase`
operations. This change is pending approval and might be reworked. See
https://github.com/zitadel/zitadel/pull/10704#discussion_r2392886177

# Additional Context

`UpdateOrganization` is partially working because the logic for handling
domain updates is not done (there is only a draft of the commanders to
showcase the call chain). See
https://github.com/zitadel/zitadel/pull/10704#discussion_r2356143178

Permissions are not implemented as they are missing. See
https://github.com/zitadel/zitadel/pull/10771

- Closes: #10445

---------

Co-authored-by: Silvan <[email protected]>
This commit is contained in:
Marco A.
2025-10-21 15:27:38 +02:00
committed by GitHub
co-authored by Silvan
parent 88213d785a
commit f04d873270
67 changed files with 8592 additions and 769 deletions
+10 -1
View File
@@ -22,10 +22,19 @@ func WithMockFeatures(features feature.Features) MockContextInstanceOpts {
}
}
func WithMockProjectID(projectID string) MockContextInstanceOpts {
return func(i *instance) {
i.projectID = projectID
}
}
func NewMockContext(instanceID, orgID, userID string, opts ...MockContextInstanceOpts) context.Context {
ctx := context.WithValue(context.Background(), dataKey, CtxData{UserID: userID, OrgID: orgID})
i := &instance{id: instanceID}
i := &instance{
id: instanceID,
orgID: orgID,
}
for _, o := range opts {
o(i)
}
@@ -46,6 +46,13 @@ func createOrganizationWithCustomOrgID(ctx context.Context, name string, orgID s
}
}
// TODO(IAM-Marco): When permission checks will be implemented, this test needs to be updated to
// add the feature flag switch:
//
// relTableState := integration.RelationalTablesEnableMatrix()
//
// See TestServer_ListOrganizations in org/v2beta/integration_test
// See https://github.com/zitadel/zitadel/issues/10219
func TestServer_ListOrganizations(t *testing.T) {
type args struct {
ctx context.Context
+5
View File
@@ -5,6 +5,7 @@ import (
"connectrpc.com/connect"
orgv2 "github.com/zitadel/zitadel/backend/v3/api/org/v2"
"github.com/zitadel/zitadel/internal/api/authz"
"github.com/zitadel/zitadel/internal/api/grpc/object/v2"
"github.com/zitadel/zitadel/internal/domain"
@@ -14,6 +15,10 @@ import (
)
func (s *Server) ListOrganizations(ctx context.Context, req *connect.Request[org.ListOrganizationsRequest]) (*connect.Response[org.ListOrganizationsResponse], error) {
if authz.GetFeatures(ctx).EnableRelationalTables {
return orgv2.ListOrganizations(ctx, req)
}
queries, err := listOrgRequestToModel(ctx, req)
if err != nil {
return nil, err
@@ -5,6 +5,7 @@ package org_test
import (
"context"
"errors"
"fmt"
"os"
"slices"
"strings"
@@ -17,6 +18,7 @@ import (
"github.com/zitadel/zitadel/internal/integration"
"github.com/zitadel/zitadel/pkg/grpc/admin"
"github.com/zitadel/zitadel/pkg/grpc/feature/v2"
v2beta_object "github.com/zitadel/zitadel/pkg/grpc/object/v2beta"
v2beta_org "github.com/zitadel/zitadel/pkg/grpc/org/v2beta"
"github.com/zitadel/zitadel/pkg/grpc/user/v2"
@@ -294,84 +296,100 @@ func TestServer_CreateOrganization(t *testing.T) {
}
func TestServer_UpdateOrganization(t *testing.T) {
orgs, orgsName, _ := createOrgs(CTX, t, Client, 1)
orgId := orgs[0].Id
orgName := orgsName[0]
ctx := Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner)
tests := []struct {
name string
ctx context.Context
req *v2beta_org.UpdateOrganizationRequest
want *v2beta_org.UpdateOrganizationResponse
wantErr bool
}{
{
name: "update org with new name",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
req: &v2beta_org.UpdateOrganizationRequest{
Id: orgId,
Name: "new org name",
},
},
{
name: "update org with same name",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
req: &v2beta_org.UpdateOrganizationRequest{
Id: orgId,
Name: orgName,
},
},
{
name: "update org with non existent org id",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
req: &v2beta_org.UpdateOrganizationRequest{
Id: "non existant org id",
// Name: "",
},
wantErr: true,
},
{
name: "update org with no id",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
req: &v2beta_org.UpdateOrganizationRequest{
Id: "",
Name: orgName,
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := Client.UpdateOrganization(tt.ctx, tt.req)
if tt.wantErr {
require.Error(t, err)
return
}
require.NoError(t, err)
t.Cleanup(func() {
_, err := Instance.Client.FeatureV2.ResetInstanceFeatures(ctx, &feature.ResetInstanceFeaturesRequest{})
require.NoError(t, err)
})
// check details
gotCD := got.GetChangeDate().AsTime()
now := time.Now()
assert.WithinRange(t, gotCD, now.Add(-time.Minute), now.Add(time.Minute))
relTableState := integration.RelationalTablesEnableMatrix()
cases := len(relTableState)
orgs, orgNames, _ := createOrgs(CTX, t, Client, 2*cases)
for i, stateCase := range relTableState {
integration.EnsureInstanceFeature(t, ctx, Instance, stateCase.FeatureSet, func(tCollect *assert.CollectT, got *feature.GetInstanceFeaturesResponse) {
assert.Equal(tCollect, stateCase.FeatureSet.GetEnableRelationalTables(), got.EnableRelationalTables.GetEnabled())
})
tests := []struct {
name string
req *v2beta_org.UpdateOrganizationRequest
want *v2beta_org.UpdateOrganizationResponse
wantErr bool
}{
{
name: "update org with new name",
req: &v2beta_org.UpdateOrganizationRequest{
Id: orgs[0+(i*cases)].GetId(),
Name: fmt.Sprintf("new org name %d", i),
},
},
{
name: "update org with same name",
req: &v2beta_org.UpdateOrganizationRequest{
Id: orgs[1+(i*cases)].GetId(),
Name: orgNames[1+(i*cases)],
},
wantErr: true,
},
{
name: "update org with non existent org id",
req: &v2beta_org.UpdateOrganizationRequest{
Id: "non existent org id",
Name: "new name",
},
wantErr: true,
},
{
name: "update org with no id",
req: &v2beta_org.UpdateOrganizationRequest{
Id: " ",
Name: "new name",
},
wantErr: true,
},
}
for _, tt := range tests {
t.Run(fmt.Sprintf("%s - %s", stateCase.State, tt.name), func(t1 *testing.T) {
got, err := Client.UpdateOrganization(ctx, tt.req)
if tt.wantErr {
require.Error(t1, err)
return
}
require.NoError(t1, err)
// check details
gotCD := got.GetChangeDate().AsTime()
now := time.Now()
assert.WithinRange(t1, gotCD, now.Add(-time.Minute), now.Add(time.Minute))
})
}
}
}
func TestServer_ListOrganizations(t *testing.T) {
t.Cleanup(func() {
_, err := Instance.Client.FeatureV2.ResetInstanceFeatures(CTX, &feature.ResetInstanceFeaturesRequest{})
require.NoError(t, err)
})
testStartTimestamp := time.Now()
ListOrgIinstance := integration.NewInstance(CTX)
listOrgIAmOwnerCtx := ListOrgIinstance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner)
listOrgClient := ListOrgIinstance.Client.OrgV2beta
listOrgInstance := integration.NewInstance(CTX)
listOrgIAmOwnerCtx := listOrgInstance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner)
listOrgClient := listOrgInstance.Client.OrgV2beta
noOfOrgs := 3
orgs, orgsName, orgsDomain := createOrgs(listOrgIAmOwnerCtx, t, listOrgClient, noOfOrgs)
// deactivat org[1]
// deactivate org[1]
_, err := listOrgClient.DeactivateOrganization(listOrgIAmOwnerCtx, &v2beta_org.DeactivateOrganizationRequest{
Id: orgs[1].Id,
})
require.NoError(t, err)
relTableState := integration.RelationalTablesEnableMatrix()
tests := []struct {
name string
ctx context.Context
@@ -381,7 +399,7 @@ func TestServer_ListOrganizations(t *testing.T) {
}{
{
name: "list organizations, without required permissions",
ctx: ListOrgIinstance.WithAuthorizationToken(CTX, integration.UserTypeNoPermission),
ctx: listOrgInstance.WithAuthorizationToken(CTX, integration.UserTypeNoPermission),
err: errors.New("membership not found"),
},
{
@@ -609,122 +627,137 @@ func TestServer_ListOrganizations(t *testing.T) {
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
retryDuration, tick := integration.WaitForAndTickWithMaxDuration(CTX, 10*time.Minute)
require.EventuallyWithT(t, func(ttt *assert.CollectT) {
got, err := listOrgClient.ListOrganizations(tt.ctx, &v2beta_org.ListOrganizationsRequest{
Filter: tt.query,
})
if tt.err != nil {
require.ErrorContains(ttt, err, tt.err.Error())
return
}
require.NoError(ttt, err)
require.Equal(ttt, uint64(len(tt.want)), got.Pagination.GetTotalResult())
for _, stateCase := range relTableState {
integration.EnsureInstanceFeature(t, listOrgIAmOwnerCtx, listOrgInstance, stateCase.FeatureSet, func(tCollect *assert.CollectT, got *feature.GetInstanceFeaturesResponse) {
assert.Equal(tCollect, stateCase.FeatureSet.GetEnableRelationalTables(), got.EnableRelationalTables.GetEnabled())
})
foundOrgs := 0
for _, got := range got.Organizations {
for _, org := range tt.want {
for _, tt := range tests {
t.Run(fmt.Sprintf("%s - %s", stateCase.State, tt.name), func(t *testing.T) {
retryDuration, tick := integration.WaitForAndTickWithMaxDuration(CTX, 20*time.Second)
require.EventuallyWithT(t, func(ttt *assert.CollectT) {
got, err := listOrgClient.ListOrganizations(tt.ctx, &v2beta_org.ListOrganizationsRequest{
Filter: tt.query,
})
if tt.err != nil {
require.ErrorContains(ttt, err, tt.err.Error())
return
}
require.NoError(ttt, err)
// created/chagned date
gotCD := got.GetCreationDate().AsTime()
now := time.Now()
assert.WithinRange(ttt, gotCD, testStartTimestamp, now.Add(time.Minute))
gotCD = got.GetChangedDate().AsTime()
assert.WithinRange(ttt, gotCD, testStartTimestamp, now.Add(time.Minute))
require.Equal(ttt, uint64(len(tt.want)), got.Pagination.GetTotalResult())
// default org
if org.Name == got.Name && got.Name == "testinstance" {
foundOrgs += 1
continue
}
foundOrgs := 0
for _, got := range got.Organizations {
for _, org := range tt.want {
if org.Name == got.Name &&
org.Id == got.Id {
foundOrgs += 1
// created/chagned date
gotCD := got.GetCreationDate().AsTime()
now := time.Now()
assert.WithinRange(ttt, gotCD, testStartTimestamp, now.Add(time.Minute))
gotCD = got.GetChangedDate().AsTime()
assert.WithinRange(ttt, gotCD, testStartTimestamp, now.Add(time.Minute))
// default org
if org.Name == got.Name && got.Name == "testinstance" {
foundOrgs += 1
continue
}
if org.Name == got.Name &&
org.Id == got.Id {
foundOrgs += 1
}
}
}
}
require.Equal(ttt, len(tt.want), foundOrgs)
}, retryDuration, tick, "timeout waiting for expected organizations being created")
})
require.Equal(ttt, len(tt.want), foundOrgs)
}, retryDuration, tick, "timeout waiting for expected organizations being created")
})
}
}
}
func TestServer_DeleteOrganization(t *testing.T) {
tests := []struct {
name string
ctx context.Context
createOrgFunc func() string
req *v2beta_org.DeleteOrganizationRequest
want *v2beta_org.DeleteOrganizationResponse
dontCheckTime bool
err error
}{
{
name: "delete org no permission",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeNoPermission),
createOrgFunc: func() string {
orgs, _, _ := createOrgs(CTX, t, Client, 1)
return orgs[0].Id
t.Cleanup(func() {
_, err := Instance.Client.FeatureV2.ResetInstanceFeatures(CTX, &feature.ResetInstanceFeaturesRequest{})
require.NoError(t, err)
})
relTableState := integration.RelationalTablesEnableMatrix()
var orgs []*v2beta_org.CreateOrganizationResponse
orgsNumPerCase := 3
orgs, _, _ = createOrgs(CTX, t, Client, orgsNumPerCase*len(relTableState))
require.NotNil(t, orgs)
require.NotEmpty(t, orgs)
for i, stateCase := range relTableState {
retryDuration, tick := integration.WaitForAndTickWithMaxDuration(CTX, time.Minute)
require.EventuallyWithT(t, func(ttt *assert.CollectT) {
deleteRes, err := Client.DeleteOrganization(CTX, &v2beta_org.DeleteOrganizationRequest{Id: orgs[2+(orgsNumPerCase*i)].GetId()})
assert.Nil(ttt, err)
assert.NotNil(ttt, deleteRes)
assert.NotZero(ttt, deleteRes.GetDeletionDate())
}, retryDuration, tick)
tests := []struct {
name string
ctx context.Context
req *v2beta_org.DeleteOrganizationRequest
want *v2beta_org.DeleteOrganizationResponse
dontCheckTime bool
err error
}{
{
name: "delete org no permission",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeNoPermission),
req: &v2beta_org.DeleteOrganizationRequest{
Id: orgs[0+(orgsNumPerCase*i)].GetId(),
},
err: errors.New("membership not found"),
},
req: &v2beta_org.DeleteOrganizationRequest{},
err: errors.New("membership not found"),
},
{
name: "delete org happy path",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
createOrgFunc: func() string {
orgs, _, _ := createOrgs(CTX, t, Client, 1)
return orgs[0].Id
{
name: "delete org happy path",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
req: &v2beta_org.DeleteOrganizationRequest{
Id: orgs[1+(orgsNumPerCase*i)].GetId(),
},
},
req: &v2beta_org.DeleteOrganizationRequest{},
},
{
name: "delete already deleted org",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
createOrgFunc: func() string {
orgs, _, _ := createOrgs(CTX, t, Client, 1)
// delete org
_, err := Client.DeleteOrganization(CTX, &v2beta_org.DeleteOrganizationRequest{Id: orgs[0].Id})
{
name: "delete already deleted org",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
req: &v2beta_org.DeleteOrganizationRequest{Id: orgs[2+(orgsNumPerCase*i)].GetId()},
dontCheckTime: true,
},
{
name: "delete non existent org",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
req: &v2beta_org.DeleteOrganizationRequest{
Id: "non existent org id",
},
dontCheckTime: true,
},
}
integration.EnsureInstanceFeature(t, CTX, Instance, stateCase.FeatureSet, func(tCollect *assert.CollectT, got *feature.GetInstanceFeaturesResponse) {
assert.Equal(tCollect, stateCase.FeatureSet.GetEnableRelationalTables(), got.EnableRelationalTables.GetEnabled())
})
for _, tt := range tests {
t.Run(fmt.Sprintf("%s - %s", stateCase.State, tt.name), func(t *testing.T) {
got, err := Client.DeleteOrganization(tt.ctx, tt.req)
if tt.err != nil {
require.Contains(t, err.Error(), tt.err.Error())
return
}
require.NoError(t, err)
return orgs[0].Id
},
req: &v2beta_org.DeleteOrganizationRequest{},
dontCheckTime: true,
},
{
name: "delete non existent org",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeIAMOwner),
req: &v2beta_org.DeleteOrganizationRequest{
Id: "non existent org id",
},
dontCheckTime: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if tt.createOrgFunc != nil {
tt.req.Id = tt.createOrgFunc()
}
got, err := Client.DeleteOrganization(tt.ctx, tt.req)
if tt.err != nil {
require.Contains(t, err.Error(), tt.err.Error())
return
}
require.NoError(t, err)
// check details
gotCD := got.GetDeletionDate().AsTime()
if !tt.dontCheckTime {
now := time.Now()
assert.WithinRange(t, gotCD, now.Add(-time.Minute), now.Add(time.Minute))
}
})
// check details
gotCD := got.GetDeletionDate().AsTime()
if !tt.dontCheckTime {
now := time.Now()
assert.WithinRange(t, gotCD, now.Add(-time.Minute), now.Add(time.Minute))
}
})
}
}
}
@@ -745,192 +778,167 @@ func TestServer_DeactivateReactivateNonExistentOrganization(t *testing.T) {
}
func TestServer_ActivateOrganization(t *testing.T) {
tests := []struct {
name string
ctx context.Context
testFunc func() string
err error
}{
{
name: "Activate, happy path",
ctx: CTX,
testFunc: func() string {
// 1. create organization
orgs, _, _ := createOrgs(CTX, t, Client, 1)
orgId := orgs[0].Id
t.Cleanup(func() {
_, err := Instance.Client.FeatureV2.ResetInstanceFeatures(CTX, &feature.ResetInstanceFeaturesRequest{})
require.NoError(t, err)
})
relTableState := integration.RelationalTablesEnableMatrix()
// 2. deactivate organization once
deactivate_res, err := Client.DeactivateOrganization(CTX, &v2beta_org.DeactivateOrganizationRequest{
Id: orgId,
})
require.NoError(t, err)
gotCD := deactivate_res.GetChangeDate().AsTime()
now := time.Now()
assert.WithinRange(t, gotCD, now.Add(-time.Minute), now.Add(time.Minute))
orgsNumPerCase := 2
orgs, _, _ := createOrgs(CTX, t, Client, orgsNumPerCase*len(relTableState))
require.NotNil(t, orgs)
require.NotEmpty(t, orgs)
// 3. check organization state is deactivated
retryDuration, tick := integration.WaitForAndTickWithMaxDuration(CTX, 10*time.Minute)
require.EventuallyWithT(t, func(ttt *assert.CollectT) {
listOrgRes, err := Client.ListOrganizations(CTX, &v2beta_org.ListOrganizationsRequest{
Filter: []*v2beta_org.OrganizationSearchFilter{
{
Filter: &v2beta_org.OrganizationSearchFilter_IdFilter{
IdFilter: &v2beta_org.OrgIDFilter{
Id: orgId,
},
},
},
},
})
require.NoError(ttt, err)
if assert.GreaterOrEqual(ttt, len(listOrgRes.Organizations), 1) {
require.Equal(ttt, v2beta_org.OrgState_ORG_STATE_INACTIVE, listOrgRes.Organizations[0].State)
}
}, retryDuration, tick, "timeout waiting for expected organizations being created")
return orgId
},
},
{
name: "Activate, no permission",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeNoPermission),
testFunc: func() string {
orgs, _, _ := createOrgs(CTX, t, Client, 1)
orgId := orgs[0].Id
return orgId
},
// BUG: this needs changing
err: errors.New("membership not found"),
},
{
name: "Activate, not existing",
ctx: CTX,
testFunc: func() string {
return "non-existing-org-id"
},
err: errors.New("Organisation not found"),
},
{
name: "Activate, already activated",
ctx: CTX,
testFunc: func() string {
orgs, _, _ := createOrgs(CTX, t, Client, 1)
orgId := orgs[0].Id
return orgId
},
err: errors.New("Organisation is already active"),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var orgId string
if tt.testFunc != nil {
orgId = tt.testFunc()
}
_, err := Client.ActivateOrganization(tt.ctx, &v2beta_org.ActivateOrganizationRequest{
Id: orgId,
})
if tt.err != nil {
require.Contains(t, err.Error(), tt.err.Error())
} else {
require.NoError(t, err)
}
for i, stateCase := range relTableState {
deactivatedOrgID := orgs[1+(orgsNumPerCase*i)].GetId()
deactivateRes, err := Client.DeactivateOrganization(CTX, &v2beta_org.DeactivateOrganizationRequest{
Id: deactivatedOrgID,
})
require.NoError(t, err)
now := time.Now()
assert.WithinRange(t, deactivateRes.GetChangeDate().AsTime(), now.Add(-time.Minute), now.Add(time.Minute))
retryDuration, tick := integration.WaitForAndTickWithMaxDuration(CTX, 20*time.Second)
require.EventuallyWithT(t, func(ttt *assert.CollectT) {
listOrgRes, err := Client.ListOrganizations(CTX, &v2beta_org.ListOrganizationsRequest{
Filter: []*v2beta_org.OrganizationSearchFilter{
{Filter: &v2beta_org.OrganizationSearchFilter_IdFilter{IdFilter: &v2beta_org.OrgIDFilter{Id: deactivatedOrgID}}},
},
})
assert.NoError(ttt, err)
assert.Equal(ttt, v2beta_org.OrgState_ORG_STATE_INACTIVE, listOrgRes.Organizations[0].State)
}, retryDuration, tick, "timeout waiting for expected organizations being created")
tt := []struct {
name string
ctx context.Context
inputOrgID string
err error
}{
{
name: "Activate, happy path",
ctx: CTX,
inputOrgID: deactivatedOrgID,
},
{
name: "Activate, no permission",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeNoPermission),
inputOrgID: orgs[0+(orgsNumPerCase*i)].GetId(),
// BUG: this needs changing
err: errors.New("membership not found"),
},
{
name: "Activate, not existing",
ctx: CTX,
inputOrgID: "non-existing-org-id",
err: errors.New("Organisation not found"),
},
{
name: "Activate, already activated",
ctx: CTX,
inputOrgID: orgs[0+(orgsNumPerCase*i)].GetId(),
err: errors.New("Organisation is already active"),
},
}
integration.EnsureInstanceFeature(t, CTX, Instance, stateCase.FeatureSet, func(tCollect *assert.CollectT, got *feature.GetInstanceFeaturesResponse) {
assert.Equal(tCollect, stateCase.FeatureSet.GetEnableRelationalTables(), got.EnableRelationalTables.GetEnabled())
})
for _, tc := range tt {
t.Run(fmt.Sprintf("%s - %s", stateCase.State, tc.name), func(t *testing.T) {
_, err := Client.ActivateOrganization(tc.ctx, &v2beta_org.ActivateOrganizationRequest{
Id: tc.inputOrgID,
})
if tc.err != nil {
require.Contains(t, err.Error(), tc.err.Error())
} else {
require.NoError(t, err)
}
})
}
}
}
func TestServer_DeactivateOrganization(t *testing.T) {
tests := []struct {
name string
ctx context.Context
testFunc func() string
err error
}{
{
name: "Deactivate, happy path",
ctx: CTX,
testFunc: func() string {
// 1. create organization
orgs, _, _ := createOrgs(CTX, t, Client, 1)
orgId := orgs[0].Id
t.Cleanup(func() {
_, err := Instance.Client.FeatureV2.ResetInstanceFeatures(CTX, &feature.ResetInstanceFeaturesRequest{})
require.NoError(t, err)
})
relTableState := integration.RelationalTablesEnableMatrix()
return orgId
},
},
{
name: "Deactivate, no permission",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeNoPermission),
testFunc: func() string {
orgs, _, _ := createOrgs(CTX, t, Client, 1)
orgId := orgs[0].Id
return orgId
},
// BUG: this needs changing
err: errors.New("membership not found"),
},
{
name: "Deactivate, not existing",
ctx: CTX,
testFunc: func() string {
return "non-existing-org-id"
},
err: errors.New("Organisation not found"),
},
{
name: "Deactivate, already deactivated",
ctx: CTX,
testFunc: func() string {
// 1. create organization
orgs, _, _ := createOrgs(CTX, t, Client, 1)
orgId := orgs[0].Id
orgsNumPerCase := 2
orgs, _, _ := createOrgs(CTX, t, Client, orgsNumPerCase*len(relTableState))
require.NotNil(t, orgs)
require.NotEmpty(t, orgs)
// 2. deactivate organization once
deactivate_res, err := Client.DeactivateOrganization(CTX, &v2beta_org.DeactivateOrganizationRequest{
Id: orgId,
})
require.NoError(t, err)
gotCD := deactivate_res.GetChangeDate().AsTime()
now := time.Now()
assert.WithinRange(t, gotCD, now.Add(-time.Minute), now.Add(time.Minute))
// 3. check organization state is deactivated
retryDuration, tick := integration.WaitForAndTickWithMaxDuration(CTX, 10*time.Minute)
require.EventuallyWithT(t, func(ttt *assert.CollectT) {
listOrgRes, err := Client.ListOrganizations(CTX, &v2beta_org.ListOrganizationsRequest{
Filter: []*v2beta_org.OrganizationSearchFilter{
{
Filter: &v2beta_org.OrganizationSearchFilter_IdFilter{
IdFilter: &v2beta_org.OrgIDFilter{
Id: orgId,
},
},
},
},
})
require.NoError(ttt, err)
require.Equal(ttt, v2beta_org.OrgState_ORG_STATE_INACTIVE, listOrgRes.Organizations[0].State)
}, retryDuration, tick, "timeout waiting for expected organizations being created")
return orgId
},
err: errors.New("Organisation is already deactivated"),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
var orgId string
orgId = tt.testFunc()
_, err := Client.DeactivateOrganization(tt.ctx, &v2beta_org.DeactivateOrganizationRequest{
Id: orgId,
})
if tt.err != nil {
require.Contains(t, err.Error(), tt.err.Error())
} else {
require.NoError(t, err)
}
for i, stateCase := range relTableState {
deactivatedOrgID := orgs[1+(orgsNumPerCase*i)].GetId()
deactivateRes, err := Client.DeactivateOrganization(CTX, &v2beta_org.DeactivateOrganizationRequest{
Id: deactivatedOrgID,
})
require.NoError(t, err)
now := time.Now()
assert.WithinRange(t, deactivateRes.GetChangeDate().AsTime(), now.Add(-time.Minute), now.Add(time.Minute))
retryDuration, tick := integration.WaitForAndTickWithMaxDuration(CTX, 20*time.Second)
require.EventuallyWithT(t, func(ttt *assert.CollectT) {
listOrgRes, err := Client.ListOrganizations(CTX, &v2beta_org.ListOrganizationsRequest{
Filter: []*v2beta_org.OrganizationSearchFilter{
{Filter: &v2beta_org.OrganizationSearchFilter_IdFilter{IdFilter: &v2beta_org.OrgIDFilter{Id: deactivatedOrgID}}},
},
})
assert.NoError(ttt, err)
assert.Equal(ttt, v2beta_org.OrgState_ORG_STATE_INACTIVE, listOrgRes.Organizations[0].State)
}, retryDuration, tick, "timeout waiting for expected organizations being created")
tt := []struct {
name string
ctx context.Context
inputOrgID string
err error
}{
{
name: "Deactivate, happy path",
ctx: CTX,
inputOrgID: orgs[0+(orgsNumPerCase*i)].GetId(),
},
{
name: "Deactivate, no permission",
ctx: Instance.WithAuthorizationToken(CTX, integration.UserTypeNoPermission),
inputOrgID: orgs[0+(orgsNumPerCase*i)].GetId(),
// BUG: this needs changing
err: errors.New("membership not found"),
},
{
name: "Deactivate, not existing",
ctx: CTX,
inputOrgID: "non-existing-org-id",
err: errors.New("Organisation not found"),
},
{
name: "Deactivate, already deactivated",
ctx: CTX,
inputOrgID: deactivatedOrgID,
err: errors.New("Organisation is already deactivated"),
},
}
integration.EnsureInstanceFeature(t, CTX, Instance, stateCase.FeatureSet, func(tCollect *assert.CollectT, got *feature.GetInstanceFeaturesResponse) {
assert.Equal(tCollect, stateCase.FeatureSet.GetEnableRelationalTables(), got.EnableRelationalTables.GetEnabled())
})
for _, tc := range tt {
t.Run(fmt.Sprintf("%s - %s", stateCase.State, tc.name), func(t *testing.T) {
_, err := Client.DeactivateOrganization(tc.ctx, &v2beta_org.DeactivateOrganizationRequest{
Id: tc.inputOrgID,
})
if tc.err != nil {
require.Contains(t, err.Error(), tc.err.Error())
} else {
require.NoError(t, err)
}
})
}
}
}
+22
View File
@@ -7,6 +7,8 @@ import (
"connectrpc.com/connect"
"google.golang.org/protobuf/types/known/timestamppb"
orgv2 "github.com/zitadel/zitadel/backend/v3/api/org/v2"
"github.com/zitadel/zitadel/internal/api/authz"
metadata "github.com/zitadel/zitadel/internal/api/grpc/metadata/v2beta"
object "github.com/zitadel/zitadel/internal/api/grpc/object/v2beta"
user "github.com/zitadel/zitadel/internal/api/grpc/user/v2beta"
@@ -31,6 +33,10 @@ func (s *Server) CreateOrganization(ctx context.Context, request *connect.Reques
}
func (s *Server) UpdateOrganization(ctx context.Context, request *connect.Request[v2beta_org.UpdateOrganizationRequest]) (*connect.Response[v2beta_org.UpdateOrganizationResponse], error) {
if authz.GetFeatures(ctx).EnableRelationalTables {
return orgv2.UpdateOrganization(ctx, request)
}
org, err := s.command.ChangeOrg(ctx, request.Msg.GetId(), request.Msg.GetName())
if err != nil {
return nil, err
@@ -42,6 +48,10 @@ func (s *Server) UpdateOrganization(ctx context.Context, request *connect.Reques
}
func (s *Server) ListOrganizations(ctx context.Context, request *connect.Request[v2beta_org.ListOrganizationsRequest]) (*connect.Response[v2beta_org.ListOrganizationsResponse], error) {
if authz.GetFeatures(ctx).EnableRelationalTables {
return orgv2.ListOrganizationsBeta(ctx, request)
}
queries, err := listOrgRequestToModel(s.systemDefaults, request.Msg)
if err != nil {
return nil, err
@@ -60,6 +70,10 @@ func (s *Server) ListOrganizations(ctx context.Context, request *connect.Request
}
func (s *Server) DeleteOrganization(ctx context.Context, request *connect.Request[v2beta_org.DeleteOrganizationRequest]) (*connect.Response[v2beta_org.DeleteOrganizationResponse], error) {
if authz.GetFeatures(ctx).EnableRelationalTables {
return orgv2.DeleteOrganization(ctx, request)
}
details, err := s.command.RemoveOrg(ctx, request.Msg.GetId())
if err != nil {
var notFoundError *zerrors.NotFoundError
@@ -112,6 +126,10 @@ func (s *Server) DeleteOrganizationMetadata(ctx context.Context, request *connec
}
func (s *Server) DeactivateOrganization(ctx context.Context, request *connect.Request[org.DeactivateOrganizationRequest]) (*connect.Response[org.DeactivateOrganizationResponse], error) {
if authz.GetFeatures(ctx).EnableRelationalTables {
return orgv2.DeactivateOrganization(ctx, request)
}
objectDetails, err := s.command.DeactivateOrg(ctx, request.Msg.GetId())
if err != nil {
return nil, err
@@ -122,6 +140,10 @@ func (s *Server) DeactivateOrganization(ctx context.Context, request *connect.Re
}
func (s *Server) ActivateOrganization(ctx context.Context, request *connect.Request[org.ActivateOrganizationRequest]) (*connect.Response[org.ActivateOrganizationResponse], error) {
if authz.GetFeatures(ctx).EnableRelationalTables {
return orgv2.ActivateOrganization(ctx, request)
}
objectDetails, err := s.command.ReactivateOrg(ctx, request.Msg.GetId())
if err != nil {
return nil, err