Convert 'MapKeyLenBetween' to use diag.Diagnostics.

Author: ewbankkit

helper/validation/map.go

@@ -4,28 +4,28 @@ import (
 	"fmt"
 	"regexp"
 
+	"github.com/hashicorp/go-cty/cty"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
 // MapKeyLenBetween returns a SchemaValidateFunc which tests if the provided value
 // is of type map and the length of all keys are between min and max (inclusive)
-func MapKeyLenBetween(min, max int) schema.SchemaValidateFunc {
-	return func(i interface{}, k string) (warnings []string, errors []error) {
-		v, ok := i.(map[string]interface{})
-		if !ok {
-			errors = append(errors, fmt.Errorf("expected type of %[1]q to be Map, got %[1]T", k))
-			return warnings, errors
-		}
-
-		for key := range v {
+func MapKeyLenBetween(min, max int) schema.SchemaValidateDiagFunc {
+	return func(v interface{}, path cty.Path) diag.Diagnostics {
+		for key := range v.(map[string]interface{}) {
 			len := len(key)
 			if len < min || len > max {
-				errors = append(errors, fmt.Errorf("expected the length of all keys of %q to be in the range (%d - %d), got %q (length = %d)", k, min, max, key, len))
-				return warnings, errors
+				return diag.Diagnostics{{
+					Severity:      diag.Error,
+					Summary:       fmt.Sprintf("expected the length of all keys to be in the range (%d - %d)", min, max),
+					Detail:        fmt.Sprintf("length = %d", len),
+					AttributePath: append(path, cty.IndexStep{Key: cty.StringVal(key)}),
+				}}
 			}
 		}
 
-		return warnings, errors
+		return nil
 	}
 }
 

helper/validation/map_test.go

@@ -3,50 +3,65 @@ package validation
 import (
 	"regexp"
 	"testing"
+
+	"github.com/hashicorp/go-cty/cty"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 )
 
 func TestValidationMapKeyLenBetween(t *testing.T) {
 	cases := map[string]struct {
-		Value interface{}
-		Error bool
+		Value         interface{}
+		ExpectedDiags diag.Diagnostics
 	}{
-		"NotMap": {
-			Value: "the map is a lie",
-			Error: true,
-		},
 		"TooLong": {
 			Value: map[string]interface{}{
 				"ABC":    "123",
 				"UVWXYZ": "123456",
 			},
-			Error: true,
+			ExpectedDiags: diag.Diagnostics{
+				{
+					Severity:      diag.Error,
+					AttributePath: append(cty.Path{}, cty.IndexStep{Key: cty.StringVal("UVWXYZ")}),
+				},
+			},
 		},
 		"TooShort": {
 			Value: map[string]interface{}{
 				"ABC": "123",
 				"U":   "1",
 			},
-			Error: true,
+			ExpectedDiags: diag.Diagnostics{
+				{
+					Severity:      diag.Error,
+					AttributePath: append(cty.Path{}, cty.IndexStep{Key: cty.StringVal("U")}),
+				},
+			},
 		},
 		"AllGood": {
 			Value: map[string]interface{}{
 				"AB":    "12",
 				"UVWXY": "12345",
 			},
-			Error: false,
+			ExpectedDiags: nil,
 		},
 	}
 
 	fn := MapKeyLenBetween(2, 5)
 
 	for tn, tc := range cases {
 		t.Run(tn, func(t *testing.T) {
-			_, errors := fn(tc.Value, tn)
+			diags := fn(tc.Value, cty.Path{})
 
-			if len(errors) > 0 && !tc.Error {
-				t.Errorf("MapKeyLenBetween(%s) produced an unexpected error", tc.Value)
-			} else if len(errors) == 0 && tc.Error {
-				t.Errorf("MapKeyLenBetween(%s) did not error", tc.Value)
+			if len(diags) != len(tc.ExpectedDiags) {
+				t.Fatalf("%s: wrong number of diags, expected %d, got %d", tn, len(tc.ExpectedDiags), len(diags))
+			}
+			for j := range diags {
+				if diags[j].Severity != tc.ExpectedDiags[j].Severity {
+					t.Fatalf("%s: expected severity %v, got %v", tn, tc.ExpectedDiags[j].Severity, diags[j].Severity)
+				}
+				if !diags[j].AttributePath.Equals(tc.ExpectedDiags[j].AttributePath) {
+					t.Fatalf("%s: attribute paths do not match expected: %v, got %v", tn, tc.ExpectedDiags[j].AttributePath, diags[j].AttributePath)
+				}
 			}
 		})
 	}