001    // Copyright 2005 The Apache Software Foundation
002    //
003    // Licensed under the Apache License, Version 2.0 (the "License");
004    // you may not use this file except in compliance with the License.
005    // You may obtain a copy of the License at
006    //
007    //     http://www.apache.org/licenses/LICENSE-2.0
008    //
009    // Unless required by applicable law or agreed to in writing, software
010    // distributed under the License is distributed on an "AS IS" BASIS,
011    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012    // See the License for the specific language governing permissions and
013    // limitations under the License.
014    
015    package org.apache.tapestry.form;
016    
017    import org.apache.hivemind.util.PropertyUtils;
018    import org.apache.tapestry.IBinding;
019    import org.apache.tapestry.IForm;
020    import org.apache.tapestry.IMarkupWriter;
021    import org.apache.tapestry.IRequestCycle;
022    import org.apache.tapestry.spec.ComponentSpecification;
023    import org.apache.tapestry.valid.IValidationDelegate;
024    import org.apache.tapestry.valid.ValidatorException;
025    import static org.easymock.EasyMock.expect;
026    import static org.easymock.EasyMock.expectLastCall;
027    import org.testng.annotations.Test;
028    
029    /**
030     * Tests for {@link org.apache.tapestry.form.TextField}.
031     * 
032     * @author Howard M. Lewis Ship
033     * @since 4.0
034     */
035    @Test(sequential=true)
036    public class TestTextField extends BaseFormComponentTestCase
037    {
038        public void testRewind()
039        {
040            TranslatedFieldSupport tfs = newMock(TranslatedFieldSupport.class);
041            ValidatableFieldSupport vfs = newMock(ValidatableFieldSupport.class);
042    
043            TextField component = newInstance(TextField.class, new Object[]
044            { "translatedFieldSupport", tfs, "validatableFieldSupport", vfs });
045            
046            IRequestCycle cycle = newCycle();
047            
048            IForm form = newMock(IForm.class);
049    
050            IMarkupWriter writer = newWriter();
051            
052            IValidationDelegate delegate = newDelegate();
053            
054            expect(cycle.renderStackPush(component)).andReturn(component);
055            
056            trainGetForm(cycle, form);
057            trainWasPrerendered(form, writer, component, false);
058            trainGetDelegate(form, delegate);
059    
060            delegate.setFormComponent(component);
061    
062            trainGetElementId(form, component, "barney");
063            trainIsRewinding(form, true);
064    
065            trainGetParameter(cycle, "barney", "10");
066    
067            Integer value = new Integer(10);
068            
069            try
070            {
071                expect(tfs.parse(component, "10")).andReturn(value);
072            
073                vfs.validate(component, writer, cycle, value);
074            }
075            catch (ValidatorException e)
076            {
077                unreachable();
078            }
079            
080            expect(cycle.renderStackPop()).andReturn(component);
081            
082            replay();
083    
084            component.render(writer, cycle);
085    
086            verify();
087            
088            assertEquals(value, component.getValue());
089        }
090    
091        @SuppressWarnings("ALL")
092        public void testRewindTranslateFailed()
093        {
094            TranslatedFieldSupport tfs = newMock(TranslatedFieldSupport.class);
095            ValidatableFieldSupport vfs = newMock(ValidatableFieldSupport.class);
096    
097            TextField component = newInstance(TextField.class, "translatedFieldSupport", tfs, "validatableFieldSupport", vfs);
098    
099            IRequestCycle cycle = newCycle();
100            
101            IForm form = newMock(IForm.class);
102    
103            IMarkupWriter writer = newWriter();
104    
105            IValidationDelegate delegate = newDelegate();
106            
107            expect(cycle.renderStackPush(component)).andReturn(component);
108            
109            trainGetForm(cycle, form);
110            trainWasPrerendered(form, writer, component, false);
111            trainGetDelegate(form, delegate);
112    
113            delegate.setFormComponent(component);
114    
115            trainGetElementId(form, component, "barney");
116            trainIsRewinding(form, true);
117    
118            trainGetParameter(cycle, "barney", "10");
119    
120            ValidatorException exception = new ValidatorException("test");
121            
122            try
123            {
124                expect(tfs.parse(component, "10")).andThrow(exception);
125            }
126            catch (ValidatorException e)
127            {
128                unreachable();
129            }
130            
131            delegate.record(exception);
132            
133            expect(cycle.renderStackPop()).andReturn(component);
134            
135            replay();
136    
137            component.render(writer, cycle);
138            
139            verify();
140    
141            assertNull(component.getValue());
142        }
143    
144        @SuppressWarnings("ALL")
145        public void testRewindValidateFailed()
146        {
147            TranslatedFieldSupport tfs = newMock(TranslatedFieldSupport.class);
148            ValidatableFieldSupport vfs = newMock(ValidatableFieldSupport.class);
149    
150            TextField component = newInstance(TextField.class, "translatedFieldSupport", tfs, "validatableFieldSupport", vfs);
151    
152            IRequestCycle cycle = newCycle();
153            IForm form = newMock(IForm.class);
154            IMarkupWriter writer = newWriter();
155            IValidationDelegate delegate = newDelegate();
156            
157            expect(cycle.renderStackPush(component)).andReturn(component);
158            
159            trainGetForm(cycle, form);
160            trainWasPrerendered(form, writer, component, false);
161    
162            delegate.setFormComponent(component);
163    
164            trainGetElementId(form, component, "barney");
165            trainIsRewinding(form, true);
166            trainGetParameter(cycle, "barney", "10");
167    
168            ValidatorException exception = new ValidatorException("test");
169            
170            Integer value = new Integer(10);
171            
172            try
173            {
174                expect(tfs.parse(component, "10")).andReturn(value);
175                
176                vfs.validate(component, writer, cycle, value);
177                expectLastCall().andThrow(exception);
178            }
179            catch (ValidatorException e)
180            {
181                unreachable();
182            }
183            
184            delegate.record(exception);
185            trainGetDelegate(form, delegate);
186            
187            expect(cycle.renderStackPop()).andReturn(component);
188            
189            replay();
190    
191            component.render(writer, cycle);
192            
193            verify();
194            
195            assertNull(component.getValue());
196        }
197    
198        public void testWasPrerendered()
199        {
200            TextField component = (TextField) newInstance(TextField.class);
201    
202            IRequestCycle cycle = newCycle();
203            
204            IForm form = newMock(IForm.class);
205            
206            IMarkupWriter writer = newWriter();
207    
208            expect(cycle.renderStackPush(component)).andReturn(component);
209            
210            trainGetForm(cycle, form);
211            trainWasPrerendered(form, writer, component, true);
212    
213            expect(cycle.renderStackPop()).andReturn(component);
214            
215            replay();
216    
217            component.render(writer, cycle);
218    
219            verify();
220        }
221    
222        public void testRewindNotForm()
223        {
224            TextField component = (TextField) newInstance(TextField.class);
225    
226            IRequestCycle cycle = newCycle();
227            
228            IForm form = newMock(IForm.class);
229    
230            IMarkupWriter writer = newWriter();
231    
232            IValidationDelegate delegate = newDelegate();
233            
234            expect(cycle.renderStackPush(component)).andReturn(component);
235            
236            trainGetForm(cycle, form);
237            trainWasPrerendered(form, writer, component, false);
238            trainGetDelegate(form, delegate);
239    
240            delegate.setFormComponent(component);
241    
242            trainGetElementId(form, component, "barney");
243            trainIsRewinding(form, false);
244            trainIsRewinding(cycle, true);
245            
246            expect(cycle.renderStackPop()).andReturn(component);
247            
248            replay();
249    
250            component.render(writer, cycle);
251    
252            verify();
253        }
254    
255        public void testRewindDisabled()
256        {
257            TextField component = (TextField) newInstance(TextField.class, "disabled", Boolean.TRUE);
258    
259            IRequestCycle cycle = newCycle();
260            
261            IForm form = newMock(IForm.class);
262    
263            IMarkupWriter writer = newWriter();
264    
265            IValidationDelegate delegate = newDelegate();
266            
267            expect(cycle.renderStackPush(component)).andReturn(component);
268            
269            trainGetForm(cycle, form);
270            trainWasPrerendered(form, writer, component, false);
271            trainGetDelegate(form, delegate);
272    
273            delegate.setFormComponent(component);
274    
275            trainGetElementId(form, component, "barney");
276            trainIsRewinding(form, true);
277            
278            expect(cycle.renderStackPop()).andReturn(component);
279            
280            replay();
281    
282            component.render(writer, cycle);
283    
284            assertNull(PropertyUtils.read(component, "value"));
285    
286            verify();
287        }
288    
289        public void test_Render()
290        {
291            TranslatedFieldSupport tfs = newMock(TranslatedFieldSupport.class);
292            
293            ValidatableFieldSupport vfs = newMock(ValidatableFieldSupport.class);
294            
295            IRequestCycle cycle = newCycle();
296            IForm form = newMock(IForm.class);
297    
298            IMarkupWriter writer = newBufferWriter();
299    
300            MockDelegate delegate = new MockDelegate();
301    
302            TextField component = newInstance(TextField.class,
303                                              "id", "fred",
304                                              "translatedFieldSupport", tfs,
305                                              "validatableFieldSupport", vfs,
306                                              "value", 10);
307            
308            expect(cycle.renderStackPush(component)).andReturn(component);
309            
310            trainGetForm(cycle, form);
311            trainWasPrerendered(form, writer, component, false);
312            trainGetDelegate(form, delegate);
313            
314            delegate.setFormComponent(component);
315    
316            trainGetElementId(form, component, "fred");
317            trainIsRewinding(form, false);
318            trainIsRewinding(cycle, false);
319            
320            form.setFormFieldUpdating(true);
321            
322            delegate.setFormComponent(component);
323            
324            expect(tfs.format(component, 10)).andReturn("10");
325    
326            tfs.renderContributions(component, writer, cycle);
327            vfs.renderContributions(component, writer, cycle);
328            
329            expect(cycle.renderStackPop()).andReturn(component);
330            
331            replay();
332    
333            component.render(writer, cycle);
334    
335            verify();
336    
337            assertBuffer("<span class=\"prefix\"><input type=\"text\" name=\"fred\" " +
338                    "value=\"10\" id=\"fred\" class=\"validation-delegate\" /></span>");
339        }
340    
341        public void testRenderHidden()
342        {
343            TranslatedFieldSupport tfs = newMock(TranslatedFieldSupport.class);
344            
345            ValidatableFieldSupport vfs = newMock(ValidatableFieldSupport.class);
346    
347            IRequestCycle cycle = newCycle();
348            IForm form = newMock(IForm.class);
349    
350            IMarkupWriter writer = newBufferWriter();
351    
352            MockDelegate delegate = new MockDelegate();
353    
354            TextField component = newInstance(TextField.class, "name", "fred", "translatedFieldSupport", tfs,
355                                              "validatableFieldSupport", vfs, "value",
356                                              10, "hidden", Boolean.TRUE);
357            
358            expect(cycle.renderStackPush(component)).andReturn(component);
359            
360            trainGetForm(cycle, form);
361            trainWasPrerendered(form, writer, component, false);
362            trainGetDelegate(form, delegate);
363    
364            delegate.setFormComponent(component);
365    
366            trainGetElementId(form, component, "fred");
367            trainIsRewinding(form, false);
368            trainIsRewinding(cycle, false);
369    
370            form.setFormFieldUpdating(true);
371            delegate.setFormComponent(component);
372    
373            expect(tfs.format(component, 10)).andReturn("10");
374            tfs.renderContributions(component, writer, cycle);
375            vfs.renderContributions(component, writer, cycle);
376            
377            expect(cycle.renderStackPop()).andReturn(component);
378            
379            replay();
380    
381            component.render(writer, cycle);
382    
383            verify();
384    
385            assertBuffer("<span class=\"prefix\"><input type=\"password\" name=\"fred\" " +
386                    "value=\"10\" id=\"fred\" class=\"validation-delegate\" /></span>");
387        }
388    
389        public void testRenderDisabled()
390        {
391            TranslatedFieldSupport tfs = newMock(TranslatedFieldSupport.class);
392    
393            ValidatableFieldSupport vfs = newMock(ValidatableFieldSupport.class);
394    
395            IRequestCycle cycle = newCycle();
396            IForm form = newMock(IForm.class);
397    
398            IMarkupWriter writer = newBufferWriter();
399    
400            MockDelegate delegate = new MockDelegate();
401    
402            TextField component = newInstance(TextField.class, "name", "fred", "translatedFieldSupport", tfs,
403                                              "validatableFieldSupport", vfs, "value", new Integer(10),
404                                              "disabled", Boolean.TRUE);
405            
406            expect(cycle.renderStackPush(component)).andReturn(component);
407            
408            trainGetForm(cycle, form);
409            trainWasPrerendered(form, writer, component, false);
410            trainGetDelegate(form, delegate);
411    
412            delegate.setFormComponent(component);
413    
414            trainGetElementId(form, component, "fred");
415            trainIsRewinding(form, false);
416            trainIsRewinding(cycle, false);
417    
418            form.setFormFieldUpdating(true);
419            delegate.setFormComponent(component);
420    
421            expect(tfs.format(component, 10)).andReturn("10");
422            
423            tfs.renderContributions(component, writer, cycle);
424            vfs.renderContributions(component, writer, cycle);
425            
426            expect(cycle.renderStackPop()).andReturn(component);
427            
428            replay();
429    
430            component.render(writer, cycle);
431    
432            verify();
433    
434            assertBuffer("<span class=\"prefix\"><input type=\"text\" name=\"fred\" disabled=\"disabled\" " +
435                    "value=\"10\" id=\"fred\" class=\"validation-delegate\" /></span>");
436        }
437    
438        public void testRenderWithInformalParameters()
439        {
440            TranslatedFieldSupport tfs = newMock(TranslatedFieldSupport.class);
441    
442            ValidatableFieldSupport vfs = newMock(ValidatableFieldSupport.class);
443    
444            IRequestCycle cycle = newCycle();
445            IForm form = newMock(IForm.class);
446    
447            IMarkupWriter writer = newBufferWriter();
448    
449            MockDelegate delegate = new MockDelegate();
450    
451            IBinding binding = newBinding("informal-value");
452    
453            TextField component = newInstance(TextField.class, new Object[]
454            { "name", "fred", "translatedFieldSupport", tfs, 
455                "validatableFieldSupport", vfs, "value", new Integer(10), 
456                "specification", new ComponentSpecification() });
457            
458            component.setBinding("informal", binding);
459            
460            expect(cycle.renderStackPush(component)).andReturn(component);
461            
462            trainGetForm(cycle, form);
463            trainWasPrerendered(form, writer, component, false);
464            trainGetDelegate(form, delegate);
465            
466            delegate.setFormComponent(component);
467    
468            trainGetElementId(form, component, "fred");
469            trainIsRewinding(form, false);
470            trainIsRewinding(cycle, false);
471            
472            form.setFormFieldUpdating(true);
473            
474            expect(tfs.format(component, new Integer(10))).andReturn("10");
475            
476            tfs.renderContributions(component, writer, cycle);
477            vfs.renderContributions(component, writer, cycle);
478            
479            expect(cycle.renderStackPop()).andReturn(component);
480            
481            replay();
482    
483            component.render(writer, cycle);
484    
485            verify();
486    
487            assertBuffer("<span class=\"prefix\"><input type=\"text\" name=\"fred\" " +
488                    "value=\"10\" id=\"fred\" class=\"validation-delegate\" informal=\"informal-value\" /></span>");
489        }
490    
491        public void testRenderNullValue()
492        {
493            TranslatedFieldSupport tfs = newMock(TranslatedFieldSupport.class);
494    
495            ValidatableFieldSupport vfs = newMock(ValidatableFieldSupport.class);
496    
497            IRequestCycle cycle = newCycle();
498            IForm form = newMock(IForm.class);
499    
500            IMarkupWriter writer = newBufferWriter();
501    
502            MockDelegate delegate = new MockDelegate();
503    
504            TextField component = newInstance(TextField.class,
505                                              "name", "fred",
506                                              "translatedFieldSupport", tfs,
507                                              "validatableFieldSupport", vfs);
508            
509            expect(cycle.renderStackPush(component)).andReturn(component);
510            
511            trainGetForm(cycle, form);
512            trainWasPrerendered(form, writer, component, false);
513            trainGetDelegate(form, delegate);
514    
515            delegate.setFormComponent(component);
516    
517            trainGetElementId(form, component, "fred");
518            trainIsRewinding(form, false);
519            trainIsRewinding(cycle, false);
520    
521            form.setFormFieldUpdating(true);
522            
523            delegate.setFormComponent(component);
524            expect(tfs.format(component, null)).andReturn("");
525    
526            tfs.renderContributions(component, writer, cycle);
527            vfs.renderContributions(component, writer, cycle);
528            
529            expect(cycle.renderStackPop()).andReturn(component);
530            
531            replay();
532    
533            component.render(writer, cycle);
534    
535            verify();
536    
537            assertBuffer("<span class=\"prefix\"><input type=\"text\" name=\"fred\" " +
538                    "value=\"\" id=\"fred\" class=\"validation-delegate\" /></span>");
539        }
540    
541        public void testIsRequired()
542        {
543            ValidatableFieldSupport support = newMock(ValidatableFieldSupport.class);
544    
545            TextField field = newInstance(TextField.class, new Object[]
546            { "validatableFieldSupport", support, });
547            
548            expect(support.isRequired(field)).andReturn(true);
549    
550            replay();
551    
552            assertEquals(true, field.isRequired());
553    
554            verify();
555        }
556    }