Skip to content

fix: negative and positive validation annotations uses relevant OAS 3.1 syntax ( #5170) #5171

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
daniel-kmiecik merged 5 commits into from
Jul 8, 2026
+555 −35
Merged

fix: negative and positive validation annotations uses relevant OAS 3.1 syntax ( #5170) #5171

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
cbe1c04
fix: negative and positive validation annotations uses relevant OAS 3…
Mattias-Sehlstedt May 4, 2026
f32e04d
fix: complete OAS 3.1 exclusiveMinimum/Maximum handling for validatio…
ewaostrowska Jun 19, 2026
aa2e9f8
fix: broken and incorrect documentation links
ewaostrowska Jun 19, 2026
6a0fdee
Revert "fix: broken and incorrect documentation links"
ewaostrowska Jun 19, 2026
9b17209
Merge branch 'master' into issue-5170
daniel-kmiecik Jul 8, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
149 changes: 123 additions & 26 deletions modules/swagger-core/src/main/java/io/swagger/v3/core/util/ValidationAnnotationsUtils.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
package io.swagger.v3.core.util;

import io.swagger.v3.oas.models.SpecVersion;
import io.swagger.v3.oas.models.media.Schema;

import javax.validation.constraints.*;
Expand Down Expand Up @@ -132,12 +133,25 @@ public static boolean applySizeConstraint(Schema schema, Size annotation) {
* @return whether the schema has been modified or not
*/
public static boolean applyDecimalMinConstraint(Schema schema, DecimalMin annotation) {
if (isNumberSchema(schema)) {
schema.setMinimum(new BigDecimal(annotation.value()));
if (!isNumberSchema(schema)) {
return false;
}
BigDecimal value = new BigDecimal(annotation.value());
if (schema.getSpecVersion().equals(SpecVersion.V31)) {
if (!annotation.inclusive()) {
schema.setExclusiveMinimumValue(value);
BigDecimal minimum = schema.getMinimum();
if (minimum != null && minimum.compareTo(value) <= 0) {
schema.setMinimum(null);
}
} else {
schema.setMinimum(value);
}
} else {
schema.setMinimum(value);
schema.setExclusiveMinimum(!annotation.inclusive());
return true;
}
return false;
return true;
}

/**
Expand All @@ -146,12 +160,25 @@ public static boolean applyDecimalMinConstraint(Schema schema, DecimalMin annota
* @return whether the schema has been modified or not
*/
public static boolean applyDecimalMaxConstraint(Schema schema, DecimalMax annotation) {
if (isNumberSchema(schema)) {
schema.setMaximum(new BigDecimal(annotation.value()));
if (!isNumberSchema(schema)) {
return false;
}
BigDecimal value = new BigDecimal(annotation.value());
if (schema.getSpecVersion().equals(SpecVersion.V31)) {
if (!annotation.inclusive()) {
schema.setExclusiveMaximumValue(value);
BigDecimal maximum = schema.getMaximum();
if (maximum != null && maximum.compareTo(value) >= 0) {
schema.setMaximum(null);
}
} else {
schema.setMaximum(value);
}
} else {
schema.setMaximum(value);
schema.setExclusiveMaximum(!annotation.inclusive());
return true;
}
return false;
return true;
}

/**
Expand Down Expand Up @@ -189,17 +216,48 @@ public static boolean applyEmailConstraint(Schema schema, Email annotation) {
}

public static boolean applyPositiveConstraint(Schema schema) {
if (isNumberSchema(schema)) {
BigDecimal current = schema.getMinimum();
if (current == null || current.compareTo(BigDecimal.ZERO) < 0) {
schema.setMinimum(BigDecimal.ZERO);
schema.setExclusiveMinimum(true);
} else if (current.compareTo(BigDecimal.ZERO) == 0 && !Boolean.TRUE.equals(schema.getExclusiveMinimum())) {
schema.setExclusiveMinimum(true);
if (!isNumberSchema(schema)) {
return false;
}
if (schema.getSpecVersion().equals(SpecVersion.V30)) {
return applyPositiveConstraintV30(schema);
}
return applyPositiveConstraintV31(schema);
}

private static boolean applyPositiveConstraintV30(Schema schema) {
BigDecimal minimum = schema.getMinimum();
if (currentMinimumOutsidePositiveRange(minimum)) {
schema.setMinimum(BigDecimal.ZERO);
schema.setExclusiveMinimum(true);
} else if (minimum.compareTo(BigDecimal.ZERO) == 0 && !Boolean.TRUE.equals(schema.getExclusiveMinimum())) {
schema.setExclusiveMinimum(true);
}
return true;
}

private static boolean applyPositiveConstraintV31(Schema schema) {
BigDecimal exclusiveMinimum = schema.getExclusiveMinimumValue();
if (exclusiveMinimum != null) {
if (exclusiveMinimum.compareTo(BigDecimal.ZERO) < 0) {
BigDecimal minimum = schema.getMinimum();
if (minimum != null && minimum.compareTo(BigDecimal.ZERO) > 0) {
schema.setExclusiveMinimumValue(null);
} else {
schema.setMinimum(null);
schema.setExclusiveMinimumValue(BigDecimal.ZERO);
}
return true;
}
return true;
return false;
}
return false;
BigDecimal minimum = schema.getMinimum();
if (minimum != null && minimum.compareTo(BigDecimal.ZERO) > 0) {
return false;
}
schema.setMinimum(null);
schema.setExclusiveMinimumValue(BigDecimal.ZERO);
return true;
}

public static boolean applyPositiveOrZeroConstraint(Schema schema) {
Expand All @@ -214,17 +272,48 @@ public static boolean applyPositiveOrZeroConstraint(Schema schema) {
}

public static boolean applyNegativeConstraint(Schema schema) {
if (isNumberSchema(schema)) {
BigDecimal current = schema.getMaximum();
if (current == null || current.compareTo(BigDecimal.ZERO) > 0) {
schema.setMaximum(BigDecimal.ZERO);
schema.setExclusiveMaximum(true);
} else if (current.compareTo(BigDecimal.ZERO) == 0 && !Boolean.TRUE.equals(schema.getExclusiveMaximum())) {
schema.setExclusiveMaximum(true);
if (!isNumberSchema(schema)) {
return false;
}
if (schema.getSpecVersion().equals(SpecVersion.V30)) {
return applyNegativeConstraintV30(schema);
}
return applyNegativeConstraintV31(schema);
}

private static boolean applyNegativeConstraintV30(Schema schema) {
BigDecimal maximum = schema.getMaximum();
if (currentMaximumOutsideNegativeRange(maximum)) {
schema.setMaximum(BigDecimal.ZERO);
schema.setExclusiveMaximum(true);
} else if (maximum.compareTo(BigDecimal.ZERO) == 0 && !Boolean.TRUE.equals(schema.getExclusiveMaximum())) {
schema.setExclusiveMaximum(true);
}
return true;
}

private static boolean applyNegativeConstraintV31(Schema schema) {
BigDecimal exclusiveMaximum = schema.getExclusiveMaximumValue();
if (exclusiveMaximum != null) {
if (exclusiveMaximum.compareTo(BigDecimal.ZERO) > 0) {
BigDecimal maximum = schema.getMaximum();
if (maximum != null && maximum.compareTo(BigDecimal.ZERO) < 0) {
schema.setExclusiveMaximumValue(null);
} else {
schema.setMaximum(null);
schema.setExclusiveMaximumValue(BigDecimal.ZERO);
}
return true;
}
return true;
return false;
}
return false;
BigDecimal maximum = schema.getMaximum();
if (maximum != null && maximum.compareTo(BigDecimal.ZERO) < 0) {
return false;
}
schema.setMaximum(null);
schema.setExclusiveMaximumValue(BigDecimal.ZERO);
return true;
}

/**
Expand Down Expand Up @@ -278,4 +367,12 @@ public static boolean applyNegativeOrZeroConstraint(Schema schema) {
return false;
}

private static boolean currentMinimumOutsidePositiveRange(BigDecimal currentMinimum) {
return currentMinimum == null || currentMinimum.compareTo(BigDecimal.ZERO) < 0;
}

private static boolean currentMaximumOutsideNegativeRange(BigDecimal currentMaximum) {
return currentMaximum == null || currentMaximum.compareTo(BigDecimal.ZERO) > 0;
}

}
96 changes: 89 additions & 7 deletions modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/BeanValidatorTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,12 +2,7 @@

import io.swagger.v3.core.converter.ModelConverters;
import io.swagger.v3.core.oas.models.BeanValidationsModel;
import io.swagger.v3.oas.models.media.ArraySchema;
import io.swagger.v3.oas.models.media.EmailSchema;
import io.swagger.v3.oas.models.media.IntegerSchema;
import io.swagger.v3.oas.models.media.NumberSchema;
import io.swagger.v3.oas.models.media.Schema;
import io.swagger.v3.oas.models.media.StringSchema;
import io.swagger.v3.oas.models.media.*;
import org.testng.annotations.Test;

import java.math.BigDecimal;
Expand All @@ -20,7 +15,7 @@
public class BeanValidatorTest {

@Test(description = "read bean validations")
public void readBeanValidatorTest() {
public void readBeanValidatorOAS30Test() {
final Map<String, Schema> schemas = ModelConverters.getInstance().readAll(BeanValidationsModel.class);
final Schema model = schemas.get("BeanValidationsModel");
final Map<String, Schema> properties = model.getProperties();
Expand Down Expand Up @@ -94,4 +89,91 @@ public void readBeanValidatorTest() {
assertEquals(negativeOrZeroWithMax.getMaximum(), new BigDecimal("-2"));
assertNull(negativeOrZeroWithMax.getExclusiveMaximum());
}

@Test(description = "read bean validations")
public void readBeanValidatorOAS31Test() {
final Map<String, Schema> schemas = ModelConverters.getInstance(true).readAll(BeanValidationsModel.class);
final Schema model = schemas.get("BeanValidationsModel");
final Map<String, Schema> properties = model.getProperties();

assertTrue(model.getRequired().contains("id"));
assertTrue(model.getRequired().contains("username"));

final JsonSchema username = (JsonSchema) properties.get("username");
assertEquals(username.getPattern(), "(?![-._])[-._a-zA-Z0-9]{3,32}");

final JsonSchema age = (JsonSchema) properties.get("age");
assertEquals(age.getMinimum(), new BigDecimal(13.0));
assertEquals(age.getMaximum(), new BigDecimal(99.0));

final JsonSchema password = (JsonSchema) properties.get("password");
assertEquals((int) password.getMinLength(), 6);
assertEquals((int) password.getMaxLength(), 20);

final JsonSchema email = (JsonSchema) properties.get("email");
assertEquals(email.getFormat(), "email");

final JsonSchema minBalance = (JsonSchema) properties.get("minBalance");
assertEquals(minBalance.getExclusiveMinimumValue(), new BigDecimal("0.1"));
assertNull(minBalance.getMinimum());
assertNull(minBalance.getExclusiveMinimum());

final JsonSchema maxBalance = (JsonSchema) properties.get("maxBalance");
assertEquals(maxBalance.getExclusiveMaximumValue(), new BigDecimal("1000000"));
assertNull(maxBalance.getMaximum());
assertNull(maxBalance.getExclusiveMaximum());

final JsonSchema items = (JsonSchema) properties.get("items");
assertEquals((int) items.getMinItems(), 2);
assertEquals((int) items.getMaxItems(), 10);
assertEquals((int) items.getItems().getMinLength(), 3);
assertEquals((int) items.getItems().getMaxLength(), 4);

final JsonSchema optionalValue = (JsonSchema) properties.get("optionalValue");
assertEquals((int) optionalValue.getMinLength(), 1);
assertEquals((int) optionalValue.getMaxLength(), 10);

final JsonSchema positiveAmount = (JsonSchema) properties.get("positiveAmount");
assertEquals(positiveAmount.getExclusiveMinimumValue(), BigDecimal.ZERO);
assertNull(positiveAmount.getMinimum());
assertNull(positiveAmount.getExclusiveMinimum());

final JsonSchema positiveOrZeroAmount = (JsonSchema) properties.get("positiveOrZeroAmount");
assertEquals(positiveOrZeroAmount.getMinimum(), BigDecimal.ZERO);
assertNull(positiveOrZeroAmount.getExclusiveMinimum());

final JsonSchema negativeAmount = (JsonSchema) properties.get("negativeAmount");
assertEquals(negativeAmount.getExclusiveMaximumValue(), BigDecimal.ZERO);
assertNull(negativeAmount.getMaximum());
assertNull(negativeAmount.getExclusiveMaximum());

final JsonSchema negativeOrZeroAmount = (JsonSchema) properties.get("negativeOrZeroAmount");
assertEquals(negativeOrZeroAmount.getMaximum(), BigDecimal.ZERO);
assertNull(negativeOrZeroAmount.getExclusiveMaximum());

final JsonSchema positiveWithMin = (JsonSchema) properties.get("positiveWithMin");
assertEquals(positiveWithMin.getMinimum(), new BigDecimal("5"));
assertNull(positiveWithMin.getExclusiveMinimum());
assertNull(positiveWithMin.getExclusiveMinimumValue());

final JsonSchema positiveWithDecimalMin = (JsonSchema) properties.get("positiveWithDecimalMin");
assertEquals(positiveWithDecimalMin.getExclusiveMinimumValue(), new BigDecimal("5.5"));
assertNull(positiveWithDecimalMin.getMinimum());
assertNull(positiveWithDecimalMin.getExclusiveMinimum());

final JsonSchema positiveOrZeroWithMin = (JsonSchema) properties.get("positiveOrZeroWithMin");
assertEquals(positiveOrZeroWithMin.getMinimum(), new BigDecimal("3"));
assertNull(positiveOrZeroWithMin.getExclusiveMinimum());
assertNull(positiveOrZeroWithMin.getExclusiveMinimumValue());

final JsonSchema negativeWithMax = (JsonSchema) properties.get("negativeWithMax");
assertEquals(negativeWithMax.getMaximum(), new BigDecimal("-3"));
assertNull(negativeWithMax.getExclusiveMaximum());
assertNull(negativeWithMax.getExclusiveMaximumValue());

final JsonSchema negativeOrZeroWithMax = (JsonSchema) properties.get("negativeOrZeroWithMax");
assertEquals(negativeOrZeroWithMax.getMaximum(), new BigDecimal("-2"));
assertNull(negativeOrZeroWithMax.getExclusiveMaximum());
assertNull(negativeOrZeroWithMax.getExclusiveMaximumValue());
}
}
Loading
Loading