1   package org.springframework.binding.validation.support;
2   
3   import java.text.MessageFormat;
4   import java.util.Locale;
5   
6   import junit.framework.TestCase;
7   
8   import org.hibernate.validator.AssertTrue;
9   import org.hibernate.validator.NotEmpty;
10  import org.hibernate.validator.Range;
11  import org.springframework.binding.form.ValidatingFormModel;
12  import org.springframework.binding.validation.ValidationResults;
13  import org.springframework.context.support.AbstractMessageSource;
14  import org.springframework.context.support.MessageSourceAccessor;
15  import org.springframework.context.support.StaticApplicationContext;
16  import org.springframework.richclient.application.Application;
17  import org.springframework.richclient.application.ApplicationServicesLocator;
18  import org.springframework.richclient.application.config.DefaultApplicationLifecycleAdvisor;
19  import org.springframework.richclient.application.support.DefaultApplicationServices;
20  import org.springframework.richclient.form.FormModelHelper;
21  import org.springframework.rules.Rules;
22  import org.springframework.rules.factory.Constraints;
23  import org.springframework.rules.support.DefaultRulesSource;
24  
25  /**
26   * Testcase for HibernateRulesValidator.
27   *
28   * @author ldo
29   *
30   */
31  public class HibernateValidatorTests extends TestCase {
32      private HibernateRulesValidator hibernateRulesValidator;
33  
34      private ValidatingFormModel model;
35  
36      /**
37       * Initialize test environment
38       */
39      protected void setUp() throws Exception {
40          Application.load(null);
41          StaticApplicationContext applicationContext = new StaticApplicationContext();
42          DefaultApplicationServices applicationServices = new DefaultApplicationServices(applicationContext);
43  
44          DefaultApplicationLifecycleAdvisor advisor = new DefaultApplicationLifecycleAdvisor();
45          Application app = new Application(advisor);
46          advisor.setApplication(app);
47  
48          Application.instance().setApplicationContext(applicationContext);
49          applicationServices.setApplicationContext(applicationContext);
50  
51          ApplicationServicesLocator locator = new ApplicationServicesLocator(applicationServices);
52          ApplicationServicesLocator.load(locator);
53  
54          // create dummy message source that always return an empty string
55          AbstractMessageSource source = new AbstractMessageSource() {
56              @Override
57              protected MessageFormat resolveCode(String s, Locale locale) {
58                  return new MessageFormat("");
59              }
60          };
61          MessageSourceAccessor accessor = new MessageSourceAccessor(source);
62          applicationServices.setMessageSourceAccesor(accessor);
63          applicationServices.setMessageSource(source);
64  
65          applicationContext.refresh();
66  
67          // create formmodel to test on and initialize value models
68          model = FormModelHelper.createFormModel(new ValidatingObject());
69          model.getValueModel("stringValue");
70          model.getValueModel("intValue");
71  
72      }
73  
74      private void setOnlyHibernateValidator()
75      {
76          hibernateRulesValidator = new HibernateRulesValidator(model, ValidatingObject.class);
77          model.setValidator(hibernateRulesValidator);
78          model.setValidating(true);
79      }
80  
81      private void setRulesAndHibernateValidator()
82      {
83          Rules rules = new Rules(ValidatingObject.class);
84          Constraints c = Constraints.instance();
85          rules.add(c.eq("intValue", 8));
86          rules.add(c.eq("stringValue", "valid"));
87          DefaultRulesSource source = new DefaultRulesSource();
88          source.addRules(rules);
89          RulesValidator rulesValidator = new RulesValidator(model, source);
90          hibernateRulesValidator = new HibernateRulesValidator(model, ValidatingObject.class);
91          CompositeRichValidator compositeValidator = new CompositeRichValidator(rulesValidator, hibernateRulesValidator);
92          model.setValidator(compositeValidator);
93          model.setValidating(true);
94      }
95  
96      /**
97       * Test valid object
98       */
99      public void testValid() {
100         setOnlyHibernateValidator();
101         ValidatingObject valid = new ValidatingObject();
102         valid.setStringValue("valid");
103         valid.setIntValue(8);
104         model.setFormObject(valid);
105         assertFalse(model.getValidationResults().getHasErrors());
106         assertTrue(model.getValidationResults().getMessageCount("stringValue") == 0);
107         assertTrue(model.getValidationResults().getMessageCount("intValue") == 0);
108 
109     }
110 
111     /**
112      * Test object with invalid String value (empty string on a NotEmpty property)
113      */
114     public void testInvalidString() {
115         setOnlyHibernateValidator();
116         ValidatingObject invalid = new ValidatingObject();
117         invalid.setStringValue("");
118         invalid.setIntValue(8);
119         model.setFormObject(invalid);
120         assertTrue(model.getValidationResults().getHasErrors());
121         assertTrue(model.getValidationResults().getMessageCount("stringValue") == 1);
122         assertTrue(model.getValidationResults().getMessageCount("intValue") == 0);
123     }
124 
125     /**
126      * Test object with invalid Integer value (value out of range)
127      */
128     public void testInvalidInt() {
129         setOnlyHibernateValidator();
130         ValidatingObject invalid = new ValidatingObject();
131         invalid.setStringValue("valid");
132         invalid.setIntValue(20);
133         model.setFormObject(invalid);
134         assertTrue(model.getValidationResults().getHasErrors());
135         assertTrue(model.getValidationResults().getMessageCount("stringValue") == 0);
136         assertTrue(model.getValidationResults().getMessageCount("intValue") == 1);
137     }
138 
139     public void testInvalidIntAndString() {
140         setOnlyHibernateValidator();
141         ValidatingObject invalid = new ValidatingObject();
142         invalid.setStringValue("");
143         invalid.setIntValue(20);
144         model.setFormObject(invalid);
145         assertTrue(model.getValidationResults().getHasErrors());
146         assertTrue(model.getValidationResults().getMessageCount("stringValue") == 1);
147         assertTrue(model.getValidationResults().getMessageCount("intValue") == 1);
148     }
149 
150     /**
151      * AssertTrue tests are not bound to a property, so they should not be included when
152      * not using explicit rules.
153      */
154     public void testInvalidAssertTrue() {
155         setOnlyHibernateValidator();
156         ValidatingObject invalid = new ValidatingObject();
157         invalid.setStringValue("valid");
158         invalid.setIntValue(12);
159         model.setFormObject(invalid);
160         assertFalse(model.getValidationResults().getHasErrors());
161     }
162 
163 
164     public void testRulesTriggeredNullFormObject()
165     {
166         setRulesAndHibernateValidator();
167         model.setFormObject(null);
168         model.setEnabled(true);
169         assertTrue(model.getValidationResults().getHasErrors());
170     }
171 
172     /**
173      * AssertTrue tests are not bound to a property, but can be coped with by
174      * using rules
175      */
176     public void testRulesAndHibernateValidation()
177     {
178         setRulesAndHibernateValidator();
179         ValidatingObject invalid = new ValidatingObject();
180         invalid.setStringValue("valid");
181         invalid.setIntValue(12);
182         model.setFormObject(invalid);
183         assertTrue(model.getValidationResults().getHasErrors());
184         assertEquals(0, model.getValidationResults().getMessageCount("stringValue"));
185         assertEquals(1, model.getValidationResults().getMessageCount("intValue"));
186     }
187 
188 
189 
190 }