1   /*
2    * Copyright 2002-2004 the original author or authors.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5    * use this file except in compliance with the License. You may obtain a copy of
6    * the License at
7    * 
8    * http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13   * License for the specific language governing permissions and limitations under
14   * the License.
15   */
16  package org.springframework.richclient.form;
17  
18  import javax.swing.JComponent;
19  import javax.swing.JRootPane;
20  import javax.swing.JTextField;
21  
22  import org.springframework.binding.form.ValidatingFormModel;
23  import org.springframework.richclient.application.support.DefaultApplicationServices;
24  import org.springframework.richclient.core.Guarded;
25  import org.springframework.richclient.test.SpringRichTestCase;
26  import org.springframework.rules.Rules;
27  import org.springframework.rules.support.DefaultRulesSource;
28  
29  /**
30   * @author Peter De Bruycker
31   */
32  public class FormGuardTests extends SpringRichTestCase {
33  
34      private ValidatingFormModel formModel;
35  
36      private TestGuarded guarded;
37  
38      private static class TestGuarded implements Guarded {
39  
40          private boolean enabled = true; // initially enabled
41  
42          public boolean isEnabled() {
43              return enabled;
44          }
45  
46          public void setEnabled(boolean enabled) {
47              this.enabled = enabled;
48          }
49      }
50  
51      private static class TestBean {
52          private String field;
53          private String field2;
54  
55          public String getField() {
56              return field;
57          }
58  
59          public String getField2() {
60              return field2;
61          }
62  
63          public void setField(String string) {
64              field = string;
65          }
66  
67          public void setField2(String string) {
68              field2 = string;
69          }
70      }
71      
72      private static class TestForm extends AbstractForm {
73          TestForm() {
74              this(new TestBean());
75          }
76          TestForm(TestBean bean) {
77              this(FormModelHelper.createFormModel(bean));
78          }
79          TestForm(ValidatingFormModel formModel) {
80              super(formModel, "testform");
81          }
82          protected JComponent createFormControl()
83          {
84              JTextField textControl = (JTextField)getBindingFactory().createBinding("field").getControl();
85              
86              // provide a rootpane for the form's control.
87              JRootPane rootPane= new JRootPane();
88              rootPane.add(textControl);
89              
90              return textControl;
91          }
92          
93          protected String getRevertCommandFaceDescriptorId()
94          {
95              return "revert";
96          }
97          
98          protected String getCommitCommandFaceDescriptorId()
99          {
100             return "commit";
101         }
102         
103     }
104 
105     protected void doSetUp() {
106         guarded = new TestGuarded();
107         TestBean bean = new TestBean();
108         bean.setField("ok"); // initialize rule to be valid.
109         formModel = FormModelHelper.createFormModel(bean);
110         formModel.setEnabled(true);
111     }
112 
113     /**
114      * May be implemented in subclasses that need to register services with the global
115      * application services instance.
116      */
117     protected void registerAdditionalServices( DefaultApplicationServices applicationServices ) {
118         DefaultRulesSource rulesSource = new DefaultRulesSource();
119         Rules rules = new Rules(TestBean.class);
120         rules.add("field", rules.required());
121         rulesSource.addRules(rules);
122 
123         applicationServices.setRulesSource(rulesSource);
124     }
125 
126     public void testEnabledState() {
127         new FormGuard(formModel, guarded);
128         assertTrue("guarded should still be enabled", guarded.isEnabled());
129 
130         formModel.setEnabled(false);
131         assertFalse("guarded should be disabled", guarded.isEnabled());
132 
133         formModel.setEnabled(true);
134         assertTrue("guarded should be enabled", guarded.isEnabled());
135     }
136 
137     public void testErrorState() {        
138         new FormGuard(formModel, guarded);
139         assertTrue("guarded should still be enabled", guarded.isEnabled());
140 
141         formModel.getValueModel("field").setValue(null);
142         assertTrue(formModel.getValidationResults().getHasErrors());
143         assertFalse("guarded should be disabled", guarded.isEnabled());
144 
145         formModel.getValueModel("field").setValue("test");
146         assertFalse(formModel.getValidationResults().getHasErrors());
147         assertTrue("guarded should be enabled", guarded.isEnabled());
148     }
149     
150     
151     // Tests added based on requirements in RCP-39
152     // The form's action commands should get enabled/disabled based on the form's state
153     
154     public void testNewFormCommandGuarding() {
155         TestForm form = new TestForm(formModel);
156         form.attachFormGuard(guarded, FormGuard.LIKE_NEWFORMOBJCOMMAND);
157         Guarded nfCmd = form.getNewFormObjectCommand();
158         
159         //default enabled
160         assertTrue("guarded like newForm should be initially enabled", guarded.isEnabled());
161         assertTrue("newForm should be initially enabled", nfCmd.isEnabled());
162         
163         // disable form --> disabled
164         form.setEnabled(false);
165         assertFalse("guarded like newform should be disabled with form", guarded.isEnabled());
166         assertFalse("newform should be disabled with form", nfCmd.isEnabled());
167         
168         // enable form --> enabled
169         form.setEnabled(true);
170         assertTrue("guarded like newForm should be initially enabled", guarded.isEnabled());
171         assertTrue("newForm should be initially enabled", nfCmd.isEnabled());
172         
173         // trigger validation-error --> still enabled
174         ((JTextField)form.getControl()).setText(null);
175         assertTrue(formModel.getValidationResults().getHasErrors());
176         assertTrue("guarded like newForm should be initially enabled", guarded.isEnabled());
177         assertTrue("newForm should be initially enabled", nfCmd.isEnabled());
178     }
179     
180     public void testRevertCommandGuarding() {
181         TestForm form = new TestForm(formModel);
182         form.attachFormGuard( guarded, FormGuard.LIKE_REVERTCOMMAND);
183         Guarded rvtCmd = form.getRevertCommand();
184         
185         // initially --> disabled
186         assertFalse("guarded like revert should be initially disabled", guarded.isEnabled());
187         assertFalse("revert should be initially disabled", rvtCmd.isEnabled());
188 
189         // create dirt with errors --> enabled
190         ((JTextField)form.getControl()).setText(null);
191         assertTrue(formModel.getValidationResults().getHasErrors());
192         assertTrue(formModel.isDirty());
193         assertTrue("guarded like revert should be enabled when there are changes", guarded.isEnabled());
194         assertTrue("revert should be enabled when there are changes", rvtCmd.isEnabled());
195         
196         // relieve errors --> enabled
197         ((JTextField)form.getControl()).setText("nok");
198         assertFalse(formModel.getValidationResults().getHasErrors());
199         assertTrue(formModel.isDirty());
200         assertTrue("guarded like revert should be enabled when there are changes", guarded.isEnabled());
201         assertTrue("revert should be enabled when there are changes", rvtCmd.isEnabled());
202         
203         // disable form --> disabled
204         form.setEnabled(false);
205         assertFalse("guarded like revert should be disabled with form", guarded.isEnabled());
206         assertFalse("revert should be disabled with form", rvtCmd.isEnabled());
207         
208         // enable form --> enabled
209         form.setEnabled(true);
210         assertTrue("guarded like revert should be enabled with form", guarded.isEnabled());
211         assertTrue("revert should be enabled with form", rvtCmd.isEnabled());
212         
213         // revert --> disabled
214         form.revert();
215         assertFalse("guarded like revert should be disabled when no changes left", guarded.isEnabled());
216         assertFalse("revert should be disabled when no changes left", rvtCmd.isEnabled());
217     }
218 
219     public void testCommitCommandGuarding() {
220         TestForm form = new TestForm(formModel);
221         new FormGuard(formModel, guarded, FormGuard.LIKE_COMMITCOMMAND);
222         Guarded cmtCmd = form.getCommitCommand();
223         
224         // initially --> disabled
225         assertFalse("guarded like commit should be initially disabled", guarded.isEnabled());
226         assertFalse("commit should be initially disabled", cmtCmd.isEnabled());
227 
228         // create dirt with errors --> disabled
229         ((JTextField)form.getControl()).setText(null);
230         assertTrue(formModel.getValidationResults().getHasErrors());
231         assertTrue(formModel.isDirty());
232         assertFalse("guarded like commit should be disabled when model has validation-errors", guarded.isEnabled());
233         assertFalse("commit should be disabled when model has validation-errors", cmtCmd.isEnabled());
234         
235         // relieve errors --> enabled
236         ((JTextField)form.getControl()).setText("nok");
237         assertFalse(formModel.getValidationResults().getHasErrors());
238         assertTrue(formModel.isDirty());
239         assertTrue("guarded like commit should be enabled if there are errors", guarded.isEnabled());
240         assertTrue("commit should be enabled if there are errors", cmtCmd.isEnabled());
241         
242         // disable form --> disabled
243         form.setEnabled(false);
244         assertFalse("guarded like commit should be disabled with form", guarded.isEnabled());
245         assertFalse("commit should be disabled with form", cmtCmd.isEnabled());
246         
247         // enable form --> enabled
248         form.setEnabled(true);
249         assertTrue("guarded like commit should be enabled with form", guarded.isEnabled());
250         assertTrue("commit should be enabled with form", cmtCmd.isEnabled());
251         
252         // revert --> disabled
253         form.revert();
254         assertFalse("guarded like commit should be disabled when no changes left", guarded.isEnabled());
255         assertFalse("commit should be disabled when no changes left", cmtCmd.isEnabled());
256     }
257 }