Merge commit 'bc5def9f8136003836911e78567dc8849a39be6d' into sync-main-FEATURE-BRANCH-6.0.0

* commit 'bc5def9f8136003836911e78567dc8849a39be6d':
  Fix test `TestAccSecurityCenterManagementOrganizationEventThreatDetectionCustomModule` (GoogleCloudPlatform#11469)
  Promoted labelFingerprint field to GA (GoogleCloudPlatform#11504)
  Revert "Prevent Dataflow options in parameters" (GoogleCloudPlatform#11485)
  Support Undelete for Vmwareengine Private Cloud (GoogleCloudPlatform#11480)

Author: c2thorn

mmv1/products/compute/GlobalAddress.yaml

@@ -100,7 +100,6 @@ properties:
       internally during updates.
     update_url: 'projects/{{project}}/global/addresses/{{name}}/setLabels'
     update_verb: :POST
-    min_version: beta
   - !ruby/object:Api::Type::Enum
     name: 'ipVersion'
     description: |

mmv1/products/vmwareengine/PrivateCloud.yaml

@@ -47,6 +47,7 @@ autogen_async: true
 custom_code: !ruby/object:Provider::Terraform::CustomCode
   constants: templates/terraform/constants/vmwareengine_private_cloud.go.erb
   decoder: "templates/terraform/decoders/private_cloud.go.erb"
+  pre_create: templates/terraform/pre_create/vmwareengine_private_cloud.go.erb
   pre_delete: templates/terraform/pre_delete/vmwareengine_private_cloud.go.erb
   post_delete: "templates/terraform/post_delete/private_cloud.go.erb"
   post_update: "templates/terraform/post_update/private_cloud.go.erb"

mmv1/templates/terraform/constants/vmwareengine_private_cloud.go.erb

@@ -31,3 +31,49 @@ func isMultiNodePrivateCloud(d *schema.ResourceData) bool {
     }
     return false
 }
+
+func isPrivateCloudInDeletedState(config *transport_tpg.Config, d *schema.ResourceData, billingProject string, userAgent string) (bool, error) {
+    baseurl, err := tpgresource.ReplaceVars(d, config, "{{<%=object.__product.name-%>BasePath}}<%=object.self_link_uri-%>")
+    if err != nil {
+        return false, err
+    }
+    res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
+        Config: config,
+        Method: "GET",
+        Project: billingProject,
+        RawURL: baseurl,
+        UserAgent: userAgent,
+    })
+    if err != nil {
+        if gerr, ok := err.(*googleapi.Error); ok && gerr.Code == 404 {
+			log.Printf("[DEBUG] No existing private cloud found")
+			return false, nil
+		} 
+        return false, err
+    }
+    // if resource exists but is marked for deletion
+    v, ok := res["state"]
+    if ok && v.(string) == "DELETED" {
+        log.Printf("[DEBUG] The Private cloud exists and is marked for deletion.")
+        return true, nil
+    }
+    return false, nil
+}
+
+// Check if private cloud is absent or if it exists in a deleted state.
+func pollCheckForPrivateCloudAbsence(resp map[string]interface{}, respErr error) transport_tpg.PollResult {
+    if respErr != nil {
+        if transport_tpg.IsGoogleApiErrorWithCode(respErr, 404) {
+            return transport_tpg.SuccessPollResult()
+        }
+        return transport_tpg.ErrorPollResult(respErr)
+    }
+    // if resource exists but is marked for deletion
+    log.Printf("[DEBUG] Fetching state of the private cloud.")
+    v, ok := resp["state"]
+    if ok && v.(string) == "DELETED" {
+        log.Printf("[DEBUG] The Private cloud has been successfully marked for delayed deletion.")
+        return transport_tpg.SuccessPollResult()
+    }
+    return transport_tpg.PendingStatusPollResult("found")
+}

mmv1/templates/terraform/post_delete/private_cloud.go.erb

@@ -29,18 +29,11 @@ privateCloudPollRead := func(d *schema.ResourceData, meta interface{}) transport
             if err != nil {
                 return res, err
             }
-            // if resource exists but is marked for deletion
-            log.Printf("[DEBUG] Fetching state of the private cloud.")
-            v, ok := res["state"]
-            if ok && v.(string) == "DELETED" {
-                log.Printf("[DEBUG] The Private cloud has been successfully marked for delayed deletion.")
-                return nil, nil
-            }
             return res, nil
         }
     }
 
-err = transport_tpg.PollingWaitTime(privateCloudPollRead(d, meta), transport_tpg.PollCheckForAbsence, "Deleting <%= object.name -%>", d.Timeout(schema.TimeoutDelete), 10)
+err = transport_tpg.PollingWaitTime(privateCloudPollRead(d, meta), pollCheckForPrivateCloudAbsence, "Deleting <%= object.name -%>", d.Timeout(schema.TimeoutDelete), 10)
 if err != nil {
     return fmt.Errorf("Error waiting to delete PrivateCloud: %s", err)
-}
+}

mmv1/templates/terraform/pre_create/vmwareengine_private_cloud.go.erb

@@ -0,0 +1,15 @@
+// Check if the project exists in a deleted state
+pcMarkedForDeletion, err := isPrivateCloudInDeletedState(config, d, billingProject, userAgent)
+if err != nil {
+        return fmt.Errorf("Error checking if Private Cloud exists and is marked for deletion: %s", err)
+}
+if pcMarkedForDeletion {
+    log.Printf("[DEBUG] Private Cloud exists and is marked for deletion. Triggering UNDELETE of the Private Cloud.\n")
+    url, err = tpgresource.ReplaceVars(d, config, "{{VmwareengineBasePath}}projects/{{project}}/locations/{{location}}/privateClouds/{{name}}:undelete")
+	if err != nil {
+		return err
+	}
+    obj = make(map[string]interface{})
+} else {
+    log.Printf("[DEBUG] Private Cloud is not found to be marked for deletion. Triggering CREATE of the Private Cloud.\n")
+}

mmv1/third_party/terraform/acctest/resource_test_utils.go

@@ -1,17 +1,40 @@
 package acctest
 
 import (
+	"context"
+	"errors"
 	"fmt"
+	"slices"
 	"testing"
 	"time"
 
+	tfjson "github.com/hashicorp/terraform-json"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/plancheck"
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
 	transport_tpg "github.com/hashicorp/terraform-provider-google/google/transport"
 )
 
 // General test utils
 
+var _ plancheck.PlanCheck = expectNoDelete{}
+
+type expectNoDelete struct{}
+
+func (e expectNoDelete) CheckPlan(ctx context.Context, req plancheck.CheckPlanRequest, resp *plancheck.CheckPlanResponse) {
+	var result error
+	for _, rc := range req.Plan.ResourceChanges {
+		if slices.Contains(rc.Change.Actions, tfjson.ActionDelete) {
+			result = errors.Join(result, fmt.Errorf("expected no deletion of resources, but %s has planned deletion", rc.Address))
+		}
+	}
+	resp.Error = result
+}
+
+func ExpectNoDelete() plancheck.PlanCheck {
+	return expectNoDelete{}
+}
+
 // TestExtractResourceAttr navigates a test's state to find the specified resource (or data source) attribute and makes the value
 // accessible via the attributeValue string pointer.
 func TestExtractResourceAttr(resourceName string, attributeName string, attributeValue *string) resource.TestCheckFunc {

mmv1/third_party/terraform/services/compute/resource_compute_global_address_test.go.erb

@@ -7,8 +7,48 @@ import (
 	"github.com/hashicorp/terraform-provider-google/google/acctest"
 
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/plancheck"
 )
 
+func TestAccComputeGlobalAddress_update(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"random_suffix": acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeGlobalAddressDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeGlobalAddress_update1(context),
+			},
+			{
+				ResourceName:      "google_compute_global_address.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateVerifyIgnore: []string{"labels", "terraform_labels"},
+			},
+			{
+				Config: testAccComputeGlobalAddress_update2(context),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						acctest.ExpectNoDelete(),
+					},
+				},
+			},
+			{
+				ResourceName:      "google_compute_global_address.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+				ImportStateVerifyIgnore: []string{"labels", "terraform_labels"},
+			},
+		},
+	})
+}
+
 func TestAccComputeGlobalAddress_ipv6(t *testing.T) {
 	t.Parallel()
 
@@ -75,3 +115,47 @@ resource "google_compute_global_address" "foobar" {
 }
 `, networkName, addressName)
 }
+
+func testAccComputeGlobalAddress_update1(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_network" "foobar" {
+  name = "tf-test-address-%{random_suffix}"
+}
+
+resource "google_compute_global_address" "foobar" {
+  address       = "172.20.181.0"
+  description   = "Description"
+  name          = "tf-test-address-%{random_suffix}"
+  labels        = {
+  	foo = "bar"
+  }
+  ip_version     = "IPV4"
+  prefix_length = 24
+  address_type  = "INTERNAL"
+  purpose       = "VPC_PEERING"
+  network       = google_compute_network.foobar.self_link
+}
+`, context)
+}
+
+func testAccComputeGlobalAddress_update2(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_compute_network" "foobar" {
+  name = "tf-test-address-%{random_suffix}"
+}
+
+resource "google_compute_global_address" "foobar" {
+  address       = "172.20.181.0"
+  description   = "Description"
+  name          = "tf-test-address-%{random_suffix}"
+  labels        = {
+  	foo = "baz"
+  }
+  ip_version     = "IPV4"
+  prefix_length = 24
+  address_type  = "INTERNAL"
+  purpose       = "VPC_PEERING"
+  network       = google_compute_network.foobar.self_link
+}
+`, context)
+}

mmv1/third_party/terraform/services/dataflow/go/resource_dataflow_flex_template_job.go.tmpl

@@ -310,23 +310,38 @@ func resourceDataflowFlexTemplateJobCreate(d *schema.ResourceData, meta interfac
 func resourceDataflowFlexJobSetupEnv(d *schema.ResourceData, config *transport_tpg.Config) (dataflow.FlexTemplateRuntimeEnvironment, map[string]string, error) {
 
 	updatedParameters := tpgresource.ExpandStringMap(d, "parameters")
-    if err := hasIllegalParametersErr(d); err != nil {
-        return dataflow.FlexTemplateRuntimeEnvironment{}, updatedParameters, err
-    }
 
 	additionalExperiments := tpgresource.ConvertStringSet(d.Get("additional_experiments").(*schema.Set))
 
 	var autoscalingAlgorithm string
 	autoscalingAlgorithm, updatedParameters = dataflowFlexJobTypeTransferVar("autoscaling_algorithm", "autoscalingAlgorithm", updatedParameters, d)
 
-    numWorkers, err := parseInt64("num_workers", d)
-	if err != nil {
-		return dataflow.FlexTemplateRuntimeEnvironment{}, updatedParameters, err
+	var numWorkers int
+	if p, ok := d.GetOk("parameters.numWorkers"); ok {
+		number, err := strconv.Atoi(p.(string))
+		if err != nil {
+			return dataflow.FlexTemplateRuntimeEnvironment{}, updatedParameters, fmt.Errorf("parameters.numWorkers must have a valid integer assigned to it, current value is %s", p.(string))
+		}
+		delete(updatedParameters, "numWorkers")
+		numWorkers = number
+	} else {
+		if v, ok := d.GetOk("num_workers"); ok {
+			numWorkers = v.(int)
+		}
 	}
 
-    maxNumWorkers, err := parseInt64("max_workers", d)
-	if err != nil {
-		return dataflow.FlexTemplateRuntimeEnvironment{}, updatedParameters, err
+	var maxNumWorkers int
+	if p, ok := d.GetOk("parameters.maxNumWorkers"); ok {
+		number, err := strconv.Atoi(p.(string))
+		if err != nil {
+			return dataflow.FlexTemplateRuntimeEnvironment{}, updatedParameters, fmt.Errorf("parameters.maxNumWorkers must have a valid integer assigned to it, current value is %s", p.(string))
+		}
+		delete(updatedParameters, "maxNumWorkers")
+		maxNumWorkers = number
+	} else {
+		if v, ok := d.GetOk("max_workers"); ok {
+			maxNumWorkers = v.(int)
+		}
 	}
 
 	network, updatedParameters := dataflowFlexJobTypeTransferVar("network", "network", updatedParameters, d)
@@ -345,10 +360,23 @@ func resourceDataflowFlexJobSetupEnv(d *schema.ResourceData, config *transport_t
 
 	ipConfiguration, updatedParameters := dataflowFlexJobTypeTransferVar("ip_configuration", "ipConfiguration", updatedParameters, d)
 
-    enableStreamingEngine, err := parseBool("enable_streaming_engine", d)
-    if err != nil {
-        return dataflow.FlexTemplateRuntimeEnvironment{}, updatedParameters, err
-    }
+	var enableStreamingEngine bool
+	if p, ok := d.GetOk("parameters.enableStreamingEngine"); ok {
+		delete(updatedParameters, "enableStreamingEngine")
+		e := strings.ToLower(p.(string))
+		switch e {
+		case "true":
+			enableStreamingEngine = true
+		case "false":
+			enableStreamingEngine = false
+		default:
+			return dataflow.FlexTemplateRuntimeEnvironment{}, nil, fmt.Errorf("error when handling parameters.enableStreamingEngine value: expected value to be true or false but got value `%s`", e)
+		}
+	} else {
+		if v, ok := d.GetOk("enable_streaming_engine"); ok {
+			enableStreamingEngine = v.(bool)
+		}
+	}
 
 	sdkContainerImage, updatedParameters := dataflowFlexJobTypeTransferVar("sdk_container_image", "sdkContainerImage", updatedParameters, d)
 
@@ -357,8 +385,8 @@ func resourceDataflowFlexJobSetupEnv(d *schema.ResourceData, config *transport_t
 	env := dataflow.FlexTemplateRuntimeEnvironment{
 		AdditionalUserLabels:  tpgresource.ExpandStringMap(d, "effective_labels"),
 		AutoscalingAlgorithm:  autoscalingAlgorithm,
-		NumWorkers:            numWorkers,
-		MaxWorkers:            maxNumWorkers,
+		NumWorkers:            int64(numWorkers),
+		MaxWorkers:            int64(maxNumWorkers),
 		Network:               network,
 		ServiceAccountEmail:   serviceAccountEmail,
 		Subnetwork:            subnetwork,
@@ -812,44 +840,4 @@ func dataflowFlexJobTypeParameterOverride(ename, pname string, d *schema.Resourc
 	return nil
 }
 
-func hasIllegalParametersErr(d *schema.ResourceData) error {
-	pKey := "parameters"
-	errFmt := "%s must not include Dataflow options, found: %s"
-	for k := range ResourceDataflowFlexTemplateJob().Schema {
-		if _, notOk := d.GetOk(fmt.Sprintf("%s.%s", pKey, k)); notOk {
-			return fmt.Errorf(errFmt, pKey, k)
-		}
-		kk := tpgresource.SnakeToPascalCase(k)
-		kk = strings.ToLower(kk)
-		if _, notOk := d.GetOk(fmt.Sprintf("%s.%s", pKey, kk)); notOk {
-			return fmt.Errorf(errFmt, pKey, kk)
-		}
-	}
-	return nil
-}
-
-func parseInt64(name string, d *schema.ResourceData) (int64, error) {
-	v, ok := d.GetOk(name)
-	if !ok {
-		return 0, nil
-	}
-	vv, err := strconv.ParseInt(fmt.Sprint(v), 10, 64)
-	if err != nil {
-		return 0, fmt.Errorf("illegal value assigned to %s, got: %s", name, v)
-	}
-	return vv, nil
-}
-
-func parseBool(name string, d *schema.ResourceData) (bool, error) {
-	v, ok := d.GetOk(name)
-	if !ok {
-		return false, nil
-	}
-	vv, err := strconv.ParseBool(fmt.Sprint(v))
-	if err != nil {
-		return false, fmt.Errorf("illegal value assigned to %s, got: %s", name, v)
-	}
-	return vv, nil
-}
-
 {{ end }}

mmv1/third_party/terraform/services/dataflow/go/resource_dataflow_flex_template_job_test.go.tmpl

@@ -581,12 +581,20 @@ func TestAccDataflowFlexTemplateJob_enableStreamingEngine(t *testing.T) {
 		CheckDestroy:             testAccCheckDataflowJobDestroyProducer(t),
 		Steps: []resource.TestStep{
 			{
-                Config:      testAccDataflowFlexTemplateJob_enableStreamingEngine_param(job, bucket, topic),
-                ExpectError: regexp.MustCompile("must not include Dataflow options"),
+				Config: testAccDataflowFlexTemplateJob_enableStreamingEngine_param(job, bucket, topic),
+				Check: resource.ComposeTestCheckFunc(
+					// Is set
+					resource.TestCheckResourceAttr("google_dataflow_flex_template_job.flex_job", "parameters.enableStreamingEngine", "true"),
+					// Is not set
+					resource.TestCheckNoResourceAttr("google_dataflow_flex_template_job.flex_job", "enable_streaming_engine"),
+				),
 			},
 			{
 				Config: testAccDataflowFlexTemplateJob_enableStreamingEngine_field(job, bucket, topic),
 				Check: resource.ComposeTestCheckFunc(
+					// Now is unset
+					resource.TestCheckNoResourceAttr("google_dataflow_flex_template_job.flex_job", "parameters.enableStreamingEngine"),
+					// Now is set
 					resource.TestCheckResourceAttr("google_dataflow_flex_template_job.flex_job", "enable_streaming_engine", "true"),
 				),
 			},