From dd9a512dd976f97d999e9fcd7893e89e60dc3fb2 Mon Sep 17 00:00:00 2001 From: Mattias-Sehlstedt <60173714+Mattias-Sehlstedt@users.noreply.github.com> Date: Fri, 17 Jul 2026 12:38:50 +0200 Subject: [PATCH] fix: correct sibling logic when reading type from schema annotation --- .../v3/core/jackson/ModelResolver.java | 2 +- .../v3/core/util/AnnotationsUtils.java | 48 +++-- .../v3/core/converting/Issue5061Test.java | 8 +- .../v3/core/converting/Issue5168Test.java | 4 +- .../SchemaAnnotationSetsTypeTest.java | 192 ++++++++++++++++++ .../v3/core/resolving/Ticket4679Test.java | 27 ++- .../v3/core/resolving/Ticket4800Test.java | 53 +++-- .../v3/core/resolving/v31/model/Address.java | 2 +- .../v31/model/PostalCodeNumberPattern.java | 2 +- .../v31/model/PostalCodePattern.java | 2 +- 10 files changed, 284 insertions(+), 56 deletions(-) create mode 100644 modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/SchemaAnnotationSetsTypeTest.java diff --git a/modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java b/modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java index 675ea0a668..c63f7ecf18 100644 --- a/modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java +++ b/modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java @@ -798,7 +798,7 @@ public Schema resolve(AnnotatedType annotatedType, ModelConverterContext context }); boolean areSiblingsAllowed = AnnotationsUtils.areSiblingsAllowed(resolvedSchemaResolution, openapi31); - aType = AnnotationsUtils.addTypeWhenSiblingsAllowed(aType, ctxSchema, areSiblingsAllowed); + aType = AnnotationsUtils.addTypeWhenSiblingsAllowed(aType, ctxSchema, openapi31, areSiblingsAllowed); property = context.resolve(aType); property = clone(property); Schema ctxProperty = null; diff --git a/modules/swagger-core/src/main/java/io/swagger/v3/core/util/AnnotationsUtils.java b/modules/swagger-core/src/main/java/io/swagger/v3/core/util/AnnotationsUtils.java index 7d758f4f10..2a4caf7820 100644 --- a/modules/swagger-core/src/main/java/io/swagger/v3/core/util/AnnotationsUtils.java +++ b/modules/swagger-core/src/main/java/io/swagger/v3/core/util/AnnotationsUtils.java @@ -61,6 +61,8 @@ public abstract class AnnotationsUtils { private static final Logger LOGGER = LoggerFactory.getLogger(AnnotationsUtils.class); + private static final String NULL_TYPE = "null"; + private static final String STRING_TYPE = "string"; public static final String COMPONENTS_REF = Components.COMPONENTS_SCHEMAS_REF; public static boolean hasSchemaAnnotation(io.swagger.v3.oas.annotations.media.Schema schema) { @@ -992,7 +994,7 @@ public static List parseExamplesArray(io.swagger.v3.oas.annotations.medi // Only parse "null" as null value when nullable=true if (node.isNull() && schema.nullable()) { parsedExamples.add(null); - } else if (schemaObject == null && "string".equals(schema.type())) { + } else if (schemaObject == null && STRING_TYPE.equals(schema.type())) { parsedExamples.add(trimmed); } else if (shouldUseNodeAsExample(node, schemaObject)) { parsedExamples.add(node); @@ -1070,7 +1072,7 @@ public static Schema resolveSchemaFromType(Class schemaImplementation, } if (StringUtils.isBlank(existingSchemaObject.get$ref()) && StringUtils.isBlank(existingSchemaObject.getType())) { // default to string - existingSchemaObject.setType("string"); + existingSchemaObject.setType(STRING_TYPE); } return existingSchemaObject; } @@ -1700,7 +1702,7 @@ public static Type getSchemaType(io.swagger.v3.oas.annotations.media.Schema sche } case "boolean": return Boolean.class; - case "string": + case STRING_TYPE: return String.class; default: if (nullIfNotFound) { @@ -1935,26 +1937,28 @@ public static Optional getSchema(io.swagger.v3.oas.annotations } else { Optional schemaFromAnnotation = AnnotationsUtils.getSchemaFromAnnotation(schemaAnnotation, components, jsonViewAnnotation, openapi31, null, context); if (schemaFromAnnotation.isPresent()) { - if (StringUtils.isBlank(schemaFromAnnotation.get().get$ref()) && StringUtils.isBlank(schemaFromAnnotation.get().getType()) && !(schemaFromAnnotation.get() instanceof ComposedSchema)) { + Schema schema = schemaFromAnnotation.get(); + if (StringUtils.isBlank(schema.get$ref()) && StringUtils.isBlank(schema.getType()) && !(schema instanceof ComposedSchema)) { // default to string - schemaFromAnnotation.get().setType("string"); + schema.setType(STRING_TYPE); } - return Optional.of(schemaFromAnnotation.get()); + return Optional.of(schema); } else { Optional arraySchemaFromAnnotation = AnnotationsUtils.getArraySchema(arrayAnnotation, components, jsonViewAnnotation, openapi31, null, false, context); if (arraySchemaFromAnnotation.isPresent()) { - if (arraySchemaFromAnnotation.get().getItems() != null && StringUtils.isBlank(arraySchemaFromAnnotation.get().getItems().get$ref()) && StringUtils.isBlank(arraySchemaFromAnnotation.get().getItems().getType())) { + Schema schema = arraySchemaFromAnnotation.get(); + Schema schemaItems = schema.getItems(); + if (schemaItems != null && StringUtils.isBlank(schemaItems.get$ref()) && StringUtils.isBlank(schemaItems.getType())) { // default to string - arraySchemaFromAnnotation.get().getItems().setType("string"); + schemaItems.setType(STRING_TYPE); } - return Optional.of(arraySchemaFromAnnotation.get()); + return Optional.of(schema); } } } return Optional.empty(); } - public static void applyTypes(String[] classTypes, String[] methodTypes, Content content, MediaType mediaType) { if (methodTypes != null && methodTypes.length > 0) { for (String value : methodTypes) { @@ -3076,14 +3080,32 @@ public static boolean areSiblingsAllowed(Schema.SchemaResolution resolvedSchemaR return Schema.SchemaResolution.ALL_OF.equals(resolvedSchemaResolution) || Schema.SchemaResolution.ALL_OF_REF.equals(resolvedSchemaResolution) || openapi31; } - public static AnnotatedType addTypeWhenSiblingsAllowed(AnnotatedType aType, io.swagger.v3.oas.annotations.media.Schema ctxSchema, boolean areSiblingsAllowed) { + public static AnnotatedType addTypeWhenSiblingsAllowed(AnnotatedType aType, + io.swagger.v3.oas.annotations.media.Schema ctxSchema, + boolean openapi31, + boolean areSiblingsAllowed) { if (areSiblingsAllowed && ctxSchema != null) { if (!Void.class.equals(ctxSchema.implementation())) { aType.setType(ctxSchema.implementation()); - } else if (StringUtils.isNotBlank(ctxSchema.type())) { - aType.setType(ctxSchema.type().getClass()); + } else if (openapi31) { + if (isOas31SingleTypeIncludingNull(ctxSchema) && Arrays.asList(ctxSchema.types()).contains(STRING_TYPE)) { + aType.setType(String.class); + } + } else if(StringUtils.isNotBlank(ctxSchema.type()) && STRING_TYPE.equals(ctxSchema.type())) { + aType.setType(String.class); } } return aType; } + + /** + * Returns whether the schema annotation defines a single type in {@code types}. + * Two types where one of them is {@code null} is counted as one type to support defining nullability + * @param schema the schema annotation + * @return whether the annotation defines a single type + */ + public static boolean isOas31SingleTypeIncludingNull(io.swagger.v3.oas.annotations.media.Schema schema) { + String[] types = schema.types(); + return types.length == 1 || types.length == 2 && Arrays.asList(types).contains(NULL_TYPE); + } } diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/Issue5061Test.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/Issue5061Test.java index d77781fdd8..b6dbfee1f9 100644 --- a/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/Issue5061Test.java +++ b/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/Issue5061Test.java @@ -142,16 +142,16 @@ public static class ModelWithDifferentCombinationOfNumberFieldsWithExamples { @io.swagger.v3.oas.annotations.media.Schema(example = "5 lacs per annum") String stringFieldType; - @io.swagger.v3.oas.annotations.media.Schema(type = "string", example = "5 lacs per annum") + @io.swagger.v3.oas.annotations.media.Schema(types = {"string"}, example = "5 lacs per annum") String stringFieldTypeWithExplicitStringSchemaType; - @io.swagger.v3.oas.annotations.media.Schema(type = "number", example = "10") + @io.swagger.v3.oas.annotations.media.Schema(types = {"number"}, example = "10") String stringFieldTypeWithExplicitNumberSchemaType; - @io.swagger.v3.oas.annotations.media.Schema(type = "integer", example = "5") + @io.swagger.v3.oas.annotations.media.Schema(types = {"integer"}, example = "5") String stringFieldTypeWithExplicitIntegerSchemaType; - @io.swagger.v3.oas.annotations.media.Schema(type = "string", example = "13.37") + @io.swagger.v3.oas.annotations.media.Schema(types = {"string"}, example = "13.37") BigDecimal bigDecimalFieldTypeWithExplicitStringSchemaType; @io.swagger.v3.oas.annotations.media.Schema(example = "13.37") diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/Issue5168Test.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/Issue5168Test.java index 31e1b5b668..94da2aea91 100644 --- a/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/Issue5168Test.java +++ b/modules/swagger-core/src/test/java/io/swagger/v3/core/converting/Issue5168Test.java @@ -55,10 +55,10 @@ public static class ModelWithDifferentCombinationOfBooleanFieldsWithExamples { @io.swagger.v3.oas.annotations.media.Schema(example = "true") String stringFieldType; - @io.swagger.v3.oas.annotations.media.Schema(type = "boolean", example = "true") + @io.swagger.v3.oas.annotations.media.Schema(types = {"boolean"}, example = "true") String stringFieldTypeWithExplicitBooleanSchemaType; - @io.swagger.v3.oas.annotations.media.Schema(type = "string", example = "true") + @io.swagger.v3.oas.annotations.media.Schema(types = {"string"}, example = "true") boolean booleanFieldTypeWithExplicitStringSchemaType; @io.swagger.v3.oas.annotations.media.Schema(example = "true") diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/SchemaAnnotationSetsTypeTest.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/SchemaAnnotationSetsTypeTest.java new file mode 100644 index 0000000000..c271e58766 --- /dev/null +++ b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/SchemaAnnotationSetsTypeTest.java @@ -0,0 +1,192 @@ +package io.swagger.v3.core.resolving; + +import io.swagger.v3.core.converter.ModelConverters; +import io.swagger.v3.core.matchers.SerializationMatchers; +import io.swagger.v3.oas.models.media.Schema; +import org.testng.annotations.Test; + +import java.math.BigDecimal; +import java.util.Map; + +public class SchemaAnnotationSetsTypeTest { + + @Test(description = "Setting type in @Schema is applied for OAS 3.0") + public void testTypeInSchemaAnnotationIsAppliedForOAS30() { + String expectedYaml = "ClassWithFieldsUsingOAS30Type:\n" + + " type: object\n" + + " properties:\n" + + " inferred:\n" + + " type: number\n" + + " amount:\n" + + " type: boolean\n" + + " count:\n" + + " type: boolean\n" + + " flag:\n" + + " type: integer\n" + + " format: int32\n" + + " unit:\n" + + " type: string\n" + + " enum:\n" + + " - DAY\n" + + " - WEEK\n" + + " - MONTH"; + + Map stringSchemaMap = ModelConverters.getInstance().readAll(ClassWithFieldsUsingOAS30Type.class); + SerializationMatchers.assertEqualsToYaml(stringSchemaMap, expectedYaml); + } + + @Test(description = "Setting types in @Schema is ignored for OAS 3.0") + public void testTypesInSchemaAnnotationIsIgnoredForOAS30() { + String expectedYaml = "ClassWithFieldsUsingOAS31Types:\n" + + " type: object\n" + + " properties:\n" + + " inferred:\n" + + " type: number\n" + + " amount:\n" + + " type: number\n" + + " count:\n" + + " type: integer\n" + + " format: int32\n" + + " flag:\n" + + " type: boolean\n" + + " unit:\n" + + " type: string\n" + + " enum:\n" + + " - DAY\n" + + " - WEEK\n" + + " - MONTH"; + + Map stringSchemaMap = ModelConverters.getInstance().readAll(ClassWithFieldsUsingOAS31Types.class); + SerializationMatchers.assertEqualsToYaml(stringSchemaMap, expectedYaml); + } + + @Test(description = "Setting type in @Schema is ignored for OAS 3.1") + public void testTypeInSchemaAnnotationIsIgnoredForOAS31() { + String expectedYaml = "ClassWithFieldsUsingOAS30Type:\n" + + " type: object\n" + + " properties:\n" + + " inferred:\n" + + " type: number\n" + + " amount:\n" + + " type: number\n" + + " count:\n" + + " type: integer\n" + + " format: int32\n" + + " flag:\n" + + " type: boolean\n" + + " unit:\n" + + " type: string\n" + + " enum:\n" + + " - DAY\n" + + " - WEEK\n" + + " - MONTH"; + + Map stringSchemaMap = ModelConverters.getInstance(true) + .readAll(ClassWithFieldsUsingOAS30Type.class); + SerializationMatchers.assertEqualsToYaml31(stringSchemaMap, expectedYaml); + } + + @Test(description = "Setting types in @Schema is applied for OAS 3.1") + public void testTypesInSchemaAnnotationIsAppliedForOAS31() { + String expectedYaml = "ClassWithFieldsUsingOAS31Types:\n" + + " type: object\n" + + " properties:\n" + + " inferred:\n" + + " type: number\n" + + " amount:\n" + + " type: boolean\n" + + " count:\n" + + " type: boolean\n" + + " format: int32\n" + + " flag:\n" + + " type: integer\n" + + " unit:\n" + + " type: string\n" + + " enum:\n" + + " - DAY\n" + + " - WEEK\n" + + " - MONTH"; + + Map stringSchemaMap = ModelConverters.getInstance(true) + .readAll(ClassWithFieldsUsingOAS31Types.class); + SerializationMatchers.assertEqualsToYaml31(stringSchemaMap, expectedYaml); + } + + @Test(description = "Setting several types in @Schema is applied for OAS 3.1") + public void testSeveralTypesInSchemaAnnotationIsAppliedForOAS31() { + String expectedYaml = "ClassWithFieldsUsingOAS31TypesDefiningSeveralTypes:\n" + + " type: object\n" + + " properties:\n" + + " inferred:\n" + + " type: number\n" + + " amount:\n" + + " type:\n" + + " - boolean\n" + + " - number\n" + + " count:\n" + + " type:\n" + + " - boolean\n" + + " - number\n" + + " format: int32\n" + + " flag:\n" + + " type:\n" + + " - integer\n" + + " - number\n" + + " unit:\n" + + " type: string\n" + + " enum:\n" + + " - DAY\n" + + " - WEEK\n" + + " - MONTH"; + + Map stringSchemaMap = ModelConverters.getInstance(true) + .readAll(ClassWithFieldsUsingOAS31TypesDefiningSeveralTypes.class); + SerializationMatchers.assertEqualsToYaml31(stringSchemaMap, expectedYaml); + } + + private static class ClassWithFieldsUsingOAS30Type { + @io.swagger.v3.oas.annotations.media.Schema + public BigDecimal inferred; + @io.swagger.v3.oas.annotations.media.Schema(type = "boolean") + public BigDecimal amount; + @io.swagger.v3.oas.annotations.media.Schema(type = "boolean") + public Integer count; + @io.swagger.v3.oas.annotations.media.Schema(type = "integer") + public Boolean flag; + @io.swagger.v3.oas.annotations.media.Schema + public Frequency unit; + + enum Frequency { DAY, WEEK, MONTH } + } + + private static class ClassWithFieldsUsingOAS31Types { + @io.swagger.v3.oas.annotations.media.Schema + public BigDecimal inferred; + @io.swagger.v3.oas.annotations.media.Schema(types = {"boolean"}) + public BigDecimal amount; + @io.swagger.v3.oas.annotations.media.Schema(types = {"boolean"}) + public Integer count; + @io.swagger.v3.oas.annotations.media.Schema(types = {"integer"}) + public Boolean flag; + @io.swagger.v3.oas.annotations.media.Schema + public Frequency unit; + + enum Frequency { DAY, WEEK, MONTH } + } + + private static class ClassWithFieldsUsingOAS31TypesDefiningSeveralTypes { + @io.swagger.v3.oas.annotations.media.Schema + public BigDecimal inferred; + @io.swagger.v3.oas.annotations.media.Schema(types = {"boolean", "number"}) + public BigDecimal amount; + @io.swagger.v3.oas.annotations.media.Schema(types = {"boolean", "number"}) + public Integer count; + @io.swagger.v3.oas.annotations.media.Schema(types = {"integer", "number"}) + public Boolean flag; + @io.swagger.v3.oas.annotations.media.Schema + public Frequency unit; + + enum Frequency { DAY, WEEK, MONTH } + } + +} diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/Ticket4679Test.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/Ticket4679Test.java index 8c51838b3a..b9fbd5e33b 100644 --- a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/Ticket4679Test.java +++ b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/Ticket4679Test.java @@ -2,28 +2,27 @@ import io.swagger.v3.core.converter.ModelConverters; import io.swagger.v3.core.matchers.SerializationMatchers; -import io.swagger.v3.core.util.Yaml; -import io.swagger.v3.core.util.Yaml31; import io.swagger.v3.oas.annotations.media.Schema; import org.testng.annotations.Test; import java.util.Map; -public class Ticket4679Test extends SwaggerTestBase{ +public class Ticket4679Test extends SwaggerTestBase { @Test(description = "Custom schema implementation in property overrides type value") - public void testCustomSchemaImplementation() { + public void testCustomSchemaImplementationOAS31() { String expectedYaml = "ModelWithCustomSchemaImplementationInProperty:\n" + - " type: object\n" + - " properties:\n" + - " exampleField:\n" + - " type: integer\n" + - " format: int32\n" + - " secondExampleField:\n" + - " type: string\n"; - - Map stringSchemaMap = ModelConverters.getInstance(true).readAll(ModelWithCustomSchemaImplementationInProperty.class); + " type: object\n" + + " properties:\n" + + " exampleField:\n" + + " type: integer\n" + + " format: int32\n" + + " secondExampleField:\n" + + " type: string\n"; + + Map stringSchemaMap = ModelConverters.getInstance(true) + .readAll(ModelWithCustomSchemaImplementationInProperty.class); SerializationMatchers.assertEqualsToYaml31(stringSchemaMap, expectedYaml); } @@ -32,7 +31,7 @@ static class ModelWithCustomSchemaImplementationInProperty { @Schema(implementation = Integer.class) private String exampleField; - @Schema(type = "string") + @Schema(types = {"string"}) private Integer secondExampleField; public String getExampleField() { diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/Ticket4800Test.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/Ticket4800Test.java index a2475a1318..9c4a66e2d1 100644 --- a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/Ticket4800Test.java +++ b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/Ticket4800Test.java @@ -7,27 +7,31 @@ import java.util.Map; -public class Ticket4800Test extends SwaggerTestBase{ +public class Ticket4800Test extends SwaggerTestBase { @Test(description = "Custom schema implementation in property and enum as ref type value") - public void testCustomSchemaImplementation() { - + public void testCustomSchemaImplementationOAS31() { String expectedYaml = "ModelWithCustomSchemaImplementationInProperty:\n" + - " type: object\n" + - " properties:\n" + - " enumExampleFieldWithImplementationProp:\n" + - " $ref: \"#/components/schemas/MyEnum\"\n" + - " default: \"yes\"\n" + - " description: Prop description\n" + - " secondExampleFieldWithTypeProp:\n" + - " type: string\n" + - "MyEnum:\n" + - " type: string\n" + - " enum:\n" + - " - \"yes\"\n" + - " - \"no\""; - - Map stringSchemaMap = ModelConverters.getInstance(true).readAll(Ticket4800Test.ModelWithCustomSchemaImplementationInProperty.class); + " type: object\n" + + " properties:\n" + + " enumExampleFieldWithImplementationProp:\n" + + " $ref: \"#/components/schemas/MyEnum\"\n" + + " default: \"yes\"\n" + + " description: Prop description\n" + + " secondExampleFieldWithTypeProp:\n" + + " type: string\n" + + " thirdExampleFieldWithTypeProp:\n" + + " type:\n" + + " - string\n" + + " - \"null\"\n" + + "MyEnum:\n" + + " type: string\n" + + " enum:\n" + + " - \"yes\"\n" + + " - \"no\""; + + Map stringSchemaMap = ModelConverters.getInstance(true) + .readAll(ModelWithCustomSchemaImplementationInProperty.class); SerializationMatchers.assertEqualsToYaml31(stringSchemaMap, expectedYaml); } @@ -36,9 +40,12 @@ static class ModelWithCustomSchemaImplementationInProperty { @io.swagger.v3.oas.annotations.media.Schema(implementation = MyEnum.class, description = "Prop description", defaultValue = "yes", enumAsRef = true) private MyEnum enumExampleFieldWithImplementationProp; - @io.swagger.v3.oas.annotations.media.Schema(type = "string", enumAsRef = true) + @io.swagger.v3.oas.annotations.media.Schema(types = {"string"}, enumAsRef = true) private MyEnum2 secondExampleFieldWithTypeProp; + @io.swagger.v3.oas.annotations.media.Schema(types = {"string", "null"}, enumAsRef = true) + private MyEnum2 thirdExampleFieldWithTypeProp; + public MyEnum getEnumExampleFieldWithImplementationProp() { return enumExampleFieldWithImplementationProp; } @@ -55,6 +62,14 @@ public void setSecondExampleFieldWithTypeProp(MyEnum2 secondExampleFieldWithType this.secondExampleFieldWithTypeProp = secondExampleFieldWithTypeProp; } + public MyEnum2 getThirdExampleFieldWithTypeProp() { + return thirdExampleFieldWithTypeProp; + } + + public void setThirdExampleFieldWithTypeProp(MyEnum2 thirdExampleFieldWithTypeProp) { + this.thirdExampleFieldWithTypeProp = thirdExampleFieldWithTypeProp; + } + enum MyEnum { yes, no } diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/Address.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/Address.java index 808daf08c8..cd47030898 100644 --- a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/Address.java +++ b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/Address.java @@ -71,7 +71,7 @@ class AnnotatedCountry { @Schema( _const = "United States", - type = "string" + types = {"string"} ) public Object getCountry() { diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/PostalCodeNumberPattern.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/PostalCodeNumberPattern.java index a3d4ba6848..3f7c363d70 100644 --- a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/PostalCodeNumberPattern.java +++ b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/PostalCodeNumberPattern.java @@ -9,7 +9,7 @@ public class PostalCodeNumberPattern { @Schema( pattern = "[0-9]{5}(-[0-9]{4})?", - type = "string" + types = {"string"} ) public Object getPostalCode() { return postalCode; diff --git a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/PostalCodePattern.java b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/PostalCodePattern.java index e5d0a0ead3..eb342159e0 100644 --- a/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/PostalCodePattern.java +++ b/modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/v31/model/PostalCodePattern.java @@ -8,7 +8,7 @@ public class PostalCodePattern { @Schema( pattern = "[A-Z][0-9][A-Z] [0-9][A-Z][0-9]", - type = "string" + types = {"string"} ) public Object getPostalCode() { return postalCode;