Added request information to all non-schema validation errors

jacobm-splunk · daveshanley · commit ab93afca63b0 · 2024-04-12T14:15:18.000-04:00
diff --git a/errors/error_utilities.go b/errors/error_utilities.go
@@ -0,0 +1,16 @@
+package errors
+
+import (
+	"net/http"
+)
+
+// PopulateValidationErrors mutates the provided validation errors with additional useful error information, that is
+// not necessarily available when the ValidationError was created and are standard for all errors.
+// Specifically, the RequestPath, SpecPath and RequestMethod are populated.
+func PopulateValidationErrors(validationErrors []*ValidationError, request *http.Request, path string) {
+	for _, validationError := range validationErrors {
+		validationError.SpecPath = path
+		validationError.RequestMethod = request.Method
+		validationError.RequestPath = request.URL.Path
+	}
+}
diff --git a/errors/request_errors.go b/errors/request_errors.go
@@ -13,7 +13,7 @@ import (
 	"github.com/pb33f/libopenapi/orderedmap"
 )
 
-func RequestContentTypeNotFound(op *v3.Operation, request *http.Request) *ValidationError {
+func RequestContentTypeNotFound(op *v3.Operation, request *http.Request, specPath string) *ValidationError {
 	ct := request.Header.Get(helpers.ContentTypeHeader)
 	var ctypes []string
 	for pair := orderedmap.First(op.RequestBody.Content); pair != nil; pair = pair.Next() {
@@ -26,23 +26,29 @@ func RequestContentTypeNotFound(op *v3.Operation, request *http.Request) *Valida
 			request.Method, ct),
 		Reason: fmt.Sprintf("The content type '%s' of the %s request submitted has not "+
 			"been defined, it's an unknown type", ct, request.Method),
-		SpecLine: op.RequestBody.GoLow().Content.KeyNode.Line,
-		SpecCol:  op.RequestBody.GoLow().Content.KeyNode.Column,
-		Context:  op,
-		HowToFix: fmt.Sprintf(HowToFixInvalidContentType, orderedmap.Len(op.RequestBody.Content), strings.Join(ctypes, ", ")),
+		SpecLine:      op.RequestBody.GoLow().Content.KeyNode.Line,
+		SpecCol:       op.RequestBody.GoLow().Content.KeyNode.Column,
+		Context:       op,
+		HowToFix:      fmt.Sprintf(HowToFixInvalidContentType, orderedmap.Len(op.RequestBody.Content), strings.Join(ctypes, ", ")),
+		RequestPath:   request.URL.Path,
+		RequestMethod: request.Method,
+		SpecPath:      specPath,
 	}
 }
 
-func OperationNotFound(pathItem *v3.PathItem, request *http.Request, method string) *ValidationError {
+func OperationNotFound(pathItem *v3.PathItem, request *http.Request, method string, specPath string) *ValidationError {
 	return &ValidationError{
 		ValidationType:    helpers.RequestValidation,
 		ValidationSubType: helpers.RequestMissingOperation,
 		Message: fmt.Sprintf("%s operation request content type '%s' does not exist",
 			request.Method, method),
-		Reason:   fmt.Sprintf("The path was found, but there was no '%s' method found in the spec", request.Method),
-		SpecLine: pathItem.GoLow().KeyNode.Line,
-		SpecCol:  pathItem.GoLow().KeyNode.Column,
-		Context:  pathItem,
-		HowToFix: HowToFixPathMethod,
+		Reason:        fmt.Sprintf("The path was found, but there was no '%s' method found in the spec", request.Method),
+		SpecLine:      pathItem.GoLow().KeyNode.Line,
+		SpecCol:       pathItem.GoLow().KeyNode.Column,
+		Context:       pathItem,
+		HowToFix:      HowToFixPathMethod,
+		RequestPath:   request.URL.Path,
+		RequestMethod: request.Method,
+		SpecPath:      specPath,
 	}
 }
diff --git a/errors/validation_error.go b/errors/validation_error.go
@@ -75,6 +75,15 @@ type ValidationError struct {
 	// HowToFix is a human-readable message describing how to fix the error.
 	HowToFix string `json:"howToFix" yaml:"howToFix"`
 
+	// RequestPath is the path of the request
+	RequestPath string `json:"requestPath" yaml:"requestPath"`
+
+	// SpecPath is the path from the specification that corresponds to the request
+	SpecPath string `json:"specPath" yaml:"specPath"`
+
+	// RequestMethod is the HTTP method of the request
+	RequestMethod string `json:"requestMethod" yaml:"requestMethod"`
+
 	// SchemaValidationErrors is a slice of SchemaValidationFailure objects that describe the validation errors
 	// This is only populated whe the validation type is against a schema.
 	SchemaValidationErrors []*SchemaValidationFailure `json:"validationErrors,omitempty" yaml:"validationErrors,omitempty"`
diff --git a/parameters/cookie_parameters.go b/parameters/cookie_parameters.go
@@ -19,15 +19,18 @@ func (v *paramValidator) ValidateCookieParams(request *http.Request) (bool, []*e
 
 	// find path
 	var pathItem *v3.PathItem
+	var foundPath string
 	var errs []*errors.ValidationError
+
 	if v.pathItem == nil {
-		pathItem, errs, _ = paths.FindPath(request, v.document)
+		pathItem, errs, foundPath = paths.FindPath(request, v.document)
 		if pathItem == nil || errs != nil {
 			v.errors = errs
 			return false, errs
 		}
 	} else {
 		pathItem = v.pathItem
+		foundPath = v.pathValue
 	}
 
 	// extract params for the operation
@@ -121,6 +124,9 @@ func (v *paramValidator) ValidateCookieParams(request *http.Request) (bool, []*e
 			}
 		}
 	}
+
+	errors.PopulateValidationErrors(validationErrors, request, foundPath)
+
 	if len(validationErrors) > 0 {
 		return false, validationErrors
 	}
diff --git a/parameters/cookie_parameters_test.go b/parameters/cookie_parameters_test.go
@@ -35,6 +35,9 @@ paths:
 
 	assert.False(t, valid)
 	assert.Len(t, errors, 1)
+	assert.Equal(t, request.Method, errors[0].RequestMethod)
+	assert.Equal(t, request.URL.Path, errors[0].RequestPath)
+	assert.Equal(t, "", errors[0].SpecPath)
 }
 
 func TestNewValidator_CookieParamNumberValid(t *testing.T) {
@@ -202,6 +205,9 @@ paths:
 	assert.Len(t, errors, 1)
 	assert.Equal(t,
 		"Instead of 'milk', use one of the allowed values: 'beef, chicken, pea protein'", errors[0].HowToFix)
+	assert.Equal(t, request.Method, errors[0].RequestMethod)
+	assert.Equal(t, request.URL.Path, errors[0].RequestPath)
+	assert.Equal(t, "/burgers/beef", errors[0].SpecPath)
 }
 
 func TestNewValidator_CookieParamBooleanInvalid(t *testing.T) {
diff --git a/parameters/header_parameters.go b/parameters/header_parameters.go
@@ -19,15 +19,17 @@ import (
 func (v *paramValidator) ValidateHeaderParams(request *http.Request) (bool, []*errors.ValidationError) {
 	// find path
 	var pathItem *v3.PathItem
+	var specPath string
 	var errs []*errors.ValidationError
 	if v.pathItem == nil {
-		pathItem, errs, _ = paths.FindPath(request, v.document)
+		pathItem, errs, specPath = paths.FindPath(request, v.document)
 		if pathItem == nil || errs != nil {
 			v.errors = errs
 			return false, errs
 		}
 	} else {
 		pathItem = v.pathItem
+		specPath = v.pathValue
 	}
 
 	// extract params for the operation
@@ -143,6 +145,8 @@ func (v *paramValidator) ValidateHeaderParams(request *http.Request) (bool, []*e
 		}
 	}
 
+	errors.PopulateValidationErrors(validationErrors, request, specPath)
+
 	if len(validationErrors) > 0 {
 		return false, validationErrors
 	}
diff --git a/parameters/header_parameters_test.go b/parameters/header_parameters_test.go
@@ -36,6 +36,9 @@ paths:
 	assert.False(t, valid)
 	assert.Equal(t, 1, len(errors))
 	assert.Equal(t, "Header parameter 'bash' is missing", errors[0].Message)
+	assert.Equal(t, request.Method, errors[0].RequestMethod)
+	assert.Equal(t, request.URL.Path, errors[0].RequestPath)
+	assert.Equal(t, "/bish/bosh", errors[0].SpecPath)
 }
 
 func TestNewValidator_HeaderPathMissing(t *testing.T) {
@@ -63,6 +66,9 @@ paths:
 	assert.False(t, valid)
 	assert.Equal(t, 1, len(errors))
 	assert.Equal(t, "GET Path '/I/do/not/exist' not found", errors[0].Message)
+	assert.Equal(t, request.Method, errors[0].RequestMethod)
+	assert.Equal(t, request.URL.Path, errors[0].RequestPath)
+	assert.Equal(t, "", errors[0].SpecPath)
 }
 
 func TestNewValidator_HeaderParamDefaultEncoding_InvalidParamTypeNumber(t *testing.T) {
diff --git a/parameters/path_parameters.go b/parameters/path_parameters.go
@@ -276,6 +276,9 @@ func (v *paramValidator) ValidatePathParams(request *http.Request) (bool, []*err
 			}
 		}
 	}
+
+	errors.PopulateValidationErrors(validationErrors, request, foundPath)
+
 	if len(validationErrors) > 0 {
 		return false, validationErrors
 	}
diff --git a/parameters/path_parameters_test.go b/parameters/path_parameters_test.go
@@ -68,6 +68,9 @@ paths:
 	assert.False(t, valid)
 	assert.Len(t, errors, 2)
 	assert.Equal(t, "Path array parameter 'burgerIds' is not a valid number", errors[0].Message)
+	assert.Equal(t, request.Method, errors[0].RequestMethod)
+	assert.Equal(t, request.URL.Path, errors[0].RequestPath)
+	assert.Equal(t, "/burgers/{burgerIds*}/locate", errors[0].SpecPath)
 }
 
 func TestNewValidator_SimpleArrayEncodedPath_InvalidBool(t *testing.T) {
diff --git a/parameters/query_parameters.go b/parameters/query_parameters.go
@@ -22,15 +22,17 @@ import (
 func (v *paramValidator) ValidateQueryParams(request *http.Request) (bool, []*errors.ValidationError) {
 	// find path
 	var pathItem *v3.PathItem
+	var foundPath string
 	var errs []*errors.ValidationError
 	if v.pathItem == nil {
-		pathItem, errs, _ = paths.FindPath(request, v.document)
+		pathItem, errs, foundPath = paths.FindPath(request, v.document)
 		if pathItem == nil || errs != nil {
 			v.errors = errs
 			return false, errs
 		}
 	} else {
 		pathItem = v.pathItem
+		foundPath = v.pathValue
 	}
 
 	// extract params for the operation
@@ -211,6 +213,8 @@ doneLooking:
 		}
 	}
 
+	errors.PopulateValidationErrors(validationErrors, request, foundPath)
+
 	v.errors = validationErrors
 	if len(validationErrors) > 0 {
 		return false, validationErrors
diff --git a/parameters/query_parameters_test.go b/parameters/query_parameters_test.go
@@ -39,6 +39,9 @@ paths:
 	assert.False(t, valid)
 	assert.Equal(t, 1, len(errors))
 	assert.Equal(t, "Query parameter 'fishy' is missing", errors[0].Message)
+	assert.Equal(t, request.Method, errors[0].RequestMethod)
+	assert.Equal(t, request.URL.Path, errors[0].RequestPath)
+	assert.Equal(t, "/a/fishy/on/a/dishy", errors[0].SpecPath)
 }
 
 func TestNewValidator_QueryParamNotMissing(t *testing.T) {
diff --git a/parameters/validate_security.go b/parameters/validate_security.go
@@ -18,15 +18,17 @@ import (
 func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*errors.ValidationError) {
 	// find path
 	var pathItem *v3.PathItem
+	var pathFound string
 	var errs []*errors.ValidationError
 	if v.pathItem == nil {
-		pathItem, errs, _ = paths.FindPath(request, v.document)
+		pathItem, errs, pathFound = paths.FindPath(request, v.document)
 		if pathItem == nil || errs != nil {
 			v.errors = errs
 			return false, errs
 		}
 	} else {
 		pathItem = v.pathItem
+		pathFound = v.pathValue
 	}
 
 	// extract security for the operation
@@ -42,7 +44,7 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 
 			// look up security from components
 			if v.document.Components == nil || v.document.Components.SecuritySchemes.GetOrZero(secName) == nil {
-				return false, []*errors.ValidationError{
+				validationErrors := []*errors.ValidationError{
 					{
 						Message: fmt.Sprintf("Security scheme '%s' is missing", secName),
 						Reason: fmt.Sprintf("The security scheme '%s' is defined as being required, "+
@@ -53,6 +55,9 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 						HowToFix:       "Add the missing security scheme to the components",
 					},
 				}
+				errors.PopulateValidationErrors(validationErrors, request, pathFound)
+
+				return false, validationErrors
 			}
 			secScheme := v.document.Components.SecuritySchemes.GetOrZero(secName)
 			switch strings.ToLower(secScheme.Type) {
@@ -61,7 +66,7 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 				case "basic", "bearer", "digest":
 					// check for an authorization header
 					if request.Header.Get("Authorization") == "" {
-						return false, []*errors.ValidationError{
+						validationErrors := []*errors.ValidationError{
 							{
 								Message:           fmt.Sprintf("Authorization header for '%s' scheme", secScheme.Scheme),
 								Reason:            "Authorization header was not found",
@@ -72,14 +77,18 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 								HowToFix:          "Add an 'Authorization' header to this request",
 							},
 						}
+
+						errors.PopulateValidationErrors(validationErrors, request, pathFound)
+
+						return false, validationErrors
 					}
 				}
 
 			case "apikey":
 				// check if the api key is in the request
 				if secScheme.In == "header" {
 					if request.Header.Get(secScheme.Name) == "" {
-						return false, []*errors.ValidationError{
+						validationErrors := []*errors.ValidationError{
 							{
 								Message:           fmt.Sprintf("API Key %s not found in header", secScheme.Name),
 								Reason:            "API Key not found in http header for security scheme 'apiKey' with type 'header'",
@@ -90,6 +99,10 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 								HowToFix:          fmt.Sprintf("Add the API Key via '%s' as a header of the request", secScheme.Name),
 							},
 						}
+
+						errors.PopulateValidationErrors(validationErrors, request, pathFound)
+
+						return false, validationErrors
 					}
 				}
 				if secScheme.In == "query" {
@@ -100,7 +113,7 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 						q.Add(secScheme.Name, "your-api-key")
 						fixed.RawQuery = q.Encode()
 
-						return false, []*errors.ValidationError{
+						validationErrors := []*errors.ValidationError{
 							{
 								Message:           fmt.Sprintf("API Key %s not found in query", secScheme.Name),
 								Reason:            "API Key not found in URL query for security scheme 'apiKey' with type 'query'",
@@ -112,6 +125,10 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 									"of the URL, for example '%s'", secScheme.Name, fixed.String()),
 							},
 						}
+
+						errors.PopulateValidationErrors(validationErrors, request, pathFound)
+
+						return false, validationErrors
 					}
 				}
 				if secScheme.In == "cookie" {
@@ -124,7 +141,7 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 						}
 					}
 					if !cookieFound {
-						return false, []*errors.ValidationError{
+						validationErrors := []*errors.ValidationError{
 							{
 								Message:           fmt.Sprintf("API Key %s not found in cookies", secScheme.Name),
 								Reason:            "API Key not found in http request cookies for security scheme 'apiKey' with type 'cookie'",
@@ -135,6 +152,10 @@ func (v *paramValidator) ValidateSecurity(request *http.Request) (bool, []*error
 								HowToFix:          fmt.Sprintf("Submit an API Key '%s' as a cookie with the request", secScheme.Name),
 							},
 						}
+
+						errors.PopulateValidationErrors(validationErrors, request, pathFound)
+
+						return false, validationErrors
 					}
 				}
 			}
diff --git a/parameters/validate_security_test.go b/parameters/validate_security_test.go
diff --git a/paths/paths.go b/paths/paths.go
diff --git a/requests/validate_body.go b/requests/validate_body.go
diff --git a/requests/validate_body_test.go b/requests/validate_body_test.go
diff --git a/responses/validate_body.go b/responses/validate_body.go
diff --git a/responses/validate_body_test.go b/responses/validate_body_test.go

Original file line number	Diff line number	Diff line change
`@@ -19,15 +19,18 @@ func (v paramValidator) ValidateCookieParams(request http.Request) (bool, []*e`
`19`	`19`
`20`	`20`	`// find path`
`21`	`21`	`var pathItem *v3.PathItem`
	`22`	`+ var foundPath string`
`22`	`23`	`var errs []*errors.ValidationError`
	`24`	`+`
`23`	`25`	`if v.pathItem == nil {`
`24`		`- pathItem, errs, _ = paths.FindPath(request, v.document)`
	`26`	`+ pathItem, errs, foundPath = paths.FindPath(request, v.document)`
`25`	`27`	`if pathItem == nil \|\| errs != nil {`
`26`	`28`	`v.errors = errs`
`27`	`29`	`return false, errs`
`28`	`30`	`}`
`29`	`31`	`} else {`
`30`	`32`	`pathItem = v.pathItem`
	`33`	`+ foundPath = v.pathValue`
`31`	`34`	`}`
`32`	`35`
`33`	`36`	`// extract params for the operation`
`@@ -121,6 +124,9 @@ func (v paramValidator) ValidateCookieParams(request http.Request) (bool, []*e`
`121`	`124`	`}`
`122`	`125`	`}`
`123`	`126`	`}`
	`127`	`+`
	`128`	`+ errors.PopulateValidationErrors(validationErrors, request, foundPath)`
	`129`	`+`
`124`	`130`	`if len(validationErrors) > 0 {`
`125`	`131`	`return false, validationErrors`
`126`	`132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,15 +19,17 @@ import (`
`19`	`19`	`func (v paramValidator) ValidateHeaderParams(request http.Request) (bool, []*errors.ValidationError) {`
`20`	`20`	`// find path`
`21`	`21`	`var pathItem *v3.PathItem`
	`22`	`+ var specPath string`
`22`	`23`	`var errs []*errors.ValidationError`
`23`	`24`	`if v.pathItem == nil {`
`24`		`- pathItem, errs, _ = paths.FindPath(request, v.document)`
	`25`	`+ pathItem, errs, specPath = paths.FindPath(request, v.document)`
`25`	`26`	`if pathItem == nil \|\| errs != nil {`
`26`	`27`	`v.errors = errs`
`27`	`28`	`return false, errs`
`28`	`29`	`}`
`29`	`30`	`} else {`
`30`	`31`	`pathItem = v.pathItem`
	`32`	`+ specPath = v.pathValue`
`31`	`33`	`}`
`32`	`34`
`33`	`35`	`// extract params for the operation`
`@@ -143,6 +145,8 @@ func (v paramValidator) ValidateHeaderParams(request http.Request) (bool, []*e`
`143`	`145`	`}`
`144`	`146`	`}`
`145`	`147`
	`148`	`+ errors.PopulateValidationErrors(validationErrors, request, specPath)`
	`149`	`+`
`146`	`150`	`if len(validationErrors) > 0 {`
`147`	`151`	`return false, validationErrors`
`148`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -276,6 +276,9 @@ func (v paramValidator) ValidatePathParams(request http.Request) (bool, []*err`
`276`	`276`	`}`
`277`	`277`	`}`
`278`	`278`	`}`
	`279`	`+`
	`280`	`+ errors.PopulateValidationErrors(validationErrors, request, foundPath)`
	`281`	`+`
`279`	`282`	`if len(validationErrors) > 0 {`
`280`	`283`	`return false, validationErrors`
`281`	`284`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,9 @@ paths:`
`68`	`68`	`assert.False(t, valid)`
`69`	`69`	`assert.Len(t, errors, 2)`
`70`	`70`	`assert.Equal(t, "Path array parameter 'burgerIds' is not a valid number", errors[0].Message)`
	`71`	`+ assert.Equal(t, request.Method, errors[0].RequestMethod)`
	`72`	`+ assert.Equal(t, request.URL.Path, errors[0].RequestPath)`
	`73`	`+ assert.Equal(t, "/burgers/{burgerIds*}/locate", errors[0].SpecPath)`
`71`	`74`	`}`
`72`	`75`
`73`	`76`	`func TestNewValidator_SimpleArrayEncodedPath_InvalidBool(t *testing.T) {`