add more helpers (#1091)

* add more exprhelpers

pkg/exprhelpers/exprlib.go

@@ -32,6 +32,10 @@ func Upper(s string) string {
 	return strings.ToUpper(s)
 }
 
+func Lower(s string) string {
+	return strings.ToLower(s)
+}
+
 func GetExprEnv(ctx map[string]interface{}) map[string]interface{} {
 	var ExprLib = map[string]interface{}{
 		"Atof":                Atof,
@@ -41,9 +45,14 @@ func GetExprEnv(ctx map[string]interface{}) map[string]interface{} {
 		"File":                File,
 		"RegexpInFile":        RegexpInFile,
 		"Upper":               Upper,
+		"Lower":               Lower,
 		"IpInRange":           IpInRange,
 		"TimeNow":             TimeNow,
 		"ParseUri":            ParseUri,
+		"PathUnescape":        PathUnescape,
+		"QueryUnescape":       QueryUnescape,
+		"PathEscape":          PathEscape,
+		"QueryEscape":         QueryEscape,
 	}
 	for k, v := range ctx {
 		ExprLib[k] = v
@@ -97,6 +106,32 @@ func FileInit(fileFolder string, filename string, fileType string) error {
 	return nil
 }
 
+func QueryEscape(s string) string {
+	return url.QueryEscape(s)
+}
+
+func PathEscape(s string) string {
+	return url.PathEscape(s)
+}
+
+func PathUnescape(s string) string {
+	ret, err := url.PathUnescape(s)
+	if err != nil {
+		log.Errorf("unable to PathUnescape '%s': %+v", s, err)
+		return s
+	}
+	return ret
+}
+
+func QueryUnescape(s string) string {
+	ret, err := url.QueryUnescape(s)
+	if err != nil {
+		log.Errorf("unable to QueryUnescape '%s': %+v", s, err)
+		return s
+	}
+	return ret
+}
+
 func File(filename string) []string {
 	if _, ok := dataFile[filename]; ok {
 		return dataFile[filename]
@@ -144,7 +179,6 @@ func TimeNow() string {
 	return time.Now().Format(time.RFC3339)
 }
 
-
 func ParseUri(uri string) map[string][]string {
 	ret := make(map[string][]string)
 	u, err := url.Parse(uri)

pkg/exprhelpers/exprlib_test.go

@@ -455,3 +455,203 @@ func TestParseUri(t *testing.T) {
 		log.Printf("test '%s' : OK", test.name)
 	}
 }
+
+func TestQueryEscape(t *testing.T) {
+	tests := []struct {
+		name   string
+		env    map[string]interface{}
+		code   string
+		result string
+		err    string
+	}{
+		{
+			name: "QueryEscape() test: basic test",
+			env: map[string]interface{}{
+				"uri":         "/foo?a=1&b=2",
+				"QueryEscape": QueryEscape,
+			},
+			code:   "QueryEscape(uri)",
+			result: "%2Ffoo%3Fa%3D1%26b%3D2",
+			err:    "",
+		},
+		{
+			name: "QueryEscape() test: basic test",
+			env: map[string]interface{}{
+				"uri":         "/foo?a=1&&b=<>'\"",
+				"QueryEscape": QueryEscape,
+			},
+			code:   "QueryEscape(uri)",
+			result: "%2Ffoo%3Fa%3D1%26%26b%3D%3C%3E%27%22",
+			err:    "",
+		},
+	}
+
+	for _, test := range tests {
+		program, err := expr.Compile(test.code, expr.Env(test.env))
+		require.NoError(t, err)
+		output, err := expr.Run(program, test.env)
+		require.NoError(t, err)
+		require.Equal(t, test.result, output)
+		log.Printf("test '%s' : OK", test.name)
+	}
+}
+
+func TestPathEscape(t *testing.T) {
+	tests := []struct {
+		name   string
+		env    map[string]interface{}
+		code   string
+		result string
+		err    string
+	}{
+		{
+			name: "PathEscape() test: basic test",
+			env: map[string]interface{}{
+				"uri":        "/foo?a=1&b=2",
+				"PathEscape": PathEscape,
+			},
+			code:   "PathEscape(uri)",
+			result: "%2Ffoo%3Fa=1&b=2",
+			err:    "",
+		},
+		{
+			name: "PathEscape() test: basic test with more special chars",
+			env: map[string]interface{}{
+				"uri":        "/foo?a=1&&b=<>'\"",
+				"PathEscape": PathEscape,
+			},
+			code:   "PathEscape(uri)",
+			result: "%2Ffoo%3Fa=1&&b=%3C%3E%27%22",
+			err:    "",
+		},
+	}
+
+	for _, test := range tests {
+		program, err := expr.Compile(test.code, expr.Env(test.env))
+		require.NoError(t, err)
+		output, err := expr.Run(program, test.env)
+		require.NoError(t, err)
+		require.Equal(t, test.result, output)
+		log.Printf("test '%s' : OK", test.name)
+	}
+}
+
+func TestPathUnescape(t *testing.T) {
+	tests := []struct {
+		name   string
+		env    map[string]interface{}
+		code   string
+		result string
+		err    string
+	}{
+		{
+			name: "PathUnescape() test: basic test",
+			env: map[string]interface{}{
+				"uri":          "%2Ffoo%3Fa=1&b=%3C%3E%27%22",
+				"PathUnescape": PathUnescape,
+			},
+			code:   "PathUnescape(uri)",
+			result: "/foo?a=1&b=<>'\"",
+			err:    "",
+		},
+		{
+			name: "PathUnescape() test: basic test with more special chars",
+			env: map[string]interface{}{
+				"uri":          "/$%7Bjndi",
+				"PathUnescape": PathUnescape,
+			},
+			code:   "PathUnescape(uri)",
+			result: "/${jndi",
+			err:    "",
+		},
+	}
+
+	for _, test := range tests {
+		program, err := expr.Compile(test.code, expr.Env(test.env))
+		require.NoError(t, err)
+		output, err := expr.Run(program, test.env)
+		require.NoError(t, err)
+		require.Equal(t, test.result, output)
+		log.Printf("test '%s' : OK", test.name)
+	}
+}
+
+func TestQueryUnescape(t *testing.T) {
+	tests := []struct {
+		name   string
+		env    map[string]interface{}
+		code   string
+		result string
+		err    string
+	}{
+		{
+			name: "QueryUnescape() test: basic test",
+			env: map[string]interface{}{
+				"uri":           "%2Ffoo%3Fa=1&b=%3C%3E%27%22",
+				"QueryUnescape": QueryUnescape,
+			},
+			code:   "QueryUnescape(uri)",
+			result: "/foo?a=1&b=<>'\"",
+			err:    "",
+		},
+		{
+			name: "QueryUnescape() test: basic test with more special chars",
+			env: map[string]interface{}{
+				"uri":           "/$%7Bjndi",
+				"QueryUnescape": QueryUnescape,
+			},
+			code:   "QueryUnescape(uri)",
+			result: "/${jndi",
+			err:    "",
+		},
+	}
+
+	for _, test := range tests {
+		program, err := expr.Compile(test.code, expr.Env(test.env))
+		require.NoError(t, err)
+		output, err := expr.Run(program, test.env)
+		require.NoError(t, err)
+		require.Equal(t, test.result, output)
+		log.Printf("test '%s' : OK", test.name)
+	}
+}
+
+func TestLower(t *testing.T) {
+	tests := []struct {
+		name   string
+		env    map[string]interface{}
+		code   string
+		result string
+		err    string
+	}{
+		{
+			name: "Lower() test: basic test",
+			env: map[string]interface{}{
+				"name":  "ABCDEFG",
+				"Lower": Lower,
+			},
+			code:   "Lower(name)",
+			result: "abcdefg",
+			err:    "",
+		},
+		{
+			name: "Lower() test: basic test with more special chars",
+			env: map[string]interface{}{
+				"name":  "AbcDefG!#",
+				"Lower": Lower,
+			},
+			code:   "Lower(name)",
+			result: "abcdefg!#",
+			err:    "",
+		},
+	}
+
+	for _, test := range tests {
+		program, err := expr.Compile(test.code, expr.Env(test.env))
+		require.NoError(t, err)
+		output, err := expr.Run(program, test.env)
+		require.NoError(t, err)
+		require.Equal(t, test.result, output)
+		log.Printf("test '%s' : OK", test.name)
+	}
+}