Fixed: Validator doesn't throw UnexpectedTypeException in retry

test-suite/src/test/java/io/micronaut/docs/validation/retry/ValidatedBean.java

@@ -0,0 +1,14 @@
+package io.micronaut.docs.validation.retry;
+
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.docs.validation.retry.validation.ValidInternalId;
+import io.micronaut.docs.validation.retry.validation.ValidatedByFactory;
+
+@Introspected
+public record ValidatedBean(
+    @ValidatedByFactory
+    String value,
+    @ValidInternalId
+    int internalId
+) {
+}

test-suite/src/test/java/io/micronaut/docs/validation/retry/ValidatorTest.java

@@ -0,0 +1,26 @@
+package io.micronaut.docs.validation.retry;
+
+import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
+import jakarta.inject.Inject;
+import jakarta.validation.UnexpectedTypeException;
+import jakarta.validation.Validator;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@MicronautTest(rebuildContext = true, startApplication = false)
+public class ValidatorTest {
+
+    @Inject
+    Validator validator;
+
+    @Test
+    void BUG_REPRODUCTION_CASE_validateValidBean_shouldNotFail() {
+        var bean = new ValidatedBean("foobar", 42);
+
+        assertThrows(UnexpectedTypeException.class, () -> validator.validate(bean));
+        assertThrows(UnexpectedTypeException.class, () -> validator.validate(bean));
+    }
+}

test-suite/src/test/java/io/micronaut/docs/validation/retry/validation/ValidInternalId.java

@@ -0,0 +1,24 @@
+package io.micronaut.docs.validation.retry.validation;
+
+import jakarta.validation.Constraint;
+import jakarta.validation.constraints.Max;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Positive;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Constraint(validatedBy = {})
+@Target({
+    ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.TYPE_USE
+})
+@Retention(RetentionPolicy.RUNTIME)
+@NotNull
+@Positive
+@Max(Integer.MAX_VALUE)
+public @interface ValidInternalId {
+}

test-suite/src/test/java/io/micronaut/docs/validation/retry/validation/ValidatedByFactory.java

@@ -0,0 +1,20 @@
+package io.micronaut.docs.validation.retry.validation;
+
+import jakarta.validation.Constraint;
+import jakarta.validation.constraints.Size;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Constraint(validatedBy = {})
+@Target({
+    ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.TYPE_USE
+})
+@Retention(RetentionPolicy.RUNTIME)
+@Size(max = 32)
+public @interface ValidatedByFactory {
+}

test-suite/src/test/java/io/micronaut/docs/validation/retry/validation/ValidatorFactory.java

@@ -0,0 +1,17 @@
+package io.micronaut.docs.validation.retry.validation;
+
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Introspected;
+import io.micronaut.validation.validator.constraints.ConstraintValidator;
+import jakarta.inject.Singleton;
+
+@Factory
+@Introspected
+public class ValidatorFactory {
+
+    @Singleton
+    ConstraintValidator<ValidatedByFactory, CharSequence> validatedByFactoryValidator() {
+        return (ignored1, ignored2, ignored3) -> true;
+    }
+
+}

validation/src/main/java/io/micronaut/validation/validator/DefaultValidator.java

@@ -1442,7 +1442,7 @@ public boolean isValid(E value, AnnotationValue<Annotation> annotationMetadata,
                 }
                 validator = constraintValidatorRegistry.findConstraintValidator(constraintType, elementArgument.getType()).orElse(null);
             }
-            if (validator == null) {
+            if (validator == null || validator == ConstraintValidator.VALID) {
                 throw new UnexpectedTypeException("Cannot find a constraint validator for constraint: " + constraintType.getName() + " and type: " + elementArgument.getType());
             }
             try {

validation/src/main/java/io/micronaut/validation/validator/constraints/DefaultConstraintValidators.java

@@ -126,45 +126,48 @@ public DefaultConstraintValidators(@Nullable BeanContext beanContext) {
     public <A extends Annotation, T> Optional<ConstraintValidator<A, T>> findConstraintValidator(@NonNull Class<A> constraintType, @NonNull Class<T> targetType) {
         ArgumentUtils.requireNonNull("constraintType", constraintType);
         ArgumentUtils.requireNonNull("targetType", targetType);
-        final ValidatorKey key = new ValidatorKey(constraintType, targetType);
+        final var key = new ValidatorKey(constraintType, targetType);
         targetType = (Class<T>) ReflectionUtils.getWrapperType(targetType);
+
         ConstraintValidator<?, ?> constraintValidator = internalValidators.get(key);
         if (constraintValidator != null) {
             return Optional.of((ConstraintValidator<A, T>) constraintValidator);
+        }
+
+        constraintValidator = validatorCache.get(key);
+        if (constraintValidator != null) {
+            return Optional.of((ConstraintValidator<A, T>) constraintValidator);
+        }
+
+        Optional<ConstraintValidator<A, T>> local = findInternalConstraintValidator(constraintType, targetType);
+        if (local.isPresent()) {
+            validatorCache.put(key, local.get());
+            return local;
+        }
+
+        if (beanContext != null) {
+            Argument<ConstraintValidator<A, T>> argument = (Argument) Argument.of(ConstraintValidator.class);
+            final Qualifier<ConstraintValidator<A, T>> qualifier = Qualifiers.byTypeArguments(
+                    constraintType,
+                    targetType
+            );
+            Optional<ConstraintValidator<A, T>> bean = beanContext.findBean(argument, qualifier);
+            if (bean.isPresent()) {
+                validatorCache.put(key, bean.get());
+                return bean;
+            }
+
         } else {
-            constraintValidator = validatorCache.get(key);
-            if (constraintValidator != null) {
-                return Optional.of((ConstraintValidator<A, T>) constraintValidator);
-            } else {
-                Optional<ConstraintValidator<A, T>> local = findInternalConstraintValidator(constraintType, targetType);
-                if (local.isPresent()) {
-                    validatorCache.put(key, local.get());
-                    return local;
-                } else if (beanContext != null) {
-                    Argument<ConstraintValidator<A, T>> argument = (Argument) Argument.of(ConstraintValidator.class);
-                    final Qualifier<ConstraintValidator<A, T>> qualifier = Qualifiers.byTypeArguments(
-                            constraintType,
-                            targetType
-                    );
-                    Optional<ConstraintValidator<A, T>> bean = beanContext.findBean(argument, qualifier);
-                    if (bean.isEmpty()) {
-                        validatorCache.put(key, ConstraintValidator.VALID);
-                    } else {
-                        ConstraintValidator<A, T> found = bean.get();
-                        validatorCache.put(key, found);
-                        return Optional.of(found);
-                    }
-                } else {
-                    // last chance lookup
-                    final ConstraintValidator<A, T> cv = findLocalConstraintValidator(constraintType, targetType)
-                            .orElse((ConstraintValidator<A, T>) ConstraintValidator.VALID);
-                    validatorCache.put(key, cv);
-                    if (cv != ConstraintValidator.VALID) {
-                        return Optional.of(cv);
-                    }
-                }
+            // last chance lookup
+            Optional<ConstraintValidator<A, T>> cv = findLocalConstraintValidator(constraintType, targetType);
+            if (cv.isPresent()) {
+                validatorCache.put(key, cv.get());
+                return cv;
             }
         }
+
+        validatorCache.put(key, ConstraintValidator.VALID);
+
         return Optional.empty();
     }