chore: Upgrades org_invitation resource to auto-generated SDK (#1897)

* rename

* remove unneeded checkAttributeUsername and checkAttributeRole

* new sdk in tests

* migration test

* data source

* read & delete

* import

* create

* update

* validateOrgInvitationAlreadyAccepted

Author: lantoli

internal/service/orginvitation/data_source_org_invitation.go

@@ -12,7 +12,7 @@ import (
 
 func DataSource() *schema.Resource {
 	return &schema.Resource{
-		ReadContext: dataSourceMongoDBAtlasOrgInvitationRead,
+		ReadContext: dataSourceRead,
 		Schema: map[string]*schema.Schema{
 			"org_id": {
 				Type:     schema.TypeString,
@@ -56,47 +56,46 @@ func DataSource() *schema.Resource {
 	}
 }
 
-func dataSourceMongoDBAtlasOrgInvitationRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	// Get client connection.
-	conn := meta.(*config.MongoDBClient).Atlas
+func dataSourceRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 	orgID := d.Get("org_id").(string)
 	username := d.Get("username").(string)
 	invitationID := d.Get("invitation_id").(string)
 
-	orgInvitation, _, err := conn.Organizations.Invitation(ctx, orgID, invitationID)
+	orgInvitation, _, err := connV2.OrganizationsApi.GetOrganizationInvitation(ctx, orgID, invitationID).Execute()
 	if err != nil {
 		return diag.FromErr(fmt.Errorf("error getting Organization Invitation information: %w", err))
 	}
 
-	if err := d.Set("username", orgInvitation.Username); err != nil {
+	if err := d.Set("username", orgInvitation.GetUsername()); err != nil {
 		return diag.FromErr(fmt.Errorf("error getting `username` for Organization Invitation (%s): %w", d.Id(), err))
 	}
 
-	if err := d.Set("org_id", orgInvitation.OrgID); err != nil {
+	if err := d.Set("org_id", orgInvitation.GetOrgId()); err != nil {
 		return diag.FromErr(fmt.Errorf("error getting `username` for Organization Invitation (%s): %w", d.Id(), err))
 	}
 
-	if err := d.Set("invitation_id", orgInvitation.ID); err != nil {
+	if err := d.Set("invitation_id", orgInvitation.GetId()); err != nil {
 		return diag.FromErr(fmt.Errorf("error getting `invitation_id` for Organization Invitation (%s): %w", d.Id(), err))
 	}
 
-	if err := d.Set("expires_at", orgInvitation.ExpiresAt); err != nil {
+	if err := d.Set("expires_at", conversion.TimePtrToStringPtr(orgInvitation.ExpiresAt)); err != nil {
 		return diag.FromErr(fmt.Errorf("error getting `expires_at` for Organization Invitation (%s): %w", d.Id(), err))
 	}
 
-	if err := d.Set("created_at", orgInvitation.CreatedAt); err != nil {
+	if err := d.Set("created_at", conversion.TimePtrToStringPtr(orgInvitation.CreatedAt)); err != nil {
 		return diag.FromErr(fmt.Errorf("error getting `created_at` for Organization Invitation (%s): %w", d.Id(), err))
 	}
 
-	if err := d.Set("inviter_username", orgInvitation.InviterUsername); err != nil {
+	if err := d.Set("inviter_username", orgInvitation.GetInviterUsername()); err != nil {
 		return diag.FromErr(fmt.Errorf("error getting `inviter_username` for Organization Invitation (%s): %w", d.Id(), err))
 	}
 
-	if err := d.Set("teams_ids", orgInvitation.TeamIDs); err != nil {
+	if err := d.Set("teams_ids", orgInvitation.GetTeamIds()); err != nil {
 		return diag.FromErr(fmt.Errorf("error getting `teams_ids` for Organization Invitation (%s): %w", d.Id(), err))
 	}
 
-	if err := d.Set("roles", orgInvitation.Roles); err != nil {
+	if err := d.Set("roles", orgInvitation.GetRoles()); err != nil {
 		return diag.FromErr(fmt.Errorf("error getting `roles` for Organization Invitation (%s): %w", d.Id(), err))
 	}
 

internal/service/orginvitation/data_source_org_invitation_test.go

@@ -25,20 +25,20 @@ func TestAccConfigDSOrgInvitation_basic(t *testing.T) {
 		CheckDestroy:             acc.CheckDestroyOrgInvitation,
 		Steps: []resource.TestStep{
 			{
-				Config: testAccDataSourceMongoDBAtlasOrgInvitationConfig(orgID, name, initialRole),
+				Config: configDS(orgID, name, initialRole),
 				Check: resource.ComposeTestCheckFunc(
-					resource.TestCheckResourceAttrSet(dataSourceName, "org_id"),
-					resource.TestCheckResourceAttrSet(dataSourceName, "username"),
 					resource.TestCheckResourceAttrSet(dataSourceName, "invitation_id"),
+					resource.TestCheckResourceAttr(dataSourceName, "org_id", orgID),
 					resource.TestCheckResourceAttr(dataSourceName, "username", name),
 					resource.TestCheckResourceAttr(dataSourceName, "roles.#", "1"),
+					resource.TestCheckTypeSetElemAttr(dataSourceName, "roles.*", initialRole[0]),
 				),
 			},
 		},
 	})
 }
 
-func testAccDataSourceMongoDBAtlasOrgInvitationConfig(orgID, username string, roles []string) string {
+func configDS(orgID, username string, roles []string) string {
 	return fmt.Sprintf(`
 		resource "mongodbatlas_org_invitation" "test" {
 			org_id   = %[1]q

internal/service/orginvitation/resource_org_invitation.go

@@ -10,22 +10,23 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"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"
 )
 
 func Resource() *schema.Resource {
 	return &schema.Resource{
-		CreateContext: resourceMongoDBAtlasOrgInvitationCreate,
-		ReadContext:   resourceMongoDBAtlasOrgInvitationRead,
-		DeleteContext: resourceMongoDBAtlasOrgInvitationDelete,
-		UpdateContext: resourceMongoDBAtlasOrgInvitationUpdate,
+		CreateContext: resourceCreate,
+		ReadContext:   resourceRead,
+		DeleteContext: resourceDelete,
+		UpdateContext: resourceUpdate,
 		Importer: &schema.ResourceImporter{
-			StateContext: resourceMongoDBAtlasOrgInvitationImportState,
+			StateContext: resourceImport,
 		},
 		Schema: map[string]*schema.Schema{
 			"org_id": {
 				Type:     schema.TypeString,
 				Required: true,
+				ForceNew: true,
 			},
 			"username": {
 				Type:     schema.TypeString,
@@ -68,23 +69,50 @@ func Resource() *schema.Resource {
 	}
 }
 
-func resourceMongoDBAtlasOrgInvitationRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	// Get client connection.
-	conn := meta.(*config.MongoDBClient).Atlas
+func resourceCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
+	orgID := d.Get("org_id").(string)
+	roles := conversion.ExpandStringListFromSetSchema(d.Get("roles").(*schema.Set))
+	teamIDs := conversion.ExpandStringListFromSetSchema(d.Get("teams_ids").(*schema.Set))
+	invitationReq := &admin.OrganizationInvitationRequest{
+		Roles:    &roles,
+		TeamIds:  &teamIDs,
+		Username: conversion.StringPtr(d.Get("username").(string)),
+	}
+
+	if validateOrgInvitationAlreadyAccepted(ctx, connV2, invitationReq.GetUsername(), orgID) {
+		d.SetId(conversion.EncodeStateID(map[string]string{
+			"username":      invitationReq.GetUsername(),
+			"org_id":        orgID,
+			"invitation_id": orgID,
+		}))
+	} else {
+		invitationRes, _, err := connV2.OrganizationsApi.CreateOrganizationInvitation(ctx, orgID, invitationReq).Execute()
+		if err != nil {
+			return diag.Errorf("error creating Organization invitation for user %s: %s", d.Get("username").(string), err)
+		}
+
+		d.SetId(conversion.EncodeStateID(map[string]string{
+			"username":      invitationRes.GetUsername(),
+			"org_id":        invitationRes.GetOrgId(),
+			"invitation_id": invitationRes.GetId(),
+		}))
+	}
+	return resourceRead(ctx, d, meta)
+}
+
+func resourceRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 	ids := conversion.DecodeStateID(d.Id())
 	orgID := ids["org_id"]
 	username := ids["username"]
 	invitationID := ids["invitation_id"]
 
 	if orgID != invitationID {
-		orgInvitation, _, err := conn.Organizations.Invitation(ctx, orgID, invitationID)
+		orgInvitation, _, err := connV2.OrganizationsApi.GetOrganizationInvitation(ctx, orgID, invitationID).Execute()
 		if err != nil {
-			// case 404
-			// deleted in the backend case
-
-			if strings.Contains(err.Error(), "404") {
-				accepted, _ := validateOrgInvitationAlreadyAccepted(ctx, meta.(*config.MongoDBClient), username, orgID)
-				if accepted {
+			if strings.Contains(err.Error(), "404") { // case 404: deleted in the backend case
+				if validateOrgInvitationAlreadyAccepted(ctx, connV2, username, orgID) {
 					d.SetId("")
 					return nil
 				}
@@ -94,35 +122,35 @@ func resourceMongoDBAtlasOrgInvitationRead(ctx context.Context, d *schema.Resour
 			return diag.Errorf("error getting Organization Invitation information: %s", err)
 		}
 
-		if err := d.Set("username", orgInvitation.Username); err != nil {
+		if err := d.Set("username", orgInvitation.GetUsername()); err != nil {
 			return diag.Errorf("error getting `username` for Organization Invitation (%s): %s", d.Id(), err)
 		}
 
-		if err := d.Set("org_id", orgInvitation.OrgID); err != nil {
+		if err := d.Set("org_id", orgInvitation.GetOrgId()); err != nil {
 			return diag.Errorf("error getting `username` for Organization Invitation (%s): %s", d.Id(), err)
 		}
 
-		if err := d.Set("invitation_id", orgInvitation.ID); err != nil {
+		if err := d.Set("invitation_id", orgInvitation.GetId()); err != nil {
 			return diag.Errorf("error getting `invitation_id` for Organization Invitation (%s): %s", d.Id(), err)
 		}
 
-		if err := d.Set("expires_at", orgInvitation.ExpiresAt); err != nil {
+		if err := d.Set("expires_at", conversion.TimePtrToStringPtr(orgInvitation.ExpiresAt)); err != nil {
 			return diag.Errorf("error getting `expires_at` for Organization Invitation (%s): %s", d.Id(), err)
 		}
 
-		if err := d.Set("created_at", orgInvitation.CreatedAt); err != nil {
+		if err := d.Set("created_at", conversion.TimePtrToStringPtr(orgInvitation.CreatedAt)); err != nil {
 			return diag.Errorf("error getting `created_at` for Organization Invitation (%s): %s", d.Id(), err)
 		}
 
-		if err := d.Set("inviter_username", orgInvitation.InviterUsername); err != nil {
+		if err := d.Set("inviter_username", orgInvitation.GetInviterUsername()); err != nil {
 			return diag.Errorf("error getting `inviter_username` for Organization Invitation (%s): %s", d.Id(), err)
 		}
 
-		if err := d.Set("teams_ids", orgInvitation.TeamIDs); err != nil {
+		if err := d.Set("teams_ids", orgInvitation.GetTeamIds()); err != nil {
 			return diag.Errorf("error getting `teams_ids` for Organization Invitation (%s): %s", d.Id(), err)
 		}
 
-		if err := d.Set("roles", orgInvitation.Roles); err != nil {
+		if err := d.Set("roles", orgInvitation.GetRoles()); err != nil {
 			return diag.Errorf("error getting `roles` for Organization Invitation (%s): %s", d.Id(), err)
 		}
 	}
@@ -135,117 +163,78 @@ func resourceMongoDBAtlasOrgInvitationRead(ctx context.Context, d *schema.Resour
 	return nil
 }
 
-func resourceMongoDBAtlasOrgInvitationCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	// Get client connection.
-	conn := meta.(*config.MongoDBClient).Atlas
-	orgID := d.Get("org_id").(string)
-
-	invitationReq := &matlas.Invitation{
-		Roles:    conversion.ExpandStringListFromSetSchema(d.Get("roles").(*schema.Set)),
-		TeamIDs:  conversion.ExpandStringListFromSetSchema(d.Get("teams_ids").(*schema.Set)),
-		Username: d.Get("username").(string),
-	}
-
-	accepted, _ := validateOrgInvitationAlreadyAccepted(ctx, meta.(*config.MongoDBClient), invitationReq.Username, orgID)
-	if accepted {
-		d.SetId(conversion.EncodeStateID(map[string]string{
-			"username":      invitationReq.Username,
-			"org_id":        orgID,
-			"invitation_id": orgID,
-		}))
-	} else {
-		invitationRes, _, err := conn.Organizations.InviteUser(ctx, orgID, invitationReq)
-		if err != nil {
-			return diag.Errorf("error creating Organization invitation for user %s: %s", d.Get("username").(string), err)
-		}
-
-		d.SetId(conversion.EncodeStateID(map[string]string{
-			"username":      invitationRes.Username,
-			"org_id":        invitationRes.OrgID,
-			"invitation_id": invitationRes.ID,
-		}))
-	}
-	return resourceMongoDBAtlasOrgInvitationRead(ctx, d, meta)
-}
-
-func resourceMongoDBAtlasOrgInvitationDelete(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())
 	orgID := ids["org_id"]
 	username := ids["username"]
 	invitationID := ids["invitation_id"]
 
-	_, _, err := conn.Organizations.Invitation(ctx, orgID, invitationID)
+	_, _, err := connV2.OrganizationsApi.GetOrganizationInvitation(ctx, orgID, invitationID).Execute()
 	if err != nil {
-		// case 404
-		// deleted in the backend case
-
-		if strings.Contains(err.Error(), "404") {
-			accepted, _ := validateOrgInvitationAlreadyAccepted(ctx, meta.(*config.MongoDBClient), username, orgID)
-			if accepted {
+		if strings.Contains(err.Error(), "404") { // case 404: deleted in the backend case
+			if validateOrgInvitationAlreadyAccepted(ctx, connV2, username, orgID) {
 				d.SetId("")
 				return nil
 			}
 			return nil
 		}
 	}
-	_, err = conn.Organizations.DeleteInvitation(ctx, orgID, invitationID)
+	_, _, err = connV2.OrganizationsApi.DeleteOrganizationInvitation(ctx, orgID, invitationID).Execute()
 	if err != nil {
 		return diag.Errorf("error deleting Organization invitation for user %s: %s", username, err)
 	}
 	d.SetId("")
 	return nil
 }
 
-func resourceMongoDBAtlasOrgInvitationUpdate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	conn := meta.(*config.MongoDBClient).Atlas
+func resourceUpdate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 	ids := conversion.DecodeStateID(d.Id())
 	orgID := ids["org_id"]
 	username := ids["username"]
 	invitationID := ids["invitation_id"]
-
-	invitationReq := &matlas.Invitation{
-		Roles: conversion.ExpandStringListFromSetSchema(d.Get("roles").(*schema.Set)),
+	roles := conversion.ExpandStringListFromSetSchema(d.Get("roles").(*schema.Set))
+	invitationReq := &admin.OrganizationInvitationUpdateRequest{
+		Roles: &roles,
 	}
-
-	_, _, err := conn.Organizations.UpdateInvitationByID(ctx, orgID, invitationID, invitationReq)
+	_, _, err := connV2.OrganizationsApi.UpdateOrganizationInvitationById(ctx, orgID, invitationID, invitationReq).Execute()
 	if err != nil {
 		return diag.Errorf("error updating Organization invitation for user %s: for %s", username, err)
 	}
-
-	return resourceMongoDBAtlasOrgInvitationRead(ctx, d, meta)
+	return resourceRead(ctx, d, meta)
 }
 
-func resourceMongoDBAtlasOrgInvitationImportState(ctx context.Context, d *schema.ResourceData, meta any) ([]*schema.ResourceData, error) {
-	conn := meta.(*config.MongoDBClient).Atlas
+func resourceImport(ctx context.Context, d *schema.ResourceData, meta any) ([]*schema.ResourceData, error) {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 	orgID, username, err := splitOrgInvitationImportID(d.Id())
 	if err != nil {
 		return nil, err
 	}
 
-	orgInvitations, _, err := conn.Organizations.Invitations(ctx, orgID, nil)
+	orgInvitations, _, err := connV2.OrganizationsApi.ListOrganizationInvitations(ctx, orgID).Execute()
 	if err != nil {
 		return nil, fmt.Errorf("couldn't import Organization invitations, error: %s", err)
 	}
 
 	for _, orgInvitation := range orgInvitations {
-		if orgInvitation.Username != username {
+		if conversion.SafeString(orgInvitation.Username) != username {
 			continue
 		}
 
-		if err := d.Set("username", orgInvitation.Username); err != nil {
+		if err := d.Set("username", orgInvitation.GetUsername()); err != nil {
 			return nil, fmt.Errorf("error getting `username` for Organization Invitation (%s): %s", username, err)
 		}
-		if err := d.Set("org_id", orgInvitation.GroupID); err != nil {
+		if err := d.Set("org_id", orgInvitation.GetOrgId()); err != nil {
 			return nil, fmt.Errorf("error getting `org_id` for Organization Invitation (%s): %s", username, err)
 		}
-		if err := d.Set("invitation_id", orgInvitation.ID); err != nil {
+		if err := d.Set("invitation_id", orgInvitation.GetId()); err != nil {
 			return nil, fmt.Errorf("error getting `invitation_id` for Organization Invitation (%s): %s", username, err)
 		}
 		d.SetId(conversion.EncodeStateID(map[string]string{
 			"username":      username,
 			"org_id":        orgID,
-			"invitation_id": orgInvitation.ID,
+			"invitation_id": orgInvitation.GetId(),
 		}))
 		return []*schema.ResourceData{d}, nil
 	}
@@ -268,17 +257,15 @@ func splitOrgInvitationImportID(id string) (orgID, username string, err error) {
 	return
 }
 
-func validateOrgInvitationAlreadyAccepted(ctx context.Context, conn *config.MongoDBClient, username, orgID string) (bool, error) {
-	user, _, err := conn.Atlas.AtlasUsers.GetByName(ctx, username)
+func validateOrgInvitationAlreadyAccepted(ctx context.Context, connV2 *admin.APIClient, username, orgID string) bool {
+	user, _, err := connV2.MongoDBCloudUsersApi.GetUserByUsername(ctx, username).Execute()
 	if err != nil {
-		return false, err
+		return false
 	}
-
-	for _, role := range user.Roles {
-		if role.OrgID == orgID {
-			return true, nil
+	for _, role := range user.GetRoles() {
+		if role.GetOrgId() == orgID {
+			return true
 		}
 	}
-
-	return false, nil
+	return false
 }