azurerm_private_endpoint implement list (#31769)

[FEATURE] * `azurerm_private_endpoint` implement list resource (#31769)

Author: mstroob

internal/services/network/private_endpoint_resource.go

@@ -622,8 +622,6 @@ func resourcePrivateEndpointUpdate(d *pluginsdk.ResourceData, meta interface{})
 
 func resourcePrivateEndpointRead(d *pluginsdk.ResourceData, meta interface{}) error {
 	client := meta.(*clients.Client).Network.PrivateEndpoints
-	nicsClient := meta.(*clients.Client).Network.NetworkInterfaces
-	dnsClient := meta.(*clients.Client).Network.PrivateDnsZoneGroups
 	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
 	defer cancel()
 
@@ -642,15 +640,17 @@ func resourcePrivateEndpointRead(d *pluginsdk.ResourceData, meta interface{}) er
 		return fmt.Errorf("reading %s: %+v", id, err)
 	}
 
-	privateDnsZoneIds, err := retrievePrivateDnsZoneGroupsForPrivateEndpoint(ctx, dnsClient, *id)
-	if err != nil {
-		return err
-	}
+	return resourcePrivateEndpointFlatten(ctx, meta.(*clients.Client), d, id, resp.Model, true)
+}
+
+func resourcePrivateEndpointFlatten(ctx context.Context, metaClient *clients.Client, d *pluginsdk.ResourceData, id *privateendpoints.PrivateEndpointId, model *privateendpoints.PrivateEndpoint, fetchCompleteData bool) error {
+	nicsClient := metaClient.Network.NetworkInterfaces
+	dnsClient := metaClient.Network.PrivateDnsZoneGroups
 
 	d.Set("name", id.PrivateEndpointName)
 	d.Set("resource_group_name", id.ResourceGroupName)
 
-	if model := resp.Model; model != nil {
+	if model != nil {
 		d.Set("location", location.NormalizeNilable(model.Location))
 
 		if props := model.Properties; props != nil {
@@ -693,33 +693,39 @@ func resourcePrivateEndpointRead(d *pluginsdk.ResourceData, meta interface{}) er
 				customNicName = *props.CustomNetworkInterfaceName
 			}
 			d.Set("custom_network_interface_name", customNicName)
-		}
 
-		privateDnsZoneConfigs := make([]interface{}, 0)
-		privateDnsZoneGroups := make([]interface{}, 0)
-		if privateDnsZoneIds != nil {
-			for _, dnsZoneId := range *privateDnsZoneIds {
-				flattened, err := retrieveAndFlattenPrivateDnsZone(ctx, dnsClient, dnsZoneId)
+			if fetchCompleteData {
+				privateDnsZoneIds, err := retrievePrivateDnsZoneGroupsForPrivateEndpoint(ctx, dnsClient, *id)
 				if err != nil {
-					return fmt.Errorf("reading %s for %s: %+v", dnsZoneId, id, err)
+					return err
 				}
 
-				// an exceptional case but no harm in handling
-				if flattened == nil {
-					continue
+				privateDnsZoneConfigs := make([]interface{}, 0)
+				privateDnsZoneGroups := make([]interface{}, 0)
+				if privateDnsZoneIds != nil {
+					for _, dnsZoneId := range *privateDnsZoneIds {
+						flattened, err := retrieveAndFlattenPrivateDnsZone(ctx, dnsClient, dnsZoneId)
+						if err != nil {
+							return fmt.Errorf("reading %s for %s: %+v", dnsZoneId, id, err)
+						}
+
+						// an exceptional case but no harm in handling
+						if flattened == nil {
+							continue
+						}
+
+						privateDnsZoneConfigs = append(privateDnsZoneConfigs, flattened.DnsZoneConfig...)
+						privateDnsZoneGroups = append(privateDnsZoneGroups, flattened.DnsZoneGroup)
+					}
+				}
+				if err = d.Set("private_dns_zone_configs", privateDnsZoneConfigs); err != nil {
+					return fmt.Errorf("setting `private_dns_zone_configs`: %+v", err)
+				}
+				if err = d.Set("private_dns_zone_group", privateDnsZoneGroups); err != nil {
+					return fmt.Errorf("setting `private_dns_zone_group`: %+v", err)
 				}
-
-				privateDnsZoneConfigs = append(privateDnsZoneConfigs, flattened.DnsZoneConfig...)
-				privateDnsZoneGroups = append(privateDnsZoneGroups, flattened.DnsZoneGroup)
 			}
 		}
-		if err = d.Set("private_dns_zone_configs", privateDnsZoneConfigs); err != nil {
-			return fmt.Errorf("setting `private_dns_zone_configs`: %+v", err)
-		}
-		if err = d.Set("private_dns_zone_group", privateDnsZoneGroups); err != nil {
-			return fmt.Errorf("setting `private_dns_zone_group`: %+v", err)
-		}
-
 		if err := tags.FlattenAndSet(d, model.Tags); err != nil {
 			return err
 		}

internal/services/network/private_endpoint_resource_list.go

@@ -0,0 +1,108 @@
+// Copyright IBM Corp.
+// SPDX-License-Identifier: MPL-2.0
+
+package network
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/go-azure-helpers/lang/pointer"
+	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonids"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/network/2025-01-01/privateendpoints"
+	"github.com/hashicorp/terraform-plugin-framework/list"
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/sdk"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
+)
+
+type PrivateEndpointListResource struct{}
+
+var _ sdk.FrameworkListWrappedResource = new(PrivateEndpointListResource)
+
+func (r PrivateEndpointListResource) ResourceFunc() *pluginsdk.Resource {
+	return resourcePrivateEndpoint()
+}
+
+func (r PrivateEndpointListResource) Metadata(_ context.Context, _ resource.MetadataRequest, response *resource.MetadataResponse) {
+	response.TypeName = "azurerm_private_endpoint"
+}
+
+func (r PrivateEndpointListResource) List(ctx context.Context, request list.ListRequest, stream *list.ListResultsStream, metadata sdk.ResourceMetadata) {
+	client := metadata.Client.Network.PrivateEndpoints
+	metaClient := metadata.Client
+
+	var data sdk.DefaultListModel
+	diags := request.Config.Get(ctx, &data)
+	if diags.HasError() {
+		stream.Results = list.ListResultsStreamDiagnostics(diags)
+		return
+	}
+
+	results := make([]privateendpoints.PrivateEndpoint, 0)
+	subscriptionID := metadata.SubscriptionId
+	if !data.SubscriptionId.IsNull() {
+		subscriptionID = data.SubscriptionId.ValueString()
+	}
+
+	switch {
+	case !data.ResourceGroupName.IsNull():
+		resp, err := client.ListComplete(ctx, commonids.NewResourceGroupID(subscriptionID, data.ResourceGroupName.ValueString()))
+		if err != nil {
+			sdk.SetResponseErrorDiagnostic(stream, fmt.Sprintf("listing `%s`", `azurerm_private_endpoint`), err)
+			return
+		}
+
+		results = resp.Items
+	default:
+		resp, err := client.ListBySubscriptionComplete(ctx, commonids.NewSubscriptionID(subscriptionID))
+		if err != nil {
+			sdk.SetResponseErrorDiagnostic(stream, fmt.Sprintf("listing `%s`", `azurerm_private_endpoint`), err)
+			return
+		}
+
+		results = resp.Items
+	}
+
+	deadline, ok := ctx.Deadline()
+	if !ok {
+		sdk.SetResponseErrorDiagnostic(stream, "internal-error", "context had no deadline")
+		return
+	}
+
+	stream.Results = func(push func(list.ListResult) bool) {
+		ctx, cancel := context.WithDeadline(context.Background(), deadline)
+		defer cancel()
+
+		for _, privateendpoint := range results {
+			result := request.NewListResult(ctx)
+
+			result.DisplayName = pointer.From(privateendpoint.Name)
+
+			rd := resourcePrivateEndpoint().Data(&terraform.InstanceState{})
+
+			id, err := privateendpoints.ParsePrivateEndpointID(pointer.From(privateendpoint.Id))
+			if err != nil {
+				sdk.SetErrorDiagnosticAndPushListResult(result, push, "parsing PrivateEndpoint ID", err)
+				return
+			}
+
+			rd.SetId(id.ID())
+
+			if err := resourcePrivateEndpointFlatten(ctx, metaClient, rd, id, &privateendpoint, request.IncludeResource); err != nil {
+				sdk.SetErrorDiagnosticAndPushListResult(result, push, fmt.Sprintf("encoding `%s` resource data", "azurerm_private_endpoint"), err)
+				return
+			}
+
+			sdk.EncodeListResult(ctx, rd, &result)
+			if result.Diagnostics.HasError() {
+				push(result)
+				return
+			}
+			if !push(result) {
+				return
+			}
+		}
+	}
+}

internal/services/network/private_endpoint_resource_list_test.go

@@ -0,0 +1,83 @@
+package network_test
+
+import (
+	"context"
+	"regexp"
+	"strconv"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/knownvalue"
+	"github.com/hashicorp/terraform-plugin-testing/querycheck"
+	"github.com/hashicorp/terraform-plugin-testing/tfversion"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/acceptance"
+	"github.com/hashicorp/terraform-provider-azurerm/internal/provider/framework"
+)
+
+func TestAccVirtualPrivateEndpoint_listBySubscriptionAndRG(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_private_endpoint", "testlist1")
+	r := PrivateEndpointResource{}
+
+	resource.Test(t, resource.TestCase{
+		TerraformVersionChecks: []tfversion.TerraformVersionCheck{
+			tfversion.SkipBelow(tfversion.Version1_14_0),
+		},
+		ProtoV5ProviderFactories: framework.ProtoV5ProviderFactoriesInit(context.Background(), "azurerm"),
+		Steps: []resource.TestStep{
+			{
+				Config: r.basic(data),
+			},
+			{
+				Query:  true,
+				Config: r.basicQuery(),
+				QueryResultChecks: []querycheck.QueryResultCheck{
+					querycheck.ExpectLengthAtLeast("azurerm_private_endpoint.list", 1), // expect at least the 1 we created
+					querycheck.ExpectIdentity(
+						"azurerm_private_endpoint.list",
+						map[string]knownvalue.Check{
+							"name":                knownvalue.StringRegexp(regexp.MustCompile(strconv.Itoa(data.RandomInteger))),
+							"resource_group_name": knownvalue.StringRegexp(regexp.MustCompile(strconv.Itoa(data.RandomInteger))),
+							"subscription_id":     knownvalue.StringExact(data.Subscriptions.Primary),
+						},
+					),
+				},
+			},
+			{
+				Query:  true,
+				Config: r.basicQueryByResourceGroupName(),
+				QueryResultChecks: []querycheck.QueryResultCheck{
+					querycheck.ExpectLength("azurerm_private_endpoint.list", 1), // expect at least the 1 we created
+					querycheck.ExpectIdentity(
+						"azurerm_private_endpoint.list",
+						map[string]knownvalue.Check{
+							"name":                knownvalue.StringRegexp(regexp.MustCompile(strconv.Itoa(data.RandomInteger))),
+							"resource_group_name": knownvalue.StringRegexp(regexp.MustCompile(strconv.Itoa(data.RandomInteger))),
+							"subscription_id":     knownvalue.StringExact(data.Subscriptions.Primary),
+						},
+					),
+				},
+			},
+		},
+	})
+}
+
+func (r PrivateEndpointResource) basicQuery() string {
+	return `
+list "azurerm_private_endpoint" "list" {
+  provider = azurerm
+  config {
+  }
+}
+`
+}
+
+func (r PrivateEndpointResource) basicQueryByResourceGroupName() string {
+	return `
+list "azurerm_private_endpoint" "list" {
+  provider = azurerm
+  config {
+    resource_group_name = azurerm_resource_group.test.name
+  }
+}
+`
+}

internal/services/network/registration.go

@@ -214,6 +214,7 @@ func (r Registration) ListResources() []sdk.FrameworkListWrappedResource {
 		NetworkProfileListResource{},
 		NetworkSecurityGroupListResource{},
 		NetworkSecurityRuleListResource{},
+		PrivateEndpointListResource{},
 		PublicIpListResource{},
 		RouteListResource{},
 		RouteTableListResource{},

website/docs/list-resources/private_endpoint.html.markdown

@@ -0,0 +1,42 @@
+---
+subcategory: "Network"
+layout: "azurerm"
+page_title: "Azure Resource Manager: azurerm_private_endpoint"
+description: |-
+    Lists Private Endpoint resources.
+---
+
+# List resource: azurerm_private_endpoint
+
+Lists Private Endpoint resources.
+
+## Example Usage
+
+### List all Private Endpoints in the subscription
+
+```hcl
+list "azurerm_private_endpoint" "example" {
+  provider = azurerm
+  config {
+  }
+}
+```
+
+### List all Private Endpoints in a Resource Group
+
+```hcl
+list "azurerm_private_endpoint" "example" {
+  provider = azurerm
+  config {
+    resource_group_name = "example-rg"
+  }
+}
+```
+
+## Argument Reference
+
+This list resource supports the following arguments:
+
+* `subscription_id` - (Optional) The ID of the Subscription to query. Defaults to the value specified in the Provider Configuration.
+
+* `resource_group_name` - (Optional) The name of the Resource Group to query.