feat(decide): add UserContext. (#297)

A part of multiple PRs for Decide API

- added OptimizelyUserContext
- added setUserContext API

Author: yasirfolio3

pkg/client/client.go

@@ -26,6 +26,7 @@ import (
 	"strconv"
 
 	"github.com/optimizely/go-sdk/pkg/config"
+	"github.com/optimizely/go-sdk/pkg/decide"
 	"github.com/optimizely/go-sdk/pkg/decision"
 	"github.com/optimizely/go-sdk/pkg/entities"
 	"github.com/optimizely/go-sdk/pkg/event"
@@ -39,12 +40,19 @@ import (
 
 // OptimizelyClient is the entry point to the Optimizely SDK
 type OptimizelyClient struct {
-	ConfigManager      config.ProjectConfigManager
-	DecisionService    decision.Service
-	EventProcessor     event.Processor
-	notificationCenter notification.Center
-	execGroup          *utils.ExecGroup
-	logger             logging.OptimizelyLogProducer
+	ConfigManager        config.ProjectConfigManager
+	DecisionService      decision.Service
+	EventProcessor       event.Processor
+	notificationCenter   notification.Center
+	execGroup            *utils.ExecGroup
+	logger               logging.OptimizelyLogProducer
+	defaultDecideOptions decide.OptimizelyDecideOptions
+}
+
+// CreateUserContext creates a context of the user for which decision APIs will be called.
+// A user context will be created successfully even when the SDK is not fully configured yet.
+func (o *OptimizelyClient) CreateUserContext(userID string, attributes map[string]interface{}) OptimizelyUserContext {
+	return newOptimizelyUserContext(o, userID, attributes)
 }
 
 // Activate returns the key of the variation the user is bucketed into and queues up an impression event to be sent to

pkg/client/client_test.go

@@ -2447,6 +2447,60 @@ func (s *ClientTestSuiteFM) TestGetEnabledFeaturesErrorCases() {
 	s.mockDecisionService.AssertNotCalled(s.T(), "GetFeatureDecision")
 }
 
+func TestCreateUserContext(t *testing.T) {
+	client := OptimizelyClient{}
+	userID := "1212121"
+	userAttributes := map[string]interface{}{"key": 1212}
+	optimizelyUserContext := client.CreateUserContext(userID, userAttributes)
+
+	assert.Equal(t, client, *optimizelyUserContext.GetOptimizely())
+	assert.Equal(t, userID, optimizelyUserContext.GetUserID())
+	assert.Equal(t, userAttributes, optimizelyUserContext.GetUserAttributes())
+}
+
+func TestChangingAttributesDoesntEffectUserContext(t *testing.T) {
+	client := OptimizelyClient{}
+	userID := "1"
+	userAttributes := map[string]interface{}{"key": 1212}
+	optimizelyUserContext := client.CreateUserContext(userID, userAttributes)
+	assert.Equal(t, client, *optimizelyUserContext.GetOptimizely())
+
+	// Changing original values
+	userID = "2"
+	userAttributes["key"] = 1213
+	// Verifying that no changes were reflected in the user context
+	assert.Equal(t, "1", optimizelyUserContext.GetUserID())
+	assert.Equal(t, map[string]interface{}{"key": 1212}, optimizelyUserContext.GetUserAttributes())
+}
+
+func TestCreateUserContextNoAttributes(t *testing.T) {
+	client := OptimizelyClient{}
+	var attributes map[string]interface{}
+	userID := "testUser1"
+	optimizelyUserContext := client.CreateUserContext(userID, attributes)
+
+	assert.Equal(t, client, *optimizelyUserContext.GetOptimizely())
+	assert.Equal(t, attributes, optimizelyUserContext.GetUserAttributes())
+}
+
+func TestCreateUserContextMultiple(t *testing.T) {
+	client := OptimizelyClient{}
+	userID1 := "testUser1"
+	userID2 := "testUser2"
+	userAttributes1 := map[string]interface{}{"key": 1212}
+	userAttributes2 := map[string]interface{}{"key": 1213}
+
+	optimizelyUserContext1 := client.CreateUserContext(userID1, userAttributes1)
+	optimizelyUserContext2 := client.CreateUserContext(userID2, userAttributes2)
+
+	assert.Equal(t, client, *optimizelyUserContext1.GetOptimizely())
+	assert.Equal(t, client, *optimizelyUserContext2.GetOptimizely())
+	assert.Equal(t, userID1, optimizelyUserContext1.GetUserID())
+	assert.Equal(t, userID2, optimizelyUserContext2.GetUserID())
+	assert.Equal(t, userAttributes1, optimizelyUserContext1.GetUserAttributes())
+	assert.Equal(t, userAttributes2, optimizelyUserContext2.GetUserAttributes())
+}
+
 func TestClose(t *testing.T) {
 	mockProcessor := &MockProcessor{}
 	mockDecisionService := new(MockDecisionService)

pkg/client/factory.go

@@ -23,6 +23,7 @@ import (
 	"time"
 
 	"github.com/optimizely/go-sdk/pkg/config"
+	"github.com/optimizely/go-sdk/pkg/decide"
 	"github.com/optimizely/go-sdk/pkg/decision"
 	"github.com/optimizely/go-sdk/pkg/event"
 	"github.com/optimizely/go-sdk/pkg/logging"
@@ -37,14 +38,15 @@ type OptimizelyFactory struct {
 	Datafile            []byte
 	DatafileAccessToken string
 
-	configManager      config.ProjectConfigManager
-	ctx                context.Context
-	decisionService    decision.Service
-	eventDispatcher    event.Dispatcher
-	eventProcessor     event.Processor
-	userProfileService decision.UserProfileService
-	overrideStore      decision.ExperimentOverrideStore
-	metricsRegistry    metrics.Registry
+	configManager        config.ProjectConfigManager
+	ctx                  context.Context
+	decisionService      decision.Service
+	defaultDecideOptions decide.OptimizelyDecideOptions
+	eventDispatcher      event.Dispatcher
+	eventProcessor       event.Processor
+	userProfileService   decision.UserProfileService
+	overrideStore        decision.ExperimentOverrideStore
+	metricsRegistry      metrics.Registry
 }
 
 // OptionFunc is used to provide custom client configuration to the OptimizelyFactory.
@@ -76,9 +78,12 @@ func (f *OptimizelyFactory) Client(clientOptions ...OptionFunc) (*OptimizelyClie
 	}
 
 	eg := utils.NewExecGroup(ctx, logging.GetLogger(f.SDKKey, "ExecGroup"))
-	appClient := &OptimizelyClient{execGroup: eg,
-		notificationCenter: registry.GetNotificationCenter(f.SDKKey),
-		logger:             logging.GetLogger(f.SDKKey, "OptimizelyClient")}
+	appClient := &OptimizelyClient{
+		defaultDecideOptions: f.defaultDecideOptions,
+		execGroup:            eg,
+		notificationCenter:   registry.GetNotificationCenter(f.SDKKey),
+		logger:               logging.GetLogger(f.SDKKey, "OptimizelyClient"),
+	}
 
 	if f.configManager != nil {
 		appClient.ConfigManager = f.configManager
@@ -167,6 +172,13 @@ func WithDecisionService(decisionService decision.Service) OptionFunc {
 	}
 }
 
+// WithDefaultDecideOptions sets default decide options on a client.
+func WithDefaultDecideOptions(decideOptions decide.OptimizelyDecideOptions) OptionFunc {
+	return func(f *OptimizelyFactory) {
+		f.defaultDecideOptions = decideOptions
+	}
+}
+
 // WithUserProfileService sets the user profile service on the decision service.
 func WithUserProfileService(userProfileService decision.UserProfileService) OptionFunc {
 	return func(f *OptimizelyFactory) {

pkg/client/factory_test.go

@@ -25,6 +25,7 @@ import (
 	"time"
 
 	"github.com/optimizely/go-sdk/pkg/config"
+	"github.com/optimizely/go-sdk/pkg/decide"
 	"github.com/optimizely/go-sdk/pkg/decision"
 	"github.com/optimizely/go-sdk/pkg/event"
 	"github.com/optimizely/go-sdk/pkg/metrics"
@@ -201,3 +202,35 @@ func TestClientWithDatafileAccessToken(t *testing.T) {
 
 	assert.Equal(t, accessToken, factory.DatafileAccessToken)
 }
+
+func TestClientWithDefaultDecideOptions(t *testing.T) {
+	decideOptions := decide.OptimizelyDecideOptions{
+		DisableDecisionEvent: true,
+		EnabledFlagsOnly:     true,
+	}
+	factory := OptimizelyFactory{SDKKey: "1212"}
+	optimizelyClient, err := factory.Client(WithDefaultDecideOptions(decideOptions))
+	assert.NoError(t, err)
+	assert.Equal(t, decideOptions, optimizelyClient.defaultDecideOptions)
+
+	// Verify that defaultDecideOptions are initialized as empty by default
+	factory = OptimizelyFactory{SDKKey: "1212"}
+	optimizelyClient, err = factory.Client()
+	assert.NoError(t, err)
+	assert.Equal(t, decide.OptimizelyDecideOptions{}, optimizelyClient.defaultDecideOptions)
+}
+
+func TestModifyingDecideOptionsOutsideClient(t *testing.T) {
+	decideOptions := decide.OptimizelyDecideOptions{
+		DisableDecisionEvent: true,
+		EnabledFlagsOnly:     true,
+	}
+	factory := OptimizelyFactory{SDKKey: "1212"}
+	optimizelyClient, err := factory.Client(WithDefaultDecideOptions(decideOptions))
+	assert.NoError(t, err)
+	decideOptions.IgnoreUserProfileService = true
+	assert.Equal(t, decide.OptimizelyDecideOptions{
+		DisableDecisionEvent: true,
+		EnabledFlagsOnly:     true,
+	}, optimizelyClient.defaultDecideOptions)
+}

pkg/client/optimizely_decision.go

@@ -0,0 +1,91 @@
+/****************************************************************************
+ * Copyright 2020, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+// Package client //
+package client
+
+import (
+	"github.com/optimizely/go-sdk/pkg/optimizelyjson"
+)
+
+// OptimizelyDecision defines the decision returned by decide api.
+type OptimizelyDecision struct {
+	variationKey string
+	enabled      bool
+	variables    *optimizelyjson.OptimizelyJSON
+	ruleKey      string
+	flagKey      string
+	userContext  OptimizelyUserContext
+	reasons      []string
+}
+
+// NewOptimizelyDecision creates and returns a new instance of OptimizelyDecision
+func NewOptimizelyDecision(variationKey, ruleKey, flagKey string, enabled bool, variables *optimizelyjson.OptimizelyJSON, userContext OptimizelyUserContext, reasons []string) OptimizelyDecision {
+	return OptimizelyDecision{
+		variationKey: variationKey,
+		enabled:      enabled,
+		variables:    variables,
+		ruleKey:      ruleKey,
+		flagKey:      flagKey,
+		userContext:  userContext,
+		reasons:      reasons,
+	}
+}
+
+// NewErrorDecision returns a decision with error
+func NewErrorDecision(key string, user OptimizelyUserContext, err error) OptimizelyDecision {
+	return OptimizelyDecision{
+		flagKey:     key,
+		userContext: user,
+		variables:   &optimizelyjson.OptimizelyJSON{},
+		reasons:     []string{err.Error()},
+	}
+}
+
+// GetVariationKey returns variation key for optimizely decision.
+func (o OptimizelyDecision) GetVariationKey() string {
+	return o.variationKey
+}
+
+// GetEnabled returns the boolean value indicating if the flag is enabled or not.
+func (o OptimizelyDecision) GetEnabled() bool {
+	return o.enabled
+}
+
+// GetVariables returns the collection of variables associated with the decision.
+func (o OptimizelyDecision) GetVariables() *optimizelyjson.OptimizelyJSON {
+	return o.variables
+}
+
+// GetRuleKey returns the rule key of the decision.
+func (o OptimizelyDecision) GetRuleKey() string {
+	return o.ruleKey
+}
+
+// GetFlagKey returns the flag key for which the decision was made.
+func (o OptimizelyDecision) GetFlagKey() string {
+	return o.flagKey
+}
+
+// GetUserContext returns the user context for which the  decision was made.
+func (o OptimizelyDecision) GetUserContext() OptimizelyUserContext {
+	return o.userContext
+}
+
+// GetReasons returns an array of error/info/debug messages describing why the decision has been made.
+func (o OptimizelyDecision) GetReasons() []string {
+	return o.reasons
+}

pkg/client/optimizely_decision_test.go

@@ -0,0 +1,80 @@
+/****************************************************************************
+ * Copyright 2020, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package client
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/optimizely/go-sdk/pkg/optimizelyjson"
+
+	"github.com/stretchr/testify/suite"
+)
+
+type OptimizelyDecisionTestSuite struct {
+	suite.Suite
+	*OptimizelyClient
+}
+
+func (s *OptimizelyDecisionTestSuite) SetupTest() {
+	factory := OptimizelyFactory{SDKKey: "1212"}
+	s.OptimizelyClient, _ = factory.Client()
+}
+
+func (s *OptimizelyDecisionTestSuite) TestOptimizelyDecision() {
+	variationKey := "var1"
+	enabled := true
+	variables, _ := optimizelyjson.NewOptimizelyJSONfromString(`{"k1":"v1"}`)
+	var ruleKey string
+	flagKey := "flag1"
+	reasons := []string{}
+	userID := "testUser1"
+	attributes := map[string]interface{}{"key": 1212}
+
+	optimizelyUserContext := s.OptimizelyClient.CreateUserContext(userID, attributes)
+	decision := NewOptimizelyDecision(variationKey, ruleKey, flagKey, enabled, variables, optimizelyUserContext, reasons)
+
+	s.Equal(variationKey, decision.GetVariationKey())
+	s.Equal(enabled, decision.GetEnabled())
+	s.Equal(variables, decision.GetVariables())
+	s.Equal(ruleKey, decision.GetRuleKey())
+	s.Equal(flagKey, decision.GetFlagKey())
+	s.Equal(reasons, decision.GetReasons())
+	s.Equal(optimizelyUserContext, decision.GetUserContext())
+}
+
+func (s *OptimizelyDecisionTestSuite) TestNewErrorDecision() {
+	flagKey := "flag1"
+	errorString := "SDK has an error"
+	userID := "testUser1"
+	attributes := map[string]interface{}{"key": 1212}
+	optimizelyUserContext := s.OptimizelyClient.CreateUserContext(userID, attributes)
+	decision := NewErrorDecision(flagKey, optimizelyUserContext, errors.New(errorString))
+
+	s.Equal("", decision.GetVariationKey())
+	s.Equal(false, decision.GetEnabled())
+	s.Equal(&optimizelyjson.OptimizelyJSON{}, decision.GetVariables())
+	s.Equal("", decision.GetRuleKey())
+	s.Equal(flagKey, decision.GetFlagKey())
+	s.Equal(1, len(decision.GetReasons()))
+	s.Equal(optimizelyUserContext, decision.GetUserContext())
+	s.Equal(errorString, decision.GetReasons()[0])
+}
+
+func TestOptimizelyDecisionTestSuite(t *testing.T) {
+	suite.Run(t, new(OptimizelyDecisionTestSuite))
+}