address issue pb33f/wiretap#146

Author: daveshanley

requests/validate_body.go

@@ -126,10 +126,11 @@ func (v *requestBodyValidator) ValidateRequestBodyWithPathItem(request *http.Req
 	}
 
 	validationSucceeded, validationErrors := ValidateRequestSchema(&ValidateRequestSchemaInput{
-		Request: request,
-		Schema:  schema,
-		Version: helpers.VersionToFloat(v.document.Version),
-		Options: []config.Option{config.WithExistingOpts(v.options)},
+		Request:      request,
+		Schema:       schema,
+		Version:      helpers.VersionToFloat(v.document.Version),
+		Options:      []config.Option{config.WithExistingOpts(v.options)},
+		BodyRequired: required,
 	})
 
 	errors.PopulateValidationErrors(validationErrors, request, pathValue)

requests/validate_body_test.go

@@ -1154,6 +1154,7 @@ paths:
   /burgers/createBurger:
     post:
       requestBody:
+        required: true
         content:
           application/json:
             schema:
@@ -1448,6 +1449,41 @@ func TestValidateBody_SchemaNoType_Issue75(t *testing.T) {
 	assert.Equal(t, "PUT request body is empty for '/path1'", valErrs[0].Message)
 }
 
+// https://github.com/pb33f/wiretap/issues/146
+func TestValidateBody_OptionalRequestBody_EmptyBody(t *testing.T) {
+	spec := `openapi: 3.0.1
+info:
+  title: test
+  version: "1.0"
+paths:
+  /test:
+    post:
+      requestBody:
+        required: false
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                name:
+                  type: string
+      responses:
+        "200":
+          description: OK`
+
+	doc, _ := libopenapi.NewDocument([]byte(spec))
+	v3Model, _ := doc.BuildV3Model()
+
+	req, _ := http.NewRequest("POST", "/test", nil)
+	req.Header.Set("Content-Type", "application/json")
+
+	reqBodyValidator := NewRequestBodyValidator(&v3Model.Model)
+	isSuccess, valErrs := reqBodyValidator.ValidateRequestBody(req)
+
+	assert.True(t, isSuccess)
+	assert.Empty(t, valErrs)
+}
+
 // https://github.com/pb33f/libopenapi-validator/issues/144
 func TestValidateBody_InvalidSchema_EnsureOptionsPassthrough(t *testing.T) {
 	spec := `openapi: 3.1.0

requests/validate_request.go

@@ -32,10 +32,11 @@ var instanceLocationRegex = regexp.MustCompile(`^/(\d+)`)
 
 // ValidateRequestSchemaInput contains parameters for request schema validation.
 type ValidateRequestSchemaInput struct {
-	Request *http.Request   // Required: The HTTP request to validate
-	Schema  *base.Schema    // Required: The OpenAPI schema to validate against
-	Version float32         // Required: OpenAPI version (3.0 or 3.1)
-	Options []config.Option // Optional: Functional options (defaults applied if empty/nil)
+	Request      *http.Request   // Required: The HTTP request to validate
+	Schema       *base.Schema    // Required: The OpenAPI schema to validate against
+	Version      float32         // Required: OpenAPI version (3.0 or 3.1)
+	Options      []config.Option // Optional: Functional options (defaults applied if empty/nil)
+	BodyRequired bool            // Optional: Whether the request body is required (default false)
 }
 
 // ValidateRequestSchema will validate a http.Request pointer against a schema.
@@ -178,6 +179,9 @@ func ValidateRequestSchema(input *ValidateRequestSchemaInput) (bool, []*errors.V
 
 	// no request body? but we do have a schema?
 	if len(requestBody) == 0 && len(jsonSchema) > 0 {
+		if !input.BodyRequired {
+			return true, nil
+		}
 
 		line := schema.ParentProxy.GetSchemaKeyNode().Line
 		col := schema.ParentProxy.GetSchemaKeyNode().Line
@@ -186,7 +190,6 @@ func ValidateRequestSchema(input *ValidateRequestSchemaInput) (bool, []*errors.V
 			col = schema.GoLow().Type.KeyNode.Column
 		}
 
-		// cannot decode the request body, so it's not valid
 		validationErrors = append(validationErrors, &errors.ValidationError{
 			ValidationType:    helpers.RequestBodyValidation,
 			ValidationSubType: helpers.Schema,

requests/validate_request_test.go

@@ -192,6 +192,41 @@ func TestValidateRequestSchema_NilSchemaGoLow(t *testing.T) {
 	assert.Contains(t, errors[0].Reason, "does not have low-level information")
 }
 
+func TestValidateRequestSchema_EmptyBodyOptional(t *testing.T) {
+	schema := parseSchemaFromSpec(t, `type: object
+properties:
+  name:
+    type: string`, 3.1)
+
+	valid, errors := ValidateRequestSchema(&ValidateRequestSchemaInput{
+		Request:      emptyPostRequest(),
+		Schema:       schema,
+		Version:      3.1,
+		BodyRequired: false,
+	})
+
+	assert.True(t, valid)
+	assert.Empty(t, errors)
+}
+
+func TestValidateRequestSchema_EmptyBodyRequired(t *testing.T) {
+	schema := parseSchemaFromSpec(t, `type: object
+properties:
+  name:
+    type: string`, 3.1)
+
+	valid, errors := ValidateRequestSchema(&ValidateRequestSchemaInput{
+		Request:      emptyPostRequest(),
+		Schema:       schema,
+		Version:      3.1,
+		BodyRequired: true,
+	})
+
+	assert.False(t, valid)
+	require.Len(t, errors, 1)
+	assert.Contains(t, errors[0].Message, "request body is empty")
+}
+
 func postRequestWithBody(payload string) *http.Request {
 	return &http.Request{
 		Method: http.MethodPost,
@@ -200,6 +235,14 @@ func postRequestWithBody(payload string) *http.Request {
 	}
 }
 
+func emptyPostRequest() *http.Request {
+	return &http.Request{
+		Method: http.MethodPost,
+		URL:    &url.URL{Path: "/test"},
+		Body:   http.NoBody,
+	}
+}
+
 // parseSchemaFromSpec creates a base.Schema from an OpenAPI spec YAML string.
 // This ensures that we're using the native libopenapi logic for generating the schema.
 func parseSchemaFromSpec(t *testing.T, schemaYAML string, version float32) *base.Schema {