chore: Adds support for multiple API versions for adv_cluster TPF

internal/common/update/patch_payload.go

@@ -2,6 +2,7 @@ package update
 
 import (
 	"encoding/json"
+	"reflect"
 	"regexp"
 	"slices"
 	"strings"
@@ -11,12 +12,28 @@ import (
 )
 
 type attrPatchOperations struct {
-	data map[string][]jsondiff.Operation
+	data          map[string][]jsondiff.Operation
+	ignoreInState []string
 }
 
-func newAttrPatchOperations(patch jsondiff.Patch) *attrPatchOperations {
+func (m *attrPatchOperations) ignoreInStatePath(path string) bool {
+	for _, ignore := range m.ignoreInState {
+		suffix := "/" + ignore
+		if strings.HasSuffix(path, suffix) {
+			return true
+		}
+	}
+	return false
+}
+
+func newAttrPatchOperations(patch jsondiff.Patch, options []PatchOptions) *attrPatchOperations {
+	ignoreInState := []string{}
+	for _, option := range options {
+		ignoreInState = append(ignoreInState, option.IgnoreInState...)
+	}
 	self := &attrPatchOperations{
-		data: map[string][]jsondiff.Operation{},
+		data:          map[string][]jsondiff.Operation{},
+		ignoreInState: ignoreInState,
 	}
 	for _, op := range patch {
 		if op.Path == "" {
@@ -79,10 +96,14 @@ func (m *attrPatchOperations) StatePatch(attr string) jsondiff.Patch {
 			lastValue = op.Value
 		}
 		if op.Type == jsondiff.OperationRemove && !indexRemoval(op.Path) {
+			path := op.Path
+			if m.ignoreInStatePath(path) {
+				continue
+			}
 			patch = append(patch, jsondiff.Operation{
 				Type:  jsondiff.OperationAdd,
 				Value: lastValue,
-				Path:  op.Path,
+				Path:  path,
 			})
 		}
 	}
@@ -113,6 +134,11 @@ func convertJSONDiffToJSONPatch(patch jsondiff.Patch) (jsonpatch.Patch, error) {
 	return decodedPatch, nil
 }
 
+// Current limitation if the field is set as part of a nested attribute in a map
+type PatchOptions struct {
+	IgnoreInState []string
+}
+
 // PatchPayload uses the state and plan to changes to find the patch request, including changes only when:
 // - The plan has replaced, added, or removed list values from the state
 // Note that we intentionally do NOT include removed state values:
@@ -129,15 +155,19 @@ func convertJSONDiffToJSONPatch(patch jsondiff.Patch) (jsonpatch.Patch, error) {
 // 4. Adds nested "removed" values from the state to the request
 // 5. Use `jsonpatch` to apply each attribute plan & state patch to an empty JSON object
 // 6. Create a `patchReq` pointer with the final JSON object marshaled to `T` or return nil if there are no changes (`{}`)
-func PatchPayload[T any](state, plan *T) (*T, error) {
+func PatchPayload[T any](state, plan *T, options ...PatchOptions) (*T, error) {
+	return PatchPayloadDiffTypes(state, plan, options...)
+}
+
+func PatchPayloadDiffTypes[T any, U any](state *T, plan *U, options ...PatchOptions) (*U, error) {
 	if plan == nil {
 		return nil, nil
 	}
 	statePlanPatch, err := jsondiff.Compare(state, plan, jsondiff.Invertible())
 	if err != nil {
 		return nil, err
 	}
-	attrOperations := newAttrPatchOperations(statePlanPatch)
+	attrOperations := newAttrPatchOperations(statePlanPatch, options)
 	reqJSON := []byte(`{}`)
 
 	addPatchToRequest := func(patchDiff jsondiff.Patch) error {
@@ -155,7 +185,7 @@ func PatchPayload[T any](state, plan *T) (*T, error) {
 		return nil
 	}
 
-	patchReq := new(T)
+	patchReq := new(U)
 	patchFromPlanDiff, err := jsondiff.Compare(patchReq, plan)
 	if err != nil {
 		return nil, err
@@ -177,3 +207,11 @@ func PatchPayload[T any](state, plan *T) (*T, error) {
 	}
 	return patchReq, json.Unmarshal(reqJSON, patchReq)
 }
+
+func IsEmpty[T any](last *T) bool {
+	if last == nil {
+		return true
+	}
+	empty := new(T)
+	return reflect.DeepEqual(last, empty)
+}

internal/common/update/patch_payload_test.go

@@ -66,6 +66,7 @@ func TestPatchReplicationSpecs(t *testing.T) {
 			state         *admin.ClusterDescription20240805
 			plan          *admin.ClusterDescription20240805
 			patchExpected *admin.ClusterDescription20240805
+			options       []update.PatchOptions
 		}{
 			"ComputedValues from the state are added to plan and unchanged attributes are not included": {
 				state: &state,
@@ -187,14 +188,33 @@ func TestPatchReplicationSpecs(t *testing.T) {
 				plan:          &planNoChanges,
 				patchExpected: nil,
 			},
+			"Empty array should return no changes": {
+				state: &admin.ClusterDescription20240805{
+					Labels: &[]admin.ComponentLabel{},
+				},
+				plan: &admin.ClusterDescription20240805{
+					Labels: &[]admin.ComponentLabel{},
+				},
+				patchExpected: nil,
+			},
+			"diskSizeGb ignored in state": {
+				state:         clusterDescriptionDiskSizeNodeCount(50.0, 3, conversion.Pointer(50.0), 0),
+				plan:          clusterDescriptionDiskSizeNodeCount(55.0, 3, nil, 0),
+				patchExpected: clusterDescriptionDiskSizeNodeCount(55.0, 3, nil, 0),
+				options: []update.PatchOptions{
+					{
+						IgnoreInState: []string{"diskSizeGB"},
+					},
+				},
+			},
 		}
 	)
 	for name, tc := range testCases {
 		t.Run(name, func(t *testing.T) {
 			if name == "Removed list entry should be included" {
 				t.Log("This test case is expected to fail due to the current implementation")
 			}
-			patchReq, err := update.PatchPayload(tc.state, tc.plan)
+			patchReq, err := update.PatchPayload(tc.state, tc.plan, tc.options...)
 			require.NoError(t, err)
 			assert.Equal(t, tc.patchExpected, patchReq)
 		})
@@ -210,6 +230,7 @@ func TestPatchAdvancedConfig(t *testing.T) {
 			state         *admin.ClusterDescriptionProcessArgs20240805
 			plan          *admin.ClusterDescriptionProcessArgs20240805
 			patchExpected *admin.ClusterDescriptionProcessArgs20240805
+			options       []update.PatchOptions
 		}{
 			"JavascriptEnabled is set to false": {
 				state: &state,
@@ -248,9 +269,37 @@ func TestPatchAdvancedConfig(t *testing.T) {
 	)
 	for name, tc := range testCases {
 		t.Run(name, func(t *testing.T) {
-			patchReq, err := update.PatchPayload(tc.state, tc.plan)
+			patchReq, err := update.PatchPayload(tc.state, tc.plan, tc.options...)
 			require.NoError(t, err)
 			assert.Equal(t, tc.patchExpected, patchReq)
 		})
 	}
 }
+
+func TestIsEmpty(t *testing.T) {
+	assert.True(t, update.IsEmpty(&admin.ClusterDescription20240805{}))
+	var myVar admin.ClusterDescription20240805
+	assert.True(t, update.IsEmpty(&myVar))
+	assert.False(t, update.IsEmpty(&admin.ClusterDescription20240805{Name: conversion.Pointer("my-cluster")}))
+}
+
+func clusterDescriptionDiskSizeNodeCount(diskSizeGBElectable float64, nodeCountElectable int, diskSizeGBReadOnly *float64, nodeCountReadOnly int) *admin.ClusterDescription20240805 {
+	return &admin.ClusterDescription20240805{
+		ReplicationSpecs: &[]admin.ReplicationSpec20240805{
+			{
+				RegionConfigs: &[]admin.CloudRegionConfig20240805{
+					{
+						ElectableSpecs: &admin.HardwareSpec20240805{
+							NodeCount:  &nodeCountElectable,
+							DiskSizeGB: &diskSizeGBElectable,
+						},
+						ReadOnlySpecs: &admin.DedicatedHardwareSpec20240805{
+							NodeCount:  &nodeCountReadOnly,
+							DiskSizeGB: diskSizeGBReadOnly,
+						},
+					},
+				},
+			},
+		},
+	}
+}

internal/service/advancedclustertpf/model_ClusterDescription20240805.go

@@ -2,19 +2,34 @@ package advancedclustertpf
 
 import (
 	"context"
+	"fmt"
+	"slices"
+	"strings"
 
 	"github.com/hashicorp/terraform-plugin-framework-timeouts/resource/timeouts"
 	"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/v20240805005/admin"
+	"go.mongodb.org/atlas-sdk/v20241113001/admin"
 )
 
-func NewTFModel(ctx context.Context, input *admin.ClusterDescription20240805, timeout timeouts.Value, diags *diag.Diagnostics) *TFModel {
+const (
+	errorZoneNameNotSet          = "zoneName is required for legacy schema"
+	errorNumShardsNotSet         = "numShards not set for zoneName %s"
+	errorReplicationSpecIDNotSet = "replicationSpecID not set for zoneName %s"
+)
+
+type LegacySchemaInfo struct {
+	ZoneNameNumShards          map[string]int64
+	ZoneNameReplicationSpecIDs map[string]string
+	RootDiskSize               *float64
+}
+
+func NewTFModel(ctx context.Context, input *admin.ClusterDescription20240805, timeout timeouts.Value, diags *diag.Diagnostics, legacyInfo *LegacySchemaInfo) *TFModel {
 	biConnector := NewBiConnectorConfigObjType(ctx, input.BiConnector, diags)
 	connectionStrings := NewConnectionStringsObjType(ctx, input.ConnectionStrings, diags)
 	labels := NewLabelsObjType(ctx, input.Labels, diags)
-	replicationSpecs := NewReplicationSpecsObjType(ctx, input.ReplicationSpecs, diags)
+	replicationSpecs := NewReplicationSpecsObjType(ctx, input.ReplicationSpecs, diags, legacyInfo)
 	tags := NewTagsObjType(ctx, input.Tags, diags)
 	if diags.HasError() {
 		return nil
@@ -28,6 +43,7 @@ func NewTFModel(ctx context.Context, input *admin.ClusterDescription20240805, ti
 		ConfigServerType:                 types.StringPointerValue(input.ConfigServerType),
 		ConnectionStrings:                connectionStrings,
 		CreateDate:                       types.StringPointerValue(conversion.TimePtrToStringPtr(input.CreateDate)),
+		DiskSizeGB:                       types.Float64PointerValue(findRegionRootDiskSize(input.ReplicationSpecs)),
 		EncryptionAtRestProvider:         types.StringPointerValue(input.EncryptionAtRestProvider),
 		GlobalClusterSelfManagedSharding: types.BoolPointerValue(input.GlobalClusterSelfManagedSharding),
 		ProjectID:                        types.StringPointerValue(input.GroupId),
@@ -96,26 +112,84 @@ func NewLabelsObjType(ctx context.Context, input *[]admin.ComponentLabel, diags
 	return setType
 }
 
-func NewReplicationSpecsObjType(ctx context.Context, input *[]admin.ReplicationSpec20240805, diags *diag.Diagnostics) types.List {
+func NewReplicationSpecsObjType(ctx context.Context, input *[]admin.ReplicationSpec20240805, diags *diag.Diagnostics, legacyInfo *LegacySchemaInfo) types.List {
 	if input == nil {
 		return types.ListNull(ReplicationSpecsObjType)
 	}
+	var tfModels *[]TFReplicationSpecsModel
+	if legacyInfo == nil {
+		tfModels = convertReplicationSpecs(ctx, input, diags)
+	} else {
+		tfModels = convertReplicationSpecsLegacy(ctx, input, diags, legacyInfo)
+	}
+	if diags.HasError() {
+		return types.ListNull(ReplicationSpecsObjType)
+	}
+	listType, diagsLocal := types.ListValueFrom(ctx, ReplicationSpecsObjType, *tfModels)
+	diags.Append(diagsLocal...)
+	return listType
+}
+
+func convertReplicationSpecs(ctx context.Context, input *[]admin.ReplicationSpec20240805, diags *diag.Diagnostics) *[]TFReplicationSpecsModel {
 	tfModels := make([]TFReplicationSpecsModel, len(*input))
 	for i, item := range *input {
 		regionConfigs := NewRegionConfigsObjType(ctx, item.RegionConfigs, diags)
 		tfModels[i] = TFReplicationSpecsModel{
 			Id:            types.StringPointerValue(item.Id),
-			ExternalId:    types.StringNull(),                          // TODO: Static
+			ExternalId:    types.StringPointerValue(item.Id),
 			NumShards:     types.Int64Value(1),                         // TODO: Static
 			ContainerId:   conversion.ToTFMapOfString(ctx, diags, nil), // TODO: Static
 			RegionConfigs: regionConfigs,
 			ZoneId:        types.StringPointerValue(item.ZoneId),
 			ZoneName:      types.StringPointerValue(item.ZoneName),
 		}
 	}
-	listType, diagsLocal := types.ListValueFrom(ctx, ReplicationSpecsObjType, tfModels)
-	diags.Append(diagsLocal...)
-	return listType
+	return &tfModels
+}
+
+func convertReplicationSpecsLegacy(ctx context.Context, input *[]admin.ReplicationSpec20240805, diags *diag.Diagnostics, legacyInfo *LegacySchemaInfo) *[]TFReplicationSpecsModel {
+	tfModels := []TFReplicationSpecsModel{}
+	tfModelsSkipIndexes := []int{}
+	for i, item := range *input {
+		if slices.Contains(tfModelsSkipIndexes, i) {
+			continue
+		}
+		regionConfigs := NewRegionConfigsObjType(ctx, item.RegionConfigs, diags)
+		zoneName := item.GetZoneName()
+		if zoneName == "" {
+			diags.AddError(errorZoneNameNotSet, errorZoneNameNotSet)
+			return &tfModels
+		}
+		numShards, ok := legacyInfo.ZoneNameNumShards[zoneName]
+		errMsg := []string{}
+		if !ok {
+			errMsg = append(errMsg, fmt.Sprintf(errorNumShardsNotSet, zoneName))
+		}
+		legacyID, ok := legacyInfo.ZoneNameReplicationSpecIDs[zoneName]
+		if !ok {
+			errMsg = append(errMsg, fmt.Sprintf(errorReplicationSpecIDNotSet, zoneName))
+		}
+		if len(errMsg) > 0 {
+			errMsgStr := strings.Join(errMsg, ", ")
+			diags.AddError(errMsgStr, errMsgStr)
+			return &tfModels
+		}
+		if numShards > 1 {
+			for j := 1; j < int(numShards); j++ {
+				tfModelsSkipIndexes = append(tfModelsSkipIndexes, i+j)
+			}
+		}
+		tfModels = append(tfModels, TFReplicationSpecsModel{
+			ContainerId:   conversion.ToTFMapOfString(ctx, diags, nil), // TODO: Static
+			ExternalId:    types.StringPointerValue(item.Id),
+			Id:            types.StringValue(legacyID),
+			RegionConfigs: regionConfigs,
+			NumShards:     types.Int64Value(numShards),
+			ZoneId:        types.StringPointerValue(item.ZoneId),
+			ZoneName:      types.StringPointerValue(item.ZoneName),
+		})
+	}
+	return &tfModels
 }
 
 func NewTagsObjType(ctx context.Context, input *[]admin.ResourceTag, diags *diag.Diagnostics) types.Set {

internal/service/advancedclustertpf/model_ClusterDescriptionProcessArgs20240805.go

@@ -7,7 +7,7 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/types"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion"
 	admin20240530 "go.mongodb.org/atlas-sdk/v20240530005/admin"
-	"go.mongodb.org/atlas-sdk/v20240805005/admin"
+	"go.mongodb.org/atlas-sdk/v20241113001/admin"
 )
 
 func AddAdvancedConfig(ctx context.Context, tfModel *TFModel, input *admin.ClusterDescriptionProcessArgs20240805, inputLegacy *admin20240530.ClusterDescriptionProcessArgs, diags *diag.Diagnostics) {