001    // Copyright 2004, 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    package org.apache.tapestry.components;
015    
016    import static org.easymock.EasyMock.*;
017    
018    import java.util.ArrayList;
019    import java.util.Iterator;
020    import java.util.List;
021    
022    import org.apache.hivemind.ApplicationRuntimeException;
023    import org.apache.tapestry.BaseComponentTestCase;
024    import org.apache.tapestry.IBinding;
025    import org.apache.tapestry.IForm;
026    import org.apache.tapestry.IMarkupWriter;
027    import org.apache.tapestry.IRender;
028    import org.apache.tapestry.IRequestCycle;
029    import org.apache.tapestry.TapestryUtils;
030    import org.apache.tapestry.coerce.ValueConverter;
031    import org.apache.tapestry.services.ResponseBuilder;
032    import org.apache.tapestry.spec.IComponentSpecification;
033    import org.apache.tapestry.spec.IParameterSpecification;
034    import org.apache.tapestry.util.io.DataSqueezerImpl;
035    import org.testng.annotations.Test;
036    
037    
038    /**
039     * Tests functionality of {@link ForBean} .
040     *
041     */
042    @Test(sequential = true)
043    public class TestForBean extends BaseComponentTestCase
044    {   
045        public void test_Render()
046        {
047            IRequestCycle cycle = newMock(IRequestCycle.class);
048            IMarkupWriter writer = newBufferWriter();
049            ValueConverter conv = newMock(ValueConverter.class);
050            ResponseBuilder resp = newMock(ResponseBuilder.class);
051            IComponentSpecification spec = newSpec();
052            IParameterSpecification pspec = newMock(IParameterSpecification.class);
053            
054            List src = new ArrayList();
055            src.add("Test1");
056            src.add("Test2");
057            
058            IBinding source = newBinding(src);
059            
060            ForBean bean = newInstance(ForBean.class, new Object[] {
061                "valueConverter", conv,
062                "responseBuilder", resp,
063                "templateTagName", "div",
064                "renderTag", true,
065                "specification", spec
066                });
067            
068            expect(cycle.renderStackPush(bean)).andReturn(bean);
069            
070            expect(cycle.isRewinding()).andReturn(false);
071            
072            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(null);
073            
074            expect(spec.getParameter("source")).andReturn(pspec).anyTimes();
075            
076            expect(conv.coerceValue(src, Iterator.class)).andReturn(src.iterator());
077            
078            expect(resp.isDynamic()).andReturn(false).anyTimes();
079            
080            expect(cycle.getResponseBuilder()).andReturn(resp).anyTimes();
081            
082            IRender body = newMock(IRender.class);
083            
084            resp.render(writer, body, cycle);
085            expectLastCall().anyTimes();
086            
087            expect(cycle.renderStackPop()).andReturn(bean);
088            
089            replay();
090            
091            bean.addBody(body);
092            bean.setBinding("source", source);
093            
094            bean.render(writer, cycle);
095            
096            verify();
097            
098            assertBuffer("<div></div><div></div>");
099        }
100        
101        public void test_Rewind_Missing_Converter()
102        {
103            IRequestCycle cycle = newMock(IRequestCycle.class);
104            IMarkupWriter writer = newWriter();
105            ValueConverter conv = newMock(ValueConverter.class);
106            ResponseBuilder resp = newMock(ResponseBuilder.class);
107            IForm form = newMock(IForm.class);
108            IComponentSpecification spec = newSpec();
109           // IParameterSpecification pspec = newMock(IParameterSpecification.class);
110            
111            List src = new ArrayList();
112            src.add("Test1");
113            src.add("Test2");
114            
115            IBinding source = newBinding(src);
116            
117            ForBean bean = newInstance(ForBean.class, new Object[] {
118                "valueConverter", conv,
119                "responseBuilder", resp,
120                "templateTagName", "div",
121                "renderTag", true,
122                "specification", spec
123                });
124            
125            expect(cycle.renderStackPush(bean)).andReturn(bean);
126            
127            expect(cycle.isRewinding()).andReturn(true).anyTimes();
128            
129            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(form);
130            
131            expect(form.isRewinding()).andReturn(true);
132            
133            expect(form.getElementId(bean)).andReturn("foo");
134            
135            String[] parms = (String[])src.toArray((new String[src.size()]));
136            
137            expect(cycle.getParameters("foo")).andReturn(parms);
138            
139            expect(conv.coerceValue(src, Iterator.class)).andReturn(src.iterator());
140            
141            expect(resp.isDynamic()).andReturn(false).anyTimes();
142            
143            expect(cycle.renderStackPop()).andReturn(bean);
144            
145            replay();
146            
147            // bean.addBody(body);
148            bean.setBinding("source", source);
149            
150            bean.render(writer, cycle);
151            
152            verify();
153        }
154        
155        class NotSerializable {
156            
157            String _value;
158            
159            public NotSerializable(String value)
160            {
161                _value = value;
162            }
163            
164            public String toString()
165            {
166                return "NotSerializable[" + _value + "]";
167            }
168        }
169        
170        public void test_Render_Line_Precise_Error()
171        {
172            IRequestCycle cycle = newMock(IRequestCycle.class);
173            IMarkupWriter writer = newBufferWriter();
174            ValueConverter conv = newMock(ValueConverter.class);
175            ResponseBuilder resp = newMock(ResponseBuilder.class);
176            IComponentSpecification spec = newSpec();
177            IParameterSpecification pspec = newMock(IParameterSpecification.class);
178            IForm form = newMock(IForm.class);
179            
180            List src = new ArrayList();
181            src.add(new NotSerializable("Test1"));
182            src.add(new NotSerializable("Test2"));
183            
184            IBinding source = newBinding(src);
185            
186            ForBean bean = newInstance(ForBean.class, new Object[] {
187                "valueConverter", conv,
188                "responseBuilder", resp,
189                "templateTagName", "div",
190                "renderTag", true,
191                "specification", spec,
192                "dataSqueezer", new DataSqueezerImpl()
193                });
194            
195            expect(cycle.renderStackPush(bean)).andReturn(bean);
196            
197            expect(cycle.isRewinding()).andReturn(false).anyTimes();
198            
199            expect(cycle.getAttribute(TapestryUtils.FORM_ATTRIBUTE)).andReturn(form);
200            
201            expect(form.getElementId(bean)).andReturn("For_1");
202            
203            expect(spec.getParameter("source")).andReturn(pspec).anyTimes();
204            
205            expect(conv.coerceValue(src, Iterator.class)).andReturn(src.iterator());
206            
207            expect(resp.isDynamic()).andReturn(false).anyTimes();
208            
209            expect(cycle.getResponseBuilder()).andReturn(resp).anyTimes();
210            
211            IRender body = newMock(IRender.class);
212            
213            resp.render(writer, body, cycle);
214            expectLastCall().anyTimes();
215            
216            form.setFormFieldUpdating(true);
217            
218            expect(cycle.renderStackPop()).andReturn(bean);
219            
220            replay();
221            
222            bean.addBody(body);
223            bean.setBinding("source", source);
224            
225            try {
226                
227                bean.render(writer, cycle);
228                fail("Exception should have been thrown");
229            } catch (ApplicationRuntimeException ex) {
230                
231                assertExceptionSubstring(ex, "error squeezing primary key value");
232            }
233            
234            verify();
235        }
236    }