feat(decision): Implement the condition tree evaluator. (#29)

Author: Michael Ng

optimizely/decision/evaluator/condition.go

@@ -23,20 +23,11 @@ import (
 	"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
+	exactMatchType = "exact"
 )
 
-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)
@@ -55,7 +46,7 @@ func (c CustomAttributeConditionEvaluator) Evaluate(condition entities.Condition
 	var matcher matchers.Matcher
 	matchType := condition.Match
 	switch matchType {
-	case EXACT.String():
+	case exactMatchType:
 		matcher = matchers.ExactMatcher{
 			Condition: condition,
 		}

optimizely/decision/evaluator/condition_tree.go

@@ -20,18 +20,15 @@ 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"
+	// "and" operator returns true if all conditions evaluate to true
+	andOperator = "and"
+	// "not" operator negates the result of the given condition
+	notOperator = "not"
+	// "or" operator returns true if any of the conditions evaluate to true
+	orOperator = "or"
 )
 
 // ConditionTreeEvaluator evaluates a condition tree
@@ -52,12 +49,86 @@ func NewConditionTreeEvaluator() *ConditionTreeEvaluator {
 // 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
+	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
+// Returns the result of the evaluation and whether the evaluation of the condition is valid or not (to handle null bubbling)
+func (c ConditionTreeEvaluator) evaluate(node *entities.ConditionTreeNode, user entities.UserContext) (evalResult bool, isValid bool) {
+	operator := node.Operator
+	if operator != "" {
+		switch operator {
+		case andOperator:
+			return c.evaluateAnd(node.Nodes, user)
+		case notOperator:
+			return c.evaluateNot(node.Nodes, user)
+		case orOperator:
+			fallthrough
+		default:
+			return c.evaluateOr(node.Nodes, user)
+		}
+	}
+
+	conditionEvaluator, ok := c.conditionEvaluatorMap[node.Condition.Type]
+	if !ok {
+		// TODO(mng): log error
+		// Result is invalid
+		return false, false
+	}
+	result, err := conditionEvaluator.Evaluate(node.Condition, user)
+	if err != nil {
+		// Result is invalid
+		return false, false
+	}
+	return result, true
+}
+
+func (c ConditionTreeEvaluator) evaluateAnd(nodes []*entities.ConditionTreeNode, user entities.UserContext) (evalResult bool, isValid bool) {
+	sawInvalid := false
+	for _, node := range nodes {
+		result, isValid := c.evaluate(node, user)
+		if !isValid {
+			return false, isValid
+		} else if result == false {
+			return result, isValid
+		}
+	}
+
+	if sawInvalid {
+		// bubble up the invalid result
+		return false, false
+	}
+
+	return true, true
+}
+
+func (c ConditionTreeEvaluator) evaluateNot(nodes []*entities.ConditionTreeNode, user entities.UserContext) (evalResult bool, isValid bool) {
+	if len(nodes) > 0 {
+		result, isValid := c.evaluate(nodes[0], user)
+		if !isValid {
+			return false, false
+		}
+		return !result, isValid
+	}
+	return false, false
+}
+
+func (c ConditionTreeEvaluator) evaluateOr(nodes []*entities.ConditionTreeNode, user entities.UserContext) (evalResult bool, isValid bool) {
+	sawInvalid := false
+	for _, node := range nodes {
+		result, isValid := c.evaluate(node, user)
+		if !isValid {
+			sawInvalid = true
+		} else if result == true {
+			return result, isValid
+		}
+	}
+
+	if sawInvalid {
+		// bubble up the invalid result
+		return false, false
+	}
+
+	return false, true
 }