Hello,
I'm using a @GroupSequence at the class level to replace the Default group and force validation to be in a specific order. I'd like to set a debug flag to get logged output indicating the order the validation occurred -- this output could also indicate if I'm unintentionally validating something more than once. Is this already possible?

Let's assume you have:



Then set up a Foo instance in a way you expect it to violate constraints of all three groups. Validate it and only the violation(s) of Group1 should be returned. Update the model so it satisfies the Group1 constraints, validate again and you should only see the Group2 constraints being violated. And so on.

Hth,

--Gunnar

Although using the @GroupSequence Annotation will validate in a specific order, how can I write tests that the validation did occur in a specific order? ... or write tests that something wasn't validated twice? I'd like to add a listener into Java Bean Validator such that when a bean is about to be validated, my listener will be notified so my tests can verify the order of validation and that the object wasn't validated twice.

// below is conceptually the idea that a functional or unit test framework can verify that the Car object below is behaving as expected.
class MyValidationListener implements ValidationListener
{
ValidatedTwiceDetector vtd = new ValidatedTwiceDetector();
OrderOfValidationChecker oovc = new OrderOfValidationChecker();
public void validatedObject(ConstraintAnnotation ca, Object ob)
{
vtd.check(ca, ob);
oovc.check(ca, ob);
}
}

ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Validator validator = factory.getValidator();
validator.addValidationListener(new MyValidationListener());

Car car = Car.createInstance();
Set<ConstraintViolation<Car>> constraintViolations = validator.validate(car);
...
It would be nice to have my listener receive events notifying what constraints were applied to the validator -- and get their respective order as well as be able to detect if something was validated twice unintentionally.

James

Hi,

The order of validation is testable in the way I described.



You would assert on the violations returned by the validator. By that you know that the constraints of Group1 are validated first, otherwise you'd see violations of the Group2 or Group3 constraints.



Again you would assert on the violations returned by the validator. Now you see that the constraints of Group1 are validated before Group2 and Group2 before Group3 (otherwise you'd have seen constraints of Group2 in the first validation and now would see Group3 constraints).

As far as asserting that no constraint is validated twice is concerned, you could add listeners to your model for revealing the order of invocation of their getters (assuming you use getter-level constraints and not field level constraints), which gives an indication of the order of validated constraints. An alternative would be to use something like AspectJ to expose the invocation order (then even including field access) without altering your actual model. Not sure though whether that all is worth the effort really.

Hth,

--Gunnar