Add extended filter/parser tests & adjust expected error messages

Author: yhabteab

internal/filter/parser_test.go

@@ -9,57 +9,80 @@ import (
 func TestParser(t *testing.T) {
 	t.Parallel()
 
-	t.Run("MissingLogicalOperatorsAfterConditionsAreDetected", func(t *testing.T) {
-		_, err := ParseFilter("(a=b|c=d)e=f")
+	t.Run("ParseInvalidFilters", func(t *testing.T) {
+		t.Parallel()
 
-		expected := "invalid filter '(a=b|c=d)e=f', unexpected e at pos 10: Expected logical operator"
-		assert.EqualError(t, err, expected, "Errors should be the same")
-	})
-
-	t.Run("MissingLogicalOperatorsAfterOperatorsAreDetected", func(t *testing.T) {
-		_, err := ParseFilter("(a=b|c=d|)e=f")
+		rule, err := ParseFilter("(a=b|c=d)e=f")
+		assert.Equal(t, rule, nil)
+		assert.EqualError(t, err, "1:10 (9): no match found, expected: \"&\", \"|\" or EOF")
 
-		expected := "invalid filter '(a=b|c=d|)e=f', unexpected e at pos 11: Expected logical operator"
-		assert.EqualError(t, err, expected, "Errors should be the same")
-	})
+		_, err = ParseFilter("(a=b|c=d|)e=f")
+		assert.EqualError(t, err, "1:10 (9): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
 
-	t.Run("ParserIdentifiesInvalidExpression", func(t *testing.T) {
-		_, err := ParseFilter("col=(")
-		assert.EqualError(t, err, "invalid filter 'col=(', unexpected ( at pos 5", "Errors should be the same")
+		_, err = ParseFilter("col=(")
+		assert.EqualError(t, err, "1:5 (4): no match found, expected: [^!&|~<>=()]")
 
 		_, err = ParseFilter("(((x=a)&y=b")
-		assert.EqualError(t, err, "invalid filter '(((x=a)&y=b', missing 2 closing ')' at pos 11", "Errors should be the same")
+		assert.EqualError(t, err, "1:12 (11): no match found, expected: \"&\", \")\", \"|\" or [^!&|~<>=()]")
 
 		_, err = ParseFilter("(x=a)&y=b)")
-		assert.EqualError(t, err, "invalid filter '(x=a)&y=b)', unexpected ) at pos 10", "Errors should be the same")
+		assert.EqualError(t, err, "1:10 (9): no match found, expected: \"&\", \"|\", [^!&|~<>=()] or EOF")
 
 		_, err = ParseFilter("!(&")
-		assert.EqualError(t, err, "invalid filter '!(&', unexpected & at pos 3", "Errors should be the same")
-
-		_, err = ParseFilter("!(!&")
-		assert.EqualError(t, err, "invalid filter '!(!&', unexpected & at pos 4: operator level 1", "Errors should be the same")
-
-		_, err = ParseFilter("!(|test")
-		assert.EqualError(t, err, "invalid filter '!(|test', unexpected | at pos 3", "Errors should be the same")
+		assert.EqualError(t, err, "1:3 (2): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
 
 		_, err = ParseFilter("foo&bar=(te(st)")
-		assert.EqualError(t, err, "invalid filter 'foo&bar=(te(st)', unexpected ( at pos 9", "Errors should be the same")
+		assert.EqualError(t, err, "1:9 (8): no match found, expected: [^!&|~<>=()]")
 
 		_, err = ParseFilter("foo&bar=te(st)")
-		assert.EqualError(t, err, "invalid filter 'foo&bar=te(st)', unexpected ( at pos 11", "Errors should be the same")
+		assert.EqualError(t, err, "1:11 (10): no match found, expected: \"&\", \"|\", [^!&|~<>=()] or EOF")
 
 		_, err = ParseFilter("foo&bar=test)")
-		assert.EqualError(t, err, "invalid filter 'foo&bar=test)', unexpected ) at pos 13", "Errors should be the same")
+		assert.EqualError(t, err, "1:13 (12): no match found, expected: \"&\", \"|\", [^!&|~<>=()] or EOF")
 
 		_, err = ParseFilter("!()|&()&)")
-		assert.EqualError(t, err, "invalid filter '!()|&()&)', unexpected closing ')' at pos 9", "Errors should be the same")
+		assert.EqualError(t, err, "1:3 (2): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
+
+		_, err = ParseFilter("=foo")
+		assert.EqualError(t, err, "1:1 (0): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
+
+		_, err = ParseFilter("foo>")
+		assert.EqualError(t, err, "1:5 (4): no match found, expected: [^!&|~<>=()]")
+
+		_, err = ParseFilter("foo==")
+		assert.EqualError(t, err, "1:5 (4): no match found, expected: [^!&|~<>=()]")
+
+		_, err = ParseFilter("=>foo")
+		assert.EqualError(t, err, "1:1 (0): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
+
+		_, err = ParseFilter("&foo")
+		assert.EqualError(t, err, "1:1 (0): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
+
+		_, err = ParseFilter("&&foo")
+		assert.EqualError(t, err, "1:1 (0): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
+
+		_, err = ParseFilter("(&foo=bar)")
+		assert.EqualError(t, err, "1:2 (1): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
+
+		_, err = ParseFilter("(foo=bar|)")
+		assert.EqualError(t, err, "1:10 (9): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
+
+		_, err = ParseFilter("((((((")
+		assert.EqualError(t, err, "1:7 (6): no match found, expected: \"!\", \"(\" or [^!&|~<>=()]")
+
+		_, err = ParseFilter("foo&bar&col=val!=val")
+		assert.EqualError(t, err, "1:16 (15): no match found, expected: \"&\", \"|\", [^!&|~<>=()] or EOF")
+
+		_, err = ParseFilter("col%7umn")
+		assert.EqualError(t, err, "1:1 (0): rule ExistsExpr: invalid URL escape \"%7u\"")
+
+		_, err = ParseFilter("((0&((((((((((((((0=0)")
+		assert.EqualError(t, err, "1:23 (22): no match found, expected: \"&\", \")\" or \"|\"")
 	})
-}
 
-func TestFilter(t *testing.T) {
-	t.Parallel()
+	t.Run("ParseAllKindOfSimpleFilters", func(t *testing.T) {
+		t.Parallel()
 
-	t.Run("ParserIdentifiesAllKindOfFilters", func(t *testing.T) {
 		rule, err := ParseFilter("foo=bar")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &Equal{}, rule)
@@ -68,11 +91,11 @@ func TestFilter(t *testing.T) {
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &UnEqual{}, rule)
 
-		rule, err = ParseFilter("foo=bar*")
+		rule, err = ParseFilter("foo~bar*")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &Like{}, rule)
 
-		rule, err = ParseFilter("foo!=bar*")
+		rule, err = ParseFilter("foo!~bar*")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &Unlike{}, rule)
 
@@ -104,49 +127,229 @@ func TestFilter(t *testing.T) {
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &None{}, rule)
 
+		rule, err = ParseFilter("foo")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		assert.Equal(t, &Exists{column: "foo"}, rule)
+
 		rule, err = ParseFilter("!foo")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		assert.Equal(t, &None{rules: []Filter{&Exists{column: "foo"}}}, rule)
+
+		rule, err = ParseFilter("!foo=bar")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		assert.Equal(t, &None{rules: []Filter{&Equal{column: "foo", value: "bar"}}}, rule)
+	})
 
-		exists, _ := NewExists("foo")
-		assert.Equal(t, &None{rules: []Filter{exists}}, rule)
+	t.Run("ParseFilterChain", func(t *testing.T) {
+		t.Parallel()
 
-		rule, err = ParseFilter("foo")
+		rule, err := ParseFilter("(foo=bar)")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		assert.Equal(t, &Equal{column: "foo", value: "bar"}, rule)
+
+		rule, err = ParseFilter("(!foo=bar)")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		none := &None{rules: []Filter{
+			&Equal{column: "foo", value: "bar"},
+		}}
+		assert.Equal(t, none, rule)
+
+		rule, err = ParseFilter("!(foo=bar)")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		none = &None{rules: []Filter{
+			&Equal{column: "foo", value: "bar"},
+		}}
+		assert.Equal(t, none, rule)
+
+		rule, err = ParseFilter("!(!foo=bar)")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		none = &None{rules: []Filter{
+			&None{rules: []Filter{&Equal{column: "foo", value: "bar"}}},
+		}}
+		assert.Equal(t, none, rule)
+
+		rule, err = ParseFilter("((!foo=bar)&bar!=foo)")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		all := &All{rules: []Filter{
+			&None{rules: []Filter{&Equal{column: "foo", value: "bar"}}},
+			&UnEqual{column: "bar", value: "foo"},
+		}}
+		assert.Equal(t, all, rule)
+
+		rule, err = ParseFilter("!foo&!bar")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		var expected Filter
+		expected = &All{rules: []Filter{
+			&None{rules: []Filter{&Exists{column: "foo"}}},
+			&None{rules: []Filter{&Exists{column: "bar"}}},
+		}}
+		assert.Equal(t, expected, rule)
+
+		rule, err = ParseFilter("!(!foo|bar)")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+
+		expected = &None{rules: []Filter{
+			&Any{rules: []Filter{
+				&None{rules: []Filter{&Exists{column: "foo"}}},
+				&Exists{column: "bar"},
+			}},
+		}}
+		assert.Equal(t, expected, rule)
+
+		rule, err = ParseFilter("!(!(foo|bar))")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+
+		expected = &None{rules: []Filter{
+			&None{rules: []Filter{
+				&Any{rules: []Filter{
+					&Exists{column: "foo"},
+					&Exists{column: "bar"},
+				}},
+			}},
+		}}
+		assert.Equal(t, expected, rule)
+
+		rule, err = ParseFilter("foo=bar&bar!=foo")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
-		assert.Equal(t, exists, rule)
 
-		rule, err = ParseFilter("!(foo=bar|bar=foo)&(foo=bar|bar=foo)")
+		expect := &All{rules: []Filter{
+			&Equal{column: "foo", value: "bar"},
+			&UnEqual{column: "bar", value: "foo"},
+		}}
+		assert.Equal(t, expect, rule)
+
+		rule, err = ParseFilter("!(foo=bar|bar=foo)&(foo!=bar|bar!=foo)")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 
-		expected := &All{rules: []Filter{
+		expected = &All{rules: []Filter{
 			&None{rules: []Filter{
+				&Any{rules: []Filter{
+					&Equal{column: "foo", value: "bar"},
+					&Equal{column: "bar", value: "foo"},
+				}},
+			}},
+			&Any{rules: []Filter{
+				&UnEqual{column: "foo", value: "bar"},
+				&UnEqual{column: "bar", value: "foo"},
+			}},
+		}}
+		assert.Equal(t, expected, rule)
+
+		rule, err = ParseFilter("foo=bar&bar!=foo&john>doe|doe<john&column!=value|column=value")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+
+		expectAny := &Any{rules: []Filter{
+			&All{rules: []Filter{
 				&Equal{column: "foo", value: "bar"},
-				&Equal{column: "bar", value: "foo"},
+				&UnEqual{column: "bar", value: "foo"},
+				&GreaterThan{column: "john", value: "doe"},
 			}},
 			&Any{rules: []Filter{
+				&All{rules: []Filter{
+					&LessThan{column: "doe", value: "john"},
+					&UnEqual{column: "column", value: "value"},
+				}},
+				&Equal{column: "column", value: "value"},
+			}},
+		}}
+		assert.Equal(t, expectAny, rule)
+
+		rule, err = ParseFilter("foo=bar&bar!=foo&(john>doe|doe<john&column!=value)|column=value")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+
+		expectAny = &Any{rules: []Filter{
+			&All{rules: []Filter{
 				&Equal{column: "foo", value: "bar"},
-				&Equal{column: "bar", value: "foo"},
+				&UnEqual{column: "bar", value: "foo"},
+				&Any{rules: []Filter{
+					&GreaterThan{column: "john", value: "doe"},
+					&All{rules: []Filter{
+						&LessThan{column: "doe", value: "john"},
+						&UnEqual{column: "column", value: "value"},
+					}},
+				}},
 			}},
+			&Equal{column: "column", value: "value"},
 		}}
-		assert.Equal(t, expected, rule)
-	})
+		assert.Equal(t, expectAny, rule)
 
-	t.Run("ParserIdentifiesSingleCondition", func(t *testing.T) {
-		rule, err := ParseFilter("foo=bar")
+		rule, err = ParseFilter("foo=bar&bar!=foo|(john>doe|doe<john&column!=value)&column=value")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+
+		expectAny = &Any{rules: []Filter{
+			// The first two filter conditions
+			&All{rules: []Filter{
+				&Equal{column: "foo", value: "bar"},
+				&UnEqual{column: "bar", value: "foo"},
+			}},
+			&All{rules: []Filter{
+				&Any{rules: []Filter{ // Represents the filter conditions within the parentheses
+					&GreaterThan{column: "john", value: "doe"},
+					&All{rules: []Filter{
+						&LessThan{column: "doe", value: "john"},
+						&UnEqual{column: "column", value: "value"},
+					}},
+				}},
+				// The last filter condition
+				&Equal{column: "column", value: "value"},
+			}},
+		}}
+		assert.Equal(t, expectAny, rule)
+
+		rule, err = ParseFilter("foo=bar&bar!=foo|(john>doe|doe<john&(column!=value|value!~column))&column=value")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 
-		expected := &Equal{column: "foo", value: "bar"}
-		assert.Equal(t, expected, rule, "Parser doesn't parse single condition correctly")
+		expectAny = &Any{rules: []Filter{
+			// The first two filter conditions
+			&All{rules: []Filter{
+				&Equal{column: "foo", value: "bar"},
+				&UnEqual{column: "bar", value: "foo"},
+			}},
+			&All{rules: []Filter{
+				&Any{rules: []Filter{ // Represents the filter conditions within the parentheses
+					&GreaterThan{column: "john", value: "doe"},
+					&All{rules: []Filter{
+						&LessThan{column: "doe", value: "john"},
+						&Any{rules: []Filter{ // Represents the filter conditions within the nested parentheses
+							&UnEqual{column: "column", value: "value"},
+							&Unlike{column: "value", value: "column"},
+						}},
+					}},
+				}},
+				// The last filter condition
+				&Equal{column: "column", value: "value"},
+			}},
+		}}
+		assert.Equal(t, expectAny, rule)
 	})
 
-	t.Run("UrlEncodedFilterExpression", func(t *testing.T) {
+	t.Run("UrlEncodedFilter", func(t *testing.T) {
+		t.Parallel()
+
 		rule, err := ParseFilter("col%3Cumn<val%3Cue")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.Equal(t, &LessThan{column: "col<umn", value: "val<ue"}, rule)
 
+		rule, err = ParseFilter("col%7Cumn")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		assert.Equal(t, &Exists{column: "col|umn"}, rule)
+
 		rule, err = ParseFilter("col%7Cumn=val%7Cue")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.Equal(t, &Equal{column: "col|umn", value: "val|ue"}, rule)
 
+		rule, err = ParseFilter("col%7Cumn!=val%7Cue")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		assert.Equal(t, &UnEqual{column: "col|umn", value: "val|ue"}, rule)
+
+		rule, err = ParseFilter("col%7Cumn~val%7Cue")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		assert.Equal(t, &Like{column: "col|umn", value: "val|ue"}, rule)
+
+		rule, err = ParseFilter("col%7Cumn!~val%7Cue")
+		assert.Nil(t, err, "There should be no errors but got: %s", err)
+		assert.Equal(t, &Unlike{column: "col|umn", value: "val|ue"}, rule)
+
 		rule, err = ParseFilter("col%26umn<=val%26ue")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.Equal(t, &LessThanOrEqual{column: "col&umn", value: "val&ue"}, rule)
@@ -174,8 +377,8 @@ func FuzzParser(f *testing.F) {
 	f.Add("foo&bar=test)")
 	f.Add("foo=bar")
 	f.Add("foo!=bar")
-	f.Add("foo=bar*")
-	f.Add("foo!=bar*")
+	f.Add("foo~bar*")
+	f.Add("foo!~bar*")
 	f.Add("foo<bar")
 	f.Add("foo<=bar")
 	f.Add("foo>bar")
@@ -187,6 +390,7 @@ func FuzzParser(f *testing.F) {
 	f.Add("foo")
 	f.Add("!(foo=bar|bar=foo)&(foo=bar|bar=foo)")
 	f.Add("foo=bar")
+	f.Add("col%7umn")
 	f.Add("col%3Cumn<val%3Cue")
 	f.Add("col%7Cumn=val%7Cue")
 	f.Add("col%26umn<=val%26ue")