fix(fsc): Fixes to test is_feature_enabled with fsc. (#47)

Author: yasirfolio3

optimizely/config/datafileProjectConfig/config.go

@@ -78,8 +78,9 @@ func NewDatafileProjectConfig(jsonDatafile []byte) (*DatafileProjectConfig, erro
 
 	experiments, experimentKeyMap := mappers.MapExperiments(datafile.Experiments)
 	rolloutMap := mappers.MapRollouts(datafile.Rollouts)
+	mergedAudiences := append(datafile.TypedAudiences, datafile.Audiences...)
 	config := &DatafileProjectConfig{
-		audienceMap:          mappers.MapAudiences(datafile.TypedAudiences),
+		audienceMap:          mappers.MapAudiences(mergedAudiences),
 		experimentMap:        experiments,
 		experimentKeyToIDMap: experimentKeyMap,
 		rolloutMap:           rolloutMap,

optimizely/config/datafileProjectConfig/mappers/audience.go

@@ -26,14 +26,17 @@ func MapAudiences(audiences []datafileEntities.Audience) map[string]entities.Aud
 
 	audienceMap := make(map[string]entities.Audience)
 	for _, audience := range audiences {
-		conditionTree, err := buildConditionTree(audience.Conditions)
-		if err != nil {
-			// @TODO: handle error
-		}
-		audienceMap[audience.ID] = entities.Audience{
-			ID:            audience.ID,
-			Name:          audience.Name,
-			ConditionTree: conditionTree,
+		_, ok := audienceMap[audience.ID]
+		if !ok {
+			conditionTree, err := buildConditionTree(audience.Conditions)
+			if err != nil {
+				// @TODO: handle error
+			}
+			audienceMap[audience.ID] = entities.Audience{
+				ID:            audience.ID,
+				Name:          audience.Name,
+				ConditionTree: conditionTree,
+			}
 		}
 	}
 	return audienceMap

optimizely/config/datafileProjectConfig/mappers/condition_trees.go

@@ -28,7 +28,16 @@ var ErrEmptyTree = errors.New("Empty Tree")
 
 // Takes the conditions array from the audience in the datafile and turns it into a condition tree
 func buildConditionTree(conditions interface{}) (conditionTree *entities.TreeNode, retErr error) {
-	value := reflect.ValueOf(conditions)
+
+	var parsedConditions interface{}
+	switch v := conditions.(type) {
+	case string:
+		json.Unmarshal([]byte(v), &parsedConditions)
+	default:
+		parsedConditions = conditions
+	}
+
+	value := reflect.ValueOf(parsedConditions)
 	visited := make(map[interface{}]bool)
 
 	conditionTree = &entities.TreeNode{}

optimizely/config/datafileProjectConfig/mappers/condition_trees_test.go

@@ -20,6 +20,7 @@ import (
 	"encoding/json"
 	"testing"
 
+	datafileConfig "github.com/optimizely/go-sdk/optimizely/config/datafileProjectConfig/entities"
 	"github.com/optimizely/go-sdk/optimizely/entities"
 	"github.com/stretchr/testify/assert"
 )
@@ -60,6 +61,44 @@ func TestBuildAudienceConditionTreeSimpleAudienceCondition(t *testing.T) {
 	assert.Equal(t, expectedConditionTree, conditionTree)
 }
 
+func TestBuildConditionTreeUsingDatafileAudienceConditions(t *testing.T) {
+
+	audience := datafileConfig.Audience{
+		ID:         "12567320080",
+		Name:       "message",
+		Conditions: "[\"and\", [\"or\", [\"or\", {\"name\": \"s_foo\", \"type\": \"custom_attribute\", \"value\": \"foo\"}]]]",
+	}
+
+	conditionTree, err := buildConditionTree(audience.Conditions)
+	if err != nil {
+		assert.Fail(t, err.Error())
+	}
+
+	expectedConditionTree := &entities.TreeNode{
+		Operator: "and",
+		Nodes: []*entities.TreeNode{
+			{
+				Operator: "or",
+				Nodes: []*entities.TreeNode{
+					{
+						Operator: "or",
+						Nodes: []*entities.TreeNode{
+							{
+								Item: entities.Condition{
+									Name:  "s_foo",
+									Type:  "custom_attribute",
+									Value: "foo",
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	assert.Equal(t, expectedConditionTree, conditionTree)
+}
+
 func TestBuildConditionTreeSimpleAudienceCondition(t *testing.T) {
 	conditionString := "[ \"and\", [ \"or\", [ \"or\", { \"type\": \"custom_attribute\", \"name\": \"s_foo\", \"match\": \"exact\", \"value\": \"foo\" } ] ] ]"
 	var conditions interface{}

optimizely/config/polling_manager_test.go

@@ -43,7 +43,7 @@ func TestNewPollingProjectConfigManager(t *testing.T) {
 	newConfig := configManager.GetConfig()
 
 	assert.Equal(t, "", newConfig.GetAccountID())
-	assert.Equal(t, 3, len(newConfig.GetAudienceMap()))
+	assert.Equal(t, 4, len(newConfig.GetAudienceMap()))
 	assert.Equal(t, "", configManager.GetMetrics())
 
 }

optimizely/decision/evaluator/condition.go

@@ -18,6 +18,7 @@ package evaluator
 
 import (
 	"fmt"
+
 	"github.com/optimizely/go-sdk/optimizely/decision/evaluator/matchers"
 	"github.com/optimizely/go-sdk/optimizely/entities"
 )
@@ -47,6 +48,9 @@ func (c CustomAttributeConditionEvaluator) Evaluate(condition entities.Condition
 
 	var matcher matchers.Matcher
 	matchType := condition.Match
+	if matchType == "" {
+		matchType = exactMatchType
+	}
 	switch matchType {
 	case exactMatchType:
 		matcher = matchers.ExactMatcher{

optimizely/decision/evaluator/condition_test.go

@@ -52,3 +52,32 @@ func TestCustomAttributeConditionEvaluator(t *testing.T) {
 	result, _ = conditionEvaluator.Evaluate(condition, condTreeParams)
 	assert.Equal(t, result, false)
 }
+
+func TestCustomAttributeConditionEvaluatorWithoutMatchType(t *testing.T) {
+	conditionEvaluator := CustomAttributeConditionEvaluator{}
+	condition := entities.Condition{
+		Value: "foo",
+		Name:  "string_foo",
+		Type:  "custom_attribute",
+	}
+
+	// Test condition passes
+	user := entities.UserContext{
+		Attributes: map[string]interface{}{
+			"string_foo": "foo",
+		},
+	}
+
+	condTreeParams := entities.NewTreeParameters(&user, map[string]entities.Audience{})
+	result, _ := conditionEvaluator.Evaluate(condition, condTreeParams)
+	assert.Equal(t, result, true)
+
+	// Test condition fails
+	user = entities.UserContext{
+		Attributes: map[string]interface{}{
+			"string_foo": "not_foo",
+		},
+	}
+	result, _ = conditionEvaluator.Evaluate(condition, condTreeParams)
+	assert.Equal(t, result, false)
+}

optimizely/decision/experiment_bucketer_service.go

@@ -52,7 +52,7 @@ func (s ExperimentBucketerService) GetDecision(decisionContext ExperimentDecisio
 	// bucket user into a variation
 	bucketingID, err := userContext.GetBucketingID()
 	if err != nil {
-		return experimentDecision, fmt.Errorf(`Error computing bucketing ID for experiment "%s": "%s"`, experiment.Key, err.Error())
+		bLogger.Debug(fmt.Sprintf(`Error computing bucketing ID for experiment "%s": "%s"`, experiment.Key, err.Error()))
 	}
 
 	bLogger.Debug(fmt.Sprintf(`Using bucketing ID: "%s"`, bucketingID))

optimizely/utils/types.go

@@ -26,41 +26,50 @@ var intType = reflect.TypeOf(int64(0))
 
 // GetBoolValue will attempt to convert the given value to a bool
 func GetBoolValue(value interface{}) (bool, error) {
-	v := reflect.ValueOf(value)
-	if v.Type().String() == "bool" {
-		return v.Bool(), nil
+	if value != nil {
+		v := reflect.ValueOf(value)
+		if v.Type().String() == "bool" {
+			return v.Bool(), nil
+		}
 	}
 
 	return false, fmt.Errorf(`Value "%v" could not be converted to bool`, value)
 }
 
 // GetFloatValue will attempt to convert the given value to a float64
 func GetFloatValue(value interface{}) (float64, error) {
-	v := reflect.ValueOf(value)
-	if v.Type().String() == "float64" || v.Type().ConvertibleTo(floatType) {
-		floatValue := v.Convert(floatType).Float()
-		return floatValue, nil
+	if value != nil {
+		v := reflect.ValueOf(value)
+		v = reflect.Indirect(v)
+		if v.Type().ConvertibleTo(floatType) {
+			fv := v.Convert(floatType)
+			return fv.Float(), nil
+		}
 	}
 
 	return 0, fmt.Errorf(`Value "%v" could not be converted to float`, value)
 }
 
 // GetIntValue will attempt to convert the given value to an int64
 func GetIntValue(value interface{}) (int64, error) {
-	v := reflect.ValueOf(value)
-	if v.Type().String() == "int64" || v.Type().ConvertibleTo(intType) {
-		intValue := v.Convert(intType).Int()
-		return intValue, nil
+	if value != nil {
+		v := reflect.ValueOf(value)
+		if v.Type().String() == "int64" || v.Type().ConvertibleTo(intType) {
+			intValue := v.Convert(intType).Int()
+			return intValue, nil
+		}
 	}
 
 	return 0, fmt.Errorf(`Value "%v" could not be converted to int`, value)
 }
 
 // GetStringValue will attempt to convert the given value to a string
 func GetStringValue(value interface{}) (string, error) {
-	v := reflect.ValueOf(value)
-	if v.Type().String() == "string" {
-		return v.String(), nil
+	if value != nil {
+		v := reflect.ValueOf(value)
+		if v.Type().String() == "string" {
+			return v.String(), nil
+		}
 	}
 
 	return "", fmt.Errorf(`Value "%v" could not be converted to string`, value)