Update a few dependencies

github.com/go-openapi/*
github.com/asaskevich/govalidator

vendor/github.com/go-openapi/validate/schema_props.go

@@ -15,10 +15,9 @@
 package validate
 
 import (
-	"log"
+	"fmt"
 	"reflect"
 
-	"github.com/go-openapi/errors"
 	"github.com/go-openapi/spec"
 	"github.com/go-openapi/strfmt"
 )
@@ -44,15 +43,15 @@ func (s *schemaPropsValidator) SetPath(path string) {
 }
 
 func newSchemaPropsValidator(path string, in string, allOf, oneOf, anyOf []spec.Schema, not *spec.Schema, deps spec.Dependencies, root interface{}, formats strfmt.Registry) *schemaPropsValidator {
-	var anyValidators []SchemaValidator
+	anyValidators := make([]SchemaValidator, 0, len(anyOf))
 	for _, v := range anyOf {
 		anyValidators = append(anyValidators, *NewSchemaValidator(&v, root, path, formats))
 	}
-	var allValidators []SchemaValidator
+	allValidators := make([]SchemaValidator, 0, len(allOf))
 	for _, v := range allOf {
 		allValidators = append(allValidators, *NewSchemaValidator(&v, root, path, formats))
 	}
-	var oneValidators []SchemaValidator
+	oneValidators := make([]SchemaValidator, 0, len(oneOf))
 	for _, v := range oneOf {
 		oneValidators = append(oneValidators, *NewSchemaValidator(&v, root, path, formats))
 	}
@@ -81,35 +80,46 @@ func newSchemaPropsValidator(path string, in string, allOf, oneOf, anyOf []spec.
 
 func (s *schemaPropsValidator) Applies(source interface{}, kind reflect.Kind) bool {
 	r := reflect.TypeOf(source) == specSchemaType
-	if Debug {
-		log.Printf("schema props validator for %q applies %t for %T (kind: %v)\n", s.Path, r, source, kind)
-	}
+	debugLog("schema props validator for %q applies %t for %T (kind: %v)\n", s.Path, r, source, kind)
 	return r
 }
 
 func (s *schemaPropsValidator) Validate(data interface{}) *Result {
 	mainResult := new(Result)
+
+	// Intermediary error results
+
+	// IMPORTANT! messages from underlying validators
+	keepResultAnyOf := new(Result)
+	keepResultOneOf := new(Result)
+	keepResultAllOf := new(Result)
+
+	// Validates at least one in anyOf schemas
 	var firstSuccess *Result
 	if len(s.anyOfValidators) > 0 {
 		var bestFailures *Result
 		succeededOnce := false
 		for _, anyOfSchema := range s.anyOfValidators {
 			result := anyOfSchema.Validate(data)
+			// We keep inner IMPORTANT! errors no matter what MatchCount tells us
+			keepResultAnyOf.Merge(result.keepRelevantErrors())
 			if result.IsValid() {
 				bestFailures = nil
 				succeededOnce = true
 				if firstSuccess == nil {
 					firstSuccess = result
 				}
+				keepResultAnyOf = new(Result)
 				break
 			}
+			// MatchCount is used to select errors from the schema with most positive checks
 			if bestFailures == nil || result.MatchCount > bestFailures.MatchCount {
 				bestFailures = result
 			}
 		}
 
 		if !succeededOnce {
-			mainResult.AddErrors(errors.New(422, "must validate at least one schema (anyOf)"))
+			mainResult.AddErrors(mustValidateAtLeastOneSchemaMsg(s.Path))
 		}
 		if bestFailures != nil {
 			mainResult.Merge(bestFailures)
@@ -118,6 +128,7 @@ func (s *schemaPropsValidator) Validate(data interface{}) *Result {
 		}
 	}
 
+	// Validates exactly one in oneOf schemas
 	if len(s.oneOfValidators) > 0 {
 		var bestFailures *Result
 		var firstSuccess *Result
@@ -125,21 +136,32 @@ func (s *schemaPropsValidator) Validate(data interface{}) *Result {
 
 		for _, oneOfSchema := range s.oneOfValidators {
 			result := oneOfSchema.Validate(data)
+			// We keep inner IMPORTANT! errors no matter what MatchCount tells us
+			keepResultOneOf.Merge(result.keepRelevantErrors())
 			if result.IsValid() {
 				validated++
 				bestFailures = nil
 				if firstSuccess == nil {
 					firstSuccess = result
 				}
+				keepResultOneOf = new(Result)
 				continue
 			}
+			// MatchCount is used to select errors from the schema with most positive checks
 			if validated == 0 && (bestFailures == nil || result.MatchCount > bestFailures.MatchCount) {
 				bestFailures = result
 			}
 		}
 
 		if validated != 1 {
-			mainResult.AddErrors(errors.New(422, "must validate one and only one schema (oneOf)"))
+			additionalMsg := ""
+			if validated == 0 {
+				additionalMsg = "Found none valid"
+			} else {
+				additionalMsg = fmt.Sprintf("Found %d valid alternatives", validated)
+			}
+
+			mainResult.AddErrors(mustValidateOnlyOneSchemaMsg(s.Path, additionalMsg))
 			if bestFailures != nil {
 				mainResult.Merge(bestFailures)
 			}
@@ -148,11 +170,15 @@ func (s *schemaPropsValidator) Validate(data interface{}) *Result {
 		}
 	}
 
+	// Validates all of allOf schemas
 	if len(s.allOfValidators) > 0 {
 		validated := 0
 
 		for _, allOfSchema := range s.allOfValidators {
 			result := allOfSchema.Validate(data)
+			// We keep inner IMPORTANT! errors no matter what MatchCount tells us
+			keepResultAllOf.Merge(result.keepRelevantErrors())
+			//keepResultAllOf.Merge(result)
 			if result.IsValid() {
 				validated++
 			}
@@ -160,14 +186,20 @@ func (s *schemaPropsValidator) Validate(data interface{}) *Result {
 		}
 
 		if validated != len(s.allOfValidators) {
-			mainResult.AddErrors(errors.New(422, "must validate all the schemas (allOf)"))
+			additionalMsg := ""
+			if validated == 0 {
+				additionalMsg = ". None validated"
+			}
+
+			mainResult.AddErrors(mustValidateAllSchemasMsg(s.Path, additionalMsg))
 		}
 	}
 
 	if s.notValidator != nil {
 		result := s.notValidator.Validate(data)
+		// We keep inner IMPORTANT! errors no matter what MatchCount tells us
 		if result.IsValid() {
-			mainResult.AddErrors(errors.New(422, "must not validate the schema (not)"))
+			mainResult.AddErrors(mustNotValidatechemaMsg(s.Path))
 		}
 	}
 
@@ -184,7 +216,7 @@ func (s *schemaPropsValidator) Validate(data interface{}) *Result {
 				if len(dep.Property) > 0 {
 					for _, depKey := range dep.Property {
 						if _, ok := val[depKey]; !ok {
-							mainResult.AddErrors(errors.New(422, "has a dependency on %s", depKey))
+							mainResult.AddErrors(hasADependencyMsg(s.Path, depKey))
 						}
 					}
 				}
@@ -193,5 +225,7 @@ func (s *schemaPropsValidator) Validate(data interface{}) *Result {
 	}
 
 	mainResult.Inc()
-	return mainResult
+	// In the end we retain best failures for schema validation
+	// plus, if any, composite errors which may explain special cases (tagged as IMPORTANT!).
+	return mainResult.Merge(keepResultAllOf, keepResultOneOf, keepResultAnyOf)
 }