001    package com.mockrunner.jms;
002    
003    import java.util.ArrayList;
004    import java.util.Collections;
005    import java.util.List;
006    
007    import javax.jms.JMSException;
008    import javax.jms.QueueBrowser;
009    import javax.jms.QueueReceiver;
010    import javax.jms.QueueSender;
011    
012    import com.mockrunner.mock.jms.MockConnection;
013    import com.mockrunner.mock.jms.MockQueue;
014    import com.mockrunner.mock.jms.MockQueueBrowser;
015    import com.mockrunner.mock.jms.MockQueueReceiver;
016    import com.mockrunner.mock.jms.MockQueueSender;
017    import com.mockrunner.mock.jms.MockSession;
018    
019    /**
020     * This class is used to create queue senders and receivers.
021     * It can be also used to access all created classes in tests.
022     */
023    public class QueueTransmissionManager
024    {
025        private MockConnection connection;
026        private MockSession session;
027        private List queueSenderList;
028        private List queueReceiverList;
029        private List queueBrowserList;
030        
031        public QueueTransmissionManager(MockConnection connection, MockSession session)
032        {
033            this.connection = connection;
034            this.session = session;
035            queueSenderList = new ArrayList();
036            queueReceiverList = new ArrayList();
037            queueBrowserList = new ArrayList();
038        }
039    
040        /**
041         * Closes all senders, receivers, browsers, publishers and subscribers.
042         */
043        public void closeAll()
044        {
045            closeAllQueueSenders();
046            closeAllQueueReceivers();
047            closeAllQueueBrowsers();
048        }
049    
050        /**
051         * Closes all queue senders.
052         */
053        public void closeAllQueueSenders()
054        {
055            for(int ii = 0; ii < queueSenderList.size(); ii++)
056            {
057                QueueSender sender = (QueueSender)queueSenderList.get(ii);
058                try
059                {
060                    sender.close();
061                }
062                catch(JMSException exc)
063                {
064                
065                }
066            }
067        }
068    
069        /**
070         * Closes all queue receivers.
071         */
072        public void closeAllQueueReceivers()
073        {
074            for(int ii = 0; ii < queueReceiverList.size(); ii++)
075            {
076                QueueReceiver receiver = (QueueReceiver)queueReceiverList.get(ii);
077                try
078                {
079                    receiver.close();
080                }
081                catch(JMSException exc)
082                {
083        
084                }
085            }
086        }
087    
088        /**
089         * Closes all queue browsers.
090         */
091        public void closeAllQueueBrowsers()
092        {
093            for(int ii = 0; ii < queueBrowserList.size(); ii++)
094            {
095                QueueBrowser browser = (QueueBrowser)queueBrowserList.get(ii);
096                try
097                {
098                    browser.close();
099                }
100                catch(JMSException exc)
101                {
102    
103                }
104            }
105        }
106        
107        /**
108         * Creates a new <code>QueueSender</code> for the specified
109         * <code>Queue</code>. Usually this method is called
110         * by {@link com.mockrunner.mock.jms.MockQueueSession#createSender}.
111         * @param queue the <code>Queue</code>
112         * @return the created <code>QueueSender</code>
113         */
114        public MockQueueSender createQueueSender(MockQueue queue)
115        {
116            MockQueueSender sender = new MockQueueSender(connection, session, queue);
117            queueSenderList.add(sender);
118            return sender;
119        }
120    
121        /**
122         * Returns a <code>QueueSender</code> by its index or
123         * <code>null</code>, if no such <code>QueueSender</code> is
124         * present.
125         * @param index the index of the <code>QueueSender</code>
126         * @return the <code>QueueSender</code>
127         */
128        public MockQueueSender getQueueSender(int index)
129        {
130            if(queueSenderList.size() <= index || index < 0) return null;
131            return (MockQueueSender)queueSenderList.get(index);
132        }
133        
134        /**
135         * Returns a <code>QueueSender</code> by the name of its
136         * corresponding <code>Queue</code>. If there's more than
137         * one <code>QueueSender</code> object for the specified name,
138         * the first one will be returned.
139         * @param queueName the name of the <code>Queue</code>
140         * @return the <code>QueueSender</code>
141         */
142        public MockQueueSender getQueueSender(String queueName)
143        {
144            List senders = getQueueSenderList(queueName);
145            if(senders.size() <= 0) return null;
146            return (MockQueueSender)senders.get(0);
147        }
148        
149        /**
150         * Returns the list of the <code>QueueSender</code> objects
151         * for a specific <code>Queue</code>.
152         * @param queueName the name of the <code>Queue</code>
153         * @return the list of <code>QueueSender</code> objects
154         */
155        public List getQueueSenderList(String queueName)
156        {
157            List resultList = new ArrayList();
158            for(int ii = 0; ii < queueSenderList.size(); ii++)
159            {
160                QueueSender sender = (QueueSender)queueSenderList.get(ii);
161                try
162                {
163                    if(sender.getQueue().getQueueName().equals(queueName))
164                    {
165                        resultList.add(sender);
166                    }
167                }
168                catch(JMSException exc)
169                {
170                
171                }
172            }
173            return Collections.unmodifiableList(resultList);
174        }
175        
176        /**
177         * Returns the list of all <code>QueueSender</code> objects.
178         * @return the list of <code>QueueSender</code> objects
179         */
180        public List getQueueSenderList()
181        {
182            return Collections.unmodifiableList(queueSenderList);
183        }
184    
185        /**
186         * Creates a new <code>QueueReceiver</code> for the specified
187         * <code>Queue</code>. Usually this method is called
188         * by {@link com.mockrunner.mock.jms.MockQueueSession#createReceiver}.
189         * @param queue the <code>Queue</code>
190         * @param messageSelector the message selector
191         * @return the created <code>QueueReceiver</code>
192         */
193        public MockQueueReceiver createQueueReceiver(MockQueue queue, String messageSelector)
194        {
195            MockQueueReceiver receiver = new MockQueueReceiver(connection, session, queue, messageSelector);
196            queueReceiverList.add(receiver);
197            return receiver;
198        }
199    
200        /**
201         * Returns a <code>QueueReceiver</code> by its index or
202         * <code>null</code>, if no such <code>QueueReceiver</code> is
203         * present.
204         * @param index the index of the <code>QueueReceiver</code>
205         * @return the <code>QueueReceiver</code>
206         */
207        public MockQueueReceiver getQueueReceiver(int index)
208        {
209            if(queueReceiverList.size() <= index || index < 0) return null;
210            return (MockQueueReceiver)queueReceiverList.get(index);
211        }
212        
213        /**
214         * Returns a <code>QueueReceiver</code> by the name of its
215         * corresponding <code>Queue</code>. If there's more than
216         * one <code>QueueReceiver</code> object for the specified name,
217         * the first one will be returned.
218         * @param queueName the name of the <code>Queue</code>
219         * @return the <code>QueueReceiver</code>
220         */
221        public MockQueueReceiver getQueueReceiver(String queueName)
222        {
223            List receivers = getQueueReceiverList(queueName);
224            if(receivers.size() <= 0) return null;
225            return (MockQueueReceiver)receivers.get(0);
226        }
227    
228        /**
229         * Returns the list of the <code>QueueReceiver</code> objects
230         * for a specific <code>Queue</code>.
231         * @param queueName the name of the <code>Queue</code>
232         * @return the list of <code>QueueReceiver</code> objects
233         */
234        public List getQueueReceiverList(String queueName)
235        {
236            List resultList = new ArrayList();
237            for(int ii = 0; ii < queueReceiverList.size(); ii++)
238            {
239                QueueReceiver receiver = (QueueReceiver)queueReceiverList.get(ii);
240                try
241                {
242                    if(receiver.getQueue().getQueueName().equals(queueName))
243                    {
244                        resultList.add(receiver);
245                    }
246                }
247                catch(JMSException exc)
248                {
249                
250                }
251            }
252            return Collections.unmodifiableList(resultList);
253        }
254        
255        /**
256         * Returns the list of <code>QueueReceiver</code> objects.
257         * @return the <code>QueueReceiver</code> list
258         */
259        public List getQueueReceiverList()
260        {
261            return Collections.unmodifiableList(queueReceiverList);
262        }
263    
264        /**
265         * Creates a new <code>QueueBrowser</code> for the specified
266         * <code>Queue</code>. Usually this method is called
267         * by {@link com.mockrunner.mock.jms.MockQueueSession#createBrowser}.
268         * @param queue the <code>Queue</code>
269         * @param messageSelector the message selector
270         * @return the created <code>QueueBrowser</code>
271         */
272        public MockQueueBrowser createQueueBrowser(MockQueue queue, String messageSelector)
273        {
274            MockQueueBrowser browser = new MockQueueBrowser(connection, queue, messageSelector);
275            queueBrowserList.add(browser);
276            return browser;
277        }
278    
279        /**
280         * Returns a <code>QueueBrowser</code> by its index or
281         * <code>null</code>, if no such <code>QueueBrowser</code> is
282         * present.
283         * @param index the index of the <code>QueueBrowser</code>
284         * @return the <code>QueueBrowser</code>
285         */
286        public MockQueueBrowser getQueueBrowser(int index)
287        {
288            if(queueBrowserList.size() <= index || index < 0) return null;
289            return (MockQueueBrowser)queueBrowserList.get(index);
290        }
291        
292        /**
293         * Returns a <code>QueueBrowser</code> by the name of its
294         * corresponding <code>Queue</code>. If there's more than
295         * one <code>QueueBrowser</code> object for the specified name,
296         * the first one will be returned.
297         * @param queueName the name of the <code>Queue</code>
298         * @return the <code>QueueBrowser</code>
299         */
300        public MockQueueBrowser getQueueBrowser(String queueName)
301        {
302            List browsers = getQueueBrowserList(queueName);
303            if(browsers.size() <= 0) return null;
304            return (MockQueueBrowser)browsers.get(0);
305        }
306    
307        /**
308         * Returns the list of the <code>QueueBrowser</code> objects
309         * for a specific <code>Queue</code>.
310         * @param queueName the name of the <code>Queue</code>
311         * @return the list of <code>QueueBrowser</code> objects
312         */
313        public List getQueueBrowserList(String queueName)
314        {
315            List resultList = new ArrayList();
316            for(int ii = 0; ii < queueBrowserList.size(); ii++)
317            {
318                QueueBrowser browser = (QueueBrowser)queueBrowserList.get(ii);
319                try
320                {
321                    if(browser.getQueue().getQueueName().equals(queueName))
322                    {
323                        resultList.add(browser);
324                    }
325                }
326                catch(JMSException exc)
327                {
328                
329                }
330            }
331            return Collections.unmodifiableList(resultList);
332        }
333        
334        /**
335         * Returns the list of <code>QueueBrowser</code> objects.
336         * @return the <code>QueueBrowser</code> list
337         */
338        public List getQueueBrowserList()
339        {
340            return Collections.unmodifiableList(queueBrowserList);
341        }
342    }