From 4f5f1e0a3a663e36884658b278800ae28019d7f7 Mon Sep 17 00:00:00 2001 From: ewezy Date: Tue, 25 Oct 2022 17:22:44 +0800 Subject: [PATCH] Update treatment service with changes to experiment model struct --- management-service/models/experiment_test.go | 51 +++---- .../fetch_treatment_it_test.go | 21 +-- treatment-service/models/storage_test.go | 33 +++-- treatment-service/models/typeconverter.go | 137 ++++++++++++------ .../models/typeconverter_test.go | 71 +++++---- .../mockmanagement/controller/experiment.go | 24 +-- .../mockmanagement/server/server_test.go | 66 +++++---- .../mockmanagement/service/store.go | 30 ++-- 8 files changed, 259 insertions(+), 174 deletions(-) diff --git a/management-service/models/experiment_test.go b/management-service/models/experiment_test.go index c8830fde..93c18fc2 100644 --- a/management-service/models/experiment_test.go +++ b/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...)) } diff --git a/treatment-service/integration-test/fetch_treatment_it_test.go b/treatment-service/integration-test/fetch_treatment_it_test.go index ab0ad840..3ba247fd 100644 --- a/treatment-service/integration-test/fetch_treatment_it_test.go +++ b/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) } diff --git a/treatment-service/models/storage_test.go b/treatment-service/models/storage_test.go index 3d4ad331..2a1cf728 100644 --- a/treatment-service/models/storage_test.go +++ b/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{ diff --git a/treatment-service/models/typeconverter.go b/treatment-service/models/typeconverter.go index 1ce81c4f..c9b80860 100644 --- a/treatment-service/models/typeconverter.go +++ b/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: ×tamppb.Timestamp{Seconds: xpExperiment.StartTime.Unix()}, - EndTime: ×tamppb.Timestamp{Seconds: xpExperiment.EndTime.Unix()}, - UpdatedAt: ×tamppb.Timestamp{Seconds: xpExperiment.UpdatedAt.Unix()}, - Version: xpExperiment.Version, + StartTime: ×tamppb.Timestamp{Seconds: startTime.Unix()}, + EndTime: ×tamppb.Timestamp{Seconds: endTime.Unix()}, + UpdatedAt: ×tamppb.Timestamp{Seconds: updatedAt.Unix()}, + Version: version, }, nil } diff --git a/treatment-service/models/typeconverter_test.go b/treatment-service/models/typeconverter_test.go index 025378f4..2c6f0c81 100644 --- a/treatment-service/models/typeconverter_test.go +++ b/treatment-service/models/typeconverter_test.go @@ -70,6 +70,20 @@ func TestOpenAPIProjectSettingsSpecToProtobuf(t *testing.T) { } func TestOpenAPIExperimentSpecToProtobuf(t *testing.T) { + projectId := int64(1) + id := int64(2) + name := "experiment-1" + statusActive := schema.ExperimentStatusActive + statusInactive := schema.ExperimentStatusInactive + tierDefault := schema.ExperimentTierDefault + tierOverride := schema.ExperimentTierOverride + typeAB := schema.ExperimentTypeAB + typeSwitchback := schema.ExperimentTypeSwitchback + version := int64(2) + startTime := time.Date(2021, 1, 1, 2, 3, 4, 0, time.UTC) + endTime := time.Date(2022, 1, 1, 2, 3, 4, 0, time.UTC) + createdAt := time.Date(2020, 1, 1, 2, 3, 4, 0, time.UTC) + updatedAt := time.Date(2020, 2, 1, 2, 3, 4, 0, time.UTC) traffic100 := int32(100) interval := int32(60) segmentersType := map[string]schema.SegmenterType{ @@ -78,6 +92,7 @@ func TestOpenAPIExperimentSpecToProtobuf(t *testing.T) { pubsubCfg, _ := structpb.NewStruct(map[string]interface{}{ "key": "value", }) + tests := []struct { Name string Experiment schema.Experiment @@ -87,14 +102,14 @@ func TestOpenAPIExperimentSpecToProtobuf(t *testing.T) { { Name: "active default a/b experiment", Experiment: schema.Experiment{ - ProjectId: 1, - Id: 2, - Name: "experiment-1", - Segment: schema.ExperimentSegment{ + ProjectId: &projectId, + Id: &id, + Name: &name, + Segment: &schema.ExperimentSegment{ "string_segmenter": []interface{}{"ID"}, }, - Status: schema.ExperimentStatusActive, - Treatments: []schema.ExperimentTreatment{ + Status: &statusActive, + Treatments: &[]schema.ExperimentTreatment{ { Name: "default", Configuration: map[string]interface{}{ @@ -103,13 +118,13 @@ func TestOpenAPIExperimentSpecToProtobuf(t *testing.T) { Traffic: &traffic100, }, }, - Tier: schema.ExperimentTierDefault, - Type: schema.ExperimentTypeAB, - StartTime: time.Date(2021, 1, 1, 2, 3, 4, 0, time.UTC), - EndTime: time.Date(2022, 1, 1, 2, 3, 4, 0, time.UTC), - CreatedAt: time.Date(2020, 1, 1, 2, 3, 4, 0, time.UTC), - UpdatedAt: time.Date(2020, 2, 1, 2, 3, 4, 0, time.UTC), - Version: 2, + Tier: &tierDefault, + Type: &typeAB, + StartTime: &startTime, + EndTime: &endTime, + CreatedAt: &createdAt, + UpdatedAt: &updatedAt, + Version: &version, }, Expected: &pubsub.Experiment{ ProjectId: 1, @@ -142,24 +157,24 @@ func TestOpenAPIExperimentSpecToProtobuf(t *testing.T) { { Name: "inactive override switchback experiment", Experiment: schema.Experiment{ - ProjectId: 3, - Id: 4, + ProjectId: &projectId, + Id: &id, Interval: &interval, - Name: "experiment-2", - Status: schema.ExperimentStatusInactive, - Tier: schema.ExperimentTierOverride, - Type: schema.ExperimentTypeSwitchback, - StartTime: time.Date(2021, 1, 1, 2, 3, 4, 0, time.UTC), - EndTime: time.Date(2022, 1, 1, 2, 3, 4, 0, time.UTC), - CreatedAt: time.Date(2020, 1, 1, 2, 3, 4, 0, time.UTC), - UpdatedAt: time.Date(2020, 2, 1, 2, 3, 4, 0, time.UTC), - Version: 1, + Name: &name, + Status: &statusInactive, + Tier: &tierOverride, + Type: &typeSwitchback, + StartTime: &startTime, + EndTime: &endTime, + CreatedAt: &createdAt, + UpdatedAt: &updatedAt, + Version: &version, }, Expected: &pubsub.Experiment{ - ProjectId: 3, - Id: 4, + ProjectId: 1, + Id: 2, Interval: 60, - Name: "experiment-2", + Name: "experiment-1", Segments: map[string]*_segmenters.ListSegmenterValue{}, Status: pubsub.Experiment_Inactive, Treatments: []*pubsub.ExperimentTreatment{}, @@ -168,7 +183,7 @@ func TestOpenAPIExperimentSpecToProtobuf(t *testing.T) { StartTime: timestamppb.New(time.Date(2021, 1, 1, 2, 3, 4, 0, time.UTC)), EndTime: timestamppb.New(time.Date(2022, 1, 1, 2, 3, 4, 0, time.UTC)), UpdatedAt: timestamppb.New(time.Date(2020, 2, 1, 2, 3, 4, 0, time.UTC)), - Version: 1, + Version: 2, }, }, } diff --git a/treatment-service/testhelper/mockmanagement/controller/experiment.go b/treatment-service/testhelper/mockmanagement/controller/experiment.go index 80e86b36..4821515e 100644 --- a/treatment-service/testhelper/mockmanagement/controller/experiment.go +++ b/treatment-service/testhelper/mockmanagement/controller/experiment.go @@ -39,17 +39,17 @@ func (e Experiment) CreateExperiment(w http.ResponseWriter, r *http.Request, pro return } experiment := schema.Experiment{ - ProjectId: projectId, + ProjectId: &projectId, Description: requestBody.Description, - EndTime: requestBody.EndTime, + EndTime: &requestBody.EndTime, Interval: requestBody.Interval, - Name: requestBody.Name, - Segment: requestBody.Segment, - StartTime: requestBody.StartTime, - Status: requestBody.Status, - Treatments: requestBody.Treatments, - Type: requestBody.Type, - UpdatedBy: *requestBody.UpdatedBy, + Name: &requestBody.Name, + Segment: &requestBody.Segment, + StartTime: &requestBody.StartTime, + Status: &requestBody.Status, + Treatments: &requestBody.Treatments, + Type: &requestBody.Type, + UpdatedBy: requestBody.UpdatedBy, } createdExperiment, err := e.ExperimentStore.CreateExperiment(experiment) if err != nil { @@ -86,7 +86,8 @@ func (e Experiment) EnableExperiment(w http.ResponseWriter, r *http.Request, pro NotFound(w, err) return } - experiment.Status = schema.ExperimentStatusActive + status := schema.ExperimentStatusActive + experiment.Status = &status updatedExperiment, err := e.ExperimentStore.UpdateExperiment(projectId, experimentId, experiment) if err != nil { BadRequest(w, err) @@ -102,7 +103,8 @@ func (e Experiment) DisableExperiment(w http.ResponseWriter, r *http.Request, pr NotFound(w, err) return } - experiment.Status = schema.ExperimentStatusInactive + status := schema.ExperimentStatusInactive + experiment.Status = &status updatedExperiment, err := e.ExperimentStore.UpdateExperiment(projectId, experimentId, experiment) if err != nil { BadRequest(w, err) diff --git a/treatment-service/testhelper/mockmanagement/server/server_test.go b/treatment-service/testhelper/mockmanagement/server/server_test.go index 9b002c56..5c9df2fe 100644 --- a/treatment-service/testhelper/mockmanagement/server/server_test.go +++ b/treatment-service/testhelper/mockmanagement/server/server_test.go @@ -77,24 +77,28 @@ func newRandomProjectSettingsOfSize(size int) []schema.ProjectSettings { func newRandomExperiment(projectId int64) schema.Experiment { description := randomString() + endTime := time.Now().Add(time.Duration(24) * time.Hour) interval := int32(rand.Int()) + name := randomString() + startTime := time.Now() daysOfWeek := []interface{}{int64(rand.Intn(7))} hoursOfDay := []interface{}{int64(rand.Intn(24))} s2Ids := []interface{}{int64(rand.Int())} traffic := int32(rand.Int()) + experimentType := newRandomExperimentType() return schema.Experiment{ - ProjectId: projectId, + ProjectId: &projectId, Description: &description, - EndTime: time.Now().Add(time.Duration(24) * time.Hour), + EndTime: &endTime, Interval: &interval, - Name: randomString(), - Segment: schema.ExperimentSegment{ + Name: &name, + Segment: &schema.ExperimentSegment{ "days_of_week": daysOfWeek, "hours_of_day": hoursOfDay, "s2_ids": s2Ids, }, - StartTime: time.Now(), - Treatments: []schema.ExperimentTreatment{ + StartTime: &startTime, + Treatments: &[]schema.ExperimentTreatment{ { Configuration: map[string]interface{}{ "config": randomBool(), @@ -103,7 +107,7 @@ func newRandomExperiment(projectId int64) schema.Experiment { Traffic: &traffic, }, }, - Type: newRandomExperimentType(), + Type: &experimentType, } } @@ -220,13 +224,13 @@ func (suite *ManagementServiceTestSuite) TestExperimentCreation() { updater := randomString() body := management.CreateExperimentJSONRequestBody{ Description: expectedExperiment.Description, - EndTime: expectedExperiment.EndTime, + EndTime: *expectedExperiment.EndTime, Interval: expectedExperiment.Interval, - Name: expectedExperiment.Name, - Segment: expectedExperiment.Segment, - StartTime: expectedExperiment.StartTime, - Treatments: expectedExperiment.Treatments, - Type: expectedExperiment.Type, + Name: *expectedExperiment.Name, + Segment: *expectedExperiment.Segment, + StartTime: *expectedExperiment.StartTime, + Treatments: *expectedExperiment.Treatments, + Type: *expectedExperiment.Type, UpdatedBy: &updater, } response, err := suite.client.CreateExperimentWithResponse(suite.ctx, 1, body) @@ -236,14 +240,14 @@ func (suite *ManagementServiceTestSuite) TestExperimentCreation() { suite.Require().Equal(expectedExperiment.Name, createdExperiment.Name) suite.Require().Len(suite.store.Experiments, 1) suite.Require().Equal(suite.store.Experiments[0].Name, createdExperiment.Name) - suite.Require().Equal(schema.ExperimentStatusActive, createdExperiment.Status) + suite.Require().Equal(schema.ExperimentStatusActive, *createdExperiment.Status) suite.Require().Equal(expectedExperiment.Treatments, createdExperiment.Treatments) - suite.Require().Equal(updater, createdExperiment.UpdatedBy) + suite.Require().Equal(updater, *createdExperiment.UpdatedBy) publishedUpdate, err := getLastPublishedUpdate(suite.ctx, 1*time.Second, suite.subscription) suite.Require().NoError(err) suite.Require().NotNil(publishedUpdate.Update) - suite.Require().Equal(expectedExperiment.Name, publishedUpdate.GetExperimentCreated().GetExperiment().Name) + suite.Require().Equal(*expectedExperiment.Name, publishedUpdate.GetExperimentCreated().GetExperiment().Name) } func (suite *ManagementServiceTestSuite) TestListExperiment() { @@ -259,9 +263,10 @@ func (suite *ManagementServiceTestSuite) TestListExperiment() { func (suite *ManagementServiceTestSuite) TestGetExperiment() { projectId := suite.projectSettings[0].ProjectId experiment := newRandomExperiment(projectId) - experiment.Id = int64(rand.Int()) + id := int64(rand.Int()) + experiment.Id = &id suite.store.Experiments = []schema.Experiment{experiment} - response, err := suite.client.GetExperimentWithResponse(suite.ctx, projectId, experiment.Id) + response, err := suite.client.GetExperimentWithResponse(suite.ctx, projectId, *experiment.Id) suite.Require().NoError(err) suite.Require().Equal(experiment.Treatments, response.JSON200.Data.Treatments) } @@ -269,13 +274,14 @@ func (suite *ManagementServiceTestSuite) TestGetExperiment() { func (suite *ManagementServiceTestSuite) TestExperimentUpdate() { projectId := suite.projectSettings[0].ProjectId experiment := newRandomExperiment(projectId) - experiment.Id = int64(rand.Int()) + id := int64(rand.Int()) + experiment.Id = &id suite.store.Experiments = []schema.Experiment{experiment} newDescription := "updated" params := management.UpdateExperimentJSONRequestBody{ Description: &newDescription, } - response, err := suite.client.UpdateExperimentWithResponse(suite.ctx, projectId, experiment.Id, params) + response, err := suite.client.UpdateExperimentWithResponse(suite.ctx, projectId, *experiment.Id, params) suite.Require().NoError(err) suite.Require().Equal(params.Description, response.JSON200.Data.Description) } @@ -309,34 +315,38 @@ func (suite *ManagementServiceTestSuite) TestUpdateProjectSettings() { func (suite *ManagementServiceTestSuite) TestEnableExperiment() { projectId := suite.projectSettings[0].ProjectId experiment := newRandomExperiment(projectId) - experiment.Id = int64(rand.Int()) - experiment.Status = schema.ExperimentStatusInactive + id := int64(rand.Int()) + experiment.Id = &id + status := schema.ExperimentStatusInactive + experiment.Status = &status suite.store.Experiments = []schema.Experiment{experiment} - response, err := suite.client.EnableExperimentWithResponse(suite.ctx, projectId, experiment.Id) + response, err := suite.client.EnableExperimentWithResponse(suite.ctx, projectId, *experiment.Id) suite.Require().NoError(err) suite.Require().Equal(http.StatusOK, response.StatusCode()) publishedUpdate, err := getLastPublishedUpdate(suite.ctx, 1*time.Second, suite.subscription) suite.Require().NoError(err) suite.Require().NotNil(publishedUpdate.Update) - suite.Require().Equal(experiment.Id, publishedUpdate.GetExperimentUpdated().GetExperiment().Id) + suite.Require().Equal(*experiment.Id, publishedUpdate.GetExperimentUpdated().GetExperiment().Id) suite.Require().Equal(_pubsub.Experiment_Active, publishedUpdate.GetExperimentUpdated().GetExperiment().Status) } func (suite *ManagementServiceTestSuite) TestDisableExperiment() { projectId := suite.projectSettings[0].ProjectId experiment := newRandomExperiment(projectId) - experiment.Id = int64(rand.Int()) - experiment.Status = schema.ExperimentStatusActive + id := int64(rand.Int()) + experiment.Id = &id + status := schema.ExperimentStatusActive + experiment.Status = &status suite.store.Experiments = []schema.Experiment{experiment} - response, err := suite.client.DisableExperimentWithResponse(suite.ctx, projectId, experiment.Id) + response, err := suite.client.DisableExperimentWithResponse(suite.ctx, projectId, *experiment.Id) suite.Require().NoError(err) suite.Require().Equal(http.StatusOK, response.StatusCode()) publishedUpdate, err := getLastPublishedUpdate(suite.ctx, 1*time.Second, suite.subscription) suite.Require().NoError(err) suite.Require().NotNil(publishedUpdate.Update) - suite.Require().Equal(experiment.Id, publishedUpdate.GetExperimentUpdated().GetExperiment().Id) + suite.Require().Equal(*experiment.Id, publishedUpdate.GetExperimentUpdated().GetExperiment().Id) suite.Require().Equal(_pubsub.Experiment_Inactive, publishedUpdate.GetExperimentUpdated().GetExperiment().Status) } diff --git a/treatment-service/testhelper/mockmanagement/service/store.go b/treatment-service/testhelper/mockmanagement/service/store.go index e8fc2061..78214a09 100644 --- a/treatment-service/testhelper/mockmanagement/service/store.go +++ b/treatment-service/testhelper/mockmanagement/service/store.go @@ -37,7 +37,7 @@ func (i *InMemoryStore) GetExperiment(projectId int64, experimentId int64) (sche i.RLock() defer i.RUnlock() for _, experiment := range i.Experiments { - if experiment.ProjectId == projectId && experiment.Id == experimentId { + if *experiment.ProjectId == projectId && *experiment.Id == experimentId { return experiment, nil } } @@ -52,7 +52,7 @@ func (i *InMemoryStore) ListExperiments(projectId int64, params api.ListExperime defer i.RUnlock() projectExperiments := make([]schema.Experiment, 0) for _, experiment := range i.Experiments { - if experiment.ProjectId == projectId { + if *experiment.ProjectId == projectId { projectExperiments = append(projectExperiments, experiment) } } @@ -62,10 +62,15 @@ func (i *InMemoryStore) ListExperiments(projectId int64, params api.ListExperime func (i *InMemoryStore) CreateExperiment(experiment schema.Experiment) (schema.Experiment, error) { i.Lock() defer i.Unlock() - experiment.Id = int64(len(i.Experiments)) + 1 - experiment.Status = schema.ExperimentStatusActive - experiment.UpdatedAt = time.Now() - experiment.Version = 1 + id := int64(len(i.Experiments)) + 1 + status := schema.ExperimentStatusActive + updatedAt := time.Now() + version := int64(1) + + experiment.Id = &id + experiment.Status = &status + experiment.UpdatedAt = &updatedAt + experiment.Version = &version i.Experiments = append(i.Experiments, experiment) err := i.MessageQueue.PublishNewExperiment(experiment, i.SegmentersTypes) @@ -79,10 +84,17 @@ func (i *InMemoryStore) CreateExperiment(experiment schema.Experiment) (schema.E func (i *InMemoryStore) UpdateExperiment(projectId int64, experimentId int64, experiment schema.Experiment) (schema.Experiment, error) { i.Lock() defer i.Unlock() - experiment.UpdatedAt = time.Now() + updatedAt := time.Now() + + experiment.UpdatedAt = &updatedAt for index, e := range i.Experiments { - if experiment.ProjectId == projectId && e.Id == experimentId { - experiment.Version = e.Version + 1 + if experiment.ProjectId != nil && e.Id != nil && *experiment.ProjectId == projectId && *e.Id == experimentId { + var version int64 + if e.Version != nil { + version = *e.Version + } + version = version + 1 + experiment.Version = &version i.Experiments[index] = experiment } }