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.components;
016    
017    import org.apache.tapestry.*;
018    import org.apache.tapestry.services.DataSqueezer;
019    import org.apache.tapestry.spec.IComponentSpecification;
020    import org.apache.tapestry.util.io.DataSqueezerUtil;
021    import static org.easymock.EasyMock.expect;
022    import org.testng.annotations.Test;
023    
024    /**
025     * Tests for {@link org.apache.tapestry.components.IfBean} 
026     * and {@link ElseBean} 
027     * components.
028     * 
029     * @author Mindbridge
030     * @since 4.0
031     */
032    @Test
033    public class TestIfElse extends BaseComponentTestCase
034    {
035        private IRender newRender(IMarkupWriter writer, IRequestCycle cycle)
036        {
037            IRender render = newMock(IRender.class);
038            
039            render.render(writer, cycle);
040            
041            return render;
042        }
043    
044        public void test_Render_Plain_True()
045        {
046            IRequestCycle cycle = newMock(IRequestCycle.class);
047    
048            IMarkupWriter writer = newWriter();
049            
050            IfBean conditional = newInstance(IfBean.class, 
051                    new Object[] { "condition", Boolean.TRUE });
052            
053            ElseBean reverse = (ElseBean) newInstance(ElseBean.class);
054            
055            expect(cycle.renderStackPush(conditional)).andReturn(conditional);
056            expect(cycle.isRewinding()).andReturn(false);
057            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(null);
058            
059            trainResponseBuilder(cycle, writer);
060            
061            IRender body = newRender(writer, cycle);
062            
063            cycle.setAttribute(IfBean.IF_VALUE_ATTRIBUTE, Boolean.TRUE);
064            
065            expect(cycle.renderStackPop()).andReturn(conditional);
066            expect(cycle.renderStackPush(reverse)).andReturn(reverse);
067            expect(cycle.getAttribute(IfBean.IF_VALUE_ATTRIBUTE)).andReturn(Boolean.TRUE);
068            expect(cycle.renderStackPop()).andReturn(reverse);
069            
070            IRender body2 = newRender();
071            
072            replay();
073            
074            conditional.addBody(body);
075            
076            conditional.render(writer, cycle);
077            
078            reverse.addBody(body2);
079            reverse.render(writer, cycle);
080    
081            verify();
082        }
083    
084        public void test_Render_Plain_False()
085        {
086            IRequestCycle cycle = newCycle();
087            IMarkupWriter writer = newWriter();
088            
089            IfBean conditional = newInstance(IfBean.class, 
090                    new Object[] { "condition", Boolean.FALSE });
091            
092            ElseBean reverse = (ElseBean) newInstance(ElseBean.class);
093            
094            expect(cycle.renderStackPush(conditional)).andReturn(conditional);
095            expect(cycle.isRewinding()).andReturn(false);
096            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(null);
097            
098            cycle.setAttribute(IfBean.IF_VALUE_ATTRIBUTE, Boolean.FALSE);
099            
100            expect(cycle.renderStackPop()).andReturn(conditional);
101            expect(cycle.renderStackPush(reverse)).andReturn(reverse);
102            expect(cycle.getAttribute(IfBean.IF_VALUE_ATTRIBUTE)).andReturn(Boolean.FALSE);
103            expect(cycle.isRewinding()).andReturn(false);
104            
105            trainResponseBuilder(cycle, writer);
106            
107            IRender body = newRender();
108            IRender body2 = newRender(writer, cycle);
109            
110            expect(cycle.renderStackPop()).andReturn(reverse);
111            
112            replay();
113            
114            conditional.addBody(body);
115            conditional.render(writer, cycle);
116            
117            reverse.addBody(body2);
118            reverse.render(writer, cycle);
119    
120            verify();
121        }
122    
123        public void test_Render_In_Form_True()
124        {
125            IMarkupWriter writer = newWriter();
126            
127            IfBean conditional = newInstance(TestIfBean.class, 
128                            new Object[] { "condition", Boolean.TRUE });
129            
130            ElseBean reverse = (ElseBean) newInstance(ElseBean.class);
131            
132            IForm form = newMock(IForm.class);
133            IRequestCycle cycle = newCycle();
134            
135            expect(cycle.renderStackPush(conditional)).andReturn(conditional);
136            
137            expect(cycle.isRewinding()).andReturn(false);
138            
139            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(form);
140            
141            expect(form.getElementId(conditional)).andReturn("If");
142            
143            form.addHiddenValue("If", "T");
144            
145            form.setFormFieldUpdating(true);
146            
147            trainResponseBuilder(cycle, writer);
148            
149            IRender body = newRender(writer, cycle);
150            
151            cycle.setAttribute(IfBean.IF_VALUE_ATTRIBUTE, Boolean.TRUE);
152            
153            expect(cycle.renderStackPop()).andReturn(conditional);
154            
155            expect(cycle.renderStackPush(reverse)).andReturn(reverse);
156            
157            expect(cycle.getAttribute(IfBean.IF_VALUE_ATTRIBUTE)).andReturn(Boolean.TRUE);
158            
159            IRender body2 = newRender();
160            
161            expect(cycle.renderStackPop()).andReturn(reverse);
162            
163            replay();
164            
165            conditional.addBody(body);
166            conditional.render(writer, cycle);
167            
168            reverse.addBody(body2);
169            reverse.render(writer, cycle);
170    
171            verify();
172        }
173    
174        public void test_Render_In_Form_False()
175        {
176            IMarkupWriter writer = newWriter();
177            
178            IfBean conditional = newInstance(TestIfBean.class, 
179                            new Object[] { "condition", Boolean.FALSE });
180    
181            ElseBean reverse = (ElseBean) newInstance(ElseBean.class);
182            
183            IRequestCycle cycle = newCycle();
184            IForm form = newMock(IForm.class);
185            
186            expect(cycle.renderStackPush(conditional)).andReturn(conditional);
187            
188            expect(cycle.isRewinding()).andReturn(false);
189            
190            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(form);
191    
192            expect(form.getElementId(conditional)).andReturn("If");
193            
194            form.addHiddenValue("If", "F");
195            
196            form.setFormFieldUpdating(true);
197            
198            cycle.setAttribute(IfBean.IF_VALUE_ATTRIBUTE, Boolean.FALSE);
199            
200            expect(cycle.renderStackPop()).andReturn(conditional);
201            
202            expect(cycle.renderStackPush(reverse)).andReturn(reverse);
203            
204            expect(cycle.getAttribute(IfBean.IF_VALUE_ATTRIBUTE)).andReturn(Boolean.FALSE);
205            
206            expect(cycle.isRewinding()).andReturn(false);
207            
208            trainResponseBuilder(cycle, writer);
209            
210            IRender body = newRender();
211            IRender body2 = newRender(writer, cycle);
212    
213            expect(cycle.renderStackPop()).andReturn(reverse);
214            
215            replay();
216    
217            conditional.addBody(body);
218            conditional.render(writer, cycle);
219            
220            reverse.addBody(body2);
221            reverse.render(writer, cycle);
222    
223            verify();
224        }
225    
226        public void test_Ignore_Element_When_Rewinding_True()
227        {
228            IMarkupWriter writer = newWriter();
229            
230            IfBean conditional = newInstance(TestIfBean.class, 
231                            new Object[] { "condition", Boolean.TRUE, "element", "div" });
232            
233            ElseBean reverse = (ElseBean) newInstance(ElseBean.class);
234            
235            IForm form = newMock(IForm.class);
236            IRequestCycle cycle = newCycle();
237            
238            expect(cycle.renderStackPush(conditional)).andReturn(conditional);
239            
240            expect(cycle.isRewinding()).andReturn(true);
241            
242            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(form);
243            
244            expect(form.isRewinding()).andReturn(true);
245            
246            expect(form.getElementId(conditional)).andReturn("If");
247            
248            expect(cycle.getParameter("If")).andReturn("T");
249            
250            trainResponseBuilder(cycle, writer);
251            
252            IRender body = newRender(writer, cycle);
253            
254            cycle.setAttribute(IfBean.IF_VALUE_ATTRIBUTE, Boolean.TRUE);
255            
256            expect(cycle.renderStackPop()).andReturn(conditional);
257            
258            expect(cycle.renderStackPush(reverse)).andReturn(reverse);
259            
260            expect(cycle.getAttribute(IfBean.IF_VALUE_ATTRIBUTE)).andReturn(Boolean.TRUE);
261            
262            IRender body2 = newRender();
263    
264            expect(cycle.renderStackPop()).andReturn(reverse);
265            
266            replay();
267    
268            conditional.addBody(body);
269            conditional.render(writer, cycle);
270            
271            reverse.addBody(body2);
272            reverse.render(writer, cycle);
273            
274            verify();
275        }
276    
277        public void test_Ignore_Element_When_Rewinding_False()
278        {
279            IMarkupWriter writer = newWriter();
280            
281            IfBean conditional = newInstance(TestIfBean.class, 
282                            new Object[] { "condition", Boolean.TRUE, "element", "div" });
283            
284            ElseBean reverse = (ElseBean) newInstance(ElseBean.class);
285            
286            IForm form = newMock(IForm.class);
287            IRequestCycle cycle = newCycle();
288            
289            expect(cycle.renderStackPush(conditional)).andReturn(conditional);
290            
291            expect(cycle.isRewinding()).andReturn(true);
292            
293            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(form);
294            
295            expect(form.isRewinding()).andReturn(true);
296            
297            expect(form.getElementId(conditional)).andReturn("If");
298            
299            expect(cycle.getParameter("If")).andReturn("F");
300            
301            cycle.setAttribute(IfBean.IF_VALUE_ATTRIBUTE, Boolean.FALSE);
302            
303            expect(cycle.renderStackPop()).andReturn(conditional);
304            
305            expect(cycle.renderStackPush(reverse)).andReturn(reverse);
306            
307            expect(cycle.getAttribute(IfBean.IF_VALUE_ATTRIBUTE)).andReturn(Boolean.FALSE);
308            
309            expect(cycle.isRewinding()).andReturn(true);
310            
311            trainResponseBuilder(cycle, writer);
312            
313            IRender body = newRender();
314            IRender body2 = newRender(writer, cycle);
315            
316            expect(cycle.renderStackPop()).andReturn(reverse);
317            
318            replay();
319    
320            conditional.addBody(body);
321            conditional.render(writer, cycle);
322            
323            reverse.addBody(body2);
324            reverse.render(writer, cycle);
325            
326            verify();
327        }
328    
329        public void test_Render_Tag()
330        {
331            IMarkupWriter writer = newWriter();
332            
333                    IBinding informal = newBinding("informal-value");
334            IComponentSpecification spec = newSpec("informal", null);
335            
336            IRequestCycle cycle = newCycle();
337    
338            IfBean conditional = newInstance(TestIfBean.class,
339                                             "condition", Boolean.TRUE,
340                                             "element", "div",
341                                             "specification", spec,
342                                             "renderTag", Boolean.TRUE,
343                                             "clientId", "testIf");
344            
345            expect(cycle.renderStackPush(conditional)).andReturn(conditional);
346            expect(cycle.isRewinding()).andReturn(false);
347            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(null);
348            
349            IRender body = newRender(writer, cycle);
350    
351            writer.begin("div");
352            writer.attribute("id", "testIf");
353            writer.attribute("informal", "informal-value");
354    
355            writer.end("div");
356            
357            trainResponseBuilder(cycle, writer);
358            
359            cycle.setAttribute(IfBean.IF_VALUE_ATTRIBUTE, Boolean.TRUE);
360            
361            expect(cycle.renderStackPop()).andReturn(conditional);
362            
363            replay();
364            
365            conditional.addBody(body);
366            conditional.setBinding("informal", informal);
367            
368            conditional.render(writer, cycle);
369            
370            verify();
371        }
372        
373        public void test_Render_Tag_False()
374        {
375            IMarkupWriter writer = newWriter();
376            IComponentSpecification spec = newSpec();
377            IRequestCycle cycle = newCycle();
378    
379            IfBean conditional = newInstance(TestIfBean.class, 
380                    new Object[] { 
381                "condition", Boolean.TRUE,
382                "specification", spec,
383                "renderTag", Boolean.FALSE,
384                "templateTagName", "fieldset"
385            });
386            
387            expect(cycle.renderStackPush(conditional)).andReturn(conditional);
388            
389            expect(cycle.isRewinding()).andReturn(false);
390            
391            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(null);
392            
393            trainResponseBuilder(cycle, writer);
394            
395            IRender body = newRender(writer, cycle);
396            
397            cycle.setAttribute(IfBean.IF_VALUE_ATTRIBUTE, Boolean.TRUE);
398            
399            expect(cycle.renderStackPop()).andReturn(conditional);
400            
401            replay();
402            
403            conditional.addBody(body);
404            
405            conditional.render(writer, cycle);
406            
407            verify();
408        }
409        
410        public static abstract class TestIfBean extends IfBean
411        {
412            public TestIfBean() {
413            }
414            
415            public DataSqueezer getDataSqueezer() {
416                    return DataSqueezerUtil.createUnitTestSqueezer();
417            }
418        }
419    }