Fix handling of []byte and uint in value reflector

Author: jpbetz

typed/parser.go

@@ -124,6 +124,7 @@ func (p ParseableType) FromStructured(in interface{}) (*TypedValue, error) {
 	}
 	return AsTyped(v, p.Schema, p.TypeRef)
 }
+
 // DeducedParseableType is a ParseableType that deduces the type from
 // the content of the object.
 var DeducedParseableType ParseableType = createOrDie(YAMLObject(`types:

value/valuereflect.go

@@ -18,6 +18,7 @@ package value
 
 import (
 	"bytes"
+	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"reflect"
@@ -78,24 +79,32 @@ func (r valueReflect) IsMap() bool {
 }
 
 func (r valueReflect) IsList() bool {
-	return r.isKind(reflect.Slice, reflect.Array)
+	typ := r.Value.Type()
+	return typ.Kind() == reflect.Slice && !(typ.Elem().Kind() == reflect.Uint8)
 }
 
 func (r valueReflect) IsBool() bool {
 	return r.isKind(reflect.Bool)
 }
 
 func (r valueReflect) IsInt() bool {
-	// This feels wrong. Very wrong.
-	return r.isKind(reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8, reflect.Uint64, reflect.Uint, reflect.Uint32, reflect.Uint16, reflect.Uint8)
+	// Uint64 deliberately excluded, see valueUnstructured.Int.
+	return r.isKind(reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8, reflect.Uint, reflect.Uint32, reflect.Uint16, reflect.Uint8)
 }
 
 func (r valueReflect) IsFloat() bool {
 	return r.isKind(reflect.Float64, reflect.Float32)
 }
 
 func (r valueReflect) IsString() bool {
-	return r.isKind(reflect.String)
+	kind := r.Value.Kind()
+	if kind == reflect.String {
+		return true
+	}
+	if kind == reflect.Slice && r.Value.Type().Elem().Kind() == reflect.Uint8 {
+		return true
+	}
+	return false
 }
 
 func (r valueReflect) IsNull() bool {
@@ -153,9 +162,13 @@ func (r valueReflect) Bool() bool {
 }
 
 func (r valueReflect) Int() int64 {
-	if r.IsInt() {
+	if r.isKind(reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8) {
 		return r.Value.Int()
 	}
+	if r.isKind(reflect.Uint, reflect.Uint32, reflect.Uint16, reflect.Uint8) {
+		return int64(r.Value.Uint())
+	}
+
 	panic("value is not an int")
 }
 
@@ -167,9 +180,13 @@ func (r valueReflect) Float() float64 {
 }
 
 func (r valueReflect) String() string {
-	if r.IsString() {
+	kind := r.Value.Kind()
+	if kind == reflect.String {
 		return r.Value.String()
 	}
+	if kind == reflect.Slice && r.Value.Type().Elem().Kind() == reflect.Uint8 {
+		return base64.StdEncoding.EncodeToString(r.Value.Bytes())
+	}
 	panic("value is not a string")
 }
 
@@ -193,7 +210,7 @@ func (r valueReflect) Unstructured() interface{} {
 	case r.IsFloat():
 		return r.Float()
 	default:
-		panic("value is not a map or struct")
+		panic(fmt.Sprintf("value of type %s is not a supported by value reflector", val.Type()))
 	}
 }
 

value/valuereflect_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package value
 
 import (
+	"encoding/base64"
 	"encoding/json"
 	"reflect"
 	"testing"
@@ -37,31 +38,51 @@ func TestReflectPrimitives(t *testing.T) {
 		t.Error("expected IsString to be true")
 	}
 	if rv.String() != "string" {
-		t.Errorf("expected rv.String to be 'string' but got %s", rv.String())
+		t.Errorf("expected rv.String to be 'string' but got %v", rv.Unstructured())
+	}
+
+	rv = MustReflect([]byte("string"))
+	if !rv.IsString() {
+		t.Error("expected IsString to be true")
+	}
+	if rv.IsList() {
+		t.Error("expected IsList to be false ([]byte is represented as a base64 encoded string)")
+	}
+	encoded := base64.StdEncoding.EncodeToString([]byte("string"))
+	if rv.String() != encoded {
+		t.Errorf("expected rv.String to be %v but got %v", []byte(encoded), rv.Unstructured())
 	}
 
 	rv = MustReflect(1)
 	if !rv.IsInt() {
 		t.Error("expected IsInt to be true")
 	}
 	if rv.Int() != 1 {
-		t.Errorf("expected rv.Int to be 1 but got %s", rv.String())
+		t.Errorf("expected rv.Int to be 1 but got %v", rv.Unstructured())
+	}
+
+	rv = MustReflect(uint32(3000000000))
+	if !rv.IsInt() {
+		t.Error("expected IsInt to be true")
+	}
+	if rv.Int() != 3000000000 {
+		t.Errorf("expected rv.Int to be 3000000000 but got %v", rv.Unstructured())
 	}
 
 	rv = MustReflect(1.5)
 	if !rv.IsFloat() {
 		t.Error("expected IsFloat to be true")
 	}
 	if rv.Float() != 1.5 {
-		t.Errorf("expected rv.Float to be 1.1 but got %s", rv.String())
+		t.Errorf("expected rv.Float to be 1.1 but got %v", rv.Unstructured())
 	}
 
 	rv = MustReflect(true)
 	if !rv.IsBool() {
 		t.Error("expected IsBool to be true")
 	}
 	if rv.Bool() != true {
-		t.Errorf("expected rv.Bool to be true but got %s", rv.String())
+		t.Errorf("expected rv.Bool to be true but got %v", rv.Unstructured())
 	}
 
 	rv = MustReflect(nil)