Dcarbone/v1.x (#10)

* v1.x work:
- removing many panic calls as that was stupid of me
- adding additional error types in relevant packages with constructors and testers
- beginning implementation of OneOf with []string
- working on more tests

* fleshing out strings comparison and tests

* adding comparison to []ints as well as some more internal cleanup

* readme updates

* CompareOp.Name() now returns underlying string value if "unknown"

Author: dcarbone

.github/workflows/tests.yaml

@@ -21,8 +21,12 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v3
         with:
-          go-version: 1.17
+          go-version-file: go.mod
 
       - run: go mod tidy -compat=1.17 && go mod vendor
+
       - working-directory: acctest
+        run: go test -v
+
+      - working-directory: validation
         run: go test -v

README.md

@@ -109,6 +109,15 @@ your own [ComparisonFunc](validation/comparison.go#44) using [SetComparisonFunc]
     Validators: []tfsdk.AttributeValidator{
         // equal
         validation.Compare(validation.Equal, 5),
+		// string comparisons are case sensitive by default
+		validation.Compare(validation.Equal, "five")
+		// passing true as the 3rd arg executes a case-insensitive comparison with strings
+		validation.Compare(validation.Equal, "fIve", true)
+		// you may also equate string slices
+		validation.Compare(validation.Equal, []string{"one", "two"})
+        validation.Compare(validation.Equal, []string{"oNe", "twO"}, true)
+		// you can also assert that a list of ints is equivalent
+		validation.Compare(validation.Equal, []int{1, 2})
 
         // less than
         validation.Compare(validation.LessThan, 10),
@@ -123,7 +132,30 @@ your own [ComparisonFunc](validation/comparison.go#44) using [SetComparisonFunc]
         validation.Compare(validation.GreaterThanOrEqualTo, 5),
 
         // not equal
-        validation.Compare(validation.NotEqual, 10).
+        validation.Compare(validation.NotEqual, 10),
+		// string comparisons are case sensitive by default
+		validation.Compare(validation.NotEqual, "ten")
+		// passing true as the 3rd arg executes a case-insensitive comparison with strings
+		validation.Compare(validation.NotEqual, "tEn", true)
+		// you may also compare string slices
+		validation.Compare(validation.NotEqual, []string{"one", "two"})
+        validation.Compare(validation.NotEqual, []string{"oNe", "twO"}, true)
+		// you can also assert that a list of ints is not equivalent
+        validation.Compare(validation.NotEqual, []int{1, 2})
+
+        // one of
+		// currently OneOf only works with strings and ints
+		validation.Compare(validation.OneOf, []string{"one", "two"})
+		// you can provide true for the 3rd parameter to perform a case-insensitive comparison
+		validation.Compare(validation.OneOf, []string{"one", "two"}, true)
+		validation.Compare(validation.OneOf []int{1, 2})
+		
+		// not one of
+		// currently NotOneOf only works with strings and ints
+		validation.Compare(validation.NotOneOf, []string{"one", "two"})
+		// you can provide true for the 3rd parameter to perform a case-insensitive comparison
+		validation.Compare(validation.NotOneOf, []string{"one", "two"}, true)
+		validation.Compare(validation.NotOneOf []int{1, 2})
     }
 }
 ```

conv/errors.go

@@ -1,39 +1,36 @@
 package conv
 
-import "errors"
+import (
+	"errors"
+	"fmt"
+
+	"github.com/dcarbone/terraform-plugin-framework-utils/internal/util"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+)
 
 var (
-	ErrValueIsNull    = errors.New("value is nil")
-	ErrValueIsUnknown = errors.New("value is unknown")
-	ErrValueIsEmpty   = errors.New("value is empty")
+	ErrValueIsNull        = errors.New("value is nil")
+	ErrValueIsUnknown     = errors.New("value is unknown")
+	ErrValueIsEmpty       = errors.New("value is empty")
+	ErrValueTypeUnhandled = errors.New("value type is unhandled, this usually means this package is out of date with the upstream provider framework")
 )
 
 func IsValueIsNullError(err error) bool {
-	for err != nil {
-		if errors.Is(err, ErrValueIsNull) {
-			return true
-		}
-		err = errors.Unwrap(err)
-	}
-	return false
+	return util.MatchError(err, ErrValueIsNull)
 }
 
 func IsValueIsUnknownError(err error) bool {
-	for err != nil {
-		if errors.Is(err, ErrValueIsUnknown) {
-			return true
-		}
-		err = errors.Unwrap(err)
-	}
-	return false
+	return util.MatchError(err, ErrValueIsUnknown)
 }
 
 func IsValueIsEmptyError(err error) bool {
-	for err != nil {
-		if errors.Is(err, ErrValueIsEmpty) {
-			return true
-		}
-		err = errors.Unwrap(err)
-	}
-	return false
+	return util.MatchError(err, ErrValueIsEmpty)
+}
+
+func ValueTypeUnhandledError(scope string, av attr.Value) error {
+	return fmt.Errorf("%w: scope=%q; type=%T", ErrValueTypeUnhandled, scope, av)
+}
+
+func IsValueTypeUnhandledError(err error) bool {
+	return util.MatchError(err, ErrValueTypeUnhandled)
 }

conv/go.go

@@ -21,6 +21,6 @@ func GoNumberToString(num interface{}) string {
 		return num.(*big.Float).String()
 
 	default:
-		panic(fmt.Sprintf("no case for type %T", num))
+		return fmt.Sprintf("%T", num)
 	}
 }

conv/values.go

@@ -9,8 +9,6 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/types"
 )
 
-type TFTypeValueType uint8
-
 // ValueToBoolType ensures we have a types.Bool literal
 func ValueToBoolType(v attr.Value) types.Bool {
 	if vb, ok := v.(types.Bool); ok {
@@ -128,70 +126,69 @@ func ValueToStringType(v attr.Value) types.String {
 //
 // A 'nil' response from this function means the attribute's value was defined to a non-"empty" value at runtime. See
 // function body for a particular type if you're interested in what "empty" means.
-func TestAttributeValueState(v attr.Value) error {
+func TestAttributeValueState(av attr.Value) error {
 	var (
 		undefined bool
 		null      bool
 		empty     bool
 	)
 
-	// first, check for unknown and null
-	switch v.(type) {
+	switch av.(type) {
+	// bool values cannot be "empty"
 	case types.Bool, *types.Bool:
-		tv := ValueToBoolType(v)
+		tv := ValueToBoolType(av)
 		undefined = tv.Unknown
 		null = tv.Null
-	// bool values cannot be "empty"
 
+	// float values cannot be "empty"
 	case types.Float64, *types.Float64:
-		tv := ValueToFloat64Type(v)
+		tv := ValueToFloat64Type(av)
 		undefined = tv.Unknown
 		null = tv.Null
-	// float values cannot be "empty"
 
+	// int values cannot be "empty"
 	case types.Int64, *types.Int64:
-		tv := ValueToInt64Type(v)
+		tv := ValueToInt64Type(av)
 		undefined = tv.Unknown
 		null = tv.Null
-	// int values cannot be "empty"
 
 	case types.List, *types.List:
-		tv := ValueToListType(v)
+		tv := ValueToListType(av)
 		undefined = tv.Unknown
 		null = tv.Null
-		empty = AttributeValueLength(v) == 0
+		empty = AttributeValueLength(av) == 0
 
 	case types.Map, *types.Map:
-		tv := ValueToMapType(v)
+		tv := ValueToMapType(av)
 		undefined = tv.Unknown
 		null = tv.Null
-		empty = AttributeValueLength(v) == 0
+		empty = AttributeValueLength(av) == 0
 
 	case types.Number, *types.Number:
-		tv := ValueToNumberType(v)
+		tv := ValueToNumberType(av)
 		undefined = tv.Unknown
 		null = tv.Null
 
+	// todo: implement object "emptiness" check
 	case types.Object, *types.Object:
-		tv := ValueToObjectType(v)
+		tv := ValueToObjectType(av)
 		undefined = tv.Unknown
 		null = tv.Null
-	// todo: implement object "emptiness" check
 
 	case types.Set, *types.Set:
-		tv := ValueToSetType(v)
+		tv := ValueToSetType(av)
 		undefined = tv.Unknown
 		null = tv.Null
-		empty = AttributeValueLength(v) > 0
+		empty = AttributeValueLength(av) > 0
 
 	case types.String, *types.String:
-		tv := ValueToStringType(v)
+		tv := ValueToStringType(av)
 		undefined = tv.Unknown
 		null = tv.Null
-		empty = StringValueToString(v) == ""
+		empty = StringValueToString(av) == ""
 
 	default:
-		panic(fmt.Sprintf("no way to test for valued state for types %T", v))
+		return ValueTypeUnhandledError("length_check", av)
 	}
 
 	if undefined {
@@ -257,7 +254,22 @@ func AttributeValueToString(v attr.Value) string {
 		return StringValueToString(v)
 
 	default:
-		panic(fmt.Sprintf("no stringer func registered for type %T", v))
+		return fmt.Sprintf("%T", v)
+	}
+}
+
+// AttributeValueToStrings attempts to convert the provided attr.Value into a slice of strings.
+func AttributeValueToStrings(av attr.Value) []string {
+	switch av.(type) {
+	case types.List, *types.List:
+		return StringListToStrings(av)
+
+	case types.Set, *types.Set:
+		return StringSetToStrings(av)
+	default:
+		out := make([]string, 0)
+		out = append(out, ValueToStringType(av).Value)
+		return out
 	}
 }
 
@@ -341,6 +353,13 @@ func NumberValueToInt64(v attr.Value) (int64, big.Accuracy) {
 	return vt.Value.Int64()
 }
 
+// NumberValueToInt accepts either a types.Number or *types.Number, returning an int representation of the *big.Float
+// value within.  It will return [0, big.Exact] if the value was not set
+func NumberValueToInt(v attr.Value) (int, big.Accuracy) {
+	iv, acc := NumberValueToInt64(v)
+	return int(iv), acc
+}
+
 // NumberValueToFloat64 accepts either a types.Number or *types.Number, returning a float64 representation of the
 // *big.Float value within.  It will return [0.0, big.Exact] of the value was not set.
 func NumberValueToFloat64(v attr.Value) (float64, big.Accuracy) {
@@ -410,13 +429,35 @@ func StringValueToStringPtr(v attr.Value) *string {
 	return vPtr
 }
 
+// StringListToStrings accepts an instance of either types.List or *types.List where ElemType MUST be types.StringType,
+// returning a slice of strings of the value of each element
+func StringListToStrings(v attr.Value) []string {
+	vt := ValueToListType(v)
+	out := make([]string, len(vt.Elems))
+	for i, ve := range vt.Elems {
+		out[i] = StringValueToString(ve)
+	}
+	return out
+}
+
+// StringSetToStrings accepts an instance of either types.Set or *types.Set where ElemType MUST be types.StringType,
+// returning a slice of strings of the value of each element
+func StringSetToStrings(v attr.Value) []string {
+	vt := ValueToSetType(v)
+	out := make([]string, len(vt.Elems))
+	for i, ve := range vt.Elems {
+		out[i] = StringValueToString(ve)
+	}
+	return out
+}
+
 // Int64ListToInts accepts an instance of either types.List or *types.List where ElemType MUST be types.Int64Type,
 // returning a slice of ints of the value of each element.
 func Int64ListToInts(v attr.Value) []int {
 	vt := ValueToListType(v)
 	out := make([]int, len(vt.Elems))
 	for i, ve := range vt.Elems {
-		out[i] = Int64ValueToInt(ve.(types.Int64))
+		out[i] = Int64ValueToInt(ve)
 	}
 	return out
 }
@@ -427,7 +468,31 @@ func Int64SetToInts(v attr.Value) []int {
 	vt := ValueToSetType(v)
 	out := make([]int, len(vt.Elems))
 	for i, ve := range vt.Elems {
-		out[i] = Int64ValueToInt(ve.(types.Int64))
+		out[i] = Int64ValueToInt(ve)
+	}
+	return out
+}
+
+// NumberListToInts accepts either an instance of types.List or *types.List where ElemType MUST be types.NumberType
+// returning a slice of ints of the value of each element
+func NumberListToInts(v attr.Value) []int {
+	vt := ValueToListType(v)
+	out := make([]int, len(vt.Elems))
+	for i, ve := range vt.Elems {
+		iv, _ := NumberValueToInt(ve)
+		out[i] = iv
+	}
+	return out
+}
+
+// NumberSetToInts accepts either an instance of types.Set or *types.Set where ElemType MUST be types.NumberType
+// returning a slice of ints of the value of each element
+func NumberSetToInts(v attr.Value) []int {
+	vt := ValueToSetType(v)
+	out := make([]int, len(vt.Elems))
+	for i, ve := range vt.Elems {
+		iv, _ := NumberValueToInt(ve)
+		out[i] = iv
 	}
 	return out
 }
@@ -451,7 +516,7 @@ func AttributeValueToFloat64(v attr.Value) (float64, big.Accuracy, error) {
 		return f, big.Exact, err
 
 	default:
-		panic(fmt.Sprintf("unable to determine float64 value of type %T", v))
+		return 0, 0, ValueTypeUnhandledError("attr_to_float64", v)
 	}
 }
 
@@ -480,7 +545,7 @@ func AttributeValueToInt64(v attr.Value) (int64, big.Accuracy, error) {
 		return int64(i), big.Exact, err
 
 	default:
-		panic(fmt.Sprintf("unable to determine int64 value of type %T", v))
+		return 0, 0, ValueTypeUnhandledError("attr_to_int64", v)
 	}
 }
 
@@ -502,7 +567,7 @@ func AttributeValueToBigFloat(v attr.Value) (*big.Float, error) {
 		return bf, err
 
 	default:
-		panic(fmt.Sprintf("unable to parse type %T into *big.Float", v))
+		return nil, ValueTypeUnhandledError("attr_to_bigfloat", v)
 	}
 }