Add marshaling and unmarshaling of Value struct (FF-1382) (#28)

* Add unit test to verify undesired functionality (FF-1382)

* marshall and unmarshall Value

* handle marshalling all types

* json string serialization

* test subject attributes

* add error handling

Author: leoromanovsky

eppoclient/assignmentlogger.go

@@ -7,13 +7,13 @@ type IAssignmentLogger interface {
 }
 
 type AssignmentEvent struct {
-	Experiment        string
-	FeatureFlag       string
-	Allocation        string
-	Variation         Value
-	Subject           string
-	Timestamp         string
-	SubjectAttributes dictionary
+	Experiment        string     `json:"experiment"`
+	FeatureFlag       string     `json:"featureFlag"`
+	Allocation        string     `json:"allocation"`
+	Variation         Value      `json:"variation"`
+	Subject           string     `json:"subject"`
+	Timestamp         string     `json:"timestamp"`
+	SubjectAttributes dictionary `json:"subjectAttributes,omitempty"`
 }
 
 type AssignmentLogger struct {

eppoclient/assignmentlogger_test.go

@@ -0,0 +1,79 @@
+package eppoclient
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+// TestAssignmentEventSerialization tests the JSON serialization and deserialization of AssignmentEvent
+func TestAssignmentEventSerialization(t *testing.T) {
+	// Create a test case with each type
+	testCases := []AssignmentEvent{
+		// empty subject attributes
+		{
+			Experiment:  "testExperiment",
+			FeatureFlag: "testFeatureFlag",
+			Allocation:  "testAllocation",
+			Variation:   String("testVariation"),
+			Subject:     "testSubject",
+			Timestamp:   "testTimestamp",
+		},
+		{
+			Experiment:        "testExperiment",
+			FeatureFlag:       "testFeatureFlag",
+			Allocation:        "testAllocation",
+			Variation:         Bool(true),
+			Subject:           "testSubject",
+			Timestamp:         "testTimestamp",
+			SubjectAttributes: dictionary{"testKey": "testValue"},
+		},
+		{
+			Experiment:        "testExperiment",
+			FeatureFlag:       "testFeatureFlag",
+			Allocation:        "testAllocation",
+			Variation:         Numeric(123.45),
+			Subject:           "testSubject",
+			Timestamp:         "testTimestamp",
+			SubjectAttributes: dictionary{"testKey": "testValue"},
+		},
+		{
+			Experiment:        "testExperiment",
+			FeatureFlag:       "testFeatureFlag",
+			Allocation:        "testAllocation",
+			Variation:         String("testVariation"),
+			Subject:           "testSubject",
+			Timestamp:         "testTimestamp",
+			SubjectAttributes: dictionary{"testKey": "testValue"},
+		},
+		{
+			Experiment:        "testExperiment",
+			FeatureFlag:       "testFeatureFlag",
+			Allocation:        "testAllocation",
+			Variation:         String("{\"foo\":\"bar\",\"car\":\"far\"}"),
+			Subject:           "testSubject",
+			Timestamp:         "testTimestamp",
+			SubjectAttributes: dictionary{"testKey": "testValue"},
+		},
+	}
+
+	for _, original := range testCases {
+		// Marshal to JSON
+		marshaled, err := json.Marshal(original)
+		if err != nil {
+			t.Errorf("Failed to marshal: %v", err)
+		}
+
+		// Unmarshal from JSON
+		var unmarshaled AssignmentEvent
+		err = json.Unmarshal(marshaled, &unmarshaled)
+		if err != nil {
+			t.Errorf("Failed to unmarshal: %v", err)
+		}
+
+		// Compare the original and unmarshaled
+		if !reflect.DeepEqual(original, unmarshaled) {
+			t.Errorf("Original and unmarshaled Value are not equal. Original: %+v, Unmarshaled: %+v", original, unmarshaled)
+		}
+	}
+}

eppoclient/client.go

@@ -35,22 +35,22 @@ func (ec *EppoClient) GetAssignment(subjectKey string, flagKey string, subjectAt
 
 func (ec *EppoClient) GetBoolAssignment(subjectKey string, flagKey string, subjectAttributes dictionary) (bool, error) {
 	variation, err := ec.getAssignment(subjectKey, flagKey, subjectAttributes, BoolType)
-	return variation.boolValue, err
+	return variation.BoolValue, err
 }
 
 func (ec *EppoClient) GetNumericAssignment(subjectKey string, flagKey string, subjectAttributes dictionary) (float64, error) {
 	variation, err := ec.getAssignment(subjectKey, flagKey, subjectAttributes, NumericType)
-	return variation.numericValue, err
+	return variation.NumericValue, err
 }
 
 func (ec *EppoClient) GetStringAssignment(subjectKey string, flagKey string, subjectAttributes dictionary) (string, error) {
 	variation, err := ec.getAssignment(subjectKey, flagKey, subjectAttributes, StringType)
-	return variation.stringValue, err
+	return variation.StringValue, err
 }
 
 func (ec *EppoClient) GetJSONStringAssignment(subjectKey string, flagKey string, subjectAttributes dictionary) (string, error) {
 	variation, err := ec.getAssignment(subjectKey, flagKey, subjectAttributes, StringType)
-	return variation.stringValue, err
+	return variation.StringValue, err
 }
 
 func (ec *EppoClient) getAssignment(subjectKey string, flagKey string, subjectAttributes dictionary, valueType ValueType) (Value, error) {

eppoclient/client_test.go

@@ -232,20 +232,20 @@ func Test_WithSubjectInOverrides(t *testing.T) {
 			case StringType:
 				assignment, _ := client.GetStringAssignment("user-1", "experiment-key-1", dictionary{})
 
-				if assignment != tt.want.stringValue {
-					t.Errorf("got %s, want %s", assignment, tt.want.stringValue)
+				if assignment != tt.want.StringValue {
+					t.Errorf("got %s, want %s", assignment, tt.want.StringValue)
 				}
 			case NumericType:
 				assignment, _ := client.GetNumericAssignment("user-1", "experiment-key-1", dictionary{})
 
-				if assignment != tt.want.numericValue {
-					t.Errorf("got %T, want %T", assignment, tt.want.numericValue)
+				if assignment != tt.want.NumericValue {
+					t.Errorf("got %T, want %T", assignment, tt.want.NumericValue)
 				}
 			case BoolType:
 				assignment, _ := client.GetBoolAssignment("user-1", "experiment-key-1", dictionary{})
 
-				if assignment != tt.want.boolValue {
-					t.Errorf("got %t, want %t", assignment, tt.want.boolValue)
+				if assignment != tt.want.BoolValue {
+					t.Errorf("got %t, want %t", assignment, tt.want.BoolValue)
 				}
 
 			}

eppoclient/eppoclient_e2e_test.go

@@ -106,25 +106,25 @@ func Test_e2e(t *testing.T) {
 		case "boolean":
 			expectedAssignments := []bool{}
 			for _, assignment := range experiment.ExpectedAssignments {
-				expectedAssignments = append(expectedAssignments, assignment.boolValue)
+				expectedAssignments = append(expectedAssignments, assignment.BoolValue)
 			}
 			assert.Equal(t, expectedAssignments, booleanAssignments)
 		case "json":
 			expectedAssignments := []string{}
 			for _, assignment := range experiment.ExpectedAssignments {
-				expectedAssignments = append(expectedAssignments, assignment.stringValue)
+				expectedAssignments = append(expectedAssignments, assignment.StringValue)
 			}
 			assert.Equal(t, expectedAssignments, jsonAssignments)
 		case "numeric":
 			expectedAssignments := []float64{}
 			for _, assignment := range experiment.ExpectedAssignments {
-				expectedAssignments = append(expectedAssignments, assignment.numericValue)
+				expectedAssignments = append(expectedAssignments, assignment.NumericValue)
 			}
 			assert.Equal(t, expectedAssignments, numericAssignments)
 		case "string":
 			expectedAssignments := []string{}
 			for _, assignment := range experiment.ExpectedAssignments {
-				expectedAssignments = append(expectedAssignments, assignment.stringValue)
+				expectedAssignments = append(expectedAssignments, assignment.StringValue)
 			}
 			assert.Equal(t, expectedAssignments, stringAssignments)
 		}

eppoclient/value.go

@@ -2,6 +2,7 @@ package eppoclient
 
 import (
 	"encoding/json"
+	"fmt"
 )
 
 type ValueType int
@@ -14,79 +15,104 @@ const (
 )
 
 type Value struct {
-	valueType    ValueType
-	boolValue    bool
-	numericValue float64
-	stringValue  string
+	ValueType    ValueType `json:"valueType"`
+	BoolValue    bool      `json:"boolValue,omitempty"`
+	NumericValue float64   `json:"numericValue,omitempty"`
+	StringValue  string    `json:"stringValue,omitempty"`
 }
 
 func Null() Value {
-	return Value{valueType: NullType}
+	return Value{ValueType: NullType}
 }
 
 func Bool(value bool) Value {
-	return Value{valueType: BoolType, boolValue: value}
+	return Value{ValueType: BoolType, BoolValue: value}
 }
 
 func Numeric(value float64) Value {
-	return Value{valueType: NumericType, numericValue: value}
+	return Value{ValueType: NumericType, NumericValue: value}
 }
 
 func String(value string) Value {
-	return Value{valueType: StringType, stringValue: value}
+	return Value{ValueType: StringType, StringValue: value}
 }
 
-func (receiver *Value) UnmarshalJSON(data []byte) error {
-	var valueInterface interface{}
-	if err := json.Unmarshal(data, &valueInterface); err != nil {
-		return err
+func (v Value) GetBoolValue() bool {
+	return v.ValueType == BoolType && v.BoolValue
+}
+
+func (v Value) GetStringValue() string {
+	if v.ValueType == StringType {
+		return v.StringValue
 	}
-	*receiver = castInterfaceToValue(valueInterface)
+	return ""
+}
 
-	return nil
+func (v Value) GetNumericValue() float64 {
+	if v.ValueType == NumericType {
+		return v.NumericValue
+	}
+
+	return 0
 }
 
-func castInterfaceToValue(valueInterface interface{}) Value {
-	if valueInterface == nil {
-		return Null()
+func (v Value) MarshalJSON() ([]byte, error) {
+	switch v.ValueType {
+	case BoolType:
+		return json.Marshal(v.BoolValue)
+	case NumericType:
+		return json.Marshal(v.NumericValue)
+	case StringType:
+		return json.Marshal(v.StringValue)
+	case NullType:
+		return json.Marshal(nil)
+	default:
+		return nil, fmt.Errorf("unsupported value type")
 	}
-	switch v := valueInterface.(type) {
+}
+
+func (v *Value) UnmarshalJSON(data []byte) error {
+	// Unmarshal the data into an interface{} to check its type
+	var typedValue interface{}
+	if err := json.Unmarshal(data, &typedValue); err != nil {
+		return err
+	}
+
+	// Determine the type of typedValue and set the Value struct accordingly
+	switch value := typedValue.(type) {
 	case Value:
-		return v
+		*v = value
 	case *Value:
 		if v == nil {
-			return Null()
+			*v = Null()
 		}
-		return *v
+	case string:
+		*v = String(value)
+	case *string:
+		if v == nil {
+			*v = Null()
+		}
+	case float64:
+		// JSON numbers are float64 by default
+		*v = Numeric(value)
 	case bool:
-		return Bool(v)
+		*v = Bool(value)
 	case *bool:
 		if v == nil {
-			return Null()
+			*v = Null()
 		}
-		return Bool(*v)
+		*v = Bool(*value)
 	case map[string]interface{}:
-		out, _ := json.Marshal(&v)
-		return String(string(out))
-	case string:
-		return String(v)
-	case *string:
-		if v == nil {
-			return Null()
+		out, err := json.Marshal(typedValue)
+		if err != nil {
+			return err
 		}
-		return String(*v)
+		*v = String(string(out))
+	case nil:
+		*v = Null()
 	default:
-		return Null()
+		*v = Null()
 	}
-}
-
-func (v Value) StringValue() string {
-	if v.valueType == StringType {
-		return v.stringValue
-	}
-	return ""
-}
 
-func (v Value) BoolValue() bool {
-	return v.valueType == BoolType && v.boolValue
+	return nil
 }