Update treatment service with changes to experiment model struct

management-service/models/experiment_test.go

@@ -66,19 +66,6 @@ func TestExperimentToApiSchema(t *testing.T) {
 	statusFriendly := schema.ExperimentStatusFriendlyCompleted
 	experimentType := schema.ExperimentTypeSwitchback
 	tier := schema.ExperimentTierDefault
-	treatments := []schema.ExperimentTreatment{
-		{
-			Configuration: map[string]interface{}{
-				"config-1": "value",
-				"config-2": 2,
-			},
-			Name:    "control",
-			Traffic: &testExperimentTraffic,
-		},
-	}
-	segment := schema.ExperimentSegment{
-		"string_segmenter": []string{"seg-1"},
-	}
 	version := int64(2)
 
 	assert.Equal(t, schema.Experiment{
@@ -96,9 +83,20 @@ func TestExperimentToApiSchema(t *testing.T) {
 		StatusFriendly: &statusFriendly,
 		Type:           &experimentType,
 		Tier:           &tier,
-		Treatments:     &treatments,
-		Segment:        &segment,
-		Version:        &version,
+		Treatments: &[]schema.ExperimentTreatment{
+			{
+				Configuration: map[string]interface{}{
+					"config-1": "value",
+					"config-2": 2,
+				},
+				Name:    "control",
+				Traffic: &testExperimentTraffic,
+			},
+		},
+		Segment: &schema.ExperimentSegment{
+			"string_segmenter": []string{"seg-1"},
+		},
+		Version: &version,
 	}, testExperiment.ToApiSchema(segmenterTypes))
 }
 
@@ -126,16 +124,6 @@ func TestExperimentToApiSchemaWithFields(t *testing.T) {
 	statusFriendly := schema.ExperimentStatusFriendlyCompleted
 	experimentType := schema.ExperimentTypeSwitchback
 	tier := schema.ExperimentTierDefault
-	treatments := []schema.ExperimentTreatment{
-		{
-			Configuration: map[string]interface{}{
-				"config-1": "value",
-				"config-2": 2,
-			},
-			Name:    "control",
-			Traffic: &testExperimentTraffic,
-		},
-	}
 
 	assert.Equal(t, schema.Experiment{
 		Id:             &id,
@@ -146,7 +134,16 @@ func TestExperimentToApiSchemaWithFields(t *testing.T) {
 		StatusFriendly: &statusFriendly,
 		Type:           &experimentType,
 		Tier:           &tier,
-		Treatments:     &treatments,
+		Treatments: &[]schema.ExperimentTreatment{
+			{
+				Configuration: map[string]interface{}{
+					"config-1": "value",
+					"config-2": 2,
+				},
+				Name:    "control",
+				Traffic: &testExperimentTraffic,
+			},
+		},
 	}, testExperiment.ToApiSchema(segmenterTypes, fields...))
 }
 

treatment-service/integration-test/fetch_treatment_it_test.go

@@ -204,23 +204,24 @@ func generateExperiments() []schema.Experiment {
 		experimentType := val["type"].(schema.ExperimentType)
 		startTime := val["start-time"].(time.Time)
 		endTime := val["end-time"].(time.Time)
+		version := int64(1)
 
 		experiment := schema.Experiment{
-			Id:          id,
-			ProjectId:   projectId,
+			Id:          &id,
+			ProjectId:   &projectId,
 			Description: &description,
-			EndTime:     endTime,
+			EndTime:     &endTime,
 			Interval:    &interval,
-			Name:        name,
-			Segment: schema.ExperimentSegment{
+			Name:        &name,
+			Segment: &schema.ExperimentSegment{
 				"days_of_week": &daysOfWeek,
 				"hours_of_day": &hoursOfDay,
 				"s2_ids":       &s2Ids,
 			},
-			StartTime:  startTime,
-			Treatments: treatments,
-			Type:       experimentType,
-			Version:    int64(1),
+			StartTime:  &startTime,
+			Treatments: &treatments,
+			Type:       &experimentType,
+			Version:    &version,
 		}
 		experiments = append(experiments, experiment)
 	}
@@ -811,5 +812,5 @@ func (suite *TreatmentServiceTestSuite) TestLocalStorage() {
 
 	resp, err := suite.managementServiceClient.GetExperimentWithResponse(suite.ctx, 1, 1)
 	suite.Require().NoError(err)
-	suite.Require().Equal(resp.JSON200.Data.Name, storage.Experiments[1][0].Experiment.Name)
+	suite.Require().Equal(storage.Experiments[1][0].Experiment.Name, *resp.JSON200.Data.Name)
 }

treatment-service/models/storage_test.go

@@ -5,7 +5,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"math/rand"
 	"net/http"
 	"os"
@@ -51,18 +51,25 @@ func newTestXPExperiment(
 		{Configuration: make(map[string]interface{}), Name: "default", Traffic: &traffic},
 	}
 
+	id := int64(rand.Intn(100))
+	nameString := name.String()
+	status := schema.ExperimentStatusActive
+	experimentType := schema.ExperimentTypeAB
+	updatedAt := time.Time{}
+	updatedBy := ""
+
 	return schema.Experiment{
-		ProjectId:  projectId,
-		Id:         int64(rand.Intn(100)),
-		StartTime:  startTime,
-		EndTime:    endTime,
-		Name:       name.String(),
-		Status:     "active",
-		Segment:    segment,
-		Treatments: treatments,
-		Type:       "A/B",
-		UpdatedAt:  time.Time{},
-		UpdatedBy:  "",
+		ProjectId:  &projectId,
+		Id:         &id,
+		StartTime:  &startTime,
+		EndTime:    &endTime,
+		Name:       &nameString,
+		Status:     &status,
+		Segment:    &segment,
+		Treatments: &treatments,
+		Type:       &experimentType,
+		UpdatedAt:  &updatedAt,
+		UpdatedBy:  &updatedBy,
 		Interval:   &interval,
 	}
 }
@@ -110,7 +117,7 @@ func (suite *LocalStorageLookupSuite) SetupTest() {
 		Return(&http.Response{
 			StatusCode: 200,
 			Header:     map[string][]string{"Content-Type": {"json"}},
-			Body:       ioutil.NopCloser(bytes.NewBufferString(`{"data" : []}`)),
+			Body:       io.NopCloser(bytes.NewBufferString(`{"data" : []}`)),
 		}, nil)
 
 	suite.storage = LocalStorage{

treatment-service/models/typeconverter.go

@@ -2,6 +2,7 @@ package models
 
 import (
 	"reflect"
+	"time"
 
 	"github.com/caraml-dev/xp/common/api/schema"
 	_pubsub "github.com/caraml-dev/xp/common/pubsub"
@@ -66,72 +67,112 @@ func OpenAPIExperimentSpecToProtobuf(
 		"default": _pubsub.Experiment_Default, "override": _pubsub.Experiment_Override,
 	}
 
+	var status _pubsub.Experiment_Status
+	if xpExperiment.Status != nil {
+		status = statusConverter[*xpExperiment.Status]
+	}
+
+	var experimentType _pubsub.Experiment_Type
+	if xpExperiment.Type != nil {
+		experimentType = typeConverter[*xpExperiment.Type]
+	}
+
+	var tier _pubsub.Experiment_Tier
+	if xpExperiment.Tier != nil {
+		tier = tierConverter[*xpExperiment.Tier]
+	}
+
 	segments := make(map[string]*_segmenters.ListSegmenterValue)
-	for key, val := range xpExperiment.Segment {
-		vals := val.([]interface{})
-		switch segmentersType[key] {
-		case "string":
-			stringVals := []string{}
-			for _, val := range vals {
-				stringVals = append(stringVals, val.(string))
-			}
-			segments[key] = _utils.StringSliceToListSegmenterValue(&stringVals)
-		case "integer":
-			intVals := []int64{}
-			for _, val := range vals {
-				reflectedVal := reflect.ValueOf(val)
-				switch reflectedVal.Kind() {
-				case reflect.Float32, reflect.Float64:
-					intVals = append(intVals, int64(reflectedVal.Float()))
-				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-					intVals = append(intVals, reflectedVal.Int())
+
+	if xpExperiment.Segment != nil {
+		for key, val := range *xpExperiment.Segment {
+			vals := val.([]interface{})
+			switch segmentersType[key] {
+			case "string":
+				stringVals := []string{}
+				for _, val := range vals {
+					stringVals = append(stringVals, val.(string))
 				}
+				segments[key] = _utils.StringSliceToListSegmenterValue(&stringVals)
+			case "integer":
+				intVals := []int64{}
+				for _, val := range vals {
+					reflectedVal := reflect.ValueOf(val)
+					switch reflectedVal.Kind() {
+					case reflect.Float32, reflect.Float64:
+						intVals = append(intVals, int64(reflectedVal.Float()))
+					case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+						intVals = append(intVals, reflectedVal.Int())
+					}
+				}
+				segments[key] = _utils.Int64ListToListSegmenterValue(&intVals)
+			case "real":
+				floatVals := []float64{}
+				for _, val := range vals {
+					floatVals = append(floatVals, val.(float64))
+				}
+				segments[key] = _utils.FloatListToListSegmenterValue(&floatVals)
+			case "bool":
+				boolVals := []bool{}
+				for _, val := range vals {
+					boolVals = append(boolVals, val.(bool))
+				}
+				segments[key] = _utils.BoolSliceToListSegmenterValue(&boolVals)
+			default:
+				segments[key] = nil
 			}
-			segments[key] = _utils.Int64ListToListSegmenterValue(&intVals)
-		case "real":
-			floatVals := []float64{}
-			for _, val := range vals {
-				floatVals = append(floatVals, val.(float64))
-			}
-			segments[key] = _utils.FloatListToListSegmenterValue(&floatVals)
-		case "bool":
-			boolVals := []bool{}
-			for _, val := range vals {
-				boolVals = append(boolVals, val.(bool))
-			}
-			segments[key] = _utils.BoolSliceToListSegmenterValue(&boolVals)
-		default:
-			segments[key] = nil
 		}
 	}
 
 	treatments := make([]*_pubsub.ExperimentTreatment, 0)
-	for _, t := range xpExperiment.Treatments {
-		treatment, err := openAPIExperimentTreatmentSpecToProtobuf(t)
-		if err != nil {
-			return nil, err
+	if xpExperiment.Treatments != nil {
+		for _, t := range *xpExperiment.Treatments {
+			treatment, err := openAPIExperimentTreatmentSpecToProtobuf(t)
+			if err != nil {
+				return nil, err
+			}
+			treatments = append(treatments, treatment)
 		}
-		treatments = append(treatments, treatment)
 	}
 	interval := int32(0)
 	if xpExperiment.Interval != nil {
 		interval = *xpExperiment.Interval
 	}
 
+	var version int64
+	if xpExperiment.Version != nil {
+		version = *xpExperiment.Version
+	}
+
+	var startTime time.Time
+	if xpExperiment.StartTime != nil {
+		startTime = *xpExperiment.StartTime
+	}
+
+	var endTime time.Time
+	if xpExperiment.EndTime != nil {
+		endTime = *xpExperiment.EndTime
+	}
+
+	var updatedAt time.Time
+	if xpExperiment.UpdatedAt != nil {
+		updatedAt = *xpExperiment.UpdatedAt
+	}
+
 	return &_pubsub.Experiment{
-		Id:         xpExperiment.Id,
-		ProjectId:  xpExperiment.ProjectId,
-		Status:     statusConverter[xpExperiment.Status],
-		Name:       xpExperiment.Name,
-		Type:       typeConverter[xpExperiment.Type],
-		Tier:       tierConverter[xpExperiment.Tier],
+		Id:         *xpExperiment.Id,
+		ProjectId:  *xpExperiment.ProjectId,
+		Status:     status,
+		Name:       *xpExperiment.Name,
+		Type:       experimentType,
+		Tier:       tier,
 		Interval:   interval,
 		Segments:   segments,
 		Treatments: treatments,
-		StartTime:  &timestamppb.Timestamp{Seconds: xpExperiment.StartTime.Unix()},
-		EndTime:    &timestamppb.Timestamp{Seconds: xpExperiment.EndTime.Unix()},
-		UpdatedAt:  &timestamppb.Timestamp{Seconds: xpExperiment.UpdatedAt.Unix()},
-		Version:    xpExperiment.Version,
+		StartTime:  &timestamppb.Timestamp{Seconds: startTime.Unix()},
+		EndTime:    &timestamppb.Timestamp{Seconds: endTime.Unix()},
+		UpdatedAt:  &timestamppb.Timestamp{Seconds: updatedAt.Unix()},
+		Version:    version,
 	}, nil
 }