001    package com.mockrunner.base;
002    
003    import junit.framework.TestCase;
004    
005    import com.mockrunner.connector.ConnectorTestModule;
006    import com.mockrunner.ejb.EJBTestModule;
007    import com.mockrunner.jdbc.JDBCTestModule;
008    import com.mockrunner.jms.JMSTestModule;
009    import com.mockrunner.mock.connector.cci.ConnectorMockObjectFactory;
010    import com.mockrunner.mock.connector.cci.MockConnectionFactory;
011    import com.mockrunner.mock.ejb.EJBMockObjectFactory;
012    import com.mockrunner.mock.jdbc.JDBCMockObjectFactory;
013    import com.mockrunner.mock.jms.JMSMockObjectFactory;
014    import com.mockrunner.mock.web.ActionMockObjectFactory;
015    import com.mockrunner.mock.web.WebMockObjectFactory;
016    import com.mockrunner.servlet.ServletTestModule;
017    import com.mockrunner.struts.ActionTestModule;
018    import com.mockrunner.tag.TagTestModule;
019    
020    /**
021     * Base class for all standard adapters. Not used for basic adapters.
022     */
023    public abstract class BaseTestCase extends TestCase
024    {
025        private WebMockObjectFactory webMockFactory;
026        private ActionMockObjectFactory actionMockFactory;
027        private JDBCMockObjectFactory jdbcMockFactory;
028        private EJBMockObjectFactory ejbMockFactory;
029        private ConnectorMockObjectFactory connectorMockFactory;
030        private JMSMockObjectFactory jmsMockFactory;
031        
032        public BaseTestCase()
033        {
034            
035        }
036    
037        public BaseTestCase(String arg0)
038        {
039            super(arg0);
040        }
041        
042        protected void tearDown() throws Exception
043        {
044            super.tearDown();
045            if(null != jdbcMockFactory)
046            {
047                jdbcMockFactory.restoreDrivers();
048                jdbcMockFactory = null;
049            }
050            if(null != ejbMockFactory)
051            {
052                ejbMockFactory.resetMockContextFactory();
053                ejbMockFactory = null;
054            }
055            webMockFactory = null;
056            actionMockFactory = null;
057            jmsMockFactory  = null;
058            connectorMockFactory = null;
059        }
060    
061        /**
062         * Creates the mock object factories. If you
063         * overwrite this method, you must call 
064         * <code>super.setUp()</code>.
065         */
066        protected void setUp() throws Exception
067        {
068            super.setUp();
069        } 
070    
071        /**
072         * Creates a {@link WebMockObjectFactory}. 
073         * @return the created {@link WebMockObjectFactory}
074         */
075        protected WebMockObjectFactory createWebMockObjectFactory()
076        {
077            return new WebMockObjectFactory();
078        }
079    
080        /**
081         * Same as <code>createWebMockObjectFactory(otherFactory, true)</code>
082         */
083        protected WebMockObjectFactory createWebMockObjectFactory(WebMockObjectFactory otherFactory)
084        {
085            return new WebMockObjectFactory(otherFactory);
086        }
087        
088        /**
089         * Creates a {@link com.mockrunner.mock.web.WebMockObjectFactory} based on another one.
090         * The created {@link com.mockrunner.mock.web.WebMockObjectFactory} will have its own
091         * request and response objects. If you set <i>createNewSession</i>
092         * to <code>true</code> it will also have its own session object.
093         * The two factories will share one <code>ServletContext</code>.
094         * Especially important for multithreading tests.
095         * If you set <i>createNewSession</i> to false, the two factories
096         * will share one session. This setting simulates multiple requests
097         * from the same client.
098         * @param otherFactory the other factory
099         * @param createNewSession create a new session for the new factory
100         * @return the created {@link com.mockrunner.mock.web.WebMockObjectFactory}
101         */
102        protected WebMockObjectFactory createWebMockObjectFactory(WebMockObjectFactory otherFactory, boolean createNewSession)
103        {
104            return new WebMockObjectFactory(otherFactory, createNewSession);
105        }
106    
107        /**
108         * Gets the current {@link WebMockObjectFactory}.
109         * @return the {@link WebMockObjectFactory}
110         */
111        protected WebMockObjectFactory getWebMockObjectFactory()
112        {
113            synchronized(ActionMockObjectFactory.class) 
114            {
115                if(webMockFactory == null)
116                {
117                    webMockFactory = getActionMockObjectFactory();
118                }
119            }
120            return webMockFactory;
121        }
122        
123        /**
124         * Sets the current {@link WebMockObjectFactory}.
125         * @param mockFactory the {@link WebMockObjectFactory}
126         */
127        protected void setWebMockObjectFactory(WebMockObjectFactory mockFactory)
128        {
129            this.webMockFactory = mockFactory;
130        }
131        
132        /**
133         * Creates a {@link ActionMockObjectFactory}. 
134         * @return the created {@link ActionMockObjectFactory}
135         */
136        protected ActionMockObjectFactory createActionMockObjectFactory()
137        {
138            return new ActionMockObjectFactory();
139        }
140    
141        /**
142         * Same as <code>createActionMockObjectFactory(otherFactory, true)</code>
143         */
144        protected ActionMockObjectFactory createActionMockObjectFactory(WebMockObjectFactory otherFactory)
145        {
146            return new ActionMockObjectFactory(otherFactory);
147        }
148        
149        /**
150         * Creates a {@link com.mockrunner.mock.web.ActionMockObjectFactory} based on 
151         * another {@link com.mockrunner.mock.web.WebMockObjectFactory}.
152         * @param otherFactory the other factory
153         * @param createNewSession create a new session for the new factory
154         * @return the created {@link com.mockrunner.mock.web.ActionMockObjectFactory}
155         * @see #createWebMockObjectFactory(WebMockObjectFactory, boolean)
156         */
157        protected ActionMockObjectFactory createActionMockObjectFactory(WebMockObjectFactory otherFactory, boolean createNewSession)
158        {
159            return new ActionMockObjectFactory(otherFactory, createNewSession);
160        }
161    
162        /**
163         * Gets the current {@link ActionMockObjectFactory}.
164         * @return the {@link ActionMockObjectFactory}
165         */
166        protected ActionMockObjectFactory getActionMockObjectFactory()
167        {
168            synchronized(ActionMockObjectFactory.class) 
169            {
170                if(actionMockFactory == null)
171                {
172                    actionMockFactory = createActionMockObjectFactory();
173                }
174            }
175            return actionMockFactory;
176        }
177        
178        /**
179         * Sets the current {@link ActionMockObjectFactory}.
180         * @param mockFactory the {@link ActionMockObjectFactory}
181         */
182        protected void setActionMockObjectFactory(ActionMockObjectFactory mockFactory)
183        {
184            this.actionMockFactory = mockFactory;
185        }
186        
187        /**
188         * Creates a {@link JDBCMockObjectFactory}. 
189         * @return the created {@link JDBCMockObjectFactory}
190         */
191        protected JDBCMockObjectFactory createJDBCMockObjectFactory()
192        {
193            return new JDBCMockObjectFactory();
194        }
195        
196        /**
197         * Gets the current {@link JDBCMockObjectFactory}.
198         * @return the {@link JDBCMockObjectFactory}
199         */
200        protected JDBCMockObjectFactory getJDBCMockObjectFactory()
201        {
202            synchronized(JDBCMockObjectFactory.class) 
203            {
204                if(jdbcMockFactory == null)
205                {
206                    jdbcMockFactory = createJDBCMockObjectFactory();
207                }
208            }
209            return jdbcMockFactory;
210        }
211    
212        /**
213         * Sets the current {@link JDBCMockObjectFactory}.
214         * @param mockFactory the {@link JDBCMockObjectFactory}
215         */
216        protected void setJDBCMockObjectFactory(JDBCMockObjectFactory mockFactory)
217        {
218            this.jdbcMockFactory = mockFactory;
219        }
220        
221        /**
222         * Creates a {@link EJBMockObjectFactory}. 
223         * @return the created {@link EJBMockObjectFactory}
224         */
225        protected EJBMockObjectFactory createEJBMockObjectFactory()
226        {
227            return new EJBMockObjectFactory();
228        }
229    
230        /**
231         * Gets the current {@link EJBMockObjectFactory}.
232         * @return the {@link EJBMockObjectFactory}
233         */
234        protected EJBMockObjectFactory getEJBMockObjectFactory()
235        {
236            synchronized(EJBMockObjectFactory.class) 
237            {
238                if(ejbMockFactory == null)
239                {
240                    ejbMockFactory = createEJBMockObjectFactory();
241                }
242            }
243            return ejbMockFactory;
244        }
245    
246        /**
247         * Sets the current {@link EJBMockObjectFactory}.
248         * @param mockFactory the {@link EJBMockObjectFactory}
249         */
250        protected void setEJBMockObjectFactory(EJBMockObjectFactory mockFactory)
251        {
252            this.ejbMockFactory = mockFactory;
253        }
254        
255            /**
256             * Creates a {@link ConnectorMockObjectFactory}. 
257             * @return the created {@link ConnectorMockObjectFactory}
258             */
259            protected ConnectorMockObjectFactory createConnectorMockObjectFactory()
260            {
261                return new ConnectorMockObjectFactory();
262            }
263    
264            /**
265             * Gets the current {@link ConnectorMockObjectFactory}.
266             * @return the {@link ConnectorMockObjectFactory}
267             */
268            protected ConnectorMockObjectFactory getConnectorMockObjectFactory()
269            {
270                synchronized(MockConnectionFactory.class) 
271                {
272                        if(connectorMockFactory == null)
273                            {
274                                connectorMockFactory = createConnectorMockObjectFactory();
275                        }
276                }
277                return connectorMockFactory;
278            }
279    
280            /**
281             * Sets the current {@link ConnectorMockObjectFactory}.
282             * @param mockFactory the {@link ConnectorMockObjectFactory}
283             */
284            protected void setConnectorMockObjectFactory(ConnectorMockObjectFactory mockFactory)
285            {
286                this.connectorMockFactory = mockFactory;
287            }
288        
289        /**
290         * Creates a {@link JMSMockObjectFactory}. 
291         * @return the created {@link JMSMockObjectFactory}
292         */
293        protected JMSMockObjectFactory createJMSMockObjectFactory()
294        {
295            return new JMSMockObjectFactory();
296        }
297    
298        /**
299         * Gets the current {@link JMSMockObjectFactory}.
300         * @return the {@link JMSMockObjectFactory}
301         */
302        protected JMSMockObjectFactory getJMSMockObjectFactory()
303        {
304            synchronized(JMSMockObjectFactory.class) 
305            {
306                if(jmsMockFactory == null)
307                {
308                    jmsMockFactory = createJMSMockObjectFactory();
309                }
310            }
311            return jmsMockFactory;
312        }
313    
314        /**
315         * Sets the current {@link JMSMockObjectFactory}.
316         * @param mockFactory the {@link JMSMockObjectFactory}
317         */
318        protected void setJMSMockObjectFactory(JMSMockObjectFactory mockFactory)
319        {
320            this.jmsMockFactory = mockFactory;
321        }
322        
323        /**
324         * Creates an {@link com.mockrunner.struts.ActionTestModule} with the specified
325         * {@link WebMockObjectFactory}.
326         * @param mockFactory the {@link ActionMockObjectFactory}
327         * @return the created {@link com.mockrunner.struts.ActionTestModule}
328         */
329        protected ActionTestModule createActionTestModule(ActionMockObjectFactory mockFactory)
330        {
331            return new ActionTestModule(mockFactory);
332        }
333        
334        /**
335         * Creates an {@link com.mockrunner.struts.ActionTestModule} based on the current
336         * {@link WebMockObjectFactory}.
337         * Same as <code>createActionTestModule(getActionMockObjectFactory())</code>.
338         * @return the created {@link com.mockrunner.struts.ActionTestModule}
339         */
340        protected ActionTestModule createActionTestModule()
341        {
342            return new ActionTestModule(getActionMockObjectFactory());
343        }
344        
345        /**
346         * Creates a {@link com.mockrunner.tag.TagTestModule} with the specified
347         * {@link WebMockObjectFactory}.
348         * @return the created {@link com.mockrunner.tag.TagTestModule}
349         */
350        protected TagTestModule createTagTestModule(WebMockObjectFactory mockFactory)
351        {
352            return new TagTestModule(mockFactory);
353        }
354        
355        /**
356         * Creates a {@link com.mockrunner.tag.TagTestModule} based on the current
357         * {@link WebMockObjectFactory}.
358         * Same as <code>createTagTestModule(getWebMockObjectFactory())</code>.
359         * @return the created {@link com.mockrunner.tag.TagTestModule}
360         */
361        protected TagTestModule createTagTestModule()
362        {
363            return new TagTestModule(getWebMockObjectFactory());
364        }
365        
366        /**
367         * Creates a {@link com.mockrunner.servlet.ServletTestModule} with the specified
368         * {@link WebMockObjectFactory}.
369         * @return the created {@link com.mockrunner.servlet.ServletTestModule}
370         */
371        protected ServletTestModule createServletTestModule(WebMockObjectFactory mockFactory)
372        {
373            return new ServletTestModule(mockFactory);
374        }
375    
376        /**
377         * Creates a {@link com.mockrunner.servlet.ServletTestModule} based on the current
378         * {@link WebMockObjectFactory}.
379         * Same as <code>createServletTestModule(getWebMockObjectFactory())</code>.
380         * @return the created {@link com.mockrunner.servlet.ServletTestModule}
381         */
382        protected ServletTestModule createServletTestModule()
383        {
384            return new ServletTestModule(getWebMockObjectFactory());
385        }
386        
387        /**
388         * Creates a {@link com.mockrunner.jdbc.JDBCTestModule} with the specified
389         * {@link JDBCMockObjectFactory}.
390         * @return the created {@link com.mockrunner.jdbc.JDBCTestModule}
391         */
392        protected JDBCTestModule createJDBCTestModule(JDBCMockObjectFactory mockFactory)
393        {
394            return new JDBCTestModule(mockFactory);
395        }
396    
397        /**
398         * Creates a {@link com.mockrunner.jdbc.JDBCTestModule} based on the current
399         * {@link JDBCMockObjectFactory}.
400         * Same as <code>createJDBCTestModule(getJDBCMockObjectFactory())</code>.
401         * @return the created {@link com.mockrunner.jdbc.JDBCTestModule}
402         */
403        protected JDBCTestModule createJDBCTestModule()
404        {
405            return new JDBCTestModule(getJDBCMockObjectFactory());
406        }
407        
408        /**
409         * Creates an {@link com.mockrunner.ejb.EJBTestModule} with the specified
410         * {@link EJBMockObjectFactory}.
411         * @return the created {@link com.mockrunner.ejb.EJBTestModule}
412         */
413        protected EJBTestModule createEJBTestModule(EJBMockObjectFactory mockFactory)
414        {
415            return new EJBTestModule(mockFactory);
416        }
417    
418        /**
419         * Creates an {@link com.mockrunner.ejb.EJBTestModule} based on the current
420         * {@link EJBMockObjectFactory}.
421         * Same as <code>createEJBTestModule(getEJBMockObjectFactory())</code>.
422         * @return the created {@link com.mockrunner.ejb.EJBTestModule}
423         */
424        protected EJBTestModule createEJBTestModule()
425        {
426            return new EJBTestModule(getEJBMockObjectFactory());
427        }
428        
429            /**
430             * Creates an {@link com.mockrunner.connector.ConnectorTestModule} with the specified
431             * {@link ConnectorMockObjectFactory}.
432             * @return the created {@link com.mockrunner.connector.ConnectorTestModule}
433             */
434            protected ConnectorTestModule createConnectorTestModule(ConnectorMockObjectFactory mockFactory)
435            {
436                return new ConnectorTestModule(mockFactory);
437            }
438    
439            /**
440             * Creates an {@link com.mockrunner.connector.ConnectorTestModule} based on the current
441             * {@link ConnectorMockObjectFactory}.
442             * Same as <code>createConnectorTestModule(getConnectorMockConnectionFactory())</code>.
443             * @return the created {@link com.mockrunner.connector.ConnectorTestModule}
444             */
445            protected ConnectorTestModule createConnectorTestModule()
446            {
447                return new ConnectorTestModule(getConnectorMockObjectFactory());
448            }
449        
450        /**
451         * Creates a {@link com.mockrunner.jms.JMSTestModule} with the specified
452         * {@link JMSMockObjectFactory}.
453         * @return the created {@link com.mockrunner.jms.JMSTestModule}
454         */
455        protected JMSTestModule createJMSTestModule(JMSMockObjectFactory mockFactory)
456        {
457            return new JMSTestModule(mockFactory);
458        }
459    
460        /**
461         * Creates a {@link com.mockrunner.jms.JMSTestModule} based on the current
462         * {@link JMSMockObjectFactory}.
463         * Same as <code>createJMSTestModule(getJMSMockObjectFactory())</code>.
464         * @return the created {@link com.mockrunner.jms.JMSTestModule}
465         */
466        protected JMSTestModule createJMSTestModule()
467        {
468            return new JMSTestModule(getJMSMockObjectFactory());
469        }
470    }
471