Composer 3 GA: Reintroduce changes (#12399) (#20478)

[upstream:300dee3525c934f6879b6d1b965e55ec483f018e]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/12399.txt

@@ -0,0 +1,15 @@
+```release-note:new-datasource
+`google_composer_user_workloads_config_map` (GA)
+```
+```release-note:new-datasource
+`google_composer_user_workloads_secret` (GA)
+```
+```release-note:new-resource
+`google_composer_user_workloads_config_map` (GA)
+```
+```release-note:new-resource
+`google_composer_user_workloads_secret` (GA)
+```
+```release-note:enhancement
+composer: added multiple composer 3 related fields to `google_composer_environment` (GA)
+```

google/provider/provider_mmv1_resources.go

@@ -40,6 +40,7 @@ import (
 	"github.com/hashicorp/terraform-provider-google/google/services/cloudrunv2"
 	"github.com/hashicorp/terraform-provider-google/google/services/cloudscheduler"
 	"github.com/hashicorp/terraform-provider-google/google/services/cloudtasks"
+	"github.com/hashicorp/terraform-provider-google/google/services/composer"
 	"github.com/hashicorp/terraform-provider-google/google/services/compute"
 	"github.com/hashicorp/terraform-provider-google/google/services/containeranalysis"
 	"github.com/hashicorp/terraform-provider-google/google/services/containerattached"
@@ -132,7 +133,6 @@ import (
 	"github.com/hashicorp/terraform-provider-google/google/services/workbench"
 	"github.com/hashicorp/terraform-provider-google/google/services/workflows"
 
-	"github.com/hashicorp/terraform-provider-google/google/services/composer"
 	"github.com/hashicorp/terraform-provider-google/google/services/container"
 	"github.com/hashicorp/terraform-provider-google/google/services/containeraws"
 	"github.com/hashicorp/terraform-provider-google/google/services/containerazure"
@@ -182,6 +182,8 @@ var handwrittenDatasources = map[string]*schema.Resource{
 	"google_cloud_run_v2_job":                              cloudrunv2.DataSourceGoogleCloudRunV2Job(),
 	"google_cloud_run_v2_service":                          cloudrunv2.DataSourceGoogleCloudRunV2Service(),
 	"google_composer_environment":                          composer.DataSourceGoogleComposerEnvironment(),
+	"google_composer_user_workloads_config_map":            composer.DataSourceGoogleComposerUserWorkloadsConfigMap(),
+	"google_composer_user_workloads_secret":                composer.DataSourceGoogleComposerUserWorkloadsSecret(),
 	"google_composer_image_versions":                       composer.DataSourceGoogleComposerImageVersions(),
 	"google_compute_address":                               compute.DataSourceGoogleComputeAddress(),
 	"google_compute_addresses":                             compute.DataSourceGoogleComputeAddresses(),
@@ -458,9 +460,9 @@ var handwrittenIAMDatasources = map[string]*schema.Resource{
 }
 
 // Resources
-// Generated resources: 495
+// Generated resources: 496
 // Generated IAM resources: 261
-// Total generated resources: 756
+// Total generated resources: 757
 var generatedResources = map[string]*schema.Resource{
 	"google_folder_access_approval_settings":                                     accessapproval.ResourceAccessApprovalFolderSettings(),
 	"google_organization_access_approval_settings":                               accessapproval.ResourceAccessApprovalOrganizationSettings(),
@@ -626,6 +628,7 @@ var generatedResources = map[string]*schema.Resource{
 	"google_cloud_tasks_queue_iam_binding":                                       tpgiamresource.ResourceIamBinding(cloudtasks.CloudTasksQueueIamSchema, cloudtasks.CloudTasksQueueIamUpdaterProducer, cloudtasks.CloudTasksQueueIdParseFunc),
 	"google_cloud_tasks_queue_iam_member":                                        tpgiamresource.ResourceIamMember(cloudtasks.CloudTasksQueueIamSchema, cloudtasks.CloudTasksQueueIamUpdaterProducer, cloudtasks.CloudTasksQueueIdParseFunc),
 	"google_cloud_tasks_queue_iam_policy":                                        tpgiamresource.ResourceIamPolicy(cloudtasks.CloudTasksQueueIamSchema, cloudtasks.CloudTasksQueueIamUpdaterProducer, cloudtasks.CloudTasksQueueIdParseFunc),
+	"google_composer_user_workloads_config_map":                                  composer.ResourceComposerUserWorkloadsConfigMap(),
 	"google_compute_address":                                                     compute.ResourceComputeAddress(),
 	"google_compute_autoscaler":                                                  compute.ResourceComputeAutoscaler(),
 	"google_compute_backend_bucket":                                              compute.ResourceComputeBackendBucket(),
@@ -1219,6 +1222,7 @@ var handwrittenResources = map[string]*schema.Resource{
 	"google_billing_subaccount":                     resourcemanager.ResourceBillingSubaccount(),
 	"google_cloudfunctions_function":                cloudfunctions.ResourceCloudFunctionsFunction(),
 	"google_composer_environment":                   composer.ResourceComposerEnvironment(),
+	"google_composer_user_workloads_secret":         composer.ResourceComposerUserWorkloadsSecret(),
 	"google_compute_attached_disk":                  compute.ResourceComputeAttachedDisk(),
 	"google_compute_instance":                       compute.ResourceComputeInstance(),
 	"google_compute_disk_async_replication":         compute.ResourceComputeDiskAsyncReplication(),

google/services/composer/data_source_google_composer_user_workloads_config_map.go

@@ -1,3 +1,51 @@
 // Copyright (c) HashiCorp, Inc.
 // SPDX-License-Identifier: MPL-2.0
 package composer
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-provider-google/google/tpgresource"
+	transport_tpg "github.com/hashicorp/terraform-provider-google/google/transport"
+)
+
+func DataSourceGoogleComposerUserWorkloadsConfigMap() *schema.Resource {
+	dsSchema := tpgresource.DatasourceSchemaFromResourceSchema(ResourceComposerUserWorkloadsConfigMap().Schema)
+
+	// Set 'Required' schema elements
+	tpgresource.AddRequiredFieldsToSchema(dsSchema, "environment", "name")
+
+	// Set 'Optional' schema elements
+	tpgresource.AddOptionalFieldsToSchema(dsSchema, "project", "region")
+
+	return &schema.Resource{
+		Read:   dataSourceGoogleComposerUserWorkloadsConfigMapRead,
+		Schema: dsSchema,
+	}
+}
+
+func dataSourceGoogleComposerUserWorkloadsConfigMapRead(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*transport_tpg.Config)
+
+	id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{region}}/environments/{{environment}}/userWorkloadsConfigMaps/{{name}}")
+	if err != nil {
+		return fmt.Errorf("Error constructing id: %s", err)
+	}
+	d.SetId(id)
+
+	err = resourceComposerUserWorkloadsConfigMapRead(d, meta)
+	if err != nil {
+		return err
+	}
+
+	if err := tpgresource.SetDataSourceLabels(d); err != nil {
+		return err
+	}
+
+	if d.Id() == "" {
+		return fmt.Errorf("%s not found", id)
+	}
+
+	return nil
+}

google/services/composer/data_source_google_composer_user_workloads_config_map_test.go

@@ -1,3 +1,59 @@
 // Copyright (c) HashiCorp, Inc.
 // SPDX-License-Identifier: MPL-2.0
 package composer_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-provider-google/google/acctest"
+)
+
+func TestAccDataSourceComposerUserWorkloadsConfigMap_basic(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"env_name":        fmt.Sprintf("%s-%d", testComposerEnvironmentPrefix, acctest.RandInt(t)),
+		"config_map_name": fmt.Sprintf("tf-test-composer-config-map-%d", acctest.RandInt(t)),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceComposerUserWorkloadsConfigMap_basic(context),
+				Check: resource.ComposeTestCheckFunc(
+					acctest.CheckDataSourceStateMatchesResourceState("data.google_composer_user_workloads_config_map.test",
+						"google_composer_user_workloads_config_map.test"),
+				),
+			},
+		},
+	})
+}
+
+func testAccDataSourceComposerUserWorkloadsConfigMap_basic(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_composer_environment" "test" {
+  name   = "%{env_name}"
+  config {
+    software_config {
+      image_version = "composer-3-airflow-2"
+    }
+  }
+}
+resource "google_composer_user_workloads_config_map" "test" {
+  environment = google_composer_environment.test.name
+  name = "%{config_map_name}"
+  data = {
+    db_host: "dbhost:5432",
+    api_host: "apihost:443",
+  }
+}
+data "google_composer_user_workloads_config_map" "test" {
+  name        = google_composer_user_workloads_config_map.test.name
+  environment = google_composer_environment.test.name
+}
+`, context)
+}

google/services/composer/data_source_google_composer_user_workloads_secret.go

@@ -1,3 +1,62 @@
 // Copyright (c) HashiCorp, Inc.
 // SPDX-License-Identifier: MPL-2.0
 package composer
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-provider-google/google/tpgresource"
+	transport_tpg "github.com/hashicorp/terraform-provider-google/google/transport"
+)
+
+func DataSourceGoogleComposerUserWorkloadsSecret() *schema.Resource {
+	dsSchema := tpgresource.DatasourceSchemaFromResourceSchema(ResourceComposerUserWorkloadsSecret().Schema)
+
+	// Set 'Required' schema elements
+	tpgresource.AddRequiredFieldsToSchema(dsSchema, "environment", "name")
+
+	// Set 'Optional' schema elements
+	tpgresource.AddOptionalFieldsToSchema(dsSchema, "project", "region")
+
+	return &schema.Resource{
+		Read:   dataSourceGoogleComposerUserWorkloadsSecretRead,
+		Schema: dsSchema,
+	}
+}
+
+func dataSourceGoogleComposerUserWorkloadsSecretRead(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*transport_tpg.Config)
+
+	id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{region}}/environments/{{environment}}/userWorkloadsSecrets/{{name}}")
+	if err != nil {
+		return fmt.Errorf("Error constructing id: %s", err)
+	}
+	d.SetId(id)
+
+	// retrieve "data" in advance, because Read function won't do it.
+	userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent)
+	if err != nil {
+		return err
+	}
+
+	res, err := config.NewComposerClient(userAgent).Projects.Locations.Environments.UserWorkloadsSecrets.Get(id).Do()
+	if err != nil {
+		return err
+	}
+
+	if err := d.Set("data", res.Data); err != nil {
+		return fmt.Errorf("Error setting UserWorkloadsSecret Data: %s", err)
+	}
+
+	err = resourceComposerUserWorkloadsSecretRead(d, meta)
+	if err != nil {
+		return err
+	}
+
+	if d.Id() == "" {
+		return fmt.Errorf("%s not found", id)
+	}
+
+	return nil
+}

google/services/composer/data_source_google_composer_user_workloads_secret_test.go

@@ -1,3 +1,102 @@
 // Copyright (c) HashiCorp, Inc.
 // SPDX-License-Identifier: MPL-2.0
 package composer_test
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/terraform"
+	"github.com/hashicorp/terraform-provider-google/google/acctest"
+)
+
+func TestAccDataSourceComposerUserWorkloadsSecret_basic(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"env_name":    fmt.Sprintf("%s-%d", testComposerEnvironmentPrefix, acctest.RandInt(t)),
+		"secret_name": fmt.Sprintf("%s-%d", testComposerUserWorkloadsSecretPrefix, acctest.RandInt(t)),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceComposerUserWorkloadsSecret_basic(context),
+				Check: resource.ComposeTestCheckFunc(
+					checkSecretDataSourceMatchesResource(),
+				),
+			},
+		},
+	})
+}
+
+func checkSecretDataSourceMatchesResource() resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		ds, ok := s.RootModule().Resources["data.google_composer_user_workloads_secret.test"]
+		if !ok {
+			return fmt.Errorf("can't find %s in state", "data.google_composer_user_workloads_secret.test")
+		}
+		rs, ok := s.RootModule().Resources["google_composer_user_workloads_secret.test"]
+		if !ok {
+			return fmt.Errorf("can't find %s in state", "google_composer_user_workloads_secret.test")
+		}
+
+		dsAttr := ds.Primary.Attributes
+		rsAttr := rs.Primary.Attributes
+		errMsg := ""
+
+		for k := range rsAttr {
+			if k == "%" || k == "data.%" {
+				continue
+			}
+			// ignore diff if it's due to secrets being masked.
+			if strings.HasPrefix(k, "data.") {
+				if _, ok := dsAttr[k]; !ok {
+					errMsg += fmt.Sprintf("%s is defined in resource and not in datasource\n", k)
+				}
+				if dsAttr[k] == "**********" {
+					continue
+				}
+			}
+			if dsAttr[k] != rsAttr[k] {
+				errMsg += fmt.Sprintf("%s is %s; want %s\n", k, dsAttr[k], rsAttr[k])
+			}
+		}
+
+		if errMsg != "" {
+			return errors.New(errMsg)
+		}
+
+		return nil
+	}
+}
+
+func testAccDataSourceComposerUserWorkloadsSecret_basic(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_composer_environment" "test" {
+  name   = "%{env_name}"
+  config {
+    software_config {
+      image_version = "composer-3-airflow-2"
+    }
+  }
+}
+resource "google_composer_user_workloads_secret" "test" {
+  environment = google_composer_environment.test.name
+  name = "%{secret_name}"
+  data = {
+    username: base64encode("username"),
+    password: base64encode("password"),
+  }
+}
+data "google_composer_user_workloads_secret" "test" {
+  name        = google_composer_user_workloads_secret.test.name
+  environment = google_composer_environment.test.name
+}
+`, context)
+}