feat: Add new resource: mongodbatlas_team_project_assignment (#3539)

* WIP - Added resource

* Model tests

* Resource tests

* Migration test

* Added error messages

* Changelog

* Added err

* Added a note

* Added a note

* Added tests to github actions

* Fixes

* Enhanced test

* Updated SDK

* Revert "Updated SDK"

This reverts commit f8d2d0a.

* feat: Add new singular data source: `mongodbatlas_team_project_assignment` (#3544)

* Added datasource schema and Read()

* Datasource tests

* Added changelog

* Fix

* Comments

---------

Co-authored-by: Cristina Sánchez Sánchez <[email protected]>

---------

Co-authored-by: Cristina Sánchez Sánchez <[email protected]>

Author: csanx

.changelog/3539.txt

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

.changelog/3544.txt

@@ -0,0 +1,3 @@
+```release-note:new-datasource
+data-source/mongodbatlas_team_project_assignment 
+```

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

@@ -323,6 +323,7 @@ jobs:
             - 'internal/service/projectapikey/*.go'
             - 'internal/service/rolesorgid/*.go'
             - 'internal/service/team/*.go'
+            - 'internal/service/teamprojectassignment/*.go'
             - 'internal/service/thirdpartyintegration/*.go'
           encryption:
             - 'internal/service/encryptionatrest/*.go' 
@@ -711,6 +712,7 @@ jobs:
             ./internal/service/apikey
             ./internal/service/rolesorgid
             ./internal/service/team
+            ./internal/service/teamprojectassignment
             ./internal/service/thirdpartyintegration
         run: make testacc
 

internal/provider/provider.go

@@ -50,6 +50,7 @@ import (
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/streaminstance"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/streamprivatelinkendpoint"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/streamprocessor"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/teamprojectassignment"
 	"github.com/mongodb/terraform-provider-mongodbatlas/version"
 )
 
@@ -463,6 +464,7 @@ func (p *MongodbtlasProvider) DataSources(context.Context) []func() datasource.D
 		resourcepolicy.PluralDataSource,
 		clouduserorgassignment.DataSource,
 		clouduserteamassignment.DataSource,
+		teamprojectassignment.DataSource,
 		apikeyprojectassignment.DataSource,
 		apikeyprojectassignment.PluralDataSource,
 	}
@@ -491,6 +493,7 @@ func (p *MongodbtlasProvider) Resources(context.Context) []func() resource.Resou
 		resourcepolicy.Resource,
 		clouduserorgassignment.Resource,
 		apikeyprojectassignment.Resource,
+		teamprojectassignment.Resource,
 		clouduserteamassignment.Resource,
 	}
 	if config.PreviewProviderV2AdvancedCluster() {

internal/service/teamprojectassignment/data_source.go

@@ -0,0 +1,57 @@
+package teamprojectassignment
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/validate"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/config"
+)
+
+var _ datasource.DataSource = &teamProjectAssignmentDS{}
+var _ datasource.DataSourceWithConfigure = &teamProjectAssignmentDS{}
+
+func DataSource() datasource.DataSource {
+	return &teamProjectAssignmentDS{
+		DSCommon: config.DSCommon{
+			DataSourceName: resourceName,
+		},
+	}
+}
+
+type teamProjectAssignmentDS struct {
+	config.DSCommon
+}
+
+func (d *teamProjectAssignmentDS) Schema(ctx context.Context, req datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = dataSourceSchema()
+}
+
+func (d *teamProjectAssignmentDS) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var state TFModel
+	resp.Diagnostics.Append(req.Config.Get(ctx, &state)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	connV2 := d.Client.AtlasV2
+	projectID := state.ProjectId.ValueString()
+	teamID := state.TeamId.ValueString()
+
+	apiResp, httpResp, err := connV2.TeamsApi.GetProjectTeam(ctx, projectID, teamID).Execute()
+	if err != nil {
+		if validate.StatusNotFound(httpResp) {
+			resp.State.RemoveResource(ctx)
+			return
+		}
+		resp.Diagnostics.AddError(errorFetchingResource, err.Error())
+		return
+	}
+
+	newTeamProjectAssignmentModel, diags := NewTFModel(ctx, apiResp, projectID)
+	if diags.HasError() {
+		resp.Diagnostics.Append(diags...)
+		return
+	}
+	resp.Diagnostics.Append(resp.State.Set(ctx, newTeamProjectAssignmentModel)...)
+}

internal/service/teamprojectassignment/main_test.go

@@ -0,0 +1,15 @@
+package teamprojectassignment_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/teamprojectassignment/model.go

@@ -0,0 +1,47 @@
+package teamprojectassignment
+
+import (
+	"context"
+
+	"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/v20250312006/admin"
+)
+
+func NewTFModel(ctx context.Context, apiResp *admin.TeamRole, projectID string) (*TFModel, diag.Diagnostics) {
+	diags := diag.Diagnostics{}
+
+	if apiResp == nil {
+		return nil, diags
+	}
+
+	roleNames := conversion.TFSetValueOrNull(ctx, apiResp.RoleNames, types.StringType)
+
+	return &TFModel{
+		ProjectId: types.StringValue(projectID),
+		TeamId:    types.StringPointerValue(apiResp.TeamId),
+		RoleNames: roleNames,
+	}, diags
+}
+
+func buildTeamRole(ctx context.Context, plan *TFModel) *admin.TeamRole {
+	roleNames := []string{}
+	if !plan.RoleNames.IsNull() && !plan.RoleNames.IsUnknown() {
+		roleNames = conversion.TypesSetToString(ctx, plan.RoleNames)
+	}
+
+	return &admin.TeamRole{
+		TeamId:    plan.TeamId.ValueStringPointer(),
+		RoleNames: &roleNames,
+	}
+}
+
+func NewAtlasReq(ctx context.Context, plan *TFModel) (*[]admin.TeamRole, diag.Diagnostics) {
+	teamRole := buildTeamRole(ctx, plan)
+	return &[]admin.TeamRole{*teamRole}, nil
+}
+
+func NewAtlasUpdateReq(ctx context.Context, plan *TFModel) (*admin.TeamRole, diag.Diagnostics) {
+	return buildTeamRole(ctx, plan), nil
+}

internal/service/teamprojectassignment/model_test.go

@@ -0,0 +1,181 @@
+package teamprojectassignment_test
+
+import (
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/service/teamprojectassignment"
+	"github.com/stretchr/testify/assert"
+	"go.mongodb.org/atlas-sdk/v20250312006/admin"
+)
+
+const (
+	testProjectID = "project-123"
+	testTeamID    = "team-123"
+)
+
+var (
+	testProjectRoles = []string{"PROJECT_OWNER", "PROJECT_READ_ONLY", "PROJECT_MEMBER"}
+)
+
+type sdkToTFModelTestCase struct {
+	SDKResp         *admin.TeamRole
+	expectedTFModel *teamprojectassignment.TFModel
+}
+
+func TestTeamProjectAssignmentSDKToTFModel(t *testing.T) {
+	ctx := t.Context()
+
+	fullResp := &admin.TeamRole{
+		TeamId:    admin.PtrString(testTeamID),
+		RoleNames: &testProjectRoles,
+	}
+
+	expectedRoles, _ := types.SetValueFrom(ctx, types.StringType, testProjectRoles)
+	expectedFullModel := &teamprojectassignment.TFModel{
+		ProjectId: types.StringValue(testProjectID),
+		TeamId:    types.StringValue(testTeamID),
+		RoleNames: expectedRoles,
+	}
+
+	fullNilResp := &admin.TeamRole{
+		TeamId:    admin.PtrString(""),
+		RoleNames: nil,
+	}
+
+	expectedNilModel := &teamprojectassignment.TFModel{
+		ProjectId: types.StringValue(testProjectID),
+		TeamId:    types.StringValue(""),
+		RoleNames: types.SetNull(types.StringType),
+	}
+
+	testCases := map[string]sdkToTFModelTestCase{
+		"Complete SDK response": {
+			SDKResp:         fullResp,
+			expectedTFModel: expectedFullModel,
+		},
+		"nil SDK response": {
+			SDKResp:         nil,
+			expectedTFModel: nil,
+		},
+		"Empty SDK response": {
+			SDKResp:         fullNilResp,
+			expectedTFModel: expectedNilModel,
+		},
+	}
+
+	for testName, tc := range testCases {
+		t.Run(testName, func(t *testing.T) {
+			resultModel, diags := teamprojectassignment.NewTFModel(t.Context(), tc.SDKResp, testProjectID)
+			assert.False(t, diags.HasError(), "expected no diagnostics")
+			assert.Equal(t, tc.expectedTFModel, resultModel, "TFModel did not match expected")
+		})
+	}
+}
+
+func TestNewAtlasReq(t *testing.T) {
+	ctx := t.Context()
+
+	roles, _ := types.SetValueFrom(ctx, types.StringType, testProjectRoles)
+	testCases := map[string]struct {
+		plan     *teamprojectassignment.TFModel
+		expected *[]admin.TeamRole
+	}{
+		"Complete TF state": {
+			plan: &teamprojectassignment.TFModel{
+				ProjectId: types.StringValue(testProjectID),
+				TeamId:    types.StringValue(testTeamID),
+				RoleNames: roles,
+			},
+			expected: &[]admin.TeamRole{
+				{
+					TeamId:    admin.PtrString(testTeamID),
+					RoleNames: &testProjectRoles,
+				},
+			},
+		},
+		"No roles": {
+			plan: &teamprojectassignment.TFModel{
+				ProjectId: types.StringValue(testProjectID),
+				TeamId:    types.StringValue(testTeamID),
+				RoleNames: types.SetNull(types.StringType),
+			},
+			expected: &[]admin.TeamRole{
+				{
+					TeamId:    admin.PtrString(testTeamID),
+					RoleNames: &[]string{},
+				},
+			},
+		},
+	}
+
+	for testName, tc := range testCases {
+		t.Run(testName, func(t *testing.T) {
+			apiReqResult, diags := teamprojectassignment.NewAtlasReq(ctx, tc.plan)
+			assert.False(t, diags.HasError(), "expected no diagnostics")
+
+			assert.Len(t, *apiReqResult, len(*tc.expected), "slice lengths don't match")
+
+			for i := range *tc.expected {
+				expectedItem := (*tc.expected)[i]
+				actualItem := (*apiReqResult)[i]
+
+				assert.Equal(t, *expectedItem.TeamId, *actualItem.TeamId, "TeamId values don't match")
+
+				if expectedItem.RoleNames == nil {
+					assert.Nil(t, actualItem.RoleNames, "expected RoleNames to be nil")
+				} else {
+					assert.Equal(t, *expectedItem.RoleNames, *actualItem.RoleNames, "RoleNames values don't match")
+				}
+			}
+		})
+	}
+}
+
+func TestNewAtlasUpdateReq(t *testing.T) {
+	ctx := t.Context()
+
+	roles, _ := types.SetValueFrom(ctx, types.StringType, testProjectRoles)
+
+	testCases := map[string]struct {
+		plan     *teamprojectassignment.TFModel
+		expected *admin.TeamRole
+	}{
+		"Complete TF state": {
+			plan: &teamprojectassignment.TFModel{
+				ProjectId: types.StringValue(testProjectID),
+				TeamId:    types.StringValue(testTeamID),
+				RoleNames: roles,
+			},
+			expected: &admin.TeamRole{
+				TeamId:    admin.PtrString(testTeamID),
+				RoleNames: &testProjectRoles,
+			},
+		},
+		"No roles": {
+			plan: &teamprojectassignment.TFModel{
+				ProjectId: types.StringValue(testProjectID),
+				TeamId:    types.StringValue(testTeamID),
+				RoleNames: types.SetNull(types.StringType),
+			},
+			expected: &admin.TeamRole{
+				TeamId:    admin.PtrString(testTeamID),
+				RoleNames: &[]string{},
+			},
+		},
+	}
+	for testName, tc := range testCases {
+		t.Run(testName, func(t *testing.T) {
+			apiReqResult, diags := teamprojectassignment.NewAtlasUpdateReq(ctx, tc.plan)
+			assert.False(t, diags.HasError(), "expected no diagnostics")
+
+			assert.Equal(t, *tc.expected.TeamId, *apiReqResult.TeamId, "TeamId values don't match")
+
+			if tc.expected.RoleNames == nil {
+				assert.Nil(t, apiReqResult.RoleNames, "expected RoleNames to be nil")
+			} else {
+				assert.Equal(t, *tc.expected.RoleNames, *apiReqResult.RoleNames, "RoleNames values don't match")
+			}
+		})
+	}
+}