Add URL escape and unespace normalizers and tests to v2. (#143)

# Describe Request

Add URL escape and unespace normalizers and tests to v2.

# Change Type

New code.

v2/maker.go

@@ -35,6 +35,7 @@ var makers = map[string]MakeCheckFunc{
 	nameTrimSpace:    makeTrimSpace,
 	nameURL:          makeURL,
 	nameURLEscape:    makeURLEscape,
+	nameURLUnescape:  makeURLUnescape,
 }
 
 // makeChecks take a checker config and returns the check functions.

v2/url_escape.go

@@ -10,28 +10,21 @@ import (
 	"reflect"
 )
 
-const (
-	// nameURLEscape is the name of the URL escape normalizer.
-	nameURLEscape = "url-escape"
-)
+// nameURLEscape is the name of the URL escape normalizer.
+const nameURLEscape = "url-escape"
 
-// normalizeURLEscape applies URL escaping to special characters.
-// Uses net.url.QueryEscape for the actual escape operation.
-func normalizeURLEscape(value string) (string, error) {
+// URLEscape applies URL escaping to special characters.
+func URLEscape(value string) (string, error) {
 	return url.QueryEscape(value), nil
 }
 
-// checkURLEscape checks if the value is a valid URL escape string.
-func checkURLEscape(value reflect.Value) (reflect.Value, error) {
-	escaped, err := normalizeURLEscape(value.Interface().(string))
-	if err != nil {
-		return value, err
-	}
-	value.SetString(escaped)
-	return value, nil
+// reflectURLEscape applies URL escaping to special characters.
+func reflectURLEscape(value reflect.Value) (reflect.Value, error) {
+	newValue, err := URLEscape(value.Interface().(string))
+	return reflect.ValueOf(newValue), err
 }
 
-// makeURLEscape makes a normalizer function for the URL escape normalizer.
+// makeURLEscape returns the URL escape normalizer function.
 func makeURLEscape(_ string) CheckFunc[reflect.Value] {
-	return checkURLEscape
+	return reflectURLEscape
 }

v2/url_escape_test.go

@@ -11,19 +11,21 @@ import (
 	v2 "github.com/cinar/checker/v2"
 )
 
-func TestNormalizeURLEscapeNonString(t *testing.T) {
-	defer FailIfNoPanic(t, "expected panic")
+func TestURLEscape(t *testing.T) {
+	input := "param1/param2 = 1 + 2 & 3 + 4"
+	expected := "param1%2Fparam2+%3D+1+%2B+2+%26+3+%2B+4"
 
-	type Request struct {
-		Query int `checkers:"url-escape"`
+	actual, err := v2.URLEscape(input)
+	if err != nil {
+		t.Fatal(err)
 	}
 
-	request := &Request{}
-
-	v2.CheckStruct(request)
+	if actual != expected {
+		t.Fatalf("actual %s expected %s", actual, expected)
+	}
 }
 
-func TestNormalizeURLEscape(t *testing.T) {
+func TestReflectURLEscape(t *testing.T) {
 	type Request struct {
 		Query string `checkers:"url-escape"`
 	}
@@ -32,12 +34,14 @@ func TestNormalizeURLEscape(t *testing.T) {
 		Query: "param1/param2 = 1 + 2 & 3 + 4",
 	}
 
-	_, valid := v2.CheckStruct(request)
-	if !valid {
-		t.Fail()
+	expected := "param1%2Fparam2+%3D+1+%2B+2+%26+3+%2B+4"
+
+	errs, ok := v2.CheckStruct(request)
+	if !ok {
+		t.Fatalf("got unexpected errors %v", errs)
 	}
 
-	if request.Query != "param1%2Fparam2+%3D+1+%2B+2+%26+3+%2B+4" {
-		t.Fail()
+	if request.Query != expected {
+		t.Fatalf("actual %s expected %s", request.Query, expected)
 	}
 }

v2/url_unescape.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2023-2024 Onur Cinar.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+// https://github.com/cinar/checker
+
+package v2
+
+import (
+	"net/url"
+	"reflect"
+)
+
+// nameURLUnescape is the name of the URL unescape normalizer.
+const nameURLUnescape = "url-unescape"
+
+// URLUnescape applies URL unescaping to special characters.
+func URLUnescape(value string) (string, error) {
+	unescaped, err := url.QueryUnescape(value)
+	return unescaped, err
+}
+
+// reflectURLUnescape applies URL unescaping to special characters.
+func reflectURLUnescape(value reflect.Value) (reflect.Value, error) {
+	newValue, err := URLUnescape(value.Interface().(string))
+	return reflect.ValueOf(newValue), err
+}
+
+// makeURLUnescape returns the URL unescape normalizer function.
+func makeURLUnescape(_ string) CheckFunc[reflect.Value] {
+	return reflectURLUnescape
+}

v2/url_unescape_test.go

@@ -0,0 +1,47 @@
+// Copyright (c) 2023-2024 Onur Cinar.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+// https://github.com/cinar/checker
+
+package v2_test
+
+import (
+	"testing"
+
+	v2 "github.com/cinar/checker/v2"
+)
+
+func TestURLUnescape(t *testing.T) {
+	input := "param1%2Fparam2+%3D+1+%2B+2+%26+3+%2B+4"
+	expected := "param1/param2 = 1 + 2 & 3 + 4"
+
+	actual, err := v2.URLUnescape(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if actual != expected {
+		t.Fatalf("actual %s expected %s", actual, expected)
+	}
+}
+
+func TestReflectURLUnescape(t *testing.T) {
+	type Request struct {
+		Query string `checkers:"url-unescape"`
+	}
+
+	request := &Request{
+		Query: "param1%2Fparam2+%3D+1+%2B+2+%26+3+%2B+4",
+	}
+
+	expected := "param1/param2 = 1 + 2 & 3 + 4"
+
+	errs, ok := v2.CheckStruct(request)
+	if !ok {
+		t.Fatalf("got unexpected errors %v", errs)
+	}
+
+	if request.Query != expected {
+		t.Fatalf("actual %s expected %s", request.Query, expected)
+	}
+}