refact(forced-decision): Support for decision context added. (#326)

* updated with changes made in swift-sdk.

* fixes.

* suggested changes made.

* Replacing `Variation` with `VariationKey` in forced-decision struct

* fixing unit tests for empty flagkey.

Author: yasirfolio3

pkg/client/client.go

@@ -112,7 +112,7 @@ func (o *OptimizelyClient) decide(userContext OptimizelyUserContext, key string,
 	// Passing empty rule-key because checking mapping with flagKey only
 	if userContext.forcedDecisionService != nil {
 		var variation *entities.Variation
-		variation, reasons, err = userContext.forcedDecisionService.FindValidatedForcedDecision(projectConfig, key, "", &allOptions)
+		variation, reasons, err = userContext.forcedDecisionService.FindValidatedForcedDecision(projectConfig, decision.OptimizelyDecisionContext{FlagKey: key, RuleKey: ""}, &allOptions)
 		decisionReasons.Append(reasons)
 		if err != nil {
 			findRegularDecision()

pkg/client/optimizely_user_context.go

@@ -18,10 +18,11 @@
 package client
 
 import (
+	"errors"
 	"sync"
 
 	"github.com/optimizely/go-sdk/pkg/decide"
-	"github.com/optimizely/go-sdk/pkg/decision"
+	pkgDecision "github.com/optimizely/go-sdk/pkg/decision"
 	"github.com/optimizely/go-sdk/pkg/entities"
 )
 
@@ -31,12 +32,12 @@ type OptimizelyUserContext struct {
 	Attributes map[string]interface{} `json:"attributes"`
 
 	optimizely            *OptimizelyClient
-	forcedDecisionService *decision.ForcedDecisionService
+	forcedDecisionService *pkgDecision.ForcedDecisionService
 	mutex                 *sync.RWMutex
 }
 
 // returns an instance of the optimizely user context.
-func newOptimizelyUserContext(optimizely *OptimizelyClient, userID string, attributes map[string]interface{}, forcedDecisionService *decision.ForcedDecisionService) OptimizelyUserContext {
+func newOptimizelyUserContext(optimizely *OptimizelyClient, userID string, attributes map[string]interface{}, forcedDecisionService *pkgDecision.ForcedDecisionService) OptimizelyUserContext {
 	// store a copy of the provided attributes so it isn't affected by changes made afterwards.
 	if attributes == nil {
 		attributes = map[string]interface{}{}
@@ -68,7 +69,7 @@ func (o OptimizelyUserContext) GetUserAttributes() map[string]interface{} {
 	return copyUserAttributes(o.Attributes)
 }
 
-func (o OptimizelyUserContext) getForcedDecisionService() *decision.ForcedDecisionService {
+func (o OptimizelyUserContext) getForcedDecisionService() *pkgDecision.ForcedDecisionService {
 	if o.forcedDecisionService != nil {
 		return o.forcedDecisionService.CreateCopy()
 	}
@@ -117,41 +118,42 @@ func (o *OptimizelyUserContext) TrackEvent(eventKey string, eventTags map[string
 	return o.optimizely.Track(eventKey, userContext, eventTags)
 }
 
-// SetForcedDecision sets the forced decision (variation key) for a given flag and an optional rule.
+// SetForcedDecision sets the forced decision (variation key) for a given decision context (flag key and optional rule key).
 // returns true if the forced decision has been set successfully.
-func (o *OptimizelyUserContext) SetForcedDecision(flagKey, ruleKey, variationKey string) bool {
+func (o *OptimizelyUserContext) SetForcedDecision(context pkgDecision.OptimizelyDecisionContext, decision pkgDecision.OptimizelyForcedDecision) bool {
 	if _, err := o.optimizely.getProjectConfig(); err != nil {
 		o.optimizely.logger.Error("Optimizely instance is not valid, failing setForcedDecision call.", err)
 		return false
 	}
 	if o.forcedDecisionService == nil {
-		o.forcedDecisionService = decision.NewForcedDecisionService(o.GetUserID())
+		o.forcedDecisionService = pkgDecision.NewForcedDecisionService(o.GetUserID())
 	}
-	return o.forcedDecisionService.SetForcedDecision(flagKey, ruleKey, variationKey)
+	return o.forcedDecisionService.SetForcedDecision(context, decision)
 }
 
 // GetForcedDecision returns the forced decision for a given flag and an optional rule
-func (o *OptimizelyUserContext) GetForcedDecision(flagKey, ruleKey string) string {
+func (o *OptimizelyUserContext) GetForcedDecision(context pkgDecision.OptimizelyDecisionContext) (pkgDecision.OptimizelyForcedDecision, error) {
+	forcedDecision := pkgDecision.OptimizelyForcedDecision{}
 	if _, err := o.optimizely.getProjectConfig(); err != nil {
 		o.optimizely.logger.Error("Optimizely instance is not valid, failing getForcedDecision call.", err)
-		return ""
+		return forcedDecision, err
 	}
 	if o.forcedDecisionService == nil {
-		return ""
+		return forcedDecision, errors.New("decision not found")
 	}
-	return o.forcedDecisionService.GetForcedDecision(flagKey, ruleKey)
+	return o.forcedDecisionService.GetForcedDecision(context)
 }
 
 // RemoveForcedDecision removes the forced decision for a given flag and an optional rule.
-func (o *OptimizelyUserContext) RemoveForcedDecision(flagKey, ruleKey string) bool {
+func (o *OptimizelyUserContext) RemoveForcedDecision(context pkgDecision.OptimizelyDecisionContext) bool {
 	if _, err := o.optimizely.getProjectConfig(); err != nil {
 		o.optimizely.logger.Error("Optimizely instance is not valid, failing removeForcedDecision call.", err)
 		return false
 	}
 	if o.forcedDecisionService == nil {
 		return false
 	}
-	return o.forcedDecisionService.RemoveForcedDecision(flagKey, ruleKey)
+	return o.forcedDecisionService.RemoveForcedDecision(context)
 }
 
 // RemoveAllForcedDecisions removes all forced decisions bound to this user context.

pkg/client/optimizely_user_context_test.go

@@ -215,7 +215,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideFeatureTestWithForcedDecision
 		s.NoError(err)
 
 		user := s.OptimizelyClient.CreateUserContext(s.userID, nil)
-		user.SetForcedDecision(flagKey, ruleKey, variationKey)
+		user.SetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKey, RuleKey: ruleKey}, decision.OptimizelyForcedDecision{VariationKey: variationKey})
 		decision := user.Decide(flagKey, []decide.OptimizelyDecideOptions{decide.IncludeReasons})
 		s.OptimizelyClient.DecisionService.RemoveOnDecision(notificationID)
 
@@ -275,7 +275,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideFeatureTestWithForcedDecision
 	s.Nil(err)
 
 	user := s.OptimizelyClient.CreateUserContext(s.userID, nil)
-	user.SetForcedDecision(flagKey, ruleKey, variationKey)
+	user.SetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKey, RuleKey: ruleKey}, decision.OptimizelyForcedDecision{VariationKey: variationKey})
 	decision := user.Decide(flagKey, []decide.OptimizelyDecideOptions{decide.IncludeReasons})
 
 	s.Equal(variationKey, decision.VariationKey)
@@ -357,7 +357,7 @@ func (s *OptimizelyUserContextTestSuite) TestDecideRolloutWithForcedDecision() {
 	s.Nil(err)
 
 	user := s.OptimizelyClient.CreateUserContext(s.userID, nil)
-	user.SetForcedDecision(flagKey, ruleKey, variationKey)
+	user.SetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKey, RuleKey: ruleKey}, decision.OptimizelyForcedDecision{VariationKey: variationKey})
 	decision := user.Decide(flagKey, []decide.OptimizelyDecideOptions{decide.IncludeReasons})
 
 	s.Equal(variationKey, decision.VariationKey)
@@ -1063,11 +1063,13 @@ func (s *OptimizelyUserContextTestSuite) TestForcedDecisionWithNilConfig() {
 	user := s.OptimizelyClient.CreateUserContext(s.userID, nil)
 	s.Nil(user.forcedDecisionService)
 
-	s.False(user.SetForcedDecision(flagKeyA, ruleKey, variationKeyA))
+	s.False(user.SetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey}, decision.OptimizelyForcedDecision{VariationKey: variationKeyA}))
 	s.Nil(user.forcedDecisionService)
 
-	s.Equal("", user.GetForcedDecision(flagKeyA, ruleKey))
-	s.False(user.RemoveForcedDecision(flagKeyA, ruleKey))
+	forcedDecision, err := user.GetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey})
+	s.Equal("", forcedDecision.VariationKey)
+	s.Error(err)
+	s.False(user.RemoveForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey}))
 	s.False(user.RemoveAllForcedDecisions())
 }
 
@@ -1081,25 +1083,39 @@ func (s *OptimizelyUserContextTestSuite) TestForcedDecision() {
 	// checking with nil forcedDecisionService
 	user := s.OptimizelyClient.CreateUserContext(s.userID, nil)
 	s.Nil(user.forcedDecisionService)
-	s.Equal("", user.GetForcedDecision(flagKeyA, ruleKey))
-	s.False(user.RemoveForcedDecision(flagKeyA, ruleKey))
+	forcedDecision, err := user.GetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey})
+	s.Equal("", forcedDecision.VariationKey)
+	s.Error(err)
+	s.False(user.RemoveForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey}))
 	s.True(user.RemoveAllForcedDecisions())
 
 	// checking if forcedDecisionService was created using SetForcedDecision
-	s.True(user.SetForcedDecision(flagKeyA, ruleKey, variationKeyA))
+	s.True(user.SetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey}, decision.OptimizelyForcedDecision{VariationKey: variationKeyA}))
 	s.NotNil(user.forcedDecisionService)
 
-	s.True(user.SetForcedDecision(flagKeyB, ruleKey, variationKeyB))
-	s.Equal(variationKeyA, user.GetForcedDecision(flagKeyA, ruleKey))
-	s.Equal(variationKeyB, user.GetForcedDecision(flagKeyB, ruleKey))
-
-	s.True(user.RemoveForcedDecision(flagKeyA, ruleKey))
-	s.Equal("", user.GetForcedDecision(flagKeyA, ruleKey))
-	s.Equal(variationKeyB, user.GetForcedDecision(flagKeyB, ruleKey))
+	s.True(user.SetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyB, RuleKey: ruleKey}, decision.OptimizelyForcedDecision{VariationKey: variationKeyB}))
+	forcedDecision, err = user.GetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey})
+	s.Equal(variationKeyA, forcedDecision.VariationKey)
+	s.NoError(err)
+	forcedDecision, err = user.GetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyB, RuleKey: ruleKey})
+	s.Equal(variationKeyB, forcedDecision.VariationKey)
+	s.NoError(err)
+
+	s.True(user.RemoveForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey}))
+	forcedDecision, err = user.GetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey})
+	s.Equal("", forcedDecision.VariationKey)
+	s.NoError(err)
+	forcedDecision, err = user.GetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyB, RuleKey: ruleKey})
+	s.Equal(variationKeyB, forcedDecision.VariationKey)
+	s.NoError(err)
 
 	s.True(user.RemoveAllForcedDecisions())
-	s.Equal("", user.GetForcedDecision(flagKeyA, ruleKey))
-	s.Equal("", user.GetForcedDecision(flagKeyB, ruleKey))
+	forcedDecision, err = user.GetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyA, RuleKey: ruleKey})
+	s.Equal("", forcedDecision.VariationKey)
+	s.Error(err)
+	forcedDecision, err = user.GetForcedDecision(decision.OptimizelyDecisionContext{FlagKey: flagKeyB, RuleKey: ruleKey})
+	s.Equal("", forcedDecision.VariationKey)
+	s.Error(err)
 }
 
 func TestOptimizelyUserContextTestSuite(t *testing.T) {

pkg/decision/feature_experiment_service.go

@@ -48,7 +48,7 @@ func (f FeatureExperimentService) GetDecision(decisionContext FeatureDecisionCon
 
 		// Checking for forced decision
 		if decisionContext.ForcedDecisionService != nil {
-			forcedDecision, _reasons, err := decisionContext.ForcedDecisionService.FindValidatedForcedDecision(decisionContext.ProjectConfig, feature.Key, featureExperiment.Key, options)
+			forcedDecision, _reasons, err := decisionContext.ForcedDecisionService.FindValidatedForcedDecision(decisionContext.ProjectConfig, OptimizelyDecisionContext{FlagKey: feature.Key, RuleKey: featureExperiment.Key}, options)
 			reasons.Append(_reasons)
 			if err == nil {
 				featureDecision := FeatureDecision{

pkg/decision/feature_experiment_service_test.go

@@ -91,7 +91,7 @@ func (s *FeatureExperimentServiceTestSuite) TestGetDecisionWithForcedDecision()
 		},
 	}
 	s.mockConfig.On("GetFlagVariationsMap").Return(flagVariationsMap)
-	s.testFeatureDecisionContext.ForcedDecisionService.SetForcedDecision(s.testFeatureDecisionContext.Feature.Key, testExp1113Key, expectedVariation.Key)
+	s.testFeatureDecisionContext.ForcedDecisionService.SetForcedDecision(OptimizelyDecisionContext{FlagKey: s.testFeatureDecisionContext.Feature.Key, RuleKey: testExp1113Key}, OptimizelyForcedDecision{VariationKey: expectedVariation.Key})
 
 	testExperimentDecisionContext := ExperimentDecisionContext{
 		Experiment:    &testExp1113,
@@ -118,7 +118,7 @@ func (s *FeatureExperimentServiceTestSuite) TestGetDecisionWithForcedDecision()
 	s.mockExperimentService.AssertNotCalled(s.T(), "GetDecision", testExperimentDecisionContext, testUserContext, options)
 
 	// invalid forced decision
-	s.testFeatureDecisionContext.ForcedDecisionService.SetForcedDecision(s.testFeatureDecisionContext.Feature.Key, testExp1113Key, "invalid")
+	s.testFeatureDecisionContext.ForcedDecisionService.SetForcedDecision(OptimizelyDecisionContext{FlagKey: s.testFeatureDecisionContext.Feature.Key, RuleKey: testExp1113Key}, OptimizelyForcedDecision{VariationKey: "invalid"})
 
 	expectedVariation = testExp1113.Variations["2223"]
 	returnExperimentDecision := ExperimentDecision{

pkg/decision/forced_decision_service.go

@@ -26,62 +26,69 @@ import (
 	"github.com/optimizely/go-sdk/pkg/entities"
 )
 
-type forcedDecision struct {
-	flagKey string
-	ruleKey string
+// OptimizelyDecisionContext defines Decision Context
+type OptimizelyDecisionContext struct {
+	FlagKey string
+	RuleKey string
+}
+
+// OptimizelyForcedDecision defines Forced Decision
+type OptimizelyForcedDecision struct {
+	VariationKey string
 }
 
 // ForcedDecisionService defines user contexts that the SDK will use to make decisions for.
 type ForcedDecisionService struct {
 	UserID          string
-	forcedDecisions map[forcedDecision]string
+	forcedDecisions map[OptimizelyDecisionContext]OptimizelyForcedDecision
 	mutex           *sync.RWMutex
 }
 
 // NewForcedDecisionService returns an instance of the optimizely user context.
 func NewForcedDecisionService(userID string) *ForcedDecisionService {
 	return &ForcedDecisionService{
 		UserID:          userID,
-		forcedDecisions: map[forcedDecision]string{},
+		forcedDecisions: map[OptimizelyDecisionContext]OptimizelyForcedDecision{},
 		mutex:           new(sync.RWMutex),
 	}
 }
 
 // SetForcedDecision sets the forced decision (variation key) for a given flag and an optional rule.
 // if rule key is empty, forced decision will be mapped against the flagKey.
 // returns true if the forced decision has been set successfully.
-func (f *ForcedDecisionService) SetForcedDecision(flagKey, ruleKey, variationKey string) bool {
-	if flagKey == "" {
-		return false
-	}
+func (f *ForcedDecisionService) SetForcedDecision(context OptimizelyDecisionContext, decision OptimizelyForcedDecision) bool {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
-	f.forcedDecisions[forcedDecision{flagKey: flagKey, ruleKey: ruleKey}] = variationKey
+	f.forcedDecisions[context] = decision
 	return true
 }
 
 // GetForcedDecision returns the forced decision for a given flag and an optional rule
 // if rule key is empty, forced decision will be returned for the flagKey.
-func (f *ForcedDecisionService) GetForcedDecision(flagKey, ruleKey string) string {
+func (f *ForcedDecisionService) GetForcedDecision(context OptimizelyDecisionContext) (OptimizelyForcedDecision, error) {
 	f.mutex.RLock()
 	defer f.mutex.RUnlock()
+	decision := OptimizelyForcedDecision{}
+	err := errors.New("decision not found")
 	if len(f.forcedDecisions) == 0 {
-		return ""
+		return decision, err
 	}
-	if variationKey, ok := f.forcedDecisions[forcedDecision{flagKey: flagKey, ruleKey: ruleKey}]; ok {
-		return variationKey
+	if forcedDecision, ok := f.forcedDecisions[context]; ok {
+		return forcedDecision, nil
 	}
-	return ""
+	return decision, err
 }
 
 // RemoveForcedDecision removes the forced decision for a given flag and an optional rule.
 // if rule key is empty, forced decision will be removed for the flagKey.
-func (f *ForcedDecisionService) RemoveForcedDecision(flagKey, ruleKey string) bool {
+func (f *ForcedDecisionService) RemoveForcedDecision(context OptimizelyDecisionContext) bool {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
-	decision := forcedDecision{flagKey: flagKey, ruleKey: ruleKey}
-	if f.forcedDecisions[decision] != "" {
-		f.forcedDecisions[decision] = ""
+	if forcedDecision, ok := f.forcedDecisions[context]; ok && forcedDecision.VariationKey != "" {
+		// modify the copy
+		forcedDecision.VariationKey = ""
+		// reassign map entry
+		f.forcedDecisions[context] = forcedDecision
 		return true
 	}
 	return false
@@ -91,29 +98,29 @@ func (f *ForcedDecisionService) RemoveForcedDecision(flagKey, ruleKey string) bo
 func (f *ForcedDecisionService) RemoveAllForcedDecisions() bool {
 	f.mutex.Lock()
 	defer f.mutex.Unlock()
-	f.forcedDecisions = map[forcedDecision]string{}
+	f.forcedDecisions = map[OptimizelyDecisionContext]OptimizelyForcedDecision{}
 	return true
 }
 
 // FindValidatedForcedDecision returns validated forced decision.
-func (f *ForcedDecisionService) FindValidatedForcedDecision(projectConfig config.ProjectConfig, flagKey, ruleKey string, options *decide.Options) (variation *entities.Variation, reasons decide.DecisionReasons, err error) {
+func (f *ForcedDecisionService) FindValidatedForcedDecision(projectConfig config.ProjectConfig, context OptimizelyDecisionContext, options *decide.Options) (variation *entities.Variation, reasons decide.DecisionReasons, err error) {
 	decisionReasons := decide.NewDecisionReasons(options)
-	variationKey := f.GetForcedDecision(flagKey, ruleKey)
-	if variationKey == "" {
-		return nil, decisionReasons, errors.New("decision not found")
+	forcedDecision, err := f.GetForcedDecision(context)
+	if err != nil {
+		return nil, decisionReasons, err
 	}
 
-	_variation, err := f.getFlagVariationByKey(projectConfig, flagKey, variationKey)
-	target := "flag (" + flagKey + ")"
-	if ruleKey != "" {
-		target += ", rule (" + ruleKey + ")"
+	_variation, err := f.getFlagVariationByKey(projectConfig, context.FlagKey, forcedDecision.VariationKey)
+	target := "flag (" + context.FlagKey + ")"
+	if context.RuleKey != "" {
+		target += ", rule (" + context.RuleKey + ")"
 	}
 
 	if err != nil {
 		decisionReasons.AddInfo("Invalid variation is mapped to %s and user (%s) in the forced decision map.", target, f.UserID)
 		return nil, decisionReasons, err
 	}
-	decisionReasons.AddInfo("Variation (%s) is mapped to %s and user (%s) in the forced decision map.", variationKey, target, f.UserID)
+	decisionReasons.AddInfo("Variation (%s) is mapped to %s and user (%s) in the forced decision map.", forcedDecision.VariationKey, target, f.UserID)
 	return _variation, decisionReasons, nil
 }
 
@@ -132,7 +139,7 @@ func (f *ForcedDecisionService) getFlagVariationByKey(projectConfig config.Proje
 func (f *ForcedDecisionService) CreateCopy() *ForcedDecisionService {
 	f.mutex.RLock()
 	defer f.mutex.RUnlock()
-	forceDecisions := map[forcedDecision]string{}
+	forceDecisions := map[OptimizelyDecisionContext]OptimizelyForcedDecision{}
 	for k, v := range f.forcedDecisions {
 		forceDecisions[k] = v
 	}