001 package com.mockrunner.mock.jms; 002 003 import java.util.ArrayList; 004 import java.util.Collections; 005 import java.util.List; 006 007 import javax.jms.Connection; 008 import javax.jms.ConnectionConsumer; 009 import javax.jms.ConnectionMetaData; 010 import javax.jms.Destination; 011 import javax.jms.ExceptionListener; 012 import javax.jms.JMSException; 013 import javax.jms.ServerSessionPool; 014 import javax.jms.Session; 015 import javax.jms.Topic; 016 017 import com.mockrunner.jms.ConfigurationManager; 018 import com.mockrunner.jms.DestinationManager; 019 020 /** 021 * Mock implementation of JMS <code>Connection</code>. 022 * Please note: The interfaces <code>ConnectionConsumer</code>, 023 * <code>ServerSessionPool</code> and <code>ServerSession</code> 024 * are not meant for application use. Mockrunner provides very 025 * simple mock implementations but usually you won't need them. 026 */ 027 public class MockConnection implements Connection 028 { 029 private ConnectionMetaData metaData; 030 private List sessions; 031 private String clientId; 032 private boolean started; 033 private boolean closed; 034 private ExceptionListener listener; 035 private JMSException exception; 036 private DestinationManager destinationManager; 037 private ConfigurationManager configurationManager; 038 039 public MockConnection(DestinationManager destinationManager, ConfigurationManager configurationManager) 040 { 041 metaData = new MockConnectionMetaData(); 042 started = false; 043 closed = false; 044 exception = null; 045 this.destinationManager = destinationManager; 046 this.configurationManager = configurationManager; 047 sessions = new ArrayList(); 048 } 049 050 /** 051 * Returns the {@link com.mockrunner.jms.DestinationManager}. 052 * @return the {@link com.mockrunner.jms.DestinationManager} 053 */ 054 public DestinationManager getDestinationManager() 055 { 056 return destinationManager; 057 } 058 059 /** 060 * Returns the {@link com.mockrunner.jms.ConfigurationManager}. 061 * @return the {@link com.mockrunner.jms.ConfigurationManager} 062 */ 063 public ConfigurationManager getConfigurationManager() 064 { 065 return configurationManager; 066 } 067 068 /** 069 * Returns the list of {@link MockSession} objects. 070 * @return the list 071 */ 072 public List getSessionList() 073 { 074 return Collections.unmodifiableList(sessions); 075 } 076 077 /** 078 * Returns a {@link MockSession}. If there's no such 079 * {@link MockSession}, <code>null</code> is returned. 080 * @param index the index of the session object 081 * @return the session object 082 */ 083 public MockSession getSession(int index) 084 { 085 if(sessions.size() <= index || index < 0) return null; 086 return (MockSession)sessions.get(index); 087 } 088 089 /** 090 * Set an exception that will be thrown when calling one 091 * of the interface methods. Since the mock implementation 092 * cannot fail like a full blown message server you can use 093 * this method to simulate server errors. After the exception 094 * was thrown it will be deleted. 095 * @param exception the exception to throw 096 */ 097 public void setJMSException(JMSException exception) 098 { 099 this.exception = exception; 100 } 101 102 /** 103 * Throws a <code>JMSException</code> if one is set with 104 * {@link #setJMSException}. Informs the <code>ExceptionListener</code> 105 * and deletes the exception after throwing it. 106 */ 107 public void throwJMSException() throws JMSException 108 { 109 if(null == exception) return; 110 JMSException tempException = exception; 111 exception = null; 112 if(listener != null) 113 { 114 listener.onException(tempException); 115 } 116 throw tempException; 117 } 118 119 /** 120 * You can use this to set the <code>ConnectionMetaData</code>. 121 * Usually this should not be necessary. Per default an instance 122 * of {@link MockConnectionMetaData} is returned when calling 123 * {@link #getMetaData}. 124 * @param metaData the meta data 125 */ 126 public void setMetaData(ConnectionMetaData metaData) 127 { 128 this.metaData = metaData; 129 } 130 131 public Session createSession(boolean transacted, int acknowledgeMode) throws JMSException 132 { 133 throwJMSException(); 134 MockSession session = new MockSession(this, transacted, acknowledgeMode); 135 sessions().add(session); 136 return session; 137 } 138 139 public ConnectionConsumer createConnectionConsumer(Destination destination, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException 140 { 141 throwJMSException(); 142 return new MockConnectionConsumer(this, sessionPool); 143 } 144 145 public ConnectionConsumer createDurableConnectionConsumer(Topic topic, String subscriptionName, String messageSelector, ServerSessionPool sessionPool, int maxMessages) throws JMSException 146 { 147 return createConnectionConsumer(topic, messageSelector, sessionPool, maxMessages); 148 } 149 150 public ConnectionMetaData getMetaData() throws JMSException 151 { 152 throwJMSException(); 153 return metaData; 154 } 155 156 public String getClientID() throws JMSException 157 { 158 throwJMSException(); 159 return clientId; 160 } 161 162 public void setClientID(String clientId) throws JMSException 163 { 164 throwJMSException(); 165 this.clientId = clientId; 166 } 167 168 public ExceptionListener getExceptionListener() throws JMSException 169 { 170 throwJMSException(); 171 return listener; 172 } 173 174 public void setExceptionListener(ExceptionListener listener) throws JMSException 175 { 176 throwJMSException(); 177 this.listener = listener; 178 } 179 180 public void start() throws JMSException 181 { 182 throwJMSException(); 183 started = true; 184 } 185 186 public void stop() throws JMSException 187 { 188 throwJMSException(); 189 started = false; 190 } 191 192 public void close() throws JMSException 193 { 194 throwJMSException(); 195 for(int ii = 0; ii < sessions.size(); ii++) 196 { 197 Session session = (Session)sessions.get(ii); 198 session.close(); 199 } 200 closed = true; 201 } 202 203 public boolean isStarted() 204 { 205 return started; 206 } 207 208 public boolean isStopped() 209 { 210 return !isStarted(); 211 } 212 213 public boolean isClosed() 214 { 215 return closed; 216 } 217 218 protected List sessions() 219 { 220 return sessions; 221 } 222 }