feat(segment-manager): Adds implementation for ODPSegmentManager

pkg/client/client.go

@@ -53,6 +53,7 @@ type OptimizelyClient struct {
 // 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 {
+	// Passing qualified segments as nil initially since they will be fetched later
 	return newOptimizelyUserContext(o, userID, attributes, nil, nil)
 }
 

pkg/client/optimizely_user_context.go

@@ -38,7 +38,7 @@ type OptimizelyUserContext struct {
 }
 
 // returns an instance of the optimizely user context.
-func newOptimizelyUserContext(optimizely *OptimizelyClient, userID string, attributes map[string]interface{}, qualifiedSegments []string, forcedDecisionService *pkgDecision.ForcedDecisionService) OptimizelyUserContext {
+func newOptimizelyUserContext(optimizely *OptimizelyClient, userID string, attributes map[string]interface{}, forcedDecisionService *pkgDecision.ForcedDecisionService, qualifiedSegments []string) OptimizelyUserContext {
 	// store a copy of the provided attributes so it isn't affected by changes made afterwards.
 	if attributes == nil {
 		attributes = map[string]interface{}{}
@@ -115,21 +115,21 @@ func (o *OptimizelyUserContext) IsQualifiedFor(segment string) bool {
 // all data required to deliver the flag or experiment.
 func (o *OptimizelyUserContext) Decide(key string, options []decide.OptimizelyDecideOptions) OptimizelyDecision {
 	// use a copy of the user context so that any changes to the original context are not reflected inside the decision
-	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.GetQualifiedSegments(), o.getForcedDecisionService())
+	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.getForcedDecisionService(), o.GetQualifiedSegments())
 	return o.optimizely.decide(userContextCopy, key, convertDecideOptions(options))
 }
 
 // DecideAll returns a key-map of decision results for all active flag keys with options.
 func (o *OptimizelyUserContext) DecideAll(options []decide.OptimizelyDecideOptions) map[string]OptimizelyDecision {
 	// use a copy of the user context so that any changes to the original context are not reflected inside the decision
-	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.GetQualifiedSegments(), o.getForcedDecisionService())
+	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.getForcedDecisionService(), o.GetQualifiedSegments())
 	return o.optimizely.decideAll(userContextCopy, convertDecideOptions(options))
 }
 
 // DecideForKeys returns a key-map of decision results for multiple flag keys and options.
 func (o *OptimizelyUserContext) DecideForKeys(keys []string, options []decide.OptimizelyDecideOptions) map[string]OptimizelyDecision {
 	// use a copy of the user context so that any changes to the original context are not reflected inside the decision
-	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.GetQualifiedSegments(), o.getForcedDecisionService())
+	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.getForcedDecisionService(), o.GetQualifiedSegments())
 	return o.optimizely.decideForKeys(userContextCopy, keys, convertDecideOptions(options))
 }
 
@@ -192,5 +192,5 @@ func copyQualifiedSegments(qualifiedSegments []string) (qualifiedSegmentsCopy []
 	}
 	qualifiedSegmentsCopy = make([]string, len(qualifiedSegments))
 	copy(qualifiedSegmentsCopy, qualifiedSegments)
-	return qualifiedSegmentsCopy
+	return
 }

pkg/client/optimizely_user_context_test.go

@@ -58,7 +58,7 @@ func (s *OptimizelyUserContextTestSuite) SetupTest() {
 func (s *OptimizelyUserContextTestSuite) TestOptimizelyUserContextWithAttributesAndSegments() {
 	attributes := map[string]interface{}{"key1": 1212, "key2": 1213}
 	segments := []string{"123"}
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, segments, nil)
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, nil, segments)
 
 	s.Equal(s.OptimizelyClient, optimizelyUserContext.GetOptimizely())
 	s.Equal(s.userID, optimizelyUserContext.GetUserID())
@@ -80,7 +80,7 @@ func (s *OptimizelyUserContextTestSuite) TestOptimizelyUserContextNoAttributesAn
 func (s *OptimizelyUserContextTestSuite) TestUpatingProvidedUserContextHasNoImpactOnOptimizelyUserContext() {
 	attributes := map[string]interface{}{"k1": "v1", "k2": false}
 	segments := []string{"123"}
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, segments, nil)
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, nil, segments)
 
 	s.Equal(s.OptimizelyClient, optimizelyUserContext.GetOptimizely())
 	s.Equal(s.userID, optimizelyUserContext.GetUserID())
@@ -177,7 +177,7 @@ func (s *OptimizelyUserContextTestSuite) TestSetAndGetQualifiedSegments() {
 	userID := "1212121"
 	var attributes map[string]interface{}
 	qualifiedSegments := []string{"1", "2", "3"}
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, []string{}, nil)
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil, []string{})
 	s.Len(optimizelyUserContext.GetQualifiedSegments(), 0)
 
 	optimizelyUserContext.SetQualifiedSegments(nil)

pkg/config/datafileprojectconfig/mappers/audience.go

@@ -43,6 +43,7 @@ func MapAudiences(audiences []datafileEntities.Audience) (audienceMap map[string
 			if err == nil {
 				audience.ConditionTree = conditionTree
 			}
+			// Only add unique segments to the list
 			for _, s := range fSegments {
 				if !odpSegmentsMap[s] {
 					odpSegmentsMap[s] = true

pkg/config/datafileprojectconfig/mappers/condition_trees.go

@@ -83,6 +83,7 @@ func buildConditionTree(conditions interface{}) (conditionTree *entities.TreeNod
 						retErr = err
 						return
 					}
+					// Extract odp segment from leaf node if applicable
 					extractSegment(&odpSegments, n)
 				}
 
@@ -102,6 +103,7 @@ func buildConditionTree(conditions interface{}) (conditionTree *entities.TreeNod
 				retErr = err
 				return
 			}
+			// Extract odp segment from leaf node if applicable
 			extractSegment(&odpSegments, n)
 			conditionTree.Operator = "or"
 			conditionTree.Nodes = append(conditionTree.Nodes, n)
@@ -209,11 +211,13 @@ func isValidOperator(op string) bool {
 	return false
 }
 
+// Extracts odpSegment from leaf node and adds it to odpSegments array
 func extractSegment(odpSegments *[]string, node *entities.TreeNode) {
 	condition, ok := node.Item.(entities.Condition)
 	if !ok {
 		return
 	}
+	// Add segment to list only if match type is qualified and value is a non-empty string
 	if condition.Match == matchers.QualifiedMatchType {
 		if segment, ok := condition.Value.(string); ok && segment != "" {
 			*odpSegments = append(*odpSegments, segment)

pkg/odp/config.go

@@ -23,42 +23,28 @@ import (
 	"github.com/optimizely/go-sdk/pkg/odp/utils"
 )
 
-// ConfigState is used to represent state of odp
-type ConfigState int64
-
-const (
-	// NotDetermined represents that odp service state is currently not determined
-	NotDetermined ConfigState = iota
-	// Integrated represents that odp service is integrated
-	Integrated
-	// NotIntegrated represents that odp service is not integrated
-	NotIntegrated
-)
-
 // Config is used to represent odp config
 type Config interface {
 	Update(apiKey, apiHost string, segmentsToCheck []string) bool
 	GetAPIKey() string
 	GetAPIHost() string
 	GetSegmentsToCheck() []string
-	IsEventQueueingAllowed() bool
+	IsOdpServiceIntegrated() bool
 }
 
 // DefaultConfig represents default implementation of odp config
 type DefaultConfig struct {
-	apiKey, apiHost      string
-	segmentsToCheck      []string
-	odpServiceIntegrated ConfigState
-	lock                 sync.RWMutex
+	apiKey, apiHost string
+	segmentsToCheck []string
+	lock            sync.RWMutex
 }
 
 // NewConfig creates and returns a new instance of DefaultConfig.
 func NewConfig(apiKey, apiHost string, segmentsToCheck []string) *DefaultConfig {
 	return &DefaultConfig{
-		apiKey:               apiKey,
-		apiHost:              apiHost,
-		segmentsToCheck:      segmentsToCheck,
-		odpServiceIntegrated: NotDetermined, // initially queueing allowed until the first datafile is parsed
+		apiKey:          apiKey,
+		apiHost:         apiHost,
+		segmentsToCheck: segmentsToCheck,
 	}
 }
 
@@ -67,12 +53,6 @@ func (s *DefaultConfig) Update(apiKey, apiHost string, segmentsToCheck []string)
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	// disable future event queueing if datafile has no ODP integrations.
-	s.odpServiceIntegrated = NotIntegrated
-	if apiKey != "" && apiHost != "" {
-		s.odpServiceIntegrated = Integrated
-	}
-
 	if s.apiKey == apiKey && s.apiHost == apiHost && utils.Equal(s.segmentsToCheck, segmentsToCheck) {
 		return false
 	}
@@ -108,13 +88,7 @@ func (s *DefaultConfig) GetSegmentsToCheck() []string {
 	return segmentsToCheck
 }
 
-// IsEventQueueingAllowed returns true if event queueing is allowed
-func (s *DefaultConfig) IsEventQueueingAllowed() bool {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-	value := true
-	if s.odpServiceIntegrated == NotIntegrated {
-		value = false
-	}
-	return value
+// IsOdpServiceIntegrated returns true if odp service is integrated
+func (s *DefaultConfig) IsOdpServiceIntegrated() bool {
+	return s.GetAPIHost() != "" && s.GetAPIKey() != ""
 }

pkg/odp/config_test.go

@@ -43,16 +43,15 @@ func (c *ConfigTestSuite) TestNewConfigWithValidValues() {
 	c.Equal(c.apiHost, c.config.GetAPIHost())
 	c.Equal(c.apiKey, c.config.GetAPIKey())
 	c.Equal(c.segmentsToCheck, c.config.GetSegmentsToCheck())
-	c.True(c.config.IsEventQueueingAllowed())
-	c.Equal(NotDetermined, c.config.odpServiceIntegrated)
+	c.True(c.config.IsOdpServiceIntegrated())
 }
 
 func (c *ConfigTestSuite) TestNewConfigWithEmptyValues() {
 	c.config = NewConfig("", "", nil)
 	c.Equal("", c.config.GetAPIHost())
 	c.Equal("", c.config.GetAPIKey())
 	c.Nil(c.config.GetSegmentsToCheck())
-	c.True(c.config.IsEventQueueingAllowed())
+	c.False(c.config.IsOdpServiceIntegrated())
 }
 
 func (c *ConfigTestSuite) TestUpdateWithValidValues() {
@@ -63,8 +62,7 @@ func (c *ConfigTestSuite) TestUpdateWithValidValues() {
 	c.Equal(expectedAPIKey, c.config.GetAPIKey())
 	c.Equal(expectedAPIHost, c.config.GetAPIHost())
 	c.Equal(expectedSegmentsList, c.config.GetSegmentsToCheck())
-	c.Equal(Integrated, c.config.odpServiceIntegrated)
-	c.True(c.config.IsEventQueueingAllowed())
+	c.True(c.config.IsOdpServiceIntegrated())
 }
 
 func (c *ConfigTestSuite) TestUpdateWithEmptyValues() {
@@ -75,17 +73,15 @@ func (c *ConfigTestSuite) TestUpdateWithEmptyValues() {
 	c.Equal(expectedAPIKey, c.config.GetAPIKey())
 	c.Equal(expectedAPIHost, c.config.GetAPIHost())
 	c.Equal(expectedSegmentsList, c.config.GetSegmentsToCheck())
-	c.Equal(NotIntegrated, c.config.odpServiceIntegrated)
-	c.False(c.config.IsEventQueueingAllowed())
+	c.False(c.config.IsOdpServiceIntegrated())
 }
 
 func (c *ConfigTestSuite) TestUpdateWithSameValues() {
 	c.False(c.config.Update(c.apiKey, c.apiHost, c.segmentsToCheck))
 	c.Equal(c.apiKey, c.config.GetAPIKey())
 	c.Equal(c.apiHost, c.config.GetAPIHost())
 	c.Equal(c.segmentsToCheck, c.config.GetSegmentsToCheck())
-	c.Equal(Integrated, c.config.odpServiceIntegrated)
-	c.True(c.config.IsEventQueueingAllowed())
+	c.True(c.config.IsOdpServiceIntegrated())
 }
 
 func (c *ConfigTestSuite) TestRaceCondition() {
@@ -111,8 +107,8 @@ func (c *ConfigTestSuite) TestRaceCondition() {
 		wg.Done()
 	}
 
-	isEventQueueingAllowed := func() {
-		c.config.IsEventQueueingAllowed()
+	isOdpServiceIntegrated := func() {
+		c.config.IsOdpServiceIntegrated()
 		wg.Done()
 	}
 
@@ -124,7 +120,7 @@ func (c *ConfigTestSuite) TestRaceCondition() {
 		go getAPIKey()
 		go getAPIHost()
 		go getSegmentsToCheck()
-		go isEventQueueingAllowed()
+		go isOdpServiceIntegrated()
 	}
 	wg.Wait()
 }

pkg/odp/lru_cache_test.go

@@ -187,3 +187,14 @@ func TestTimeout(t *testing.T) {
 	assert.Equal(t, 200, cache2.Lookup("2"))
 	assert.Equal(t, 300, cache2.Lookup("3"))
 }
+
+type TestCache struct {
+}
+
+func (l *TestCache) Save(key string, value interface{}) {
+}
+func (l *TestCache) Lookup(key string) interface{} {
+	return nil
+}
+func (l *TestCache) Reset() {
+}

pkg/odp/segment_manager.go

@@ -25,7 +25,7 @@ import (
 
 // SegmentManager represents the odp segment manager.
 type SegmentManager interface {
-	FetchQualifiedSegments(userKey, userValue string, options []SegmentOption) (segments []string, err error)
+	FetchQualifiedSegments(userKey, userValue string, options []OptimizelySegmentOption) (segments []string, err error)
 	Reset()
 }
 
@@ -37,11 +37,14 @@ type DefaultSegmentManager struct {
 }
 
 // NewSegmentManager creates and returns a new instance of DefaultSegmentManager.
-func NewSegmentManager(cacheSize int, cacheTimeoutInSecs int64, odpConfig Config, apiManager SegmentAPIManager) *DefaultSegmentManager {
+func NewSegmentManager(cache Cache, cacheSize int, cacheTimeoutInSecs int64, odpConfig Config, apiManager SegmentAPIManager) *DefaultSegmentManager {
 	segmentManager := DefaultSegmentManager{
 		odpConfig:         odpConfig,
 		segmentAPIManager: apiManager,
-		segmentsCache:     NewLRUCache(cacheSize, cacheTimeoutInSecs),
+		segmentsCache:     cache,
+	}
+	if segmentManager.segmentsCache == nil {
+		segmentManager.segmentsCache = NewLRUCache(cacheSize, cacheTimeoutInSecs)
 	}
 	if segmentManager.odpConfig == nil {
 		segmentManager.odpConfig = NewConfig("", "", nil)
@@ -53,8 +56,8 @@ func NewSegmentManager(cacheSize int, cacheTimeoutInSecs int64, odpConfig Config
 }
 
 // FetchQualifiedSegments fetches and returns qualified segments
-func (s *DefaultSegmentManager) FetchQualifiedSegments(userKey, userValue string, options []SegmentOption) (segments []string, err error) {
-	if s.odpConfig == nil || s.odpConfig.GetAPIHost() == "" || s.odpConfig.GetAPIKey() == "" {
+func (s *DefaultSegmentManager) FetchQualifiedSegments(userKey, userValue string, options []OptimizelySegmentOption) (segments []string, err error) {
+	if s.odpConfig == nil || !s.odpConfig.IsOdpServiceIntegrated() {
 		return nil, fmt.Errorf(fetchSegmentsFailedError, "apiKey/apiHost not defined")
 	}
 

pkg/odp/segment_manager_test.go

@@ -37,27 +37,33 @@ type SegmentManagerTestSuite struct {
 func (s *SegmentManagerTestSuite) SetupTest() {
 	s.segmentAPIManager = &MockSegmentAPIManager{}
 	s.config = NewConfig("", "", nil)
-	s.segmentManager = NewSegmentManager(10, 10, s.config, s.segmentAPIManager)
+	s.segmentManager = NewSegmentManager(nil, 10, 10, s.config, s.segmentAPIManager)
 	s.userValue = "test-user"
 	s.userKey = "vuid"
 }
 
 func (s *SegmentManagerTestSuite) TestNewSegmentManagerNilParameters() {
-	segmentManager := NewSegmentManager(0, 0, nil, nil)
+	segmentManager := NewSegmentManager(nil, 0, 0, nil, nil)
 	s.NotNil(segmentManager.segmentAPIManager)
 	s.NotNil(segmentManager.segmentsCache)
 	s.NotNil(segmentManager.odpConfig)
 }
 
+func (s *SegmentManagerTestSuite) TestNewSegmentManagerCustomCache() {
+	customCache := &TestCache{}
+	segmentManager := NewSegmentManager(customCache, 0, 0, nil, nil)
+	s.Equal(customCache, segmentManager.segmentsCache)
+}
+
 func (s *SegmentManagerTestSuite) TestFetchSegmentsNilConfig() {
-	segmentManager := NewSegmentManager(0, 0, nil, nil)
+	segmentManager := NewSegmentManager(nil, 0, 0, nil, nil)
 	segments, err := segmentManager.FetchQualifiedSegments(s.userKey, s.userValue, nil)
 	s.Nil(segments)
 	s.Error(err)
 }
 
 func (s *SegmentManagerTestSuite) TestFetchSegmentsNoSegmentsToCheckInConfig() {
-	segmentManager := NewSegmentManager(0, 0, NewConfig("a", "b", nil), nil)
+	segmentManager := NewSegmentManager(nil, 0, 0, NewConfig("a", "b", nil), nil)
 	segments, err := segmentManager.FetchQualifiedSegments(s.userKey, s.userValue, nil)
 	s.Empty(segments)
 	s.Nil(err)
@@ -100,7 +106,7 @@ func (s *SegmentManagerTestSuite) TestOptionsIgnoreCache() {
 	s.setCache(s.userKey, s.userValue, []string{"a"})
 	s.segmentAPIManager.On("FetchSegments", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 
-	segments, err := s.segmentManager.FetchQualifiedSegments(s.userKey, s.userValue, []SegmentOption{IgnoreCache})
+	segments, err := s.segmentManager.FetchQualifiedSegments(s.userKey, s.userValue, []OptimizelySegmentOption{IgnoreCache})
 	s.Nil(err)
 	s.Equal(expectedSegments, segments)
 }
@@ -113,7 +119,7 @@ func (s *SegmentManagerTestSuite) TestOptionsResetCache() {
 	s.setCache(s.userKey, "456", []string{"a"})
 	s.segmentAPIManager.On("FetchSegments", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
 
-	segments, err := s.segmentManager.FetchQualifiedSegments(s.userKey, s.userValue, []SegmentOption{ResetCache})
+	segments, err := s.segmentManager.FetchQualifiedSegments(s.userKey, s.userValue, []OptimizelySegmentOption{ResetCache})
 	s.Nil(err)
 	s.Equal(expectedSegments, segments)
 }

pkg/odp/segment_option.go

@@ -17,12 +17,12 @@
 // Package odp //
 package odp
 
-// SegmentOption represents options controlling audience segments.
-type SegmentOption int64
+// OptimizelySegmentOption represents options controlling audience segments.
+type OptimizelySegmentOption int
 
 const (
 	// IgnoreCache ignores cache (save/lookup)
-	IgnoreCache SegmentOption = iota
+	IgnoreCache OptimizelySegmentOption = iota
 	// ResetCache resets cache
 	ResetCache
 )