expanded logic to support collection reference type items validation as well

Author: lpandzic

modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java

@@ -86,6 +86,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.Objects;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -695,8 +696,8 @@ public Schema resolve(AnnotatedType annotatedType, ModelConverterContext context
                         addRequiredItem(model, property.getName());
                     }
                     final boolean applyNotNullAnnotations = io.swagger.v3.oas.annotations.media.Schema.RequiredMode.AUTO.equals(requiredMode);
-                    annotations = addGenericTypeAnnotations(propDef, annotations);
-                    applyBeanValidatorAnnotations(property, annotations, model, applyNotNullAnnotations);
+                    annotations = addGenericTypeArgumentAnnotationsForOptionalField(propDef, annotations);
+                    applyBeanValidatorAnnotations(propDef, property, annotations, model, applyNotNullAnnotations);
 
                     props.add(property);
                 }
@@ -898,22 +899,38 @@ public Schema resolve(AnnotatedType annotatedType, ModelConverterContext context
         return model;
     }
 
-    private Annotation[] addGenericTypeAnnotations(BeanPropertyDefinition propDef, Annotation[] annotations) {
-        AnnotatedField field = propDef.getField();
-        if (!field.getType().getRawClass().equals(Optional.class)) {
-            return annotations;
-        }
+    private Annotation[] addGenericTypeArgumentAnnotationsForOptionalField(BeanPropertyDefinition propDef, Annotation[] annotations) {
+
+        boolean isNotOptionalType = Optional.ofNullable(propDef)
+                                            .map(BeanPropertyDefinition::getField)
+                                            .map(AnnotatedField::getAnnotated)
+                                            .map(field -> !(field.getType().equals(Optional.class)))
+                                            .orElse(false);
 
-        java.lang.reflect.AnnotatedType annotatedType = field.getAnnotated().getAnnotatedType();
-        if (!(annotatedType instanceof AnnotatedParameterizedType)) {
+        if (isNotOptionalType) {
             return annotations;
         }
 
-        AnnotatedParameterizedType parameterizedType = (AnnotatedParameterizedType) annotatedType;
+        Stream<Annotation> genericTypeArgumentAnnotations = extractGenericTypeArgumentAnnotations(propDef);
+        return Stream.concat(Stream.of(annotations), genericTypeArgumentAnnotations).toArray(Annotation[]::new);
+    }
+
+    private Stream<Annotation> extractGenericTypeArgumentAnnotations(BeanPropertyDefinition propDef) {
+        return Optional.ofNullable(propDef)
+                       .map(BeanPropertyDefinition::getField)
+                       .map(AnnotatedField::getAnnotated)
+                       .map(this::getGenericTypeArgumentAnnotations)
+                       .orElseGet(Stream::of);
+    }
 
-        Stream<Annotation> genericTypeAnnotations = Stream.of(parameterizedType.getAnnotatedActualTypeArguments())
-                                                          .flatMap(type -> Stream.of(type.getAnnotations()));
-        return Stream.concat(Stream.of(annotations), genericTypeAnnotations).toArray(Annotation[]::new);
+    private Stream<Annotation> getGenericTypeArgumentAnnotations(Field field) {
+        return Optional.of(field.getAnnotatedType())
+                       .filter(annotatedType -> annotatedType instanceof AnnotatedParameterizedType)
+                       .map(annotatedType -> (AnnotatedParameterizedType) annotatedType)
+                       .map(AnnotatedParameterizedType::getAnnotatedActualTypeArguments)
+                       .map(types -> Stream.of(types)
+                                           .flatMap(type -> Stream.of(type.getAnnotations())))
+                       .orElseGet(Stream::of);
     }
 
     private boolean shouldResolveEnumAsRef(io.swagger.v3.oas.annotations.media.Schema resolvedSchemaAnnotation) {
@@ -1309,6 +1326,15 @@ private AnnotatedType removeJsonIdentityAnnotations(AnnotatedType type) {
         }
     }
 
+    protected void applyBeanValidatorAnnotations(BeanPropertyDefinition propDef, Schema property, Annotation[] annotations, Schema parent, boolean applyNotNullAnnotations) {
+        applyBeanValidatorAnnotations(property, annotations, parent, applyNotNullAnnotations);
+
+        if (Objects.nonNull(property.getItems())) {
+            Annotation[] genericTypeArgumentAnnotations = extractGenericTypeArgumentAnnotations(propDef).toArray(Annotation[]::new);
+            applyBeanValidatorAnnotations(property.getItems(), genericTypeArgumentAnnotations, property, applyNotNullAnnotations);
+        }
+    }
+
     protected void applyBeanValidatorAnnotations(Schema property, Annotation[] annotations, Schema parent, boolean applyNotNullAnnotations) {
         Map<String, Annotation> annos = new HashMap<>();
         if (annotations != null) {

modules/swagger-core/src/test/java/io/swagger/v3/core/oas/models/BeanValidationsModel.java

@@ -37,7 +37,7 @@ public class BeanValidationsModel {
     protected Integer birthYear;
 
     @Size(min = 2, max = 10)
-    private List<String> items;
+    private List<@Size(min = 3, max = 4) String> items;
 
     private Optional<@Size(min= 1, max=10) String> optionalValue;
 

modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/BeanValidatorTest.java

@@ -43,6 +43,8 @@ public void readBeanValidatorTest() {
         final ArraySchema items = (ArraySchema) properties.get("items");
         Assert.assertEquals((int) items.getMinItems(), 2);
         Assert.assertEquals((int) items.getMaxItems(), 10);
+        Assert.assertEquals((int) items.getItems().getMinLength(), 3);
+        Assert.assertEquals((int) items.getItems().getMaxLength(), 4);
 
         final StringSchema optionalValue = (StringSchema) properties.get("optionalValue");
         Assert.assertEquals((int) optionalValue.getMinLength(), 1);