resource_sql_database_instance_test.go

// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: MPL-2.0
// ----------------------------------------------------------------------------
//
//	***     AUTO GENERATED CODE    ***    Type: Handwritten     ***
//
// ----------------------------------------------------------------------------
//
//	This code is generated by Magic Modules using the following:
//
//	Source file: https://github.com/GoogleCloudPlatform/magic-modules/tree/main/mmv1/third_party/terraform/services/sql/resource_sql_database_instance_test.go.tmpl
//
//	DO NOT EDIT this file directly. Any changes made to this file will be
//	overwritten during the next generation cycle.
//
// ----------------------------------------------------------------------------
package sql_test

import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/hashicorp/terraform-provider-google/google/acctest"
	"github.com/hashicorp/terraform-provider-google/google/envvar"
	"github.com/hashicorp/terraform-provider-google/google/services/sql"

	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
	"github.com/hashicorp/terraform-plugin-testing/terraform"
	sqladmin "google.golang.org/api/sqladmin/v1beta4"
)

// Fields that should be ignored in import tests because they aren't returned
// from GCP (and thus can't be imported)
var ignoredReplicaConfigurationFields = []string{
	"deletion_protection",
	"root_password",
	"replica_configuration.0.ca_certificate",
	"replica_configuration.0.client_certificate",
	"replica_configuration.0.client_key",
	"replica_configuration.0.connect_retry_interval",
	"replica_configuration.0.dump_file_path",
	"replica_configuration.0.master_heartbeat_period",
	"replica_configuration.0.password",
	"replica_configuration.0.ssl_cipher",
	"replica_configuration.0.username",
	"replica_configuration.0.verify_server_certificate",
	"replica_configuration.0.failover_target",
}

func TestAccSqlDatabaseInstance_basicInferredName(t *testing.T) {
	// Randomness
	acctest.SkipIfVcr(t)
	t.Parallel()

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_basic2,
				Check: resource.ComposeTestCheckFunc(
					checkInstanceTypeIsPresent("google_sql_database_instance.instance"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_basicSecondGen(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic3, databaseName),
				Check: testAccCheckGoogleSqlDatabaseRootUserDoesNotExist(t, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_basicMSSQL(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	rootPassword := acctest.RandString(t, 15)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic_mssql, databaseName, rootPassword),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_update_mssql, databaseName, rootPassword),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_basicMSSQL_passwordWo(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	rootPassword := acctest.RandString(t, 15)
	updatedRootPassword := acctest.RandString(t, 15)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic_mssql_wo_password, databaseName, rootPassword),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckNoResourceAttr("google_sql_database_instance.instance", "root_password_wo"),
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "root_password_wo_version", "1"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic_mssql_wo_password_update, databaseName, updatedRootPassword),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckNoResourceAttr("google_sql_database_instance.instance", "root_password_wo"),
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "root_password_wo_version", "2"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_dontDeleteDefaultUserOnReplica(t *testing.T) {
	t.Skip("https://github.com/hashicorp/terraform-provider-google/issues/20975")
	t.Parallel()

	databaseName := "tf-test-sql-instance-" + acctest.RandString(t, 10)
	failoverName := "tf-test-sql-instance-failover-" + acctest.RandString(t, 10)
	// 1. Create an instance.
	// 2. Add a root@'%' user.
	// 3. Create a replica and assert it succeeds (it'll fail if we try to delete the root user thinking it's a
	//    default user)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_withoutReplica(databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				PreConfig: func() {
					// Add a root user
					config := acctest.GoogleProviderConfig(t)
					user := sqladmin.User{
						Name:     "root",
						Host:     "%",
						Password: acctest.RandString(t, 26),
					}
					op, err := config.NewSqlAdminClient(config.UserAgent).Users.Insert(config.Project, databaseName, &user).Do()
					if err != nil {
						t.Errorf("Error while inserting root@%% user: %s", err)
						return
					}
					err = sql.SqlAdminOperationWaitTime(config, op, config.Project, "Waiting for user to insert", config.UserAgent, 10*time.Minute)
					if err != nil {
						t.Errorf("Error while waiting for user insert operation to complete: %s", err.Error())
					}
					// User was created, now create replica
				},
				Config: testGoogleSqlDatabaseInstanceConfig_withReplica(databaseName, failoverName),
			},
		},
	})
}

// This test requires an arbitrary error to occur during the SQL instance creation. Currently, we
// are relying on an error that occurs when settings are used on a MySQL clone. Note that this is
// somewhat brittle, and the test could begin failing if that error no longer behaves the same way.
// If this test begins failing, we will want to be sure that the root user is removed as early as
// possible, and we should attempt to find any other scenarios where the root user could otherwise
// be left on the instance.
func TestAccSqlDatabaseInstance_deleteDefaultUserBeforeSubsequentApiCalls(t *testing.T) {

	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	testId := "sql-instance-clone-2"
	addressName := acctest.BootstrapSharedTestGlobalAddress(t, testId)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, testId)

	// 1. Create an instance.
	// 2. Add a root@'%' user.
	// 3. Create a clone with settings and assert it fails after the instance creation API call.
	// 4. Check root user was deleted.
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withoutAllocatedIpRange(databaseName, networkName, false, false),
			},
			{
				PreConfig: func() {
					// Add a root user
					config := acctest.GoogleProviderConfig(t)
					user := sqladmin.User{
						Name:     "root",
						Host:     "%",
						Password: acctest.RandString(t, 26),
					}
					op, err := config.NewSqlAdminClient(config.UserAgent).Users.Insert(config.Project, databaseName, &user).Do()
					if err != nil {
						t.Errorf("Error while inserting root@%% user: %s", err)
						return
					}
					err = sql.SqlAdminOperationWaitTime(config, op, config.Project, "Waiting for user to insert", config.UserAgent, 10*time.Minute)
					if err != nil {
						t.Errorf("Error while waiting for user insert operation to complete: %s", err.Error())
					}
				},
				Config:      testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeClone_withSettings(databaseName, networkName, addressName),
				ExpectError: regexp.MustCompile("Error, failed to update instance settings"),
			},
			{
				// This PreConfig does a check on the previous step. It is needed because the
				// previous step expects an error, so it cannot perform a check of its own.
				PreConfig: func() {
					var s *terraform.State
					err := testAccCheckGoogleSqlDatabaseRootUserDoesNotExist(t, databaseName+"-clone1")(s)
					if err != nil {
						t.Errorf("Failed to verify that root user was removed: %s", err)
					}
				},
				Config:             testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeClone_withSettings(databaseName, networkName, addressName),
				PlanOnly:           true,
				ExpectNonEmptyPlan: true,
			},
		},
	})
}

func TestAccSqlDatabaseInstance_settings_basic(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_settings_secondary(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings_secondary, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_settings_deletionProtection(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings_deletionProtection, databaseName, "true"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings_deletionProtection, databaseName, "true"),
				Destroy:     true,
				ExpectError: regexp.MustCompile("Error, failed to delete instance because deletion_protection is set to true. Set it to false to proceed with instance deletion"),
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings_deletionProtection, databaseName, "false"),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_maintenanceVersion(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_maintenanceVersionWithOldVersion, databaseName),
				ExpectError: regexp.MustCompile(
					`.*Maintenance version \(MYSQL_5_7_37.R20210508.01_03\) must not be set.*`),
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic3, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_maintenanceVersionWithOldVersion, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_settings_deletionProtectionEnabled(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings_deletionProtectionEnabled, databaseName, "true"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings_deletionProtectionEnabled, databaseName, "true"),
				Destroy:     true,
				ExpectError: regexp.MustCompile(fmt.Sprintf("Error, failed to delete instance %s: googleapi: Error 400: The instance is protected. Please disable the deletion protection and try again. To disable deletion protection, update the instance settings with deletionProtectionEnabled set to false.", databaseName)),
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings_deletionProtectionEnabled, databaseName, "false"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_settings_checkServiceNetworking(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings_checkServiceNetworking, databaseName, databaseName),
				ExpectError: regexp.MustCompile("Error, failed to create instance because the network doesn't have at least 1 private services connection. Please see https://cloud.google.com/sql/docs/mysql/private-ip#network_requirements for how to create this connection."),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_replica(t *testing.T) {
	t.Parallel()

	databaseID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_replica, databaseID, databaseID, databaseID, "true"),
				ExpectError: regexp.MustCompile("Error, failed to create instance tf-test-\\d+-2: googleapi: Error 400: Invalid request: Invalid flag for instance role: Backups cannot be enabled for read replica instance"),
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_replica, databaseID, databaseID, databaseID, "false"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance_master",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.replica1",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			{
				ResourceName:            "google_sql_database_instance.replica2",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
		},
	})
}

func TestAccSqlDatabaseInstance_slave(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)
	slaveID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_slave, masterID, slaveID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance_master",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance_slave",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_highAvailability(t *testing.T) {
	t.Parallel()

	instanceID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_highAvailability, instanceID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_diskspecs(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_diskspecs, masterID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_maintenance(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_maintenance, masterID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_maintenance_update_track_week5(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_maintenance_week5, masterID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_settings_upgrade(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic3, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_settingsDowngrade(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_settings, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic3, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

// GH-4222
func TestAccSqlDatabaseInstance_authNets(t *testing.T) {
	t.Parallel()

	databaseID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_authNets_step1, databaseID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_authNets_step2, databaseID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_authNets_step1, databaseID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

// Tests that a SQL instance can be referenced from more than one other resource without
// throwing an error during provisioning, see #9018.
func TestAccSqlDatabaseInstance_multipleOperations(t *testing.T) {
	t.Parallel()

	databaseID, instanceID, userID := acctest.RandString(t, 8), acctest.RandString(t, 8), acctest.RandString(t, 8)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_multipleOperations, databaseID, instanceID, userID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_basic_with_user_labels(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic_with_user_labels, databaseName),
				Check: testAccCheckGoogleSqlDatabaseRootUserDoesNotExist(t, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_basic_with_user_labels_update, databaseName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPrivateNetwork_withoutAllocatedIpRange(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, "sql-instance-1")

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withoutAllocatedIpRange(databaseName, networkName, false, false),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withoutAllocatedIpRange(databaseName, networkName, true, false),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withoutAllocatedIpRange(databaseName, networkName, true, true),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withoutAllocatedIpRange(databaseName, networkName, true, false),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withMCPEnabled(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withMCPEnabled(instanceName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withoutMCPEnabled(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withoutMCPEnabled(instanceName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_updateMCPEnabled(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	resourceName := "google_sql_database_instance.instance"

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withoutMCPEnabled(instanceName),
			},
			{
				Config: testAccSqlDatabaseInstance_withMCPEnabled(instanceName),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.connection_pool_config.0.connection_pooling_enabled", "true"),
					resource.TestCheckResourceAttr(resourceName, "settings.0.connection_pool_config.0.flags.#", "1"),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPSCEnabled_withoutAllowedConsumerProjects(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	projectId := "psctestproject" + acctest.RandString(t, 10)
	orgId := envvar.GetTestOrgFromEnv(t)
	billingAccount := envvar.GetTestBillingAccountFromEnv(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withoutAllowedConsumerProjects(instanceName, projectId, orgId, billingAccount),
				Check:  resource.ComposeTestCheckFunc(verifyPscOperation("google_sql_database_instance.instance", true, true, nil)),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPSCEnabled_withEmptyAllowedConsumerProjects(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	projectId := "psctestproject" + acctest.RandString(t, 10)
	orgId := envvar.GetTestOrgFromEnv(t)
	billingAccount := envvar.GetTestBillingAccountFromEnv(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withEmptyAllowedConsumerProjects(instanceName, projectId, orgId, billingAccount),
				Check:  resource.ComposeTestCheckFunc(verifyPscOperation("google_sql_database_instance.instance", true, true, []string{})),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPSCEnabled_withAllowedConsumerProjects(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	projectId := "psctestproject" + acctest.RandString(t, 10)
	orgId := envvar.GetTestOrgFromEnv(t)
	billingAccount := envvar.GetTestBillingAccountFromEnv(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withAllowedConsumerProjects(instanceName, projectId, orgId, billingAccount),
				Check:  resource.ComposeTestCheckFunc(verifyPscOperation("google_sql_database_instance.instance", true, true, []string{envvar.GetTestProjectFromEnv()})),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPSCEnabled_thenAddAllowedConsumerProjects_thenRemoveAllowedConsumerProject(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	projectId := "psctestproject" + acctest.RandString(t, 10)
	orgId := envvar.GetTestOrgFromEnv(t)
	billingAccount := envvar.GetTestBillingAccountFromEnv(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withoutAllowedConsumerProjects(instanceName, projectId, orgId, billingAccount),
				Check:  resource.ComposeTestCheckFunc(verifyPscOperation("google_sql_database_instance.instance", true, true, nil)),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withAllowedConsumerProjects(instanceName, projectId, orgId, billingAccount),
				Check:  resource.ComposeTestCheckFunc(verifyPscOperation("google_sql_database_instance.instance", true, true, []string{envvar.GetTestProjectFromEnv()})),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withoutAllowedConsumerProjects(instanceName, projectId, orgId, billingAccount),
				Check:  resource.ComposeTestCheckFunc(verifyPscOperation("google_sql_database_instance.instance", true, true, []string{})),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPSCEnabled_withoutPscAutoConnections(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	projectId := envvar.GetTestProjectFromEnv()

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withoutPscAutoConnections(instanceName),
				Check:  resource.ComposeTestCheckFunc(verifyPscAutoConnectionsOperation("google_sql_database_instance.instance", true, true, false, "", "")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPSCEnabled_withPscAutoConnections(t *testing.T) {
	t.Parallel()

	testId := "test-psc-auto-con-1"
	instanceName := "tf-test-" + acctest.RandString(t, 10)
	projectId := envvar.GetTestProjectFromEnv()
	networkName := acctest.BootstrapSharedTestNetwork(t, testId)
	network_short_link_name := fmt.Sprintf("projects/%s/global/networks/%s", projectId, networkName)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withPscAutoConnections(instanceName, projectId, networkName),
				Check:  resource.ComposeTestCheckFunc(verifyPscAutoConnectionsOperation("google_sql_database_instance.instance", true, true, true, network_short_link_name, projectId)),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPSCEnabled_thenAddPscAutoConnections_thenRemovePscAutoConnections(t *testing.T) {
	t.Parallel()

	testId := "test-psc-auto-con-2"
	instanceName := "tf-test-" + acctest.RandString(t, 10)
	projectId := envvar.GetTestProjectFromEnv()
	networkName := acctest.BootstrapSharedTestNetwork(t, testId)
	network_short_link_name := fmt.Sprintf("projects/%s/global/networks/%s", projectId, networkName)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withoutPscAutoConnections(instanceName),
				Check:  resource.ComposeTestCheckFunc(verifyPscAutoConnectionsOperation("google_sql_database_instance.instance", true, true, false, "", "")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withPscAutoConnections(instanceName, projectId, networkName),
				Check:  resource.ComposeTestCheckFunc(verifyPscAutoConnectionsOperation("google_sql_database_instance.instance", true, true, true, network_short_link_name, projectId)),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withoutPscAutoConnections(instanceName),
				Check:  resource.ComposeTestCheckFunc(verifyPscAutoConnectionsOperation("google_sql_database_instance.instance", true, true, false, "", "")),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPSCEnabled_withIpV4Enabled(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	projectId := "psctestproject" + acctest.RandString(t, 10)
	orgId := envvar.GetTestOrgFromEnv(t)
	billingAccount := envvar.GetTestBillingAccountFromEnv(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config:      testAccSqlDatabaseInstance_withPSCEnabled_withIpV4Enable(instanceName, projectId, orgId, billingAccount),
				ExpectError: regexp.MustCompile("PSC connectivity cannot be enabled together with only public IP"),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPscEnabled_withNetworkAttachmentUri_thenRemoveNetworkAttachment(t *testing.T) {
	t.Parallel()

	random_suffix := acctest.RandString(t, 10)
	instanceName := "tf-test-" + random_suffix
	projectId := envvar.GetTestProjectFromEnv()
	region := "us-central1"
	networkNameStr := "tf-test-cloud-sql-network-psc-1"
	subnetworkNameStr := "tf-test-cloud-sql-subnetwork-psc-1"
	networkAttachmentNameStr := "tf-test-cloud-sql-update-na-psc-1"
	networkName := acctest.BootstrapSharedTestNetwork(t, networkNameStr)
	subnetworkName := acctest.BootstrapSubnet(t, subnetworkNameStr, networkName)
	networkAttachmentName := acctest.BootstrapNetworkAttachment(t, networkAttachmentNameStr, subnetworkName)
	networkAttachmentUri := fmt.Sprintf("projects/%s/regions/%s/networkAttachments/%s", projectId, region, networkAttachmentName)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withoutPscOutbound(instanceName),
				Check:  resource.ComposeTestCheckFunc(verifyPscNetorkAttachmentOperation("google_sql_database_instance.instance", true, true, "")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withNetworkAttachmentUri(instanceName, networkAttachmentUri),
				Check:  resource.ComposeTestCheckFunc(verifyPscNetorkAttachmentOperation("google_sql_database_instance.instance", true, true, networkAttachmentUri)),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPSCEnabled_withoutPscOutbound(instanceName),
				Check:  resource.ComposeTestCheckFunc(verifyPscNetorkAttachmentOperation("google_sql_database_instance.instance", true, true, "")),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPscEnabled_withNetworkAttachmentUriOnCreate(t *testing.T) {
	t.Parallel()

	random_suffix := acctest.RandString(t, 10)
	instanceName := "tf-test-" + random_suffix
	projectId := envvar.GetTestProjectFromEnv()
	region := "us-central1"
	networkNameStr := "tf-test-cloud-sql-network-psc-2"
	subnetworkNameStr := "tf-test-cloud-sql-subnetwork-psc-2"
	networkAttachmentNameStr := "tf-test-cloud-sql-update-na-psc-2"
	networkName := acctest.BootstrapSharedTestNetwork(t, networkNameStr)
	subnetworkName := acctest.BootstrapSubnet(t, subnetworkNameStr, networkName)
	networkAttachmentName := acctest.BootstrapNetworkAttachment(t, networkAttachmentNameStr, subnetworkName)
	networkAttachmentUri := fmt.Sprintf("projects/%s/regions/%s/networkAttachments/%s", projectId, region, networkAttachmentName)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config:      testAccSqlDatabaseInstance_withPSCEnabled_withNetworkAttachmentUri(instanceName, networkAttachmentUri),
				ExpectError: regexp.MustCompile(`.*Network attachment used for Private Service Connect interfaces can not be assigned with instance creation.*`),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRange(t *testing.T) {

	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	testId := "sql-instance-allocated-1"
	addressName := acctest.BootstrapSharedTestGlobalAddress(t, testId)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, testId)

	updateTestId := "sql-instance-allocated-update-1"
	addressName_update := acctest.BootstrapSharedTestGlobalAddress(t, updateTestId)
	networkName_update := acctest.BootstrapSharedServiceNetworkingConnection(t, updateTestId)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRange(databaseName, networkName, addressName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRange(databaseName, networkName_update, addressName_update),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeReplica(t *testing.T) {

	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)

	testId := "sql-instance-replica-1"
	addressName := acctest.BootstrapSharedTestGlobalAddress(t, testId)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, testId)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeReplica(databaseName, networkName, addressName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.replica1",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
		},
	})
}

func TestAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeClone(t *testing.T) {

	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	testId := "sql-instance-clone-1"
	addressName := acctest.BootstrapSharedTestGlobalAddress(t, testId)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, testId)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeClone(databaseName, networkName, addressName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.clone1",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "clone"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_createFromBackup(t *testing.T) {
	// Sqladmin client
	acctest.SkipIfVcr(t)
	t.Parallel()

	context := map[string]interface{}{
		"random_suffix":    acctest.RandString(t, 10),
		"original_db_name": acctest.BootstrapSharedSQLInstanceBackupRun(t),
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_restoreFromBackup(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "restore_backup_context"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_createFromBackupDR(t *testing.T) {
	t.Skip("https://github.com/hashicorp/terraform-provider-google/issues/24234")
	acctest.SkipIfVcr(t)
	t.Parallel()

	// Bootstrap the BackupDR vault
	backupVaultID := "bv-test"
	vaultLocation := "us-central1"
	project := envvar.GetTestProjectFromEnv()
	backupvault := acctest.BootstrapBackupDRVault(t, backupVaultID, vaultLocation)

	context := map[string]interface{}{
		"random_suffix":          acctest.RandString(t, 10),
		"project":                project,
		"backup_vault_id":        backupVaultID,
		"backup_vault":           backupvault,
		"target_instance_region": "us-central1",
		"vault_location":         vaultLocation,
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_createFromBackupDR(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "backupdr_backup"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_backupUpdate(t *testing.T) {
	// Sqladmin client
	acctest.SkipIfVcr(t)
	t.Parallel()

	context := map[string]interface{}{
		"random_suffix":    acctest.RandString(t, 10),
		"db_version":       "POSTGRES_11",
		"original_db_name": acctest.BootstrapSharedSQLInstanceBackupRun(t),
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_beforeBackup(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_restoreFromBackup(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "restore_backup_context"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_BackupDRUpdate(t *testing.T) {
	t.Skip("https://github.com/hashicorp/terraform-provider-google/issues/24234")
	acctest.SkipIfVcr(t)
	t.Parallel()

	// Bootstrap the BackupDR vault
	backupVaultID := "bv-test"
	location := "us-central1"
	project := envvar.GetTestProjectFromEnv()
	backupvault := acctest.BootstrapBackupDRVault(t, backupVaultID, location)

	context := map[string]interface{}{
		"random_suffix":   acctest.RandString(t, 10),
		"project":         project,
		"backup_vault_id": backupVaultID,
		"backup_vault":    backupvault,
		"db_version":      "MYSQL_8_0_41",
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_beforeBackup(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testAccSqlDatabaseInstance_updateFromBackupDR(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "backupdr_backup"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_createFromCrossRegionBackupDrBackup(t *testing.T) {
	t.Parallel()

	// Bootstrap the BackupDR vault
	backupVaultID := "bv-test"
	vaultLocation := "us-central1"
	project := envvar.GetTestProjectFromEnv()
	backupvault := acctest.BootstrapBackupDRVault(t, backupVaultID, vaultLocation)

	context := map[string]interface{}{
		"random_suffix":          acctest.RandString(t, 10),
		"project":                project,
		"backup_vault_id":        backupVaultID,
		"backup_vault":           backupvault,
		"target_instance_region": "us-east1",
		"vault_location":         vaultLocation,
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_createFromBackupDR(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "backupdr_backup"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_createFromMultiRegionBackupDrBackup(t *testing.T) {
	t.Parallel()

	// Bootstrap the BackupDR vault
	backupVaultID := "bv-test-mr"
	vaultLocation := "us"
	project := envvar.GetTestProjectFromEnv()
	backupvault := acctest.BootstrapBackupDRVault(t, backupVaultID, vaultLocation)

	context := map[string]interface{}{
		"random_suffix":          acctest.RandString(t, 10),
		"project":                project,
		"backup_vault_id":        backupVaultID,
		"backup_vault":           backupvault,
		"target_instance_region": "us-central1",
		"vault_location":         vaultLocation,
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_createFromBackupDR(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "backupdr_backup"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_createFromMultiRegionBackupDrBackupCrossRegion(t *testing.T) {
	t.Parallel()

	// Bootstrap the BackupDR vault
	backupVaultID := "bv-test-mr"
	vaultLocation := "us"
	project := envvar.GetTestProjectFromEnv()
	backupvault := acctest.BootstrapBackupDRVault(t, backupVaultID, vaultLocation)

	context := map[string]interface{}{
		"random_suffix":          acctest.RandString(t, 10),
		"project":                project,
		"backup_vault_id":        backupVaultID,
		"backup_vault":           backupvault,
		"target_instance_region": "us-east1",
		"vault_location":         vaultLocation,
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_createFromBackupDR(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "backupdr_backup"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_basicClone(t *testing.T) {
	// Sqladmin client
	acctest.SkipIfVcr(t)
	t.Parallel()

	context := map[string]interface{}{
		"random_suffix":    acctest.RandString(t, 10),
		"original_db_name": acctest.BootstrapSharedSQLInstanceBackupRun(t),
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_basicClone(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "clone"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_cloneWithSettings(t *testing.T) {
	// Sqladmin client
	acctest.SkipIfVcr(t)
	t.Parallel()

	context := map[string]interface{}{
		"random_suffix":    acctest.RandString(t, 10),
		"original_db_name": acctest.BootstrapSharedSQLInstanceBackupRun(t),
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_cloneWithSettings(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "clone"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_cloneWithDatabaseNames(t *testing.T) {
	// Sqladmin client
	acctest.SkipIfVcr(t)
	t.Parallel()

	context := map[string]interface{}{
		"random_suffix":    acctest.RandString(t, 10),
		"original_db_name": acctest.BootstrapSharedSQLInstanceBackupRun(t),
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_cloneWithDatabaseNames(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "clone"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_pointInTimeRestore(t *testing.T) {
	// Skipped due to randomness
	acctest.SkipIfVcr(t)
	t.Parallel()

	backupVaultID := "bv-test"
	location := "us-central1"
	project := envvar.GetTestProjectFromEnv()
	backupVault := acctest.BootstrapBackupDRVault(t, backupVaultID, location)

	context := map[string]interface{}{
		"random_suffix":   acctest.RandString(t, 10),
		"project":         project,
		"backup_vault_id": backupVaultID,
		"backup_vault":    backupVault,
		"db_version":      "MYSQL_8_0_41",
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_pointInTimeRestoreContext(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "point_in_time_restore_context"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_pointInTimeRestoreWithSettings(t *testing.T) {
	// Skipped due to randomness
	acctest.SkipIfVcr(t)
	t.Parallel()

	backupVaultID := "bv-test"
	location := "us-central1"
	project := envvar.GetTestProjectFromEnv()
	backupVault := acctest.BootstrapBackupDRVault(t, backupVaultID, location)

	context := map[string]interface{}{
		"random_suffix":   acctest.RandString(t, 10),
		"project":         project,
		"backup_vault_id": backupVaultID,
		"backup_vault":    backupVault,
		"db_version":      "MYSQL_8_0_41",
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_pointInTimeRestoreContextWithSettings(context),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "point_in_time_restore_context"},
			},
		},
	})
}

func testAccSqlDatabaseInstanceDestroyProducer(t *testing.T) func(s *terraform.State) error {
	return func(s *terraform.State) error {
		for _, rs := range s.RootModule().Resources {
			config := acctest.GoogleProviderConfig(t)
			if rs.Type != "google_sql_database_instance" {
				continue
			}

			_, err := config.NewSqlAdminClient(config.UserAgent).Instances.Get(config.Project,
				rs.Primary.Attributes["name"]).Do()
			if err == nil {
				return fmt.Errorf("Database Instance still exists")
			}
		}

		return nil
	}
}

func testAccCheckGoogleSqlDatabaseRootUserDoesNotExist(t *testing.T, instance string) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		config := acctest.GoogleProviderConfig(t)

		users, err := config.NewSqlAdminClient(config.UserAgent).Users.List(config.Project, instance).Do()

		if err != nil {
			return fmt.Errorf("Could not list database users for %q: %s", instance, err)
		}

		for _, u := range users.Items {
			if u.Name == "root" && u.Host == "%" {
				return fmt.Errorf("%v@%v user still exists", u.Name, u.Host)
			}
		}

		return nil
	}
}

func TestAccSqlDatabaseInstance_BackupRetention(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_BackupRetention(masterID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_RetainBackupOnDelete(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_RetainBackupOnDelete(masterID, true),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_RetainBackupOnDelete(masterID, false),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_FinalBackupConfig(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_FinalBackupConfig(masterID, true, 10),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "final_backup_description"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_FinalBackupConfig(masterID, false, -1),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "final_backup_description"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_PointInTimeRecoveryEnabled(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_PointInTimeRecoveryEnabled(masterID, true, "POSTGRES_9_6"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_PointInTimeRecoveryEnabled(masterID, false, "POSTGRES_9_6"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_PointInTimeRecoveryEnabledForSqlServer(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_PointInTimeRecoveryEnabled(masterID, true, "SQLSERVER_2017_STANDARD"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_PointInTimeRecoveryEnabled(masterID, false, "SQLSERVER_2017_STANDARD"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_EnableGoogleMlIntegration(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_EnableGoogleMlIntegration(masterID, true, "POSTGRES_14", "db-custom-2-13312"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			// Test that updates to other settings work after google-ml-integration is enabled
			{
				Config: testGoogleSqlDatabaseInstance_EnableGoogleMlIntegration(masterID, true, "POSTGRES_14", "db-custom-2-10240"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_EnableGoogleMlIntegration(masterID, false, "POSTGRES_14", "db-custom-2-10240"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_EnableGoogleDataplexIntegration(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_EnableDataplexIntegration(masterID, true),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_EnableDataplexIntegration(masterID, false),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_insights(t *testing.T) {
	t.Parallel()

	masterID := acctest.RandInt(t)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(
					testGoogleSqlDatabaseInstance_insights, masterID),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_encryptionKey(t *testing.T) {
	t.Parallel()

	context := map[string]interface{}{
		"project_id":    envvar.GetTestProjectFromEnv(),
		"key_name":      "tf-test-key-" + acctest.RandString(t, 10),
		"instance_name": "tf-test-sql-" + acctest.RandString(t, 10),
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: acctest.Nprintf(
					testGoogleSqlDatabaseInstance_encryptionKey, context),
			},
			{
				ResourceName:            "google_sql_database_instance.replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.master",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_encryptionKey_replicaInDifferentRegion(t *testing.T) {
	t.Parallel()

	context := map[string]interface{}{
		"project_id":    envvar.GetTestProjectFromEnv(),
		"instance_name": "tf-test-sql-" + acctest.RandString(t, 10),
		"kms_key_name1": acctest.BootstrapKMSKeyWithPurposeInLocationAndName(t, "ENCRYPT_DECRYPT", "us-central1", "tf-bootstrap-sql-database-instance-key1").CryptoKey.Name,
		"kms_key_name2": acctest.BootstrapKMSKeyWithPurposeInLocationAndName(t, "ENCRYPT_DECRYPT", "us-east1", "tf-bootstrap-sql-database-instance-key2").CryptoKey.Name,
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: acctest.Nprintf(
					testGoogleSqlDatabaseInstance_encryptionKey_replicaInDifferentRegion, context),
			},
			{
				ResourceName:            "google_sql_database_instance.replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.master",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_ActiveDirectory(t *testing.T) {
	// skip the test until Active Directory setup issue gets resolved
	// see https://github.com/hashicorp/terraform-provider-google/issues/13517
	t.Skip()

	t.Parallel()
	databaseName := "tf-test-" + acctest.RandString(t, 10)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, "sql-instance-ad-1")
	rootPassword := acctest.RandString(t, 15)
	adDomainName := acctest.BootstrapSharedTestADDomain(t, "test-domain", networkName)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_ActiveDirectoryConfig(databaseName, networkName, rootPassword, adDomainName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance-with-ad",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
		},
	})
}

func TestAccSQLDatabaseInstance_DenyMaintenancePeriod(t *testing.T) {
	t.Parallel()
	databaseName := "tf-test-" + acctest.RandString(t, 10)
	endDate := "2022-12-5"
	startDate := "2022-10-5"
	time := "00:00:00"
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_DenyMaintenancePeriodConfig(databaseName, endDate, startDate, time),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSQLDatabaseInstance_DefaultEdition(t *testing.T) {
	t.Parallel()
	databaseName := "tf-test-" + acctest.RandString(t, 10)
	databaseVersion := "POSTGRES_16"
	enterprisePlusTier := "db-c4a-highmem-4"
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_DefaultEdition(databaseName, databaseVersion, enterprisePlusTier),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE_PLUS"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_Edition(t *testing.T) {
	t.Parallel()
	enterprisePlusName := "tf-test-enterprise-plus" + acctest.RandString(t, 10)
	enterprisePlusTier := "db-perf-optimized-N-2"
	enterpriseName := "tf-test-enterprise-" + acctest.RandString(t, 10)
	enterpriseTier := "db-custom-2-13312"
	noEditionName := "tf-test-enterprise-noedition-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_EditionConfig_noEdition(noEditionName, enterpriseTier),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			// Delete and recreate (ForceNew) triggered by passing in a new `name` value
			{
				Config: testGoogleSqlDatabaseInstance_EditionConfig(enterprisePlusName, enterprisePlusTier, "ENTERPRISE_PLUS"),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE_PLUS"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			// Delete and recreate (ForceNew) triggered by passing in a new `name` value
			{
				Config: testGoogleSqlDatabaseInstance_EditionConfig(enterpriseName, enterpriseTier, "ENTERPRISE"),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSQLDatabaseInstance_sqlMysqlDataCacheConfig(t *testing.T) {
	t.Parallel()
	instanceName := "tf-test-enterprise-plus" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_sqlMysqlDataCacheConfig(instanceName, false),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.data_cache_config.0.data_cache_enabled", "false"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_sqlMysqlDataCacheConfig(instanceName, true),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.data_cache_config.0.data_cache_enabled", "true"),
				),
			},
		},
	})
}

func TestAccSQLDatabaseInstance_sqlPostgresDataCacheConfig(t *testing.T) {
	t.Parallel()
	enterprisePlusInstanceName := "tf-test-enterprise-plus" + acctest.RandString(t, 10)
	enterprisePlusTier := "db-perf-optimized-N-2"
	enterpriseInstanceName := "tf-test-enterprise-" + acctest.RandString(t, 10)
	enterpriseTier := "db-custom-2-13312"
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_sqlPostgresDataCacheConfig(enterprisePlusInstanceName, enterprisePlusTier, "ENTERPRISE_PLUS", true),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.data_cache_config.0.data_cache_enabled", "true"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_sqlPostgresDataCacheConfig(enterprisePlusInstanceName, enterprisePlusTier, "ENTERPRISE_PLUS", false),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.data_cache_config.0.data_cache_enabled", "false"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_sqlPostgresDataCacheConfig(enterpriseInstanceName, enterpriseTier, "ENTERPRISE", true),
				ExpectError: regexp.MustCompile(
					fmt.Sprintf("Error, failed to create instance %s: googleapi: Error 400: Invalid request: Only ENTERPRISE PLUS edition supports data cache", enterpriseInstanceName)),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_Mysql_Edition_Upgrade(t *testing.T) {
	t.Parallel()
	enterpriseTier := "db-custom-2-13312"
	editionUpgrade := "tf-test-enterprise-upgrade-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_sqlMysql(editionUpgrade, enterpriseTier),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_sqlMysqlDataCacheConfig(editionUpgrade, true),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE_PLUS"),
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.data_cache_config.0.data_cache_enabled", "true"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_Postgres_Edition_Upgrade(t *testing.T) {
	t.Parallel()
	enterpriseTier := "db-custom-2-13312"
	enterprisePlusTier := "db-perf-optimized-N-2"
	editionUpgrade := "tf-test-enterprise-upgrade-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_EditionConfig(editionUpgrade, enterpriseTier, "ENTERPRISE"),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_EditionConfig(editionUpgrade, enterprisePlusTier, "ENTERPRISE_PLUS"),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE_PLUS"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_Edition_Downgrade(t *testing.T) {
	t.Parallel()
	enterprisePlusTier := "db-perf-optimized-N-2"
	enterpriseTier := "db-custom-2-13312"
	editionDowngrade := "tf-test-enterprise-downgrade-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_EditionConfig(editionDowngrade, enterprisePlusTier, "ENTERPRISE_PLUS"),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE_PLUS"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_EditionConfig(editionDowngrade, enterpriseTier, "ENTERPRISE"),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE"),
				),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_SqlServerAuditConfig(t *testing.T) {
	// Service Networking
	acctest.SkipIfVcr(t)
	t.Parallel()
	databaseName := "tf-test-" + acctest.RandString(t, 10)
	rootPassword := acctest.RandString(t, 15)
	bucketName := fmt.Sprintf("%s-%d", "tf-test-bucket", acctest.RandInt(t))
	uploadInterval := "900s"
	retentionInterval := "86400s"
	bucketNameUpdate := fmt.Sprintf("%s-%d", "tf-test-bucket", acctest.RandInt(t)) + "update"
	uploadIntervalUpdate := "1200s"
	retentionIntervalUpdate := "172800s"

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_SqlServerAuditConfig(databaseName, rootPassword, bucketName, uploadInterval, retentionInterval),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_SqlServerAuditConfig(databaseName, rootPassword, bucketNameUpdate, uploadIntervalUpdate, retentionIntervalUpdate),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_SqlServerAuditOptionalBucket(t *testing.T) {
	t.Parallel()
	databaseName := "tf-test-" + acctest.RandString(t, 10)
	rootPassword := acctest.RandString(t, 15)
	uploadInterval := "900s"
	retentionInterval := "86400s"

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_SqlServerAuditOptionalBucket(databaseName, rootPassword, uploadInterval, retentionInterval),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_Smt(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	rootPassword := acctest.RandString(t, 15)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_Smt(databaseName, rootPassword, 1),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_Smt(databaseName, rootPassword, 2),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_NullSmt(databaseName, rootPassword),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_Timezone(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	rootPassword := acctest.RandString(t, 15)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_Timezone(databaseName, rootPassword, "Pacific Standard Time"),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"root_password", "deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_updateDifferentFlagOrder(t *testing.T) {
	t.Parallel()

	instance := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_flags(instance),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config:             testGoogleSqlDatabaseInstance_flags_update(instance),
				PlanOnly:           true,
				ExpectNonEmptyPlan: false,
			},
		},
	})
}

func TestAccSqlDatabaseInstance_sqlMysqlInstancePvpExample(t *testing.T) {
	t.Parallel()

	context := map[string]interface{}{
		"deletion_protection": false,
		"random_suffix":       acctest.RandString(t, 10),
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		Steps: []resource.TestStep{
			{
				Config: testAccSqlDatabaseInstance_sqlMysqlInstancePvpExample(context),
			},
			{
				ResourceName:            "google_sql_database_instance.mysql_pvp_instance_name",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_updateReadReplicaWithBinaryLogEnabled(t *testing.T) {
	t.Parallel()

	instance := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_readReplica(instance),
			},
			{
				ResourceName:            "google_sql_database_instance.replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_updateReadReplica(instance),
			},
			{
				ResourceName:            "google_sql_database_instance.replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_rootPasswordShouldBeUpdatable(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	rootPwd := "rootPassword-1-" + acctest.RandString(t, 10)
	newRootPwd := "rootPassword-2-" + acctest.RandString(t, 10)
	databaseVersion := "SQLSERVER_2017_STANDARD"

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_updateRootPassword(databaseName, databaseVersion, rootPwd),
			},
			{
				ResourceName:            "google_sql_database_instance.main",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_updateRootPassword(databaseName, databaseVersion, newRootPwd),
			},
			{
				ResourceName:            "google_sql_database_instance.main",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_updateRootPassword(databaseName, databaseVersion, ""),
				ExpectError: regexp.MustCompile(
					`Error, root password cannot be empty for SQL Server instance.`),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_SqlServerTimezoneUpdate(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	rootPassword := acctest.RandString(t, 15)
	timezone := "Eastern Standard Time"
	timezoneUpdate := "Pacific Standard Time"

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_SqlServerTimezone(instanceName, rootPassword, timezone),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_SqlServerTimezone(instanceName, rootPassword, timezoneUpdate),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_activationPolicy(t *testing.T) {
	t.Parallel()

	// Skip in VCR until the test issue is resolved
	// https://github.com/hashicorp/terraform-provider-google/issues/24593
	acctest.SkipIfVcr(t)

	instanceName := "tf-test-" + acctest.RandString(t, 10)

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_activationPolicy(instanceName, "MYSQL_5_7", "ALWAYS", true),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_activationPolicy(instanceName, "MYSQL_5_7", "NEVER", true),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_activationPolicy(instanceName, "MYSQL_8_0_18", "ALWAYS", true),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_activationPolicy(instanceName, "MYSQL_8_0_37", "NEVER", true),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_activationPolicy(instanceName, "MYSQL_8_0_37", "ALWAYS", false),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_activationPolicy(instanceName, "MYSQL_8_4", "ALWAYS", false),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "root_password"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_ReplicaPromoteSuccessful(t *testing.T) {
	t.Skip("https://github.com/hashicorp/terraform-provider-google/issues/20975")
	t.Parallel()

	databaseName := "tf-test-sql-instance-" + acctest.RandString(t, 10)
	failoverName := "tf-test-sql-instance-failover-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_withReplica(databaseName, failoverName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: googleSqlDatabaseInstance_replicaPromote(databaseName, failoverName),
				Check:  resource.ComposeTestCheckFunc(checkPromoteReplicaConfigurations("google_sql_database_instance.instance-failover")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_ReplicaPromoteFailedWithMasterInstanceNamePresent(t *testing.T) {
	t.Skip("https://github.com/hashicorp/terraform-provider-google/issues/20975")
	t.Parallel()
	databaseName := "tf-test-sql-instance-" + acctest.RandString(t, 10)
	failoverName := "tf-test-sql-instance-failover-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_withReplica(databaseName, failoverName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config:      googleSqlDatabaseInstance_replicaPromoteWithMasterInstanceName(databaseName, failoverName),
				ExpectError: regexp.MustCompile("Replica promote configuration check failed. Please remove master_instance_name and try again."),
				Check:       resource.ComposeTestCheckFunc(checkPromoteReplicaSkipConfigurations("google_sql_database_instance.instance-failover")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_ReplicaPromoteFailedWithReplicaConfigurationPresent(t *testing.T) {
	t.Skip("https://github.com/hashicorp/terraform-provider-google/issues/20975")
	t.Parallel()

	databaseName := "tf-test-sql-instance-" + acctest.RandString(t, 10)
	failoverName := "tf-test-sql-instance-failover-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_withReplica(databaseName, failoverName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config:      googleSqlDatabaseInstance_replicaPromoteWithReplicaConfiguration(databaseName, failoverName),
				ExpectError: regexp.MustCompile("Replica promote configuration check failed. Please remove replica_configuration and try again."),
				Check:       resource.ComposeTestCheckFunc(checkPromoteReplicaSkipConfigurations("google_sql_database_instance.instance-failover")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_ReplicaPromoteFailedWithMasterInstanceNameAndReplicaConfigurationPresent(t *testing.T) {
	t.Skip("https://github.com/hashicorp/terraform-provider-google/issues/20975")
	t.Parallel()

	databaseName := "tf-test-sql-instance-" + acctest.RandString(t, 10)
	failoverName := "tf-test-sql-instance-failover-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_withReplica(databaseName, failoverName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config:      googleSqlDatabaseInstance_replicaPromoteWithMasterInstanceNameAndReplicaConfiguration(databaseName, failoverName),
				ExpectError: regexp.MustCompile("Replica promote configuration check failed. Please remove master_instance_name and try again."),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_ReplicaPromoteSkippedWithNoMasterInstanceNameAndNoReplicaConfigurationPresent(t *testing.T) {
	t.Skip("https://github.com/hashicorp/terraform-provider-google/issues/20975")
	t.Parallel()

	databaseName := "tf-test-sql-instance-" + acctest.RandString(t, 10)
	failoverName := "tf-test-sql-instance-failover-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_withReplica(databaseName, failoverName),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: googleSqlDatabaseInstance_replicaPromoteSkippedWithNoMasterInstanceNameAndNoReplicaConfiguration(databaseName, failoverName),
				Check:  resource.ComposeTestCheckFunc(checkPromoteReplicaSkipConfigurations("google_sql_database_instance.instance-failover")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.instance-failover",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

// Switchover between primary and cascadable replica sunny case
func TestAccSqlDatabaseInstance_SwitchoverSuccess(t *testing.T) {
	t.Parallel()
	primaryName := "tf-test-sql-instance-" + acctest.RandString(t, 10)
	replicaName := "tf-test-sql-instance-replica-" + acctest.RandString(t, 10)
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_SqlServerwithCascadableReplica(primaryName, replicaName),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			{
				ResourceName:            "google_sql_database_instance.original-replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			{
				// Split into two configs because current TestStep implementation checks diff before refreshing.
				Config: googleSqlDatabaseInstance_switchoverOnReplica(primaryName, replicaName),
			},
			{
				Config: googleSqlDatabaseInstance_updatePrimaryAfterSwitchover(primaryName, replicaName),
			},
			{
				RefreshState: true,
				Check:        resource.ComposeTestCheckFunc(resource.TestCheckTypeSetElemAttr("google_sql_database_instance.original-replica", "replica_names.*", primaryName), checkSwitchoverOriginalReplicaConfigurations("google_sql_database_instance.original-replica"), checkSwitchoverOriginalPrimaryConfigurations("google_sql_database_instance.original-primary", replicaName)),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			{
				ResourceName:      "google_sql_database_instance.original-replica",
				ImportState:       true,
				ImportStateVerify: true,
				// original-replica is no longer a replica, but replica_configuration is O + C and cannot be unset
				ImportStateVerifyIgnore: []string{"replica_configuration", "deletion_protection", "root_password"},
			},
			{
				// Delete replica first so PostTestDestroy doesn't fail when deleting instances which have replicas. We've already validated switchover behavior, the remaining steps are cleanup
				Config: googleSqlDatabaseInstance_deleteReplicasAfterSwitchover(primaryName, replicaName),
				// We delete replica, but haven't updated the master's replica_names
				ExpectNonEmptyPlan: true,
			},
			{
				// Remove replica from primary's resource
				Config: googleSqlDatabaseInstance_removeReplicaFromPrimaryAfterSwitchover(replicaName),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_MysqlEplusWithFailoverReplicaSetupWithPrivateNetwork(t *testing.T) {
	t.Parallel()

	primaryName := "tf-test-mysql-primary-" + acctest.RandString(t, 10)
	replicaName := "tf-test-mysql-replica-" + acctest.RandString(t, 10)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, "endpoint")
	projectId := envvar.GetTestProjectFromEnv()

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_mySqlEplusPrimaryReplicaSetupWithPrivateNetwork(projectId, primaryName, replicaName, networkName, "MYSQL_8_0"),
				Check:  resource.ComposeTestCheckFunc(verifyCreateOperationOnEplusWithPrivateNetwork("google_sql_database_instance.primary")),
			},
			{
				ResourceName:            "google_sql_database_instance.primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_setMySqlFailoverReplicaEplusWithPrivateNetwork(projectId, primaryName, replicaName, networkName, "MYSQL_8_0"),
				Check:  resource.ComposeTestCheckFunc(verifyCreateOperationOnEplusWithPrivateNetwork("google_sql_database_instance.primary")),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_PostgresEplusWithFailoverReplicaSetupWithPrivateNetwork(t *testing.T) {
	t.Parallel()

	primaryName := "tf-test-postgres-primary-" + acctest.RandString(t, 10)
	replicaName := "tf-test-postgres-replica-" + acctest.RandString(t, 10)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, "endpoint")
	projectId := envvar.GetTestProjectFromEnv()

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_postgresEplusPrimaryReplicaSetupWithPrivateNetwork(projectId, primaryName, replicaName, networkName, "POSTGRES_12"),
				Check:  resource.ComposeTestCheckFunc(verifyCreateOperationOnEplusWithPrivateNetwork("google_sql_database_instance.primary")),
			},
			{
				ResourceName:            "google_sql_database_instance.primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_setPostgresFailoverReplicaEplusWithPrivateNetwork(projectId, primaryName, replicaName, networkName, "POSTGRES_12"),
				Check:  resource.ComposeTestCheckFunc(verifyCreateOperationOnEplusWithPrivateNetwork("google_sql_database_instance.primary")),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_MysqlEplusWithPrivateNetwork(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, "endpoint")
	projectId := envvar.GetTestProjectFromEnv()

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusOnPrivateNetwork(projectId, networkName, instanceName, "MYSQL_8_0"),
				Check:  resource.ComposeTestCheckFunc(verifyCreateOperationOnEplusWithPrivateNetwork("google_sql_database_instance.instance")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_PostgresEplusWithPrivateNetwork(t *testing.T) {
	t.Parallel()

	instanceName := "tf-test-" + acctest.RandString(t, 10)
	networkName := acctest.BootstrapSharedServiceNetworkingConnection(t, "endpoint")
	projectId := envvar.GetTestProjectFromEnv()

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusOnPrivateNetwork(projectId, networkName, instanceName, "POSTGRES_12"),
				Check:  resource.ComposeTestCheckFunc(verifyCreateOperationOnEplusWithPrivateNetwork("google_sql_database_instance.instance")),
			},
			{
				ResourceName:            "google_sql_database_instance.instance",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateIdPrefix:     fmt.Sprintf("%s/", projectId),
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

// Switchover for MySQL.
func TestAccSqlDatabaseInstance_MysqlSwitchoverSuccess(t *testing.T) {
	t.Parallel()
	primaryName := "tf-test-mysql-sw-primary-" + acctest.RandString(t, 10)
	replicaName := "tf-test-mysql-sw-replica-" + acctest.RandString(t, 10)
	project := envvar.GetTestProjectFromEnv()
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_mysqlEplusWithReplica(project, primaryName, replicaName),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			{
				ResourceName:            "google_sql_database_instance.original-replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			// Let's make sure that setting and unsetting failover replica works.
			// Make sure we test both normalized and shortened version of DR replica
			// names.
			{
				Config: googleSqlDatabaseInstance_mysqlSetFailoverReplica(project, primaryName, replicaName, false /* =useNormalizedDrReplicaName */),
			},
			{
				Config: googleSqlDatabaseInstance_mysqlUnsetFailoverReplica(project, primaryName, replicaName),
			},
			{
				Config: googleSqlDatabaseInstance_mysqlSetFailoverReplica(project, primaryName, replicaName, true /* =useNormalizedDrReplicaName */),
			},
			{
				// Split into two configs because current TestStep implementation checks diff before refreshing.
				Config: googleSqlDatabaseInstance_mysqlSwitchoverOnReplica(project, primaryName, replicaName),
				// Original primary needs to be updated at the next step.
				ExpectNonEmptyPlan: true,
			},
			{
				Config: googleSqlDatabaseInstance_mysqlUpdatePrimaryAfterSwitchover(project, primaryName, replicaName),
			},
			{
				RefreshState: true,
				Check:        resource.ComposeTestCheckFunc(resource.TestCheckTypeSetElemAttr("google_sql_database_instance.original-replica", "replica_names.*", primaryName), checkSwitchoverOriginalReplicaConfigurations("google_sql_database_instance.original-replica"), checkSwitchoverOriginalPrimaryConfigurations("google_sql_database_instance.original-primary", replicaName)),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			{
				ResourceName:      "google_sql_database_instance.original-replica",
				ImportState:       true,
				ImportStateVerify: true,
				// original-replica is no longer a replica, but replica_configuration is O + C and cannot be unset
				ImportStateVerifyIgnore: []string{"replica_configuration", "deletion_protection", "root_password"},
			},
			{
				// Delete replica first so PostTestDestroy doesn't fail when deleting instances which have replicas. We've already validated switchover behavior, the remaining steps are cleanup
				Config: googleSqlDatabaseInstance_mysqlDeleteReplicasAfterSwitchover(project, primaryName, replicaName),
				// We delete replica, but haven't updated the master's replica_names
				ExpectNonEmptyPlan: true,
			},
			{
				// Remove replica from primary's resource
				Config: googleSqlDatabaseInstance_mysqlRemoveReplicaFromPrimaryAfterSwitchover(project, replicaName),
			},
		},
	})
}

// Switchover for PostgreSQL.
func TestAccSqlDatabaseInstance_PostgresSwitchoverSuccess(t *testing.T) {
	t.Parallel()
	primaryName := "tf-test-pg-sw-primary-" + acctest.RandString(t, 10)
	replicaName := "tf-test-pg-sw-replica-" + acctest.RandString(t, 10)
	project := envvar.GetTestProjectFromEnv()
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_postgresEplusWithReplica(project, primaryName, replicaName),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			{
				ResourceName:            "google_sql_database_instance.original-replica",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			// Let's make sure that setting and unsetting failover replica works.
			// Make sure we test both normalized and shortened version of DR replica
			// names.
			{
				Config: googleSqlDatabaseInstance_postgresSetFailoverReplica(project, primaryName, replicaName, false /* =useNormalizedDrReplicaName */),
			},
			{
				Config: googleSqlDatabaseInstance_postgresUnsetFailoverReplica(project, primaryName, replicaName),
			},
			{
				Config: googleSqlDatabaseInstance_postgresSetFailoverReplica(project, primaryName, replicaName, true /* =useNormalizedDrReplicaName */),
			},
			{
				// Split into two configs because current TestStep implementation checks diff before refreshing.
				Config: googleSqlDatabaseInstance_postgresSwitchoverOnReplica(project, primaryName, replicaName),
				// Original primary needs to be updated at the next step.
				ExpectNonEmptyPlan: true,
			},
			{
				Config: googleSqlDatabaseInstance_postgresUpdatePrimaryAfterSwitchover(project, primaryName, replicaName),
			},
			{
				RefreshState: true,
				Check:        resource.ComposeTestCheckFunc(resource.TestCheckTypeSetElemAttr("google_sql_database_instance.original-replica", "replica_names.*", primaryName), checkSwitchoverOriginalReplicaConfigurations("google_sql_database_instance.original-replica"), checkSwitchoverOriginalPrimaryConfigurations("google_sql_database_instance.original-primary", replicaName)),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: ignoredReplicaConfigurationFields,
			},
			{
				ResourceName:      "google_sql_database_instance.original-replica",
				ImportState:       true,
				ImportStateVerify: true,
				// original-replica is no longer a replica, but replica_configuration is O + C and cannot be unset
				ImportStateVerifyIgnore: []string{"replica_configuration", "deletion_protection", "root_password"},
			},
			{
				// Delete replica first so PostTestDestroy doesn't fail when deleting instances which have replicas. We've already validated switchover behavior, the remaining steps are cleanup
				Config: googleSqlDatabaseInstance_postgresDeleteReplicasAfterSwitchover(project, primaryName, replicaName),
				// We delete replica, but haven't updated the master's replica_names
				ExpectNonEmptyPlan: true,
			},
			{
				// Remove replica from primary's resource
				Config: googleSqlDatabaseInstance_postgresRemoveReplicaFromPrimaryAfterSwitchover(project, replicaName),
			},
		},
	})
}

// Read pool for Postgres. Scale out (change node count)
func TestAccSqlDatabaseInstance_PostgresReadPoolScaleOutSuccess(t *testing.T) {
	t.Parallel()
	primaryName := "tf-test-pg-readpool-primary-" + acctest.RandString(t, 10)
	readPoolName := "tf-test-pg-readpool-" + acctest.RandString(t, 10)
	project := envvar.GetTestProjectFromEnv()
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType: "POSTGRES_15",
					ReplicaName:  readPoolName,
					NodeCount:    1,
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType: "POSTGRES_15",
					ReplicaName:  readPoolName,
					NodeCount:    2,
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

// Read pool for Postgres. Scale up (change machine type)
func TestAccSqlDatabaseInstance_PostgresReadPoolScaleUpSuccess(t *testing.T) {
	t.Parallel()
	primaryName := "tf-test-pg-readpool-mtc-primary-" + acctest.RandString(t, 10)
	readPoolName := "tf-test-pg-readpool-mtc-" + acctest.RandString(t, 10)
	project := envvar.GetTestProjectFromEnv()
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:       "POSTGRES_15",
					ReplicaName:        readPoolName,
					NodeCount:          1,
					ReplicaMachineType: "db-perf-optimized-N-2",
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:       "POSTGRES_15",
					ReplicaName:        readPoolName,
					NodeCount:          1,
					ReplicaMachineType: "db-perf-optimized-N-4",
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

// Read pool for MySQL. Enable and disable read pool
func TestAccSqlDatabaseInstance_MysqlReadPoolEnableDisableSuccess(t *testing.T) {
	t.Parallel()
	primaryName := "tf-test-mysql-readpool-primary-" + acctest.RandString(t, 10)
	readPoolName := "tf-test-mysql-readpool-" + acctest.RandString(t, 10)
	project := envvar.GetTestProjectFromEnv()
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType: "MYSQL_8_0",
					ReplicaName:  readPoolName,
					InstanceType: "READ_REPLICA_INSTANCE",
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			// Enable read pool
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType: "MYSQL_8_0",
					ReplicaName:  readPoolName,
					InstanceType: "READ_POOL_INSTANCE",
					NodeCount:    1,
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			// Disable read pool
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType: "MYSQL_8_0",
					ReplicaName:  readPoolName,
					InstanceType: "READ_REPLICA_INSTANCE",
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

// Read pool for MySQL. Enable and disable read pool auto scale
func TestAccSqlDatabaseInstance_MysqlReadPoolAutoScaleEnableDisableSuccess(t *testing.T) {
	t.Parallel()
	primaryName := "tf-test-mysql-as-readpool-primary-" + acctest.RandString(t, 10)
	readPoolName := "tf-test-mysql-as-readpool-" + acctest.RandString(t, 10)
	project := envvar.GetTestProjectFromEnv()
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType: "MYSQL_8_0",
					ReplicaName:  readPoolName,
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			// Enable auto scale
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:     "MYSQL_8_0",
					ReplicaName:      readPoolName,
					AutoScaleEnabled: true,
					NodeCount:        2,
					MaxNodeCount:     2,
					MinNodeCount:     2,
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			// Disable auto scale
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:     "MYSQL_8_0",
					ReplicaName:      readPoolName,
					AutoScaleEnabled: false,
				}),
			},
			{
				ResourceName:            "google_sql_database_instance.original-primary",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
			{
				ResourceName:            "google_sql_database_instance.original-read-pool",
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

// Read pool for Postgres. Modify Node Count when auto scale enabled
func TestAccSqlDatabaseInstance_PostgresReadPoolAutoScaleChangeNodeCount(t *testing.T) {
	t.Parallel()
	primaryName := "tf-test-postgreas-as-readpool-primary-" + acctest.RandString(t, 10)
	readPoolName := "tf-test-postgres-as-readpool-" + acctest.RandString(t, 10)
	project := envvar.GetTestProjectFromEnv()
	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			// Create with auto scale takes min node count as node count
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:     "POSTGRES_15",
					ReplicaName:      readPoolName,
					AutoScaleEnabled: true,
					NodeCount:        2,
					MinNodeCount:     1,
					MaxNodeCount:     5,
				}),
				Check: testGoogleSqlDatabaseInstanceCheckNodeCount(t, readPoolName, 1, 1, 5),
			},
			// Change node count not respected
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:     "POSTGRES_15",
					ReplicaName:      readPoolName,
					AutoScaleEnabled: true,
					NodeCount:        4,
					MinNodeCount:     1,
					MaxNodeCount:     5,
				}),
				Check: resource.ComposeTestCheckFunc(
					testGoogleSqlDatabaseInstanceCheckNodeCount(t, readPoolName, 1, 1, 5),
					testGoogleSqlDatabaseInstanceChangeNodeCount(t, readPoolName, 3),
				), // Simulate auto scale to 3 nodes.

			},
			// Change Min/Max (no change to node count)
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:     "POSTGRES_15",
					ReplicaName:      readPoolName,
					AutoScaleEnabled: true,
					NodeCount:        4,
					MinNodeCount:     2,
					MaxNodeCount:     4,
				}),
				Check: testGoogleSqlDatabaseInstanceCheckNodeCount(t, readPoolName, 3, 2, 4),
			},
			// Change Min (higher than node count), sets node count
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:     "POSTGRES_15",
					ReplicaName:      readPoolName,
					AutoScaleEnabled: true,
					NodeCount:        3,
					MinNodeCount:     4,
					MaxNodeCount:     5,
				}),
				Check: testGoogleSqlDatabaseInstanceCheckNodeCount(t, readPoolName, 4, 4, 5),
			},
			// Change Max (lower than node count), sets node count
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:     "POSTGRES_15",
					ReplicaName:      readPoolName,
					AutoScaleEnabled: true,
					NodeCount:        5,
					MinNodeCount:     3,
					MaxNodeCount:     3,
				}),
				Check: testGoogleSqlDatabaseInstanceCheckNodeCount(t, readPoolName, 3, 3, 3),
			},
			// Disable auto scale, sets node count
			{
				Config: testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName, ReadPoolConfig{
					DatabaseType:     "POSTGRES_15",
					ReplicaName:      readPoolName,
					AutoScaleEnabled: false,
					NodeCount:        2,
				}),
				Check: testGoogleSqlDatabaseInstanceCheckNodeCount(t, readPoolName, 2, 0, 0),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_updateSslOptionsForPostgreSQL(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	databaseVersion := "POSTGRES_14"
	resourceName := "google_sql_database_instance.instance"

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),

		// We don't do ImportStateVerify for the ssl_mode because of the implementation. The ssl_mode is expected to be discarded if the local state doesn't have it.
		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_setSslOptionsForPostgreSQL(databaseName, databaseVersion, "ALLOW_UNENCRYPTED_AND_ENCRYPTED"),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.ssl_mode", "ALLOW_UNENCRYPTED_AND_ENCRYPTED"),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "settings.0.ip_configuration.0.ssl_mode"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_setSslOptionsForPostgreSQL(databaseName, databaseVersion, "ENCRYPTED_ONLY"),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.ssl_mode", "ENCRYPTED_ONLY"),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "settings.0.ip_configuration.0.ssl_mode"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_setSslOptionsForPostgreSQL(databaseName, databaseVersion, "TRUSTED_CLIENT_CERTIFICATE_REQUIRED"),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.ssl_mode", "TRUSTED_CLIENT_CERTIFICATE_REQUIRED"),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "settings.0.ip_configuration.0.ssl_mode"},
			},
			{
				Config: testGoogleSqlDatabaseInstance_setSslOptionsForPostgreSQL(databaseName, databaseVersion, "ALLOW_UNENCRYPTED_AND_ENCRYPTED"),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.ssl_mode", "ALLOW_UNENCRYPTED_AND_ENCRYPTED"),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection", "settings.0.ip_configuration.0.ssl_mode"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_useInternalCaByDefault(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	resourceName := "google_sql_database_instance.instance"

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),

		Steps: []resource.TestStep{
			{
				Config: fmt.Sprintf(testGoogleSqlDatabaseInstance_basic3, databaseName),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.server_ca_mode", "GOOGLE_MANAGED_INTERNAL_CA"),
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.server_ca_pool", ""),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_useCasBasedServerCa(t *testing.T) {
	t.Parallel()

	databaseName := "tf-test-" + acctest.RandString(t, 10)
	resourceName := "google_sql_database_instance.instance"

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),

		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_setCasServerCa(databaseName, "GOOGLE_MANAGED_CAS_CA"),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.server_ca_mode", "GOOGLE_MANAGED_CAS_CA"),
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.server_ca_pool", ""),
					resource.TestCheckResourceAttr(resourceName, "dns_names.#", "1"),
					resource.TestCheckResourceAttr(resourceName, "dns_names.0.connection_type", "PUBLIC"),
					resource.TestCheckResourceAttr(resourceName, "dns_names.0.dns_scope", "INSTANCE"),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_useCustomSubjectAlternateName(t *testing.T) {
	t.Parallel()

	resourceName := "google_sql_database_instance.instance"

	context := map[string]interface{}{
		"projectID":       envvar.GetTestProjectFromEnv(),
		"databaseName":    "tf-test-" + acctest.RandString(t, 10),
		"casRandomSuffix": acctest.RandString(t, 10),
		"customSan":       "test.example.com",
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		CheckDestroy: testAccSqlDatabaseInstanceDestroyProducer(t),

		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_setCustomSubjectAlternateName(context),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.server_ca_mode", "CUSTOMER_MANAGED_CAS_CA"),
					resource.TestCheckTypeSetElemAttr(resourceName, "settings.0.ip_configuration.0.custom_subject_alternative_names.*", "test.example.com"),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_useCustomerManagedServerCa(t *testing.T) {
	t.Parallel()

	resourceName := "google_sql_database_instance.instance"

	context := map[string]interface{}{
		"projectID":       envvar.GetTestProjectFromEnv(),
		"databaseName":    "tf-test-" + acctest.RandString(t, 10),
		"casRandomSuffix": acctest.RandString(t, 10),
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		ExternalProviders: map[string]resource.ExternalProvider{
			"time": {},
		},
		CheckDestroy: testAccSqlDatabaseInstanceDestroyProducer(t),

		Steps: []resource.TestStep{
			{
				Config: testGoogleSqlDatabaseInstance_setCustomerManagedServerCa(context),
				Check: resource.ComposeTestCheckFunc(
					resource.TestCheckResourceAttr(resourceName, "settings.0.ip_configuration.0.server_ca_mode", "CUSTOMER_MANAGED_CAS_CA"),
				),
			},
			{
				ResourceName:            resourceName,
				ImportState:             true,
				ImportStateVerify:       true,
				ImportStateVerifyIgnore: []string{"deletion_protection"},
			},
		},
	})
}

func TestAccSqlDatabaseInstance_DiskSizeAutoResizeWithoutDiskSize(t *testing.T) {
	t.Parallel()

	project := envvar.GetTestProjectFromEnv()
	databaseName := "tf-test-" + acctest.RandString(t, 10)

	trueVar := true
	falseVar := false

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				// Create DB with disk size 10gb (minimal) - no disk size specified in configuration, auto resize enabled
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 0, 100, nil, false, false),
				// Add additional 2gb outside of TF to simulate increase in disk size
				Check: testGoogleSqlDatabaseInstanceResizeDisk(t, databaseName, 2),
			},
			{
				// Disk size is now 12gb - requested (original value) 10gb, configuration is empty - should not trigger resize, no errors.
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 0, 101, nil, false, false),
				Check:  testGoogleSqlDatabaseInstanceCheckDiskSize(t, databaseName, 12),
			},
			{
				// Disk size is now 12gb - requested (original value) 10gb, configuration is empty - should not trigger resize, no errors.
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 0, 101, &trueVar, false, false),
				Check:  testGoogleSqlDatabaseInstanceCheckDiskSize(t, databaseName, 12),
			},
			{
				// Disk size is now 12gb - requested (original value) 10gb, configuration is empty - disable auto resize - should not error.
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 0, 101, &falseVar, false, false),
				Check:  testGoogleSqlDatabaseInstanceCheckDiskSize(t, databaseName, 12),
			},
			{
				// Disk size is now 12gb - requested (original value) 10gb, configuration is empty - disable auto resize, but enable deletion protection should not error.
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 0, 101, &falseVar, true, false),
				Check:  testGoogleSqlDatabaseInstanceCheckDiskSize(t, databaseName, 12),
			},
			{
				// Allow destroy
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 0, 101, &falseVar, true, true),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_DiskSizeAutoResizeWithDiskSize(t *testing.T) {
	t.Parallel()

	project := envvar.GetTestProjectFromEnv()
	databaseName := "tf-test-" + acctest.RandString(t, 10)

	trueVar := true
	falseVar := false

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				// Create DB with disk size 12gb with auto resize enabled
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 12, 100, nil, false, false),
				// Add additional 2gb outside of TF to simulate increase in disk size
				Check: testGoogleSqlDatabaseInstanceResizeDisk(t, databaseName, 2),
			},
			{
				// Disk size is now 14gb - requested (original value) 12gb and auto resize enable - should not trigger resize, no errors.
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 12, 101, nil, false, false),
				Check:  testGoogleSqlDatabaseInstanceCheckDiskSize(t, databaseName, 14),
			},
			{
				// Disk size is now 14gb - requested 13gb in configuration, still less - should not trigger resize, no errors.
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 13, 102, &trueVar, false, false),
				Check:  testGoogleSqlDatabaseInstanceCheckDiskSize(t, databaseName, 14),
			},
			{
				// Disk size is now 14gb - requested 15gb in configuration, that's an additional increase should trigger resize to 15gb.
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 15, 103, nil, false, false),
				Check:  testGoogleSqlDatabaseInstanceCheckDiskSize(t, databaseName, 15),
			},
			{
				// Disk size is now 15gb - requested 14gb, but disabled auto resize - should error because it can't be deleted for replacement.
				Config:      testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 14, 104, &falseVar, false, false),
				ExpectError: regexp.MustCompile("Instance cannot be destroyed"),
			},
			{
				// Disk size is now 15gb - requested 14gb, but ignore changes is set - so should ignore the configuration change.
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 14, 105, &falseVar, true, false),
				Check:  testGoogleSqlDatabaseInstanceCheckDiskSize(t, databaseName, 15),
			},
			{
				// Allow destroy
				Config: testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, databaseName, 14, 105, &falseVar, true, true),
			},
		},
	})
}

func TestEnhancedBackupManagerDiffSuppressFunc(t *testing.T) {
	cases := map[string]struct {
		key            string
		old            string
		new            string
		backupTier     string
		expectSuppress bool
		description    string
	}{
		"suppress enabled diff when backup tier is enhanced": {
			key:            "settings.0.backup_configuration.0.enabled",
			old:            "true",
			new:            "false",
			backupTier:     "ENHANCED",
			expectSuppress: true,
			description:    "enabled should be suppressed when ENHANCED",
		},
		"suppress start_time diff when backup tier is enhanced": {
			key:            "settings.0.backup_configuration.0.start_time",
			old:            "03:00",
			new:            "05:00",
			backupTier:     "ENHANCED",
			expectSuppress: true,
			description:    "start_time should be suppressed when ENHANCED",
		},
		"suppress binary_log_enabled diff when backup tier is enhanced": {
			key:            "settings.0.backup_configuration.0.binary_log_enabled",
			old:            "true",
			new:            "false",
			backupTier:     "ENHANCED",
			expectSuppress: true,
			description:    "binary_log_enabled should be suppressed when ENHANCED",
		},
		"suppress point_in_time_recovery_enabled diff when backup tier is enhanced": {
			key:            "settings.0.backup_configuration.0.point_in_time_recovery_enabled",
			old:            "false",
			new:            "true",
			backupTier:     "ENHANCED",
			expectSuppress: true,
			description:    "point_in_time_recovery_enabled should be suppressed when ENHANCED",
		},
		"suppress transaction_log_retention_days diff when backup tier is enhanced": {
			key:            "settings.0.backup_configuration.0.transaction_log_retention_days",
			old:            "7",
			new:            "14",
			backupTier:     "ENHANCED",
			expectSuppress: true,
			description:    "transaction_log_retention_days should be suppressed when ENHANCED",
		},
		"suppress retained_backups diff when backup tier is enhanced": {
			key:            "settings.0.backup_configuration.0.backup_retention_settings.0.retained_backups",
			old:            "7",
			new:            "14",
			backupTier:     "ENHANCED",
			expectSuppress: true,
			description:    "retained_backups should be suppressed when ENHANCED",
		},
		"do not suppress diff when backup tier is standard": {
			key:            "settings.0.backup_configuration.0.enabled",
			old:            "true",
			new:            "false",
			backupTier:     "STANDARD",
			expectSuppress: false,
			description:    "enabled should NOT be suppressed when STANDARD",
		},
		"do not suppress diff when backup tier is empty": {
			key:            "settings.0.backup_configuration.0.enabled",
			old:            "true",
			new:            "false",
			backupTier:     "",
			expectSuppress: false,
			description:    "enabled should NOT be suppressed when backup_tier is empty",
		},
		"do not suppress when old and new are same": {
			key:            "settings.0.backup_configuration.0.enabled",
			old:            "true",
			new:            "true",
			backupTier:     "ENHANCED",
			expectSuppress: true,
			description:    "no diff to suppress when old and new are same",
		},
	}

	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			// Build real *schema.ResourceData using the resource schema and TestResourceDataRaw
			// Put backup_tier into the nested settings->backup_configuration block (state)
			rd := schema.TestResourceDataRaw(t, sql.ResourceSqlDatabaseInstance().Schema, map[string]interface{}{
				"name": "test-instance",
				"settings": []interface{}{
					map[string]interface{}{
						"backup_configuration": []interface{}{
							map[string]interface{}{
								"backup_tier": tc.backupTier,
							},
						},
					},
				},
			})

			suppressed := sql.EnhancedBackupManagerDiffSuppressFunc(tc.key, tc.old, tc.new, rd)

			if suppressed != tc.expectSuppress {
				t.Errorf("expected suppressed to be %v but got %v. Desc: %s", tc.expectSuppress, suppressed, tc.description)
			}
		})
	}
}

func TestAccSqlDatabaseInstance_updateInstanceTierForEnhancedBackupTierInstance(t *testing.T) {
	t.Parallel()

	backupVaultID := "bv-test"
	location := "us-central1"
	project := envvar.GetTestProjectFromEnv()
	backupVault := acctest.BootstrapBackupDRVault(t, backupVaultID, location)

	context := map[string]interface{}{
		"random_suffix":   acctest.RandString(t, 10),
		"project":         project,
		"backup_vault_id": backupVaultID,
		"backup_vault":    backupVault,
		"db_version":      "MYSQL_8_0_41",
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				// Create backup plan and associate with instance
				Config: testGoogleSqlDatabaseInstance_attachGCBDR(context),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttrSet("google_backup_dr_backup_plan_association.backup_association", "id"),
				),
			},
			{
				// Update instance backup tier to ENHANCED, which should ignore backup_configuration settings
				Config: testGoogleSqlDatabaseInstance_updateTierForGcbdrManagedInstance(context),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.tier", "db-g1-small"),
				),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_majorVersionUpgradeForEnhancedBackupTierInstance(t *testing.T) {
	t.Parallel()

	backupVault := acctest.BootstrapBackupDRVault(t, "bv-test", "us-central1")

	context := map[string]interface{}{
		"random_suffix": acctest.RandString(t, 10),
		"project":       envvar.GetTestProjectFromEnv(),
		"backup_vault":  backupVault,
		"db_version":    "MYSQL_8_0_41",
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				// Create backup plan and associate with instance
				Config: testGoogleSqlDatabaseInstance_attachGCBDR(context),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttrSet("google_backup_dr_backup_plan_association.backup_association", "id"),
				),
			},
			{
				// Update instance database version to a new major version, which should ignore backup_configuration settings
				Config: testGoogleSqlDatabaseInstance_majorVersionUpgradeGcbdrManagedInstance(context),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "database_version", "MYSQL_8_0_42"),
				),
			},
		},
	})
}

func TestAccSqlDatabaseInstance_editionUpdateForEnhancedBackupTierInstance(t *testing.T) {
	t.Parallel()

	backupVault := acctest.BootstrapBackupDRVault(t, "bv-test", "us-central1")

	context := map[string]interface{}{
		"random_suffix": acctest.RandString(t, 10),
		"project":       envvar.GetTestProjectFromEnv(),
		"backup_vault":  backupVault,
		"db_version":    "MYSQL_8_0_41",
		"edition":       "ENTERPRISE",
		"tier":          "db-f1-micro",
	}

	acctest.VcrTest(t, resource.TestCase{
		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
		CheckDestroy:             testAccSqlDatabaseInstanceDestroyProducer(t),
		Steps: []resource.TestStep{
			{
				// Create backup plan and associate with instance
				Config: testGoogleSqlDatabaseInstance_attachGCBDR(context),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttrSet("google_backup_dr_backup_plan_association.backup_association", "id"),
				),
			},
			{
				// Edition upgrade, which should ignore backup_configuration settings
				Config: testGoogleSqlDatabaseInstance_editionUpdateForGcbdrManagedInstance(context, "ENTERPRISE_PLUS", "db-perf-optimized-N-4"),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE_PLUS"),
				),
			},
			{
				// Edition downgrade, which should ignore backup_configuration settings
				Config: testGoogleSqlDatabaseInstance_editionUpdateForGcbdrManagedInstance(context, "ENTERPRISE", "db-f1-micro"),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("google_sql_database_instance.instance", "settings.0.edition", "ENTERPRISE"),
				),
			},
		},
	})
}

func testGoogleSqlDatabaseInstance_attachGCBDR(context map[string]interface{}) string {
	return acctest.Nprintf(`
data "google_project" "project" {}

resource "google_sql_database_instance" "instance" {
  name             = "tf-test-instance-%{random_suffix}"
  database_version = "%{db_version}"
  region           = "us-central1"

  settings {
    tier = "db-f1-micro"
  }
    deletion_protection = false
}

resource "google_backup_dr_backup_plan" "plan" {
  location       = "us-central1"
  backup_plan_id = "tf-test-bp-test-%{random_suffix}"
  resource_type  = "sqladmin.googleapis.com/Instance"
  backup_vault   = "%{backup_vault}"

  backup_rules {
    rule_id                = "rule-1"
    backup_retention_days  = 7

    standard_schedule {
      recurrence_type     = "DAILY"
      hourly_frequency    = 6
      time_zone           = "UTC"

      backup_window {
        start_hour_of_day = 0
        end_hour_of_day   = 23
      }
    }
  }
}

resource "google_backup_dr_backup_plan_association" "backup_association" {
  location                      = "us-central1" 
  backup_plan_association_id    = "tf-test-bpa-test-%{random_suffix}"
  resource                      = "projects/${data.google_project.project.project_id}/instances/${google_sql_database_instance.instance.name}"
  resource_type                 = "sqladmin.googleapis.com/Instance"
  backup_plan                   = google_backup_dr_backup_plan.plan.name
}
`, context)
}

func testGoogleSqlDatabaseInstance_updateTierForGcbdrManagedInstance(context map[string]interface{}) string {
	return acctest.Nprintf(`
data "google_project" "project" {}

resource "google_sql_database_instance" "instance" {
  name             = "tf-test-instance-%{random_suffix}"
  database_version = "%{db_version}"
  region           = "us-central1"

  settings {
    tier = "db-g1-small"

    backup_configuration {
      enabled            = false
      binary_log_enabled = false
      start_time         = "05:00"
      
      backup_retention_settings {
        retained_backups = 8
		retention_unit   = "COUNT"
      }
    }
  }
	deletion_protection = false
}

resource "google_backup_dr_backup_plan" "plan" {
  location       = "us-central1"
  backup_plan_id = "tf-test-bp-test-%{random_suffix}"
  resource_type  = "sqladmin.googleapis.com/Instance"
  backup_vault   = "%{backup_vault}"

  backup_rules {
    rule_id                = "rule-1"
    backup_retention_days  = 7

    standard_schedule {
      recurrence_type     = "DAILY"
      hourly_frequency    = 6
      time_zone           = "UTC"

      backup_window {
        start_hour_of_day = 0
        end_hour_of_day   = 23
      }
    }
  }
}

resource "google_backup_dr_backup_plan_association" "backup_association" {
  location                      = "us-central1" 
  backup_plan_association_id    = "tf-test-bpa-test-%{random_suffix}"
  resource                      = "projects/${data.google_project.project.project_id}/instances/${google_sql_database_instance.instance.name}"
  resource_type                 = "sqladmin.googleapis.com/Instance"
  backup_plan                   = google_backup_dr_backup_plan.plan.name
}
`, context)
}

func testGoogleSqlDatabaseInstance_majorVersionUpgradeGcbdrManagedInstance(context map[string]interface{}) string {
	return acctest.Nprintf(`
data "google_project" "project" {}

resource "google_sql_database_instance" "instance" {
  name             = "tf-test-instance-%{random_suffix}"
  database_version = "MYSQL_8_0_42"
  region           = "us-central1"

  settings {
    tier = "db-f1-micro"

    backup_configuration {
      enabled            = false
      binary_log_enabled = false
      start_time         = "05:00"
      
      backup_retention_settings {
        retained_backups = 8
		retention_unit   = "COUNT"
      }
    }
  }
	deletion_protection = false
}

resource "google_backup_dr_backup_plan" "plan" {
  location       = "us-central1"
  backup_plan_id = "tf-test-bp-test-%{random_suffix}"
  resource_type  = "sqladmin.googleapis.com/Instance"
  backup_vault   = "%{backup_vault}"

  backup_rules {
    rule_id                = "rule-1"
    backup_retention_days  = 7

    standard_schedule {
      recurrence_type     = "DAILY"
      hourly_frequency    = 6
      time_zone           = "UTC"

      backup_window {
        start_hour_of_day = 0
        end_hour_of_day   = 23
      }
    }
  }
}

resource "google_backup_dr_backup_plan_association" "backup_association" {
  location                      = "us-central1" 
  backup_plan_association_id    = "tf-test-bpa-test-%{random_suffix}"
  resource                      = "projects/${data.google_project.project.project_id}/instances/${google_sql_database_instance.instance.name}"
  resource_type                 = "sqladmin.googleapis.com/Instance"
  backup_plan                   = google_backup_dr_backup_plan.plan.name
}
`, context)
}

func testGoogleSqlDatabaseInstance_editionUpdateForGcbdrManagedInstance(context map[string]interface{}, edition string, tier string) string {
	// Create a copy of the context map to avoid modifying the map from the caller
	localContext := make(map[string]interface{})
	for k, v := range context {
		localContext[k] = v
	}
	localContext["edition"] = edition
	localContext["tier"] = tier
	return acctest.Nprintf(`
data "google_project" "project" {}

resource "google_sql_database_instance" "instance" {
  name             = "tf-test-instance-%{random_suffix}"
  database_version = "%{db_version}"
  region           = "us-central1"

  settings {
    tier = "%{tier}"
    edition = "%{edition}"

    backup_configuration {
      enabled            = false
      binary_log_enabled = false
      start_time         = "05:00"
      
      backup_retention_settings {
        retained_backups = 8
		retention_unit   = "COUNT"
      }
    }
  }
	deletion_protection = false
}

resource "google_backup_dr_backup_plan" "plan" {
  location       = "us-central1"
  backup_plan_id = "tf-test-bp-test-%{random_suffix}"
  resource_type  = "sqladmin.googleapis.com/Instance"
  backup_vault   = "%{backup_vault}"

  backup_rules {
    rule_id                = "rule-1"
    backup_retention_days  = 7

    standard_schedule {
      recurrence_type     = "DAILY"
      hourly_frequency    = 6
      time_zone           = "UTC"

      backup_window {
        start_hour_of_day = 0
        end_hour_of_day   = 23
      }
    }
  }
}

resource "google_backup_dr_backup_plan_association" "backup_association" {
  location                      = "us-central1" 
  backup_plan_association_id    = "tf-test-bpa-test-%{random_suffix}"
  resource                      = "projects/${data.google_project.project.project_id}/instances/${google_sql_database_instance.instance.name}"
  resource_type                 = "sqladmin.googleapis.com/Instance"
  backup_plan                   = google_backup_dr_backup_plan.plan.name
}
`, localContext)
}

func testGoogleSqlDatabaseInstance_setCustomSubjectAlternateName(context map[string]interface{}) string {
	return acctest.Nprintf(`
data "google_project" "project" {
  project_id = "%{projectID}"
}

resource "google_privateca_ca_pool" "customer_ca_pool" {
  name     = "tf-test-cap-%{casRandomSuffix}"
  location = "us-central1"
  tier     = "DEVOPS"

  publishing_options {
    publish_ca_cert = false
    publish_crl     = false
  }
}

resource "google_privateca_certificate_authority" "customer_ca" {
  pool                                   = google_privateca_ca_pool.customer_ca_pool.name
  certificate_authority_id               = "tf-test-ca-%{casRandomSuffix}"
  location                               = "us-central1"
  lifetime                               = "86400s"
  type                                   = "SELF_SIGNED"
  deletion_protection                    = false
  skip_grace_period                      = true
  ignore_active_certificates_on_deletion = true

  config {
    subject_config {
      subject {
        organization = "Test LLC"
        common_name  = "my-ca"
      }
    }
    x509_config {
      ca_options {
        is_ca = true
      }
      key_usage {
        base_key_usage {
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
          server_auth = false
        }
      }
    }
  }

  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}

resource "google_privateca_ca_pool_iam_member" "granting" {
  ca_pool  = google_privateca_ca_pool.customer_ca_pool.id
  role     = "roles/privateca.certificateRequester"
  member = "serviceAccount:service-${data.google_project.project.number}@gcp-sa-cloud-sql.iam.gserviceaccount.com"
}

resource "time_sleep" "wait_2_mins" {
  depends_on = [
    google_privateca_certificate_authority.customer_ca,
    google_privateca_ca_pool_iam_member.granting
  ]

  create_duration = "120s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%{databaseName}"
  region              = "us-central1"
  database_version    = "POSTGRES_15"
  deletion_protection = false
  settings {
	tier = "db-f1-micro"
	ip_configuration {
		ipv4_enabled    = "true"
		server_ca_mode  = "CUSTOMER_MANAGED_CAS_CA"
		server_ca_pool  = google_privateca_ca_pool.customer_ca_pool.id
		custom_subject_alternative_names = ["%{customSan}"]
	}
  }

  depends_on = [time_sleep.wait_2_mins]
}
`, context)
}

func testGoogleSqlDatabaseInstance_setCustomerManagedServerCa(context map[string]interface{}) string {
	return acctest.Nprintf(`
data "google_project" "project" {
  project_id = "%{projectID}"
}

resource "google_privateca_ca_pool" "customer_ca_pool" {
  name     = "tf-test-cap-%{casRandomSuffix}"
  location = "us-central1"
  tier     = "DEVOPS"

  publishing_options {
    publish_ca_cert = false
    publish_crl     = false
  }
}

resource "google_privateca_certificate_authority" "customer_ca" {
  pool                                   = google_privateca_ca_pool.customer_ca_pool.name
  certificate_authority_id               = "tf-test-ca-%{casRandomSuffix}"
  location                               = "us-central1"
  lifetime                               = "86400s"
  type                                   = "SELF_SIGNED"
  deletion_protection                    = false
  skip_grace_period                      = true
  ignore_active_certificates_on_deletion = true

  config {
    subject_config {
      subject {
        organization = "Test LLC"
        common_name  = "my-ca"
      }
    }
    x509_config {
      ca_options {
        is_ca = true
      }
      key_usage {
        base_key_usage {
          cert_sign = true
          crl_sign  = true
        }
        extended_key_usage {
          server_auth = false
        }
      }
    }
  }

  key_spec {
    algorithm = "RSA_PKCS1_4096_SHA256"
  }
}

resource "google_privateca_ca_pool_iam_member" "granting" {
  ca_pool  = google_privateca_ca_pool.customer_ca_pool.id
  role     = "roles/privateca.certificateRequester"
  member = "serviceAccount:service-${data.google_project.project.number}@gcp-sa-cloud-sql.iam.gserviceaccount.com"
}


resource "time_sleep" "wait_2_mins" {
  depends_on = [
    google_privateca_certificate_authority.customer_ca,
    google_privateca_ca_pool_iam_member.granting
  ]

  create_duration = "120s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%{databaseName}"
  region              = "us-central1"
  database_version    = "POSTGRES_15"
  deletion_protection = false
  settings {
	tier = "db-f1-micro"
	ip_configuration {
		ipv4_enabled    = "true"
		server_ca_mode  = "CUSTOMER_MANAGED_CAS_CA"
		server_ca_pool  = google_privateca_ca_pool.customer_ca_pool.id
	}
  }

  depends_on = [time_sleep.wait_2_mins]
}
`, context)
}

func testGoogleSqlDatabaseInstance_setCasServerCa(databaseName, serverCaMode string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "POSTGRES_15"
  deletion_protection = false
  settings {
    tier = "db-f1-micro"
    ip_configuration {
      ipv4_enabled    = "true"
      server_ca_mode  = "%s"
    }
  }
}
`, databaseName, serverCaMode)
}

func testGoogleSqlDatabaseInstance_setSslOptionsForPostgreSQL(databaseName string, databaseVersion string, sslMode string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "%s"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
      ipv4_enabled = true
      ssl_mode = "%s"
    }
  }
}`, databaseName, databaseVersion, sslMode)
}

func testAccSqlDatabaseInstance_sqlMysqlInstancePvpExample(context map[string]interface{}) string {
	return acctest.Nprintf(`
resource "google_sql_database_instance" "mysql_pvp_instance_name" {
  name             = "tf-test-mysql-pvp-instance-name%{random_suffix}"
  region           = "asia-northeast1"
  database_version = "MYSQL_8_0"
  root_password = "abcABC123!"
  settings {
    tier              = "db-g1-small"
    password_validation_policy {
      min_length  = 6
      complexity  =  "COMPLEXITY_DEFAULT"
      reuse_interval = 2
      disallow_username_substring = true
      enable_password_policy = true
    }
  }
  deletion_protection =  "%{deletion_protection}"
}
`, context)
}

var testGoogleSqlDatabaseInstance_basic2 = `
resource "google_sql_database_instance" "instance" {
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
  }
}
`

var testGoogleSqlDatabaseInstance_basic3 = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
  }
}
`

var testGoogleSqlDatabaseInstance_basic3_update = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
  }
}
`

var testGoogleSqlDatabaseInstance_basic_mssql = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  database_version    = "SQLSERVER_2019_STANDARD"
  root_password       = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-1-3840"
    collation = "Polish_CI_AS"
  }
}
`

var testGoogleSqlDatabaseInstance_basic_mssql_wo_password = `
resource "google_sql_database_instance" "instance" {
  name                     = "%s"
  database_version         = "SQLSERVER_2019_STANDARD"
  root_password_wo         = "%s"
  root_password_wo_version = "1"
  deletion_protection      = false
  settings {
    tier = "db-custom-1-3840"
    collation = "Polish_CI_AS"
  }
}
`

var testGoogleSqlDatabaseInstance_basic_mssql_wo_password_update = `
resource "google_sql_database_instance" "instance" {
  name                     = "%s"
  database_version         = "SQLSERVER_2019_STANDARD"
  root_password_wo         = "%s"
  root_password_wo_version = "2"
  deletion_protection      = false
  settings {
    tier = "db-custom-1-3840"
    collation = "Polish_CI_AS"
  }
}
`

var testGoogleSqlDatabaseInstance_update_mssql = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  database_version    = "SQLSERVER_2019_STANDARD"
  root_password       = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-1-3840"
    collation = "Polish_CI_AS"
    ip_configuration {
      ipv4_enabled = true
      ssl_mode = "ENCRYPTED_ONLY"
    }
  }
}
`

func testGoogleSqlDatabaseInstance_ActiveDirectoryConfig(databaseName, networkName, rootPassword, adDomainName string) string {
	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance-with-ad" {
  name             = "%s"
  region           = "us-central1"
  database_version = "SQLSERVER_2017_STANDARD"
  root_password    = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-2-7680"
    ip_configuration {
      ipv4_enabled       = "false"
      private_network    = data.google_compute_network.servicenet.self_link
    }

    active_directory_config {
      domain = "%s"
    }
  }
}`, networkName, databaseName, rootPassword, adDomainName)
}

func testGoogleSqlDatabaseInstance_DenyMaintenancePeriodConfig(databaseName, endDate, startDate, time string) string {
	return fmt.Sprintf(`

resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-custom-4-26624"
    deny_maintenance_period {
      end_date     	= "%s"
      start_date	= "%s"
      time 		= "%s"
    }
  }
}`, databaseName, endDate, startDate, time)
}

func testGoogleSqlDatabaseInstance_DefaultEdition(databaseName, databaseVersion, tier string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-east1"
  database_version    = "%s"
  deletion_protection = false
  settings {
    tier = "%s"
  }
}`, databaseName, databaseVersion, tier)
}

func testGoogleSqlDatabaseInstance_EditionConfig_noEdition(databaseName, tier string) string {
	return fmt.Sprintf(`

resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-east1"
  database_version    = "POSTGRES_14"
  deletion_protection = false
  settings {
    tier = "%s"
  }
}`, databaseName, tier)
}

func testGoogleSqlDatabaseInstance_EditionConfig(databaseName, tier, edition string) string {
	return fmt.Sprintf(`

resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-east1"
  database_version    = "POSTGRES_14"
  deletion_protection = false
  settings {
    tier = "%s"
    edition = "%s"
	backup_configuration {
	  transaction_log_retention_days = 7
    }
  }
}`, databaseName, tier, edition)
}

func testGoogleSqlDatabaseInstance_sqlMysql(databaseName, tier string) string {
	return fmt.Sprintf(`

resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-east1"
  database_version    = "MYSQL_8_0_31"
  deletion_protection = false
  settings {
    tier = "%s"
  }
}`, databaseName, tier)
}

func testGoogleSqlDatabaseInstance_sqlMysqlDataCacheConfig(instanceName string, datacache bool) string {
	return fmt.Sprintf(`

resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-east1"
  database_version    = "MYSQL_8_0_31"
  deletion_protection = false
  settings {
    tier = "db-perf-optimized-N-2"
    edition = "ENTERPRISE_PLUS"
    data_cache_config {
        data_cache_enabled = "%t"
    }
  }
}`, instanceName, datacache)
}

func testGoogleSqlDatabaseInstance_sqlPostgresDataCacheConfig(instanceName, tier, edition string, datacache bool) string {
	return fmt.Sprintf(`

resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-east1"
  database_version    = "POSTGRES_14"
  deletion_protection = false
  settings {
    tier = "%s"
    edition = "%s"
    data_cache_config {
        data_cache_enabled = "%t"
    }
  }
}`, instanceName, tier, edition, datacache)
}

func testGoogleSqlDatabaseInstance_SqlServerTimezone(instance, rootPassword, timezone string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-central1"
  database_version = "SQLSERVER_2017_STANDARD"
  root_password    = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-1-3840"
    ip_configuration {
      ipv4_enabled       = "true"
    }
    time_zone = "%s"
  }
}
`, instance, rootPassword, timezone)
}

func testGoogleSqlDatabaseInstance_SqlServerAuditConfig(databaseName, rootPassword, bucketName, uploadInterval, retentionInterval string) string {
	return fmt.Sprintf(`
resource "google_storage_bucket" "gs-bucket" {
  name                      	= "%s"
  location                  	= "US"
  uniform_bucket_level_access = true
}

resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-central1"
  database_version = "SQLSERVER_2017_STANDARD"
  root_password    = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-1-3840"
    ip_configuration {
      ipv4_enabled       = "true"
    }
    sql_server_audit_config {
      bucket = "gs://%s"
      retention_interval = "%s"
      upload_interval = "%s"
    }
  }
}
`, bucketName, databaseName, rootPassword, bucketName, retentionInterval, uploadInterval)
}

func testGoogleSqlDatabaseInstance_SqlServerAuditOptionalBucket(databaseName, rootPassword, uploadInterval, retentionInterval string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-central1"
  database_version = "SQLSERVER_2017_STANDARD"
  root_password    = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-1-3840"
    sql_server_audit_config {
      retention_interval = "%s"
      upload_interval = "%s"
    }
  }
}
`, databaseName, rootPassword, retentionInterval, uploadInterval)
}

func testGoogleSqlDatabaseInstance_NullSmt(databaseName, rootPassword string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-central1"
  database_version = "SQLSERVER_2017_STANDARD"
  root_password    = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-8-53248"
    ip_configuration {
      ipv4_enabled       = "true"
    }
    advanced_machine_features {
    }
  }
}
`, databaseName, rootPassword)
}

func testGoogleSqlDatabaseInstance_Smt(databaseName, rootPassword string, threadsPerCore int) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-central1"
  database_version = "SQLSERVER_2017_STANDARD"
  root_password    = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-8-53248"
    ip_configuration {
      ipv4_enabled       = "true"
    }
    advanced_machine_features {
      threads_per_core = "%d"
    }
  }
}
`, databaseName, rootPassword, threadsPerCore)
}

func testGoogleSqlDatabaseInstance_Timezone(databaseName, rootPassword, timezone string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "%s"
  region           = "us-central1"
  database_version = "SQLSERVER_2017_STANDARD"
  root_password    = "%s"
  deletion_protection = false
  settings {
    tier = "db-custom-1-3840"
    ip_configuration {
      ipv4_enabled       = "true"
    }
    time_zone = "%s"
  }
}
`, databaseName, rootPassword, timezone)
}

func testGoogleSqlDatabaseInstanceConfig_withoutReplica(instanceName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      binary_log_enabled = "true"
      enabled            = "true"
      start_time         = "18:00"
    }
  }
}
`, instanceName)
}

func testGoogleSqlDatabaseInstanceConfig_withReplica(instanceName, failoverName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      binary_log_enabled = "true"
      enabled            = "true"
      start_time         = "18:00"
    }
  }
}

resource "google_sql_database_instance" "instance-failover" {
  name                 = "%s"
  region               = "us-central1"
  database_version     = "MYSQL_5_7"
  master_instance_name = google_sql_database_instance.instance.name
  deletion_protection  = false

  replica_configuration {
    failover_target = "true"
  }

  settings {
    tier = "db-n1-standard-1"
  }
}
`, instanceName, failoverName)
}

func googleSqlDatabaseInstance_replicaPromote(instanceName, failoverName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      binary_log_enabled = "true"
      enabled            = "true"
      start_time         = "18:00"
    }
  }
}

resource "google_sql_database_instance" "instance-failover" {
  name                 = "%s"
  region               = "us-central1"
  database_version     = "MYSQL_5_7"
  deletion_protection  = false

  instance_type = "CLOUD_SQL_INSTANCE"
  settings {
    tier = "db-n1-standard-1"
  }
}
`, instanceName, failoverName)
}

func googleSqlDatabaseInstance_replicaPromoteWithMasterInstanceName(instanceName, failoverName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      binary_log_enabled = "true"
      enabled            = "true"
      start_time         = "18:00"
    }
  }
}

resource "google_sql_database_instance" "instance-failover" {
  name                 = "%s"
  region               = "us-central1"
  master_instance_name = google_sql_database_instance.instance.name
  database_version     = "MYSQL_5_7"
  deletion_protection  = false
  instance_type = "CLOUD_SQL_INSTANCE"
  settings {
    tier = "db-n1-standard-1"
  }
}
`, instanceName, failoverName)
}

func googleSqlDatabaseInstance_replicaPromoteWithMasterInstanceNameAndReplicaConfiguration(instanceName string, failoverName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      binary_log_enabled = "true"
      enabled            = "true"
      start_time         = "18:00"
    }
  }
}

resource "google_sql_database_instance" "instance-failover" {
  name                 = "%s"
  region               = "us-central1"
  master_instance_name = google_sql_database_instance.instance.name
  database_version     = "MYSQL_5_7"
  deletion_protection  = false

  replica_configuration {
    failover_target = "true"
  }

  instance_type = "CLOUD_SQL_INSTANCE"
  settings {
    tier = "db-n1-standard-1"
  }
}
`, instanceName, failoverName)
}

func googleSqlDatabaseInstance_replicaPromoteSkippedWithNoMasterInstanceNameAndNoReplicaConfiguration(instanceName string, failoverName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      binary_log_enabled = "true"
      enabled            = "true"
      start_time         = "18:00"
    }
  }
}

resource "google_sql_database_instance" "instance-failover" {
  name                 = "%s"
  region               = "us-central1"
  database_version     = "MYSQL_5_7"
  deletion_protection  = false
  settings {
    tier = "db-n1-standard-1"
  }
  depends_on = [google_sql_database_instance.instance]
}
`, instanceName, failoverName)
}

func googleSqlDatabaseInstance_replicaPromoteWithReplicaConfiguration(instanceName string, failoverName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      binary_log_enabled = "true"
      enabled            = "true"
      start_time         = "18:00"
    }
  }
}

resource "google_sql_database_instance" "instance-failover" {
  name                 = "%s"
  region               = "us-central1"
  database_version     = "MYSQL_5_7"
  deletion_protection  = false

  replica_configuration {
    failover_target = "true"
  }

  instance_type = "CLOUD_SQL_INSTANCE"
  settings {
    tier = "db-n1-standard-1"
  }
}
`, instanceName, failoverName)
}

// Create SQL server primary with cascadable replica
func testGoogleSqlDatabaseInstanceConfig_SqlServerwithCascadableReplica(primaryName string, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  name                = "%s"
  region              = "us-east1"
  database_version    = "SQLSERVER_2019_ENTERPRISE"
  deletion_protection = false

  root_password = "sqlserver1"
  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}

resource "google_sql_database_instance" "original-replica" {
  name                 = "%s"
  region               = "us-west2"
  database_version     = "SQLSERVER_2019_ENTERPRISE"
  master_instance_name = google_sql_database_instance.original-primary.name
  deletion_protection  = false
  root_password = "sqlserver1"
  replica_configuration {
    cascadable_replica = true
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}
`, primaryName, replicaName)
}

func googleSqlDatabaseInstance_switchoverOnReplica(primaryName string, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  name                = "%s"
  region              = "us-east1"
  database_version    = "SQLSERVER_2019_ENTERPRISE"
  deletion_protection = false

  root_password = "sqlserver1"
  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}

resource "google_sql_database_instance" "original-replica" {
  name                 = "%s"
  region               = "us-west2"
  database_version     = "SQLSERVER_2019_ENTERPRISE"
  deletion_protection  = false
  root_password = "sqlserver1"
  instance_type = "CLOUD_SQL_INSTANCE"
  replica_names = [google_sql_database_instance.original-primary.name]
  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}
`, primaryName, replicaName)
}

func googleSqlDatabaseInstance_updatePrimaryAfterSwitchover(primaryName string, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  name                = "%s"
  region              = "us-east1"
  database_version    = "SQLSERVER_2019_ENTERPRISE"
  deletion_protection = false
  root_password = "sqlserver1"
  instance_type = "READ_REPLICA_INSTANCE"
  master_instance_name = "%s"
  replica_configuration {
	cascadable_replica = true
  }
  replica_names = []
  settings {
	tier              = "db-perf-optimized-N-2"
	edition           = "ENTERPRISE_PLUS"
  }
}

  resource "google_sql_database_instance" "original-replica" {
  name                 = "%s"
  region               = "us-west2"
  database_version     = "SQLSERVER_2019_ENTERPRISE"
  deletion_protection  = false
  root_password = "sqlserver1"
  instance_type = "CLOUD_SQL_INSTANCE"
  replica_names = [google_sql_database_instance.original-primary.name]
  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}
`, primaryName, replicaName, replicaName)
}

// After a switchover, the original-primary is now the replica and must be removed first.
func googleSqlDatabaseInstance_deleteReplicasAfterSwitchover(primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-replica" {
  name                 = "%s"
  region               = "us-west2"
  database_version     = "SQLSERVER_2019_ENTERPRISE"
  deletion_protection  = false
  root_password = "sqlserver1"
  instance_type = "CLOUD_SQL_INSTANCE"
  replica_names = ["%s"]
  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}

`, replicaName, primaryName)
}

// Update original-replica replica_names after deleting original-primary
func googleSqlDatabaseInstance_removeReplicaFromPrimaryAfterSwitchover(replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-replica" {
  name                 = "%s"
  region               = "us-west2"
  database_version     = "SQLSERVER_2019_ENTERPRISE"
  deletion_protection  = false
  root_password = "sqlserver1"
  instance_type = "CLOUD_SQL_INSTANCE"
  replica_names = []
  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}
`, replicaName)
}

func testGoogleSqlDatabaseInstanceConfig_eplusOnPrivateNetwork(project, networkName, instanceName, databaseVersion string) string {
	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "%s"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = "false"
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      enabled            = true
    }
  }
}
`, networkName, project, instanceName, databaseVersion)
}

func testGoogleSqlDatabaseInstanceConfig_mysqlEplusWithReplica(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "MYSQL_8_0"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "MYSQL_8_0"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = google_sql_database_instance.original-primary.name
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      binary_log_enabled = true
    }
  }
}
`, project, primaryName, project, replicaName)
}

func testGoogleSqlDatabaseInstance_setMySqlFailoverReplicaEplusWithPrivateNetwork(project, primaryName, replicaName, networkName, databaseVersion string) string {

	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "%s"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  replication_cluster {
    failover_dr_replica_name = "%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = false
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "%s"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = google_sql_database_instance.primary.name
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = false
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      binary_log_enabled = true
    }
  }
}
`, networkName, project, primaryName, databaseVersion, replicaName, project, replicaName, databaseVersion)
}

func testGoogleSqlDatabaseInstance_setPostgresFailoverReplicaEplusWithPrivateNetwork(project, primaryName, replicaName, networkName, databaseVersion string) string {

	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "%s"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  replication_cluster {
    failover_dr_replica_name = "%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = false
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}

resource "google_sql_database_instance" "replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "%s"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = google_sql_database_instance.primary.name
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = false
      private_network    = data.google_compute_network.servicenet.self_link
    }
  }
}
`, networkName, project, primaryName, databaseVersion, replicaName, project, replicaName, databaseVersion)
}

func testGoogleSqlDatabaseInstance_mySqlEplusPrimaryReplicaSetupWithPrivateNetwork(project, primaryName, replicaName, networkName, databaseVersion string) string {

	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "%s"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = false
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "%s"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = google_sql_database_instance.primary.name
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = false
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      binary_log_enabled = true
    }
  }
}
`, networkName, project, primaryName, databaseVersion, project, replicaName, databaseVersion)
}

func testGoogleSqlDatabaseInstance_postgresEplusPrimaryReplicaSetupWithPrivateNetwork(project, primaryName, replicaName, networkName, databaseVersion string) string {

	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "%s"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = false
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}

resource "google_sql_database_instance" "replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "%s"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = google_sql_database_instance.primary.name
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    ip_configuration {
      ipv4_enabled       = false
      private_network    = data.google_compute_network.servicenet.self_link
    }
  }
}
`, networkName, project, primaryName, databaseVersion, project, replicaName, databaseVersion)
}

func googleSqlDatabaseInstance_mysqlSetFailoverReplica(project, primaryName, replicaName string, useNormalizedDrReplicaName bool) string {
	drReplicaName := fmt.Sprintf("%s:%s", project, replicaName)
	if !useNormalizedDrReplicaName {
		drReplicaName = replicaName
	}

	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "MYSQL_8_0"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  replication_cluster {
    failover_dr_replica_name = "%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "MYSQL_8_0"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = "%s"
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      binary_log_enabled = true
    }
  }
}
`, project, primaryName, drReplicaName, project, replicaName, primaryName)
}

func googleSqlDatabaseInstance_mysqlUnsetFailoverReplica(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "MYSQL_8_0"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  replication_cluster {
    failover_dr_replica_name = ""
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "MYSQL_8_0"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = "%s"
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      binary_log_enabled = true
    }
  }
}
`, project, primaryName, project, replicaName, primaryName)
}

func googleSqlDatabaseInstance_mysqlSwitchoverOnReplica(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "MYSQL_8_0"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  replication_cluster {
    failover_dr_replica_name = "%s:%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "MYSQL_8_0"
  instance_type        = "CLOUD_SQL_INSTANCE"
  replica_names        = ["%s"]
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = "%s:%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}
`, project, primaryName, project, replicaName, project, replicaName, primaryName, project, primaryName)
}

func googleSqlDatabaseInstance_mysqlUpdatePrimaryAfterSwitchover(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project              = "%s"
  name                 = "%s"
  region               = "us-east1"
  database_version     = "MYSQL_8_0"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = "%s"
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = ""
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = false
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "MYSQL_8_0"
  instance_type        = "CLOUD_SQL_INSTANCE"
  replica_names        = ["%s"]
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = "%s:%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}
`, project, primaryName, replicaName, project, replicaName, primaryName, project, primaryName)
}

// After a switchover, the original-primary is now the replica and must be removed first.
func googleSqlDatabaseInstance_mysqlDeleteReplicasAfterSwitchover(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "MYSQL_8_0"
  instance_type        = "CLOUD_SQL_INSTANCE"
  replica_names        = ["%s"]
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = "%s:%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}
`, project, replicaName, primaryName, project, primaryName)
}

// Update original-replica replica_names after deleting original-primary
func googleSqlDatabaseInstance_mysqlRemoveReplicaFromPrimaryAfterSwitchover(project, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "MYSQL_8_0"
  instance_type        = "CLOUD_SQL_INSTANCE"
  replica_names        = []
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = ""
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}
`, project, replicaName)
}

func testGoogleSqlDatabaseInstanceConfig_postgresEplusWithReplica(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "POSTGRES_12"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "POSTGRES_12"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = google_sql_database_instance.original-primary.name
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}
`, project, primaryName, project, replicaName)
}

func googleSqlDatabaseInstance_postgresSetFailoverReplica(project, primaryName, replicaName string, useNormalizedDrReplicaName bool) string {
	drReplicaName := fmt.Sprintf("%s:%s", project, replicaName)
	if !useNormalizedDrReplicaName {
		drReplicaName = replicaName
	}
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "POSTGRES_12"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  replication_cluster {
    failover_dr_replica_name = "%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "POSTGRES_12"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = "%s"
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}
`, project, primaryName, drReplicaName, project, replicaName, primaryName)
}

func googleSqlDatabaseInstance_postgresUnsetFailoverReplica(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "POSTGRES_12"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  replication_cluster {
    failover_dr_replica_name = ""
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "POSTGRES_12"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = "%s"
  deletion_protection  = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
  }
}
`, project, primaryName, project, replicaName, primaryName)
}

func googleSqlDatabaseInstance_postgresSwitchoverOnReplica(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "POSTGRES_12"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  replication_cluster {
    failover_dr_replica_name = "%s:%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "POSTGRES_12"
  instance_type        = "CLOUD_SQL_INSTANCE"
  replica_names        = ["%s"]
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = "%s:%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}
`, project, primaryName, project, replicaName, project, replicaName, primaryName, project, primaryName)
}

func googleSqlDatabaseInstance_postgresUpdatePrimaryAfterSwitchover(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project              = "%s"
  name                 = "%s"
  region               = "us-east1"
  database_version     = "POSTGRES_12"
  instance_type        = "READ_REPLICA_INSTANCE"
  master_instance_name = "%s"
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = ""
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = false
      point_in_time_recovery_enabled = false
    }
  }
}

resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "POSTGRES_12"
  instance_type        = "CLOUD_SQL_INSTANCE"
  replica_names        = ["%s"]
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = "%s:%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}
`, project, primaryName, replicaName, project, replicaName, primaryName, project, primaryName)
}

// After a switchover, the original-primary is now the replica and must be removed first.
func googleSqlDatabaseInstance_postgresDeleteReplicasAfterSwitchover(project, primaryName, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "POSTGRES_12"
  instance_type        = "CLOUD_SQL_INSTANCE"
  replica_names        = ["%s"]
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = "%s:%s"
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}
`, project, replicaName, primaryName, project, primaryName)
}

// Update original-replica replica_names after deleting original-primary
func googleSqlDatabaseInstance_postgresRemoveReplicaFromPrimaryAfterSwitchover(project, replicaName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-replica" {
  project              = "%s"
  name                 = "%s"
  region               = "us-west2"
  database_version     = "POSTGRES_12"
  instance_type        = "CLOUD_SQL_INSTANCE"
  replica_names        = []
  deletion_protection  = false

  replication_cluster {
    failover_dr_replica_name = ""
  }

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
      point_in_time_recovery_enabled = true
    }
  }
}
`, project, replicaName)
}

type ReadPoolConfig struct {
	DatabaseType string
	ReplicaName  string
	// InstanceType specifies the instance type of the replica,
	// defaulting to READ_POOL_INSTANCE.
	//
	// Despite the naming of this struct, you can also set it to
	// READ_REPLICA_INSTANCE to create an ordinary read replica in order
	// to test enable/disable pool scenarios.
	InstanceType string
	NodeCount    int64
	// ReplicaMachineType gives the machine type of the read pool nodes
	// or read replica. It defaults to db-perf-optimized-N-2.
	ReplicaMachineType string
	// AutoScaleEnabled indicates if auto scaling should be enabled on
	// the read pool.
	AutoScaleEnabled bool
	MinNodeCount     int64
	MaxNodeCount     int64
}

func testGoogleSqlDatabaseInstanceConfig_eplusWithReadPool(project, primaryName string, rpconfig ReadPoolConfig) string {
	nodeCountStr := ""
	if rpconfig.NodeCount > 0 {
		nodeCountStr = fmt.Sprintf(`  node_count = %d
`, rpconfig.NodeCount)
	}
	minNodeCountStr := ""
	if rpconfig.MinNodeCount > 0 {
		minNodeCountStr = fmt.Sprintf(`	min_node_count = %d
`, rpconfig.MinNodeCount)
	}
	maxNodeCountStr := ""
	if rpconfig.MaxNodeCount > 0 {
		maxNodeCountStr = fmt.Sprintf(`	max_node_count = %d
`, rpconfig.MaxNodeCount)
	}

	if rpconfig.InstanceType == "" {
		rpconfig.InstanceType = "READ_POOL_INSTANCE"
	}

	if rpconfig.ReplicaMachineType == "" {
		rpconfig.ReplicaMachineType = "db-perf-optimized-N-2"
	}

	primaryTxnLogs := ""
	if strings.HasPrefix(rpconfig.DatabaseType, "MYSQL") {
		primaryTxnLogs = "binary_log_enabled = true\n"
	} else if strings.HasPrefix(rpconfig.DatabaseType, "POSTGRES") {
		primaryTxnLogs = "point_in_time_recovery_enabled = true\n"
	}
	autoScaleConfigStr := ""
	if rpconfig.AutoScaleEnabled {
		cooldownSeconds := 180
		autoScaleConfigStr = fmt.Sprintf(`
	read_pool_auto_scale_config {
		enabled = true
%s
%s
		target_metrics {
			metric = "AVERAGE_CPU_UTILIZATION"
			target_value = 0.5
		}
		scale_in_cooldown_seconds = %d
		scale_out_cooldown_seconds = %d
		disable_scale_in = true
	}
`, minNodeCountStr, maxNodeCountStr, cooldownSeconds, cooldownSeconds)
	} else {
		autoScaleConfigStr = fmt.Sprintf(`
	read_pool_auto_scale_config {
		enabled = false
	}
`)
	}

	return fmt.Sprintf(`
resource "google_sql_database_instance" "original-primary" {
  project             = "%s"
  name                = "%s"
  region              = "us-east1"
  database_version    = "%s"
  instance_type       = "CLOUD_SQL_INSTANCE"
  deletion_protection = false

  settings {
    tier              = "db-perf-optimized-N-2"
    edition           = "ENTERPRISE_PLUS"
    backup_configuration {
      enabled                        = true
%s
    }
  }
}

resource "google_sql_database_instance" "original-read-pool" {
  project              = "%s"
  name                 = "%s"
  region               = "us-east1"
  database_version     = "%s"
  instance_type        = "%s"
%s
  master_instance_name = google_sql_database_instance.original-primary.name
  deletion_protection  = false

  settings {
    tier              = "%s"
    edition           = "ENTERPRISE_PLUS"
    %s
  }
}
`, project, primaryName, rpconfig.DatabaseType, primaryTxnLogs, project, rpconfig.ReplicaName, rpconfig.DatabaseType, rpconfig.InstanceType, nodeCountStr, rpconfig.ReplicaMachineType, autoScaleConfigStr)
}

func testAccSqlDatabaseInstance_basicInstanceForPsc(instanceName string, projectId string, orgId string, billingAccount string) string {
	return fmt.Sprintf(`
resource "google_project" "testproject" {
  name                = "%s"
  project_id          = "%s"
  org_id              = "%s"
  billing_account     = "%s"
  deletion_policy = "DELETE"
}

resource "google_sql_database_instance" "instance" {
  project             = google_project.testproject.project_id
  name                = "%s"
  region              = "us-south1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	}
	availability_type = "REGIONAL"
  }
}
`, projectId, projectId, orgId, billingAccount, instanceName)
}

func testAccSqlDatabaseInstance_withPSCEnabled_withIpV4Enable(instanceName string, projectId string, orgId string, billingAccount string) string {
	return fmt.Sprintf(`
resource "google_project" "testproject" {
  name                = "%s"
  project_id          = "%s"
  org_id              = "%s"
  billing_account     = "%s"
  deletion_policy = "DELETE"
}

resource "google_sql_database_instance" "instance" {
  project             = google_project.testproject.project_id
  name                = "%s"
  region              = "us-south1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
		psc_config {
			psc_enabled = true
		}
		ipv4_enabled = true
    }
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	}
	availability_type = "REGIONAL"
  }
}
`, projectId, projectId, orgId, billingAccount, instanceName)
}

func testAccSqlDatabaseInstance_withPSCEnabled_withoutAllowedConsumerProjects(instanceName string, projectId string, orgId string, billingAccount string) string {
	return fmt.Sprintf(`
resource "google_project" "testproject" {
  name                = "%s"
  project_id          = "%s"
  org_id              = "%s"
  billing_account     = "%s"
  deletion_policy = "DELETE"
}

resource "google_sql_database_instance" "instance" {
  project             = google_project.testproject.project_id
  name                = "%s"
  region              = "us-south1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
		psc_config {
			psc_enabled = true
		}
		ipv4_enabled = false
    }
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	  }
	availability_type = "REGIONAL"
  }
}
`, projectId, projectId, orgId, billingAccount, instanceName)
}

func testAccSqlDatabaseInstance_withPSCEnabled_withEmptyAllowedConsumerProjects(instanceName string, projectId string, orgId string, billingAccount string) string {
	return fmt.Sprintf(`
resource "google_project" "testproject" {
  name                = "%s"
  project_id          = "%s"
  org_id              = "%s"
  billing_account     = "%s"
  deletion_policy = "DELETE"
}

resource "google_sql_database_instance" "instance" {
  project             = google_project.testproject.project_id
  name                = "%s"
  region              = "us-south1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
		psc_config {
			psc_enabled = true
			allowed_consumer_projects = []
		}
		ipv4_enabled = false
    }
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	}
	availability_type = "REGIONAL"
  }
}
`, projectId, projectId, orgId, billingAccount, instanceName)
}

func testAccSqlDatabaseInstance_withPSCEnabled_withAllowedConsumerProjects(instanceName string, projectId string, orgId string, billingAccount string) string {
	return fmt.Sprintf(`
resource "google_project" "testproject" {
  name                = "%s"
  project_id          = "%s"
  org_id              = "%s"
  billing_account     = "%s"
  deletion_policy = "DELETE"
}

resource "google_sql_database_instance" "instance" {
  project             = google_project.testproject.project_id
  name                = "%s"
  region              = "us-south1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
		psc_config {
			psc_enabled = true
			allowed_consumer_projects = ["%s"]
		}
		ipv4_enabled = false
    }
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	}
	availability_type = "REGIONAL"
  }
}
`, projectId, projectId, orgId, billingAccount, instanceName, projectId)
}

func verifyPscOperation(resourceName string, isPscConfigExpected bool, expectedPscEnabled bool, expectedAllowedConsumerProjects []string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		resource, ok := s.RootModule().Resources[resourceName]
		if !ok {
			return fmt.Errorf("Can't find %s in state", resourceName)
		}

		resourceAttributes := resource.Primary.Attributes
		_, ok = resourceAttributes["settings.0.ip_configuration.#"]
		if !ok {
			return fmt.Errorf("settings.0.ip_configuration.# block is not present in state for %s", resourceName)
		}

		if isPscConfigExpected {
			_, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.#"]
			if !ok {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config property is not present or set in state of %s", resourceName)
			}

			pscEnabledStr, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.0.psc_enabled"]
			pscEnabled, err := strconv.ParseBool(pscEnabledStr)
			if err != nil || pscEnabled != expectedPscEnabled {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.psc_enabled property value is not set as expected in state of %s, expected %v, actual %v", resourceName, expectedPscEnabled, pscEnabled)
			}

			allowedConsumerProjectsStr, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.0.allowed_consumer_projects.#"]
			allowedConsumerProjects, err := strconv.Atoi(allowedConsumerProjectsStr)
			if !ok || allowedConsumerProjects != len(expectedAllowedConsumerProjects) {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.allowed_consumer_projects property is not present or set as expected in state of %s", resourceName)
			}

			pscServiceAttachmentLink, ok := resourceAttributes["psc_service_attachment_link"]
			if !ok || pscServiceAttachmentLink == "" {
				return fmt.Errorf("psc_service_attachment_link property value is empty")
			}
		}

		return nil
	}
}

func verifyCreateOperationOnEplusWithPrivateNetwork(resourceName string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		resource, ok := s.RootModule().Resources[resourceName]
		if !ok {
			return fmt.Errorf("Can't find %s in state", resourceName)
		}

		resourceAttributes := resource.Primary.Attributes
		_, ok = resourceAttributes["replication_cluster.#"]
		if !ok {
			return fmt.Errorf("replication_cluster.# block is not present in state for %s", resourceName)
		}

		_, ok = resourceAttributes["replication_cluster.0.psa_write_endpoint"]
		if !ok {
			return fmt.Errorf("replication_cluster.psa_write_endpoint is not present in state for %s", resourceName)
		}

		return nil
	}
}

func verifyPscAutoConnectionsOperation(resourceName string, isPscConfigExpected bool, expectedPscEnabled bool, isPscAutoConnectionConfigExpected bool, expectedConsumerNetwork string, expectedConsumerProject string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		resource, ok := s.RootModule().Resources[resourceName]
		if !ok {
			return fmt.Errorf("Can't find %s in state", resourceName)
		}

		resourceAttributes := resource.Primary.Attributes
		_, ok = resourceAttributes["settings.0.ip_configuration.#"]
		if !ok {
			return fmt.Errorf("settings.0.ip_configuration.# block is not present in state for %s", resourceName)
		}

		if isPscConfigExpected {
			_, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.#"]
			if !ok {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config property is not present or set in state of %s", resourceName)
			}

			pscEnabledStr, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.0.psc_enabled"]
			pscEnabled, err := strconv.ParseBool(pscEnabledStr)
			if err != nil || pscEnabled != expectedPscEnabled {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.psc_enabled property value is not set as expected in state of %s, expected %v, actual %v", resourceName, expectedPscEnabled, pscEnabled)
			}

			_, ok = resourceAttributes["settings.0.ip_configuration.0.psc_config.0.psc_auto_connections.#"]
			if !ok {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.psc_auto_connections property is not present or set in state of %s", resourceName)
			}

			if isPscAutoConnectionConfigExpected {
				consumerNetwork, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.0.psc_auto_connections.0.consumer_network"]
				if !ok || consumerNetwork != expectedConsumerNetwork {
					return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.psc_auto_connections.0.consumer_network property is not present or set as expected in state of %s", resourceName)
				}

				consumerProject, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.0.psc_auto_connections.0.consumer_service_project_id"]
				if !ok || consumerProject != expectedConsumerProject {
					return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.psc_auto_connections.0.consumer_service_project_id property is not present or set as expected in state of %s", resourceName)
				}
			}
		}

		return nil
	}
}

func verifyPscNetorkAttachmentOperation(resourceName string, isPscConfigExpected bool, expectedPscEnabled bool, expectedNetworkAttachmentUri string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		resource, ok := s.RootModule().Resources[resourceName]
		if !ok {
			return fmt.Errorf("Can't find %s in state", resourceName)
		}

		resourceAttributes := resource.Primary.Attributes
		_, ok = resourceAttributes["settings.0.ip_configuration.#"]
		if !ok {
			return fmt.Errorf("settings.0.ip_configuration.# block is not present in state for %s", resourceName)
		}

		if isPscConfigExpected {
			_, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.#"]
			if !ok {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config property is not present or set in state of %s", resourceName)
			}

			pscEnabledStr, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.0.psc_enabled"]
			pscEnabled, err := strconv.ParseBool(pscEnabledStr)
			if err != nil || pscEnabled != expectedPscEnabled {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.psc_enabled property value is not set as expected in state of %s, expected %v, actual %v", resourceName, expectedPscEnabled, pscEnabled)
			}

			networkAttachmentUriStr, ok := resourceAttributes["settings.0.ip_configuration.0.psc_config.0.network_attachment_uri"]
			if !ok {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.network_attachment_uri block is not present in state for %s", resourceName)
			}

			if networkAttachmentUriStr != expectedNetworkAttachmentUri && len(networkAttachmentUriStr) == 0 {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.network_attachment_uri block is not set in state for %s", resourceName)
			}

			if networkAttachmentUriStr != expectedNetworkAttachmentUri {
				return fmt.Errorf("settings.0.ip_configuration.0.psc_config.0.network_attachment_uri block does not match the expected value for %s", resourceName)
			}
		}

		return nil
	}
}

func testAccSqlDatabaseInstance_withoutMCPEnabled(instanceName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "POSTGRES_16"
  deletion_protection = false
  settings {
    tier = "db-perf-optimized-N-2"
  }
}
`, instanceName)
}

func testAccSqlDatabaseInstance_withMCPEnabled(instanceName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "POSTGRES_16"
  deletion_protection = false
  settings {
    tier    = "db-perf-optimized-N-2"
    edition = "ENTERPRISE_PLUS"
	connection_pool_config {
		connection_pooling_enabled = true
		flags {
			name = "max_client_connections"
			value = "1980"
		}
	}
  }
}
`, instanceName)
}

func testAccSqlDatabaseInstance_withPSCEnabled_withoutPscAutoConnections(instanceName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-west2"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
		psc_config {
			psc_enabled = true
		}
		ipv4_enabled = false
    }
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	}
	availability_type = "REGIONAL"
  }
}
`, instanceName)
}

func testAccSqlDatabaseInstance_withPSCEnabled_withoutPscOutbound(instanceName string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
		psc_config {
			psc_enabled = true
			network_attachment_uri = ""
		}
		ipv4_enabled = false
    }
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	}
	availability_type = "REGIONAL"
  }
}
`, instanceName)
}

func testAccSqlDatabaseInstance_withPSCEnabled_withPscAutoConnections(instanceName string, projectId string, networkName string) string {
	return fmt.Sprintf(`
data "google_compute_network" "testnetwork" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-west2"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
		psc_config {
			psc_enabled = true
			psc_auto_connections {
				consumer_network = "projects/%s/global/networks/%s"
				consumer_service_project_id = "%s"
			}
		}
		ipv4_enabled = false
    }
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	}
	availability_type = "REGIONAL"
  }
}
`, networkName, instanceName, projectId, networkName, projectId)
}

func testAccSqlDatabaseInstance_withPSCEnabled_withNetworkAttachmentUri(instanceName string, networkAttachmentUri string) string {
	return fmt.Sprintf(`

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
		psc_config {
			psc_enabled = true
			network_attachment_uri = "%s"
		}
		ipv4_enabled = false
    }
	backup_configuration {
		enabled = true
		binary_log_enabled = true
	}
	availability_type = "REGIONAL"
  }
}`, instanceName, networkAttachmentUri)
}

func testAccSqlDatabaseInstance_withPrivateNetwork_withoutAllocatedIpRange(databaseName, networkName string, specifyPrivatePathOption bool, enablePrivatePath bool) string {
	privatePathOption := ""
	if specifyPrivatePathOption {
		privatePathOption = fmt.Sprintf("enable_private_path_for_google_cloud_services = %t", enablePrivatePath)
	}

	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
      ipv4_enabled       = "false"
      private_network    = data.google_compute_network.servicenet.self_link
      %s
    }
  }
}
`, networkName, databaseName, privatePathOption)
}

func testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRange(databaseName, networkName, addressRangeName string) string {
	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
      ipv4_enabled       = "false"
      private_network    = data.google_compute_network.servicenet.self_link
      allocated_ip_range = "%s"
    }
  }
}
`, networkName, databaseName, addressRangeName)
}

func testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeReplica(databaseName, networkName, addressRangeName string) string {
	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
      ipv4_enabled       = "false"
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      enabled            = true
      start_time         = "00:00"
      binary_log_enabled = true
    }
  }
}
resource "google_sql_database_instance" "replica1" {
  name                = "%s-replica1"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
      ipv4_enabled       = "false"
      private_network    = data.google_compute_network.servicenet.self_link
      allocated_ip_range = "%s"
    }
  }

  master_instance_name = google_sql_database_instance.instance.name

  replica_configuration {
    connect_retry_interval    = 100
    master_heartbeat_period   = 10000
    password                  = "password"
    username                  = "username"
    ssl_cipher                = "ALL"
    verify_server_certificate = false
  }
}
`, networkName, databaseName, databaseName, addressRangeName)
}

func testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeClone(databaseName, networkName, addressRangeName string) string {
	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
      ipv4_enabled       = "false"
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      enabled            = true
      start_time         = "00:00"
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "clone1" {
  name                = "%s-clone1"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  clone {
    source_instance_name = google_sql_database_instance.instance.name
    allocated_ip_range   = "%s"
  }

}
`, networkName, databaseName, databaseName, addressRangeName)
}

func testAccSqlDatabaseInstance_withPrivateNetwork_withAllocatedIpRangeClone_withSettings(databaseName, networkName, addressRangeName string) string {
	return fmt.Sprintf(`
data "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
      ipv4_enabled       = "false"
      private_network    = data.google_compute_network.servicenet.self_link
    }
    backup_configuration {
      enabled            = true
      start_time         = "00:00"
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "clone1" {
  name                = "%s-clone1"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  clone {
    source_instance_name = google_sql_database_instance.instance.name
    allocated_ip_range   = "%s"
  }

  settings {
    tier = "db-g1-small"
    backup_configuration {
      enabled = false
    }
  }
}
`, networkName, databaseName, databaseName, addressRangeName)
}

var testGoogleSqlDatabaseInstance_settings = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier                   = "db-g1-small"
    location_preference {
      zone = "us-central1-f"
    }

    ip_configuration {
      ipv4_enabled = "true"
      authorized_networks {
        value           = "108.12.12.12"
        name            = "misc"
        expiration_time = "2037-11-15T16:19:00.094Z"
      }
    }

    backup_configuration {
      enabled    = "true"
      start_time = "19:19"
    }

    activation_policy = "ALWAYS"
  }
}
`

var testGoogleSqlDatabaseInstance_settings_secondary = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier                   = "db-g1-small"
    availability_type      = "REGIONAL"
    location_preference {
      zone           = "us-central1-f"
      secondary_zone = "us-central1-a"
    }

    ip_configuration {
      ipv4_enabled = "true"
      authorized_networks {
        value           = "108.12.12.12"
        name            = "misc"
        expiration_time = "2037-11-15T16:19:00.094Z"
      }
    }

    backup_configuration {
      enabled    = "true"
      start_time = "19:19"
      binary_log_enabled = true
    }

    activation_policy = "ALWAYS"
    connector_enforcement = "REQUIRED"
  }
}
`

var testGoogleSqlDatabaseInstance_settings_deletionProtection = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = %s
  settings {
    tier                   = "db-g1-small"
    location_preference {
      zone = "us-central1-f"
	}

    ip_configuration {
	  ipv4_enabled = "true"
      authorized_networks {
        value           = "108.12.12.12"
        name            = "misc"
        expiration_time = "2037-11-15T16:19:00.094Z"
      }
    }

    backup_configuration {
      enabled    = "true"
      start_time = "19:19"
    }

    activation_policy = "ALWAYS"
  }
}
`

var testGoogleSqlDatabaseInstance_maintenanceVersionWithOldVersion = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  maintenance_version = "MYSQL_5_7_37.R20210508.01_03"
  settings {
    tier = "db-g1-small"
  }
}
`

var testGoogleSqlDatabaseInstance_settings_deletionProtectionEnabled = `
resource "google_sql_database_instance" "instance" {
  name                        = "%s"
  region                      = "us-central1"
  database_version            = "MYSQL_5_7"
  deletion_protection         = false
  settings {
	deletion_protection_enabled = %s
    tier                        = "db-g1-small"
  }
}
`

var testGoogleSqlDatabaseInstance_settings_checkServiceNetworking = `
resource "google_compute_network" "servicenet" {
  name                    = "%s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    ip_configuration {
      ipv4_enabled    = "false"
      private_network = google_compute_network.servicenet.self_link
    }
  }
}
`

var testGoogleSqlDatabaseInstance_replica = `
resource "google_sql_database_instance" "instance_master" {
  name                = "tf-test-%d"
  database_version    = "MYSQL_5_7"
  region              = "us-central1"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      enabled            = true
      start_time         = "00:00"
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "replica1" {
  name                = "tf-test-%d-1"
  database_version    = "MYSQL_5_7"
  region              = "us-central1"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"
    backup_configuration {
      enabled = false
      binary_log_enabled = true
    }
  }

  master_instance_name = google_sql_database_instance.instance_master.name

  replica_configuration {
    connect_retry_interval    = 100
    master_heartbeat_period   = 10000
    password                  = "password"
    username                  = "username"
    ssl_cipher                = "ALL"
    verify_server_certificate = false
  }
}

resource "google_sql_database_instance" "replica2" {
  name                = "tf-test-%d-2"
  database_version    = "MYSQL_5_7"
  region              = "us-central1"
  deletion_protection = false

  settings {
    tier = "db-n1-standard-1"
    backup_configuration {
      enabled = %s
    }
  }

  master_instance_name = google_sql_database_instance.instance_master.name

  replica_configuration {
    connect_retry_interval    = 100
    master_heartbeat_period   = 10000
    password                  = "password"
    username                  = "username"
    ssl_cipher                = "ALL"
    verify_server_certificate = false
  }
}
`

var testGoogleSqlDatabaseInstance_slave = `
resource "google_sql_database_instance" "instance_master" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-g1-small"

    backup_configuration {
      enabled            = true
      binary_log_enabled = true
    }
  }
}

resource "google_sql_database_instance" "instance_slave" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  master_instance_name = google_sql_database_instance.instance_master.name

  settings {
    tier = "db-g1-small"
  }
}
`

var testGoogleSqlDatabaseInstance_highAvailability = `
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "POSTGRES_9_6"
  deletion_protection = false

  settings {
    tier = "db-g1-small"

    availability_type = "REGIONAL"

    backup_configuration {
      enabled  = true
      location = "us"
    }
  }
}
`

var testGoogleSqlDatabaseInstance_diskspecs = `
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier                  = "db-g1-small"
    disk_autoresize       = true
    disk_autoresize_limit = 50
    disk_size             = 15
    disk_type             = "PD_HDD"
  }
}
`

var testGoogleSqlDatabaseInstance_maintenance = `
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-g1-small"

    maintenance_window {
      day          = 7
      hour         = 3
      update_track = "canary"
    }
  }
}
`

var testGoogleSqlDatabaseInstance_maintenance_week5 = `
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false

  settings {
    tier = "db-f1-micro"

    maintenance_window {
      day          = 7
      hour         = 3
      update_track = "week5"
    }
  }
}
`

var testGoogleSqlDatabaseInstance_authNets_step1 = `
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier                   = "db-g1-small"

    ip_configuration {
      authorized_networks {
        value           = "108.12.12.12"
        name            = "misc"
        expiration_time = "2037-11-15T16:19:00.094Z"
      }
    }
  }
}
`

var testGoogleSqlDatabaseInstance_authNets_step2 = `
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier                   = "db-g1-small"

    ip_configuration {
      ipv4_enabled = "true"
    }
  }
}
`

var testGoogleSqlDatabaseInstance_multipleOperations = `
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier                   = "db-g1-small"
  }
}

resource "google_sql_database" "database" {
  name     = "tf-test-%s"
  instance = google_sql_database_instance.instance.name
}

resource "google_sql_user" "user" {
  name     = "tf-test-%s"
  instance = google_sql_database_instance.instance.name
  host     = "google.com"
  password = "hunter2"
}
`

var testGoogleSqlDatabaseInstance_basic_with_user_labels = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    user_labels = {
      track    = "production"
      location = "western-division"
    }
  }
}
`
var testGoogleSqlDatabaseInstance_basic_with_user_labels_update = `
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    user_labels = {
      track = "production"
    }
  }
}
`

var testGoogleSqlDatabaseInstance_insights = `
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "POSTGRES_9_6"
  deletion_protection = false

  settings {
    tier = "db-g1-small"

    insights_config {
      query_insights_enabled  = true
      query_string_length     = 256
      record_application_tags = true
      record_client_address   = true
      query_plans_per_minute  = 10
    }
  }
}
`
var testGoogleSqlDatabaseInstance_encryptionKey = `
data "google_project" "project" {
  project_id = "%{project_id}"
}
resource "google_kms_key_ring" "keyring" {
  name     = "%{key_name}"
  location = "us-central1"
}

resource "google_kms_crypto_key" "key" {
  name     = "%{key_name}"
  key_ring = google_kms_key_ring.keyring.id
}

resource "google_kms_crypto_key_iam_member" "crypto_key" {
  crypto_key_id = google_kms_crypto_key.key.id
  role          = "roles/cloudkms.cryptoKeyEncrypterDecrypter"

  member = "serviceAccount:service-${data.google_project.project.number}@gcp-sa-cloud-sql.iam.gserviceaccount.com"
}

resource "google_sql_database_instance" "master" {
  name                = "%{instance_name}-master"
  database_version    = "MYSQL_5_7"
  region              = "us-central1"
  deletion_protection = false
  encryption_key_name = google_kms_crypto_key.key.id

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      enabled            = true
      start_time         = "00:00"
      binary_log_enabled = true
    }
  }
  depends_on = [google_kms_crypto_key_iam_member.crypto_key]
}

resource "google_sql_database_instance" "replica" {
  name                 = "%{instance_name}-replica"
  database_version     = "MYSQL_5_7"
  region               = "us-central1"
  master_instance_name = google_sql_database_instance.master.name
  deletion_protection  = false

  settings {
    tier = "db-n1-standard-1"
  }

  depends_on = [google_sql_database_instance.master]
}
`

var testGoogleSqlDatabaseInstance_encryptionKey_replicaInDifferentRegion = `

data "google_project" "project" {
  project_id = "%{project_id}"
}

resource "google_kms_crypto_key_iam_member" "crypto_key" {
  crypto_key_id = "%{kms_key_name1}"
  role          = "roles/cloudkms.cryptoKeyEncrypterDecrypter"

  member = "serviceAccount:service-${data.google_project.project.number}@gcp-sa-cloud-sql.iam.gserviceaccount.com"
}

resource "google_sql_database_instance" "master" {
  name                = "%{instance_name}-master"
  database_version    = "MYSQL_5_7"
  region              = "us-central1"
  deletion_protection = false
  encryption_key_name = "%{kms_key_name1}"

  settings {
    tier = "db-n1-standard-1"

    backup_configuration {
      enabled            = true
      start_time         = "00:00"
      binary_log_enabled = true
    }
  }

  depends_on = [google_kms_crypto_key_iam_member.crypto_key]
}

resource "google_kms_crypto_key_iam_member" "crypto_key_rep" {
  crypto_key_id = "%{kms_key_name2}"
  role          = "roles/cloudkms.cryptoKeyEncrypterDecrypter"

  member = "serviceAccount:service-${data.google_project.project.number}@gcp-sa-cloud-sql.iam.gserviceaccount.com"
}

resource "google_sql_database_instance" "replica" {
  name                 = "%{instance_name}-replica"
  database_version     = "MYSQL_5_7"
  region               = "us-east1"
  master_instance_name = google_sql_database_instance.master.name
  encryption_key_name = "%{kms_key_name2}"
  deletion_protection  = false

  settings {
    tier = "db-n1-standard-1"
  }

  depends_on = [
    google_sql_database_instance.master,
    google_kms_crypto_key_iam_member.crypto_key_rep
  ]
}
`

func testGoogleSqlDatabaseInstance_PointInTimeRecoveryEnabled(masterID int, pointInTimeRecoveryEnabled bool, dbVersion string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "%s"
  deletion_protection = false
  root_password		  = "rand-pwd-%d"
  settings {
    tier = "db-custom-2-13312"
    backup_configuration {
      enabled                        = true
      start_time                     = "00:00"
      point_in_time_recovery_enabled = %t
    }
  }
}
`, masterID, dbVersion, masterID, pointInTimeRecoveryEnabled)
}

func testGoogleSqlDatabaseInstance_EnableGoogleMlIntegration(masterID int, enableGoogleMlIntegration bool, dbVersion string, tier string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "%s"
  deletion_protection = false
  root_password		  = "rand-pwd-%d"
  settings {
    tier = "%s"
	enable_google_ml_integration = %t
  }
}
`, masterID, dbVersion, masterID, tier, enableGoogleMlIntegration)
}

func testGoogleSqlDatabaseInstance_EnableDataplexIntegration(masterID int, enableDataplexIntegration bool) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  root_password		  = "rand-pwd-%d"
  settings {
    tier = "db-custom-2-10240"
	enable_dataplex_integration = %t
  }
}
`, masterID, masterID, enableDataplexIntegration)
}

func testGoogleSqlDatabaseInstance_BackupRetention(masterID int) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    backup_configuration {
      enabled                        = true
      start_time                     = "00:00"
      binary_log_enabled             = true
	  transaction_log_retention_days = 2
	  backup_retention_settings {
	    retained_backups = 4
	  }
    }
  }
}
`, masterID)
}

func testGoogleSqlDatabaseInstance_RetainBackupOnDelete(masterID int, retainBackupOnDelete bool) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  settings {
    tier = "db-g1-small"
    backup_configuration {
      enabled                        = true
      start_time                     = "00:00"
      binary_log_enabled             = true
	  transaction_log_retention_days = 2
	  backup_retention_settings {
	    retained_backups = 4
	  }
    }
    retain_backups_on_delete = %v
  }
}
`, masterID, retainBackupOnDelete)
}

func testGoogleSqlDatabaseInstance_FinalBackupConfig(masterID int, enabled bool, retention_days int64) string {
	retentionSetting := ""
	if retention_days >= 0 {
		retentionSetting = fmt.Sprintf(`retention_days = %d`, retention_days)
	}

	finalBackupConfig := fmt.Sprintf(`final_backup_config {
		enabled = %v
		%v
	}`, enabled, retentionSetting)

	finalBackupDescription := `""`
	if enabled {
		finalBackupDescription = `"Test FinalBackup Description"`
	}

	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "tf-test-%d"
  region              = "us-central1"
  database_version    = "MYSQL_8_0"
  deletion_protection = false
  final_backup_description = %v

  settings {
    tier = "db-g1-small"
    backup_configuration {
      enabled                        = true
      start_time                     = "00:00"
      binary_log_enabled             = true
	  transaction_log_retention_days = 2
	  backup_retention_settings {
	    retained_backups = 4
	  }
    }
%v
  }
}
`, masterID, finalBackupDescription, finalBackupConfig)
}

func testAccSqlDatabaseInstance_beforeBackup(context map[string]interface{}) string {
	return acctest.Nprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "%{db_version}"
  region           = "us-central1"

  settings {
	tier = "db-g1-small"
	backup_configuration {
		enabled            = "false"
	}
  }

  deletion_protection = false
}
`, context)
}

func testAccSqlDatabaseInstance_restoreFromBackup(context map[string]interface{}) string {
	return acctest.Nprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "POSTGRES_11"
  region           = "us-central1"

  settings {
	tier = "db-g1-small"
	backup_configuration {
		enabled            = "false"
	}
  }

  restore_backup_context {
    backup_run_id = data.google_sql_backup_run.backup.backup_id
    instance_id = data.google_sql_backup_run.backup.instance
  }

  // Ignore changes, since the most recent backup may change during the test
  lifecycle{
	ignore_changes = [restore_backup_context[0].backup_run_id]
  }

  deletion_protection = false
}

data "google_sql_backup_run" "backup" {
	instance = "%{original_db_name}"
	most_recent = true
}
`, context)
}

func testAccSqlDatabaseInstance_createFromBackupDR(context map[string]interface{}) string {
	return acctest.Nprintf(`
// Create service account
resource "google_service_account" "bkdr_sa" {
    account_id   = "tf-test-bkdr-sa-%{random_suffix}"
    display_name = "Backup DR Service Account"
}

// Create a backup plan
resource "google_backup_dr_backup_plan" "plan" {
  location       = "us-central1"
  backup_plan_id = "tf-test-bp-test-%{random_suffix}"
  resource_type  = "sqladmin.googleapis.com/Instance"
  backup_vault   = "%{backup_vault}"

  backup_rules {
    rule_id                = "rule-1"
    backup_retention_days  = 7

    standard_schedule {
      recurrence_type     = "DAILY"
      hourly_frequency    = 6
      time_zone           = "UTC"

      backup_window {
        start_hour_of_day = 0
        end_hour_of_day   = 23
      }
    }
  }
}

// Create source SQL instance to backup
resource "google_sql_database_instance" "source" {
    name                = "tf-test-source-%{random_suffix}"
    database_version    = "MYSQL_8_0_41"
    region             	= "us-central1"
    project            	= "%{project}"
    settings {
        tier = "db-f1-micro"
        backup_configuration {
            enabled = true
        }
    }
	lifecycle {
		ignore_changes = [
		  settings[0].backup_configuration[0].enabled,
		]
 	}
    deletion_protection = false
}

// Associate backup plan with SQL instance
resource "google_backup_dr_backup_plan_association" "association" { 
  location 						= "us-central1" 
  backup_plan_association_id 	= "tf-test-bpa-test-%{random_suffix}"
  resource 						= "projects/${google_sql_database_instance.source.project}/instances/${google_sql_database_instance.source.name}"
  resource_type					= "sqladmin.googleapis.com/Instance"
  backup_plan 					= google_backup_dr_backup_plan.plan.name
}

// Wait for the first backup to be created
resource "time_sleep" "wait_10_mins" {
  depends_on = [google_backup_dr_backup_plan_association.association]

  create_duration = "600s"
}

data "google_backup_dr_backup" "sql_backups" {
  project			= "%{project}"
  location      	= "%{vault_location}"
  backup_vault_id 	= "%{backup_vault_id}"
  data_source_id 	= element(split("/", google_backup_dr_backup_plan_association.association.data_source), length(split("/", google_backup_dr_backup_plan_association.association.data_source)) - 1)

  depends_on = [time_sleep.wait_10_mins]
}

resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "MYSQL_8_0_41"
  region           = "%{target_instance_region}"

  settings {
    tier = "db-g1-small"
	backup_configuration {
    	enabled = true
    }
  }

  backupdr_backup 		= data.google_backup_dr_backup.sql_backups.backups[0].name

  deletion_protection 	= false
}
`, context)
}

func testAccSqlDatabaseInstance_updateFromBackupDR(context map[string]interface{}) string {
	return acctest.Nprintf(`
// Create service account
resource "google_service_account" "bkdr_sa" {
    account_id   = "tf-test-bkdr-sa-%{random_suffix}"
    display_name = "Backup DR Service Account"
}

// Create a backup plan
resource "google_backup_dr_backup_plan" "plan" {
  location       = "us-central1"
  backup_plan_id = "tf-test-bp-test-%{random_suffix}"
  resource_type  = "sqladmin.googleapis.com/Instance"
  backup_vault   = "%{backup_vault}"

  backup_rules {
    rule_id                = "rule-1"
    backup_retention_days  = 7

    standard_schedule {
      recurrence_type     = "DAILY"
      hourly_frequency    = 6
      time_zone           = "UTC"

      backup_window {
        start_hour_of_day = 0
        end_hour_of_day   = 23
      }
    }
  }
}

// Create source SQL instance to backup
resource "google_sql_database_instance" "source" {
    name                = "tf-test-source-%{random_suffix}"
    database_version    = "MYSQL_8_0_41"
    region             	= "us-central1"
    project            	= "%{project}"
    settings {
        tier = "db-f1-micro"
        backup_configuration {
            enabled = true
        }
    }
	lifecycle {
		ignore_changes = [
		  settings[0].backup_configuration[0].enabled,
		]
 	}
    deletion_protection = false
}

// Associate backup plan with SQL instance
resource "google_backup_dr_backup_plan_association" "association" { 
  location 						= "us-central1" 
  backup_plan_association_id 	= "tf-test-bpa-test-%{random_suffix}"
  resource 						= "projects/${google_sql_database_instance.source.project}/instances/${google_sql_database_instance.source.name}"
  resource_type					= "sqladmin.googleapis.com/Instance"
  backup_plan 					= google_backup_dr_backup_plan.plan.name
}

// Wait for the first backup to be created
resource "time_sleep" "wait_10_mins" {
  depends_on = [google_backup_dr_backup_plan_association.association]

  create_duration = "600s"
}

data "google_backup_dr_backup" "sql_backups" {
  project			= "%{project}"
  location      	= "us-central1"
  backup_vault_id 	= "%{backup_vault_id}"
  data_source_id 	= element(split("/", google_backup_dr_backup_plan_association.association.data_source), length(split("/", google_backup_dr_backup_plan_association.association.data_source)) - 1)

  depends_on = [time_sleep.wait_10_mins]
}

resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "MYSQL_8_0_41"
  region           = "us-central1"

  settings {
	tier = "db-g1-small"
	backup_configuration {
		enabled = "false"
	}
  }
  lifecycle {
	ignore_changes = [
	  settings[0].backup_configuration[0].enabled,
	]
  }

  backupdr_backup 		= data.google_backup_dr_backup.sql_backups.backups[0].name

  deletion_protection 	= false
}
`, context)
}

func testAccSqlDatabaseInstance_basicClone(context map[string]interface{}) string {
	return acctest.Nprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "POSTGRES_11"
  region           = "us-central1"

  clone {
    source_instance_name = data.google_sql_backup_run.backup.instance
    point_in_time = data.google_sql_backup_run.backup.start_time
  }

  deletion_protection = false

  // Ignore changes, since the most recent backup may change during the test
  lifecycle{
	ignore_changes = [clone[0].point_in_time]
  }
}

data "google_sql_backup_run" "backup" {
	instance = "%{original_db_name}"
	most_recent = true
}
`, context)
}

func testAccSqlDatabaseInstance_cloneWithSettings(context map[string]interface{}) string {
	return acctest.Nprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "POSTGRES_11"
  region           = "us-central1"

  settings {
	tier = "db-g1-small"
	backup_configuration {
		enabled            = false
	}
  }

  clone {
    source_instance_name = data.google_sql_backup_run.backup.instance
    point_in_time = data.google_sql_backup_run.backup.start_time
	preferred_zone = "us-central1-b"
  }

  deletion_protection = false

  // Ignore changes, since the most recent backup may change during the test
  lifecycle{
	ignore_changes = [clone[0].point_in_time]
  }
}

data "google_sql_backup_run" "backup" {
	instance = "%{original_db_name}"
	most_recent = true
}
`, context)
}

func testAccSqlDatabaseInstance_cloneWithDatabaseNames(context map[string]interface{}) string {
	return acctest.Nprintf(`
resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "POSTGRES_11"
  region           = "us-central1"

  clone {
    source_instance_name = data.google_sql_backup_run.backup.instance
    point_in_time = data.google_sql_backup_run.backup.start_time
    database_names = ["userdb1"]
  }

  deletion_protection = false

  // Ignore changes, since the most recent backup may change during the test
  lifecycle{
	ignore_changes = [clone[0].point_in_time]
  }
}

data "google_sql_backup_run" "backup" {
	instance = "%{original_db_name}"
	most_recent = true
}
`, context)
}

func testAccSqlDatabaseInstance_pointInTimeRestoreContext(context map[string]interface{}) string {
	return acctest.Nprintf(`
// Create service account
resource "google_service_account" "bkdr_sa" {
    account_id   = "tf-test-bkdr-sa-%{random_suffix}"
    display_name = "Backup DR Service Account"
}

// Create a backup plan
resource "google_backup_dr_backup_plan" "plan" {
  location       = "us-central1"
  backup_plan_id = "tf-test-bp-test-%{random_suffix}"
  resource_type  = "sqladmin.googleapis.com/Instance"
  backup_vault   = "%{backup_vault}"
  log_retention_days = 2

  backup_rules {
    rule_id                = "rule-1"
    backup_retention_days  = 7

    standard_schedule {
      recurrence_type     = "DAILY"
      hourly_frequency    = 6
      time_zone           = "UTC"

      backup_window {
        start_hour_of_day = 0
        end_hour_of_day   = 23
      }
    }
  }
}

// Create source SQL instance to backup
resource "google_sql_database_instance" "source" {
    name                = "tf-test-source-%{random_suffix}"
    database_version    = "MYSQL_8_0_41"
    region             	= "us-central1"
    project            	= "%{project}"
    settings {
        tier = "db-f1-micro"
        backup_configuration {
            enabled = true
        }
    }
	lifecycle {
		ignore_changes = [
		  settings[0].backup_configuration[0].enabled,
		]
 	}
    deletion_protection = false
}

// Associate backup plan with SQL instance
resource "google_backup_dr_backup_plan_association" "association" { 
  location 						= "us-central1" 
  backup_plan_association_id 	= "tf-test-bpa-test-%{random_suffix}"
  resource 						= "projects/${google_sql_database_instance.source.project}/instances/${google_sql_database_instance.source.name}"
  resource_type					= "sqladmin.googleapis.com/Instance"
  backup_plan 					= google_backup_dr_backup_plan.plan.name
}

// Wait for the first backup to be created
resource "time_sleep" "wait_10_mins" {
  depends_on = [google_backup_dr_backup_plan_association.association]

  create_duration = "600s"
}

data "google_backup_dr_backup" "sql_backups" {
  project			= "%{project}"
  location      	= "us-central1"
  backup_vault_id 	= "%{backup_vault_id}"
  data_source_id 	= element(split("/", google_backup_dr_backup_plan_association.association.data_source), length(split("/", google_backup_dr_backup_plan_association.association.data_source)) - 1)

  depends_on = [time_sleep.wait_10_mins]
}

// for a point in time restore operation to succeed, the source instance must be in active state and have logs
resource "google_sql_database" "database" {
  name     = "tf-test-db-%{random_suffix}"
  instance =  google_sql_database_instance.source.name
  project  = "%{project}"
  depends_on = [data.google_backup_dr_backup.sql_backups]
}

// Wait for the ten minutes (RPO is 5 minutes)
resource "time_sleep" "wait_for_binlog" {
  depends_on = [google_sql_database.database]

  create_duration = "600s"
}

resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "MYSQL_8_0_41"
  region           = "us-central1"

  point_in_time_restore_context {
    datasource      = google_backup_dr_backup_plan_association.association.data_source
	target_instance = "%{project}:tf-test-%{random_suffix}"
	point_in_time   = timestamp()
  }

  lifecycle {
	ignore_changes = [point_in_time_restore_context[0].point_in_time]
  }

  depends_on = [time_sleep.wait_for_binlog]

  deletion_protection 	= false
}
`, context)
}

func testAccSqlDatabaseInstance_pointInTimeRestoreContextWithSettings(context map[string]interface{}) string {
	return acctest.Nprintf(`
// Create service account
resource "google_service_account" "bkdr_sa" {
    account_id   = "tf-test-bkdr-sa-%{random_suffix}"
    display_name = "Backup DR Service Account"
}

// Create a backup plan
resource "google_backup_dr_backup_plan" "plan" {
  location       = "us-central1"
  backup_plan_id = "tf-test-bp-test-%{random_suffix}"
  resource_type  = "sqladmin.googleapis.com/Instance"
  backup_vault   = "%{backup_vault}"
  log_retention_days = 2

  backup_rules {
    rule_id                = "rule-1"
    backup_retention_days  = 7

    standard_schedule {
      recurrence_type     = "DAILY"
      hourly_frequency    = 6
      time_zone           = "UTC"

      backup_window {
        start_hour_of_day = 0
        end_hour_of_day   = 23
      }
    }
  }
}

// Create source SQL instance to backup
resource "google_sql_database_instance" "source" {
    name                = "tf-test-source-%{random_suffix}"
    database_version    = "MYSQL_8_0_41"
    region             	= "us-central1"
    project            	= "%{project}"
    settings {
        tier = "db-f1-micro"
        backup_configuration {
            enabled = true
        }
    }
	lifecycle {
		ignore_changes = [
		  settings[0].backup_configuration[0].enabled,
		]
 	}
    deletion_protection = false
}

// Associate backup plan with SQL instance
resource "google_backup_dr_backup_plan_association" "association" { 
  location 						= "us-central1" 
  backup_plan_association_id 	= "tf-test-bpa-test-%{random_suffix}"
  resource 						= "projects/${google_sql_database_instance.source.project}/instances/${google_sql_database_instance.source.name}"
  resource_type					= "sqladmin.googleapis.com/Instance"
  backup_plan 					= google_backup_dr_backup_plan.plan.name
}

// Wait for the first backup to be created
resource "time_sleep" "wait_10_mins" {
  depends_on = [google_backup_dr_backup_plan_association.association]

  create_duration = "600s"
}

data "google_backup_dr_backup" "sql_backups" {
  project			= "%{project}"
  location      	= "us-central1"
  backup_vault_id 	= "%{backup_vault_id}"
  data_source_id 	= element(split("/", google_backup_dr_backup_plan_association.association.data_source), length(split("/", google_backup_dr_backup_plan_association.association.data_source)) - 1)

  depends_on = [time_sleep.wait_10_mins]
}

// for a point in time restore operation to succeed, the source instance must be in active state and have logs
resource "google_sql_database" "database" {
  name     = "tf-test-db-%{random_suffix}"
  instance =  google_sql_database_instance.source.name
  project  = "%{project}"
  depends_on = [data.google_backup_dr_backup.sql_backups]
}

// Wait for the ten minutes (RPO is 5 minutes)
resource "time_sleep" "wait_for_binlog" {
  depends_on = [google_sql_database.database]

  create_duration = "600s"
}

resource "google_sql_database_instance" "instance" {
  name             = "tf-test-%{random_suffix}"
  database_version = "MYSQL_8_0_41"
  region           = "us-central1"

  settings {
	tier = "db-g1-small"
	backup_configuration {
		enabled            = false
	}
  }

  point_in_time_restore_context {
    datasource      = google_backup_dr_backup_plan_association.association.data_source
	target_instance = "%{project}:tf-test-%{random_suffix}"
	point_in_time   = timestamp()
  }

  lifecycle {
	ignore_changes = [point_in_time_restore_context[0].point_in_time]
  }

  depends_on = [time_sleep.wait_for_binlog]

  deletion_protection 	= false
}
`, context)
}

func checkPromoteReplicaSkipConfigurations(resourceName string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		resource, ok := s.RootModule().Resources[resourceName]
		if !ok {
			return fmt.Errorf("Can't find %s in state", resourceName)
		}

		resourceAttributes := resource.Primary.Attributes
		instanceType, ok := resourceAttributes["instance_type"]
		if !ok {
			return fmt.Errorf("Instance type is not present in state for %s", resourceName)
		}
		if instanceType != "READ_REPLICA_INSTANCE" {
			return fmt.Errorf("instance_type is %s, it should be READ_REPLICA_INSTANCE.", instanceType)
		}

		masterInstanceName, ok := resourceAttributes["master_instance_name"]
		if !ok && masterInstanceName != "" {
			return fmt.Errorf("master_instance_name should be present in %s state.", resourceName)
		}

		return nil
	}
}

func checkPromoteReplicaConfigurations(resourceName string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		resource, ok := s.RootModule().Resources[resourceName]
		if !ok {
			return fmt.Errorf("Can't find %s in state", resourceName)
		}

		resourceAttributes := resource.Primary.Attributes
		instanceType, ok := resourceAttributes["instance_type"]
		if !ok {
			return fmt.Errorf("Instance type is not present in state for %s", resourceName)
		}
		if instanceType != "CLOUD_SQL_INSTANCE" {
			return fmt.Errorf("Error in replica promotion. instance_type is %s, it should be CLOUD_SQL_INSTANCE.", instanceType)
		}

		masterInstanceName, ok := resourceAttributes["master_instance_name"]
		if ok && masterInstanceName != "" {
			return fmt.Errorf("Error in replica promotion. master_instance_name should not be present in %s state.", resourceName)
		}

		replicaConfiguration, ok := resourceAttributes["replica_configuration"]
		if ok && replicaConfiguration != "" {
			return fmt.Errorf("Error in replica promotion. replica_configuration should not be present in %s state.", resourceName)
		}
		return nil
	}
}

// Check that original-replica is now the primary
func checkSwitchoverOriginalReplicaConfigurations(replicaResourceName string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		replicaResource, ok := s.RootModule().Resources[replicaResourceName]
		if !ok {
			return fmt.Errorf("Can't find %s in state", replicaResourceName)
		}
		replicaResourceAttributes := replicaResource.Primary.Attributes

		replicaInstanceType, ok := replicaResourceAttributes["instance_type"]
		if !ok {
			return fmt.Errorf("Instance type is not present in state for %s", replicaResourceName)
		}
		if replicaInstanceType != "CLOUD_SQL_INSTANCE" {
			return fmt.Errorf("Error in switchover. Original replica instance_type is %s, it should be CLOUD_SQL_INSTANCE.", replicaInstanceType)
		}

		replicaMasterInstanceName, ok := replicaResourceAttributes["master_instance_name"]
		if ok && replicaMasterInstanceName != "" {
			return fmt.Errorf("Error in switchover. master_instance_name should not be set on new primary")
		}
		return nil
	}
}

// Check that original-primary is now a replica
func checkSwitchoverOriginalPrimaryConfigurations(primaryResourceName string, replicaName string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		primaryResource, ok := s.RootModule().Resources[primaryResourceName]
		if !ok {
			return fmt.Errorf("Can't find %s in state", primaryResourceName)
		}
		primaryResourceAttributes := primaryResource.Primary.Attributes
		primaryInstanceType, ok := primaryResourceAttributes["instance_type"]
		if !ok {
			return fmt.Errorf("Instance type is not present in state for %s", primaryResourceName)
		}
		if primaryInstanceType != "READ_REPLICA_INSTANCE" {
			return fmt.Errorf("Error in switchover. Original primary instance_type is %s, it should be READ_REPLICA_INSTANCE.", primaryInstanceType)
		}

		primaryMasterInstanceName, ok := primaryResourceAttributes["master_instance_name"]
		if !ok {
			return fmt.Errorf("Master instance name is not present in state for %s", primaryResourceName)
		}
		if primaryMasterInstanceName != replicaName {
			return fmt.Errorf("Error in switchover. master_instance_name should be %s", replicaName)
		}
		return nil
	}
}

func checkInstanceTypeIsPresent(resourceName string) func(*terraform.State) error {
	return func(s *terraform.State) error {
		rs, ok := s.RootModule().Resources[resourceName]
		if !ok {
			return fmt.Errorf("can't find %s in state", resourceName)
		}
		rsAttr := rs.Primary.Attributes
		_, ok = rsAttr["instance_type"]
		if !ok {
			return fmt.Errorf("Instance type is not computed for %s", resourceName)
		}
		return nil
	}
}

func testGoogleSqlDatabaseInstance_flags(instance string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"

    database_flags {
      name  = "character_set_server"
      value = "utf8mb4"
    }
    database_flags {
      name  = "auto_increment_increment"
      value = "2"
    }
  }
}`, instance)
}

func testGoogleSqlDatabaseInstance_flags_update(instance string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "MYSQL_5_7"
  deletion_protection = false
  settings {
    tier = "db-g1-small"

    database_flags {
      name  = "auto_increment_increment"
      value = "2"
    }
    database_flags {
      name  = "character_set_server"
      value = "utf8mb4"
    }
  }
}`, instance)
}

func testGoogleSqlDatabaseInstance_readReplica(instance string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "master" {
  region           = "asia-northeast1"
  name             = "%s-master"
  database_version = "MYSQL_5_7"
  deletion_protection  = false
  settings {
    availability_type = "ZONAL"
    disk_autoresize   = true
    disk_size         = 10
    disk_type         = "PD_SSD"
    tier              = "db-g1-small"

    activation_policy = "ALWAYS"
    pricing_plan      = "PER_USE"

    backup_configuration {
      binary_log_enabled = true
      enabled            = true
      location           = "asia"
      start_time         = "18:00"
    }

    database_flags {
      name  = "character_set_server"
      value = "utf8mb4"
    }
  }
}


resource "google_sql_database_instance" "replica" {
  depends_on           = [google_sql_database_instance.master]
  name                 = "%s-replica"
  master_instance_name = google_sql_database_instance.master.name
  region               = "asia-northeast1"
  database_version     = "MYSQL_5_7"
  deletion_protection  = false
  replica_configuration {
    failover_target = false
  }
  settings {
    tier              = "db-g1-small"
    availability_type = "ZONAL"
    pricing_plan      = "PER_USE"
    disk_autoresize   = true
    disk_size         = 10

    backup_configuration {
      binary_log_enabled = true
    }

    database_flags {
      name  = "slave_parallel_workers"
      value = "3"
    }

    database_flags {
      name  = "slave_parallel_type"
      value = "LOGICAL_CLOCK"
    }

    database_flags {
      name  = "slave_pending_jobs_size_max"
      value = "536870912" # 512MB
    }
  }
}`, instance, instance)
}

func testGoogleSqlDatabaseInstance_updateReadReplica(instance string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "master" {
  region           = "asia-northeast1"
  name             = "%s-master"
  database_version = "MYSQL_5_7"
  deletion_protection  = false
  settings {
    availability_type = "ZONAL"
    disk_autoresize   = true
    disk_size         = 10
    disk_type         = "PD_SSD"
    tier              = "db-g1-small"

    activation_policy = "ALWAYS"
    pricing_plan      = "PER_USE"

    backup_configuration {
      binary_log_enabled = true
      enabled            = true
      location           = "asia"
      start_time         = "18:00"
    }

    database_flags {
      name  = "character_set_server"
      value = "utf8mb4"
    }
  }
}


resource "google_sql_database_instance" "replica" {
  depends_on           = [google_sql_database_instance.master]
  name                 = "%s-replica"
  master_instance_name = google_sql_database_instance.master.name
  region               = "asia-northeast1"
  database_version     = "MYSQL_5_7"
  deletion_protection  = false
  replica_configuration {
    failover_target = false
  }
  settings {
    tier              = "db-g1-small"
    availability_type = "ZONAL"
    pricing_plan      = "PER_USE"
    disk_autoresize   = true
    disk_size         = 10

    backup_configuration {
      binary_log_enabled = true
    }

    database_flags {
      name  = "slave_parallel_workers"
      value = "2"
    }

    database_flags {
      name  = "slave_parallel_type"
      value = "LOGICAL_CLOCK"
    }

    database_flags {
      name  = "slave_pending_jobs_size_max"
      value = "536870912" # 512MB
    }
  }
}`, instance, instance)
}

func testGoogleSqlDatabaseInstance_updateRootPassword(instance, databaseVersion, rootPassword string) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "main" {
    name             = "%s"
	database_version = "%s"
	region           = "us-central1"
	deletion_protection = false
	root_password = "%s"
	settings {
		tier = "db-custom-2-13312"
	}
}`, instance, databaseVersion, rootPassword)
}

func testGoogleSqlDatabaseInstance_activationPolicy(instance, databaseVersion, activationPolicy string, deletionProtection bool) string {
	return fmt.Sprintf(`
resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "%s"
  deletion_protection = %t
  settings {
    tier              = "db-g1-small"
    activation_policy = "%s"
  }
}
`, instance, databaseVersion, deletionProtection, activationPolicy)
}

func testGoogleSqlDatabaseInstance_diskSizeAutoResize(project, dbName string, diskSize, maxConnections int, autoResize *bool, ignoreChanges, allowDestroy bool) string {
	diskSizeStmt := ""
	if diskSize != 0 {
		diskSizeStmt = fmt.Sprintf("disk_size = %d", diskSize)
	}
	autoResizeStmt := ""
	if autoResize != nil {
		if *autoResize {
			autoResizeStmt = "disk_autoresize = true"
		} else {
			autoResizeStmt = "disk_autoresize = false"
		}
	}
	ignoreChangesStmt := ""
	if ignoreChanges {
		ignoreChangesStmt = "settings[0].disk_size"
	}

	preventDestroyStmt := "prevent_destroy = true"
	if allowDestroy {
		preventDestroyStmt = ""
	}

	return fmt.Sprintf(`
data "google_project" "project" {
  project_id = "%s"
}

resource "google_sql_database_instance" "instance" {
  name                = "%s"
  region              = "us-central1"
  database_version    = "POSTGRES_15"
  deletion_protection = false
  settings {
	tier = "db-f1-micro"
	%s
	%s
	database_flags {
      name  = "max_connections"
      value = "%d"
    }
  }
  lifecycle {
    ignore_changes = [%s]
	%s
  }
}
`, project, dbName, diskSizeStmt, autoResizeStmt, maxConnections, ignoreChangesStmt, preventDestroyStmt)
}

func testGoogleSqlDatabaseInstanceResizeDisk(t *testing.T, instance string, addGb int64) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		config := acctest.GoogleProviderConfig(t)

		sqlAdminClient := config.NewSqlAdminClient(config.UserAgent)

		inst, err := sqlAdminClient.Instances.Get(config.Project, instance).Do()
		if err != nil {
			return fmt.Errorf("Could not get database instance %q: %s", instance, err)
		}

		operation, err := sqlAdminClient.Instances.Patch(config.Project, instance, &sqladmin.DatabaseInstance{
			Settings: &sqladmin.Settings{
				SettingsVersion: inst.Settings.SettingsVersion,
				DataDiskSizeGb:  inst.Settings.DataDiskSizeGb + addGb,
			},
		}).Do()
		if err != nil {
			return fmt.Errorf("Could not update database instance %q: %s", instance, err)
		}

		// Wait for the operation to complete
		if err := sql.SqlAdminOperationWaitTime(config, operation, config.Project, "Waiting for disk resize", config.UserAgent, 10*time.Minute); err != nil {
			return fmt.Errorf("Could not wait for operation to complete: %s", err)
		}

		return nil
	}
}

func testGoogleSqlDatabaseInstanceCheckDiskSize(t *testing.T, instance string, size int64) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		config := acctest.GoogleProviderConfig(t)

		sqlAdminClient := config.NewSqlAdminClient(config.UserAgent)

		inst, err := sqlAdminClient.Instances.Get(config.Project, instance).Do()
		if err != nil {
			return fmt.Errorf("Could not get database instance %q: %s", instance, err)
		}

		if inst.Settings.DataDiskSizeGb != size {
			return fmt.Errorf("Expected disk size %d, got %d", size, inst.Settings.DataDiskSizeGb)
		}

		return nil
	}
}

func testGoogleSqlDatabaseInstanceChangeNodeCount(t *testing.T, instance string, newNodeCount int64) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		config := acctest.GoogleProviderConfig(t)

		sqlAdminClient := config.NewSqlAdminClient(config.UserAgent)

		operation, err := sqlAdminClient.Instances.Patch(config.Project, instance, &sqladmin.DatabaseInstance{
			NodeCount: newNodeCount,
		}).Do()
		if err != nil {
			return fmt.Errorf("Could not update database instance %q: %s", instance, err)
		}

		// Wait for the operation to complete
		if err := sql.SqlAdminOperationWaitTime(config, operation, config.Project, "Waiting for scale op", config.UserAgent, 10*time.Minute); err != nil {
			return fmt.Errorf("Could not wait for operation to complete: %s", err)
		}

		return nil
	}
}

func testGoogleSqlDatabaseInstanceCheckNodeCount(t *testing.T, instance string, nodeCount, minNodeCount, maxNodeCount int64) resource.TestCheckFunc {
	return func(s *terraform.State) error {
		config := acctest.GoogleProviderConfig(t)

		sqlAdminClient := config.NewSqlAdminClient(config.UserAgent)

		inst, err := sqlAdminClient.Instances.Get(config.Project, instance).Do()
		if err != nil {
			return fmt.Errorf("Could not get database instance %q: %s", instance, err)
		}
		if inst.NodeCount != nodeCount {
			return fmt.Errorf("Expected nodeCount %d, got %d", nodeCount, inst.NodeCount)
		}
		if minNodeCount > 0 && inst.Settings.ReadPoolAutoScaleConfig.MinNodeCount != minNodeCount {
			return fmt.Errorf("Expected min node count %d, got %d", minNodeCount, inst.Settings.ReadPoolAutoScaleConfig.MinNodeCount)
		}
		if maxNodeCount > 0 && inst.Settings.ReadPoolAutoScaleConfig.MaxNodeCount != maxNodeCount {
			return fmt.Errorf("Expected max node count %d, got %d", maxNodeCount, inst.Settings.ReadPoolAutoScaleConfig.MaxNodeCount)
		}

		return nil
	}
}