fetchforresourceType bpa added (#15043)

Co-authored-by: Cameron Thornton <[email protected]>

Author: kushallunkad-google

mmv1/third_party/terraform/provider/provider_mmv1_resources.go.tmpl

@@ -43,6 +43,7 @@ var handwrittenDatasources = map[string]*schema.Resource{
 	"google_apphub_discovered_service":		    apphub.DataSourceApphubDiscoveredService(),
 	"google_backup_dr_management_server":				backupdr.DataSourceGoogleCloudBackupDRService(),
 	"google_backup_dr_backup_plan_association":			backupdr.DataSourceGoogleCloudBackupDRBackupPlanAssociation(),
+	"google_backup_dr_backup_plan_associations":		backupdr.DataSourceGoogleCloudBackupDRBackupPlanAssociations(),
 	"google_backup_dr_backup_plan":						backupdr.DataSourceGoogleCloudBackupDRBackupPlan(),
 	"google_backup_dr_backup":							backupdr.DataSourceGoogleCloudBackupDRBackup(),
 	"google_backup_dr_data_source":						backupdr.DataSourceGoogleCloudBackupDRDataSource(),

mmv1/third_party/terraform/services/backupdr/data_source_backup_dr_backup_plan_association.go

@@ -2,6 +2,7 @@ package backupdr
 
 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"
@@ -44,3 +45,110 @@ func dataSourceGoogleCloudBackupDRBackupPlanAssociationRead(d *schema.ResourceDa
 	}
 	return nil
 }
+
+// Plural datasource to Fetch BackupPlanAssociations for a given resource type
+func DataSourceGoogleCloudBackupDRBackupPlanAssociations() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceGoogleCloudBackupDRBackupPlanAssociationsRead,
+		Schema: map[string]*schema.Schema{
+			"location": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: "The location to list the backup plan associations from.",
+			},
+			"project": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Computed:    true,
+				Description: "The ID of the project in which the resource belongs.",
+			},
+			"resource_type": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: `The resource type of workload on which backup plan is applied. Examples include, "compute.googleapis.com/Instance", "compute.googleapis.com/Disk".`,
+			},
+
+			"associations": {
+				Type:        schema.TypeList,
+				Computed:    true,
+				Description: "A list of the backup plan associations found.",
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"resource": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"backup_plan": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"create_time": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dataSourceGoogleCloudBackupDRBackupPlanAssociationsRead(d *schema.ResourceData, meta interface{}) error {
+	config := meta.(*transport_tpg.Config)
+	userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent)
+	if err != nil {
+		return err
+	}
+
+	project, err := tpgresource.GetProject(d, config)
+	if err != nil {
+		return err
+	}
+
+	location := d.Get("location").(string)
+	resourceType := d.Get("resource_type").(string)
+
+	url := fmt.Sprintf("%sprojects/%s/locations/%s/backupPlanAssociations:fetchForResourceType?resourceType=%s", config.BackupDRBasePath, project, location, resourceType)
+
+	res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
+		Config:    config,
+		Method:    "GET",
+		Project:   project,
+		RawURL:    url,
+		UserAgent: userAgent,
+	})
+	if err != nil {
+		return fmt.Errorf("Error reading BackupPlanAssociations: %s", err)
+	}
+
+	// Adjust "backupPlanAssociations" to match the key in the actual API response.
+	items, ok := res["backupPlanAssociations"].([]interface{})
+	if !ok {
+		items = make([]interface{}, 0)
+	}
+
+	// Flatten the list of items from the API response into the schema
+	associations := make([]map[string]interface{}, 0, len(items))
+	for _, item := range items {
+		association := item.(map[string]interface{})
+		flattened := map[string]interface{}{
+			"name":        association["name"],
+			"resource":    association["resource"],
+			"backup_plan": association["backupPlan"],
+			"create_time": association["createTime"],
+		}
+		associations = append(associations, flattened)
+	}
+
+	if err := d.Set("associations", associations); err != nil {
+		return fmt.Errorf("Error setting associations: %s", err)
+	}
+
+	d.SetId(url)
+
+	return nil
+}

mmv1/third_party/terraform/services/backupdr/data_source_backup_dr_backup_plan_association_test.go

@@ -1,9 +1,14 @@
 package backupdr_test
 
 import (
+	"fmt"
+	"strconv"
+	"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"
-	"testing"
 )
 
 func TestAccDataSourceGoogleBackupDRBackupPlanAssociation_basic(t *testing.T) {
@@ -121,3 +126,168 @@ data "google_backup_dr_backup_plan_association" "bpa-test" {
   }
 `, context)
 }
+
+func TestAccDataSourceGoogleBackupDRBackupPlanAssociations(t *testing.T) {
+	t.Parallel()
+	context := map[string]interface{}{
+		"random_suffix": acctest.RandString(t, 10),
+		"bpa_id":        "tf-test-bpa-plural-" + acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccDataSourceGoogleBackupDRBackupPlanAssociations_config(context),
+				Check: testAccCheckBackupPlanAssociationInList(
+					"data.google_backup_dr_backup_plan_associations.bpas",
+					"google_compute_instance.default",
+					"google_backup_dr_backup_plan.foo1",
+					"data.google_project.project",
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckBackupPlanAssociationInList(dataSourceName, instanceName, backupPlanName, projectDsName string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		ds, ok := s.RootModule().Resources[dataSourceName]
+		if !ok {
+			return fmt.Errorf("data source not found: %s", dataSourceName)
+		}
+
+		instance, ok := s.RootModule().Resources[instanceName]
+		if !ok {
+			return fmt.Errorf("instance resource not found: %s", instanceName)
+		}
+
+		backupPlan, ok := s.RootModule().Resources[backupPlanName]
+		if !ok {
+			return fmt.Errorf("backup plan resource not found: %s", backupPlanName)
+		}
+		backupPlanNameFromState := backupPlan.Primary.Attributes["name"]
+
+		project, ok := s.RootModule().Resources[projectDsName]
+		if !ok {
+			return fmt.Errorf("project data source not found: %s", projectDsName)
+		}
+		projectID := project.Primary.Attributes["project_id"]
+		projectNumber := project.Primary.Attributes["number"]
+
+		fmt.Printf("\n--- Performing Direct Association Check ---\n")
+
+		// 1. Reconstruct the 'resource' string using the project NUMBER and instance ID
+		//    to match the format returned by the BackupDR API.
+		instanceID := instance.Primary.Attributes["instance_id"]
+		zone := instance.Primary.Attributes["zone"]
+		expectedResource := fmt.Sprintf("projects/%s/zones/%s/instances/%s", projectNumber, zone, instanceID)
+		fmt.Printf("Expected Resource (constructed): %s\n", expectedResource)
+
+		// 2. Normalize the backup plan name to also use the project NUMBER.
+		expectedBackupPlan := strings.Replace(backupPlanNameFromState, "projects/"+projectID, "projects/"+projectNumber, 1)
+		fmt.Printf("Expected Backup Plan (normalized): %s\n", expectedBackupPlan)
+
+		associationsCount, _ := strconv.Atoi(ds.Primary.Attributes["associations.#"])
+		fmt.Printf("Total associations found by data source: %d\n", associationsCount)
+
+		for i := 0; i < associationsCount; i++ {
+			resourceAttr := ds.Primary.Attributes[fmt.Sprintf("associations.%d.resource", i)]
+			backupPlanAttr := ds.Primary.Attributes[fmt.Sprintf("associations.%d.backup_plan", i)]
+
+			fmt.Printf("Found Association #%d: Resource='%s', BackupPlan='%s'\n", i, resourceAttr, backupPlanAttr)
+
+			if resourceAttr == expectedResource && backupPlanAttr == expectedBackupPlan {
+				fmt.Println("--- Match found! Test successful. ---")
+				return nil
+			}
+		}
+
+		fmt.Println("--- No match found after checking all associations. ---")
+		return fmt.Errorf("no matching backup plan association found in data source '%s' for resource '%s'", dataSourceName, expectedResource)
+	}
+}
+
+func testAccDataSourceGoogleBackupDRBackupPlanAssociations_config(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+  data "google_project" "project" {}
+  
+resource "google_service_account" "default" {
+  account_id   = "tf-test-my-custom1-%{random_suffix}"
+  display_name = "Custom SA for VM Instance"
+}
+
+resource "google_compute_instance" "default" {
+  name         = "tf-test-compute-instance1-%{random_suffix}"
+  machine_type = "n2-standard-2"
+  zone         = "us-central1-a"
+  tags         = ["foo", "bar"]
+  boot_disk {
+    initialize_params {
+      image = "debian-cloud/debian-11"
+    }
+  }
+  network_interface {
+    network = "default"
+  }
+  service_account {
+    email  = google_service_account.default.email
+    scopes = ["cloud-platform"]
+  }
+}
+
+resource "google_backup_dr_backup_vault" "my-backup-vault" {
+    location        = "us-central1"
+    backup_vault_id = "tf-test-bv1-%{random_suffix}"
+    description     = "This is a backup vault for list datasource test."
+    backup_minimum_enforced_retention_duration = "100000s"
+    labels = {
+      foo = "bar1"
+      bar = "baz1"
+    }
+    annotations = {
+      annotations1 = "bar1"
+      annotations2 = "baz1"
+    }
+    force_update = "true"
+    force_delete = "true"
+    allow_missing = "true" 
+}
+
+resource "google_backup_dr_backup_plan" "foo1" {
+  location       = "us-central1"
+  backup_plan_id = "tf-test-bp-test1-%{random_suffix}"
+  resource_type  = "compute.googleapis.com/Instance"
+  backup_vault   = google_backup_dr_backup_vault.my-backup-vault.name
+
+  backup_rules {
+    rule_id                = "rule-1"
+    backup_retention_days  = 2
+    standard_schedule {
+      recurrence_type     = "HOURLY"
+      hourly_frequency    = 6
+      time_zone           = "UTC"
+      backup_window {
+        start_hour_of_day = 12
+        end_hour_of_day   = 18
+      }
+    }
+  }
+}
+
+resource "google_backup_dr_backup_plan_association" "bpa" {
+  location                     = "us-central1"
+  backup_plan_association_id   = "%{bpa_id}"
+  resource                     = google_compute_instance.default.id
+  resource_type                = "compute.googleapis.com/Instance"
+  backup_plan                  = google_backup_dr_backup_plan.foo1.name
+}
+
+data "google_backup_dr_backup_plan_associations" "bpas" {
+  location      = "us-central1"
+  resource_type = "compute.googleapis.com/Instance"
+  depends_on = [google_backup_dr_backup_plan_association.bpa]
+}
+`, context)
+}

mmv1/third_party/terraform/website/docs/d/backup_dr_backup_plan_associations.html.markdown

@@ -0,0 +1,48 @@
+---
+subcategory: "Backup and DR Service"
+description: |-
+  Get information about a list of Backup and DR BackupPlanAssociations for a specific resource type .
+---
+
+# google_backup_dr_backup_plan_associations
+
+Provides a list of Backup and DR BackupPlanAssociations for a specific resource type.
+
+~> **Warning:** This datasource is in beta, and should be used with the terraform-provider-google-beta provider.
+See [Provider Versions](https://terraform.io/docs/providers/google/guides/provider_versions.html) for more details on beta datasources.
+
+## Example Usage
+
+```hcl
+data "google_backup_dr_backup_plan_associations" "compute_instance_associations" {
+  location      = "us-central1"
+  resource_type = "compute.googleapis.com/Instance"
+}
+
+## Argument Reference
+
+The following arguments are supported:
+
+* `location` - (Required)The location where the Backup Plan Association resources reside.
+* `resource_type` - (Required) The resource type of the workload. For example, sqladmin.googleapis.com/Instance or compute.googleapis.com/Instance.
+
+- - -
+
+* `project` - (Optional) The project in which the resource belongs. If it
+    is not provided, the provider project is used.
+
+## Attributes Reference
+
+In addition to the arguments listed above, the following computed attributes are exported:
+
+*   `project` - The ID of the project in which the resource belongs.
+*   `associations` - A list of the backup plan associations found.
+
+Each entry in the `associations` list contains the following fields:
+
+*   `name` - The full name of the backup plan association resource.
+*   `resource` - The resource to which the backup plan is applied.
+*   `backup_plan` - The backup plan to which the resource is attached.
+*   `create_time` - The time when the association was created.
+
+See [google_backup_dr_backup_plan_associations](https://registry.terraform.io/providers/hashicorp/google/latest/docs/resources/backup_dr_backup_plan_associations) resource for details of the available attributes.