Bugfix inconsistent applies of ListAttributes (#328)

* sort the list of ACLs for MongoDBFlex

* Fix and test other cases of ListAttribute ordering

* fix linting

* revert sorting changes, introduce new reconcilestrlist function

* merge main

* Fix rabbitmq

* fix segmentation fault

* Improve testing

* pass context to mapfields, minor name fixes

stackit/internal/utils/utils.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+
+	"github.com/hashicorp/terraform-plugin-framework/types"
+)
+
+// ReconcileStringSlices reconciles two string lists by removing elements from the
+// first list that are not in the second list and appending elements from the
+// second list that are not in the first list.
+// This preserves the order of the elements in the first list that are also in
+// the second list, which is useful when using ListAttributes in Terraform.
+// The source of truth for the order is the first list and the source of truth for the content is the second list.
+func ReconcileStringSlices(list1, list2 []string) []string {
+	// Create a copy of list1 to avoid modifying the original list
+	list1Copy := append([]string{}, list1...)
+
+	// Create a map to quickly check if an element is in list2
+	inList2 := make(map[string]bool)
+	for _, elem := range list2 {
+		inList2[elem] = true
+	}
+
+	// Remove elements from list1Copy that are not in list2
+	i := 0
+	for _, elem := range list1Copy {
+		if inList2[elem] {
+			list1Copy[i] = elem
+			i++
+		}
+	}
+	list1Copy = list1Copy[:i]
+
+	// Append elements to list1Copy that are in list2 but not in list1Copy
+	inList1 := make(map[string]bool)
+	for _, elem := range list1Copy {
+		inList1[elem] = true
+	}
+	for _, elem := range list2 {
+		if !inList1[elem] {
+			list1Copy = append(list1Copy, elem)
+		}
+	}
+
+	return list1Copy
+}
+
+func ListValuetoStringSlice(list basetypes.ListValue) ([]string, error) {
+	result := []string{}
+	for _, el := range list.Elements() {
+		elStr, ok := el.(types.String)
+		if !ok {
+			return result, fmt.Errorf("expected record to be of type %T, got %T", types.String{}, elStr)
+		}
+		result = append(result, elStr.ValueString())
+	}
+
+	return result, nil
+}

stackit/internal/utils/utils_test.go

@@ -0,0 +1,122 @@
+package utils
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+)
+
+func TestReconcileStrLists(t *testing.T) {
+	tests := []struct {
+		description string
+		list1       []string
+		list2       []string
+		expected    []string
+	}{
+		{
+			"empty lists",
+			[]string{},
+			[]string{},
+			[]string{},
+		},
+		{
+			"list1 empty",
+			[]string{},
+			[]string{"a", "b", "c"},
+			[]string{"a", "b", "c"},
+		},
+		{
+			"list2 empty",
+			[]string{"a", "b", "c"},
+			[]string{},
+			[]string{},
+		},
+		{
+			"no common elements",
+			[]string{"a", "b", "c"},
+			[]string{"d", "e", "f"},
+			[]string{"d", "e", "f"},
+		},
+		{
+			"common elements",
+			[]string{"d", "a", "c"},
+			[]string{"b", "c", "d", "e"},
+			[]string{"d", "c", "b", "e"},
+		},
+		{
+			"common elements with empty string",
+			[]string{"d", "", "c"},
+			[]string{"", "c", "d"},
+			[]string{"d", "", "c"},
+		},
+		{
+			"common elements with duplicates",
+			[]string{"a", "b", "c", "c"},
+			[]string{"b", "c", "d", "e"},
+			[]string{"b", "c", "c", "d", "e"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.description, func(t *testing.T) {
+			output := ReconcileStringSlices(tt.list1, tt.list2)
+			diff := cmp.Diff(output, tt.expected)
+			if diff != "" {
+				t.Fatalf("Data does not match: %s", diff)
+			}
+		})
+	}
+}
+
+func TestListValuetoStrSlice(t *testing.T) {
+	tests := []struct {
+		description string
+		input       basetypes.ListValue
+		expected    []string
+		isValid     bool
+	}{
+		{
+			description: "empty list",
+			input:       types.ListValueMust(types.StringType, []attr.Value{}),
+			expected:    []string{},
+			isValid:     true,
+		},
+		{
+			description: "values ok",
+			input: types.ListValueMust(types.StringType, []attr.Value{
+				types.StringValue("a"),
+				types.StringValue("b"),
+				types.StringValue("c"),
+			}),
+			expected: []string{"a", "b", "c"},
+			isValid:  true,
+		},
+		{
+			description: "different type",
+			input: types.ListValueMust(types.Int64Type, []attr.Value{
+				types.Int64Value(12),
+			}),
+			isValid: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.description, func(t *testing.T) {
+			output, err := ListValuetoStringSlice(tt.input)
+			if err != nil {
+				if !tt.isValid {
+					return
+				}
+				t.Fatalf("Should not have failed: %v", err)
+			}
+			if !tt.isValid {
+				t.Fatalf("Should have failed")
+			}
+			diff := cmp.Diff(output, tt.expected)
+			if diff != "" {
+				t.Fatalf("Data does not match: %s", diff)
+			}
+		})
+	}
+}