added has and does_not_have operators

has and does_not_have operators test whether a property value that's a
list of values contains or does not contain a specific value

Author: braindev

README.md

@@ -55,6 +55,8 @@ These are the types of values that should be used with together.  The "Rule Valu
 | string | `not_in` — _not one of a group_ | []string |
 | bool | `eq` — _equal to_ | bool |
 | bool | `not_eq` — _not equal to_ | bool |
+| []string | `has` — _includes item_ | string |
+| []string | `does_not_have` — _doesn't include item_ | string
 
 #### Nested Example
 

isit.go

@@ -113,6 +113,11 @@ func ruleTest(rule Rule, values map[string]interface{}) (bool, error) {
 
 	switch t := actual.(type) {
 	default:
+		if isSlice(actual) {
+			if ss, err := toStringSlice(actual); err == nil {
+				return ruleTestStringSlice(ss, rule)
+			}
+		}
 		return false, fmt.Errorf("unexpected type %T in rule value", t)
 	case bool:
 		v, _ := values[rule.Property].(bool)
@@ -124,7 +129,21 @@ func ruleTest(rule Rule, values map[string]interface{}) (bool, error) {
 		v, _ := floatFromInterface(values[rule.Property])
 		return ruleTestNumeric(actual, v, rule)
 	}
+}
 
+func ruleTestStringSlice(ss []string, rule Rule) (bool, error) {
+	expected, ok := rule.Value.(string)
+	if !ok {
+		return false, fmt.Errorf("Invalid rule value type (%T) for property type []string", expected)
+	}
+	switch strings.ToUpper(rule.Operator) {
+	default:
+		return false, fmt.Errorf("unsupported operator: %s for type []string", rule.Operator)
+	case "HAS":
+		return stringSliceContains(ss, expected), nil
+	case "DOES_NOT_HAVE":
+		return !stringSliceContains(ss, expected), nil
+	}
 }
 
 func ruleTestNumeric(actual interface{}, v float64, rule Rule) (bool, error) {
@@ -285,3 +304,12 @@ func toStringSlice(o interface{}) ([]string, error) {
 
 	return ret, nil
 }
+
+func stringSliceContains(ss []string, s string) bool {
+	for _, v := range ss {
+		if s == v {
+			return true
+		}
+	}
+	return false
+}

isit_test.go

@@ -154,6 +154,29 @@ func Test_ruleTest_numeric(t *testing.T) {
 	}
 }
 
+func Test_ruleTest_stringSlice(t *testing.T) {
+	rule := Rule{
+		Property: "v",
+		Operator: "has",
+		Value:    "oranges",
+	}
+	if res, err := ruleTest(rule, map[string]interface{}{"v": []string{"a", "b", "oranges"}}); !res || err != nil {
+		t.Errorf(`testing ["a", "b", "oranges"] has "oranges" returned %v %v`, res, err)
+	}
+	if res, err := ruleTest(rule, map[string]interface{}{"v": []string{"a", "b", "c"}}); res || err != nil {
+		t.Errorf(`testing ["a", "b", "c"] has "oranges" returned %v %v`, res, err)
+	}
+
+	rule.Operator = "does_not_have"
+	if res, err := ruleTest(rule, map[string]interface{}{"v": []string{"a", "b", "oranges"}}); res || err != nil {
+		t.Errorf(`testing ["a", "b", "oranges"] does_not_have "oranges" returned %v %v`, res, err)
+	}
+	if res, err := ruleTest(rule, map[string]interface{}{"v": []string{"a", "b", "c"}}); !res || err != nil {
+		t.Errorf(`testing ["a", "b", "c"] does_not_have "oranges" returned %v %v`, res, err)
+	}
+
+}
+
 func Test_ruleTest_string(t *testing.T) {
 	rule := Rule{
 		Property: "v",