feat(client): Allow user profile service and overrides to be passed in. (#168)

Author: Michael Ng

pkg/client/factory.go

@@ -32,35 +32,72 @@ import (
 type OptimizelyFactory struct {
 	SDKKey   string
 	Datafile []byte
+
+	configManager      pkg.ProjectConfigManager
+	decisionService    decision.Service
+	eventProcessor     event.Processor
+	executionCtx       utils.ExecutionCtx
+	userProfileService decision.UserProfileService
+	overrideStore      decision.ExperimentOverrideStore
 }
 
 // OptionFunc is a type to a proper func
-type OptionFunc func(*OptimizelyClient)
+type OptionFunc func(*OptimizelyFactory)
 
 // Client gets client and sets some parameters
 func (f OptimizelyFactory) Client(clientOptions ...OptionFunc) (*OptimizelyClient, error) {
+	// extract options
+	for _, opt := range clientOptions {
+		opt(&f)
+	}
 
-	executionCtx := utils.NewCancelableExecutionCtx()
+	if f.SDKKey == "" && f.Datafile == nil && f.configManager == nil {
+		return nil, errors.New("unable to instantiate client: no project config manager, SDK key, or a Datafile provided")
+	}
 
-	appClient := &OptimizelyClient{
-		executionCtx:    executionCtx,
-		DecisionService: decision.NewCompositeService(f.SDKKey),
-		EventProcessor: event.NewBatchEventProcessor(event.WithBatchSize(event.DefaultBatchSize),
-			event.WithQueueSize(event.DefaultEventQueueSize), event.WithFlushInterval(event.DefaultEventFlushInterval),
-			event.WithSDKKey(f.SDKKey)),
+	var executionCtx utils.ExecutionCtx
+	if f.executionCtx != nil {
+		executionCtx = f.executionCtx
+	} else {
+		executionCtx = utils.NewCancelableExecutionCtx()
 	}
 
-	for _, opt := range clientOptions {
-		opt(appClient)
+	appClient := &OptimizelyClient{executionCtx: executionCtx}
+
+	if f.configManager != nil {
+		appClient.ConfigManager = f.configManager
+	} else {
+		appClient.ConfigManager = config.NewPollingProjectConfigManager(
+			f.SDKKey,
+			config.InitialDatafile(f.Datafile),
+			config.PollingInterval(config.DefaultPollingInterval),
+		)
 	}
 
-	if f.SDKKey == "" && f.Datafile == nil && appClient.ConfigManager == nil {
-		return nil, errors.New("unable to instantiate client: no project config manager, SDK key, or a Datafile provided")
+	if f.eventProcessor != nil {
+		appClient.EventProcessor = f.eventProcessor
+	} else {
+		appClient.EventProcessor = event.NewBatchEventProcessor(
+			event.WithBatchSize(event.DefaultBatchSize),
+			event.WithQueueSize(event.DefaultEventQueueSize),
+			event.WithFlushInterval(event.DefaultEventFlushInterval),
+			event.WithSDKKey(f.SDKKey),
+		)
 	}
 
-	if appClient.ConfigManager == nil { // if it was not passed then assign here
-		appClient.ConfigManager = config.NewPollingProjectConfigManager(f.SDKKey,
-			config.InitialDatafile(f.Datafile), config.PollingInterval(config.DefaultPollingInterval))
+	if f.decisionService != nil {
+		appClient.DecisionService = f.decisionService
+	} else {
+		experimentServiceOptions := []decision.CESOptionFunc{}
+		if f.userProfileService != nil {
+			experimentServiceOptions = append(experimentServiceOptions, decision.WithUserProfileService(f.userProfileService))
+		}
+		if f.overrideStore != nil {
+			experimentServiceOptions = append(experimentServiceOptions, decision.WithOverrideStore(f.overrideStore))
+		}
+		compositeExperimentService := decision.NewCompositeExperimentService(experimentServiceOptions...)
+		compositeService := decision.NewCompositeService(f.SDKKey, decision.WithCompositeExperimentService(compositeExperimentService))
+		appClient.DecisionService = compositeService
 	}
 
 	// Initialize the default services with the execution context
@@ -77,59 +114,73 @@ func (f OptimizelyFactory) Client(clientOptions ...OptionFunc) (*OptimizelyClien
 
 // WithPollingConfigManager sets polling config manager on a client
 func WithPollingConfigManager(sdkKey string, pollingInterval time.Duration, initDataFile []byte) OptionFunc {
-	return func(f *OptimizelyClient) {
-		f.ConfigManager = config.NewPollingProjectConfigManager(sdkKey, config.InitialDatafile(initDataFile),
+	return func(f *OptimizelyFactory) {
+		f.configManager = config.NewPollingProjectConfigManager(sdkKey, config.InitialDatafile(initDataFile),
 			config.PollingInterval(pollingInterval))
 	}
 }
 
 // WithPollingConfigManagerRequester sets polling config manager on a client
 func WithPollingConfigManagerRequester(requester utils.Requester, pollingInterval time.Duration, initDataFile []byte) OptionFunc {
-	return func(f *OptimizelyClient) {
-		f.ConfigManager = config.NewPollingProjectConfigManager("", config.InitialDatafile(initDataFile),
+	return func(f *OptimizelyFactory) {
+		f.configManager = config.NewPollingProjectConfigManager("", config.InitialDatafile(initDataFile),
 			config.PollingInterval(pollingInterval), config.Requester(requester))
 	}
 }
 
 // WithConfigManager sets polling config manager on a client
 func WithConfigManager(configManager pkg.ProjectConfigManager) OptionFunc {
-	return func(f *OptimizelyClient) {
-		f.ConfigManager = configManager
+	return func(f *OptimizelyFactory) {
+		f.configManager = configManager
 	}
 }
 
 // WithCompositeDecisionService sets decision service on a client
 func WithCompositeDecisionService(sdkKey string) OptionFunc {
-	return func(f *OptimizelyClient) {
-		f.DecisionService = decision.NewCompositeService(sdkKey)
+	return func(f *OptimizelyFactory) {
+		f.decisionService = decision.NewCompositeService(sdkKey)
 	}
 }
 
 // WithDecisionService sets decision service on a client
 func WithDecisionService(decisionService decision.Service) OptionFunc {
-	return func(f *OptimizelyClient) {
-		f.DecisionService = decisionService
+	return func(f *OptimizelyFactory) {
+		f.decisionService = decisionService
+	}
+}
+
+// WithUserProfileService sets the user profile service on the decision service
+func WithUserProfileService(userProfileService decision.UserProfileService) OptionFunc {
+	return func(f *OptimizelyFactory) {
+		f.userProfileService = userProfileService
+	}
+}
+
+// WithExperimentOverrides sets the experiment override store on the decision service
+func WithExperimentOverrides(overrideStore decision.ExperimentOverrideStore) OptionFunc {
+	return func(f *OptimizelyFactory) {
+		f.overrideStore = overrideStore
 	}
 }
 
 // WithBatchEventProcessor sets event processor on a client
 func WithBatchEventProcessor(batchSize, queueSize int, flushInterval time.Duration) OptionFunc {
-	return func(f *OptimizelyClient) {
-		f.EventProcessor = event.NewBatchEventProcessor(event.WithBatchSize(batchSize),
+	return func(f *OptimizelyFactory) {
+		f.eventProcessor = event.NewBatchEventProcessor(event.WithBatchSize(batchSize),
 			event.WithQueueSize(queueSize), event.WithFlushInterval(flushInterval))
 	}
 }
 
 // WithEventProcessor sets event processor on a client
 func WithEventProcessor(eventProcessor event.Processor) OptionFunc {
-	return func(f *OptimizelyClient) {
-		f.EventProcessor = eventProcessor
+	return func(f *OptimizelyFactory) {
+		f.eventProcessor = eventProcessor
 	}
 }
 
 // WithExecutionContext allows user to pass in their own execution context to override the default one in the client
 func WithExecutionContext(executionContext utils.ExecutionCtx) OptionFunc {
-	return func(f *OptimizelyClient) {
+	return func(f *OptimizelyFactory) {
 		f.executionCtx = executionContext
 	}
 }

pkg/client/factory_test.go

@@ -27,6 +27,7 @@ import (
 
 	"github.com/optimizely/go-sdk/pkg/config"
 	"github.com/optimizely/go-sdk/pkg/config/datafileprojectconfig"
+	"github.com/optimizely/go-sdk/pkg/decision"
 	"github.com/optimizely/go-sdk/pkg/event"
 	"github.com/optimizely/go-sdk/pkg/utils"
 
@@ -111,7 +112,7 @@ func TestClientWithDecisionServiceAndEventProcessorInOptions(t *testing.T) {
 		MaxQueueSize:    100,
 		FlushInterval:   100,
 		Q:               event.NewInMemoryQueue(100),
-		EventDispatcher: &MockDispatcher{Events:[]event.LogEvent{}},
+		EventDispatcher: &MockDispatcher{Events: []event.LogEvent{}},
 	}
 
 	optimizelyClient, err := factory.Client(WithConfigManager(configManager), WithDecisionService(decisionService), WithEventProcessor(processor))
@@ -145,3 +146,16 @@ func TestStaticClient(t *testing.T) {
 	assert.Error(t, err)
 	assert.Nil(t, optlyClient)
 }
+
+func TestClientWithCustomDecisionServiceOptions(t *testing.T) {
+	factory := OptimizelyFactory{SDKKey: "1212"}
+
+	mockUserProfileService := new(MockUserProfileService)
+	mockOverrideStore := new(decision.MapOverridesStore)
+	optimizelyClient, err := factory.Client(
+		WithUserProfileService(mockUserProfileService),
+		WithExperimentOverrides(mockOverrideStore),
+	)
+	assert.NoError(t, err)
+	assert.NotNil(t, optimizelyClient.DecisionService)
+}

pkg/client/fixtures_test.go

@@ -151,6 +151,11 @@ func (m *PanickingDecisionService) RemoveOnDecision(id int) error {
 	panic("I'm panicking")
 }
 
+type MockUserProfileService struct {
+	decision.UserProfileService
+	mock.Mock
+}
+
 // Helper methods for creating test entities
 func makeTestExperiment(experimentKey string) entities.Experiment {
 	return entities.Experiment{

pkg/decision/composite_experiment_service.go

@@ -27,23 +27,60 @@ import (
 
 var ceLogger = logging.GetLogger("CompositeExperimentService")
 
+// CESOptionFunc is used to assign optional configuration options
+type CESOptionFunc func(*CompositeExperimentService)
+
+// WithUserProfileService adds a user profile service
+func WithUserProfileService(userProfileService UserProfileService) CESOptionFunc {
+	return func(f *CompositeExperimentService) {
+		f.userProfileService = userProfileService
+	}
+}
+
+// WithOverrideStore adds an experiment override store
+func WithOverrideStore(overrideStore ExperimentOverrideStore) CESOptionFunc {
+	return func(f *CompositeExperimentService) {
+		f.overrideStore = overrideStore
+	}
+}
+
 // CompositeExperimentService bridges together the various experiment decision services that ship by default with the SDK
 type CompositeExperimentService struct {
 	experimentServices []ExperimentService
+	overrideStore      ExperimentOverrideStore
+	userProfileService UserProfileService
 }
 
 // NewCompositeExperimentService creates a new instance of the CompositeExperimentService
-func NewCompositeExperimentService() *CompositeExperimentService {
+func NewCompositeExperimentService(options ...CESOptionFunc) *CompositeExperimentService {
 	// These decision services are applied in order:
-	// 1. Whitelist
-	// 2. Bucketing
-	// @TODO(mng): Prepend forced variation
-	return &CompositeExperimentService{
-		experimentServices: []ExperimentService{
-			NewExperimentWhitelistService(),
-			NewExperimentBucketerService(),
-		},
+	// 1. Overrides (if supplied)
+	// 2. Whitelist
+	// 3. Bucketing (with User profile integration if supplied)
+	compositeExperimentService := &CompositeExperimentService{}
+	for _, opt := range options {
+		opt(compositeExperimentService)
 	}
+	experimentServices := []ExperimentService{
+		NewExperimentWhitelistService(),
+	}
+
+	// Prepend overrides if supplied
+	if compositeExperimentService.overrideStore != nil {
+		overrideService := NewExperimentOverrideService(compositeExperimentService.overrideStore)
+		experimentServices = append([]ExperimentService{overrideService}, experimentServices...)
+	}
+
+	experimentBucketerService := NewExperimentBucketerService()
+	if compositeExperimentService.userProfileService != nil {
+		persistingExperimentService := NewPersistingExperimentService(experimentBucketerService, compositeExperimentService.userProfileService)
+		experimentServices = append(experimentServices, persistingExperimentService)
+	} else {
+		experimentServices = append(experimentServices, experimentBucketerService)
+	}
+	compositeExperimentService.experimentServices = experimentServices
+
+	return compositeExperimentService
 }
 
 // GetDecision returns a decision for the given experiment and user context

pkg/decision/composite_experiment_service_test.go

@@ -158,6 +158,17 @@ func (s *CompositeExperimentTestSuite) TestNewCompositeExperimentService() {
 	s.IsType(&ExperimentBucketerService{}, compositeExperimentService.experimentServices[1])
 }
 
+func (s *CompositeExperimentTestSuite) TestNewCompositeExperimentServiceWithCustomOptions() {
+	mockUserProfileService := new(MockUserProfileService)
+	mockExperimentOverrideStore := new(MapOverridesStore)
+	compositeExperimentService := NewCompositeExperimentService(
+		WithUserProfileService(mockUserProfileService),
+		WithOverrideStore(mockExperimentOverrideStore),
+	)
+	s.Equal(mockUserProfileService, compositeExperimentService.userProfileService)
+	s.Equal(mockExperimentOverrideStore, compositeExperimentService.overrideStore)
+}
+
 func TestCompositeExperimentTestSuite(t *testing.T) {
 	suite.Run(t, new(CompositeExperimentTestSuite))
 }

pkg/decision/composite_service.go

@@ -35,16 +35,32 @@ type CompositeService struct {
 	notificationCenter         notification.Center
 }
 
+// CSOptionFunc is used to pass config options into the CompositeService
+type CSOptionFunc func(*CompositeService)
+
+// WithCompositeExperimentService sets the composite experiment service on the CompositeService
+func WithCompositeExperimentService(compositeExperimentService ExperimentService) CSOptionFunc {
+	return func(f *CompositeService) {
+		f.compositeExperimentService = compositeExperimentService
+	}
+}
+
 // NewCompositeService returns a new instance of the CompositeService with the defaults
-func NewCompositeService(sdkKey string) *CompositeService {
-	// @TODO: add factory method with option funcs to accept custom feature and experiment services
-	compositeExperimentService := NewCompositeExperimentService()
-	compositeFeatureDecisionService := NewCompositeFeatureService(compositeExperimentService)
-	return &CompositeService{
-		compositeExperimentService: compositeExperimentService,
-		compositeFeatureService:    compositeFeatureDecisionService,
-		notificationCenter:         registry.GetNotificationCenter(sdkKey),
+func NewCompositeService(sdkKey string, options ...CSOptionFunc) *CompositeService {
+	compositeService := &CompositeService{
+		notificationCenter: registry.GetNotificationCenter(sdkKey),
 	}
+
+	for _, opts := range options {
+		opts(compositeService)
+	}
+
+	if compositeService.compositeExperimentService == nil {
+		compositeService.compositeExperimentService = NewCompositeExperimentService()
+	}
+	compositeService.compositeFeatureService = NewCompositeFeatureService(compositeService.compositeExperimentService)
+
+	return compositeService
 }
 
 // GetFeatureDecision returns a decision for the given feature key

pkg/decision/composite_service_test.go

@@ -98,6 +98,13 @@ func (s *CompositeServiceFeatureTestSuite) TestNewCompositeService() {
 	s.IsType(&CompositeFeatureService{}, compositeService.compositeFeatureService)
 }
 
+func (s *CompositeServiceFeatureTestSuite) TestNewCompositeServiceWithCustomOptions() {
+	compositeExperimentService := NewCompositeExperimentService()
+	compositeService := NewCompositeService("sdk_key", WithCompositeExperimentService(compositeExperimentService))
+	s.IsType(compositeExperimentService, compositeService.compositeExperimentService)
+	s.IsType(&CompositeFeatureService{}, compositeService.compositeFeatureService)
+}
+
 type CompositeServiceExperimentTestSuite struct {
 	suite.Suite
 	decisionContext       ExperimentDecisionContext

pkg/decision/helpers_test.go

@@ -75,6 +75,20 @@ type MockAudienceTreeEvaluator struct {
 	mock.Mock
 }
 
+type MockUserProfileService struct {
+	UserProfileService
+	mock.Mock
+}
+
+func (m *MockUserProfileService) Lookup(userID string) UserProfile {
+	args := m.Called(userID)
+	return args.Get(0).(UserProfile)
+}
+
+func (m *MockUserProfileService) Save(userProfile UserProfile) {
+	m.Called(userProfile)
+}
+
 func (m *MockAudienceTreeEvaluator) Evaluate(node *entities.TreeNode, condTreeParams *entities.TreeParameters) bool {
 	args := m.Called(node, condTreeParams)
 	return args.Bool(0)