Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

42.6 KB
Raw Blame
package tests

import (
	"context"
	"fmt"
	"strings"
	"testing"
	"time"

	"connectrpc.com/connect"
	"github.com/google/uuid"
	"github.com/stretchr/testify/require"
	"google.golang.org/genproto/googleapis/type/expr"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

	"github.com/bytebase/bytebase/backend/common"
	"github.com/bytebase/bytebase/backend/component/review"
	storepb "github.com/bytebase/bytebase/backend/generated-go/store"
	v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
	"github.com/bytebase/bytebase/backend/store"
)

// TestDirectApprovalRuleMatching tests the new direct approval rule API
// where rules are created via WorkspaceApprovalSetting without the risk layer.
func TestDirectApprovalRuleMatching(t *testing.T) {
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	// Create instance in prod environment
	pgContainer := sharedPgTarget(t)
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: generateRandomString("inst"),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Prod Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/prod"),
			Activation:    true,
			DataSources:   []*v1pb.DataSource{pgContainer.adminDataSource()},
		},
	}))
	a.NoError(err)

	// Create database
	dbName := generateRandomString("db")
	err = ctl.createDatabase(ctx, ctl.project, instanceResp.Msg, nil, dbName, "")
	a.NoError(err)

	// Create approval rule directly via WorkspaceApprovalSetting
	// This tests the new direct approval rule API (without risk layer)
	_, err = ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								Source: v1pb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
								Condition: &expr.Expr{
									Expression: `resource.db_engine == "POSTGRES"`, // Use db_engine to test CEL with variables
								},
								Template: &v1pb.ApprovalTemplate{
									Title:       "Prod Change Database Approval",
									Description: "Requires workspace owner approval for database changes in prod",
									Flow: &v1pb.ApprovalFlow{
										Roles: []string{"roles/workspaceOwner"},
									},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.NoError(err, "Setting update should succeed")

	// Create sheet with DDL statement
	sheet, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: ctl.project.Name,
		Sheet: &v1pb.Sheet{
			Content: []byte("CREATE TABLE approval_test (id INTEGER PRIMARY KEY);"),
		},
	}))
	a.NoError(err)

	// Create plan
	planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
		Parent: ctl.project.Name,
		Plan: &v1pb.Plan{
			Title: "Test DDL Plan for Direct Approval",
			Specs: []*v1pb.Plan_Spec{{
				Id: uuid.NewString(),
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName)},
						Sheet:   sheet.Msg.Name,
					},
				},
			}},
		},
	}))
	a.NoError(err)

	// Create issue - this triggers approval rule matching
	issueResp, err := ctl.issueServiceClient.CreateIssue(ctx, connect.NewRequest(&v1pb.CreateIssueRequest{
		Parent: ctl.project.Name,
		Issue: &v1pb.Issue{
			Title:       "Test Issue for Direct Approval Rule",
			Type:        v1pb.Issue_DATABASE_CHANGE,
			Description: "Testing direct approval rule matching",
			Plan:        planResp.Msg.Name,
		},
	}))
	a.NoError(err)

	// Wait for approval finding to complete
	var issue *v1pb.Issue
	for i := 0; i < 5; i++ {
		if i > 0 {
			time.Sleep(3 * time.Second)
		}

		issueGetResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{
			Name: issueResp.Msg.Name,
		}))
		a.NoError(err)
		issue = issueGetResp.Msg

		if issue.ApprovalStatus != v1pb.ApprovalStatus_CHECKING {
			break
		}
	}

	// Verify approval finding completed successfully
	a.NotNil(issue)
	a.NotEqual(v1pb.ApprovalStatus_CHECKING, issue.ApprovalStatus, "Approval finding should complete")

	// Verify that the approval template was correctly assigned
	// Note: The status may be SKIPPED/APPROVED if the user is a workspace owner
	// who can self-approve, but the template should still be assigned
	a.NotNil(issue.ApprovalTemplate, "Approval template should be assigned")
	a.Equal("Prod Change Database Approval", issue.GetApprovalTemplate().GetTitle(), "Correct approval template should be applied")
}

func TestApprovalFindingRerunsPlanCheckForStaleApprovalInputVersion(t *testing.T) {
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	pgContainer := sharedPgTarget(t)
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: generateRandomString("inst"),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Approval Input Version Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/prod"),
			Activation:    true,
			DataSources:   []*v1pb.DataSource{pgContainer.adminDataSource()},
		},
	}))
	a.NoError(err)

	dbName := generateRandomString("db")
	err = ctl.createDatabase(ctx, ctl.project, instanceResp.Msg, nil, dbName, "")
	a.NoError(err)
	databaseName := fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName)

	_, err = ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								Source: v1pb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
								Condition: &expr.Expr{
									Expression: `statement.text.contains("stale_approval_b")`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Postgres change approval B",
									Flow: &v1pb.ApprovalFlow{
										Roles: []string{"roles/workspaceOwner"},
									},
								},
							},
							{
								Source: v1pb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
								Condition: &expr.Expr{
									Expression: `statement.text.contains("stale_approval_a")`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Postgres change approval A",
									Flow: &v1pb.ApprovalFlow{
										Roles: []string{"roles/workspaceOwner"},
									},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.NoError(err)

	sheet1, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: ctl.project.Name,
		Sheet: &v1pb.Sheet{
			Content: []byte("CREATE TABLE stale_approval_a (id INTEGER PRIMARY KEY);"),
		},
	}))
	a.NoError(err)
	sheet2, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: ctl.project.Name,
		Sheet: &v1pb.Sheet{
			Content: []byte("CREATE TABLE stale_approval_b (id INTEGER PRIMARY KEY);"),
		},
	}))
	a.NoError(err)

	specID := uuid.NewString()
	planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
		Parent: ctl.project.Name,
		Plan: &v1pb.Plan{
			Title: "Approval input version plan",
			Specs: []*v1pb.Plan_Spec{{
				Id: specID,
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{databaseName},
						Sheet:   sheet1.Msg.Name,
					},
				},
			}},
		},
	}))
	a.NoError(err)

	issueResp, err := ctl.issueServiceClient.CreateIssue(ctx, connect.NewRequest(&v1pb.CreateIssueRequest{
		Parent: ctl.project.Name,
		Issue: &v1pb.Issue{
			Title:       "Approval input version issue",
			Type:        v1pb.Issue_DATABASE_CHANGE,
			Description: "Testing approval input version rerun",
			Plan:        planResp.Msg.Name,
		},
	}))
	a.NoError(err)

	waitForApprovalFindingDone(ctx, t, ctl, issueResp.Msg)

	gotIssueResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{Name: issueResp.Msg.Name}))
	a.NoError(err)
	a.NotEqual(v1pb.ApprovalStatus_CHECKING, gotIssueResp.Msg.ApprovalStatus)
	a.Equal("Postgres change approval A", gotIssueResp.Msg.GetApprovalTemplate().GetTitle())

	updatedPlanResp, err := ctl.planServiceClient.UpdatePlan(ctx, connect.NewRequest(&v1pb.UpdatePlanRequest{
		Plan: &v1pb.Plan{
			Name: planResp.Msg.Name,
			Specs: []*v1pb.Plan_Spec{{
				Id: specID,
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{databaseName},
						Sheet:   sheet2.Msg.Name,
					},
				},
			}},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"specs"}},
	}))
	a.NoError(err)

	waitForApprovalFindingDone(ctx, t, ctl, issueResp.Msg)

	gotIssueResp, err = ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{Name: issueResp.Msg.Name}))
	a.NoError(err)
	a.NotEqual(v1pb.ApprovalStatus_CHECKING, gotIssueResp.Msg.ApprovalStatus)
	a.Equal("Postgres change approval B", gotIssueResp.Msg.GetApprovalTemplate().GetTitle())

	checkResp, err := ctl.planServiceClient.GetPlanCheckRun(ctx, connect.NewRequest(&v1pb.GetPlanCheckRunRequest{
		Name: fmt.Sprintf("%s/planCheckRun", updatedPlanResp.Msg.Name),
	}))
	a.NoError(err)
	a.Equal(v1pb.PlanCheckRun_DONE, checkResp.Msg.Status)
}

//nolint:tparallel // Subtests share one server lifecycle.
func TestApprovalActionRejectsStaleApprovalInputVersion(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	stores := getStore(t, ctl.server)

	t.Run("ApproveIssue", func(t *testing.T) {
		issue, staleApproval, approver := createStaleApprovalInputVersionIssue(ctx, t, ctl, stores, "stale-approve")

		withImpersonation(ctx, t, ctl, approver, func() {
			_, err := ctl.issueServiceClient.ApproveIssue(ctx, connect.NewRequest(&v1pb.ApproveIssueRequest{
				Name:    issue.Name,
				Comment: "approve stale approval",
			}))
			require.Error(t, err)
			require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
		})

		got, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{Name: issue.Name}))
		require.NoError(t, err)
		require.Equal(t, v1pb.ApprovalStatus_PENDING, got.Msg.ApprovalStatus)
		requireApprovalPayloadApproverCount(ctx, t, stores, issue.Name, len(staleApproval.Approvers))
	})

	t.Run("RejectIssue", func(t *testing.T) {
		issue, staleApproval, approver := createStaleApprovalInputVersionIssue(ctx, t, ctl, stores, "stale-reject")

		withImpersonation(ctx, t, ctl, approver, func() {
			_, err := ctl.issueServiceClient.RejectIssue(ctx, connect.NewRequest(&v1pb.RejectIssueRequest{
				Name:    issue.Name,
				Comment: "reject stale approval",
			}))
			require.Error(t, err)
			require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))
		})

		got, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{Name: issue.Name}))
		require.NoError(t, err)
		require.Equal(t, v1pb.ApprovalStatus_PENDING, got.Msg.ApprovalStatus)
		requireApprovalPayloadApproverCount(ctx, t, stores, issue.Name, len(staleApproval.Approvers))
	})

	t.Run("RequestIssue", func(t *testing.T) {
		issue, staleApproval, approver := createStaleApprovalInputVersionIssue(ctx, t, ctl, stores, "stale-request")
		staleApproval.Approvers = append(staleApproval.Approvers, &storepb.IssuePayloadApproval_Approver{
			Status:    storepb.IssuePayloadApproval_Approver_REJECTED,
			Principal: common.FormatUserEmail(approver.Email),
		})
		writeIssueApprovalPayload(ctx, t, stores, issue.Name, staleApproval)

		_, err := ctl.issueServiceClient.RequestIssue(ctx, connect.NewRequest(&v1pb.RequestIssueRequest{
			Name:    issue.Name,
			Comment: "request stale approval",
		}))
		require.Error(t, err)
		require.Equal(t, connect.CodeFailedPrecondition, connect.CodeOf(err))

		got, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{Name: issue.Name}))
		require.NoError(t, err)
		require.Equal(t, v1pb.ApprovalStatus_REJECTED, got.Msg.ApprovalStatus)
		requireApprovalPayloadApproverCount(ctx, t, stores, issue.Name, len(staleApproval.Approvers))
	})
}

func createStaleApprovalInputVersionIssue(ctx context.Context, t *testing.T, ctl *controller, stores *store.Store, suffix string) (*v1pb.Issue, *storepb.IssuePayloadApproval, testApprover) {
	t.Helper()
	project := ctl.createTestProject(ctx, t, suffix)

	pgContainer := sharedPgTarget(t)
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: generateRandomString("inst"),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Stale Approval Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/prod"),
			Activation:    true,
			DataSources:   []*v1pb.DataSource{pgContainer.adminDataSource()},
		},
	}))
	require.NoError(t, err)

	dbName := generateRandomString("db")
	require.NoError(t, ctl.createDatabase(ctx, project, instanceResp.Msg, nil, dbName, ""))
	target := dbTargetName(instanceResp.Msg, dbName)

	disableSelfApproval(ctx, t, ctl, project)
	installWorkspaceApprovalRule(ctx, t, ctl, project, []string{"roles/projectOwner"})
	approver := provisionApprover(ctx, t, ctl, project, suffix, "roles/projectOwner")

	sheet1 := createSheetWithContent(ctx, t, ctl, project, []byte(fmt.Sprintf("CREATE TABLE %s_a (id INTEGER PRIMARY KEY);", strings.ReplaceAll(suffix, "-", "_"))))

	specID := uuid.NewString()
	planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
		Parent: project.Name,
		Plan: &v1pb.Plan{
			Title: "Stale approval input version plan " + suffix,
			Specs: []*v1pb.Plan_Spec{{
				Id: specID,
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{target},
						Sheet:   sheet1,
					},
				},
			}},
		},
	}))
	require.NoError(t, err)

	issue := createIssueForPlan(ctx, t, ctl, project, planResp.Msg, "stale approval input version "+suffix)
	waitForIssuePending(ctx, t, ctl, issue)

	_, issueUID, err := common.GetProjectIDIssueUID(issue.Name)
	require.NoError(t, err)
	projectID, err := common.GetProjectID(project.Name)
	require.NoError(t, err)
	storeIssue, err := stores.GetIssue(ctx, &store.FindIssueMessage{
		ProjectIDs: []string{projectID},
		UID:        &issueUID,
	})
	require.NoError(t, err)
	require.NotNil(t, storeIssue)
	staleApproval := proto.CloneOf(storeIssue.Payload.Approval)

	_, planUID, err := common.GetProjectIDPlanID(planResp.Msg.Name)
	require.NoError(t, err)
	plan, err := stores.GetPlan(ctx, &store.FindPlanMessage{ProjectID: projectID, UID: &planUID})
	require.NoError(t, err)
	require.NotNil(t, plan)
	storeProject, err := stores.GetProjectByResourceID(ctx, projectID)
	require.NoError(t, err)
	require.NotNil(t, storeProject)
	_, err = review.NewWorkflow(stores).UpdatePlanSpecs(ctx, review.UpdatePlanSpecsInput{
		Workspace: storeProject.Workspace,
		PlanUID:   plan.UID,
		ProjectID: plan.ProjectID,
		Specs:     proto.CloneOf(plan.Config).GetSpecs(),
	})
	require.NoError(t, err)

	writeIssueApprovalPayload(ctx, t, stores, issue.Name, staleApproval)
	return issue, staleApproval, approver
}

func createSheetWithContent(ctx context.Context, t *testing.T, ctl *controller, project *v1pb.Project, content []byte) string {
	t.Helper()
	resp, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: project.Name,
		Sheet:  &v1pb.Sheet{Content: content},
	}))
	require.NoError(t, err)
	return resp.Msg.Name
}

func writeIssueApprovalPayload(ctx context.Context, t *testing.T, stores *store.Store, issueName string, approval *storepb.IssuePayloadApproval) {
	t.Helper()
	projectID, issueUID, err := common.GetProjectIDIssueUID(issueName)
	require.NoError(t, err)
	_, err = stores.UpdateIssue(ctx, projectID, issueUID, &store.UpdateIssueMessage{
		PayloadUpsert: &storepb.Issue{
			Approval: approval,
		},
	})
	require.NoError(t, err)
}

func requireApprovalPayloadApproverCount(ctx context.Context, t *testing.T, stores *store.Store, issueName string, count int) {
	t.Helper()
	projectID, issueUID, err := common.GetProjectIDIssueUID(issueName)
	require.NoError(t, err)
	issue, err := stores.GetIssue(ctx, &store.FindIssueMessage{
		ProjectIDs: []string{projectID},
		UID:        &issueUID,
	})
	require.NoError(t, err)
	require.NotNil(t, issue)
	require.Len(t, issue.Payload.GetApproval().GetApprovers(), count)
}

// TestApprovalRuleFirstMatchWins tests that the first matching approval rule is applied
// when multiple rules could potentially match.
func TestApprovalRuleFirstMatchWins(t *testing.T) {
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	// Create instance in prod environment
	pgContainer := sharedPgTarget(t)
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: generateRandomString("inst"),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Prod Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/prod"),
			Activation:    true,
			DataSources:   []*v1pb.DataSource{pgContainer.adminDataSource()},
		},
	}))
	a.NoError(err)

	// Create database
	dbName := generateRandomString("db")
	err = ctl.createDatabase(ctx, ctl.project, instanceResp.Msg, nil, dbName, "")
	a.NoError(err)

	// Create multiple approval rules - first one should match
	// Rule 1: Specific condition (should match first)
	// Rule 2: Catch-all condition (would also match, but shouldn't be used)
	_, err = ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								// Rule 1: Specific - prod environment
								Source: v1pb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
								Condition: &expr.Expr{
									Expression: `resource.environment_id == "prod"`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Prod Change Database - First Rule",
									Flow: &v1pb.ApprovalFlow{
										Roles: []string{"roles/workspaceOwner"},
									},
								},
							},
							{
								// Rule 2: Catch-all - matches everything
								Source: v1pb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
								Condition: &expr.Expr{
									Expression: `true`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Catch-all Change Database - Second Rule",
									Flow: &v1pb.ApprovalFlow{
										Roles: []string{"roles/projectOwner", "roles/workspaceOwner"},
									},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.NoError(err)

	// Create sheet with DDL statement
	sheet, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: ctl.project.Name,
		Sheet: &v1pb.Sheet{
			Content: []byte("CREATE TABLE first_match_test (id INTEGER PRIMARY KEY);"),
		},
	}))
	a.NoError(err)

	// Create plan
	planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
		Parent: ctl.project.Name,
		Plan: &v1pb.Plan{
			Title: "Test First Match Plan",
			Specs: []*v1pb.Plan_Spec{{
				Id: uuid.NewString(),
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName)},
						Sheet:   sheet.Msg.Name,
					},
				},
			}},
		},
	}))
	a.NoError(err)

	// Create issue
	issueResp, err := ctl.issueServiceClient.CreateIssue(ctx, connect.NewRequest(&v1pb.CreateIssueRequest{
		Parent: ctl.project.Name,
		Issue: &v1pb.Issue{
			Title:       "Test Issue for First Match Wins",
			Type:        v1pb.Issue_DATABASE_CHANGE,
			Description: "Testing first match wins behavior",
			Plan:        planResp.Msg.Name,
		},
	}))
	a.NoError(err)

	// Wait for approval finding to complete
	var issue *v1pb.Issue
	for i := 0; i < 5; i++ {
		if i > 0 {
			time.Sleep(3 * time.Second)
		}

		issueGetResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{
			Name: issueResp.Msg.Name,
		}))
		a.NoError(err)
		issue = issueGetResp.Msg

		if issue.ApprovalStatus != v1pb.ApprovalStatus_CHECKING {
			break
		}
	}

	// Verify approval finding completed
	a.NotNil(issue)
	a.NotEqual(v1pb.ApprovalStatus_CHECKING, issue.ApprovalStatus)

	// Verify the first rule was applied (not the catch-all)
	a.Equal("Prod Change Database - First Rule", issue.GetApprovalTemplate().GetTitle(), "First matching rule should be applied")
}

// TestApprovalRuleNoMatch tests that issues without matching approval rules
// are automatically approved (no approval required).
func TestApprovalRuleNoMatch(t *testing.T) {
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	// Create instance in test environment (not prod)
	pgContainer := sharedPgTarget(t)
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: generateRandomString("inst"),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Test Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/test"),
			Activation:    true,
			DataSources:   []*v1pb.DataSource{pgContainer.adminDataSource()},
		},
	}))
	a.NoError(err)

	// Create database
	dbName := generateRandomString("db")
	err = ctl.createDatabase(ctx, ctl.project, instanceResp.Msg, nil, dbName, "")
	a.NoError(err)

	// Create approval rule only for prod environment
	_, err = ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								Source: v1pb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
								Condition: &expr.Expr{
									Expression: `resource.environment_id == "prod"`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Prod Only Rule",
									Flow: &v1pb.ApprovalFlow{
										Roles: []string{"roles/workspaceOwner"},
									},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.NoError(err)

	// Create sheet with DDL statement
	sheet, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: ctl.project.Name,
		Sheet: &v1pb.Sheet{
			Content: []byte("CREATE TABLE no_match_test (id INTEGER PRIMARY KEY);"),
		},
	}))
	a.NoError(err)

	// Create plan targeting test environment (not prod)
	planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
		Parent: ctl.project.Name,
		Plan: &v1pb.Plan{
			Title: "Test No Match Plan",
			Specs: []*v1pb.Plan_Spec{{
				Id: uuid.NewString(),
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName)},
						Sheet:   sheet.Msg.Name,
					},
				},
			}},
		},
	}))
	a.NoError(err)

	// Create issue
	issueResp, err := ctl.issueServiceClient.CreateIssue(ctx, connect.NewRequest(&v1pb.CreateIssueRequest{
		Parent: ctl.project.Name,
		Issue: &v1pb.Issue{
			Title:       "Test Issue No Matching Rule",
			Type:        v1pb.Issue_DATABASE_CHANGE,
			Description: "Testing no matching approval rule",
			Plan:        planResp.Msg.Name,
		},
	}))
	a.NoError(err)

	// Wait for approval finding to complete
	var issue *v1pb.Issue
	for i := 0; i < 5; i++ {
		if i > 0 {
			time.Sleep(3 * time.Second)
		}

		issueGetResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{
			Name: issueResp.Msg.Name,
		}))
		a.NoError(err)
		issue = issueGetResp.Msg

		if issue.ApprovalStatus != v1pb.ApprovalStatus_CHECKING {
			break
		}
	}

	// Verify approval finding completed
	a.NotNil(issue)
	a.NotEqual(v1pb.ApprovalStatus_CHECKING, issue.ApprovalStatus)

	// Since no rule matches test environment, no approval template should be assigned
	// and the issue should be auto-approved (or skipped)
	a.Nil(issue.ApprovalTemplate, "No approval template should be assigned when no rule matches")
	// Status should be APPROVED or SKIPPED (auto-approved)
	a.True(issue.ApprovalStatus == v1pb.ApprovalStatus_APPROVED || issue.ApprovalStatus == v1pb.ApprovalStatus_SKIPPED,
		"Issue should be auto-approved when no rule matches, got status: %v", issue.ApprovalStatus)
}

// TestFallbackRuleValidation tests that SOURCE_UNSPECIFIED rules
// can only use resource.project_id in conditions.
func TestFallbackRuleValidation(t *testing.T) {
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	// Test 1: Valid fallback rule with project_id should succeed
	_, err := ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								Source: v1pb.WorkspaceApprovalSetting_Rule_SOURCE_UNSPECIFIED,
								Condition: &expr.Expr{
									Expression: `resource.project_id == "proj-123"`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Valid Fallback Rule",
									Flow:  &v1pb.ApprovalFlow{Roles: []string{"roles/workspaceOwner"}},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.NoError(err, "Fallback rule with project_id should be valid")

	// Test 2: Invalid fallback rule with environment_id should fail
	_, err = ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								Source: v1pb.WorkspaceApprovalSetting_Rule_SOURCE_UNSPECIFIED,
								Condition: &expr.Expr{
									Expression: `resource.environment_id == "prod"`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Invalid Fallback Rule",
									Flow:  &v1pb.ApprovalFlow{Roles: []string{"roles/workspaceOwner"}},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.Error(err, "Fallback rule with environment_id should be rejected")
	a.Contains(err.Error(), "fallback rules can only use resource.project_id")
}

// TestFallbackRuleMatchesWhenSourceSpecificDoesNot tests that
// SOURCE_UNSPECIFIED rules are used as fallback when no source-specific rules match.
func TestFallbackRuleMatchesWhenSourceSpecificDoesNot(t *testing.T) {
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	// Create instance in TEST environment (not prod)
	pgContainer := sharedPgTarget(t)
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: generateRandomString("inst"),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Test Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/test"),
			Activation:    true,
			DataSources:   []*v1pb.DataSource{pgContainer.adminDataSource()},
		},
	}))
	a.NoError(err)

	// Create database
	dbName := generateRandomString("db")
	err = ctl.createDatabase(ctx, ctl.project, instanceResp.Msg, nil, dbName, "")
	a.NoError(err)

	// Create rules:
	// 1. Source-specific rule for prod only (won't match test environment)
	// 2. Fallback rule for this project (should match)
	projectID := strings.TrimPrefix(ctl.project.Name, "projects/")
	_, err = ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								// Source-specific: only matches prod
								Source: v1pb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
								Condition: &expr.Expr{
									Expression: `resource.environment_id == "prod"`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Prod Only Rule",
									Flow:  &v1pb.ApprovalFlow{Roles: []string{"roles/workspaceOwner"}},
								},
							},
							{
								// Fallback: matches this project
								Source: v1pb.WorkspaceApprovalSetting_Rule_SOURCE_UNSPECIFIED,
								Condition: &expr.Expr{
									Expression: fmt.Sprintf(`resource.project_id == "%s"`, projectID),
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Fallback Rule",
									Flow:  &v1pb.ApprovalFlow{Roles: []string{"roles/projectOwner"}},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.NoError(err)

	// Create sheet with DDL statement
	sheet, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: ctl.project.Name,
		Sheet: &v1pb.Sheet{
			Content: []byte("CREATE TABLE fallback_test (id INTEGER PRIMARY KEY);"),
		},
	}))
	a.NoError(err)

	// Create plan targeting test environment
	planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
		Parent: ctl.project.Name,
		Plan: &v1pb.Plan{
			Title: "Test Fallback Plan",
			Specs: []*v1pb.Plan_Spec{{
				Id: uuid.NewString(),
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName)},
						Sheet:   sheet.Msg.Name,
					},
				},
			}},
		},
	}))
	a.NoError(err)

	// Create issue
	issueResp, err := ctl.issueServiceClient.CreateIssue(ctx, connect.NewRequest(&v1pb.CreateIssueRequest{
		Parent: ctl.project.Name,
		Issue: &v1pb.Issue{
			Title:       "Test Issue for Fallback Rule",
			Type:        v1pb.Issue_DATABASE_CHANGE,
			Description: "Testing fallback rule matching",
			Plan:        planResp.Msg.Name,
		},
	}))
	a.NoError(err)

	// Wait for approval finding to complete
	var issue *v1pb.Issue
	for i := 0; i < 5; i++ {
		if i > 0 {
			time.Sleep(3 * time.Second)
		}
		issueGetResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{
			Name: issueResp.Msg.Name,
		}))
		a.NoError(err)
		issue = issueGetResp.Msg
		if issue.ApprovalStatus != v1pb.ApprovalStatus_CHECKING {
			break
		}
	}

	// Verify fallback rule was applied
	a.NotNil(issue)
	a.NotEqual(v1pb.ApprovalStatus_CHECKING, issue.ApprovalStatus)
	a.NotNil(issue.ApprovalTemplate, "Fallback approval template should be assigned")
	a.Equal("Fallback Rule", issue.GetApprovalTemplate().GetTitle(), "Fallback rule should be applied")
}

// TestSourceSpecificRuleTakesPriorityOverFallback verifies that
// source-specific rules are always tried before fallback rules.
func TestSourceSpecificRuleTakesPriorityOverFallback(t *testing.T) {
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	// Create instance in prod environment
	pgContainer := sharedPgTarget(t)
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: generateRandomString("inst"),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Prod Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/prod"),
			Activation:    true,
			DataSources:   []*v1pb.DataSource{pgContainer.adminDataSource()},
		},
	}))
	a.NoError(err)

	// Create database
	dbName := generateRandomString("db")
	err = ctl.createDatabase(ctx, ctl.project, instanceResp.Msg, nil, dbName, "")
	a.NoError(err)

	// Create rules with fallback FIRST in the list, but source-specific should still win
	projectID := strings.TrimPrefix(ctl.project.Name, "projects/")
	_, err = ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								// Fallback rule FIRST in list
								Source: v1pb.WorkspaceApprovalSetting_Rule_SOURCE_UNSPECIFIED,
								Condition: &expr.Expr{
									Expression: fmt.Sprintf(`resource.project_id == "%s"`, projectID),
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Fallback Rule (should NOT be used)",
									Flow:  &v1pb.ApprovalFlow{Roles: []string{"roles/projectOwner"}},
								},
							},
							{
								// Source-specific rule SECOND in list
								Source: v1pb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
								Condition: &expr.Expr{
									Expression: `resource.environment_id == "prod"`,
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Source Specific Rule (should be used)",
									Flow:  &v1pb.ApprovalFlow{Roles: []string{"roles/workspaceOwner"}},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.NoError(err)

	// Create sheet with DDL statement
	sheet, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: ctl.project.Name,
		Sheet: &v1pb.Sheet{
			Content: []byte("CREATE TABLE priority_test (id INTEGER PRIMARY KEY);"),
		},
	}))
	a.NoError(err)

	// Create plan
	planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
		Parent: ctl.project.Name,
		Plan: &v1pb.Plan{
			Title: "Test Priority Plan",
			Specs: []*v1pb.Plan_Spec{{
				Id: uuid.NewString(),
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName)},
						Sheet:   sheet.Msg.Name,
					},
				},
			}},
		},
	}))
	a.NoError(err)

	// Create issue
	issueResp, err := ctl.issueServiceClient.CreateIssue(ctx, connect.NewRequest(&v1pb.CreateIssueRequest{
		Parent: ctl.project.Name,
		Issue: &v1pb.Issue{
			Title:       "Test Issue for Priority",
			Type:        v1pb.Issue_DATABASE_CHANGE,
			Description: "Testing source-specific priority over fallback",
			Plan:        planResp.Msg.Name,
		},
	}))
	a.NoError(err)

	// Wait for approval finding to complete
	var issue *v1pb.Issue
	for i := 0; i < 5; i++ {
		if i > 0 {
			time.Sleep(3 * time.Second)
		}
		issueGetResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{
			Name: issueResp.Msg.Name,
		}))
		a.NoError(err)
		issue = issueGetResp.Msg
		if issue.ApprovalStatus != v1pb.ApprovalStatus_CHECKING {
			break
		}
	}

	// Verify source-specific rule was applied, NOT the fallback
	a.NotNil(issue)
	a.NotEqual(v1pb.ApprovalStatus_CHECKING, issue.ApprovalStatus)
	a.NotNil(issue.ApprovalTemplate)
	a.Equal("Source Specific Rule (should be used)", issue.GetApprovalTemplate().GetTitle(),
		"Source-specific rule should take priority over fallback even when fallback is first in list")
}

// TestSelfApprovalBlocked tests that when a project has allowSelfApproval disabled,
// the issue creator cannot approve or reject their own issue, but another eligible user can.
func TestSelfApprovalBlocked(t *testing.T) {
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startWorkspace(ctx, t)

	// Create a dedicated project (initially with self-approval enabled for database creation)
	projectID := generateRandomString("self-approval-test")
	projectResp, err := ctl.projectServiceClient.CreateProject(ctx, connect.NewRequest(&v1pb.CreateProjectRequest{
		Project: &v1pb.Project{
			Name:              fmt.Sprintf("projects/%s", projectID),
			Title:             projectID,
			AllowSelfApproval: true,
		},
		ProjectId: projectID,
	}))
	a.NoError(err)
	project := projectResp.Msg

	// Create instance
	pgContainer := sharedPgTarget(t)
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: generateRandomString("inst"),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Prod Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/prod"),
			Activation:    true,
			DataSources:   []*v1pb.DataSource{pgContainer.adminDataSource()},
		},
	}))
	a.NoError(err)

	// Create database in the dedicated project
	dbName := generateRandomString("db")
	err = ctl.createDatabase(ctx, project, instanceResp.Msg, nil, dbName, "")
	a.NoError(err)

	// Now disable self-approval for the test
	_, err = ctl.projectServiceClient.UpdateProject(ctx, connect.NewRequest(&v1pb.UpdateProjectRequest{
		Project: &v1pb.Project{
			Name:              project.Name,
			AllowSelfApproval: false,
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"allow_self_approval"}},
	}))
	a.NoError(err)

	// Create approval rule requiring projectOwner for this project
	_, err = ctl.settingServiceClient.UpdateSetting(ctx, connect.NewRequest(&v1pb.UpdateSettingRequest{
		AllowMissing: true,
		Setting: &v1pb.Setting{
			Name: "settings/WORKSPACE_APPROVAL",
			Value: &v1pb.SettingValue{
				Value: &v1pb.SettingValue_WorkspaceApproval{
					WorkspaceApproval: &v1pb.WorkspaceApprovalSetting{
						Rules: []*v1pb.WorkspaceApprovalSetting_Rule{
							{
								Source: v1pb.WorkspaceApprovalSetting_Rule_SOURCE_UNSPECIFIED,
								Condition: &expr.Expr{
									Expression: fmt.Sprintf(`resource.project_id == "%s"`, projectID),
								},
								Template: &v1pb.ApprovalTemplate{
									Title: "Project Owner Approval",
									Flow: &v1pb.ApprovalFlow{
										Roles: []string{"roles/projectOwner"},
									},
								},
							},
						},
					},
				},
			},
		},
	}))
	a.NoError(err)

	// [email protected] creates the issue (already has projectOwner role as project creator)
	sheet, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
		Parent: project.Name,
		Sheet: &v1pb.Sheet{
			Content: []byte("CREATE TABLE self_approval_test (id INTEGER PRIMARY KEY);"),
		},
	}))
	a.NoError(err)

	planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{
		Parent: project.Name,
		Plan: &v1pb.Plan{
			Title: "Self Approval Test Plan",
			Specs: []*v1pb.Plan_Spec{{
				Id: uuid.NewString(),
				Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{
						Targets: []string{fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName)},
						Sheet:   sheet.Msg.Name,
					},
				},
			}},
		},
	}))
	a.NoError(err)

	issueResp, err := ctl.issueServiceClient.CreateIssue(ctx, connect.NewRequest(&v1pb.CreateIssueRequest{
		Parent: project.Name,
		Issue: &v1pb.Issue{
			Title:       "Self Approval Test Issue",
			Type:        v1pb.Issue_DATABASE_CHANGE,
			Description: "Testing self-approval is blocked",
			Plan:        planResp.Msg.Name,
		},
	}))
	a.NoError(err)

	// Wait for approval finding to complete
	var issue *v1pb.Issue
	for i := 0; i < 5; i++ {
		if i > 0 {
			time.Sleep(3 * time.Second)
		}
		issueGetResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{
			Name: issueResp.Msg.Name,
		}))
		a.NoError(err)
		issue = issueGetResp.Msg
		if issue.ApprovalStatus != v1pb.ApprovalStatus_CHECKING {
			break
		}
	}
	a.NotNil(issue)
	a.Equal(v1pb.ApprovalStatus_PENDING, issue.ApprovalStatus)

	// Try to approve as creator (should fail due to self-approval restriction)
	_, err = ctl.issueServiceClient.ApproveIssue(ctx, connect.NewRequest(&v1pb.ApproveIssueRequest{
		Name: issue.Name,
	}))
	a.Error(err, "Self-approval should be blocked")
	a.Equal(connect.CodePermissionDenied, connect.CodeOf(err))

	// Try to reject as creator (should fail due to self-approval restriction)
	_, err = ctl.issueServiceClient.RejectIssue(ctx, connect.NewRequest(&v1pb.RejectIssueRequest{
		Name: issue.Name,
	}))
	a.Error(err, "Self-reject should be blocked")
	a.Equal(connect.CodePermissionDenied, connect.CodeOf(err))

	// Create another project owner who can approve
	approverEmail := fmt.Sprintf("approver-%s@example.com", projectID)
	approverPassword := "1024bytebase"
	newUser, err := ctl.userServiceClient.CreateUser(ctx, connect.NewRequest(&v1pb.CreateUserRequest{
		User: &v1pb.User{
			Email:    approverEmail,
			Password: approverPassword,
			Title:    "Approver",
		},
	}))
	a.NoError(err)

	// Add to workspace IAM so the user can login.
	_, err = ctl.addMemberToWorkspaceIAM(ctx, newUser.Msg.Workspace, fmt.Sprintf("user:%s", approverEmail), "roles/workspaceMember")
	a.NoError(err)

	// Grant approver projectOwner role via project IAM
	approverPolicyResp, err := ctl.projectServiceClient.GetIamPolicy(ctx, connect.NewRequest(&v1pb.GetIamPolicyRequest{
		Resource: project.Name,
	}))
	a.NoError(err)
	approverPolicy := approverPolicyResp.Msg
	approverPolicy.Bindings = append(approverPolicy.Bindings, &v1pb.Binding{
		Role:    "roles/projectOwner",
		Members: []string{fmt.Sprintf("user:%s", approverEmail)},
	})
	_, err = ctl.projectServiceClient.SetIamPolicy(ctx, connect.NewRequest(&v1pb.SetIamPolicyRequest{
		Resource: project.Name,
		Policy:   approverPolicy,
	}))
	a.NoError(err)

	// Login as approver
	loginResp, err := ctl.authServiceClient.Login(ctx, connect.NewRequest(&v1pb.LoginRequest{
		Email:    approverEmail,
		Password: approverPassword,
	}))
	a.NoError(err)
	ctl.authInterceptor.token = loginResp.Msg.Token

	// Approve as different user (should succeed)
	_, err = ctl.issueServiceClient.ApproveIssue(ctx, connect.NewRequest(&v1pb.ApproveIssueRequest{
		Name: issue.Name,
	}))
	a.NoError(err, "Approval by different user should succeed")

	// Verify the issue is now approved
	issueGetResp, err := ctl.issueServiceClient.GetIssue(ctx, connect.NewRequest(&v1pb.GetIssueRequest{
		Name: issue.Name,
	}))
	a.NoError(err)
	a.Equal(v1pb.ApprovalStatus_APPROVED, issueGetResp.Msg.ApprovalStatus)
}