Merge pull request #136 from microsoft/andrueastman/validateEnumParsing

Validates cases for enum parsing

Author: andrueastman

internal/test_entity.go

@@ -7,10 +7,10 @@ import (
 )
 
 type TestEntity struct {
-	additionalData map[string]interface{}
-	id             *string
-	officeLocation *string
-	//TODO test numbers enum
+	additionalData  map[string]interface{}
+	id              *string
+	officeLocation  *string
+	sensitivity     *TestSensitivity
 	workDuration    *absser.ISODuration
 	birthDay        *absser.DateOnly
 	startWorkTime   *absser.TimeOnly
@@ -35,6 +35,8 @@ type TestEntityable interface {
 	SetEndWorkTime(value *absser.TimeOnly)
 	GetCreatedDateTime() *time.Time
 	SetCreatedDateTime(value *time.Time)
+	GetSensitivity() *TestSensitivity
+	SetSensitivity(value *TestSensitivity)
 }
 
 func TestEntityDiscriminator(absser.ParseNode) (absser.Parsable, error) {
@@ -95,6 +97,12 @@ func (e *TestEntity) GetCreatedDateTime() *time.Time {
 func (e *TestEntity) SetCreatedDateTime(value *time.Time) {
 	e.createdDateTime = value
 }
+func (e *TestEntity) GetSensitivity() *TestSensitivity {
+	return e.sensitivity
+}
+func (e *TestEntity) SetSensitivity(value *TestSensitivity) {
+	e.sensitivity = value
+}
 
 func CreateTestEntityFromDiscriminator(parseNode absser.ParseNode) (absser.Parsable, error) {
 	return NewTestEntity(), nil
@@ -172,6 +180,16 @@ func (e *TestEntity) GetFieldDeserializers() map[string]func(absser.ParseNode) e
 		}
 		return nil
 	}
+	res["sensitivity"] = func(n absser.ParseNode) error {
+		val, err := n.GetEnumValue(ParseTestSensitivity)
+		if err != nil {
+			return err
+		}
+		if val != nil {
+			e.SetSensitivity(val.(*TestSensitivity))
+		}
+		return nil
+	}
 	return res
 }
 
@@ -218,5 +236,12 @@ func (m *TestEntity) Serialize(writer absser.SerializationWriter) error {
 			return err
 		}
 	}
+	if m.GetSensitivity() != nil {
+		cast := (*m.GetSensitivity()).String()
+		err := writer.WriteStringValue("sensitivity", &cast)
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }

internal/test_sensitivity.go

@@ -0,0 +1,40 @@
+package internal
+
+type TestSensitivity int
+
+const (
+	NORMAL_SENSITIVITY TestSensitivity = iota
+	PERSONAL_SENSITIVITY
+	PRIVATE_SENSITIVITY
+	CONFIDENTIAL_SENSITIVITY
+)
+
+func (i TestSensitivity) String() string {
+	return []string{"normal", "personal", "private", "confidential"}[i]
+}
+func ParseTestSensitivity(v string) (any, error) {
+	result := NORMAL_SENSITIVITY
+	switch v {
+	case "normal":
+		result = NORMAL_SENSITIVITY
+	case "personal":
+		result = PERSONAL_SENSITIVITY
+	case "private":
+		result = PRIVATE_SENSITIVITY
+	case "confidential":
+		result = CONFIDENTIAL_SENSITIVITY
+	default:
+		return nil, nil
+	}
+	return &result, nil
+}
+func SerializeTestSensitivity(values []TestSensitivity) []string {
+	result := make([]string, len(values))
+	for i, v := range values {
+		result[i] = v.String()
+	}
+	return result
+}
+func (i TestSensitivity) isMultiValue() bool {
+	return false
+}

json_parse_node_test.go

@@ -122,6 +122,42 @@ func TestNestedGetRawValue(t *testing.T) {
 	assert.Equal(t, expected, value)
 }
 
+func TestValidEnumValue(t *testing.T) {
+	source := `{
+					"id": "acbb4e46-0aa9-11ee-be56-0242ac120002",
+					"officeLocation": "Nairobi",
+					"sensitivity": "normal"
+				}`
+	sourceArray := []byte(source)
+	parseNode, err := NewJsonParseNode(sourceArray)
+	if err != nil {
+		t.Errorf("Error creating parse node: %s", err.Error())
+	}
+	parsable, err := parseNode.GetObjectValue(internal.CreateTestEntityFromDiscriminator)
+	testEntity := parsable.(*internal.TestEntity)
+	require.NoError(t, err)
+	assert.Equal(t, "Nairobi", *testEntity.GetOfficeLocation())
+	assert.Equal(t, internal.NORMAL_SENSITIVITY, *testEntity.GetSensitivity())
+}
+
+func TestInvalidEnumValueReturnsNil(t *testing.T) {
+	source := `{
+					"id": "acbb4e46-0aa9-11ee-be56-0242ac120002",
+					"officeLocation": "Nairobi",
+					"sensitivity": "invalid"
+				}`
+	sourceArray := []byte(source)
+	parseNode, err := NewJsonParseNode(sourceArray)
+	if err != nil {
+		t.Errorf("Error creating parse node: %s", err.Error())
+	}
+	parsable, err := parseNode.GetObjectValue(internal.CreateTestEntityFromDiscriminator)
+	testEntity := parsable.(*internal.TestEntity)
+	require.NoError(t, err)
+	assert.Equal(t, "Nairobi", *testEntity.GetOfficeLocation())
+	assert.Nil(t, testEntity.GetSensitivity())
+}
+
 func TestNilValuesInCollections(t *testing.T) {
 	source := `{
 				"id": "2",
@@ -131,12 +167,14 @@ func TestNilValuesInCollections(t *testing.T) {
 				"testEntities": [
 					{
 						"id": "acbb4e46-0aa9-11ee-be56-0242ac120002",
-						"officeLocation": "Nairobi"
+						"officeLocation": "Nairobi",
+						"sensitivity": "personal"
 					},
 					null,
 					{
 						"id": "acbb4e46-0aa9-11ee-be56-0242ac120002",
-						"officeLocation": "Nairobi"
+						"officeLocation": "Nairobi",
+						"sensitivity": "confidential"
 					}
 				]
 		  }`

json_serialization_writer_test.go

@@ -535,6 +535,25 @@ func TestJsonSerializationWriter_WriteNullValue(t *testing.T) {
 	assert.Equal(t, "\"name\":null", converted)
 }
 
+func TestJsonSerializationWriter_WriteEnumValue(t *testing.T) {
+	serializer := NewJsonSerializationWriter()
+
+	values := []internal.TestSensitivity{internal.NORMAL_SENSITIVITY, internal.PERSONAL_SENSITIVITY, internal.PRIVATE_SENSITIVITY, internal.CONFIDENTIAL_SENSITIVITY}
+	valuesString := internal.SerializeTestSensitivity(values)
+	assert.Equal(t, []string{"normal", "personal", "private", "confidential"}, valuesString) // validates the string representation of the enum values
+
+	test := internal.NewTestEntity()
+	sensitivity := internal.NORMAL_SENSITIVITY
+	test.SetSensitivity(&sensitivity)
+	err := serializer.WriteObjectValue("name", test)
+	assert.NoError(t, err)
+	result, err := serializer.GetSerializedContent()
+	assert.NoError(t, err)
+	converted := string(result)
+
+	assert.Contains(t, converted, "\"sensitivity\":\"normal\"")
+}
+
 func TestJsonSerializationWriter(t *testing.T) {
 	serializer := NewJsonSerializationWriter()
 	countBefore := 0