Bug: Bean validation not working on default interface methods

[cdprete]

🐞 Bug report (please don't include this emoji/text, just add your details)

Hello.
It seems like that custom constraints are simply ignored in version 3.5.8 when applied to parameters of interface default methods.
I've the following custom constraint:

@Documented
@Retention(RUNTIME)
@Target({TYPE, RECORD_COMPONENT, PARAMETER, METHOD})
@Constraint(validatedBy = ValidAdjustmentDateValidator.class)
public @interface ValidAdjustmentDate {
    String message() default "Invalid date combination";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

import com.google.type.Date;
import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.DateTimeException;
import java.time.LocalDate;
import java.time.Year;

public class ValidAdjustmentDateValidator implements ConstraintValidator<ValidAdjustmentDate, Date> {
    private static final Logger logger = LoggerFactory.getLogger(ValidAdjustmentDateValidator.class);

    static final int MIN_YEAR = LocalDate.EPOCH.getYear();

    @Override
    public boolean isValid(Date adjustmentDate, ConstraintValidatorContext context) {
        String validationErrorMessage = null;
        int maxYear = getMaxYear();
        if (adjustmentDate.getYear() < MIN_YEAR || adjustmentDate.getYear() > maxYear) {
            validationErrorMessage = "Year must be between %d and %d: year=%d".formatted(MIN_YEAR, maxYear, adjustmentDate.getYear());
        } else {
            try {
                //noinspection ResultOfMethodCallIgnored -> needed just to validate the date itself
                LocalDate.of(adjustmentDate.getYear(), adjustmentDate.getMonth(), adjustmentDate.getDay());
            } catch (DateTimeException e) {
                logger.debug(e.toString(), e);
                validationErrorMessage = "Invalid date combination: year=%d, month=%d, day=%d".formatted(adjustmentDate.getYear(), adjustmentDate.getMonth(), adjustmentDate.getDay());
            }
        }

        if(validationErrorMessage != null) {
            context.disableDefaultConstraintViolation();
            context.buildConstraintViolationWithTemplate(validationErrorMessage).addConstraintViolation();
        }

        return validationErrorMessage == null;
    }

    public static int getMaxYear() {
        return Year.now().plusYears(1).getValue();
    }
}

which is applied on the following Converter interface:

@Validated
@Mapper(config = MappingConfiguration.class, uses = ListingIdentifierToListingConverter.class)
public interface GetAdjustmentsRequestToAdjustmentRequestConverter extends Converter<GetAdjustmentsRequest, AdjustmentRequest> {
    @Valid
    @Override
    @Mapping(source = "listingsList", target = "listings")
    @Mapping(expression = "java(toLocalDate(source.getToDate()))", target = "to")
    @Mapping(expression = "java(toLocalDate(source.getFromDate()))", target = "from")
    AdjustmentRequest convert(GetAdjustmentsRequest source);

    default LocalDate toLocalDate(@ValidAdjustmentDate Date date) {
        return date == null ? null : LocalDate.of(date.getYear(), date.getMonth(), date.getDay());
    }
}

The implementation that gets generated looks, to me, correct:

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    comments = "version: 1.6.3, compiler: javac, environment: Java 25 (Azul Systems, Inc.)"
)
@Component
public class GetAdjustmentsRequestToAdjustmentRequestConverterImpl implements GetAdjustmentsRequestToAdjustmentRequestConverter {

    private final ListingIdentifierToListingConverter listingIdentifierToListingConverter;

    @Autowired
    public GetAdjustmentsRequestToAdjustmentRequestConverterImpl(ListingIdentifierToListingConverter listingIdentifierToListingConverter) {

        this.listingIdentifierToListingConverter = listingIdentifierToListingConverter;
    }

    @Override
    public AdjustmentRequest convert(GetAdjustmentsRequest source) {
        if ( source == null ) {
            return null;
        }

        Set<Listing> listings = null;
        boolean cumulateDailyAdjustments = false;

        listings = listingIdentifierListToListingSet( source.getListingsList() );
        cumulateDailyAdjustments = source.getCumulateDailyAdjustments();

        LocalDate to = toLocalDate(source.getToDate());
        LocalDate from = toLocalDate(source.getFromDate());

        AdjustmentRequest adjustmentRequest = new AdjustmentRequest( listings, from, to, cumulateDailyAdjustments );

        return adjustmentRequest;
    }

    protected Set<Listing> listingIdentifierListToListingSet(List<ListingIdentifier> list) {
        if ( list == null ) {
            return new LinkedHashSet<Listing>();
        }

        Set<Listing> set = LinkedHashSet.newLinkedHashSet( list.size() );
        for ( ListingIdentifier listingIdentifier : list ) {
            set.add( listingIdentifierToListingConverter.convert( listingIdentifier ) );
        }

        return set;
    }
}

For constraints defined on objects themselves like, for example:

import org.hibernate.validator.constraints.Range;

public record Listing(@Range(min = 1, max = MAX_UINT) long valor, @Range(min = 1, max = MAX_USHORT) int marketCode, @Range(min = 1, max = MAX_USHORT) int currencyCode) {
    static final long MAX_UINT = (1L << Integer.SIZE) - 1;
    static final int MAX_USHORT = (1 << Short.SIZE) - 1;
}

the validation is working as expected.
I would be expecting to not be working given that the method is within the same class being proxied, but MethodValidationPostProcessor is there and it should therefore work to my knowledge.

[wilkinsona]

We appreciate bug reports and are more than happy to fix problems but I'm afraid we don't have time to perform diagnosis of broad problems involving multiple different components.

I can see that you're using MapStruct and have some doubt that it's generated the correct code. To narrow down the problem, it should be removed to eliminate one possible cause.

You mentioned that constraints on Objects work and you only have a problem with constraints on an interface's default method. I don't know if Bean Validation requires implementations to support finding constraints on an interface's default methods. You could experiment with a minimal example that focuses on this part to find out.

You mention constraints on Listing as working but say that you expected it not to work. Unfortunately, I can't see any example of Listing being used in the other code you've shared so it doesn't narrow down the problem for us.

Hopefully, it you follow the steps above and generally spend some time minimising the problem you'll either identify a cause that you can fix yourself or you'll have identified the cause in a library that you're using. If the problem's caused by a library that you're using, you should, by this point, have a minimal and focused example that you can share with the maintainers of the project to help them to diagnose and fix the bug.

[cdprete]

Hello @wilkinsona.

Thanks for the reply.
Actually, after further testing, it seems to me that custom constraints are simply ignored.
I tried with the following:

public record AdjustmentRequest(@NotNull @Size(min = 1, max = 1_000) Set<@Valid @NotNull Listing> listings,
                                @ValidAdjustmentDate LocalDate from, @ValidAdjustmentDate LocalDate to,
                                boolean cumulateDailyAdjustments) {
}

simplified the validator like:

public class ValidAdjustmentDateValidator implements ConstraintValidator<ValidAdjustmentDate, LocalDate> {
    static final int MIN_YEAR = LocalDate.EPOCH.getYear();

    @Override
    public boolean isValid(LocalDate adjustmentDate, ConstraintValidatorContext context) {
        String validationErrorMessage = null;
        if(adjustmentDate != null) {
            int maxYear = getMaxYear();
            if (adjustmentDate.getYear() < MIN_YEAR || adjustmentDate.getYear() > maxYear) {
                validationErrorMessage = "Year must be between %d and %d: year=%d".formatted(MIN_YEAR, maxYear, adjustmentDate.getYear());
            }
        }

        if(validationErrorMessage != null) {
            context.disableDefaultConstraintViolation();
            context.buildConstraintViolationWithTemplate(validationErrorMessage).addConstraintViolation();
        }

        return validationErrorMessage == null;
    }

    public static int getMaxYear() {
        return Year.now().plusYears(1).getValue();
    }
}

and I created an object like the following:

which should, per validation, fail given that the year > max-year, but it doesn't.
Nor when the converter returns the object nor with the manual validation I've then by using the Validator object.
Also in the debug mode, the custom validator code doesn't get called at all.

Has something maybe changed in the way custom validators should be registered?

[wilkinsona]

Has something maybe changed in the way custom validators should be registered?

That's a Hibernate Validator question. FWIW, I'm not aware of any changes but that doesn't mean there have not been any.

[cdprete]

I sorted it out.

It seems like that, for Records, FIELD as a Target value is necessary as well in the annotation.
Without it, the annotation is simply ignored.
I was expecting RECORD_COMPONENT to be enough, but it doesn't seem so.

@wilkinsona may AOT, since I've it enabled, play some role in all this which may explain this behavior?
I don't know, maybe in the way the proxies are generated...

[wilkinsona]

may AOT, since I've it enabled, play some role in all this which may explain this behavior?

I don't think so, no. You don't need to ask and wait for an answer though. Instead, disable AOT and see for yourself whether or not the behavior changes.