refactor: swap SDK for network_device_type data source

Author: ctreatma

equinix/network_edge_provider_maps.go

@@ -2,14 +2,15 @@ package equinix
 
 import (
 	"github.com/equinix/terraform-provider-equinix/internal/resources/network_edge/account"
+	"github.com/equinix/terraform-provider-equinix/internal/resources/network_edge/devicetype"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
 func networkEdgeDatasources() map[string]*schema.Resource {
 	return map[string]*schema.Resource{
 		"equinix_network_account":         account.DataSource(),
 		"equinix_network_device":          dataSourceNetworkDevice(),
-		"equinix_network_device_type":     dataSourceNetworkDeviceType(),
+		"equinix_network_device_type":     devicetype.DataSource(),
 		"equinix_network_device_software": dataSourceNetworkDeviceSoftware(),
 		"equinix_network_device_platform": dataSourceNetworkDevicePlatform(),
 	}

equinix/data_source_network_device_type.go renamed to internal/resources/network_edge/devicetype/data_source.go

@@ -1,15 +1,17 @@
-package equinix
+// Package devicetype provides the network_device_type data source
+package devicetype
 
 import (
 	"context"
 	"fmt"
 	"strings"
 
+	"github.com/equinix/terraform-provider-equinix/internal/comparisons"
 	"github.com/equinix/terraform-provider-equinix/internal/config"
 	"github.com/equinix/terraform-provider-equinix/internal/converters"
 	equinix_validation "github.com/equinix/terraform-provider-equinix/internal/validation"
 
-	"github.com/equinix/ne-go"
+	"github.com/equinix/equinix-sdk-go/services/networkedgev1"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
@@ -33,7 +35,8 @@ var networkDeviceTypeDescriptions = map[string]string{
 	"MetroCodes":  "List of metro codes where device type has to be available",
 }
 
-func dataSourceNetworkDeviceType() *schema.Resource {
+// DataSource creates a new Terraform data source for retrieving device type data
+func DataSource() *schema.Resource {
 	return &schema.Resource{
 		ReadContext: dataSourceNetworkDeviceTypeRead,
 		Description: "Use this data source to get Equinix Network Edge device type details",
@@ -85,28 +88,33 @@ func dataSourceNetworkDeviceType() *schema.Resource {
 }
 
 func dataSourceNetworkDeviceTypeRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
-	conf := m.(*config.Config)
 	var diags diag.Diagnostics
-	types, err := conf.Ne.GetDeviceTypes()
+	client := m.(*config.Config).NewNetworkEdgeClientForSDK(ctx, d)
+	types, _, err := client.SetupApi.GetVirtualDevicesUsingGET(ctx).Execute()
 	name := d.Get(networkDeviceTypeSchemaNames["Name"]).(string)
 	vendor := d.Get(networkDeviceTypeSchemaNames["Vendor"]).(string)
 	category := d.Get(networkDeviceTypeSchemaNames["Category"]).(string)
 	metroCodes := converters.SetToStringList(d.Get(networkDeviceTypeSchemaNames["MetroCodes"]).(*schema.Set))
 	if err != nil {
 		return diag.FromErr(err)
 	}
-	filtered := make([]ne.DeviceType, 0, len(types))
-	for _, deviceType := range types {
-		if name != "" && ne.StringValue(deviceType.Name) != name {
+	filtered := make([]networkedgev1.VirtualDeviceType, 0, len(types.Data))
+	for _, deviceType := range types.Data {
+		if name != "" && deviceType.GetName() != name {
 			continue
 		}
-		if vendor != "" && ne.StringValue(deviceType.Vendor) != vendor {
+		if vendor != "" && deviceType.GetVendor() != vendor {
 			continue
 		}
-		if category != "" && !strings.EqualFold(ne.StringValue(deviceType.Category), category) {
+		if category != "" && !strings.EqualFold(deviceType.GetCategory(), category) {
 			continue
 		}
-		if !stringsFound(metroCodes, deviceType.MetroCodes) {
+
+		availableMetros := make([]string, len(deviceType.AvailableMetros))
+		for _, metro := range deviceType.AvailableMetros {
+			availableMetros = append(availableMetros, metro.GetMetroCode())
+		}
+		if !comparisons.Subsets(metroCodes, availableMetros) {
 			continue
 		}
 		filtered = append(filtered, deviceType)
@@ -123,24 +131,29 @@ func dataSourceNetworkDeviceTypeRead(ctx context.Context, d *schema.ResourceData
 	return diags
 }
 
-func updateNetworkDeviceTypeResource(deviceType ne.DeviceType, d *schema.ResourceData) error {
-	d.SetId(ne.StringValue(deviceType.Code))
-	if err := d.Set(networkDeviceTypeSchemaNames["Name"], deviceType.Name); err != nil {
+func updateNetworkDeviceTypeResource(deviceType networkedgev1.VirtualDeviceType, d *schema.ResourceData) error {
+	d.SetId(deviceType.GetDeviceTypeCode())
+	if err := d.Set(networkDeviceTypeSchemaNames["Name"], deviceType.GetName()); err != nil {
 		return fmt.Errorf("error reading Name: %s", err)
 	}
-	if err := d.Set(networkDeviceTypeSchemaNames["Code"], deviceType.Code); err != nil {
+	if err := d.Set(networkDeviceTypeSchemaNames["Code"], deviceType.GetDeviceTypeCode()); err != nil {
 		return fmt.Errorf("error reading Code: %s", err)
 	}
-	if err := d.Set(networkDeviceTypeSchemaNames["Description"], deviceType.Description); err != nil {
+	if err := d.Set(networkDeviceTypeSchemaNames["Description"], deviceType.GetDescription()); err != nil {
 		return fmt.Errorf("error reading Description: %s", err)
 	}
-	if err := d.Set(networkDeviceTypeSchemaNames["Vendor"], deviceType.Vendor); err != nil {
+	if err := d.Set(networkDeviceTypeSchemaNames["Vendor"], deviceType.GetVendor()); err != nil {
 		return fmt.Errorf("error reading Vendor: %s", err)
 	}
-	if err := d.Set(networkDeviceTypeSchemaNames["Category"], deviceType.Category); err != nil {
+	if err := d.Set(networkDeviceTypeSchemaNames["Category"], deviceType.GetCategory()); err != nil {
 		return fmt.Errorf("error reading Category: %s", err)
 	}
-	if err := d.Set(networkDeviceTypeSchemaNames["MetroCodes"], deviceType.MetroCodes); err != nil {
+
+	availableMetros := make([]string, len(deviceType.AvailableMetros))
+	for _, metro := range deviceType.AvailableMetros {
+		availableMetros = append(availableMetros, metro.GetMetroCode())
+	}
+	if err := d.Set(networkDeviceTypeSchemaNames["MetroCodes"], availableMetros); err != nil {
 		return fmt.Errorf("error reading MetroCodes: %s", err)
 	}
 	return nil

equinix/data_source_network_device_type_acc_test.go renamed to internal/resources/network_edge/devicetype/data_source_test.go

@@ -1,15 +1,17 @@
-package equinix
+package devicetype_test
 
 import (
 	"fmt"
 	"testing"
 
+	"github.com/equinix/terraform-provider-equinix/internal/acceptance"
+	"github.com/equinix/terraform-provider-equinix/internal/nprintf"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
 )
 
 func TestAccDataSourceNetworkDeviceType_basic(t *testing.T) {
-	metro, _ := schema.EnvDefaultFunc(networkDeviceMetroEnvVar, "SV")()
+	metro, _ := schema.EnvDefaultFunc(acceptance.NetworkDeviceMetroEnvVar, "SV")()
 	context := map[string]interface{}{
 		"resourceName": "router",
 		"category":     "Router",
@@ -18,8 +20,8 @@ func TestAccDataSourceNetworkDeviceType_basic(t *testing.T) {
 	}
 	resourceName := fmt.Sprintf("data.equinix_network_device_type.%s", context["resourceName"].(string))
 	resource.ParallelTest(t, resource.TestCase{
-		PreCheck:  func() { testAccPreCheck(t) },
-		Providers: testAccProviders,
+		PreCheck:  func() { acceptance.TestAccPreCheck(t) },
+		Providers: acceptance.TestAccProviders,
 		Steps: []resource.TestStep{
 			{
 				Config: testAccDataSourceNetworkDeviceTypeConfig_basic(context),
@@ -34,7 +36,7 @@ func TestAccDataSourceNetworkDeviceType_basic(t *testing.T) {
 }
 
 func testAccDataSourceNetworkDeviceTypeConfig_basic(ctx map[string]interface{}) string {
-	return nprintf(`
+	return nprintf.NPrintf(`
 data "equinix_network_device_type" "%{resourceName}" {
   category    = "%{category}"
   vendor      = "%{vendor}"