fix: support audience ids (#161)

Michael Ng · web-flow · commit e9a646ea80de · 2019-10-31T11:49:20.000-07:00
diff --git a/pkg/config/datafileprojectconfig/entities/entities.go b/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
diff --git a/pkg/config/datafileprojectconfig/mappers/condition_trees.go b/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) {
 
diff --git a/pkg/config/datafileprojectconfig/mappers/condition_trees_test.go b/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{
diff --git a/pkg/config/datafileprojectconfig/mappers/experiment.go b/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
diff --git a/pkg/config/datafileprojectconfig/mappers/experiment_test.go b/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)
+}
diff --git a/pkg/decision/evaluator/matchers/exact.go b/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
 	}
diff --git a/pkg/decision/evaluator/matchers/exact_test.go b/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)
 }
diff --git a/pkg/decision/evaluator/matchers/gt.go b/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
 	}
diff --git a/pkg/decision/evaluator/matchers/gt_test.go b/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)
 }
diff --git a/pkg/decision/evaluator/matchers/lt.go b/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
 	}
diff --git a/pkg/decision/evaluator/matchers/lt_test.go b/pkg/decision/evaluator/matchers/lt_test.go
@@ -76,15 +76,15 @@ func TestLtMatcherInt(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 TestLtMatcherFloat(t *testing.T) {
@@ -127,13 +127,13 @@ func TestLtMatcherFloat(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)
 }
diff --git a/pkg/decision/evaluator/matchers/substring.go b/pkg/decision/evaluator/matchers/substring.go
@@ -35,7 +35,7 @@ func (m SubstringMatcher) 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 strings.Contains(attributeValue, stringValue), nil
 	}
diff --git a/pkg/decision/evaluator/matchers/substring_test.go b/pkg/decision/evaluator/matchers/substring_test.go
@@ -55,13 +55,13 @@ func TestSubstringMatcher(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_string_foo": "foo",
 		},
 	}
 
 	_, err = matcher.Match(user)
-	assert.Error(t, err)
+	assert.NoError(t, err)
 }

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ type Experiment struct {`
`42`	`42`	TrafficAllocation []trafficAllocation `json:"trafficAllocation"`
`43`	`43`	AudienceIds []string `json:"audienceIds"`
`44`	`44`	ForcedVariations map[string]string `json:"forcedVariations"`
`45`		- AudienceConditions interface{} `json:"audienceConditions"`
	`45`	+ AudienceConditions []interface{} `json:"audienceConditions"`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`// FeatureFlag represents a FeatureFlag object from the Optimizely datafile`
Original file line number	Diff line number	Diff line change
`@@ -34,23 +34,23 @@ func (m ExactMatcher) Match(user entities.UserContext) (bool, error) {`
`34`	`34`	`if stringValue, ok := m.Condition.Value.(string); ok {`
`35`	`35`	`attributeValue, err := user.GetStringAttribute(m.Condition.Name)`
`36`	`36`	`if err != nil {`
`37`		`- return false, err`
	`37`	`+ return false, nil`
`38`	`38`	`}`
`39`	`39`	`return stringValue == attributeValue, nil`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`if boolValue, ok := m.Condition.Value.(bool); ok {`
`43`	`43`	`attributeValue, err := user.GetBoolAttribute(m.Condition.Name)`
`44`	`44`	`if err != nil {`
`45`		`- return false, err`
	`45`	`+ return false, nil`
`46`	`46`	`}`
`47`	`47`	`return boolValue == attributeValue, nil`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`if floatValue, ok := utils.ToFloat(m.Condition.Value); ok {`
`51`	`51`	`attributeValue, err := user.GetFloatAttribute(m.Condition.Name)`
`52`	`52`	`if err != nil {`
`53`		`- return false, err`
	`53`	`+ return false, nil`
`54`	`54`	`}`
`55`	`55`	`return floatValue == attributeValue, nil`
`56`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ func (m GtMatcher) Match(user entities.UserContext) (bool, error) {`
`35`	`35`	`if floatValue, ok := utils.ToFloat(m.Condition.Value); ok {`
`36`	`36`	`attributeValue, err := user.GetFloatAttribute(m.Condition.Name)`
`37`	`37`	`if err != nil {`
`38`		`- return false, err`
	`38`	`+ return false, nil`
`39`	`39`	`}`
`40`	`40`	`return floatValue < attributeValue, nil`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ func (m LtMatcher) Match(user entities.UserContext) (bool, error) {`
`35`	`35`	`if floatValue, ok := utils.ToFloat(m.Condition.Value); ok {`
`36`	`36`	`attributeValue, err := user.GetFloatAttribute(m.Condition.Name)`
`37`	`37`	`if err != nil {`
`38`		`- return false, err`
	`38`	`+ return false, nil`
`39`	`39`	`}`
`40`	`40`	`return floatValue > attributeValue, nil`
`41`	`41`	`}`