feat(decision): Condition tree eval skeleton (#27)

Author: mikeproeng37

optimizely/client/client.go

@@ -30,7 +30,7 @@ type OptimizelyClient struct {
 
 // IsFeatureEnabled returns true if the feature is enabled for the given user
 func (optly *OptimizelyClient) IsFeatureEnabled(featureKey string, userID string, attributes map[string]interface{}) bool {
-	userContext := entities.UserContext{ID: userID, Attributes: attributes}
+	userContext := entities.UserContext{ID: userID, Attributes: entities.UserAttributes{Attributes: attributes}}
 
 	// @TODO(mng): we should fetch the Feature entity from the config service instead of manually creating it here
 	featureExperiment := entities.Experiment{}

optimizely/decision/evaluator/audience.go

@@ -0,0 +1,44 @@
+/****************************************************************************
+ * Copyright 2019, 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                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package evaluator
+
+import (
+	"github.com/optimizely/go-sdk/optimizely/entities"
+)
+
+// AudienceEvaluator evaluates an audience against the given user's attributes
+type AudienceEvaluator interface {
+	Evaluate(audience entities.Audience, user entities.UserContext) bool
+}
+
+// TypedAudienceEvaluator evaluates typed audiences
+type TypedAudienceEvaluator struct {
+	conditionTreeEvaluator ConditionTreeEvaluator
+}
+
+// NewTypedAudienceEvaluator creates a new instance of the TypedAudienceEvaluator
+func NewTypedAudienceEvaluator() *TypedAudienceEvaluator {
+	conditionTreeEvaluator := NewConditionTreeEvaluator()
+	return &TypedAudienceEvaluator{
+		conditionTreeEvaluator: *conditionTreeEvaluator,
+	}
+}
+
+// Evaluate evaluates the typed audience against the given user's attributes
+func (a TypedAudienceEvaluator) Evaluate(audience entities.Audience, user entities.UserContext) bool {
+	return a.conditionTreeEvaluator.Evaluate(audience.ConditionTree, user)
+}

optimizely/decision/evaluator/condition.go

@@ -0,0 +1,66 @@
+/****************************************************************************
+ * Copyright 2019, 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                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package evaluator
+
+import (
+	"fmt"
+
+	"github.com/optimizely/go-sdk/optimizely/decision/evaluator/matchers"
+	"github.com/optimizely/go-sdk/optimizely/entities"
+)
+
+// MatchType dictates how the condition value will be matched to the corresponding attribute value
+type MatchType int
+
+const (
+	// EXACT match type performs an equality comparison
+	EXACT MatchType = iota
+)
+
+func (m MatchType) String() string {
+	return [...]string{
+		"exact",
+	}[m]
+}
+
+// ConditionEvaluator evaluates a condition against the given user's attributes
+type ConditionEvaluator interface {
+	Evaluate(entities.Condition, entities.UserContext) (bool, error)
+}
+
+// CustomAttributeConditionEvaluator evaluates conditions with custom attributes
+type CustomAttributeConditionEvaluator struct{}
+
+// Evaluate returns true if the given user's attributes match the condition
+func (c CustomAttributeConditionEvaluator) Evaluate(condition entities.Condition, user entities.UserContext) (bool, error) {
+	// We should only be evaluating custom attributes
+	if condition.Type != customAttributeType {
+		return false, fmt.Errorf(`Unable to evaluator condition of type "%s"`, condition.Type)
+	}
+
+	var matcher matchers.Matcher
+	matchType := condition.Match
+	switch matchType {
+	case EXACT.String():
+		matcher = matchers.ExactMatcher{
+			Condition: condition,
+		}
+	}
+
+	result, err := matcher.Match(user)
+	return result, err
+}

optimizely/decision/evaluator/condition_test.go

@@ -0,0 +1,56 @@
+/****************************************************************************
+ * Copyright 2019, 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                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package evaluator
+
+import (
+	"testing"
+
+	"github.com/optimizely/go-sdk/optimizely/entities"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCustomAttributeConditionEvaluator(t *testing.T) {
+	conditionEvaluator := CustomAttributeConditionEvaluator{}
+	condition := entities.Condition{
+		Match: "exact",
+		Value: "foo",
+		Name:  "string_foo",
+		Type:  "custom_attribute",
+	}
+
+	// Test condition passes
+	user := entities.UserContext{
+		Attributes: entities.UserAttributes{
+			Attributes: map[string]interface{}{
+				"string_foo": "foo",
+			},
+		},
+	}
+	result, _ := conditionEvaluator.Evaluate(condition, user)
+	assert.Equal(t, result, true)
+
+	// Test condition fails
+	user = entities.UserContext{
+		Attributes: entities.UserAttributes{
+			Attributes: map[string]interface{}{
+				"string_foo": "not_foo",
+			},
+		},
+	}
+	result, _ = conditionEvaluator.Evaluate(condition, user)
+	assert.Equal(t, result, false)
+}

optimizely/decision/evaluator/condition_tree.go

@@ -0,0 +1,63 @@
+/****************************************************************************
+ * Copyright 2019, 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                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package evaluator
+
+import (
+	"github.com/optimizely/go-sdk/optimizely/entities"
+)
+
+// conditionEvalResult is the result of evaluating a Condition, which can be true/false or null if the condition could not be evaluated
+type conditionEvalResult string
+
+const customAttributeType = "custom_attribute"
+
+const (
+	// TRUE means the condition passes
+	TRUE conditionEvalResult = "TRUE"
+	// FALSE means the condition does not pass
+	FALSE conditionEvalResult = "FALSE"
+	// NULL means the condition could not be evaluated
+	NULL conditionEvalResult = "NULL"
+)
+
+// ConditionTreeEvaluator evaluates a condition tree
+type ConditionTreeEvaluator struct {
+	conditionEvaluatorMap map[string]ConditionEvaluator
+}
+
+// NewConditionTreeEvaluator creates a condition tree evaluator with the out-of-the-box condition evaluators
+func NewConditionTreeEvaluator() *ConditionTreeEvaluator {
+	// For now, only one evaluator per attribute type
+	conditionEvaluatorMap := make(map[string]ConditionEvaluator)
+	conditionEvaluatorMap[customAttributeType] = CustomAttributeConditionEvaluator{}
+	return &ConditionTreeEvaluator{
+		conditionEvaluatorMap: conditionEvaluatorMap,
+	}
+}
+
+// Evaluate returns true if the userAttributes satisfy the given condition tree
+func (c ConditionTreeEvaluator) Evaluate(node *entities.ConditionTreeNode, user entities.UserContext) bool {
+	// This wrapper method converts the conditionEvalResult to a boolean
+	result := c.evaluate(node, user)
+	return result == TRUE
+}
+
+// Helper method to recursively evaluate a condition tree
+func (c ConditionTreeEvaluator) evaluate(node *entities.ConditionTreeNode, user entities.UserContext) conditionEvalResult {
+	// @TODO(mng): Implement tree evaluator with and/or/not operators
+	return TRUE
+}

optimizely/decision/evaluator/matchers/exact.go

@@ -0,0 +1,58 @@
+/****************************************************************************
+ * Copyright 2019, 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                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+package matchers
+
+import (
+	"fmt"
+
+	"github.com/optimizely/go-sdk/optimizely/decision/evaluator/matchers/utils"
+	"github.com/optimizely/go-sdk/optimizely/entities"
+)
+
+// ExactMatcher matches against the "exact" match type
+type ExactMatcher struct {
+	Condition entities.Condition
+}
+
+// Match returns true if the user's attribute match the condition's string value
+func (m ExactMatcher) Match(user entities.UserContext) (bool, error) {
+	if stringValue, ok := m.Condition.Value.(string); ok {
+		attributeValue, err := user.Attributes.GetString(m.Condition.Name)
+		if err != nil {
+			return false, err
+		}
+		return stringValue == attributeValue, nil
+	}
+
+	if boolValue, ok := m.Condition.Value.(bool); ok {
+		attributeValue, err := user.Attributes.GetBool(m.Condition.Name)
+		if err != nil {
+			return false, err
+		}
+		return boolValue == attributeValue, nil
+	}
+
+	if floatValue, ok := utils.ToFloat(m.Condition.Value); ok {
+		attributeValue, err := user.Attributes.GetFloat(m.Condition.Name)
+		if err != nil {
+			return false, err
+		}
+		return floatValue == attributeValue, nil
+	}
+
+	return false, fmt.Errorf("audience condition %s evaluated to NULL because the condition value type is not supported", m.Condition.Name)
+}