@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
@Retention(RUNTIME)
@Repeatable(ConfigurableSize.List.class)
@Constraint(validatedBy = {ConfigurableSizeCharSequenceValidator.class})
public @interface ConfigurableSize {

    String message() default "size is not valid";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

    String minProperty() default "";

    String maxProperty() default "";

    @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER, TYPE_USE })
    @Retention(RUNTIME)
    @Documented
    @interface List {
        ConfigurableSize[] value();
    }

}

public class ConfigurableSizeCharSequenceValidator implements ConstraintValidator<ConfigurableSize, CharSequence> {

    private final PropertyResolver propertyResolver;
    private int min;
    private int max;

    @Autowired
    public ConfigurableSizeCharSequenceValidator(PropertyResolver propertyResolver) {
        this.propertyResolver = propertyResolver;
    }

    @Override
    public void initialize(ConfigurableSize configurableSize) {
        String minProperty = configurableSize.minProperty();
        String maxProperty = configurableSize.maxProperty();
        this.min = "".equals(minProperty) ? 0 :
                propertyResolver.getRequiredProperty(minProperty, Integer.class);
        this.max = "".equals(maxProperty) ? Integer.MAX_VALUE :
                propertyResolver.getRequiredProperty(maxProperty, Integer.class);
        validateParameters();
    }

    private void validateParameters() {
        if (this.min < 0) {
            throw new IllegalArgumentException("The min parameter cannot be negative.");
        } else if (this.max < 0) {
            throw new IllegalArgumentException("The max parameter cannot be negative.");
        } else if (this.max < this.min) {
            throw new IllegalArgumentException("The length cannot be negative.");
        }
    }

    @Override
    public boolean isValid(CharSequence value, ConstraintValidatorContext context) {
        if (value == null) {
            return true;
        } else {
            int length = value.length();
            boolean retVal = length >= this.min && length <= this.max;
            if (!retVal) {
                HibernateConstraintValidatorContext hibernateContext =
                        context.unwrap(HibernateConstraintValidatorContext.class);
                hibernateContext.addMessageParameter("min", this.min)
                        .addMessageParameter("max", this.max);
                hibernateContext.disableDefaultConstraintViolation();
                hibernateContext
                        .buildConstraintViolationWithTemplate("{javax.validation.constraints.Size.message}")
                        .addConstraintViolation();
            }
            return retVal;
        }
    }

}

@Data
@Accessors(chain = true)
@UniqueSsn
public class Employee {

    private Long id;
    @NotNull
    @ConfigurableSize(minProperty = "employee.fullName.size.min", maxProperty = "employee.fullName.size.max")
    private String fullName;
    @NotEmpty
    private String socialSecurityNumber;

}

@SpringBootTest
class MockValidatorDependenciesApplicationTests {

    //lines omitted for brevity
    @Value("${employee.fullName.size.min}")
    private int fullNameMinSize;
    @Value("${employee.fullName.size.max}")
    private int fullNameMaxSize;
    //lines omitted for brevity
    @Test
    void fullNameMinSizeHasExpectedValue() {
        assertEquals(3, fullNameMinSize);
    }

    @Test
    void fullNameMaxSizeHasExpectedValue() {
        assertEquals(128, fullNameMaxSize);
    }

}

class EmployeeServiceValidationTest {
    //lines omitted for brevity
    private final EmployeeValidationService mockEmployeeValidationService = mock(EmployeeValidationService.class);
    private final PropertyResolver mockPropertyResolver = mock(PropertyResolver.class);
    private final List<ConstraintValidator<?, ?>> customConstraintValidators =
            Arrays.asList(
                    new UniqueSsnValidator(mockEmployeeValidationService),
                    new ConfigurableSizeCharSequenceValidator(mockPropertyResolver));
    //lines omitted for brevity

    void setupMocks() {
        //lines omitted for brevity
        fullNameSizeMustBeBetween(3, 128);
    }
    //lines omitted for brevity

    @SuppressWarnings("SameParameterValue")
    private void fullNameSizeMustBeBetween(int min, int max) {
        when(mockPropertyResolver.getRequiredProperty(eq("employee.fullName.size.min"), eq(Integer.class)))
                .thenReturn(min);
        when(mockPropertyResolver.getRequiredProperty(eq("employee.fullName.size.max"), eq(Integer.class)))
                .thenReturn(max);
    }

    @BeforeEach
    void setupTest() {
        resetEmployeeSequence();
        initEmployees();
        setupMocks();
    }
    //lines omitted for brevity
}

class EmployeeServiceValidationTest {
    //lines omitted for brevity
    private final static Employee BAD_EMPLOYEE_FULL_NAME_TOO_SHORT = new Employee();
    private final static Employee BAD_EMPLOYEE_FULL_NAME_TOO_LONG = new Employee();
    //lines omitted for brevity
    private static void initBadEmployeeFullNameTooShort() {
        BAD_EMPLOYEE_FULL_NAME_TOO_SHORT.setId(null).setFullName("Jo").setSocialSecurityNumber(VALID_SSN);
    }

    private static void initBadEmployeeFullNameTooLong() {
        BAD_EMPLOYEE_FULL_NAME_TOO_LONG.setId(null)
                .setFullName("Daenerys Stormborn of the House Targaryen, First of Her Name, the Unburnt, Queen of " +
                        "the Andals and the First Men, Khaleesi of the Great Grass Sea, Breaker of Chains, " +
                        "and Mother of Dragons")
                .setSocialSecurityNumber(VALID_SSN);
    }
    //lines omitted for brevity
    private static void initEmployees() {
        //lines omitted for brevity
        initBadEmployeeFullNameTooShort();
        initBadEmployeeFullNameTooLong();
        //lines omitted for brevity
    }
    //lines omitted for brevity
    @Test
    void givenEmployeeWithFullNameTooShortWhenSaveThenCve() {
        ConstraintViolationException cve = assertThrows(ConstraintViolationException.class,
                () -> validationProxy.save(BAD_EMPLOYEE_FULL_NAME_TOO_SHORT));
        Set<ConstraintViolation<?>> violations = cve.getConstraintViolations();
        assertEquals(1, violations.size());
        assertEquals(ConfigurableSize.class,
                getFirstConstraintViolation(violations).getConstraintDescriptor().getAnnotation().annotationType());
    }

    @Test
    void givenEmployeeWithFullNameTooLongWhenSaveThenCve() {
        ConstraintViolationException cve = assertThrows(ConstraintViolationException.class,
                () -> validationProxy.save(BAD_EMPLOYEE_FULL_NAME_TOO_LONG));
        Set<ConstraintViolation<?>> violations = cve.getConstraintViolations();
        assertEquals(1, violations.size());
        assertEquals(ConfigurableSize.class,
                getFirstConstraintViolation(violations).getConstraintDescriptor().getAnnotation().annotationType());
    }
    //lines omitted for brevity
}