openapi3: preserve all validation errors for allOf

openapi3/errors.go

@@ -57,3 +57,13 @@ func (meo multiErrorForOneOf) Error() string {
 func (meo multiErrorForOneOf) Unwrap() error {
 	return MultiError(meo)
 }
+
+type multiErrorForAllOf MultiError
+
+func (mea multiErrorForAllOf) Error() string {
+	return spliceErr(" And ", mea)
+}
+
+func (mea multiErrorForAllOf) Unwrap() error {
+	return MultiError(mea)
+}

openapi3/schema.go

@@ -1429,6 +1429,7 @@ func (schema *Schema) visitXOFOperations(settings *schemaValidationSettings, val
 		visitedAnyOf = true
 	}
 
+	validationErrors := multiErrorForAllOf{}
 	for _, item := range schema.AllOf {
 		v := item.Value
 		if v == nil {
@@ -1438,17 +1439,20 @@ func (schema *Schema) visitXOFOperations(settings *schemaValidationSettings, val
 			if settings.failfast {
 				return errSchema, false
 			}
-			return &SchemaError{
-				Value:                 value,
-				Schema:                schema,
-				SchemaField:           "allOf",
-				Reason:                `doesn't match all schemas from "allOf"`,
-				Origin:                err,
-				customizeMessageError: settings.customizeMessageError,
-			}, false
+			validationErrors = append(validationErrors, err)
 		}
 		visitedAllOf = true
 	}
+	if len(validationErrors) > 0 {
+		return &SchemaError{
+			Value:                 value,
+			Schema:                schema,
+			SchemaField:           "allOf",
+			Reason:                `doesn't match all schemas from "allOf"`,
+			Origin:                fmt.Errorf("doesn't match schema due to: %w", validationErrors),
+			customizeMessageError: settings.customizeMessageError,
+		}, false
+	}
 
 	run = !((visitedOneOf || visitedAnyOf || visitedAllOf) && value == nil)
 	return

openapi3filter/issue641_test.go

@@ -69,7 +69,7 @@ paths:
 			name:   "failed allof pattern",
 			spec:   allOfSpec,
 			req:    `/items?test=999999`,
-			errStr: `parameter "test" in query has an error: string doesn't match the regular expression "^[0-9]{1,4}$"`,
+			errStr: `parameter "test" in query has an error: doesn't match schema due to: string doesn't match the regular expression "^[0-9]{1,4}$"`,
 		},
 	}
 

openapi3filter/issue789_test.go

@@ -69,7 +69,7 @@ paths:
 			name:   "failed allof object array",
 			spec:   allOfArraySpec,
 			req:    `/items?test=foo`,
-			errStr: `parameter "test" in query has an error: string doesn't match the regular expression`,
+			errStr: `parameter "test" in query has an error: doesn't match schema due to: string doesn't match the regular expression`,
 		},
 		{
 			name: "success oneof string pattern match",

openapi3filter/validation_error_test.go

@@ -3,6 +3,7 @@ package openapi3filter
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -47,6 +48,9 @@ type validationTest struct {
 	wantErrSchemaOriginReason string
 	wantErrSchemaOriginPath   string
 	wantErrSchemaOriginValue  any
+	wantMultiErrSchemaReasons []string
+	wantMultiErrSchemaPaths   []string
+	wantMultiErrSchemaValues  []any
 	wantErrParam              string
 	wantErrParamIn            string
 	wantErrParseKind          ParseErrorKind
@@ -478,17 +482,38 @@ func getValidationTests(t *testing.T) []*validationTest {
 			args: validationArgs{
 				r: newPetstoreRequest(t, http.MethodPost, "/pet2", bytes.NewBufferString(`{"name":"Bahama"}`)),
 			},
-			wantErrReason:             "doesn't match schema",
-			wantErrSchemaPath:         "/",
-			wantErrSchemaValue:        map[string]string{"name": "Bahama"},
-			wantErrSchemaReason:       `doesn't match all schemas from "allOf"`,
-			wantErrSchemaOriginReason: `property "photoUrls" is missing`,
-			wantErrSchemaOriginValue:  map[string]string{"name": "Bahama"},
-			wantErrSchemaOriginPath:   "/photoUrls",
+			wantErrReason:            "doesn't match schema",
+			wantErrSchemaPath:        "/",
+			wantErrSchemaValue:       map[string]string{"name": "Bahama"},
+			wantErrSchemaReason:      `doesn't match all schemas from "allOf"`,
+			wantMultiErrSchemaPaths:  []string{"/photoUrls"},
+			wantMultiErrSchemaValues: []any{map[string]string{"name": "Bahama"}},
+			wantMultiErrSchemaReasons: []string{
+				`property "photoUrls" is missing`,
+			},
 			wantErrResponse: &ValidationError{
 				Status: http.StatusUnprocessableEntity,
-				Title:  `property "photoUrls" is missing`,
-				Source: &ValidationErrorSource{Pointer: "/photoUrls"},
+				Title:  `doesn't match all schemas from "allOf"`,
+			},
+		},
+		{
+			name: "error - missing required object attribute and bad type from allOf required overlay",
+			args: validationArgs{
+				r: newPetstoreRequest(t, http.MethodPost, "/pet2", bytes.NewBufferString(`{"name":1}`)),
+			},
+			wantErrReason:            "doesn't match schema",
+			wantErrSchemaPath:        "/",
+			wantErrSchemaValue:       map[string]float64{"name": 1},
+			wantErrSchemaReason:      `doesn't match all schemas from "allOf"`,
+			wantMultiErrSchemaPaths:  []string{"/name", "/photoUrls"},
+			wantMultiErrSchemaValues: []any{1, map[string]float64{"name": 1}},
+			wantMultiErrSchemaReasons: []string{
+				"value must be a string",
+				"property \"photoUrls\" is missing",
+			},
+			wantErrResponse: &ValidationError{
+				Status: http.StatusUnprocessableEntity,
+				Title:  `doesn't match all schemas from "allOf"`,
 			},
 		},
 		{
@@ -599,6 +624,23 @@ func TestValidationHandler_validateRequest(t *testing.T) {
 						pointer := toJSONPointer(originErr.JSONPointer())
 						req.Equal(tt.wantErrSchemaOriginPath, pointer)
 						req.Equal(fmt.Sprint(tt.wantErrSchemaOriginValue), fmt.Sprint(originErr.Value))
+					} else if wrapErr := errors.Unwrap(innerErr.Origin); wrapErr != nil {
+						if multiErr, ok := errors.Unwrap(wrapErr).(openapi3.MultiError); ok {
+							req.Len(multiErr, len(tt.wantMultiErrSchemaReasons))
+							req.Len(multiErr, len(tt.wantMultiErrSchemaPaths))
+							req.Len(multiErr, len(tt.wantMultiErrSchemaValues))
+							for i, merr := range multiErr {
+								schemaErr, ok := merr.(*openapi3.SchemaError)
+								if !ok {
+									continue
+								}
+								req.Equal(tt.wantMultiErrSchemaReasons[i], schemaErr.Reason)
+								pointer := toJSONPointer(schemaErr.JSONPointer())
+								req.Equal(tt.wantMultiErrSchemaPaths[i], pointer)
+								req.Equal(fmt.Sprint(tt.wantMultiErrSchemaValues[i]), fmt.Sprint(schemaErr.Value))
+
+							}
+						}
 					}
 				} else {
 					req.False(tt.wantErrSchemaReason != "" || tt.wantErrSchemaPath != "",