mirror of
https://github.com/zitadel/zitadel.git
synced 2025-12-23 16:46:46 +00:00
35ad7fd9b8
# Which Problems Are Solved
As part of our efforts to simplify the structure and versions of our
APIs, were moving all existing v2beta endpoints to v2 and deprecate
them. They will be removed in Zitadel V5.
# How the Problems Are Solved
- This PR moves instance v2beta service and its endpoints to a
corresponding v2 version. The v2beta service and endpoints are
deprecated.
- The docs are moved to the new GA service and its endpoints. The v2beta
is not displayed anymore.
- The comments and have been improved and, where not already done, moved
from swagger annotations to proto.
- All required fields have been marked with (google.api.field_behavior)
= REQUIRED and validation rules have been added where missing
- `Domain` has been renamed to `CustomDomain` to align with naming
conventions
- `..Query` has been renamed to `..Filter` to align with other services
- The `instance_id` parameter can now passed on all endpoints and is
properly used, but requires `system` permissions. It can be omitted to
use the own instance (identified by context as any other service).
- The following endpoints are affected:
- GetInstance
- UpdateInstance
- ListCustomDomains
- AddTrustedDomain
- RemoveTrustedDomain
- ListTrustedDomains
- InstanceService has been added the InstanceInterceptor's
`explicitInstanceIdServices` to allow passing the id
- If the instance is not found by id, the error is not directly returned
to prevent enumeration.
- Permissions are checked in the API instead of the interceptor for
these calls.
- Setting the same instance name in the update no longer returns an
error, but the previous change date.
# Additional Changes
none
# Additional Context
- part of https://github.com/zitadel/zitadel/issues/10772
- requires backport to v4.x
(cherry picked from commit c2a0b9d187)
392 lines
11 KiB
Go
392 lines
11 KiB
Go
package instance
|
|
|
|
import (
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/protobuf/types/known/timestamppb"
|
|
|
|
"github.com/zitadel/zitadel/cmd/build"
|
|
"github.com/zitadel/zitadel/internal/config/systemdefaults"
|
|
"github.com/zitadel/zitadel/internal/query"
|
|
"github.com/zitadel/zitadel/internal/zerrors"
|
|
"github.com/zitadel/zitadel/pkg/grpc/filter/v2"
|
|
"github.com/zitadel/zitadel/pkg/grpc/instance/v2"
|
|
"github.com/zitadel/zitadel/pkg/grpc/object/v2"
|
|
)
|
|
|
|
func Test_InstancesToPb(t *testing.T) {
|
|
instances := []*query.Instance{
|
|
{
|
|
ID: "instance1",
|
|
Name: "Instance One",
|
|
Domains: []*query.InstanceDomain{
|
|
{
|
|
Domain: "example.com",
|
|
IsPrimary: true,
|
|
IsGenerated: false,
|
|
Sequence: 1,
|
|
CreationDate: time.Unix(123, 0),
|
|
ChangeDate: time.Unix(124, 0),
|
|
InstanceID: "instance1",
|
|
},
|
|
},
|
|
Sequence: 1,
|
|
CreationDate: time.Unix(123, 0),
|
|
ChangeDate: time.Unix(124, 0),
|
|
},
|
|
}
|
|
|
|
want := []*instance.Instance{
|
|
{
|
|
Id: "instance1",
|
|
Name: "Instance One",
|
|
CustomDomains: []*instance.CustomDomain{
|
|
{
|
|
Domain: "example.com",
|
|
Primary: true,
|
|
Generated: false,
|
|
InstanceId: "instance1",
|
|
CreationDate: ×tamppb.Timestamp{Seconds: 123},
|
|
},
|
|
},
|
|
Version: build.Version(),
|
|
ChangeDate: ×tamppb.Timestamp{Seconds: 124},
|
|
CreationDate: ×tamppb.Timestamp{Seconds: 123},
|
|
},
|
|
}
|
|
|
|
got := InstancesToPb(instances)
|
|
assert.Equal(t, want, got)
|
|
}
|
|
|
|
func Test_ListInstancesRequestToModel(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
searchInstanceByID, err := query.NewInstanceIDsListSearchQuery("instance1", "instance2")
|
|
require.Nil(t, err)
|
|
|
|
tt := []struct {
|
|
testName string
|
|
inputRequest *instance.ListInstancesRequest
|
|
maxQueryLimit uint64
|
|
expectedResult *query.InstanceSearchQueries
|
|
expectedError error
|
|
}{
|
|
{
|
|
testName: "when query limit exceeds max query limit should return invalid argument error",
|
|
maxQueryLimit: 1,
|
|
inputRequest: &instance.ListInstancesRequest{
|
|
Pagination: &filter.PaginationRequest{Limit: 10, Offset: 0, Asc: true},
|
|
SortingColumn: instance.FieldName_FIELD_NAME_ID,
|
|
Filters: []*instance.Filter{{Filter: &instance.Filter_InIdsFilter{InIdsFilter: &filter.InIDsFilter{Ids: []string{"instance1", "instance2"}}}}},
|
|
},
|
|
expectedError: zerrors.ThrowInvalidArgumentf(errors.New("given: 10, allowed: 1"), "QUERY-4M0fs", "Errors.Query.LimitExceeded"),
|
|
},
|
|
{
|
|
testName: "when valid request should return instance search query model",
|
|
inputRequest: &instance.ListInstancesRequest{
|
|
Pagination: &filter.PaginationRequest{Limit: 10, Offset: 0, Asc: true},
|
|
SortingColumn: instance.FieldName_FIELD_NAME_ID,
|
|
Filters: []*instance.Filter{{Filter: &instance.Filter_InIdsFilter{InIdsFilter: &filter.InIDsFilter{Ids: []string{"instance1", "instance2"}}}}},
|
|
},
|
|
expectedResult: &query.InstanceSearchQueries{
|
|
SearchRequest: query.SearchRequest{
|
|
Offset: 0,
|
|
Limit: 10,
|
|
Asc: true,
|
|
SortingColumn: query.InstanceColumnID,
|
|
},
|
|
Queries: []query.SearchQuery{searchInstanceByID},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tt {
|
|
t.Run(tc.testName, func(t *testing.T) {
|
|
t.Parallel()
|
|
sysDefaults := systemdefaults.SystemDefaults{MaxQueryLimit: tc.maxQueryLimit}
|
|
|
|
got, err := ListInstancesRequestToModel(tc.inputRequest, sysDefaults)
|
|
assert.Equal(t, tc.expectedError, err)
|
|
assert.Equal(t, tc.expectedResult, got)
|
|
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_fieldNameToInstanceColumn(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
fieldName instance.FieldName
|
|
want query.Column
|
|
}{
|
|
{
|
|
name: "ID field",
|
|
fieldName: instance.FieldName_FIELD_NAME_ID,
|
|
want: query.InstanceColumnID,
|
|
},
|
|
{
|
|
name: "Name field",
|
|
fieldName: instance.FieldName_FIELD_NAME_NAME,
|
|
want: query.InstanceColumnName,
|
|
},
|
|
{
|
|
name: "Creation Date field",
|
|
fieldName: instance.FieldName_FIELD_NAME_CREATION_DATE,
|
|
want: query.InstanceColumnCreationDate,
|
|
},
|
|
{
|
|
name: "Unknown field",
|
|
fieldName: instance.FieldName(99),
|
|
want: query.Column{},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
got := fieldNameToInstanceColumn(tt.fieldName)
|
|
assert.Equal(t, tt.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_instanceQueryToModel(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
searchInstanceByID, err := query.NewInstanceIDsListSearchQuery("instance1")
|
|
require.Nil(t, err)
|
|
|
|
searchInstanceByDomain, err := query.NewInstanceDomainsListSearchQuery("example.com")
|
|
require.Nil(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
searchQuery *instance.Filter
|
|
want query.SearchQuery
|
|
wantErr bool
|
|
}{
|
|
{
|
|
name: "ID Query",
|
|
searchQuery: &instance.Filter{
|
|
Filter: &instance.Filter_InIdsFilter{
|
|
InIdsFilter: &filter.InIDsFilter{
|
|
Ids: []string{"instance1"},
|
|
},
|
|
},
|
|
},
|
|
want: searchInstanceByID,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "Domain Query",
|
|
searchQuery: &instance.Filter{
|
|
Filter: &instance.Filter_CustomDomainsFilter{
|
|
CustomDomainsFilter: &instance.CustomDomainsFilter{
|
|
Domains: []string{"example.com"},
|
|
},
|
|
},
|
|
},
|
|
want: searchInstanceByDomain,
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "Invalid Query",
|
|
searchQuery: &instance.Filter{
|
|
Filter: nil,
|
|
},
|
|
want: nil,
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := instanceFilterToQuery(tt.searchQuery)
|
|
if tt.wantErr {
|
|
assert.Error(t, err)
|
|
} else {
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, tt.want, got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_ListCustomDomainsRequestToModel(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
querySearchRes, err := query.NewInstanceDomainDomainSearchQuery(query.TextEquals, "example.com")
|
|
require.Nil(t, err)
|
|
|
|
queryGeneratedRes, err := query.NewInstanceDomainGeneratedSearchQuery(false)
|
|
require.Nil(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
inputRequest *instance.ListCustomDomainsRequest
|
|
maxQueryLimit uint64
|
|
expectedResult *query.InstanceDomainSearchQueries
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "when query limit exceeds max query limit should return invalid argument error",
|
|
inputRequest: &instance.ListCustomDomainsRequest{
|
|
Pagination: &filter.PaginationRequest{Limit: 10, Offset: 0, Asc: true},
|
|
SortingColumn: instance.DomainFieldName_DOMAIN_FIELD_NAME_DOMAIN,
|
|
Filters: []*instance.CustomDomainFilter{
|
|
{
|
|
Filter: &instance.CustomDomainFilter_DomainFilter{
|
|
DomainFilter: &instance.DomainFilter{
|
|
Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS,
|
|
Domain: "example.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
maxQueryLimit: 1,
|
|
expectedError: zerrors.ThrowInvalidArgumentf(errors.New("given: 10, allowed: 1"), "QUERY-4M0fs", "Errors.Query.LimitExceeded"),
|
|
},
|
|
{
|
|
name: "when valid request should return domain search query model",
|
|
inputRequest: &instance.ListCustomDomainsRequest{
|
|
Pagination: &filter.PaginationRequest{Limit: 10, Offset: 0, Asc: true},
|
|
SortingColumn: instance.DomainFieldName_DOMAIN_FIELD_NAME_PRIMARY,
|
|
Filters: []*instance.CustomDomainFilter{
|
|
{
|
|
Filter: &instance.CustomDomainFilter_DomainFilter{
|
|
DomainFilter: &instance.DomainFilter{Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS, Domain: "example.com"}},
|
|
},
|
|
{
|
|
Filter: &instance.CustomDomainFilter_GeneratedFilter{
|
|
GeneratedFilter: false,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
maxQueryLimit: 100,
|
|
expectedResult: &query.InstanceDomainSearchQueries{
|
|
SearchRequest: query.SearchRequest{Offset: 0, Limit: 10, Asc: true, SortingColumn: query.InstanceDomainIsPrimaryCol},
|
|
Queries: []query.SearchQuery{
|
|
querySearchRes,
|
|
queryGeneratedRes,
|
|
},
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "when invalid query should return error",
|
|
inputRequest: &instance.ListCustomDomainsRequest{
|
|
Pagination: &filter.PaginationRequest{Limit: 10, Offset: 0, Asc: true},
|
|
SortingColumn: instance.DomainFieldName_DOMAIN_FIELD_NAME_GENERATED,
|
|
Filters: []*instance.CustomDomainFilter{
|
|
{
|
|
Filter: nil,
|
|
},
|
|
},
|
|
},
|
|
maxQueryLimit: 100,
|
|
expectedResult: nil,
|
|
expectedError: zerrors.ThrowInvalidArgument(nil, "INST-Ags42", "List.Query.Invalid"),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
sysDefaults := systemdefaults.SystemDefaults{MaxQueryLimit: tt.maxQueryLimit}
|
|
|
|
got, err := ListCustomDomainsRequestToModel(tt.inputRequest, sysDefaults)
|
|
assert.Equal(t, tt.expectedError, err)
|
|
assert.Equal(t, tt.expectedResult, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_ListTrustedDomainsRequestToModel(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
querySearchRes, err := query.NewInstanceTrustedDomainDomainSearchQuery(query.TextEquals, "example.com")
|
|
require.Nil(t, err)
|
|
|
|
tests := []struct {
|
|
name string
|
|
inputRequest *instance.ListTrustedDomainsRequest
|
|
maxQueryLimit uint64
|
|
expectedResult *query.InstanceTrustedDomainSearchQueries
|
|
expectedError error
|
|
}{
|
|
{
|
|
name: "when query limit exceeds max query limit should return invalid argument error",
|
|
inputRequest: &instance.ListTrustedDomainsRequest{
|
|
Pagination: &filter.PaginationRequest{Limit: 10, Offset: 0, Asc: true},
|
|
SortingColumn: instance.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_DOMAIN,
|
|
Filters: []*instance.TrustedDomainFilter{
|
|
{
|
|
Filter: &instance.TrustedDomainFilter_DomainFilter{
|
|
DomainFilter: &instance.DomainFilter{
|
|
Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS,
|
|
Domain: "example.com",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
maxQueryLimit: 1,
|
|
expectedError: zerrors.ThrowInvalidArgumentf(errors.New("given: 10, allowed: 1"), "QUERY-4M0fs", "Errors.Query.LimitExceeded"),
|
|
},
|
|
{
|
|
name: "when valid request should return domain search query model",
|
|
inputRequest: &instance.ListTrustedDomainsRequest{
|
|
Pagination: &filter.PaginationRequest{Limit: 10, Offset: 0, Asc: true},
|
|
SortingColumn: instance.TrustedDomainFieldName_TRUSTED_DOMAIN_FIELD_NAME_CREATION_DATE,
|
|
Filters: []*instance.TrustedDomainFilter{
|
|
{
|
|
Filter: &instance.TrustedDomainFilter_DomainFilter{
|
|
DomainFilter: &instance.DomainFilter{Method: object.TextQueryMethod_TEXT_QUERY_METHOD_EQUALS, Domain: "example.com"}},
|
|
},
|
|
},
|
|
},
|
|
maxQueryLimit: 100,
|
|
expectedResult: &query.InstanceTrustedDomainSearchQueries{
|
|
SearchRequest: query.SearchRequest{Offset: 0, Limit: 10, Asc: true, SortingColumn: query.InstanceTrustedDomainCreationDateCol},
|
|
Queries: []query.SearchQuery{querySearchRes},
|
|
},
|
|
expectedError: nil,
|
|
},
|
|
{
|
|
name: "when invalid query should return error",
|
|
inputRequest: &instance.ListTrustedDomainsRequest{
|
|
Pagination: &filter.PaginationRequest{Limit: 10, Offset: 0, Asc: true},
|
|
Filters: []*instance.TrustedDomainFilter{
|
|
{
|
|
Filter: nil,
|
|
},
|
|
},
|
|
},
|
|
maxQueryLimit: 100,
|
|
expectedResult: nil,
|
|
expectedError: zerrors.ThrowInvalidArgument(nil, "INST-Ags42", "List.Query.Invalid"),
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
sysDefaults := systemdefaults.SystemDefaults{MaxQueryLimit: tt.maxQueryLimit}
|
|
|
|
got, err := ListTrustedDomainsRequestToModel(tt.inputRequest, sysDefaults)
|
|
assert.Equal(t, tt.expectedError, err)
|
|
assert.Equal(t, tt.expectedResult, got)
|
|
})
|
|
}
|
|
}
|