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 }