View Javadoc

1   /*
2    * $Id: SedaStageInterceptingMessageProcessorTestCase.java 23126 2011-10-07 01:06:45Z dfeist $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
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, // source
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                 // noop
118             }
119 
120             @Override
121             public void run()
122             {
123                 // noop
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 }