Add ozzo string rule for checking if a value is a valid path parameter

Author: Kem-Gov

utils/url/url.go

@@ -25,7 +25,7 @@ type PathSegmentMatcherFunc = func(segmentA, segmentB string) (match bool, err e
 // ValidatePathParameter checks whether a path parameter is valid. An error is returned if it is invalid.
 // Version 3.1.0 of the OpenAPI spec provides some guidance for path parameter values (see https://spec.openapis.org/oas/v3.1.0.html#path-templating)
 func ValidatePathParameter(parameter string) error {
-	if !IsPathParameter(parameter) {
+	if !MatchesPathParameterSyntax(parameter) {
 		return commonerrors.Newf(commonerrors.ErrInvalid, "parameter %q must not be empty, cannot contain only whitespaces, have a length greater than or equal to three, start with an opening brace, and end with a closing brace", parameter)
 	}
 
@@ -41,8 +41,8 @@ func ValidatePathParameter(parameter string) error {
 	return nil
 }
 
-// IsPathParameter checks whether the parameter string is a path parameter as described by the OpenAPI spec (see https://spec.openapis.org/oas/v3.0.0.html#path-templating).
-func IsPathParameter(parameter string) bool {
+// MatchesPathParameterSyntax checks whether the parameter string matches the syntax for a path parameter as described by the OpenAPI spec (see https://spec.openapis.org/oas/v3.0.0.html#path-templating).
+func MatchesPathParameterSyntax(parameter string) bool {
 	if reflection.IsEmpty(parameter) {
 		return false
 	}
@@ -80,7 +80,7 @@ func BasicEqualityPathSegmentMatcher(segmentA, segmentB string) (match bool, err
 
 // BasicEqualityPathSegmentWithParamMatcher is a PathSegmentMatcherFunc that is similar to BasicEqualityPathSegmentMatcher but accounts for path parameter segments.
 func BasicEqualityPathSegmentWithParamMatcher(segmentA, segmentB string) (match bool, err error) {
-	if IsPathParameter(segmentA) {
+	if MatchesPathParameterSyntax(segmentA) {
 		if errValidatePathASeg := ValidatePathParameter(segmentA); errValidatePathASeg != nil {
 			err = commonerrors.WrapErrorf(commonerrors.ErrInvalid, errValidatePathASeg, "an error occurred while validating path parameter %q", segmentA)
 			return
@@ -90,7 +90,7 @@ func BasicEqualityPathSegmentWithParamMatcher(segmentA, segmentB string) (match
 		return
 	}
 
-	if IsPathParameter(segmentB) {
+	if MatchesPathParameterSyntax(segmentB) {
 		if errValidatePathBSeg := ValidatePathParameter(segmentB); errValidatePathBSeg != nil {
 			err = commonerrors.WrapErrorf(commonerrors.ErrInvalid, errValidatePathBSeg, "an error occurred while validating path parameter %q", segmentB)
 			return

utils/url/url_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/ARM-software/golang-utils/utils/commonerrors/errortest"
 )
 
-func TestUrl_IsPathParameter(t *testing.T) {
+func TestUrl_MatchesPathParameterSyntax(t *testing.T) {
 	tests := []struct {
 		name      string
 		parameter string
@@ -71,7 +71,7 @@ func TestUrl_IsPathParameter(t *testing.T) {
 	for i := range tests {
 		test := tests[i]
 		t.Run(test.name, func(t *testing.T) {
-			assert.Equal(t, test.result, IsPathParameter(test.parameter))
+			assert.Equal(t, test.result, MatchesPathParameterSyntax(test.parameter))
 		})
 	}
 }

utils/validation/rules.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/ARM-software/golang-utils/utils/commonerrors"
 	"github.com/ARM-software/golang-utils/utils/encoding/base64"
+	"github.com/ARM-software/golang-utils/utils/url"
 )
 
 // IsPort validates whether a value is a port using is.Port from github.com/go-ozzo/ozzo-validation/v4.
@@ -41,3 +42,11 @@ func isPort(vRaw any) (err error) {
 
 // IsBase64 validates whether a value is a base64 encoded string. It is similar to is.Base64 but more generic and robust although less performant.
 var IsBase64 = validation.NewStringRuleWithError(base64.IsEncoded, is.ErrBase64)
+
+// IsPathParameter validates whether a value is a valid path parameter of a url.
+var IsPathParameter = validation.NewStringRule(isValidPathParameter, "invalid path parameter")
+
+func isValidPathParameter(value string) bool {
+	err := url.ValidatePathParameter(value)
+	return err == nil
+}

utils/validation/rules_test.go

@@ -97,3 +97,31 @@ func TestIsBase64Encoded(t *testing.T) {
 		})
 	}
 }
+
+func TestIsPathParameter(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected bool
+	}{
+		{"{abc}", true},
+		{"abc}", false},
+		{"{abc", false},
+		{"abc", false},
+		{"{abc$123.zzz~999}", true},
+		{"{abc%5F1}", true}, // unescaped as '{abc_1}'
+		{"{abc#123}", false},
+		{" ", false},
+	}
+
+	for i := range tests {
+		test := tests[i]
+		t.Run(test.input, func(t *testing.T) {
+			err := validation.Validate(test.input, IsPathParameter)
+			if test.expected {
+				require.NoError(t, err)
+			} else {
+				errortest.AssertErrorDescription(t, err, "invalid path parameter")
+			}
+		})
+	}
+}