Skip to content

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

55.3 KB
Raw Blame
package tests

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"testing"
	"time"

	"connectrpc.com/connect"
	"github.com/stretchr/testify/require"
	"google.golang.org/genproto/googleapis/type/expr"

	"github.com/bytebase/bytebase/action/command"
	"github.com/bytebase/bytebase/action/world"
	v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
)

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

	// Create test instance and database
	database := ctl.createTestDatabase(ctx, t)

	// Create test data directory
	testDataDir := t.TempDir()
	validMigrationsDir := filepath.Join(testDataDir, "valid-migrations")
	err := os.MkdirAll(validMigrationsDir, 0755)
	a.NoError(err)

	// Create a valid migration file
	migrationContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	err = os.WriteFile(filepath.Join(validMigrationsDir, "00001_create_users.sql"), []byte(migrationContent), 0644)
	a.NoError(err)

	// Execute check command using backend test credentials
	result, err := executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", filepath.Join(validMigrationsDir, "*.sql"),
		"--check-release", "FAIL_ON_ERROR",
	)

	a.NoError(err, "Check command should succeed for valid migrations")

	// E2E Verification for check command:
	// The key expectation is that check validates files without modifying target databases

	// Verify database was NOT modified (this is the critical check)
	// Query database to ensure no tables were created
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)
	// Verify no user tables exist
	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			a.NotEqual("users", table.Name, "Check command should not create tables")
		}
	}

	// 4. Verify command succeeded with proper exit code
	a.Contains(result.Stdout, "", "Check should complete without errors")
}

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

	// Create test instance and database
	database := ctl.createTestDatabase(ctx, t)

	databaseGroup, err := ctl.databaseGroupServiceClient.CreateDatabaseGroup(ctx, connect.NewRequest(&v1pb.CreateDatabaseGroupRequest{
		Parent:          ctl.project.Name,
		DatabaseGroupId: "test-database-group",
		DatabaseGroup: &v1pb.DatabaseGroup{
			Title:        "test database group",
			DatabaseExpr: &expr.Expr{Expression: "true"},
		},
	}))
	a.NoError(err)

	// Create test data directory
	testDataDir := t.TempDir()
	validMigrationsDir := filepath.Join(testDataDir, "valid-migrations")
	err = os.MkdirAll(validMigrationsDir, 0755)
	a.NoError(err)

	// Create a valid migration file
	migrationContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	err = os.WriteFile(filepath.Join(validMigrationsDir, "00001_create_users.sql"), []byte(migrationContent), 0644)
	a.NoError(err)

	// Execute check command using backend test credentials
	result, err := executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", databaseGroup.Msg.Name,
		"--file-pattern", filepath.Join(validMigrationsDir, "*.sql"),
		"--check-release", "FAIL_ON_ERROR",
	)

	a.NoError(err, "Check command should succeed for valid migrations")

	// E2E Verification for check command:
	// The key expectation is that check validates files without modifying target databases

	// Verify database was NOT modified (this is the critical check)
	// Query database to ensure no tables were created
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)
	// Verify no user tables exist
	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			a.NotEqual("users", table.Name, "Check command should not create tables")
		}
	}

	// 4. Verify command succeeded with proper exit code
	a.Contains(result.Stdout, "", "Check should complete without errors")
}

func TestActionCheckCommand_PolicyViolations(t *testing.T) {
	t.Skip("Skipping policy violations test - SQL review policies not configured in test environment")
}

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

	// Create test database
	database := ctl.createTestDatabase(ctx, t)

	// Create test data directory with syntax error migration
	testDataDir := t.TempDir()
	err := os.MkdirAll(testDataDir, 0755)
	a.NoError(err)

	// Create a migration file with obvious syntax errors
	migrationContent := `INVALID SQL SYNTAX THIS IS NOT VALID SQL AT ALL!!!`
	err = os.WriteFile(filepath.Join(testDataDir, "00001_syntax_error.sql"), []byte(migrationContent), 0644)
	a.NoError(err)

	// Execute check with file that has syntax errors
	_, err = executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", filepath.Join(testDataDir, "00001_syntax_error.sql"),
		"--check-release", "FAIL_ON_ERROR",
	)

	// Postgres parses the statement, so the release check reports the syntax
	// error and FAIL_ON_ERROR makes the command exit with an error.
	a.Error(err)
	a.Contains(err.Error(), "error(s) in release check")

	// Verify NO database changes occurred
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)
	// Ensure no tables were created
	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			a.NotEqual("invalid", table.Name, "Check should not create tables with syntax errors")
		}
	}
}

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

	// Create multiple test databases
	database1 := ctl.createTestDatabase(ctx, t)
	database2 := ctl.createTestDatabase(ctx, t)

	// Create test data directory
	testDataDir := t.TempDir()
	err := os.MkdirAll(testDataDir, 0755)
	a.NoError(err)

	// Create a valid migration file
	migrationContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    email VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	err = os.WriteFile(filepath.Join(testDataDir, "00001_create_users.sql"), []byte(migrationContent), 0644)
	a.NoError(err)

	// Execute check command with multiple targets
	result, err := executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", fmt.Sprintf("%s,%s", database1.Name, database2.Name),
		"--file-pattern", filepath.Join(testDataDir, "00001_create_users.sql"),
		"--check-release", "FAIL_ON_ERROR",
	)

	a.NoError(err, "Check command should succeed for multiple valid targets")

	// E2E Verification for check command with multiple targets:
	// The check should validate all targets without modifying any databases

	// Verify both databases were NOT modified
	for _, db := range []*v1pb.Database{database1, database2} {
		metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
			Name: db.Name + "/metadata",
		}))
		a.NoError(err)
		// Verify no user tables exist
		for _, schema := range metadata.Msg.Schemas {
			for _, table := range schema.Tables {
				a.NotEqual("users", table.Name, "Check command should not create tables")
			}
		}
	}

	// 4. Verify command succeeded
	a.NotContains(result.Stderr, "error", "Check should complete without errors")
}

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

	// Create PostgreSQL test database
	database := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create test data directory and schema.sql file
	testDataDir := t.TempDir()
	schemaContent := `CREATE TABLE public.users (
    id SERIAL NOT NULL,
    username VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT pk_users PRIMARY KEY (id),
    CONSTRAINT uk_users_username UNIQUE (username)
);`
	schemaFile := filepath.Join(testDataDir, "schema.sql")
	err := os.WriteFile(schemaFile, []byte(schemaContent), 0644)
	a.NoError(err)

	// Execute declarative check command
	_, err = executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", schemaFile,
		"--check-release", "FAIL_ON_ERROR",
		"--declarative",
	)

	a.NoError(err, "Declarative check command should succeed for valid schema")
}

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

	// Create PostgreSQL test database
	database := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create test data directory with multiple SQL files
	testDataDir := t.TempDir()

	// Create users.sql
	usersContent := `CREATE TABLE public.users (
    id SERIAL NOT NULL,
    username VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    CONSTRAINT pk_users PRIMARY KEY (id),
    CONSTRAINT uk_users_username UNIQUE (username)
);`
	usersFile := filepath.Join(testDataDir, "users.sql")
	err := os.WriteFile(usersFile, []byte(usersContent), 0644)
	a.NoError(err)

	// Create products.sql
	productsContent := `CREATE TABLE public.products (
    id SERIAL NOT NULL,
    name VARCHAR(255) NOT NULL,
    price DECIMAL(10,2),
    CONSTRAINT pk_products PRIMARY KEY (id)
);`
	productsFile := filepath.Join(testDataDir, "products.sql")
	err = os.WriteFile(productsFile, []byte(productsContent), 0644)
	a.NoError(err)

	// Execute declarative check command with multiple files
	_, err = executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", filepath.Join(testDataDir, "*.sql"),
		"--check-release", "FAIL_ON_ERROR",
		"--declarative",
	)

	a.NoError(err, "Declarative check command should succeed with multiple files")
}

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

	// Keeps MySQL. Porting this to Postgres was tried and reverted: the
	// declarative release check returns three errors against the same schema
	// on Postgres, so the engine changes the result here rather than being
	// incidental, and what those errors are is its own question.
	_, mysqlContainer := ctl.createTestMySQLDatabase(ctx, t)
	defer mysqlContainer.Close(ctx)

	// Create database group
	databaseGroup, err := ctl.databaseGroupServiceClient.CreateDatabaseGroup(ctx, connect.NewRequest(&v1pb.CreateDatabaseGroupRequest{
		Parent:          ctl.project.Name,
		DatabaseGroupId: "test-declarative-check-group",
		DatabaseGroup: &v1pb.DatabaseGroup{
			Title:        "Test Declarative Check Group",
			DatabaseExpr: &expr.Expr{Expression: "true"},
		},
	}))
	a.NoError(err)

	// Create test data directory and schema.sql file
	testDataDir := t.TempDir()
	schemaContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(255) NOT NULL UNIQUE,
    email VARCHAR(255)
);`
	schemaFile := filepath.Join(testDataDir, "schema.sql")
	err = os.WriteFile(schemaFile, []byte(schemaContent), 0644)
	a.NoError(err)

	// Execute declarative check command with database group
	_, err = executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", databaseGroup.Msg.Name,
		"--file-pattern", schemaFile,
		"--check-release", "FAIL_ON_ERROR",
		"--declarative",
	)

	a.NoError(err, "Declarative check command should succeed with database group")
}

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

	// Create PostgreSQL test database
	database := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create test data directory with invalid SQL
	testDataDir := t.TempDir()
	invalidSchemaContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(255) NOT NULL UNIQUE
    email VARCHAR(255)  -- Missing comma after previous column
);`
	schemaFile := filepath.Join(testDataDir, "schema.sql")
	err := os.WriteFile(schemaFile, []byte(invalidSchemaContent), 0644)
	a.NoError(err)

	// Execute declarative check command with syntax error
	_, err = executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", schemaFile,
		"--check-release", "FAIL_ON_ERROR",
		"--declarative",
	)

	// The command may complete but should report the syntax issue
	a.Error(err, "should error")
	a.Contains(err.Error(), "found 1 error(s) in release check. view on Bytebase")
}

// ActionResult holds the result of executing an action command
type ActionResult struct {
	Stdout     string
	Stderr     string
	Error      error
	OutputJSON map[string]any // Parsed from --output file
}

// executeActionCommand executes the bytebase-action cobra command with given arguments
func executeActionCommand(ctx context.Context, args ...string) (*ActionResult, error) {
	// Create new world instance for test isolation
	w := world.NewWorld()
	w.Platform = world.LocalPlatform
	// The release default of 5 s between rollout status polls was most of
	// these tests' time; a rollout here finishes in well under a second.
	w.RolloutPollInterval = 300 * time.Millisecond

	// Create new command instance using the factory function
	cmd := command.NewRootCommand(w)

	// Set up output buffers
	stdout := new(bytes.Buffer)
	stderr := new(bytes.Buffer)
	cmd.SetOut(stdout)
	cmd.SetErr(stderr)

	// Set arguments
	cmd.SetArgs(args)

	// Execute command
	err := cmd.ExecuteContext(ctx)

	// Get output from world.OutputMap
	outputJSON := make(map[string]any)
	if j, err := json.Marshal(w.OutputMap); err == nil {
		if err := json.Unmarshal(j, &outputJSON); err != nil {
			return nil, err
		}
	}

	// Also parse output file if specified
	if w.Output != "" {
		if data, readErr := os.ReadFile(w.Output); readErr == nil {
			var fileOutput map[string]any
			if json.Unmarshal(data, &fileOutput) == nil {
				for k, v := range fileOutput {
					outputJSON[k] = v
				}
			}
		}
	}

	return &ActionResult{
		Stdout:     stdout.String(),
		Stderr:     stderr.String(),
		Error:      err,
		OutputJSON: outputJSON,
	}, err
}

// createTestDatabase creates a test Postgres database instance and database
func (ctl *controller) createTestDatabase(ctx context.Context, t *testing.T) *v1pb.Database {
	a := require.New(t)

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

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

	// Get database
	databaseResp, err := ctl.databaseServiceClient.GetDatabase(ctx, connect.NewRequest(&v1pb.GetDatabaseRequest{
		Name: fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName),
	}))
	a.NoError(err)

	return databaseResp.Msg
}

// createTestMySQLDatabase creates a test MySQL database instance and database
func (ctl *controller) createTestMySQLDatabase(ctx context.Context, t *testing.T) (*v1pb.Database, *Container) {
	a := require.New(t)

	// Get MySQL container
	mysqlContainer := provisionMySQLInstance(t)

	// Create MySQL instance
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: shortInstanceID(),
		Instance: &v1pb.Instance{
			Title:       "Test MySQL Instance",
			Engine:      v1pb.Engine_MYSQL,
			Environment: new("environments/prod"),
			Activation:  true,
			DataSources: []*v1pb.DataSource{{
				Type:     v1pb.DataSourceType_ADMIN,
				Host:     mysqlContainer.GetHost(),
				Port:     mysqlContainer.GetPort(),
				Username: "root",
				Password: "root-password",
				Id:       "admin",
			}},
		},
	}))
	a.NoError(err)

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

	// Get database
	databaseResp, err := ctl.databaseServiceClient.GetDatabase(ctx, connect.NewRequest(&v1pb.GetDatabaseRequest{
		Name: fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName),
	}))
	a.NoError(err)

	return databaseResp.Msg, mysqlContainer
}

// createTestPostgreSQLDatabase creates a test PostgreSQL database instance and database
func (ctl *controller) createTestPostgreSQLDatabase(ctx context.Context, t *testing.T) *v1pb.Database {
	a := require.New(t)

	// Get PostgreSQL container
	pgContainer := sharedPgTarget(t)

	// Create PostgreSQL instance
	instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{
		InstanceId: shortInstanceID(),
		Instance: &v1pb.Instance{
			SyncDatabases: &v1pb.SyncDatabases{},
			Title:         "Test PostgreSQL Instance",
			Engine:        v1pb.Engine_POSTGRES,
			Environment:   new("environments/prod"),
			Activation:    true,
			DataSources: []*v1pb.DataSource{{
				Type:     v1pb.DataSourceType_ADMIN,
				Host:     pgContainer.GetHost(),
				Port:     pgContainer.GetPort(),
				Username: "postgres",
				Password: "root-password",
				Id:       "admin",
			}},
		},
	}))
	a.NoError(err)

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

	// Get database
	databaseResp, err := ctl.databaseServiceClient.GetDatabase(ctx, connect.NewRequest(&v1pb.GetDatabaseRequest{
		Name: fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName),
	}))
	a.NoError(err)

	return databaseResp.Msg
}

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

	// Create test database
	database := ctl.createTestDatabase(ctx, t)

	// Create test data directory and migration file
	testDataDir := t.TempDir()
	migrationContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	migrationFile := filepath.Join(testDataDir, "00001_create_users.sql")
	err := os.WriteFile(migrationFile, []byte(migrationContent), 0644)
	a.NoError(err)

	// Create output file
	outputFile := filepath.Join(t.TempDir(), "rollout-output.json")

	// Execute rollout
	result, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", migrationFile,
		"--target-stage", "environments/prod",
		"--output", outputFile,
	)

	a.NoError(err, "Rollout command should succeed")

	// E2E Verification: Check server state for complete rollout lifecycle

	// 1. Verify plan was created
	plans, err := ctl.planServiceClient.ListPlans(ctx, connect.NewRequest(&v1pb.ListPlansRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.NotEmpty(plans.Msg.Plans, "Expected plan to be created")
	plan := plans.Msg.Plans[0]

	// 2. Verify release was created with correct title
	releases, err := ctl.releaseServiceClient.ListReleases(ctx, connect.NewRequest(&v1pb.ListReleasesRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.Len(releases.Msg.Releases, 1, "Expected exactly one release")
	release := releases.Msg.Releases[0]

	// 3. Verify rollout was created and completed
	rollouts, err := ctl.rolloutServiceClient.ListRollouts(ctx, connect.NewRequest(&v1pb.ListRolloutsRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.NotEmpty(rollouts.Msg.Rollouts, "Expected rollout to be created")
	rollout := rollouts.Msg.Rollouts[0]
	a.Equal(rollout.Name, result.OutputJSON["rollout"])

	// Verify rollout completed by checking all task statuses
	for _, stage := range rollout.Stages {
		for _, task := range stage.Tasks {
			a.True(task.Status == v1pb.Task_DONE || task.Status == v1pb.Task_SKIPPED,
				"Task %s should be completed (DONE or SKIPPED), got %s", task.Name, task.Status.String())
		}
	}

	// 4. Verify database schema was actually changed
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)
	// Find the users table in metadata if schema sync worked
	foundUsersTable := false
	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			if table.Name == "users" {
				foundUsersTable = true
				// Verify table structure
				a.GreaterOrEqual(len(table.Columns), 2, "Expected at least 2 columns")
			}
		}
	}
	a.True(foundUsersTable, "Users table not found in metadata, but rollout completed successfully")

	// 5. Verify database revision was updated
	updatedDatabase, err := ctl.databaseServiceClient.GetDatabase(ctx, connect.NewRequest(&v1pb.GetDatabaseRequest{
		Name: database.Name,
	}))
	a.NoError(err)
	a.NotEmpty(updatedDatabase.Msg.Release, "Database release not set, but rollout completed successfully")
	a.Equal(release.Name, updatedDatabase.Msg.Release, "Database release should match the applied release")

	// 6. Verify change history was recorded
	changelogs, err := ctl.changelogServiceClient.ListChangelogs(ctx, connect.NewRequest(&v1pb.ListChangelogsRequest{
		Parent: database.Name,
	}))
	a.NoError(err)
	a.NotEmpty(changelogs.Msg.Changelogs, "No change history found, but rollout completed successfully")

	revisions, err := ctl.revisionServiceClient.ListRevisions(ctx, connect.NewRequest(&v1pb.ListRevisionsRequest{
		Parent: database.Name,
	}))
	a.NoError(err)
	a.NotEmpty(revisions.Msg.Revisions, "No revision found, but rollout completed successfully")
	a.Len(revisions.Msg.Revisions, 1, "Expected exactly one revision")
	revision := revisions.Msg.Revisions[0]
	a.Equal("00001", revision.Version)

	// 7. Verify output file contains server resource names
	var output map[string]string
	data, err := os.ReadFile(outputFile)
	a.NoError(err)
	err = json.Unmarshal(data, &output)
	a.NoError(err)

	a.Equal(release.Name, output["release"], "Output should contain actual release name")
	a.Equal(plan.Name, output["plan"], "Output should contain actual plan name")
	a.Equal(rollout.Name, output["rollout"], "Output should contain actual rollout name")

	// 8. Verify command output
	a.NotContains(result.Stderr, "error", "Rollout should complete without errors")
}

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

	// Create test database
	database := ctl.createTestDatabase(ctx, t)

	// Create test data directory and multiple migration files
	testDataDir := t.TempDir()

	// Create 00001_create_users.sql
	migrationContent1 := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	err := os.WriteFile(filepath.Join(testDataDir, "00001_create_users.sql"), []byte(migrationContent1), 0644)
	a.NoError(err)

	// Create 00002_add_email.sql
	migrationContent2 := `ALTER TABLE users ADD COLUMN email TEXT;`
	err = os.WriteFile(filepath.Join(testDataDir, "00002_add_email.sql"), []byte(migrationContent2), 0644)
	a.NoError(err)

	// Create 00003_create_index.sql
	migrationContent3 := `CREATE INDEX idx_users_username ON users(username);`
	err = os.WriteFile(filepath.Join(testDataDir, "00003_create_index.sql"), []byte(migrationContent3), 0644)
	a.NoError(err)

	// Create output file
	outputFile := filepath.Join(t.TempDir(), "rollout-output.json")

	// Execute rollout with multiple migration files
	result, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", filepath.Join(testDataDir, "0000*.sql"),
		"--target-stage", "environments/prod",
		"--output", outputFile,
	)

	a.NoError(err, "Rollout command should succeed with multiple files")

	// E2E Verification: Check server state for complete rollout lifecycle

	// 1. Verify plan was created
	plans, err := ctl.planServiceClient.ListPlans(ctx, connect.NewRequest(&v1pb.ListPlansRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.NotEmpty(plans.Msg.Plans, "Expected plan to be created")
	plan := plans.Msg.Plans[0]

	// 2. Verify release was created with correct title
	releases, err := ctl.releaseServiceClient.ListReleases(ctx, connect.NewRequest(&v1pb.ListReleasesRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.Len(releases.Msg.Releases, 1, "Expected exactly one release")
	release := releases.Msg.Releases[0]

	// Verify release files
	a.Len(release.Files, 3, "Expected exactly 3 files in release")
	// Verify each file has correct version and path
	for _, f := range release.Files {
		a.Contains(f.Path, f.Version, "File path %s should contain version %s", f.Path, f.Version)
	}
	// Verify specific files exist
	fileVersions := make(map[string]string)
	for _, f := range release.Files {
		fileVersions[f.Version] = f.Path
	}
	a.Contains(fileVersions, "00001", "Should have file with version 00001")
	a.Contains(fileVersions["00001"], "00001_create_users.sql", "File 00001 should be create_users")
	a.Contains(fileVersions, "00002", "Should have file with version 00002")
	a.Contains(fileVersions["00002"], "00002_add_email.sql", "File 00002 should be add_email")
	a.Contains(fileVersions, "00003", "Should have file with version 00003")
	a.Contains(fileVersions["00003"], "00003_create_index.sql", "File 00003 should be create_index")

	// Verify release file contents match original files
	expectedContents := map[string]string{
		"00001": migrationContent1,
		"00002": migrationContent2,
		"00003": migrationContent3,
	}
	for _, f := range release.Files {
		a.NotEmpty(f.Sheet, "File %s should have a sheet", f.Path)
		sheet, err := ctl.sheetServiceClient.GetSheet(ctx, connect.NewRequest(&v1pb.GetSheetRequest{
			Name: f.Sheet,
			Raw:  true,
		}))
		a.NoError(err)
		expectedContent, ok := expectedContents[f.Version]
		a.True(ok, "Unexpected version %s", f.Version)
		a.Equal(expectedContent, string(sheet.Msg.Content), "File %s content should match original", f.Path)
	}

	// 3. Verify rollout was created and completed
	rollouts, err := ctl.rolloutServiceClient.ListRollouts(ctx, connect.NewRequest(&v1pb.ListRolloutsRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.NotEmpty(rollouts.Msg.Rollouts, "Expected rollout to be created")
	rollout := rollouts.Msg.Rollouts[0]
	a.Equal(rollout.Name, result.OutputJSON["rollout"])

	// Verify rollout completed by checking all task statuses
	for _, stage := range rollout.Stages {
		for _, task := range stage.Tasks {
			a.True(task.Status == v1pb.Task_DONE || task.Status == v1pb.Task_SKIPPED,
				"Task %s should be completed (DONE or SKIPPED), got %s", task.Name, task.Status.String())
		}
	}

	// 4. Verify database schema was actually changed
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)

	// Check for users table (from 00001_create_users.sql)
	foundUsersTable := false
	foundEmailColumn := false
	foundUsernameIndex := false

	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			if table.Name == "users" {
				foundUsersTable = true
				// Check for email column (from 00002_add_email.sql)
				for _, col := range table.Columns {
					if col.Name == "email" {
						foundEmailColumn = true
					}
				}
				// Check for index (from 00003_create_index.sql)
				for _, index := range table.Indexes {
					if index.Name == "idx_users_username" {
						foundUsernameIndex = true
					}
				}
			}
		}
	}

	a.True(foundUsersTable, "Users table should exist after rollout")
	a.True(foundEmailColumn, "Email column should exist after rollout")
	a.True(foundUsernameIndex, "Username index should exist after rollout")

	// 5. Verify database revision was updated
	updatedDatabase, err := ctl.databaseServiceClient.GetDatabase(ctx, connect.NewRequest(&v1pb.GetDatabaseRequest{
		Name: database.Name,
	}))
	a.NoError(err)
	a.NotEmpty(updatedDatabase.Msg.Release, "Database release not set, but rollout completed successfully")
	a.Equal(release.Name, updatedDatabase.Msg.Release, "Database release should match the applied release")

	// 6. Verify change history was recorded
	// Note: Versioned releases create one MIGRATE changelog for the entire release (not per file)
	// Plus a BASELINE changelog if this is the first migration for the database
	changelogs, err := ctl.changelogServiceClient.ListChangelogs(ctx, connect.NewRequest(&v1pb.ListChangelogsRequest{
		Parent: database.Name,
	}))
	a.NoError(err)
	// Expect at least 1 changelog for the versioned release
	a.GreaterOrEqual(len(changelogs.Msg.Changelogs), 1, "Expected at least 1 changelog for the versioned release")

	revisions, err := ctl.revisionServiceClient.ListRevisions(ctx, connect.NewRequest(&v1pb.ListRevisionsRequest{
		Parent: database.Name,
	}))
	a.NoError(err)
	a.NotEmpty(revisions.Msg.Revisions, "No revision found, but rollout completed successfully")
	a.Len(revisions.Msg.Revisions, 3, "Expected exactly three revisions")
	// Check last revision version. Revisions are ordered by version desc
	lastRevision := revisions.Msg.Revisions[0]
	a.Equal("00003", lastRevision.Version)

	// 7. Verify output file contains server resource names
	var output map[string]string
	data, err := os.ReadFile(outputFile)
	a.NoError(err)
	err = json.Unmarshal(data, &output)
	a.NoError(err)

	a.Equal(release.Name, output["release"], "Output should contain actual release name")
	a.Equal(plan.Name, output["plan"], "Output should contain actual plan name")
	a.Equal(rollout.Name, output["rollout"], "Output should contain actual rollout name")

	// 8. Verify command output
	a.NotContains(result.Stderr, "error", "Multi-file rollout should complete without errors")
}

func TestActionRolloutCommand_FileContentVersionMatch(t *testing.T) {
	// This test verifies that file content matches the correct version
	// when lexicographical order differs from version order
	t.Parallel()
	a := require.New(t)
	ctx := context.Background()
	ctl, ctx := startProject(ctx, t)

	// Create test database
	database := ctl.createTestDatabase(ctx, t)

	// Create test data directory with files where lex order != version order
	testDataDir := t.TempDir()

	// Lexicographical order: v1, v10, v2
	// Version numeric order: 1, 2, 10
	migrationContent1 := `CREATE TABLE first_table (id INTEGER);`
	migrationContent2 := `CREATE TABLE second_table (id INTEGER);`
	migrationContent10 := `CREATE TABLE tenth_table (id INTEGER);`

	err := os.WriteFile(filepath.Join(testDataDir, "v1_first.sql"), []byte(migrationContent1), 0644)
	a.NoError(err)
	err = os.WriteFile(filepath.Join(testDataDir, "v2_second.sql"), []byte(migrationContent2), 0644)
	a.NoError(err)
	err = os.WriteFile(filepath.Join(testDataDir, "v10_tenth.sql"), []byte(migrationContent10), 0644)
	a.NoError(err)

	// Execute rollout
	_, err = executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", filepath.Join(testDataDir, "v*.sql"),
		"--target-stage", "environments/prod",
	)
	a.NoError(err, "Rollout command should succeed")

	// Verify release files have correct content for each version
	releases, err := ctl.releaseServiceClient.ListReleases(ctx, connect.NewRequest(&v1pb.ListReleasesRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.Len(releases.Msg.Releases, 1, "Expected exactly one release")
	release := releases.Msg.Releases[0]
	a.Len(release.Files, 3, "Expected exactly 3 files in release")

	// Build expected content map by version
	expectedContents := map[string]string{
		"1":  migrationContent1,
		"2":  migrationContent2,
		"10": migrationContent10,
	}

	// Verify each file's content matches its version
	for _, f := range release.Files {
		a.NotEmpty(f.Sheet, "File %s should have a sheet", f.Path)
		sheet, err := ctl.sheetServiceClient.GetSheet(ctx, connect.NewRequest(&v1pb.GetSheetRequest{
			Name: f.Sheet,
			Raw:  true,
		}))
		a.NoError(err)
		expectedContent, ok := expectedContents[f.Version]
		a.True(ok, "Unexpected version %s", f.Version)
		a.Equal(expectedContent, string(sheet.Msg.Content),
			"File %s with version %s should contain '%s' but got '%s'",
			f.Path, f.Version, expectedContent, string(sheet.Msg.Content))
	}
}

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

	// Create PostgreSQL test database
	database := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create test data directory and schema.sql file
	testDataDir := t.TempDir()
	migrationContent1 := `CREATE TABLE users (
    id SERIAL,
    username VARCHAR(255) NOT NULL UNIQUE
);`
	schemaFile := filepath.Join(testDataDir, "schema.sql")
	err := os.WriteFile(schemaFile, []byte(migrationContent1), 0644)
	a.NoError(err)

	// Create output file
	outputFile := filepath.Join(t.TempDir(), "rollout-output.json")

	// Execute declarative rollout
	result, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", schemaFile,
		"--target-stage", "environments/prod",
		"--output", outputFile,
		"--declarative",
	)

	a.NoError(err, "Declarative rollout command should succeed")

	// Verify release was created
	releases, err := ctl.releaseServiceClient.ListReleases(ctx, connect.NewRequest(&v1pb.ListReleasesRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.Len(releases.Msg.Releases, 1, "Expected exactly one release")

	// Verify database schema was created
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)
	foundUsersTable := false
	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			if table.Name == "users" {
				foundUsersTable = true
				a.Equal(2, len(table.Columns), "Expected 2 columns (id, username)")
			}
		}
	}
	a.True(foundUsersTable, "Users table should exist after declarative rollout")

	// Verify command output
	a.NotContains(result.Stderr, "error", "Declarative rollout should complete without errors")
}

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

	// Create PostgreSQL test database
	database := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create test data directory
	testDataDir := t.TempDir()
	schemaFile := filepath.Join(testDataDir, "schema.sql")

	// First version of schema
	migrationContent1 := `CREATE TABLE users (
    id SERIAL,
    username VARCHAR(255) NOT NULL UNIQUE
);`
	err := os.WriteFile(schemaFile, []byte(migrationContent1), 0644)
	a.NoError(err)

	// Execute first declarative rollout
	result1, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", schemaFile,
		"--target-stage", "environments/prod",
		"--declarative",
	)
	a.NoError(err, "First declarative rollout should succeed")

	// Verify initial schema
	metadata1, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)
	foundTable1 := false
	for _, schema := range metadata1.Msg.Schemas {
		for _, table := range schema.Tables {
			if table.Name == "users" {
				foundTable1 = true
				a.Equal(2, len(table.Columns), "Initial schema should have 2 columns")
			}
		}
	}
	a.True(foundTable1, "Users table should exist after first rollout")

	// Update schema.sql with evolved schema (second version)
	migrationContent2 := `CREATE TABLE users (
    id SERIAL,
    username VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	err = os.WriteFile(schemaFile, []byte(migrationContent2), 0644)
	a.NoError(err)

	// Execute second declarative rollout with evolved schema
	result2, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", schemaFile,
		"--target-stage", "environments/prod",
		"--declarative",
	)
	a.NoError(err, "Second declarative rollout should succeed")

	// Verify evolved schema
	metadata2, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)
	foundTable2 := false
	hasCreatedAt := false
	for _, schema := range metadata2.Msg.Schemas {
		for _, table := range schema.Tables {
			if table.Name == "users" {
				foundTable2 = true
				a.Equal(3, len(table.Columns), "Evolved schema should have 3 columns")
				for _, col := range table.Columns {
					if col.Name == "created_at" {
						hasCreatedAt = true
					}
				}
			}
		}
	}
	a.True(foundTable2, "Users table should still exist after evolution")
	a.True(hasCreatedAt, "created_at column should be added")

	// Verify no errors
	a.NotContains(result1.Stderr, "error", "First rollout should complete without errors")
	a.NotContains(result2.Stderr, "error", "Second rollout should complete without errors")
}

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

	// Create PostgreSQL test database
	database := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create test data directory and schema.sql file
	testDataDir := t.TempDir()
	migrationContent := `CREATE TABLE users (
    id SERIAL,
    username VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	schemaFile := filepath.Join(testDataDir, "schema.sql")
	err := os.WriteFile(schemaFile, []byte(migrationContent), 0644)
	a.NoError(err)

	// Create output files
	outputFile1 := filepath.Join(t.TempDir(), "rollout-output1.json")
	outputFile2 := filepath.Join(t.TempDir(), "rollout-output2.json")
	outputFile3 := filepath.Join(t.TempDir(), "rollout-output3.json")

	// Execute first declarative rollout
	result1, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", schemaFile,
		"--target-stage", "environments/prod",
		"--output", outputFile1,
		"--declarative",
	)
	a.NoError(err, "First declarative rollout should succeed")

	// Read first output
	var output1 map[string]string
	data1, err := os.ReadFile(outputFile1)
	a.NoError(err)
	err = json.Unmarshal(data1, &output1)
	a.NoError(err)

	// Execute second declarative rollout with same schema (should succeed with task as no-op)
	result2, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", schemaFile,
		"--target-stage", "environments/prod",
		"--output", outputFile2,
		"--declarative",
	)
	// Second rollout should succeed (SDL diff detects no changes, executes as no-op)
	a.NoError(err, "Second declarative rollout should succeed")

	// Read second output
	var output2 map[string]string
	data2, err := os.ReadFile(outputFile2)
	a.NoError(err)
	err = json.Unmarshal(data2, &output2)
	a.NoError(err)

	// Rollout should be created for second execution
	rolloutName := output2["rollout"]
	a.NotEmpty(rolloutName, "Rollout should be created for second execution")

	// Execute third declarative rollout with same schema (should also succeed with task as no-op)
	result3, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", schemaFile,
		"--target-stage", "environments/prod",
		"--output", outputFile3,
		"--declarative",
	)
	// Third rollout should also succeed (SDL diff detects no changes, executes as no-op)
	a.NoError(err, "Third declarative rollout should succeed")

	// Read third output
	var output3 map[string]string
	data3, err := os.ReadFile(outputFile3)
	a.NoError(err)
	err = json.Unmarshal(data3, &output3)
	a.NoError(err)

	// Verify that each rollout creates a separate release (no deduplication)
	releases, err := ctl.releaseServiceClient.ListReleases(ctx, connect.NewRequest(&v1pb.ListReleasesRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.Len(releases.Msg.Releases, 3, "Should have three separate releases (no deduplication)")

	// Verify each rollout has its own release
	a.NotEqual(output1["release"], output2["release"], "Second rollout should create a new release")
	a.NotEqual(output1["release"], output3["release"], "Third rollout should create a new release")
	a.NotEqual(output2["release"], output3["release"], "Each rollout should have a unique release")

	// Verify schema remains consistent (only one table created)
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)

	tableCount := 0
	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			if table.Name == "users" {
				tableCount++
				a.Equal(3, len(table.Columns), "Table should have consistent columns")
			}
		}
	}
	a.Equal(1, tableCount, "Should have exactly one users table (idempotent)")

	// Verify all rollouts succeeded
	a.NotContains(result1.Stderr, "error", "first rollout should complete without errors")
	a.NotContains(result2.Stderr, "error", "second rollout should complete without errors")
	a.NotContains(result3.Stderr, "error", "third rollout should complete without errors")

	// Verify that second rollout has 1 task (idempotency handled by SDL diff at execution)
	rollout2, err := ctl.rolloutServiceClient.GetRollout(ctx, connect.NewRequest(&v1pb.GetRolloutRequest{
		Name: rolloutName,
	}))
	a.NoError(err)
	// Check that rollout has 1 task (executes as no-op when schema matches)
	totalTasks := 0
	for _, stage := range rollout2.Msg.Stages {
		totalTasks += len(stage.Tasks)
	}
	a.Equal(1, totalTasks, "Second rollout should have 1 task")
	a.Len(rollout2.Msg.Stages, 1, "Second rollout should have 1 stage")

	// Verify third rollout also has 1 task
	rolloutName3 := output3["rollout"]
	a.NotEmpty(rolloutName3, "Rollout should be created for third execution")

	rollout3, err := ctl.rolloutServiceClient.GetRollout(ctx, connect.NewRequest(&v1pb.GetRolloutRequest{
		Name: rolloutName3,
	}))
	a.NoError(err)
	// Check that rollout has 1 task (executes as no-op when schema matches)
	totalTasks = 0
	for _, stage := range rollout3.Msg.Stages {
		totalTasks += len(stage.Tasks)
	}
	a.Equal(1, totalTasks, "Third rollout should have 1 task")
	a.Len(rollout3.Msg.Stages, 1, "Third rollout should have 1 stage")
}

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

	// Create multiple PostgreSQL test databases
	database1 := ctl.createTestPostgreSQLDatabase(ctx, t)
	database2 := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create test data directory and schema.sql file
	testDataDir := t.TempDir()
	migrationContent := `CREATE TABLE users (
    id SERIAL,
    username VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	schemaFile := filepath.Join(testDataDir, "schema.sql")
	err := os.WriteFile(schemaFile, []byte(migrationContent), 0644)
	a.NoError(err)

	// Execute declarative rollout to multiple databases
	result, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", fmt.Sprintf("%s,%s", database1.Name, database2.Name),
		"--file-pattern", schemaFile,
		"--target-stage", "environments/prod",
		"--declarative",
	)
	a.NoError(err, "Declarative rollout to multiple databases should succeed")

	// Verify schema was applied to both databases
	for _, db := range []*v1pb.Database{database1, database2} {
		metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
			Name: db.Name + "/metadata",
		}))
		a.NoError(err)

		foundUsersTable := false
		for _, schema := range metadata.Msg.Schemas {
			for _, table := range schema.Tables {
				if table.Name == "users" {
					foundUsersTable = true
					a.Equal(3, len(table.Columns), "Table should have 3 columns in "+db.Name)
				}
			}
		}
		a.True(foundUsersTable, "Users table should exist in "+db.Name)
	}

	// Verify command output
	a.NotContains(result.Stderr, "error", "Multi-database declarative rollout should complete without errors")
}

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

	// Create PostgreSQL test database
	database := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create database group
	databaseGroup, err := ctl.databaseGroupServiceClient.CreateDatabaseGroup(ctx, connect.NewRequest(&v1pb.CreateDatabaseGroupRequest{
		Parent:          ctl.project.Name,
		DatabaseGroupId: "test-declarative-group",
		DatabaseGroup: &v1pb.DatabaseGroup{
			Title:        "Test Declarative Group",
			DatabaseExpr: &expr.Expr{Expression: "true"},
		},
	}))
	a.NoError(err)

	// Create test data directory and schema.sql file
	testDataDir := t.TempDir()
	migrationContent := `CREATE TABLE users (
    id SERIAL,
    username VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	schemaFile := filepath.Join(testDataDir, "schema.sql")
	err = os.WriteFile(schemaFile, []byte(migrationContent), 0644)
	a.NoError(err)

	// Execute declarative rollout with database group
	result, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", databaseGroup.Msg.Name,
		"--file-pattern", schemaFile,
		"--target-stage", "environments/prod",
		"--declarative",
	)
	a.NoError(err, "Declarative rollout with database group should succeed")

	// Verify schema was applied
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)

	foundUsersTable := false
	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			if table.Name == "users" {
				foundUsersTable = true
				a.Equal(3, len(table.Columns), "Table should have 3 columns")
			}
		}
	}
	a.True(foundUsersTable, "Users table should exist after declarative rollout with database group")

	// Verify command output
	a.NotContains(result.Stderr, "error", "Declarative rollout with database group should complete without errors")
}

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

	// Create PostgreSQL test database
	database := ctl.createTestPostgreSQLDatabase(ctx, t)

	// Create test data directory with multiple SQL files
	testDataDir := t.TempDir()

	// Create users.sql
	usersContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(255) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	usersFile := filepath.Join(testDataDir, "users.sql")
	err := os.WriteFile(usersFile, []byte(usersContent), 0644)
	a.NoError(err)

	// Create names.sql
	namesContent := `CREATE TABLE names (
    id SERIAL PRIMARY KEY,
    first_name VARCHAR(100) NOT NULL,
    last_name VARCHAR(100) NOT NULL
);`
	namesFile := filepath.Join(testDataDir, "names.sql")
	err = os.WriteFile(namesFile, []byte(namesContent), 0644)
	a.NoError(err)

	// Execute declarative rollout with multiple files (should succeed - files are merged)
	result, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", filepath.Join(testDataDir, "*.sql"),
		"--target-stage", "environments/prod",
		"--declarative",
	)

	// This should succeed because bytebase-action merges multiple declarative files
	a.NoError(err, "Declarative rollout with multiple files should succeed (files are merged)")

	// Verify the release was created with exactly one merged file
	releases, err := ctl.releaseServiceClient.ListReleases(ctx, connect.NewRequest(&v1pb.ListReleasesRequest{
		Parent: ctl.project.Name,
	}))
	a.NoError(err)
	a.Len(releases.Msg.Releases, 1, "Expected exactly one release")
	release := releases.Msg.Releases[0]

	// Verify the release contains exactly one file (the merged result)
	a.Len(release.Files, 1, "Release should contain exactly one merged file")
	mergedFile := release.Files[0]

	// Verify the merged file contains both table definitions via Sheet
	a.NotNil(mergedFile.Sheet, "File should have a Sheet")

	sheet, err := ctl.sheetServiceClient.GetSheet(ctx, connect.NewRequest(&v1pb.GetSheetRequest{
		Name: mergedFile.Sheet,
		Raw:  true,
	}))
	a.NoError(err)

	a.Contains(string(sheet.Msg.Content), "CREATE TABLE users", "Merged file should contain users table definition")
	a.Contains(string(sheet.Msg.Content), "CREATE TABLE names", "Merged file should contain names table definition")

	// Verify both tables were created from the merged files
	metadata, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{
		Name: database.Name + "/metadata",
	}))
	a.NoError(err)

	// Verify both users and names tables were created
	foundUsersTable := false
	foundNamesTable := false
	for _, schema := range metadata.Msg.Schemas {
		for _, table := range schema.Tables {
			if table.Name == "users" {
				foundUsersTable = true
				a.Equal(3, len(table.Columns), "Users table should have 3 columns")
			}
			if table.Name == "names" {
				foundNamesTable = true
				a.Equal(3, len(table.Columns), "Names table should have 3 columns")
			}
		}
	}
	a.True(foundUsersTable, "Users table should exist after merged declarative rollout")
	a.True(foundNamesTable, "Names table should exist after merged declarative rollout")

	// Verify command output
	a.NotContains(result.Stderr, "error", "Merged declarative rollout should complete without errors")
}

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

	// Create test database
	database := ctl.createTestDatabase(ctx, t)

	// Create test data directory and migration file
	testDataDir := t.TempDir()
	migrationContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	err := os.WriteFile(filepath.Join(testDataDir, "00001_create_users.sql"), []byte(migrationContent), 0644)
	a.NoError(err)

	// Execute command with invalid credentials
	result, err := executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "invalid-secret",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", filepath.Join(testDataDir, "*.sql"),
	)

	a.Error(err, "Command should fail with invalid service account secret")
	a.Contains(result.Stderr, "failed to login", "Expected authentication error in stderr")
}

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

	// Create test data directory and migration file
	testDataDir := t.TempDir()
	migrationContent := `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);`
	err := os.WriteFile(filepath.Join(testDataDir, "00001_create_users.sql"), []byte(migrationContent), 0644)
	a.NoError(err)

	// Try to target a database that doesn't exist
	result, err := executeActionCommand(ctx,
		"check",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", "instances/fake/databases/nonexistent",
		"--file-pattern", filepath.Join(testDataDir, "*.sql"),
	)

	a.Error(err, "Command should fail with non-existent database")
	a.Contains(result.Stderr, "database instances/fake/databases/nonexistent not found", "Expected not found error in stderr")
}

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

	database := ctl.createTestDatabase(ctx, t)

	// Create test data directory (but don't create any files)
	testDataDir := t.TempDir()

	// Use a pattern that matches no files
	_, err := executeActionCommand(ctx,
		"rollout",
		"--url", ctl.rootURL,
		"--service-account", "[email protected]",
		"--service-account-secret", "1024bytebase",
		"--project", ctl.project.Name,
		"--targets", database.Name,
		"--file-pattern", filepath.Join(testDataDir, "*.nonexistent"),
		"--target-stage", "environments/prod",
	)

	a.Error(err, "Command should fail with empty file pattern")
	a.ErrorContains(err, "no files found for pattern")
}