refac(config): Make project config a top-level object we pass around. (#39)

Author: Michael Ng

optimizely/client/client.go

@@ -19,7 +19,7 @@ package client
 import (
 	"errors"
 
-	"github.com/optimizely/go-sdk/optimizely/config"
+	"github.com/optimizely/go-sdk/optimizely"
 	"github.com/optimizely/go-sdk/optimizely/decision"
 	"github.com/optimizely/go-sdk/optimizely/entities"
 	"github.com/optimizely/go-sdk/optimizely/logging"
@@ -29,7 +29,7 @@ var logger = logging.GetLogger("Client")
 
 // OptimizelyClient is the entry point to the Optimizely SDK
 type OptimizelyClient struct {
-	configManager   config.ProjectConfigManager
+	configManager   optimizely.ProjectConfigManager
 	decisionService decision.DecisionService
 	isValid         bool
 }
@@ -44,14 +44,9 @@ func (o *OptimizelyClient) IsFeatureEnabled(featureKey string, userContext entit
 	}
 
 	projectConfig := o.configManager.GetConfig()
-	feature, err := projectConfig.GetFeatureByKey(featureKey)
-	if err != nil {
-		return false, err
-	}
-
-	// @TODO(mng): Include assigned group for mutex support
 	featureDecisionContext := decision.FeatureDecisionContext{
-		Feature: feature,
+		FeatureKey:    featureKey,
+		ProjectConfig: projectConfig,
 	}
 
 	featureDecision, err := o.decisionService.GetFeatureDecision(featureDecisionContext, userContext)
@@ -61,5 +56,5 @@ func (o *OptimizelyClient) IsFeatureEnabled(featureKey string, userContext entit
 	}
 
 	// @TODO(mng): send impression event
-	return featureDecision.FeatureEnabled, nil
+	return featureDecision.Variation.FeatureEnabled, nil
 }

optimizely/client/client_test.go

@@ -22,14 +22,14 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	"github.com/optimizely/go-sdk/optimizely/config"
+	"github.com/optimizely/go-sdk/optimizely"
 	"github.com/optimizely/go-sdk/optimizely/decision"
 	"github.com/optimizely/go-sdk/optimizely/entities"
 	"github.com/stretchr/testify/mock"
 )
 
 type MockProjectConfig struct {
-	config.ProjectConfig
+	optimizely.ProjectConfig
 	mock.Mock
 }
 
@@ -42,9 +42,9 @@ type MockProjectConfigManager struct {
 	mock.Mock
 }
 
-func (p *MockProjectConfigManager) GetConfig() config.ProjectConfig {
+func (p *MockProjectConfigManager) GetConfig() optimizely.ProjectConfig {
 	args := p.Called()
-	return args.Get(0).(config.ProjectConfig)
+	return args.Get(0).(optimizely.ProjectConfig)
 }
 
 type MockDecisionService struct {
@@ -58,37 +58,31 @@ func (m *MockDecisionService) GetFeatureDecision(decisionContext decision.Featur
 
 func TestIsFeatureEnabled(t *testing.T) {
 	testUserContext := entities.UserContext{ID: "test_user_1"}
-	testFeatureKey := "test_feature_key"
-	testFeature := entities.Feature{
-		Key: testFeatureKey,
-		FeatureExperiments: []entities.Experiment{
-			entities.Experiment{
-				ID: "111111",
-				Variations: map[string]entities.Variation{
-					"22222": entities.Variation{
-						ID:             "22222",
-						Key:            "22222",
-						FeatureEnabled: true,
-					},
-				},
-			},
-		},
+	testVariation := entities.Variation{
+		ID:             "22222",
+		Key:            "22222",
+		FeatureEnabled: true,
 	}
+	testExperiment := entities.Experiment{
+		ID:         "111111",
+		Variations: map[string]entities.Variation{"22222": testVariation},
+	}
+	testFeatureKey := "test_feature_key"
 
 	// Test happy path
 	mockConfig := new(MockProjectConfig)
-	mockConfig.On("GetFeatureByKey", testFeatureKey).Return(testFeature, nil)
-
 	mockConfigManager := new(MockProjectConfigManager)
 	mockConfigManager.On("GetConfig").Return(mockConfig)
 
 	// Set up the mock decision service and its return value
 	testDecisionContext := decision.FeatureDecisionContext{
-		Feature: testFeature,
+		FeatureKey:    testFeatureKey,
+		ProjectConfig: mockConfig,
 	}
 
 	expectedFeatureDecision := decision.FeatureDecision{
-		FeatureEnabled: true,
+		Experiment: testExperiment,
+		Variation:  testVariation,
 		Decision: decision.Decision{
 			DecisionMade: true,
 		},
@@ -127,15 +121,19 @@ func TestIsFeatureEnabledErrorCases(t *testing.T) {
 	mockConfigManager.AssertNotCalled(t, "GetFeatureByKey")
 	mockDecisionService.AssertNotCalled(t, "GetFeatureDecision")
 
-	// Test invalid feature key
+	// Test decision serviceinvalid feature key
 	expectedError := errors.New("Invalid feature key")
 	mockConfig := new(MockProjectConfig)
-	mockConfig.On("GetFeatureByKey", testFeatureKey).Return(entities.Feature{}, expectedError)
 
 	mockConfigManager = new(MockProjectConfigManager)
 	mockConfigManager.On("GetConfig").Return(mockConfig)
-	mockDecisionService = new(MockDecisionService)
 
+	testFeatureDecisionContext := decision.FeatureDecisionContext{
+		FeatureKey:    testFeatureKey,
+		ProjectConfig: mockConfig,
+	}
+	mockDecisionService = new(MockDecisionService)
+	mockDecisionService.On("GetFeatureDecision", testFeatureDecisionContext, testUserContext).Return(decision.FeatureDecision{}, expectedError)
 	client = OptimizelyClient{
 		configManager:   mockConfigManager,
 		decisionService: mockDecisionService,
@@ -146,4 +144,6 @@ func TestIsFeatureEnabledErrorCases(t *testing.T) {
 		assert.Equal(t, expectedError, err)
 	}
 	assert.False(t, result)
+	mockConfigManager.AssertExpectations(t)
+	mockDecisionService.AssertExpectations(t)
 }

optimizely/client/factory.go

@@ -17,6 +17,7 @@
 package client
 
 import (
+	"github.com/optimizely/go-sdk/optimizely"
 	"github.com/optimizely/go-sdk/optimizely/config"
 	"github.com/optimizely/go-sdk/optimizely/config/datafileProjectConfig"
 	"github.com/optimizely/go-sdk/optimizely/decision"
@@ -30,8 +31,8 @@ type OptimizelyFactory struct {
 
 // Client returns a client initialized with the defaults
 func (f OptimizelyFactory) Client() OptimizelyClient {
-	var projectConfig config.ProjectConfig
-	var configManager config.ProjectConfigManager
+	var projectConfig optimizely.ProjectConfig
+	var configManager optimizely.ProjectConfigManager
 	if f.Datafile != nil {
 		projectConfig = datafileProjectConfig.NewDatafileProjectConfig(f.Datafile)
 

optimizely/config/datafileProjectConfig/config.go

@@ -29,42 +29,42 @@ var logger = logging.GetLogger("DatafileProjectConfig")
 
 // DatafileProjectConfig is a project config backed by a datafile
 type DatafileProjectConfig struct {
+	accountID            string
+	anonymizeIP          bool
+	attributeKeyToIDMap  map[string]string
 	audienceMap          map[string]entities.Audience
-	experimentMap        map[string]entities.Experiment
+	botFiltering         bool
+	eventMap             map[string]entities.Event
 	experimentKeyToIDMap map[string]string
+	experimentMap        map[string]entities.Experiment
 	featureMap           map[string]entities.Feature
-	attributeKeyToIDMap  map[string]string
-	eventMap             map[string]entities.Event
-	projectID			 string
-	revision			 string
-	accountID			 string
-	anonymizeIP			 bool
-	botFiltering		 bool
-
+	groupMap             map[string]entities.Group
+	projectID            string
+	revision             string
 }
 
-func (config DatafileProjectConfig) GetProjectID() string {
-	return config.projectID
+func (c DatafileProjectConfig) GetProjectID() string {
+	return c.projectID
 }
 
-func (config DatafileProjectConfig) GetRevision() string {
-	return config.revision
+func (c DatafileProjectConfig) GetRevision() string {
+	return c.revision
 }
 
-func (config DatafileProjectConfig) GetAccountID() string {
-	return config.accountID
+func (c DatafileProjectConfig) GetAccountID() string {
+	return c.accountID
 }
 
-func (config DatafileProjectConfig) GetAnonymizeIP() bool {
-	return config.anonymizeIP
+func (c DatafileProjectConfig) GetAnonymizeIP() bool {
+	return c.anonymizeIP
 }
 
-func (config DatafileProjectConfig) GetAttributeID(key string) string {
-	return config.attributeKeyToIDMap[key]
+func (c DatafileProjectConfig) GetAttributeID(key string) string {
+	return c.attributeKeyToIDMap[key]
 }
 
-func (config DatafileProjectConfig) GetBotFiltering() bool {
-	return config.botFiltering
+func (c DatafileProjectConfig) GetBotFiltering() bool {
+	return c.botFiltering
 }
 
 // NewDatafileProjectConfig initializes a new datafile from a json byte array using the default JSON datafile parser
@@ -86,8 +86,8 @@ func NewDatafileProjectConfig(jsonDatafile []byte) *DatafileProjectConfig {
 }
 
 // GetEventByKey returns the event with the given key
-func (config DatafileProjectConfig) GetEventByKey(eventKey string) (entities.Event, error) {
-	if event, ok := config.eventMap[eventKey]; ok {
+func (c DatafileProjectConfig) GetEventByKey(eventKey string) (entities.Event, error) {
+	if event, ok := c.eventMap[eventKey]; ok {
 		return event, nil
 	}
 
@@ -96,11 +96,42 @@ func (config DatafileProjectConfig) GetEventByKey(eventKey string) (entities.Eve
 }
 
 // GetFeatureByKey returns the feature with the given key
-func (config DatafileProjectConfig) GetFeatureByKey(featureKey string) (entities.Feature, error) {
-	if feature, ok := config.featureMap[featureKey]; ok {
+func (c DatafileProjectConfig) GetFeatureByKey(featureKey string) (entities.Feature, error) {
+	if feature, ok := c.featureMap[featureKey]; ok {
 		return feature, nil
 	}
 
 	errMessage := fmt.Sprintf("Feature with key %s not found", featureKey)
 	return entities.Feature{}, errors.New(errMessage)
 }
+
+// GetAudienceByID returns the audience with the given ID
+func (c DatafileProjectConfig) GetAudienceByID(audienceID string) (entities.Audience, error) {
+	if audience, ok := c.audienceMap[audienceID]; ok {
+		return audience, nil
+	}
+
+	errMessage := fmt.Sprintf(`Audience with ID "%s" not found`, audienceID)
+	return entities.Audience{}, errors.New(errMessage)
+}
+
+// GetExperimentByKey returns the experiment with the given key
+func (c DatafileProjectConfig) GetExperimentByKey(experimentKey string) (entities.Experiment, error) {
+	if experimentID, ok := c.experimentKeyToIDMap[experimentKey]; ok {
+		experiment := c.experimentMap[experimentID]
+		return experiment, nil
+	}
+
+	errMessage := fmt.Sprintf(`Experiment with key "%s" not found`, experimentKey)
+	return entities.Experiment{}, errors.New(errMessage)
+}
+
+// GetGroupByID returns the group with the given ID
+func (c DatafileProjectConfig) GetGroupByID(groupID string) (entities.Group, error) {
+	if group, ok := c.groupMap[groupID]; ok {
+		return group, nil
+	}
+
+	errMessage := fmt.Sprintf(`Group with ID "%s" not found`, groupID)
+	return entities.Group{}, errors.New(errMessage)
+}

optimizely/config/static_manager.go

@@ -16,23 +16,27 @@
 
 package config
 
-import "sync"
+import (
+	"sync"
+
+	"github.com/optimizely/go-sdk/optimizely"
+)
 
 // StaticProjectConfigManager maintains a static copy of the project config
 type StaticProjectConfigManager struct {
-	projectConfig ProjectConfig
+	projectConfig optimizely.ProjectConfig
 	configLock    sync.Mutex
 }
 
 // NewStaticProjectConfigManager creates a new instance of the manager with the given project config
-func NewStaticProjectConfigManager(config ProjectConfig) *StaticProjectConfigManager {
+func NewStaticProjectConfigManager(config optimizely.ProjectConfig) *StaticProjectConfigManager {
 	return &StaticProjectConfigManager{
 		projectConfig: config,
 	}
 }
 
 // GetConfig returns the project config
-func (cm *StaticProjectConfigManager) GetConfig() ProjectConfig {
+func (cm *StaticProjectConfigManager) GetConfig() optimizely.ProjectConfig {
 	cm.configLock.Lock()
 	defer cm.configLock.Unlock()
 	return cm.projectConfig

optimizely/decision/composite_experiment_service.go

@@ -42,17 +42,18 @@ func NewCompositeExperimentService() *CompositeExperimentService {
 
 // GetDecision returns a decision for the given experiment and user context
 func (s CompositeExperimentService) GetDecision(decisionContext ExperimentDecisionContext, userContext entities.UserContext) (ExperimentDecision, error) {
+	_, err := decisionContext.ProjectConfig.GetExperimentByKey(decisionContext.ExperimentKey)
+	if err != nil {
+		return ExperimentDecision{}, err
+	}
+
 	for _, experimentService := range s.experimentDecisionServices {
 		decision, err := experimentService.GetDecision(decisionContext, userContext)
 		if decision.DecisionMade == true {
 			return decision, err
 		}
 	}
 
-	experimentDecision := ExperimentDecision{
-		Decision: Decision{
-			DecisionMade: false,
-		},
-	}
-	return experimentDecision, nil
+	// zero-value for DecisionMade is false
+	return ExperimentDecision{}, nil
 }

optimizely/decision/composite_experiment_service_test.go

@@ -35,24 +35,30 @@ func (m *MockExperimentDecisionService) GetDecision(decisionContext ExperimentDe
 }
 
 func TestCompositeExperimentServiceGetDecision(t *testing.T) {
-	testDecisionContext := ExperimentDecisionContext{
-		Experiment: entities.Experiment{
-			ID: "111111",
-			Variations: map[string]entities.Variation{
-				"22222": entities.Variation{
-					ID:  "22222",
-					Key: "22222",
-				},
+	testExperimentKey := "test_experiment"
+	testExperiment := entities.Experiment{
+		ID:  "111111",
+		Key: testExperimentKey,
+		Variations: map[string]entities.Variation{
+			"22222": entities.Variation{
+				ID:  "22222",
+				Key: "22222",
 			},
 		},
 	}
+	mockProjectConfig := new(MockProjectConfig)
+	mockProjectConfig.On("GetExperimentByKey", testExperimentKey).Return(testExperiment, nil)
+	testDecisionContext := ExperimentDecisionContext{
+		ExperimentKey: testExperimentKey,
+		ProjectConfig: mockProjectConfig,
+	}
 
 	testUserContext := entities.UserContext{
 		ID: "test_user_1",
 	}
 
 	expectedExperimentDecision := ExperimentDecision{
-		Variation: testDecisionContext.Experiment.Variations["22222"],
+		Variation: testExperiment.Variations["22222"],
 		Decision: Decision{
 			DecisionMade: true,
 		},
@@ -86,7 +92,7 @@ func TestCompositeExperimentServiceGetDecision(t *testing.T) {
 
 	mockExperimentDecisionService2 = new(MockExperimentDecisionService)
 	expectedExperimentDecision2 := ExperimentDecision{
-		Variation: testDecisionContext.Experiment.Variations["22222"],
+		Variation: testExperiment.Variations["22222"],
 		Decision: Decision{
 			DecisionMade: true,
 		},