Question

I got following test case below and have a question to it. Why does the validation of a nested property without the groups parameter always fail? How can I achieve a validation of the nested properties without groups?

Thx in advance

Kind regards

Christian

My Test case:

    package validation;
    import java.util.Set;
    import javax.validation.*;
    import javax.validation.constraints.*;
    import junit.framework.Assert;
    import lombok.Data;
    import lombok.extern.slf4j.Slf4j;
    import org.junit.*;

    @Slf4j
    public class NestedPropertiesTest {

        private ValidatorFactory factory;
        private Validator validator;

        @Before
        public void setUp() throws Exception {
            log.info("\n\nTest start:");
            this.factory = Validation.buildDefaultValidatorFactory();
            this.validator = factory.getValidator();
        }

        @Test
        public void testNestedBarNullValue() {
            Foo foo = new Foo();
            Bar bar = new Bar();
            bar.setNotempty(null);
            foo.setBar(bar);
            log.info("With groups:");
            Set<ConstraintViolation<Foo>> errors = validator.validateProperty(foo, "bar.notempty", Checks.class);
            logErrors(errors);
            Assert.assertFalse(errors.isEmpty());
            log.info("Without groups:");
            errors = validator.validateProperty(foo, "bar.notempty");
            logErrors(errors);
            Assert.assertFalse(errors.isEmpty());
        }

        @Test
        public void testNestedBarMinSize() {
            Foo foo = new Foo();
            Bar bar = new Bar();
            bar.setNotempty("1");
            foo.setBar(bar);
            log.info("With groups:");
            Set<ConstraintViolation<Foo>> errors = validator.validateProperty(foo, "bar.notempty", Checks.class);
            logErrors(errors);
            Assert.assertFalse(errors.isEmpty());
            log.info("Without groups:");
            errors = validator.validateProperty(foo, "bar.notempty");
            logErrors(errors);
            Assert.assertFalse(errors.isEmpty());
        }

        @SuppressWarnings("rawtypes")
        private void logErrors(Set errors) {
            log.info("Nr. of validation errors: {}", errors.size());
            for (Object error : errors) {
                ConstraintViolation cv = (ConstraintViolation) error;  
                log.info("{}: {}", cv.getPropertyPath(), cv.getMessage());
            }
        }

        @Data private class Foo {
            @Valid private Bar bar;
        }
        @Data private class Bar {
            @NotNull(groups=Checks.class)
            @Size(min = 2, groups=Checks.class)
            private String notempty;
        }
        private interface Checks {}
    }

My pom (just in case):

    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>noorg</groupId>
        <artifactId>validation</artifactId>
        <version>0.0.1-SNAPSHOT</version>

        <dependencies>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-validator</artifactId>
                <version>4.2.0.Final</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.10</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>0.11.0</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-simple</artifactId>
                <version>1.6.4</version>
            </dependency>
        </dependencies>
    </project>

Answer 1

Once you specify a group, your constraint is no longer implicitly part of the default group. If you want your annotation to also still be in the default group, then you need to specify it.

    @Data private class Bar {
        @NotNull(groups={Checks.class, javax.validation.groups.Default.class})
        @Size(min = 2, groups={Checks.class, javax.validation.groups.Default.class})
        private String notempty;
    }