Good patterns for unit testing form beans that have annotation-based validation in Spring MVC

问题

When using annotation based validation for a form bean, what is the best practice for unit-testing those beans in order to ensure that correct validations annotations are specified for each field?

For example, if you have:

public class MyForm {
    @NotNull
    private String name;
}

What is the best way to verify that @NotNull is applied to it?

One obvious way is to create a validator, throw a null at it and expect it to fail. But in my view this is not the best way as you'll be testing the behaviour and implementation of @NotNull using that rather than trusting the framework.

Ideally I would want to use reflection or a utility that gives me the possibility of just asserting that an @NotNull (and any other) validation is applied to a given field, rather than having to send various combination of values that fail validation.

Is there an elegant way of doing this, or am I on the right track in general?

回答1:

You can also write unit tests for your Beans which are annotated usin JSR303 using validator factory. See example: http://musingsofaprogrammingaddict.blogspot.com/2009/02/using-bean-validation-with-spring.html

回答2:

Two things you should consider:

Do Not test your third party libraries/frameworks.

You should rely on them, they are supposed to be already tested by their maintainers and the surrounding community usage. You don't test them, you rather assess them. To make sure that they fit your needs and mitigate the risks.

Testing behavior is what matter, really!

In the vast majority of applications there is little place for real UNIT testing as the business logic is either small are widespread across multiple modules of the application. So you should consider Integration testing with the same priority than Unit testing. And this is more easily captured by using a behavioral approach.

So, to answer your question, you should not try to Unit test a form bean at all. It's just a transport object. What you should test is how the receiver react with that form, and check both the normal case and the edge cases.

回答3:

You can test it easily.

Let's say you are using Hibernate Validator. More or less, it should be something like this

    import javax.validation.ConstraintViolation;
    import junit.framework.Assert;
    import org.hibernate.validator.HibernateValidator;
    import org.junit.Before;
    import org.junit.Test;
    import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;

 private LocalValidatorFactoryBean localValidatorFactory;


@Before
public void setup() {
    localValidatorFactory = new LocalValidatorFactoryBean();
    localValidatorFactory.setProviderClass(HibernateValidator.class);
    localValidatorFactory.afterPropertiesSet();
}

  @Test
  public void testNullValidationError() {
        final MyForm myForm= new MyForm ();
        myForm.setName(null);
        Set<ConstraintViolation<MyForm >> constraintViolations =      localValidatorFactory.validate(myForm);
        Assert.assertTrue("Your error message", constraintViolations.notNull == null);
    }

回答4:

We test the annotations at bean properties as part of integration testing between our presentation layer and spring container.

What we do is create fake MockPortletContext, DispatcherPortlet and MockRequests (these classes are part of spring-test library), fill the requests so they look like real form was submited and then call the dispatcherPortlet. (we have portlet environment but it doesnt matter)

Then you can check that your backend was called approprietly or that the response contains binding result with expected validation errors which is what you need..

来源：https://stackoverflow.com/questions/9516079/good-patterns-for-unit-testing-form-beans-that-have-annotation-based-validation

标签

java

unit-testing

spring-mvc

annotations

bean-validation