Adding OneOf and NoneOf to stringvalidator

It's a string-specific version of `genericvalidator.OneOf/NoneOf`, that adds support for case-sensitiveness.

Author: Ivan De Marino

genericvalidator/none_of_test.go

@@ -43,7 +43,7 @@ func TestNoneOfValidator(t *testing.T) {
 			),
 			expErrors: 1,
 		},
-		"simple-mismatch-match": {
+		"simple-mismatch": {
 			in: types.String{Value: "foz"},
 			validator: genericvalidator.NoneOf(
 				types.String{Value: "foo"},

genericvalidator/one_of_test.go

@@ -42,7 +42,7 @@ func TestOneOfValidator(t *testing.T) {
 				types.String{Value: "baz"},
 			),
 		},
-		"simple-mismatch-match": {
+		"simple-mismatch": {
 			in: types.String{Value: "foz"},
 			validator: genericvalidator.OneOf(
 				types.String{Value: "foo"},

helpers/validatordiag/diag.go

@@ -44,6 +44,15 @@ func InvalidSchemaDiagnostic(path *tftypes.AttributePath, description string) di
 	)
 }
 
+// InvalidTypeDiagnostic returns an error Diagnostic to be used when an attribute has an invalid type.
+func InvalidTypeDiagnostic(path *tftypes.AttributePath, description string, value string) diag.Diagnostic {
+	return diag.NewAttributeErrorDiagnostic(
+		path,
+		"Invalid Attribute Type",
+		capitalize(description)+", got: "+value,
+	)
+}
+
 // ErrorsCount returns the amount of diag.Diagnostic in diag.Diagnostics that are diag.SeverityError.
 func ErrorsCount(diags diag.Diagnostics) int {
 	count := 0

stringvalidator/acceptable_strings_validator.go

@@ -0,0 +1,115 @@
+package stringvalidator
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-framework-validators/helpers/validatordiag"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/tfsdk"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+)
+
+// acceptableStringsAttributeValidator is the underlying struct implementing OneOf and NoneOf.
+type acceptableStringsAttributeValidator struct {
+	acceptableStringValues []types.String
+	caseSensitive          bool
+	shouldMatch            bool
+}
+
+var _ tfsdk.AttributeValidator = (*acceptableStringsAttributeValidator)(nil)
+
+func (av *acceptableStringsAttributeValidator) Description(ctx context.Context) string {
+	return av.MarkdownDescription(ctx)
+}
+
+func (av *acceptableStringsAttributeValidator) MarkdownDescription(_ context.Context) string {
+	if av.shouldMatch {
+		return fmt.Sprintf("String(s) must match one of: %q", av.acceptableStringValues)
+	} else {
+		return fmt.Sprintf("String(s) must match none of: %q", av.acceptableStringValues)
+	}
+
+}
+
+func (av *acceptableStringsAttributeValidator) Validate(ctx context.Context, req tfsdk.ValidateAttributeRequest, res *tfsdk.ValidateAttributeResponse) {
+	if req.AttributeConfig.IsNull() || req.AttributeConfig.IsUnknown() {
+		return
+	}
+
+	// Gather the `values` to validate:
+	// singleton slice for primitives,
+	// a collection for the other possible `types.*`.
+	var values []attr.Value
+	switch typedAttributeConfig := req.AttributeConfig.(type) {
+	case types.List:
+		values = typedAttributeConfig.Elems
+	case types.Map:
+		values = make([]attr.Value, 0, len(typedAttributeConfig.Elems))
+		for _, v := range typedAttributeConfig.Elems {
+			values = append(values, v)
+		}
+	case types.Set:
+		values = typedAttributeConfig.Elems
+	case types.Object:
+		values = make([]attr.Value, 0, len(typedAttributeConfig.Attrs))
+		for _, v := range typedAttributeConfig.Attrs {
+			values = append(values, v)
+		}
+	default:
+		values = []attr.Value{typedAttributeConfig}
+	}
+
+	for _, v := range values {
+		// Before we go any further, we need to confirm the values we gathered are indeed strings
+		vType := v.Type(ctx)
+		if vType != types.StringType {
+			res.Diagnostics.Append(validatordiag.InvalidTypeDiagnostic(
+				req.AttributePath,
+				fmt.Sprintf("Expected value %q of type %s", v.String(), types.StringType),
+				v.Type(ctx).String(),
+			))
+			continue
+		}
+
+		vStr := v.(types.String)
+
+		if av.shouldMatch && !av.isAcceptableValue(vStr) || //< EITHER should match but it does not
+			!av.shouldMatch && av.isAcceptableValue(vStr) { //< OR should not match but it does
+			res.Diagnostics.Append(validatordiag.InvalidValueMatchDiagnostic(
+				req.AttributePath,
+				av.Description(ctx),
+				v.String(),
+			))
+		}
+	}
+}
+
+func (av *acceptableStringsAttributeValidator) isAcceptableValue(v types.String) bool {
+	for _, acceptableV := range av.acceptableStringValues {
+		if av.caseSensitive {
+			if v.Equal(acceptableV) {
+				return true
+			}
+		} else {
+			// Before we proceed, we make lower-cased copies of the values involved
+			vLower := types.String{
+				Value:   strings.ToLower(v.Value),
+				Unknown: v.Unknown,
+				Null:    v.Null,
+			}
+			acceptableVLower := types.String{
+				Value:   strings.ToLower(acceptableV.Value),
+				Unknown: v.Unknown,
+				Null:    v.Null,
+			}
+
+			if vLower.Equal(acceptableVLower) {
+				return true
+			}
+		}
+	}
+
+	return false
+}

stringvalidator/none_of.go

@@ -0,0 +1,29 @@
+package stringvalidator
+
+import (
+	"github.com/hashicorp/terraform-plugin-framework/tfsdk"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+)
+
+// NoneOf checks that string(s) held in the attribute
+// is (are) none of the given `acceptableStrings`.
+//
+// This validator can be used `types.String`, as well as
+// collections (`types.List`, `types.Set`, `types.Map` and `types.Object`)
+// that contain `types.String`.
+//
+// For key/value collections, the validator will be applied only to the values.
+//
+// String comparison case sensitiveness is controlled by the `caseSensitive` argument.
+func NoneOf(caseSensitive bool, acceptableStrings ...string) tfsdk.AttributeValidator {
+	acceptableStringValues := make([]types.String, 0, len(acceptableStrings))
+	for _, s := range acceptableStrings {
+		acceptableStringValues = append(acceptableStringValues, types.String{Value: s})
+	}
+
+	return &acceptableStringsAttributeValidator{
+		acceptableStringValues: acceptableStringValues,
+		caseSensitive:          caseSensitive,
+		shouldMatch:            false,
+	}
+}