1
2
3
4
5
6
7
8
9
10
11 package org.mule.processor;
12
13 import static org.junit.Assert.assertEquals;
14 import static org.junit.Assert.assertNotNull;
15 import static org.junit.Assert.assertTrue;
16
17 import org.mule.api.MuleException;
18 import org.mule.api.MuleRuntimeException;
19 import org.mule.api.lifecycle.Initialisable;
20 import org.mule.api.lifecycle.InitialisationException;
21 import org.mule.api.lifecycle.Lifecycle;
22 import org.mule.api.lifecycle.LifecycleState;
23 import org.mule.api.lifecycle.Startable;
24 import org.mule.api.lifecycle.Stoppable;
25 import org.mule.api.processor.MessageProcessor;
26 import org.mule.config.QueueProfile;
27 import org.mule.management.stats.QueueStatistics;
28 import org.mule.service.Pausable;
29
30 import java.beans.ExceptionListener;
31 import java.util.concurrent.atomic.AtomicBoolean;
32
33 import javax.resource.spi.work.Work;
34 import javax.resource.spi.work.WorkEvent;
35 import javax.resource.spi.work.WorkException;
36
37 import org.junit.Test;
38
39 public class SedaStageInterceptingMessageProcessorTestCase extends AsyncInterceptingMessageProcessorTestCase
40 implements ExceptionListener
41 {
42 QueueProfile queueProfile = null;
43 int queueTimeout;
44 QueueStatistics queueStatistics;
45 TestLifeCycleState lifeCycleState;
46
47 @Override
48 protected void doSetUp() throws Exception
49 {
50 super.doSetUp();
51 queueProfile = QueueProfile.newInstancePersistingToDefaultMemoryQueueStore(muleContext);
52 queueStatistics = new TestQueueStatistics();
53 queueTimeout = muleContext.getConfiguration().getDefaultQueueTimeout();
54 lifeCycleState = new TestLifeCycleState();
55 super.doSetUp();
56 ((Initialisable) messageProcessor).initialise();
57 ((Startable) messageProcessor).start();
58 lifeCycleState.start();
59 }
60
61 @Override
62 protected boolean isStartContext()
63 {
64 return false;
65 }
66
67 @Override
68 protected void doTearDown() throws Exception
69 {
70 super.doTearDown();
71 ((Stoppable) messageProcessor).stop();
72 lifeCycleState.stop();
73 lifeCycleState.dispose();
74
75 }
76
77 @Override
78 protected AsyncInterceptingMessageProcessor createAsyncInterceptingMessageProcessor(MessageProcessor listener)
79 throws Exception
80 {
81 SedaStageInterceptingMessageProcessor mp = new SedaStageInterceptingMessageProcessor("name", "name",
82 queueProfile, queueTimeout, muleContext.getDefaultThreadingProfile(), queueStatistics,
83 muleContext);
84 mp.setListener(listener);
85 return mp;
86 }
87
88 @Test
89 public void testSpiWorkThrowableHandling() throws Exception
90 {
91 try
92 {
93 new AsyncWorkListener(getSensingNullMessageProcessor()).handleWorkException(getTestWorkEvent(),
94 "workRejected");
95 }
96 catch (MuleRuntimeException mrex)
97 {
98 assertNotNull(mrex);
99 assertTrue(mrex.getCause().getClass() == Throwable.class);
100 assertEquals("testThrowable", mrex.getCause().getMessage());
101 }
102 }
103
104 private WorkEvent getTestWorkEvent()
105 {
106 return new WorkEvent(this,
107 WorkEvent.WORK_REJECTED, getTestWork(), new WorkException(new Throwable("testThrowable")));
108 }
109
110 private Work getTestWork()
111 {
112 return new Work()
113 {
114 @Override
115 public void release()
116 {
117
118 }
119
120 @Override
121 public void run()
122 {
123
124 }
125 };
126 }
127
128 class TestQueueStatistics implements QueueStatistics
129 {
130 int incCount;
131 int decCount;
132
133 @Override
134 public void decQueuedEvent()
135 {
136 decCount++;
137 }
138
139 @Override
140 public void incQueuedEvent()
141 {
142 incCount++;
143 }
144
145 @Override
146 public boolean isEnabled()
147 {
148 return true;
149 }
150 }
151
152 class TestLifeCycleState implements LifecycleState, Lifecycle
153 {
154
155 AtomicBoolean started = new AtomicBoolean(false);
156 AtomicBoolean stopped = new AtomicBoolean(true);
157 AtomicBoolean disposed = new AtomicBoolean(false);
158 AtomicBoolean initialised = new AtomicBoolean(false);
159 AtomicBoolean paused = new AtomicBoolean(false);
160
161 @Override
162 public boolean isDisposed()
163 {
164 return disposed.get();
165 }
166
167 @Override
168 public boolean isDisposing()
169 {
170 return false;
171 }
172
173 @Override
174 public boolean isInitialised()
175 {
176 return initialised.get();
177 }
178
179 @Override
180 public boolean isInitialising()
181 {
182 return false;
183 }
184
185 @Override
186 public boolean isPhaseComplete(String phase)
187 {
188 if (Pausable.PHASE_NAME.equals(phase))
189 {
190 return paused.get();
191 }
192 else
193 {
194 return false;
195 }
196 }
197
198 @Override
199 public boolean isPhaseExecuting(String phase)
200 {
201 return false;
202 }
203
204 @Override
205 public boolean isStarted()
206 {
207 return started.get();
208 }
209
210 @Override
211 public boolean isStarting()
212 {
213 return false;
214 }
215
216 @Override
217 public boolean isStopped()
218 {
219 return stopped.get();
220 }
221
222 @Override
223 public boolean isStopping()
224 {
225 return false;
226 }
227
228 @Override
229 public void initialise() throws InitialisationException
230 {
231 initialised.set(true);
232 }
233
234 @Override
235 public void start() throws MuleException
236 {
237 initialised.set(false);
238 stopped.set(false);
239 started.set(true);
240 }
241
242 @Override
243 public void stop() throws MuleException
244 {
245 started.set(false);
246 stopped.set(true);
247 }
248
249 @Override
250 public void dispose()
251 {
252 stopped.set(true);
253 disposed.set(true);
254 }
255
256 @Override
257 public boolean isValidTransition(String phase)
258 {
259 return false;
260 }
261 }
262 }