fix: support audience ids (#161)

Author: Michael Ng

pkg/config/datafileprojectconfig/entities/entities.go

@@ -42,7 +42,7 @@ type Experiment struct {
 	TrafficAllocation  []trafficAllocation `json:"trafficAllocation"`
 	AudienceIds        []string            `json:"audienceIds"`
 	ForcedVariations   map[string]string   `json:"forcedVariations"`
-	AudienceConditions interface{}         `json:"audienceConditions"`
+	AudienceConditions []interface{}       `json:"audienceConditions"`
 }
 
 // FeatureFlag represents a FeatureFlag object from the Optimizely datafile

pkg/config/datafileprojectconfig/mappers/condition_trees.go

@@ -108,7 +108,7 @@ func buildAudienceConditionTree(conditions interface{}) (conditionTree *entities
 	value := reflect.ValueOf(conditions)
 	visited := make(map[interface{}]bool)
 
-	conditionTree = &entities.TreeNode{}
+	conditionTree = &entities.TreeNode{ Operator: "or" }
 	var populateConditions func(v reflect.Value, root *entities.TreeNode)
 	populateConditions = func(v reflect.Value, root *entities.TreeNode) {
 

pkg/config/datafileprojectconfig/mappers/condition_trees_test.go

@@ -30,8 +30,9 @@ func TestBuildAudienceConditionTreeEmpty(t *testing.T) {
 	json.Unmarshal([]byte(conditionString), &conditions)
 	conditionTree, err := buildAudienceConditionTree(conditions)
 
-	assert.NotNil(t, err)
-	assert.Equal(t, (*entities.TreeNode)(nil), conditionTree)
+	expectedTree := &entities.TreeNode{Operator: "or"}
+	assert.NoError(t, err)
+	assert.Equal(t, expectedTree, conditionTree)
 }
 
 func TestBuildAudienceConditionTreeSimpleAudienceCondition(t *testing.T) {
@@ -70,6 +71,22 @@ func TestBuildAudienceConditionTreeSimpleAudienceCondition(t *testing.T) {
 	assert.Equal(t, expectedConditionTree, conditionTree)
 }
 
+func TestBuildAudienceConditionTreeNoOperators(t *testing.T) {
+	conditions := []string{"123"}
+	expectedConditionTree := &entities.TreeNode{
+		Operator: "or",
+		Nodes: []*entities.TreeNode{
+			{
+				Item: "123",
+			},
+		},
+	}
+
+	conditionTree, err := buildAudienceConditionTree(conditions)
+	assert.Equal(t, expectedConditionTree, conditionTree)
+	assert.NoError(t, err)
+}
+
 func TestBuildConditionTreeUsingDatafileAudienceConditions(t *testing.T) {
 
 	audience := datafileConfig.Audience{

pkg/config/datafileprojectconfig/mappers/experiment.go

@@ -56,7 +56,13 @@ func mapVariation(rawVariation datafileEntities.Variation) entities.Variation {
 
 // Maps the raw experiment entity from the datafile into an SDK Experiment entity
 func mapExperiment(rawExperiment datafileEntities.Experiment) entities.Experiment {
-	audienceConditionTree, err := buildAudienceConditionTree(rawExperiment.AudienceConditions)
+	var audienceConditionTree *entities.TreeNode
+	var err error
+	if rawExperiment.AudienceConditions == nil && len(rawExperiment.AudienceIds) > 0 {
+		audienceConditionTree, err = buildAudienceConditionTree(rawExperiment.AudienceIds)
+	} else if len(rawExperiment.AudienceConditions) > 0 {
+		audienceConditionTree, err = buildAudienceConditionTree(rawExperiment.AudienceConditions)
+	}
 	if err != nil {
 		// @TODO: handle error
 		func() {}() // cheat the linters

pkg/config/datafileprojectconfig/mappers/experiment_test.go

@@ -19,7 +19,7 @@ package mappers
 import (
 	"testing"
 
-	"github.com/json-iterator/go"
+	jsoniter "github.com/json-iterator/go"
 	datafileEntities "github.com/optimizely/go-sdk/pkg/config/datafileprojectconfig/entities"
 	"github.com/optimizely/go-sdk/pkg/entities"
 	"github.com/stretchr/testify/assert"
@@ -113,3 +113,31 @@ func TestMapExperiments(t *testing.T) {
 	assert.Equal(t, expectedExperiments, experiments)
 	assert.Equal(t, expectedExperimentKeyMap, experimentKeyMap)
 }
+
+func TestMapExperimentsAudienceIdsOnly(t *testing.T) {
+	var rawExperiment datafileEntities.Experiment
+	rawExperiment.AudienceIds = []string{"11111", "11112"}
+	rawExperiment.Key = "test_experiment_1"
+	rawExperiment.ID = "22222"
+
+	expectedExperiment := entities.Experiment{
+		AudienceIds: rawExperiment.AudienceIds,
+		ID:          rawExperiment.ID,
+		Key:         rawExperiment.Key,
+		AudienceConditionTree: &entities.TreeNode{
+			Operator: "or",
+			Nodes: []*entities.TreeNode{
+				{
+					Operator: "",
+					Item:     "11111",
+				},
+				{
+					Operator: "",
+					Item:     "11112",
+				},
+			},
+		},
+	}
+	experiments, _ := MapExperiments([]datafileEntities.Experiment{rawExperiment})
+	assert.Equal(t, expectedExperiment.AudienceConditionTree, experiments[rawExperiment.ID].AudienceConditionTree)
+}

pkg/decision/evaluator/matchers/exact.go

@@ -34,23 +34,23 @@ func (m ExactMatcher) Match(user entities.UserContext) (bool, error) {
 	if stringValue, ok := m.Condition.Value.(string); ok {
 		attributeValue, err := user.GetStringAttribute(m.Condition.Name)
 		if err != nil {
-			return false, err
+			return false, nil
 		}
 		return stringValue == attributeValue, nil
 	}
 
 	if boolValue, ok := m.Condition.Value.(bool); ok {
 		attributeValue, err := user.GetBoolAttribute(m.Condition.Name)
 		if err != nil {
-			return false, err
+			return false, nil
 		}
 		return boolValue == attributeValue, nil
 	}
 
 	if floatValue, ok := utils.ToFloat(m.Condition.Value); ok {
 		attributeValue, err := user.GetFloatAttribute(m.Condition.Name)
 		if err != nil {
-			return false, err
+			return false, nil
 		}
 		return floatValue == attributeValue, nil
 	}

pkg/decision/evaluator/matchers/exact_test.go

@@ -54,15 +54,15 @@ func TestExactMatcherString(t *testing.T) {
 	assert.NoError(t, err)
 	assert.False(t, result)
 
-	// Test error case
+	// Test attribute not found
 	user = entities.UserContext{
 		Attributes: map[string]interface{}{
 			"string_not_foo": "foo",
 		},
 	}
 
 	_, err = matcher.Match(user)
-	assert.Error(t, err)
+	assert.NoError(t, err)
 }
 
 func TestExactMatcherBool(t *testing.T) {
@@ -95,15 +95,15 @@ func TestExactMatcherBool(t *testing.T) {
 	assert.NoError(t, err)
 	assert.False(t, result)
 
-	// Test error case
+	// Test attribute not found
 	user = entities.UserContext{
 		Attributes: map[string]interface{}{
 			"not_bool_true": true,
 		},
 	}
 
 	_, err = matcher.Match(user)
-	assert.Error(t, err)
+	assert.NoError(t, err)
 }
 
 func TestExactMatcherInt(t *testing.T) {
@@ -147,15 +147,15 @@ func TestExactMatcherInt(t *testing.T) {
 	assert.NoError(t, err)
 	assert.False(t, result)
 
-	// Test error case
+	// Test attribute not found
 	user = entities.UserContext{
 		Attributes: map[string]interface{}{
 			"int_43": 42,
 		},
 	}
 
 	_, err = matcher.Match(user)
-	assert.Error(t, err)
+	assert.NoError(t, err)
 }
 
 func TestExactMatcherFloat(t *testing.T) {
@@ -188,13 +188,13 @@ func TestExactMatcherFloat(t *testing.T) {
 	assert.NoError(t, err)
 	assert.False(t, result)
 
-	// Test error case
+	// Test attribute not found
 	user = entities.UserContext{
 		Attributes: map[string]interface{}{
 			"float_4_3": 4.2,
 		},
 	}
 
 	_, err = matcher.Match(user)
-	assert.Error(t, err)
+	assert.NoError(t, err)
 }

pkg/decision/evaluator/matchers/gt.go

@@ -35,7 +35,7 @@ func (m GtMatcher) Match(user entities.UserContext) (bool, error) {
 	if floatValue, ok := utils.ToFloat(m.Condition.Value); ok {
 		attributeValue, err := user.GetFloatAttribute(m.Condition.Name)
 		if err != nil {
-			return false, err
+			return false, nil
 		}
 		return floatValue < attributeValue, nil
 	}

pkg/decision/evaluator/matchers/gt_test.go

@@ -76,15 +76,15 @@ func TestGtMatcherInt(t *testing.T) {
 	assert.NoError(t, err)
 	assert.False(t, result)
 
-	// Test error case
+	// Test attribute not found
 	user = entities.UserContext{
 		Attributes: map[string]interface{}{
 			"int_43": 42,
 		},
 	}
 
 	_, err = matcher.Match(user)
-	assert.Error(t, err)
+	assert.NoError(t, err)
 }
 
 func TestGtMatcherFloat(t *testing.T) {
@@ -127,13 +127,13 @@ func TestGtMatcherFloat(t *testing.T) {
 	assert.NoError(t, err)
 	assert.False(t, result)
 
-	// Test error case
+	// Test attribute not found
 	user = entities.UserContext{
 		Attributes: map[string]interface{}{
 			"float_4_3": 4.2,
 		},
 	}
 
 	_, err = matcher.Match(user)
-	assert.Error(t, err)
+	assert.NoError(t, err)
 }

pkg/decision/evaluator/matchers/lt.go

@@ -35,7 +35,7 @@ func (m LtMatcher) Match(user entities.UserContext) (bool, error) {
 	if floatValue, ok := utils.ToFloat(m.Condition.Value); ok {
 		attributeValue, err := user.GetFloatAttribute(m.Condition.Name)
 		if err != nil {
-			return false, err
+			return false, nil
 		}
 		return floatValue > attributeValue, nil
 	}