chore: Upgrades private_link_endpoint resource to auto-generated SDK. (#1901)

* chore: Upgrades private_link_endpoint resource to auto-generated SDK.

* adds migration test.

* Update internal/service/privatelinkendpoint/resource_privatelink_endpoint_migration_test.go

Co-authored-by: Leo Antoli <[email protected]>

* Update internal/service/privatelinkendpoint/resource_privatelink_endpoint_migration_test.go

Co-authored-by: Leo Antoli <[email protected]>

* updates method name.

* config mig network group

* removes old API usage in the test.

---------

Co-authored-by: Leo Antoli <[email protected]>

Author: marcosuma

.github/workflows/migration-tests.yml

@@ -64,6 +64,7 @@ jobs:
       federation: ${{ steps.filter.outputs.federation == 'true' || env.mustTrigger == 'true' }}
       search_deployment: ${{ steps.filter.outputs.search_deployment == 'true' || env.mustTrigger == 'true' }}
       generic: ${{ steps.filter.outputs.generic == 'true' || env.mustTrigger == 'true' }}
+      network: ${{ steps.filter.outputs.network == 'true' || env.mustTrigger == 'true' }}
     steps:
     - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
     - uses: dorny/paths-filter@0bc4621a3135347011ad047f9ecf449bf72ce2bd
@@ -106,6 +107,13 @@ jobs:
             - 'internal/service/backupcompliancepolicy/*.go'
             - 'internal/service/auditing/*.go'
             - 'internal/service/x509authenticationdatabaseuser/*.go'
+          network:
+            - 'internal/service/networkcontainer/*.go'
+            - 'internal/service/networkpeering/*.go'
+            - 'internal/service/privateendpointregionalmode/*.go'
+            - 'internal/service/privatelinkendpoint/*.go'
+            - 'internal/service/privatelinkendpointservice/*.go'
+            - 'internal/service/privatelinkendpointservicedatafederationonlinearchive/*.go'
   
   project: 
     needs: [ change-detection, get-provider-version ]
@@ -329,4 +337,37 @@ jobs:
           MONGODB_ATLAS_LAST_VERSION: ${{ needs.get-provider-version.outputs.provider_version }}
           TEST_REGEX: "^TestAccMigrationGeneric"
         run: make testacc
-      
+      
+  network:
+    needs: [ change-detection, get-provider-version ]
+    if: ${{ needs.change-detection.outputs.network == 'true' || inputs.test_group == 'network' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: 'go.mod'
+      - uses: hashicorp/setup-terraform@v3
+        with:
+          terraform_version: ${{ env.terraform_version }}
+          terraform_wrapper: false    
+      - name: Migration Tests
+        env:
+          MONGODB_ATLAS_PUBLIC_KEY: ${{ secrets.MONGODB_ATLAS_PUBLIC_KEY_CLOUD_DEV_NETWORK }}
+          MONGODB_ATLAS_PRIVATE_KEY: ${{ secrets.MONGODB_ATLAS_PRIVATE_KEY_CLOUD_DEV_NETWORK }}
+          MONGODB_ATLAS_ORG_ID: ${{ vars.MONGODB_ATLAS_ORG_ID_CLOUD_DEV_NETWORK }}
+          MONGODB_ATLAS_PROJECT_ID: ${{ vars.MONGODB_ATLAS_PROJECT_ID_CLOUD_DEV_NETWORK }}
+          MONGODB_ATLAS_BASE_URL: ${{ vars.MONGODB_ATLAS_BASE_URL }}
+          AWS_ACCOUNT_ID: ${{ secrets.AWS_ACCOUNT_ID }}
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          AWS_REGION: ${{ vars.AWS_REGION }}
+          AWS_SECURITY_GROUP_1: ${{ vars.AWS_SECURITY_GROUP_1 }}
+          AWS_SECURITY_GROUP_2: ${{ vars.AWS_SECURITY_GROUP_2 }}
+          AWS_VPC_CIDR_BLOCK: ${{ vars.AWS_VPC_CIDR_BLOCK }}
+          AWS_VPC_ID: ${{ vars.AWS_VPC_ID }}
+          MONGODB_ATLAS_LAST_VERSION: ${{ needs.get-provider-version.outputs.provider_version }}
+          TEST_REGEX: "^TestAccMigrationNetwork"
+        run: make testacc

internal/service/privatelinkendpoint/data_source_privatelink_endpoint.go

@@ -12,7 +12,7 @@ import (
 
 func DataSource() *schema.Resource {
 	return &schema.Resource{
-		ReadContext: dataSourceMongoDBAtlasPrivateLinkEndpointRead,
+		ReadContext: dataSourceRead,
 		Schema: map[string]*schema.Schema{
 			"project_id": {
 				Type:     schema.TypeString,
@@ -85,65 +85,65 @@ func DataSource() *schema.Resource {
 	}
 }
 
-func dataSourceMongoDBAtlasPrivateLinkEndpointRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+func dataSourceRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	// Get client connection.
-	conn := meta.(*config.MongoDBClient).Atlas
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 
 	projectID := d.Get("project_id").(string)
 	privateLinkID := conversion.GetEncodedID(d.Get("private_link_id").(string), "private_link_id")
 	providerName := d.Get("provider_name").(string)
 
-	privateEndpoint, _, err := conn.PrivateEndpoints.Get(ctx, projectID, providerName, privateLinkID)
+	privateEndpoint, _, err := connV2.PrivateEndpointServicesApi.GetPrivateEndpointService(ctx, projectID, providerName, privateLinkID).Execute()
 	if err != nil {
 		return diag.FromErr(fmt.Errorf(errorPrivateLinkEndpointsRead, privateLinkID, err))
 	}
 
-	if err := d.Set("private_link_id", privateEndpoint.ID); err != nil {
+	if err := d.Set("private_link_id", privateEndpoint.GetId()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "private_link_id", privateLinkID, err))
 	}
 
-	if err := d.Set("endpoint_service_name", privateEndpoint.EndpointServiceName); err != nil {
+	if err := d.Set("endpoint_service_name", privateEndpoint.GetEndpointServiceName()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "endpoint_service_name", privateLinkID, err))
 	}
 
-	if err := d.Set("error_message", privateEndpoint.ErrorMessage); err != nil {
+	if err := d.Set("error_message", privateEndpoint.GetErrorMessage()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "error_message", privateLinkID, err))
 	}
 
-	if err := d.Set("interface_endpoints", privateEndpoint.InterfaceEndpoints); err != nil {
+	if err := d.Set("interface_endpoints", privateEndpoint.GetInterfaceEndpoints()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "interface_endpoints", privateLinkID, err))
 	}
 
-	if err := d.Set("private_endpoints", privateEndpoint.PrivateEndpoints); err != nil {
+	if err := d.Set("private_endpoints", privateEndpoint.GetPrivateEndpoints()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "private_endpoints", privateLinkID, err))
 	}
 
-	if err := d.Set("private_link_service_name", privateEndpoint.PrivateLinkServiceName); err != nil {
+	if err := d.Set("private_link_service_name", privateEndpoint.GetPrivateLinkServiceName()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "private_link_service_name", privateLinkID, err))
 	}
 
-	if err := d.Set("private_link_service_resource_id", privateEndpoint.PrivateLinkServiceResourceID); err != nil {
+	if err := d.Set("private_link_service_resource_id", privateEndpoint.GetPrivateLinkServiceResourceId()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "private_link_service_resource_id", privateLinkID, err))
 	}
 
-	if err := d.Set("status", privateEndpoint.Status); err != nil {
+	if err := d.Set("status", privateEndpoint.GetStatus()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "status", privateLinkID, err))
 	}
 
-	if err := d.Set("endpoint_group_names", privateEndpoint.EndpointGroupNames); err != nil {
+	if err := d.Set("endpoint_group_names", privateEndpoint.GetEndpointGroupNames()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "endpoint_group_names", privateLinkID, err))
 	}
 
-	if err := d.Set("region_name", privateEndpoint.RegionName); err != nil {
+	if err := d.Set("region_name", privateEndpoint.GetRegionName()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "region_name", privateLinkID, err))
 	}
 
-	if err := d.Set("service_attachment_names", privateEndpoint.ServiceAttachmentNames); err != nil {
+	if err := d.Set("service_attachment_names", privateEndpoint.GetServiceAttachmentNames()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "service_attachment_names", privateLinkID, err))
 	}
 
 	d.SetId(conversion.EncodeStateID(map[string]string{
-		"private_link_id": privateEndpoint.ID,
+		"private_link_id": privateEndpoint.GetId(),
 		"project_id":      projectID,
 		"provider_name":   providerName,
 	}))

internal/service/privatelinkendpoint/data_source_privatelink_endpoint_test.go

@@ -21,9 +21,9 @@ func TestAccNetworkDSPrivateLinkEndpoint_basic(t *testing.T) {
 		ProtoV6ProviderFactories: acc.TestAccProviderV6Factories,
 		Steps: []resource.TestStep{
 			{
-				Config: testAccMongoDBAtlasPrivateLinkEndpointDataSourceConfig(projectID, providerName, region),
+				Config: configDS(projectID, providerName, region),
 				Check: resource.ComposeTestCheckFunc(
-					testAccCheckMongoDBAtlasPrivateLinkEndpointExists(resourceName),
+					checkExists(resourceName),
 					resource.TestCheckResourceAttrSet(resourceName, "project_id"),
 					resource.TestCheckResourceAttrSet(resourceName, "private_link_id"),
 				),
@@ -32,7 +32,7 @@ func TestAccNetworkDSPrivateLinkEndpoint_basic(t *testing.T) {
 	})
 }
 
-func testAccMongoDBAtlasPrivateLinkEndpointDataSourceConfig(projectID, providerName, region string) string {
+func configDS(projectID, providerName, region string) string {
 	return fmt.Sprintf(`
 		resource "mongodbatlas_privatelink_endpoint" "test" {
 			project_id    = "%s"

internal/service/privatelinkendpoint/resource_privatelink_endpoint.go

@@ -15,7 +15,7 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/config"
-	matlas "go.mongodb.org/atlas/mongodbatlas"
+	"go.mongodb.org/atlas-sdk/v20231115005/admin"
 )
 
 const (
@@ -27,11 +27,11 @@ const (
 
 func Resource() *schema.Resource {
 	return &schema.Resource{
-		CreateContext: resourceMongoDBAtlasPrivateLinkEndpointCreate,
-		ReadContext:   resourceMongoDBAtlasPrivateLinkEndpointRead,
-		DeleteContext: resourceMongoDBAtlasPrivateLinkEndpointDelete,
+		CreateContext: resourceCreate,
+		ReadContext:   resourceRead,
+		DeleteContext: resourceDelete,
 		Importer: &schema.ResourceImporter{
-			StateContext: resourceMongoDBAtlasPrivateLinkEndpointImportState,
+			StateContext: resourceImport,
 		},
 		Schema: map[string]*schema.Schema{
 			"project_id": {
@@ -114,26 +114,26 @@ func Resource() *schema.Resource {
 	}
 }
 
-func resourceMongoDBAtlasPrivateLinkEndpointCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	conn := meta.(*config.MongoDBClient).Atlas
+func resourceCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 	projectID := d.Get("project_id").(string)
 	providerName := d.Get("provider_name").(string)
 	region := d.Get("region").(string)
 
-	request := &matlas.PrivateEndpointConnection{
+	request := &admin.CloudProviderEndpointServiceRequest{
 		ProviderName: providerName,
 		Region:       region,
 	}
 
-	privateEndpointConn, _, err := conn.PrivateEndpoints.Create(ctx, projectID, request)
+	privateEndpoint, _, err := connV2.PrivateEndpointServicesApi.CreatePrivateEndpointService(ctx, projectID, request).Execute()
 	if err != nil {
 		return diag.FromErr(fmt.Errorf(errorPrivateLinkEndpointsCreate, err))
 	}
 
 	stateConf := &retry.StateChangeConf{
 		Pending:    []string{"INITIATING", "DELETING"},
 		Target:     []string{"WAITING_FOR_USER", "FAILED", "DELETED", "AVAILABLE"},
-		Refresh:    resourcePrivateLinkEndpointRefreshFunc(ctx, conn, projectID, providerName, privateEndpointConn.ID),
+		Refresh:    refreshFunc(ctx, connV2, projectID, providerName, privateEndpoint.GetId()),
 		Timeout:    d.Timeout(schema.TimeoutCreate),
 		MinTimeout: 5 * time.Second,
 		Delay:      3 * time.Second,
@@ -146,25 +146,25 @@ func resourceMongoDBAtlasPrivateLinkEndpointCreate(ctx context.Context, d *schem
 	}
 
 	d.SetId(conversion.EncodeStateID(map[string]string{
-		"private_link_id": privateEndpointConn.ID,
+		"private_link_id": privateEndpoint.GetId(),
 		"project_id":      projectID,
 		"provider_name":   providerName,
 		"region":          region,
 	}))
 
-	return resourceMongoDBAtlasPrivateLinkEndpointRead(ctx, d, meta)
+	return resourceRead(ctx, d, meta)
 }
 
-func resourceMongoDBAtlasPrivateLinkEndpointRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	conn := meta.(*config.MongoDBClient).Atlas
+func resourceRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 
 	ids := conversion.DecodeStateID(d.Id())
 	projectID := ids["project_id"]
 	privateLinkID := ids["private_link_id"]
 	providerName := ids["provider_name"]
 	region := ids["region"]
 
-	privateEndpoint, resp, err := conn.PrivateEndpoints.Get(context.Background(), projectID, providerName, privateLinkID)
+	privateEndpoint, resp, err := connV2.PrivateEndpointServicesApi.GetPrivateEndpointService(context.Background(), projectID, providerName, privateLinkID).Execute()
 	if err != nil {
 		if resp != nil && resp.StatusCode == http.StatusNotFound {
 			d.SetId("")
@@ -174,35 +174,35 @@ func resourceMongoDBAtlasPrivateLinkEndpointRead(ctx context.Context, d *schema.
 		return diag.FromErr(fmt.Errorf(errorPrivateLinkEndpointsRead, privateLinkID, err))
 	}
 
-	if err := d.Set("private_link_id", privateEndpoint.ID); err != nil {
+	if err := d.Set("private_link_id", privateEndpoint.GetId()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "private_link_id", privateLinkID, err))
 	}
 
-	if err := d.Set("endpoint_service_name", privateEndpoint.EndpointServiceName); err != nil {
+	if err := d.Set("endpoint_service_name", privateEndpoint.GetEndpointServiceName()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "endpoint_service_name", privateLinkID, err))
 	}
 
-	if err := d.Set("error_message", privateEndpoint.ErrorMessage); err != nil {
+	if err := d.Set("error_message", privateEndpoint.GetErrorMessage()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "error_message", privateLinkID, err))
 	}
 
-	if err := d.Set("interface_endpoints", privateEndpoint.InterfaceEndpoints); err != nil {
+	if err := d.Set("interface_endpoints", privateEndpoint.GetInterfaceEndpoints()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "interface_endpoints", privateLinkID, err))
 	}
 
-	if err := d.Set("private_endpoints", privateEndpoint.PrivateEndpoints); err != nil {
+	if err := d.Set("private_endpoints", privateEndpoint.GetPrivateEndpoints()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "interface_endpoints", privateLinkID, err))
 	}
 
-	if err := d.Set("private_link_service_name", privateEndpoint.PrivateLinkServiceName); err != nil {
+	if err := d.Set("private_link_service_name", privateEndpoint.GetPrivateLinkServiceName()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "interface_endpoints", privateLinkID, err))
 	}
 
-	if err := d.Set("private_link_service_resource_id", privateEndpoint.PrivateLinkServiceResourceID); err != nil {
+	if err := d.Set("private_link_service_resource_id", privateEndpoint.GetPrivateLinkServiceResourceId()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "interface_endpoints", privateLinkID, err))
 	}
 
-	if err := d.Set("status", privateEndpoint.Status); err != nil {
+	if err := d.Set("status", privateEndpoint.GetStatus()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "status", privateLinkID, err))
 	}
 
@@ -214,32 +214,32 @@ func resourceMongoDBAtlasPrivateLinkEndpointRead(ctx context.Context, d *schema.
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "region", privateLinkID, err))
 	}
 
-	if err := d.Set("endpoint_group_names", privateEndpoint.EndpointGroupNames); err != nil {
+	if err := d.Set("endpoint_group_names", privateEndpoint.GetEndpointGroupNames()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "endpoint_group_names", privateLinkID, err))
 	}
 
-	if err := d.Set("region_name", privateEndpoint.RegionName); err != nil {
+	if err := d.Set("region_name", privateEndpoint.GetRegionName()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "region_name", privateLinkID, err))
 	}
 
-	if err := d.Set("service_attachment_names", privateEndpoint.ServiceAttachmentNames); err != nil {
+	if err := d.Set("service_attachment_names", privateEndpoint.GetServiceAttachmentNames()); err != nil {
 		return diag.FromErr(fmt.Errorf(ErrorPrivateLinkEndpointsSetting, "service_attachment_names", privateLinkID, err))
 	}
 
 	return nil
 }
 
-func resourceMongoDBAtlasPrivateLinkEndpointDelete(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	conn := meta.(*config.MongoDBClient).Atlas
+func resourceDelete(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 
 	ids := conversion.DecodeStateID(d.Id())
 	privateLinkID := ids["private_link_id"]
 	projectID := ids["project_id"]
 	providerName := ids["provider_name"]
 
-	resp, err := conn.PrivateEndpoints.Delete(ctx, projectID, providerName, privateLinkID)
+	_, resp, err := connV2.PrivateEndpointServicesApi.DeletePrivateEndpointService(ctx, projectID, providerName, privateLinkID).Execute()
 	if err != nil {
-		if resp.Response.StatusCode == 404 {
+		if resp.StatusCode == 404 {
 			return nil
 		}
 
@@ -251,7 +251,7 @@ func resourceMongoDBAtlasPrivateLinkEndpointDelete(ctx context.Context, d *schem
 	stateConf := &retry.StateChangeConf{
 		Pending:    []string{"DELETING"},
 		Target:     []string{"DELETED", "FAILED"},
-		Refresh:    resourcePrivateLinkEndpointRefreshFunc(ctx, conn, projectID, providerName, privateLinkID),
+		Refresh:    refreshFunc(ctx, connV2, projectID, providerName, privateLinkID),
 		Timeout:    d.Timeout(schema.TimeoutDelete),
 		MinTimeout: 5 * time.Second,
 		Delay:      3 * time.Second,
@@ -265,7 +265,7 @@ func resourceMongoDBAtlasPrivateLinkEndpointDelete(ctx context.Context, d *schem
 	return nil
 }
 
-func resourceMongoDBAtlasPrivateLinkEndpointImportState(ctx context.Context, d *schema.ResourceData, meta any) ([]*schema.ResourceData, error) {
+func resourceImport(ctx context.Context, d *schema.ResourceData, meta any) ([]*schema.ResourceData, error) {
 	conn := meta.(*config.MongoDBClient).Atlas
 
 	parts := strings.Split(d.Id(), "-")
@@ -304,21 +304,26 @@ func resourceMongoDBAtlasPrivateLinkEndpointImportState(ctx context.Context, d *
 	return []*schema.ResourceData{d}, nil
 }
 
-func resourcePrivateLinkEndpointRefreshFunc(ctx context.Context, client *matlas.Client, projectID, providerName, privateLinkID string) retry.StateRefreshFunc {
+func refreshFunc(ctx context.Context, client *admin.APIClient, projectID, providerName, privateLinkID string) retry.StateRefreshFunc {
 	return func() (any, string, error) {
-		p, resp, err := client.PrivateEndpoints.Get(ctx, projectID, providerName, privateLinkID)
+		p, resp, err := client.PrivateEndpointServicesApi.GetPrivateEndpointService(ctx, projectID, providerName, privateLinkID).Execute()
 		if err != nil {
-			if resp.Response.StatusCode == 404 {
+			if resp.StatusCode == 404 {
 				return "", "DELETED", nil
 			}
 
 			return nil, "REJECTED", err
 		}
 
-		if p.Status != "WAITING_FOR_USER" {
-			return "", p.Status, nil
+		status := ""
+		if _, ok := p.GetStatusOk(); ok {
+			status = p.GetStatus()
+		}
+
+		if status != "WAITING_FOR_USER" {
+			return "", status, nil
 		}
 
-		return p, p.Status, nil
+		return p, status, nil
 	}
 }