#minor Enum type (flyteorg#183)

* Enum type definition

Signed-off-by: Ketan Umare <ketan.umare@gmail.com>

* Enum Type support in flyteidl

Signed-off-by: Ketan Umare <ketan.umare@gmail.com>

* lint fixes

Signed-off-by: Ketan Umare <ketan.umare@gmail.com>

* re-generated

Signed-off-by: Ketan Umare <ketan.umare@gmail.com>

* Enum default values are the first value in the list

Signed-off-by: Ketan Umare <ketan.umare@gmail.com>

clients/go/coreutils/literals.go

@@ -294,6 +294,8 @@ func MakeDefaultLiteralForType(typ *core.LiteralType) (*core.Literal, error) {
 				},
 			},
 		}, nil
+	case *core.LiteralType_EnumType:
+		return MakeLiteralForType(typ, nil)
 		//case *core.LiteralType_Schema:
 	}
 
@@ -462,6 +464,7 @@ func MakeLiteralForType(t *core.LiteralType, v interface{}) (*core.Literal, erro
 				Literals: literals,
 			},
 		}
+
 	case *core.LiteralType_CollectionType:
 		newT := t.Type.(*core.LiteralType_CollectionType)
 		newV, ok := v.([]interface{})
@@ -482,6 +485,7 @@ func MakeLiteralForType(t *core.LiteralType, v interface{}) (*core.Literal, erro
 				Literals: literals,
 			},
 		}
+
 	case *core.LiteralType_Simple:
 		newT := t.Type.(*core.LiteralType_Simple)
 		strValue := fmt.Sprintf("%v", v)
@@ -499,11 +503,39 @@ func MakeLiteralForType(t *core.LiteralType, v interface{}) (*core.Literal, erro
 			return nil, err
 		}
 		return lv, nil
+
 	case *core.LiteralType_Blob:
 		newT := t.Type.(*core.LiteralType_Blob)
 		isDir := newT.Blob.Dimensionality == core.BlobType_MULTIPART
 		lv := MakeLiteralForBlob(storage.DataReference(fmt.Sprintf("%v", v)), isDir, newT.Blob.Format)
 		return lv, nil
+
+	case *core.LiteralType_EnumType:
+		var newV string
+		if v == nil {
+			if len(t.GetEnumType().Values) == 0 {
+				return nil, fmt.Errorf("enum types need atleast one value")
+			}
+			newV = t.GetEnumType().Values[0]
+		} else {
+			var ok bool
+			newV, ok = v.(string)
+			if !ok {
+				return nil, fmt.Errorf("cannot convert [%v] to enum representations, only string values are supported in enum literals", reflect.TypeOf(v))
+			}
+			found := false
+			for _, val := range t.GetEnumType().GetValues() {
+				if val == newV {
+					found = true
+					break
+				}
+			}
+			if !found {
+				return nil, fmt.Errorf("incorrect enum value [%s], supported values %+v", newV, t.GetEnumType().GetValues())
+			}
+		}
+		return MakePrimitiveLiteral(newV)
+
 	default:
 		return nil, fmt.Errorf("unsupported type %s", t.String())
 	}

clients/go/coreutils/literals_test.go

@@ -248,6 +248,17 @@ func TestMakeDefaultLiteralForType(t *testing.T) {
 		assert.NoError(t, err)
 		assert.NotNil(t, l.GetScalar().GetGeneric())
 	})
+
+	t.Run("enum", func(t *testing.T) {
+		l, err := MakeDefaultLiteralForType(&core.LiteralType{Type: &core.LiteralType_EnumType{
+			EnumType: &core.EnumType{Values: []string{"x", "y", "z"}},
+		}})
+		assert.NoError(t, err)
+		assert.NotNil(t, l.GetScalar().GetPrimitive().GetStringValue())
+		expected := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{
+			Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "x"}}}}}}
+		assert.Equal(t, expected, l)
+	})
 }
 
 func TestMustMakeDefaultLiteralForType(t *testing.T) {
@@ -581,4 +592,29 @@ func TestMakeLiteralForType(t *testing.T) {
 		assert.Equal(t, expectedErrorf, err)
 
 	})
+
+	t.Run("enumtype-nil", func(t *testing.T) {
+		var literalType = &core.LiteralType{Type: &core.LiteralType_EnumType{EnumType: &core.EnumType{}}}
+		_, err := MakeLiteralForType(literalType, nil)
+		assert.Error(t, err)
+		_, err = MakeLiteralForType(literalType, "")
+		assert.Error(t, err)
+	})
+
+	t.Run("enumtype-happy", func(t *testing.T) {
+		var literalType = &core.LiteralType{Type: &core.LiteralType_EnumType{EnumType: &core.EnumType{Values: []string{"x", "y", "z"}}}}
+		expected := &core.Literal{Value: &core.Literal_Scalar{Scalar: &core.Scalar{
+			Value: &core.Scalar_Primitive{Primitive: &core.Primitive{Value: &core.Primitive_StringValue{StringValue: "x"}}}}}}
+		v, err := MakeLiteralForType(literalType, "x")
+		assert.NoError(t, err)
+		assert.Equal(t, expected, v)
+		_, err = MakeLiteralForType(literalType, "")
+		assert.Error(t, err)
+	})
+
+	t.Run("enumtype-illegal-val", func(t *testing.T) {
+		var literalType = &core.LiteralType{Type: &core.LiteralType_EnumType{EnumType: &core.EnumType{Values: []string{"x", "y", "z"}}}}
+		_, err := MakeLiteralForType(literalType, "m")
+		assert.Error(t, err)
+	})
 }

clients/go/events/admin_eventsink_integration_test.go

@@ -14,8 +14,8 @@ import (
 	"github.com/flyteorg/flyteidl/clients/go/admin"
 	"github.com/flyteorg/flyteidl/gen/pb-go/flyteidl/core"
 	"github.com/flyteorg/flyteidl/gen/pb-go/flyteidl/event"
-	"github.com/golang/protobuf/ptypes"
 	"github.com/flyteorg/flytestdlib/config"
+	"github.com/golang/protobuf/ptypes"
 )
 
 var (