Use filter.ParseFilter() every where

Author: yhabteab

internal/config/runtime.go

@@ -393,7 +393,7 @@ func (r *RuntimeConfig) UpdateRulesFromDatabase(ctx context.Context, db *icingad
 		}
 
 		if rule.ObjectFilterExpr.Valid {
-			f, err := filter.Parse(rule.ObjectFilterExpr.String)
+			f, err := filter.ParseFilter(rule.ObjectFilterExpr.String)
 			if err != nil {
 				ruleLogger.Warnw("ignoring rule as parsing object_filter failed", zap.Error(err))
 				rules[i] = nil

internal/filter/parser_test.go

@@ -10,48 +10,48 @@ func TestParser(t *testing.T) {
 	t.Parallel()
 
 	t.Run("MissingLogicalOperatorsAfterConditionsAreDetected", func(t *testing.T) {
-		_, err := Parse("(a=b|c=d)e=f")
+		_, err := ParseFilter("(a=b|c=d)e=f")
 
 		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 := Parse("(a=b|c=d|)e=f")
+		_, err := ParseFilter("(a=b|c=d|)e=f")
 
 		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")
 	})
 
 	t.Run("ParserIdentifiesInvalidExpression", func(t *testing.T) {
-		_, err := Parse("col=(")
+		_, err := ParseFilter("col=(")
 		assert.EqualError(t, err, "invalid filter 'col=(', unexpected ( at pos 5", "Errors should be the same")
 
-		_, err = Parse("(((x=a)&y=b")
+		_, 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")
 
-		_, err = Parse("(x=a)&y=b)")
+		_, 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")
 
-		_, err = Parse("!(&")
+		_, err = ParseFilter("!(&")
 		assert.EqualError(t, err, "invalid filter '!(&', unexpected & at pos 3", "Errors should be the same")
 
-		_, err = Parse("!(!&")
+		_, err = ParseFilter("!(!&")
 		assert.EqualError(t, err, "invalid filter '!(!&', unexpected & at pos 4: operator level 1", "Errors should be the same")
 
-		_, err = Parse("!(|test")
+		_, err = ParseFilter("!(|test")
 		assert.EqualError(t, err, "invalid filter '!(|test', unexpected | at pos 3", "Errors should be the same")
 
-		_, err = Parse("foo&bar=(te(st)")
+		_, 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")
 
-		_, err = Parse("foo&bar=te(st)")
+		_, 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")
 
-		_, err = Parse("foo&bar=test)")
+		_, err = ParseFilter("foo&bar=test)")
 		assert.EqualError(t, err, "invalid filter 'foo&bar=test)', unexpected ) at pos 13", "Errors should be the same")
 
-		_, err = Parse("!()|&()&)")
+		_, err = ParseFilter("!()|&()&)")
 		assert.EqualError(t, err, "invalid filter '!()|&()&)', unexpected closing ')' at pos 9", "Errors should be the same")
 	})
 }
@@ -60,60 +60,61 @@ func TestFilter(t *testing.T) {
 	t.Parallel()
 
 	t.Run("ParserIdentifiesAllKindOfFilters", func(t *testing.T) {
-		rule, err := Parse("foo=bar")
+		rule, err := ParseFilter("foo=bar")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &Equal{}, rule)
 
-		rule, err = Parse("foo!=bar")
+		rule, err = ParseFilter("foo!=bar")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &UnEqual{}, rule)
 
-		rule, err = Parse("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 = Parse("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)
 
-		rule, err = Parse("foo<bar")
+		rule, err = ParseFilter("foo<bar")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &LessThan{}, rule)
 
-		rule, err = Parse("foo<=bar")
+		rule, err = ParseFilter("foo<=bar")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &LessThanOrEqual{}, rule)
 
-		rule, err = Parse("foo>bar")
+		rule, err = ParseFilter("foo>bar")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &GreaterThan{}, rule)
 
-		rule, err = Parse("foo>=bar")
+		rule, err = ParseFilter("foo>=bar")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &GreaterThanOrEqual{}, rule)
 
-		rule, err = Parse("foo=bar&bar=foo")
+		rule, err = ParseFilter("foo=bar&bar=foo")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &All{}, rule)
 
-		rule, err = Parse("foo=bar|bar=foo")
+		rule, err = ParseFilter("foo=bar|bar=foo")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &Any{}, rule)
 
-		rule, err = Parse("!(foo=bar|bar=foo)")
+		rule, err = ParseFilter("!(foo=bar|bar=foo)")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.IsType(t, &None{}, rule)
 
-		rule, err = Parse("!foo")
+		rule, err = ParseFilter("!foo")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 
-		assert.Equal(t, &None{rules: []Filter{NewExists("foo")}}, rule)
+		exists, _ := NewExists("foo")
+		assert.Equal(t, &None{rules: []Filter{exists}}, rule)
 
-		rule, err = Parse("foo")
+		rule, err = ParseFilter("foo")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
-		assert.Equal(t, NewExists("foo"), rule)
+		assert.Equal(t, exists, rule)
 
-		rule, err = Parse("!(foo=bar|bar=foo)&(foo=bar|bar=foo)")
+		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{
@@ -130,31 +131,31 @@ func TestFilter(t *testing.T) {
 	})
 
 	t.Run("ParserIdentifiesSingleCondition", func(t *testing.T) {
-		rule, err := Parse("foo=bar")
+		rule, err := ParseFilter("foo=bar")
 		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")
 	})
 
 	t.Run("UrlEncodedFilterExpression", func(t *testing.T) {
-		rule, err := Parse("col%3Cumn<val%3Cue")
+		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 = Parse("col%7Cumn=val%7Cue")
+		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 = Parse("col%26umn<=val%26ue")
+		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)
 
-		rule, err = Parse("col%28umn>val%28ue")
+		rule, err = ParseFilter("col%28umn>val%28ue")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.Equal(t, &GreaterThan{column: "col(umn", value: "val(ue"}, rule)
 
-		rule, err = Parse("col%29umn>=val%29ue")
+		rule, err = ParseFilter("col%29umn>=val%29ue")
 		assert.Nil(t, err, "There should be no errors but got: %s", err)
 		assert.Equal(t, &GreaterThanOrEqual{column: "col)umn", value: "val)ue"}, rule)
 	})
@@ -193,7 +194,7 @@ func FuzzParser(f *testing.F) {
 	f.Add("col%29umn>val%29ue")
 
 	f.Fuzz(func(t *testing.T, expr string) {
-		_, err := Parse(expr)
+		_, err := ParseFilter(expr)
 
 		if strings.Count(expr, "(") != strings.Count(expr, ")") {
 			assert.Error(t, err)