feat(integrations): Added support for integrations in datafile and evaluation.

examples/main.go

@@ -7,7 +7,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/optimizely/go-sdk"
+	optimizely "github.com/optimizely/go-sdk"
 	"github.com/optimizely/go-sdk/pkg/client"
 	"github.com/optimizely/go-sdk/pkg/config"
 	"github.com/optimizely/go-sdk/pkg/event"

pkg/client/client.go

@@ -1,11 +1,11 @@
 /****************************************************************************
- * Copyright 2019-2021, Optimizely, Inc. and contributors                   *
+ * Copyright 2019-2022, 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                            *
+ *    https://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,        *
@@ -53,7 +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 {
-	return newOptimizelyUserContext(o, userID, attributes, nil)
+	return newOptimizelyUserContext(o, userID, attributes, nil, nil)
 }
 
 func (o *OptimizelyClient) decide(userContext OptimizelyUserContext, key string, options *decide.Options) OptimizelyDecision {
@@ -90,8 +90,9 @@ func (o *OptimizelyClient) decide(userContext OptimizelyUserContext, key string,
 	decisionContext.Feature = &feature
 
 	usrContext := entities.UserContext{
-		ID:         userContext.GetUserID(),
-		Attributes: userContext.GetUserAttributes(),
+		ID:                userContext.GetUserID(),
+		Attributes:        userContext.GetUserAttributes(),
+		QualifiedSegments: userContext.GetQualifiedSegments(),
 	}
 	var variationKey string
 	var eventSent, flagEnabled bool

pkg/client/optimizely_user_context.go

@@ -1,11 +1,11 @@
 /****************************************************************************
- * Copyright 2020-2021, Optimizely, Inc. and contributors                   *
+ * Copyright 2020-2022, 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                            *
+ *    https://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,        *
@@ -31,21 +31,24 @@ type OptimizelyUserContext struct {
 	UserID     string                 `json:"userId"`
 	Attributes map[string]interface{} `json:"attributes"`
 
+	qualifiedSegments     []string
 	optimizely            *OptimizelyClient
 	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 *pkgDecision.ForcedDecisionService) OptimizelyUserContext {
+func newOptimizelyUserContext(optimizely *OptimizelyClient, userID string, attributes map[string]interface{}, qualifiedSegments []string, 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{}{}
 	}
 	attributesCopy := copyUserAttributes(attributes)
+	qualifiedSegmentsCopy := copyQualifiedSegments(qualifiedSegments)
 	return OptimizelyUserContext{
 		UserID:                userID,
 		Attributes:            attributesCopy,
+		qualifiedSegments:     qualifiedSegmentsCopy,
 		optimizely:            optimizely,
 		forcedDecisionService: forcedDecisionService,
 		mutex:                 new(sync.RWMutex),
@@ -69,6 +72,13 @@ func (o OptimizelyUserContext) GetUserAttributes() map[string]interface{} {
 	return copyUserAttributes(o.Attributes)
 }
 
+// GetQualifiedSegments returns qualified segments for Optimizely user context
+func (o *OptimizelyUserContext) GetQualifiedSegments() []string {
+	o.mutex.RLock()
+	defer o.mutex.RUnlock()
+	return copyQualifiedSegments(o.qualifiedSegments)
+}
+
 func (o OptimizelyUserContext) getForcedDecisionService() *pkgDecision.ForcedDecisionService {
 	if o.forcedDecisionService != nil {
 		return o.forcedDecisionService.CreateCopy()
@@ -86,25 +96,40 @@ func (o *OptimizelyUserContext) SetAttribute(key string, value interface{}) {
 	o.Attributes[key] = value
 }
 
+// SetQualifiedSegments clears and adds qualified segments for Optimizely user context
+func (o *OptimizelyUserContext) SetQualifiedSegments(qualifiedSegments []string) {
+	o.mutex.Lock()
+	defer o.mutex.Unlock()
+	o.qualifiedSegments = copyQualifiedSegments(qualifiedSegments)
+}
+
+// IsQualifiedFor returns true if the user is qualified for the given segment name
+func (o *OptimizelyUserContext) IsQualifiedFor(segment string) bool {
+	userContext := entities.UserContext{
+		QualifiedSegments: o.GetQualifiedSegments(),
+	}
+	return userContext.IsQualifiedFor(segment)
+}
+
 // Decide returns a decision result for a given flag key and a user context, which contains
 // 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.getForcedDecisionService())
+	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.GetQualifiedSegments(), o.getForcedDecisionService())
 	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.getForcedDecisionService())
+	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.GetQualifiedSegments(), o.getForcedDecisionService())
 	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.getForcedDecisionService())
+	userContextCopy := newOptimizelyUserContext(o.GetOptimizely(), o.GetUserID(), o.GetUserAttributes(), o.GetQualifiedSegments(), o.getForcedDecisionService())
 	return o.optimizely.decideForKeys(userContextCopy, keys, convertDecideOptions(options))
 }
 
@@ -160,3 +185,12 @@ func copyUserAttributes(attributes map[string]interface{}) (attributesCopy map[s
 	}
 	return attributesCopy
 }
+
+func copyQualifiedSegments(qualifiedSegments []string) (qualifiedSegmentsCopy []string) {
+	if qualifiedSegments == nil {
+		return nil
+	}
+	qualifiedSegmentsCopy = make([]string, len(qualifiedSegments))
+	copy(qualifiedSegmentsCopy, qualifiedSegments)
+	return qualifiedSegmentsCopy
+}

pkg/client/optimizely_user_context_test.go

@@ -1,11 +1,11 @@
 /****************************************************************************
- * Copyright 2020-2021, Optimizely, Inc. and contributors                   *
+ * Copyright 2020-2022, 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                            *
+ *    https://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,        *
@@ -55,65 +55,83 @@ func (s *OptimizelyUserContextTestSuite) SetupTest() {
 	s.userID = "tester"
 }
 
-func (s *OptimizelyUserContextTestSuite) TestOptimizelyUserContextWithAttributes() {
+func (s *OptimizelyUserContextTestSuite) TestOptimizelyUserContextWithAttributesAndSegments() {
 	attributes := map[string]interface{}{"key1": 1212, "key2": 1213}
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, nil)
+	segments := []string{"123"}
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, segments, nil)
 
 	s.Equal(s.OptimizelyClient, optimizelyUserContext.GetOptimizely())
 	s.Equal(s.userID, optimizelyUserContext.GetUserID())
 	s.Equal(attributes, optimizelyUserContext.GetUserAttributes())
+	s.Equal(segments, optimizelyUserContext.GetQualifiedSegments())
 	s.Nil(optimizelyUserContext.forcedDecisionService)
 }
 
-func (s *OptimizelyUserContextTestSuite) TestOptimizelyUserContextNoAttributes() {
+func (s *OptimizelyUserContextTestSuite) TestOptimizelyUserContextNoAttributesAndNilSegments() {
 	attributes := map[string]interface{}{}
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, nil)
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, nil, nil)
 
 	s.Equal(s.OptimizelyClient, optimizelyUserContext.GetOptimizely())
 	s.Equal(s.userID, optimizelyUserContext.GetUserID())
 	s.Equal(attributes, optimizelyUserContext.GetUserAttributes())
+	s.Nil(optimizelyUserContext.GetQualifiedSegments())
 }
 
 func (s *OptimizelyUserContextTestSuite) TestUpatingProvidedUserContextHasNoImpactOnOptimizelyUserContext() {
 	attributes := map[string]interface{}{"k1": "v1", "k2": false}
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, nil)
+	segments := []string{"123"}
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, s.userID, attributes, segments, nil)
 
 	s.Equal(s.OptimizelyClient, optimizelyUserContext.GetOptimizely())
 	s.Equal(s.userID, optimizelyUserContext.GetUserID())
 	s.Equal(attributes, optimizelyUserContext.GetUserAttributes())
+	s.Equal(segments, optimizelyUserContext.GetQualifiedSegments())
 
 	attributes["k1"] = "v2"
 	attributes["k2"] = true
+	segments[0] = "456"
 
 	s.Equal("v1", optimizelyUserContext.GetUserAttributes()["k1"])
 	s.Equal(false, optimizelyUserContext.GetUserAttributes()["k2"])
+	s.Equal([]string{"123"}, optimizelyUserContext.GetQualifiedSegments())
 
 	attributes = optimizelyUserContext.GetUserAttributes()
+	segments = optimizelyUserContext.GetQualifiedSegments()
 	attributes["k1"] = "v2"
 	attributes["k2"] = true
+	segments[0] = "456"
 
 	s.Equal("v1", optimizelyUserContext.GetUserAttributes()["k1"])
 	s.Equal(false, optimizelyUserContext.GetUserAttributes()["k2"])
+	s.Equal([]string{"123"}, optimizelyUserContext.GetQualifiedSegments())
 }
 
-func (s *OptimizelyUserContextTestSuite) TestSetAttribute() {
+func (s *OptimizelyUserContextTestSuite) TestSetAndGetUserAttributesRaceCondition() {
 	userID := "1212121"
 	var attributes map[string]interface{}
 
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil)
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil, nil)
 	s.Equal(s.OptimizelyClient, optimizelyUserContext.GetOptimizely())
 
 	var wg sync.WaitGroup
-	wg.Add(4)
+	wg.Add(8)
 	addInsideGoRoutine := func(key string, value interface{}, wg *sync.WaitGroup) {
 		optimizelyUserContext.SetAttribute(key, value)
 		wg.Done()
 	}
+	getInsideGoRoutine := func(wg *sync.WaitGroup) {
+		optimizelyUserContext.GetUserAttributes()
+		wg.Done()
+	}
 
 	go addInsideGoRoutine("k1", "v1", &wg)
 	go addInsideGoRoutine("k2", true, &wg)
 	go addInsideGoRoutine("k3", 100, &wg)
 	go addInsideGoRoutine("k4", 3.5, &wg)
+	go getInsideGoRoutine(&wg)
+	go getInsideGoRoutine(&wg)
+	go getInsideGoRoutine(&wg)
+	go getInsideGoRoutine(&wg)
 	wg.Wait()
 
 	s.Equal(userID, optimizelyUserContext.GetUserID())
@@ -126,7 +144,7 @@ func (s *OptimizelyUserContextTestSuite) TestSetAttribute() {
 func (s *OptimizelyUserContextTestSuite) TestSetAttributeOverride() {
 	userID := "1212121"
 	attributes := map[string]interface{}{"k1": "v1", "k2": false}
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil)
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil, nil)
 
 	s.Equal(s.OptimizelyClient, optimizelyUserContext.GetOptimizely())
 	s.Equal(userID, optimizelyUserContext.GetUserID())
@@ -142,7 +160,7 @@ func (s *OptimizelyUserContextTestSuite) TestSetAttributeOverride() {
 func (s *OptimizelyUserContextTestSuite) TestSetAttributeNullValue() {
 	userID := "1212121"
 	attributes := map[string]interface{}{"k1": nil}
-	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil)
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil, nil)
 
 	s.Equal(s.OptimizelyClient, optimizelyUserContext.GetOptimizely())
 	s.Equal(userID, optimizelyUserContext.GetUserID())
@@ -155,6 +173,87 @@ func (s *OptimizelyUserContextTestSuite) TestSetAttributeNullValue() {
 	s.Equal(nil, optimizelyUserContext.GetUserAttributes()["k1"])
 }
 
+func (s *OptimizelyUserContextTestSuite) TestSetAndGetQualifiedSegments() {
+	userID := "1212121"
+	var attributes map[string]interface{}
+	qualifiedSegments := []string{"1", "2", "3"}
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, []string{}, nil)
+	s.Len(optimizelyUserContext.GetQualifiedSegments(), 0)
+
+	optimizelyUserContext.SetQualifiedSegments(nil)
+	s.Nil(optimizelyUserContext.GetQualifiedSegments())
+
+	optimizelyUserContext.SetQualifiedSegments(qualifiedSegments)
+	s.Equal(qualifiedSegments, optimizelyUserContext.GetQualifiedSegments())
+}
+
+func (s *OptimizelyUserContextTestSuite) TestQualifiedSegmentsRaceCondition() {
+	userID := "1212121"
+	qualifiedSegments := []string{"1", "2", "3"}
+	segment := "1"
+	var attributes map[string]interface{}
+
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil, nil)
+	s.Nil(optimizelyUserContext.GetQualifiedSegments())
+	var wg sync.WaitGroup
+	wg.Add(9)
+
+	setQualifiedSegments := func(value []string, wg *sync.WaitGroup) {
+		optimizelyUserContext.SetQualifiedSegments(value)
+		wg.Done()
+	}
+	getQualifiedSegments := func(wg *sync.WaitGroup) {
+		optimizelyUserContext.GetQualifiedSegments()
+		wg.Done()
+	}
+
+	IsQualifiedFor := func(segment string, wg *sync.WaitGroup) {
+		optimizelyUserContext.IsQualifiedFor(segment)
+		wg.Done()
+	}
+
+	go setQualifiedSegments(qualifiedSegments, &wg)
+	go setQualifiedSegments(qualifiedSegments, &wg)
+	go setQualifiedSegments(qualifiedSegments, &wg)
+	go getQualifiedSegments(&wg)
+	go getQualifiedSegments(&wg)
+	go getQualifiedSegments(&wg)
+	go IsQualifiedFor(segment, &wg)
+	go IsQualifiedFor(segment, &wg)
+	go IsQualifiedFor(segment, &wg)
+
+	wg.Wait()
+
+	s.Equal(qualifiedSegments, optimizelyUserContext.GetQualifiedSegments())
+	s.Equal(true, optimizelyUserContext.IsQualifiedFor(segment))
+}
+
+func (s *OptimizelyUserContextTestSuite) TestIsQualifiedFor() {
+	userID := "1212121"
+	qualifiedSegments := []string{"1", "2", "3"}
+	var attributes map[string]interface{}
+
+	optimizelyUserContext := newOptimizelyUserContext(s.OptimizelyClient, userID, attributes, nil, nil)
+	s.False(optimizelyUserContext.IsQualifiedFor("1"))
+	optimizelyUserContext.SetQualifiedSegments(qualifiedSegments)
+
+	var wg sync.WaitGroup
+	wg.Add(6)
+	testInsideGoRoutine := func(value string, result bool, wg *sync.WaitGroup) {
+		s.Equal(result, optimizelyUserContext.IsQualifiedFor(value))
+		wg.Done()
+	}
+
+	go testInsideGoRoutine("1", true, &wg)
+	go testInsideGoRoutine("2", true, &wg)
+	go testInsideGoRoutine("3", true, &wg)
+	go testInsideGoRoutine("4", false, &wg)
+	go testInsideGoRoutine("5", false, &wg)
+	go testInsideGoRoutine("6", false, &wg)
+
+	wg.Wait()
+}
+
 func (s *OptimizelyUserContextTestSuite) TestDecideResponseContainsUserContextCopy() {
 	flagKey := "feature_2"
 	userContext := s.OptimizelyClient.CreateUserContext(s.userID, nil)
@@ -163,8 +262,11 @@ func (s *OptimizelyUserContextTestSuite) TestDecideResponseContainsUserContextCo
 
 	// Change attributes for user context
 	userContext.SetAttribute("test", 123)
-	// Attributes should not update for the userContext returned inside decision
+	// Change qualifiedSegments for user context
+	userContext.SetQualifiedSegments([]string{"123"})
+	// Attributes and qualifiedSegments should not update for the userContext returned inside decision
 	s.Nil(decisionUserContext.Attributes["test"])
+	s.Len(decisionUserContext.qualifiedSegments, 0)
 }
 
 func (s *OptimizelyUserContextTestSuite) TestDecideFeatureTest() {