Mfw 4086 (#332)

* Added generic array comparable
Added StringArrayComparable

* Added unit tests

---------

Co-authored-by: Christian Rasmussen <crasmussen@arista.com>

booleval/array_comparable.go

@@ -0,0 +1,61 @@
+package booleval
+
+import "net"
+
+// ArrayComparable is a Comparable for arrays of Comparables.
+type ArrayComparable struct {
+	theThings []Comparable
+}
+
+var _ Comparable = ArrayComparable{}
+
+// NewArrayComparable returns a Comparable for a array of value.
+func NewArrayComparable(value any) ArrayComparable {
+	var comparables []Comparable
+	switch val := value.(type) {
+	case []string:
+		for _, v := range val {
+			comparables = append(comparables, NewStringComparable(v))
+		}
+	// We loose the type if we have more than one case listed.
+	case []int:
+		for _, v := range val {
+			if iComp, err := NewIntegerComparableFromAny(v); err == nil {
+				comparables = append(comparables, iComp)
+			}
+		}
+	case []net.IP:
+		for _, v := range val {
+			if ipComp, err := NewIPOrIPNetComparable(v.String()); err == nil {
+				comparables = append(comparables, ipComp)
+			}
+		}
+	case []net.IPNet:
+		for _, v := range val {
+			if ipComp, err := NewIPOrIPNetComparable(v.String()); err == nil {
+				comparables = append(comparables, ipComp)
+			}
+		}
+	}
+	return ArrayComparable{comparables}
+}
+
+// Equal returns true if other is is equal to any of the comparables in the array
+func (s ArrayComparable) Equal(other any) (bool, error) {
+	for _, v := range s.theThings {
+		if equal, err := v.Equal(other); err == nil && equal {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// Greater returns true if other is is greater than any of the things in the array
+func (s ArrayComparable) Greater(other any) (bool, error) {
+	for _, v := range s.theThings {
+		if greater, err := v.Greater(other); err == nil && greater {
+			return true, nil
+		}
+	}
+	return false, nil
+}

booleval/comparables_test.go

@@ -289,3 +289,14 @@ func TestStrings(t *testing.T) {
 		{eq, 1, false, false}}
 	testDriver(t, comp, tests)
 }
+
+func TestStringArrays(t *testing.T) {
+	comp := NewStringArrayComparable([]string{"a_one", "a_two"})
+	tests := []valueCondTest{
+		{eq, "a_one", true, false},
+		{eq, "a_two", true, false},
+		{eq, "a", false, false},
+		{eq, &valueCondTest{}, false, false},
+		{eq, 1, false, false}}
+	testDriver(t, comp, tests)
+}

booleval/eval_test.go

@@ -22,6 +22,7 @@ func TestExprs(t *testing.T) {
 	timeComparable1999 := TimeComparable{time: time1}
 	time2 := time.Date(2000, time.April, int(time.Monday), 0, 0, 0, 0, location)
 	timeComparable2000 := TimeComparable{time: time2}
+	stringArrayComparable := NewStringArrayComparable([]string{"doodle", "toodle"})
 	tests := []struct {
 		expr   Expression
 		result bool
@@ -292,6 +293,34 @@ func TestExprs(t *testing.T) {
 			false,
 			false,
 		},
+		{NewSimpleExpression(
+			AndOfOrsMode,
+			[][]*AtomicExpression{
+				{
+					{"==", stringArrayComparable, "myStringArray"},
+				},
+				{
+					{"==", stringArrayComparable, "toodle"},
+				},
+			},
+		),
+			false,
+			false,
+		},
+		{NewSimpleExpression(
+			OrOfAndsMode,
+			[][]*AtomicExpression{
+				{
+					{"==", stringArrayComparable, "myStringArray"},
+				},
+				{
+					{"==", stringArrayComparable, "toodle"},
+				},
+			},
+		),
+			true,
+			false,
+		},
 	}
 
 	for _, test := range tests {

booleval/string_comparable.go

@@ -43,3 +43,8 @@ func (s StringComparable) Equal(other any) (bool, error) {
 }
 
 var _ Comparable = StringComparable{}
+
+// NewStringArrayComparable returns a Comparable for an array of strings.
+func NewStringArrayComparable(val []string) ArrayComparable {
+	return NewArrayComparable(val)
+}