feat: Adds new mongodbatlas_cloud_user_team_assignment resource

.changelog/3502.txt

@@ -0,0 +1,3 @@
+```release-note:new-resource
+resource/mongodbatlas_cloud_user_team_assignment 
+```

.github/workflows/acceptance-tests-runner.yml

@@ -302,6 +302,7 @@ jobs:
             - 'internal/service/controlplaneipaddresses/*.go'
           cloud_user:
             - 'internal/service/clouduserorgassignment/*.go'
+            - 'internal/service/clouduserteamassignment/*.go'
           cluster:
             - 'internal/service/cluster/*.go'
           cluster_outage_simulation:
@@ -592,7 +593,7 @@ jobs:
           MONGODB_ATLAS_LAST_VERSION: ${{ needs.get-provider-version.outputs.provider_version }}
           ACCTEST_PACKAGES: ./internal/service/controlplaneipaddresses
         run: make testacc
-
+        
   cloud_user:
     needs: [ change-detection, get-provider-version ]
     if: ${{ needs.change-detection.outputs.cloud_user == 'true' || inputs.test_group == 'cloud_user' }}
@@ -613,9 +614,13 @@ jobs:
         env:
           MONGODB_ATLAS_LAST_VERSION: ${{ needs.get-provider-version.outputs.provider_version }}
           MONGODB_ATLAS_TEAMS_IDS: ${{ inputs.mongodb_atlas_teams_ids }}
-          ACCTEST_PACKAGES: ./internal/service/clouduserorgassignment
+          MONGODB_ATLAS_PROJECT_OWNER_ID: ${{ inputs.mongodb_atlas_project_owner_id }}
+          MONGODB_ATLAS_ORG_ID: ${{ inputs.mongodb_atlas_org_id }}
+          ACCTEST_PACKAGES: |
+            ./internal/service/clouduserorgassignment
+            ./internal/service/clouduserteamassignment
         run: make testacc
-      
+
   cluster:
     needs: [ change-detection, get-provider-version ]
     if: ${{ needs.change-detection.outputs.cluster == 'true' || inputs.test_group == 'cluster' }}

internal/provider/provider.go

@@ -30,6 +30,7 @@ import (
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/apikeyprojectassignment"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/atlasuser"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/clouduserorgassignment"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/clouduserteamassignment"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/controlplaneipaddresses"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/databaseuser"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/encryptionatrest"
@@ -487,6 +488,7 @@ func (p *MongodbtlasProvider) Resources(context.Context) []func() resource.Resou
 		resourcepolicy.Resource,
 		clouduserorgassignment.Resource,
 		apikeyprojectassignment.Resource,
+		clouduserteamassignment.Resource,
 	}
 	if config.PreviewProviderV2AdvancedCluster() {
 		resources = append(resources, advancedclustertpf.Resource)

internal/service/clouduserteamassignment/main_test.go

@@ -0,0 +1,15 @@
+package clouduserteamassignment_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/testutil/acc"
+)
+
+func TestMain(m *testing.M) {
+	cleanup := acc.SetupSharedResources()
+	exitCode := m.Run()
+	cleanup()
+	os.Exit(exitCode)
+}

internal/service/clouduserteamassignment/model.go

@@ -0,0 +1,109 @@
+package clouduserteamassignment
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion"
+	"go.mongodb.org/atlas-sdk/v20250312005/admin"
+)
+
+func NewTFUserTeamAssignmentModel(ctx context.Context, apiResp *admin.OrgUserResponse) (*TFUserTeamAssignmentModel, diag.Diagnostics) {
+	diags := diag.Diagnostics{}
+	var rolesObj types.Object
+	var rolesDiags diag.Diagnostics
+
+	if apiResp == nil {
+		return nil, diags
+	}
+
+	rolesObj, rolesDiags = NewTFRolesModel(ctx, &apiResp.Roles)
+	diags.Append(rolesDiags...)
+
+	userTeamAssignment := TFUserTeamAssignmentModel{
+		UserId:              types.StringValue(apiResp.GetId()),
+		Username:            types.StringValue(apiResp.GetUsername()),
+		OrgMembershipStatus: types.StringValue(apiResp.GetOrgMembershipStatus()),
+		Roles:               rolesObj,
+		InvitationCreatedAt: types.StringPointerValue(conversion.TimePtrToStringPtr(apiResp.InvitationCreatedAt)),
+		InvitationExpiresAt: types.StringPointerValue(conversion.TimePtrToStringPtr(apiResp.InvitationExpiresAt)),
+		InviterUsername:     types.StringPointerValue(apiResp.InviterUsername),
+		Country:             types.StringPointerValue(apiResp.Country),
+		FirstName:           types.StringPointerValue(apiResp.FirstName),
+		LastName:            types.StringPointerValue(apiResp.LastName),
+		CreatedAt:           types.StringPointerValue(conversion.TimePtrToStringPtr(apiResp.CreatedAt)),
+		LastAuth:            types.StringPointerValue(conversion.TimePtrToStringPtr(apiResp.LastAuth)),
+		MobileNumber:        types.StringPointerValue(apiResp.MobileNumber),
+	}
+
+	userTeamAssignment.TeamIDs = types.SetNull(types.StringType)
+	if apiResp.TeamIds != nil {
+		userTeamAssignment.TeamIDs, diags = types.SetValueFrom(ctx, types.StringType, apiResp.TeamIds)
+		if diags.HasError() {
+			return nil, diags
+		}
+	}
+
+	return &userTeamAssignment, nil
+}
+
+func NewTFRolesModel(ctx context.Context, roles *admin.OrgUserRolesResponse) (types.Object, diag.Diagnostics) {
+	diags := diag.Diagnostics{}
+
+	if roles == nil {
+		return types.ObjectNull(RolesObjectAttrTypes), diags
+	}
+
+	var orgRoles types.Set
+	if roles.OrgRoles == nil || len(*roles.OrgRoles) == 0 {
+		orgRoles = types.SetNull(types.StringType)
+	} else {
+		orgRoles, _ = types.SetValueFrom(ctx, types.StringType, *roles.OrgRoles)
+	}
+
+	projectRoleAssignmentsSet := NewTFProjectRoleAssignments(ctx, roles.GroupRoleAssignments)
+
+	rolesObj, _ := types.ObjectValue(
+		RolesObjectAttrTypes,
+		map[string]attr.Value{
+			"project_role_assignments": projectRoleAssignmentsSet,
+			"org_roles":                orgRoles,
+		},
+	)
+
+	return rolesObj, diags
+}
+
+func NewTFProjectRoleAssignments(ctx context.Context, groupRoleAssignments *[]admin.GroupRoleAssignment) types.Set {
+	if groupRoleAssignments == nil {
+		return types.SetNull(ProjectRoleAssignmentsAttrType)
+	}
+
+	var projectRoleAssignments []TFProjectRoleAssignmentsModel
+
+	for _, pra := range *groupRoleAssignments {
+		projectID := types.StringPointerValue(pra.GroupId)
+		var projectRoles types.Set
+		if pra.GroupRoles == nil || len(*pra.GroupRoles) == 0 {
+			projectRoles = types.SetNull(types.StringType)
+		} else {
+			projectRoles, _ = types.SetValueFrom(ctx, types.StringType, pra.GroupRoles)
+		}
+		projectRoleAssignments = append(projectRoleAssignments, TFProjectRoleAssignmentsModel{
+			ProjectId:    projectID,
+			ProjectRoles: projectRoles,
+		})
+	}
+
+	praSet, _ := types.SetValueFrom(ctx, ProjectRoleAssignmentsAttrType.ElemType.(types.ObjectType), projectRoleAssignments)
+	return praSet
+}
+
+func NewUserTeamAssignmentReq(ctx context.Context, plan *TFUserTeamAssignmentModel) (*admin.AddOrRemoveUserFromTeam, diag.Diagnostics) {
+	addOrRemoveUserFromTeam := admin.AddOrRemoveUserFromTeam{
+		Id: plan.UserId.ValueString(),
+	}
+	return &addOrRemoveUserFromTeam, nil
+}

internal/service/clouduserteamassignment/model_test.go

@@ -0,0 +1,186 @@
+package clouduserteamassignment_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/clouduserteamassignment"
+	"github.com/stretchr/testify/assert"
+	"go.mongodb.org/atlas-sdk/v20250312005/admin"
+)
+
+const (
+	testUserID              = "user-123"
+	testUsername            = "jdoe"
+	testFirstName           = "John"
+	testLastName            = "Doe"
+	testCountry             = "CA"
+	testMobile              = "+1555123456"
+	testInviter             = "admin"
+	testOrgMembershipStatus = "ACTIVE"
+	testInviterUsername     = ""
+
+	testOrgRoleOwner      = "ORG_OWNER"
+	testOrgRoleMember     = "ORG_MEMBER"
+	testProjectRoleOwner  = "PROJECT_OWNER"
+	testProjectRoleRead   = "PROJECT_READ_ONLY"
+	testProjectRoleMember = "PROJECT_MEMBER"
+
+	testTeamID1    = "team1"
+	testTeamID2    = "team2"
+	testProjectID1 = "project-123"
+	testOrgID      = "org-123"
+)
+
+var (
+	when                    = time.Date(2020, 1, 2, 3, 4, 5, 0, time.UTC)
+	testCreatedAt           = when.Format(time.RFC3339)
+	testInvitationCreatedAt = when.Add(-24 * time.Hour).Format(time.RFC3339)
+	testInvitationExpiresAt = when.Add(24 * time.Hour).Format(time.RFC3339)
+	testLastAuth            = when.Add(-2 * time.Hour).Format(time.RFC3339)
+
+	testTeamIDs  = []string{"team1", "team2"}
+	testOrgRoles = []string{"owner", "readWrite"}
+)
+
+type sdkToTFModelTestCase struct {
+	SDKResp         *admin.OrgUserResponse
+	expectedTFModel *clouduserteamassignment.TFUserTeamAssignmentModel
+}
+
+func TestUserTeamAssignmentSDKToTFModel(t *testing.T) {
+	ctx := t.Context()
+
+	fullResp := &admin.OrgUserResponse{
+		Id:                  testUserID,
+		Username:            testUsername,
+		FirstName:           admin.PtrString(testFirstName),
+		LastName:            admin.PtrString(testLastName),
+		Country:             admin.PtrString(testCountry),
+		MobileNumber:        admin.PtrString(testMobile),
+		OrgMembershipStatus: testOrgMembershipStatus,
+		CreatedAt:           admin.PtrTime(when),
+		LastAuth:            admin.PtrTime(when.Add(-2 * time.Hour)),
+		InvitationCreatedAt: admin.PtrTime(when.Add(-24 * time.Hour)),
+		InvitationExpiresAt: admin.PtrTime(when.Add(24 * time.Hour)),
+		InviterUsername:     admin.PtrString(testInviterUsername),
+		TeamIds:             &testTeamIDs,
+		Roles: admin.OrgUserRolesResponse{
+			OrgRoles: &testOrgRoles,
+		},
+	}
+
+	orgRolesSet, _ := types.SetValueFrom(ctx, types.StringType, testOrgRoles)
+	expectedRoles, _ := types.ObjectValue(clouduserteamassignment.RolesObjectAttrTypes, map[string]attr.Value{
+		"org_roles":                orgRolesSet,
+		"project_role_assignments": types.ListNull(clouduserteamassignment.ProjectRoleAssignmentsAttrType),
+	})
+	expectedTeams, _ := types.SetValueFrom(ctx, types.StringType, testTeamIDs)
+	expectedFullModel := &clouduserteamassignment.TFUserTeamAssignmentModel{
+		UserId:              types.StringValue(testUserID),
+		Username:            types.StringValue(testUsername),
+		FirstName:           types.StringValue(testFirstName),
+		LastName:            types.StringValue(testLastName),
+		Country:             types.StringValue(testCountry),
+		MobileNumber:        types.StringValue(testMobile),
+		OrgMembershipStatus: types.StringValue(testOrgMembershipStatus),
+		CreatedAt:           types.StringValue(testCreatedAt),
+		LastAuth:            types.StringValue(testLastAuth),
+		InvitationCreatedAt: types.StringValue(testInvitationCreatedAt),
+		InvitationExpiresAt: types.StringValue(testInvitationExpiresAt),
+		InviterUsername:     types.StringValue(testInviterUsername),
+		OrgId:               types.StringNull(),
+		TeamId:              types.StringNull(),
+		Roles:               expectedRoles,
+		TeamIDs:             expectedTeams,
+	}
+
+	testCases := map[string]sdkToTFModelTestCase{
+		"nil SDK response": {
+			SDKResp:         nil,
+			expectedTFModel: nil,
+		},
+		"Complete SDK response": {
+			SDKResp:         fullResp,
+			expectedTFModel: expectedFullModel,
+		},
+	}
+
+	for testName, tc := range testCases {
+		t.Run(testName, func(t *testing.T) {
+			resultModel, diags := clouduserteamassignment.NewTFUserTeamAssignmentModel(t.Context(), tc.SDKResp)
+			assert.False(t, diags.HasError(), "expected no diagnostics")
+			assert.Equal(t, tc.expectedTFModel, resultModel, "created terraform model did not match expected output")
+		})
+	}
+}
+
+func createRolesObject(ctx context.Context, orgRoles []string, projectAssignments []clouduserteamassignment.TFProjectRoleAssignmentsModel) types.Object {
+	orgRolesSet, _ := types.SetValueFrom(ctx, types.StringType, orgRoles)
+
+	var projectRoleAssignmentsList types.List
+	if len(projectAssignments) == 0 {
+		projectRoleAssignmentsList = types.ListNull(clouduserteamassignment.ProjectRoleAssignmentsAttrType.ElemType.(types.ObjectType))
+	} else {
+		projectRoleAssignmentsList, _ = types.ListValueFrom(ctx, clouduserteamassignment.ProjectRoleAssignmentsAttrType.ElemType.(types.ObjectType), projectAssignments)
+	}
+
+	obj, _ := types.ObjectValue(
+		clouduserteamassignment.RolesObjectAttrTypes,
+		map[string]attr.Value{
+			"org_roles":                orgRolesSet,
+			"project_role_assignments": projectRoleAssignmentsList,
+		},
+	)
+	return obj
+}
+
+func TestNewUserTeamAssignmentReq(t *testing.T) {
+	ctx := t.Context()
+	projectAssignment := clouduserteamassignment.TFProjectRoleAssignmentsModel{
+		ProjectId:    types.StringValue(testProjectID1),
+		ProjectRoles: types.SetValueMust(types.StringType, []attr.Value{types.StringValue(testProjectRoleOwner)}),
+	}
+	teams, _ := types.SetValueFrom(ctx, types.StringType, testTeamIDs)
+	testCases := map[string]struct {
+		plan     *clouduserteamassignment.TFUserTeamAssignmentModel
+		expected *admin.AddOrRemoveUserFromTeam
+	}{
+		"Complete model": {
+			plan: &clouduserteamassignment.TFUserTeamAssignmentModel{
+				OrgId:               types.StringValue(testOrgID),
+				TeamId:              types.StringValue(testTeamID1),
+				UserId:              types.StringValue(testUserID),
+				Username:            types.StringValue(testUsername),
+				OrgMembershipStatus: types.StringValue(testOrgMembershipStatus),
+				Roles: createRolesObject(ctx, testOrgRoles, []clouduserteamassignment.TFProjectRoleAssignmentsModel{
+					projectAssignment,
+				}),
+				TeamIDs:             teams,
+				InvitationCreatedAt: types.StringValue(testInvitationCreatedAt),
+				InvitationExpiresAt: types.StringValue(testInvitationExpiresAt),
+				InviterUsername:     types.StringValue(testInviterUsername),
+				Country:             types.StringValue(testCountry),
+				FirstName:           types.StringValue(testFirstName),
+				LastName:            types.StringValue(testLastName),
+				CreatedAt:           types.StringValue(testCreatedAt),
+				LastAuth:            types.StringValue(testLastAuth),
+				MobileNumber:        types.StringValue(testMobile),
+			},
+			expected: &admin.AddOrRemoveUserFromTeam{
+				Id: testUserID,
+			},
+		},
+	}
+
+	for name, tc := range testCases {
+		t.Run(name, func(t *testing.T) {
+			req, diags := clouduserteamassignment.NewUserTeamAssignmentReq(ctx, tc.plan)
+			assert.False(t, diags.HasError(), "expected no diagnostics")
+			assert.Equal(t, tc.expected, req)
+		})
+	}
+}