feat: add action v2 execution on requests and responses (#7637)

* feat: add execution of targets to grpc calls * feat: add execution of targets to grpc calls * feat: add execution of targets to grpc calls * feat: add execution of targets to grpc calls * feat: add execution of targets to grpc calls * feat: add execution of targets to grpc calls * feat: add execution of targets to grpc calls * feat: split request and response logic to handle the different context information * feat: split request and response logic to handle the different context information * fix: integration test * fix: import alias * fix: refactor execution package * fix: refactor execution interceptor integration and unit tests * fix: refactor execution interceptor integration and unit tests * fix: refactor execution interceptor integration and unit tests * fix: refactor execution interceptor integration and unit tests * fix: refactor execution interceptor integration and unit tests * docs: basic documentation for executions and targets * fix: change order for interceptors * fix: merge back origin/main * fix: change target definition command and query side (#7735) * fix: change target definition command and query side * fix: correct refactoring name changes * fix: correct refactoring name changes * fix: changing execution defintion with target list and type * fix: changing execution definition with target list and type * fix: add back search queries for target and include * fix: projections change for execution with targets suffix table * fix: projections change for execution with targets suffix table * fix: projections change for execution with targets suffix table * fix: projections change for execution with targets suffix table * fix: projections change for execution with targets suffix table * fix: projections change for execution with targets suffix table * fix: projections change for execution with targets suffix table * docs: add example to actions v2 * docs: add example to actions v2 * fix: correct integration tests on query for executions * fix: add separate event for execution v2 as content changed * fix: add separate event for execution v2 as content changed * fix: added review comment changes * fix: added review comment changes * fix: added review comment changes --------- Co-authored-by: adlerhurst <silvan.reusser@gmail.com> * fix: added review comment changes * fix: added review comment changes * Update internal/api/grpc/server/middleware/execution_interceptor.go Co-authored-by: Silvan <silvan.reusser@gmail.com> * fix: added review comment changes * fix: added review comment changes * fix: added review comment changes * fix: added review comment changes * fix: added review comment changes * fix: added review comment changes --------- Co-authored-by: adlerhurst <silvan.reusser@gmail.com> Co-authored-by: Elio Bischof <elio@zitadel.com>
2025-10-10 10:09:45 +00:00 · 2024-05-04 11:55:57 +02:00
parent 7e345444bf
commit 1c5ecba42a
67 changed files with 4397 additions and 1556 deletions
--- a/internal/api/grpc/action/v3alpha/query_integration_test.go
+++ b/internal/api/grpc/action/v3alpha/query_integration_test.go
@@ -5,6 +5,7 @@ package action_test
 import (
 	"context"
 	"fmt"
+	"reflect"
 	"testing"
 	"time"

@@ -12,6 +13,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"google.golang.org/protobuf/types/known/durationpb"

+	"github.com/zitadel/zitadel/internal/domain"
 	"github.com/zitadel/zitadel/internal/integration"
 	action "github.com/zitadel/zitadel/pkg/grpc/action/v3alpha"
 	object "github.com/zitadel/zitadel/pkg/grpc/object/v2beta"
@@ -52,7 +54,7 @@ func TestServer_GetTargetByID(t *testing.T) {
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.GetTargetByIDRequest, response *action.GetTargetByIDResponse) error {
 					name := fmt.Sprint(time.Now().UnixNano() + 1)
-					resp := Tester.CreateTargetWithNameAndType(ctx, t, name, false, false)
+					resp := Tester.CreateTarget(ctx, t, name, "https://example.com", domain.TargetTypeWebhook, false)
 					request.TargetId = resp.GetId()

 					response.Target.TargetId = resp.GetId()
@@ -69,10 +71,9 @@ func TestServer_GetTargetByID(t *testing.T) {
 					Details: &object.Details{
 						ResourceOwner: Tester.Instance.InstanceID(),
 					},
+					Endpoint: "https://example.com",
 					TargetType: &action.Target_RestWebhook{
-						RestWebhook: &action.SetRESTWebhook{
-							Url: "https://example.com",
-						},
+						RestWebhook: &action.SetRESTWebhook{},
 					},
 					Timeout: durationpb.New(10 * time.Second),
 				},
@@ -84,7 +85,7 @@ func TestServer_GetTargetByID(t *testing.T) {
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.GetTargetByIDRequest, response *action.GetTargetByIDResponse) error {
 					name := fmt.Sprint(time.Now().UnixNano() + 1)
-					resp := Tester.CreateTargetWithNameAndType(ctx, t, name, true, false)
+					resp := Tester.CreateTarget(ctx, t, name, "https://example.com", domain.TargetTypeAsync, false)
 					request.TargetId = resp.GetId()

 					response.Target.TargetId = resp.GetId()
@@ -101,23 +102,21 @@ func TestServer_GetTargetByID(t *testing.T) {
 					Details: &object.Details{
 						ResourceOwner: Tester.Instance.InstanceID(),
 					},
-					TargetType: &action.Target_RestWebhook{
-						RestWebhook: &action.SetRESTWebhook{
-							Url: "https://example.com",
-						},
+					Endpoint: "https://example.com",
+					TargetType: &action.Target_RestAsync{
+						RestAsync: &action.SetRESTAsync{},
 					},
-					Timeout:       durationpb.New(10 * time.Second),
-					ExecutionType: &action.Target_IsAsync{IsAsync: true},
+					Timeout: durationpb.New(10 * time.Second),
 				},
 			},
 		},
 		{
-			name: "get, interruptOnError, ok",
+			name: "get, webhook interruptOnError, ok",
 			args: args{
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.GetTargetByIDRequest, response *action.GetTargetByIDResponse) error {
 					name := fmt.Sprint(time.Now().UnixNano() + 1)
-					resp := Tester.CreateTargetWithNameAndType(ctx, t, name, false, true)
+					resp := Tester.CreateTarget(ctx, t, name, "https://example.com", domain.TargetTypeWebhook, true)
 					request.TargetId = resp.GetId()

 					response.Target.TargetId = resp.GetId()
@@ -134,13 +133,79 @@ func TestServer_GetTargetByID(t *testing.T) {
 					Details: &object.Details{
 						ResourceOwner: Tester.Instance.InstanceID(),
 					},
+					Endpoint: "https://example.com",
 					TargetType: &action.Target_RestWebhook{
 						RestWebhook: &action.SetRESTWebhook{
-							Url: "https://example.com",
+							InterruptOnError: true,
 						},
 					},
-					Timeout:       durationpb.New(10 * time.Second),
-					ExecutionType: &action.Target_InterruptOnError{InterruptOnError: true},
+					Timeout: durationpb.New(10 * time.Second),
+				},
+			},
+		},
+		{
+			name: "get, call, ok",
+			args: args{
+				ctx: CTX,
+				dep: func(ctx context.Context, request *action.GetTargetByIDRequest, response *action.GetTargetByIDResponse) error {
+					name := fmt.Sprint(time.Now().UnixNano() + 1)
+					resp := Tester.CreateTarget(ctx, t, name, "https://example.com", domain.TargetTypeCall, false)
+					request.TargetId = resp.GetId()
+
+					response.Target.TargetId = resp.GetId()
+					response.Target.Name = name
+					response.Target.Details.ResourceOwner = resp.GetDetails().GetResourceOwner()
+					response.Target.Details.ChangeDate = resp.GetDetails().GetChangeDate()
+					response.Target.Details.Sequence = resp.GetDetails().GetSequence()
+					return nil
+				},
+				req: &action.GetTargetByIDRequest{},
+			},
+			want: &action.GetTargetByIDResponse{
+				Target: &action.Target{
+					Details: &object.Details{
+						ResourceOwner: Tester.Instance.InstanceID(),
+					},
+					Endpoint: "https://example.com",
+					TargetType: &action.Target_RestCall{
+						RestCall: &action.SetRESTCall{
+							InterruptOnError: false,
+						},
+					},
+					Timeout: durationpb.New(10 * time.Second),
+				},
+			},
+		},
+		{
+			name: "get, call interruptOnError, ok",
+			args: args{
+				ctx: CTX,
+				dep: func(ctx context.Context, request *action.GetTargetByIDRequest, response *action.GetTargetByIDResponse) error {
+					name := fmt.Sprint(time.Now().UnixNano() + 1)
+					resp := Tester.CreateTarget(ctx, t, name, "https://example.com", domain.TargetTypeCall, true)
+					request.TargetId = resp.GetId()
+
+					response.Target.TargetId = resp.GetId()
+					response.Target.Name = name
+					response.Target.Details.ResourceOwner = resp.GetDetails().GetResourceOwner()
+					response.Target.Details.ChangeDate = resp.GetDetails().GetChangeDate()
+					response.Target.Details.Sequence = resp.GetDetails().GetSequence()
+					return nil
+				},
+				req: &action.GetTargetByIDRequest{},
+			},
+			want: &action.GetTargetByIDResponse{
+				Target: &action.Target{
+					Details: &object.Details{
+						ResourceOwner: Tester.Instance.InstanceID(),
+					},
+					Endpoint: "https://example.com",
+					TargetType: &action.Target_RestCall{
+						RestCall: &action.SetRESTCall{
+							InterruptOnError: true,
+						},
+					},
+					Timeout: durationpb.New(10 * time.Second),
 				},
 			},
 		},
@@ -163,15 +228,11 @@ func TestServer_GetTargetByID(t *testing.T) {
 					assert.Error(ttt, getErr, "Error: "+getErr.Error())
 				} else {
 					assert.NoError(ttt, getErr)
-				}
-				if getErr != nil {
-					fmt.Println("Error: " + getErr.Error())
-					return
-				}

-				integration.AssertDetails(t, tt.want.GetTarget(), got.GetTarget())
+					integration.AssertDetails(t, tt.want.GetTarget(), got.GetTarget())

-				assert.Equal(t, tt.want.Target, got.Target)
+					assert.Equal(t, tt.want.Target, got.Target)
+				}

 			}, retryDuration, time.Millisecond*100, "timeout waiting for expected execution result")
 		})
@@ -227,14 +288,14 @@ func TestServer_ListTargets(t *testing.T) {
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.ListTargetsRequest, response *action.ListTargetsResponse) error {
 					name := fmt.Sprint(time.Now().UnixNano() + 1)
-					resp := Tester.CreateTargetWithNameAndType(ctx, t, name, false, false)
+					resp := Tester.CreateTarget(ctx, t, name, "https://example.com", domain.TargetTypeWebhook, false)
 					request.Queries[0].Query = &action.TargetSearchQuery_InTargetIdsQuery{
 						InTargetIdsQuery: &action.InTargetIDsQuery{
 							TargetIds: []string{resp.GetId()},
 						},
 					}
 					response.Details.Timestamp = resp.GetDetails().GetChangeDate()
-					response.Details.ProcessedSequence = resp.GetDetails().GetSequence()
+					//response.Details.ProcessedSequence = resp.GetDetails().GetSequence()

 					response.Result[0].Details.ChangeDate = resp.GetDetails().GetChangeDate()
 					response.Result[0].Details.Sequence = resp.GetDetails().GetSequence()
@@ -255,9 +316,10 @@ func TestServer_ListTargets(t *testing.T) {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
+						Endpoint: "https://example.com",
 						TargetType: &action.Target_RestWebhook{
 							RestWebhook: &action.SetRESTWebhook{
-								Url: "https://example.com",
+								InterruptOnError: false,
 							},
 						},
 						Timeout: durationpb.New(10 * time.Second),
@@ -270,7 +332,7 @@ func TestServer_ListTargets(t *testing.T) {
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.ListTargetsRequest, response *action.ListTargetsResponse) error {
 					name := fmt.Sprint(time.Now().UnixNano() + 1)
-					resp := Tester.CreateTargetWithNameAndType(ctx, t, name, false, false)
+					resp := Tester.CreateTarget(ctx, t, name, "https://example.com", domain.TargetTypeWebhook, false)
 					request.Queries[0].Query = &action.TargetSearchQuery_TargetNameQuery{
 						TargetNameQuery: &action.TargetNameQuery{
 							TargetName: name,
@@ -298,9 +360,10 @@ func TestServer_ListTargets(t *testing.T) {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
+						Endpoint: "https://example.com",
 						TargetType: &action.Target_RestWebhook{
 							RestWebhook: &action.SetRESTWebhook{
-								Url: "https://example.com",
+								InterruptOnError: false,
 							},
 						},
 						Timeout: durationpb.New(10 * time.Second),
@@ -316,9 +379,9 @@ func TestServer_ListTargets(t *testing.T) {
 					name1 := fmt.Sprint(time.Now().UnixNano() + 1)
 					name2 := fmt.Sprint(time.Now().UnixNano() + 3)
 					name3 := fmt.Sprint(time.Now().UnixNano() + 5)
-					resp1 := Tester.CreateTargetWithNameAndType(ctx, t, name1, false, false)
-					resp2 := Tester.CreateTargetWithNameAndType(ctx, t, name2, true, false)
-					resp3 := Tester.CreateTargetWithNameAndType(ctx, t, name3, false, true)
+					resp1 := Tester.CreateTarget(ctx, t, name1, "https://example.com", domain.TargetTypeWebhook, false)
+					resp2 := Tester.CreateTarget(ctx, t, name2, "https://example.com", domain.TargetTypeCall, true)
+					resp3 := Tester.CreateTarget(ctx, t, name3, "https://example.com", domain.TargetTypeAsync, false)
 					request.Queries[0].Query = &action.TargetSearchQuery_InTargetIdsQuery{
 						InTargetIdsQuery: &action.InTargetIDsQuery{
 							TargetIds: []string{resp1.GetId(), resp2.GetId(), resp3.GetId()},
@@ -354,9 +417,10 @@ func TestServer_ListTargets(t *testing.T) {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
+						Endpoint: "https://example.com",
 						TargetType: &action.Target_RestWebhook{
 							RestWebhook: &action.SetRESTWebhook{
-								Url: "https://example.com",
+								InterruptOnError: false,
 							},
 						},
 						Timeout: durationpb.New(10 * time.Second),
@@ -365,25 +429,23 @@ func TestServer_ListTargets(t *testing.T) {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
-						TargetType: &action.Target_RestWebhook{
-							RestWebhook: &action.SetRESTWebhook{
-								Url: "https://example.com",
+						Endpoint: "https://example.com",
+						TargetType: &action.Target_RestCall{
+							RestCall: &action.SetRESTCall{
+								InterruptOnError: true,
 							},
 						},
-						Timeout:       durationpb.New(10 * time.Second),
-						ExecutionType: &action.Target_IsAsync{IsAsync: true},
+						Timeout: durationpb.New(10 * time.Second),
 					},
 					{
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
-						TargetType: &action.Target_RestWebhook{
-							RestWebhook: &action.SetRESTWebhook{
-								Url: "https://example.com",
-							},
+						Endpoint: "https://example.com",
+						TargetType: &action.Target_RestAsync{
+							RestAsync: &action.SetRESTAsync{},
 						},
-						Timeout:       durationpb.New(10 * time.Second),
-						ExecutionType: &action.Target_InterruptOnError{InterruptOnError: true},
+						Timeout: durationpb.New(10 * time.Second),
 					},
 				},
 			},
@@ -422,9 +484,9 @@ func TestServer_ListTargets(t *testing.T) {
 	}
 }

-func TestServer_ListExecutions_Request(t *testing.T) {
+func TestServer_ListExecutions(t *testing.T) {
 	ensureFeatureEnabled(t)
-	targetResp := Tester.CreateTarget(CTX, t)
+	targetResp := Tester.CreateTarget(CTX, t, "", "https://example.com", domain.TargetTypeWebhook, false)

 	type args struct {
 		ctx context.Context
@@ -446,17 +508,20 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 			wantErr: true,
 		},
 		{
-			name: "list single condition",
+			name: "list request single condition",
 			args: args{
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.ListExecutionsRequest, response *action.ListExecutionsResponse) error {
-					resp := Tester.SetExecution(ctx, t, request.Queries[0].GetInConditionsQuery().GetConditions()[0], []string{targetResp.GetId()}, []string{})
+					cond := request.Queries[0].GetInConditionsQuery().GetConditions()[0]
+					resp := Tester.SetExecution(ctx, t, cond, executionTargetsSingleTarget(targetResp.GetId()))

 					response.Details.Timestamp = resp.GetDetails().GetChangeDate()
-					response.Details.ProcessedSequence = resp.GetDetails().GetSequence()
+					// response.Details.ProcessedSequence = resp.GetDetails().GetSequence()

+					// Set expected response with used values for SetExecution
 					response.Result[0].Details.ChangeDate = resp.GetDetails().GetChangeDate()
 					response.Result[0].Details.Sequence = resp.GetDetails().GetSequence()
+					response.Result[0].Condition = cond
 					return nil
 				},
 				req: &action.ListExecutionsRequest{
@@ -471,8 +536,7 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 											},
 										},
 									},
-								},
-								},
+								}},
 							},
 						},
 					}},
@@ -487,18 +551,26 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
-						ExecutionId: "request./zitadel.session.v2beta.SessionService/GetSession",
-						Targets:     []string{targetResp.GetId()},
+						Condition: &action.Condition{
+							ConditionType: &action.Condition_Request{
+								Request: &action.RequestExecution{
+									Condition: &action.RequestExecution_Method{
+										Method: "/zitadel.session.v2beta.SessionService/GetSession",
+									},
+								},
+							},
+						},
+						Targets: executionTargetsSingleTarget(targetResp.GetId()),
 					},
 				},
 			},
 		},
 		{
-			name: "list single target",
+			name: "list request single target",
 			args: args{
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.ListExecutionsRequest, response *action.ListExecutionsResponse) error {
-					target := Tester.CreateTarget(ctx, t)
+					target := Tester.CreateTarget(CTX, t, "", "https://example.com", domain.TargetTypeWebhook, false)
 					// add target as query to the request
 					request.Queries[0] = &action.SearchQuery{
 						Query: &action.SearchQuery_TargetQuery{
@@ -507,7 +579,7 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 							},
 						},
 					}
-					resp := Tester.SetExecution(ctx, t, &action.Condition{
+					cond := &action.Condition{
 						ConditionType: &action.Condition_Request{
 							Request: &action.RequestExecution{
 								Condition: &action.RequestExecution_Method{
@@ -515,14 +587,17 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 								},
 							},
 						},
-					}, []string{target.GetId()}, []string{})
+					}
+					targets := executionTargetsSingleTarget(target.GetId())
+					resp := Tester.SetExecution(ctx, t, cond, targets)

 					response.Details.Timestamp = resp.GetDetails().GetChangeDate()
 					response.Details.ProcessedSequence = resp.GetDetails().GetSequence()

 					response.Result[0].Details.ChangeDate = resp.GetDetails().GetChangeDate()
 					response.Result[0].Details.Sequence = resp.GetDetails().GetSequence()
-					response.Result[0].Targets[0] = target.GetId()
+					response.Result[0].Condition = cond
+					response.Result[0].Targets = targets
 					return nil
 				},
 				req: &action.ListExecutionsRequest{
@@ -538,17 +613,17 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
-						ExecutionId: "request./zitadel.management.v1.ManagementService/UpdateAction",
-						Targets:     []string{""},
+						Condition: &action.Condition{},
+						Targets:   executionTargetsSingleTarget(""),
 					},
 				},
 			},
 		}, {
-			name: "list single include",
+			name: "list request single include",
 			args: args{
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.ListExecutionsRequest, response *action.ListExecutionsResponse) error {
-					Tester.SetExecution(ctx, t, &action.Condition{
+					cond := &action.Condition{
 						ConditionType: &action.Condition_Request{
 							Request: &action.RequestExecution{
 								Condition: &action.RequestExecution_Method{
@@ -556,8 +631,11 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 								},
 							},
 						},
-					}, []string{targetResp.GetId()}, []string{})
-					resp2 := Tester.SetExecution(ctx, t, &action.Condition{
+					}
+					Tester.SetExecution(ctx, t, cond, executionTargetsSingleTarget(targetResp.GetId()))
+					request.Queries[0].GetIncludeQuery().Include = cond
+
+					includeCond := &action.Condition{
 						ConditionType: &action.Condition_Request{
 							Request: &action.RequestExecution{
 								Condition: &action.RequestExecution_Method{
@@ -565,19 +643,23 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 								},
 							},
 						},
-					}, []string{}, []string{"request./zitadel.management.v1.ManagementService/GetAction"})
+					}
+					includeTargets := executionTargetsSingleInclude(cond)
+					resp2 := Tester.SetExecution(ctx, t, includeCond, includeTargets)

 					response.Details.Timestamp = resp2.GetDetails().GetChangeDate()
 					response.Details.ProcessedSequence = resp2.GetDetails().GetSequence()

 					response.Result[0].Details.ChangeDate = resp2.GetDetails().GetChangeDate()
 					response.Result[0].Details.Sequence = resp2.GetDetails().GetSequence()
+					response.Result[0].Condition = includeCond
+					response.Result[0].Targets = includeTargets
 					return nil
 				},
 				req: &action.ListExecutionsRequest{
 					Queries: []*action.SearchQuery{{
 						Query: &action.SearchQuery_IncludeQuery{
-							IncludeQuery: &action.IncludeQuery{Include: "request./zitadel.management.v1.ManagementService/GetAction"},
+							IncludeQuery: &action.IncludeQuery{},
 						},
 					}},
 				},
@@ -591,8 +673,6 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
-						ExecutionId: "request./zitadel.management.v1.ManagementService/ListActions",
-						Includes:    []string{"request./zitadel.management.v1.ManagementService/GetAction"},
 					},
 				},
 			},
@@ -603,19 +683,32 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 				ctx: CTX,
 				dep: func(ctx context.Context, request *action.ListExecutionsRequest, response *action.ListExecutionsResponse) error {

-					resp1 := Tester.SetExecution(ctx, t, request.Queries[0].GetInConditionsQuery().GetConditions()[0], []string{targetResp.GetId()}, []string{})
+					cond1 := request.Queries[0].GetInConditionsQuery().GetConditions()[0]
+					targets1 := executionTargetsSingleTarget(targetResp.GetId())
+					resp1 := Tester.SetExecution(ctx, t, cond1, targets1)
 					response.Result[0].Details.ChangeDate = resp1.GetDetails().GetChangeDate()
 					response.Result[0].Details.Sequence = resp1.GetDetails().GetSequence()
+					response.Result[0].Condition = cond1
+					response.Result[0].Targets = targets1

-					resp2 := Tester.SetExecution(ctx, t, request.Queries[0].GetInConditionsQuery().GetConditions()[1], []string{targetResp.GetId()}, []string{})
+					cond2 := request.Queries[0].GetInConditionsQuery().GetConditions()[1]
+					targets2 := executionTargetsSingleTarget(targetResp.GetId())
+					resp2 := Tester.SetExecution(ctx, t, cond2, targets2)
 					response.Result[1].Details.ChangeDate = resp2.GetDetails().GetChangeDate()
 					response.Result[1].Details.Sequence = resp2.GetDetails().GetSequence()
+					response.Result[1].Condition = cond2
+					response.Result[1].Targets = targets2

-					resp3 := Tester.SetExecution(ctx, t, request.Queries[0].GetInConditionsQuery().GetConditions()[2], []string{targetResp.GetId()}, []string{})
-					response.Details.Timestamp = resp3.GetDetails().GetChangeDate()
-					response.Details.ProcessedSequence = resp3.GetDetails().GetSequence()
+					cond3 := request.Queries[0].GetInConditionsQuery().GetConditions()[2]
+					targets3 := executionTargetsSingleTarget(targetResp.GetId())
+					resp3 := Tester.SetExecution(ctx, t, cond3, targets3)
 					response.Result[2].Details.ChangeDate = resp3.GetDetails().GetChangeDate()
 					response.Result[2].Details.Sequence = resp3.GetDetails().GetSequence()
+					response.Result[2].Condition = cond3
+					response.Result[2].Targets = targets3
+
+					response.Details.Timestamp = resp3.GetDetails().GetChangeDate()
+					response.Details.ProcessedSequence = resp3.GetDetails().GetSequence()
 					return nil
 				},
 				req: &action.ListExecutionsRequest{
@@ -665,24 +758,77 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
-						ExecutionId: "request./zitadel.session.v2beta.SessionService/GetSession",
-						Targets:     []string{targetResp.GetId()},
 					}, {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
-						ExecutionId: "request./zitadel.session.v2beta.SessionService/CreateSession",
-						Targets:     []string{targetResp.GetId()},
 					}, {
 						Details: &object.Details{
 							ResourceOwner: Tester.Instance.InstanceID(),
 						},
-						ExecutionId: "request./zitadel.session.v2beta.SessionService/SetSession",
-						Targets:     []string{targetResp.GetId()},
 					},
 				},
 			},
 		},
+		{
+			name: "list multiple conditions all types",
+			args: args{
+				ctx: CTX,
+				dep: func(ctx context.Context, request *action.ListExecutionsRequest, response *action.ListExecutionsResponse) error {
+					targets := executionTargetsSingleTarget(targetResp.GetId())
+					for i, cond := range request.Queries[0].GetInConditionsQuery().GetConditions() {
+						resp := Tester.SetExecution(ctx, t, cond, targets)
+						response.Result[i].Details.ChangeDate = resp.GetDetails().GetChangeDate()
+						response.Result[i].Details.Sequence = resp.GetDetails().GetSequence()
+						response.Result[i].Condition = cond
+						response.Result[i].Targets = targets
+
+						// filled with info of last sequence
+						response.Details.Timestamp = resp.GetDetails().GetChangeDate()
+						response.Details.ProcessedSequence = resp.GetDetails().GetSequence()
+					}
+
+					return nil
+				},
+				req: &action.ListExecutionsRequest{
+					Queries: []*action.SearchQuery{{
+						Query: &action.SearchQuery_InConditionsQuery{
+							InConditionsQuery: &action.InConditionsQuery{
+								Conditions: []*action.Condition{
+									{ConditionType: &action.Condition_Request{Request: &action.RequestExecution{Condition: &action.RequestExecution_Method{Method: "/zitadel.session.v2beta.SessionService/GetSession"}}}},
+									{ConditionType: &action.Condition_Request{Request: &action.RequestExecution{Condition: &action.RequestExecution_Service{Service: "zitadel.session.v2beta.SessionService"}}}},
+									{ConditionType: &action.Condition_Request{Request: &action.RequestExecution{Condition: &action.RequestExecution_All{All: true}}}},
+									{ConditionType: &action.Condition_Response{Response: &action.ResponseExecution{Condition: &action.ResponseExecution_Method{Method: "/zitadel.session.v2beta.SessionService/GetSession"}}}},
+									{ConditionType: &action.Condition_Response{Response: &action.ResponseExecution{Condition: &action.ResponseExecution_Service{Service: "zitadel.session.v2beta.SessionService"}}}},
+									{ConditionType: &action.Condition_Response{Response: &action.ResponseExecution{Condition: &action.ResponseExecution_All{All: true}}}},
+									{ConditionType: &action.Condition_Event{Event: &action.EventExecution{Condition: &action.EventExecution_Event{Event: "user.added"}}}},
+									{ConditionType: &action.Condition_Event{Event: &action.EventExecution{Condition: &action.EventExecution_Group{Group: "user"}}}},
+									{ConditionType: &action.Condition_Event{Event: &action.EventExecution{Condition: &action.EventExecution_All{All: true}}}},
+									{ConditionType: &action.Condition_Function{Function: &action.FunctionExecution{Name: "Action.Flow.Type.ExternalAuthentication.Action.TriggerType.PostAuthentication"}}},
+								},
+							},
+						},
+					}},
+				},
+			},
+			want: &action.ListExecutionsResponse{
+				Details: &object.ListDetails{
+					TotalResult: 10,
+				},
+				Result: []*action.Execution{
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+					{Details: &object.Details{ResourceOwner: Tester.Instance.InstanceID()}},
+				},
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -699,20 +845,33 @@ func TestServer_ListExecutions_Request(t *testing.T) {
 			require.EventuallyWithT(t, func(ttt *assert.CollectT) {
 				got, listErr := Client.ListExecutions(tt.args.ctx, tt.args.req)
 				if tt.wantErr {
-					assert.Error(ttt, listErr, "Error: "+listErr.Error())
+					assert.Error(t, listErr, "Error: "+listErr.Error())
 				} else {
-					assert.NoError(ttt, listErr)
+					assert.NoError(t, listErr)
 				}
 				if listErr != nil {
 					return
 				}
 				// always first check length, otherwise its failed anyway
-				assert.Len(ttt, got.Result, len(tt.want.Result))
+				assert.Len(t, got.Result, len(tt.want.Result))
 				for i := range tt.want.Result {
-					assert.Contains(ttt, got.Result, tt.want.Result[i])
+					// as not sorted, all elements have to be checked
+					// workaround as oneof elements can only be checked with assert.EqualExportedValues()
+					if j, found := containExecution(got.Result, tt.want.Result[i]); found {
+						assert.EqualExportedValues(t, tt.want.Result[i], got.Result[j])
+					}
 				}
 				integration.AssertListDetails(t, tt.want, got)
 			}, retryDuration, time.Millisecond*100, "timeout waiting for expected execution result")
 		})
 	}
 }
+
+func containExecution(executionList []*action.Execution, execution *action.Execution) (int, bool) {
+	for i, exec := range executionList {
+		if reflect.DeepEqual(exec.Details, execution.Details) {
+			return i, true
+		}
+	}
+	return 0, false
+}