View Javadoc

1   /*
2    * $Id: RequestContextTestCase.java 22597 2011-08-05 20:40:24Z 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.registry;
12  
13  import static org.junit.Assert.assertEquals;
14  import static org.mockito.Mockito.mock;
15  
16  import org.mule.DefaultMuleMessage;
17  import org.mule.MessageExchangePattern;
18  import org.mule.OptimizedRequestContext;
19  import org.mule.RequestContext;
20  import org.mule.api.MuleContext;
21  import org.mule.api.MuleEvent;
22  import org.mule.api.MuleException;
23  import org.mule.api.MuleMessage;
24  import org.mule.api.MuleSession;
25  import org.mule.api.ThreadSafeAccess;
26  import org.mule.api.construct.FlowConstruct;
27  import org.mule.api.security.Credentials;
28  import org.mule.api.transformer.DataType;
29  import org.mule.api.transformer.TransformerException;
30  import org.mule.api.transport.ReplyToHandler;
31  import org.mule.management.stats.ProcessingTime;
32  import org.mule.message.DefaultExceptionPayload;
33  import org.mule.tck.junit4.AbstractMuleTestCase;
34  
35  import java.io.OutputStream;
36  import java.net.URI;
37  import java.util.concurrent.atomic.AtomicBoolean;
38  
39  import org.junit.Test;
40  
41  public class RequestContextTestCase extends AbstractMuleTestCase
42  {
43  
44      private boolean threadSafeEvent;
45      private MuleContext muleContext = mock(MuleContext.class);
46  
47      @Test
48      public void testSetExceptionPayloadAcrossThreads() throws InterruptedException
49      {
50          threadSafeEvent = true;
51          MuleEvent event = new DummyEvent();
52          runThread(event, false);
53          runThread(event, true);
54      }
55  
56      @Test
57      public void testFailureWithoutThreadSafeEvent() throws InterruptedException
58      {
59          threadSafeEvent = false;
60          MuleEvent event = new DummyEvent();
61          runThread(event, false);
62          runThread(event, true);
63      }
64  
65      protected void runThread(MuleEvent event, boolean doTest) throws InterruptedException
66      {
67          AtomicBoolean success = new AtomicBoolean(false);
68          Thread thread = new Thread(new SetExceptionPayload(event, success));
69          thread.start();
70          thread.join();
71          if (doTest)
72          {
73              assertEquals(threadSafeEvent, success.get());
74          }
75      }
76  
77      private class SetExceptionPayload implements Runnable
78      {
79  
80          private MuleEvent event;
81          private AtomicBoolean success;
82  
83          public SetExceptionPayload(MuleEvent event, AtomicBoolean success)
84          {
85              this.event = event;
86              this.success = success;
87          }
88  
89          @Override
90          public void run()
91          {
92              try
93              {
94                  OptimizedRequestContext.unsafeSetEvent(event);
95                  RequestContext.setExceptionPayload(new DefaultExceptionPayload(new Exception()));
96                  success.set(true);
97              }
98              catch (RuntimeException e)
99              {
100                 logger.error("error in thread", e);
101             }
102         }
103 
104     }
105 
106     private class DummyEvent implements MuleEvent, ThreadSafeAccess
107     {
108 
109         private MuleMessage message = new DefaultMuleMessage(null, muleContext);
110 
111         @Override
112         public MuleMessage getMessage()
113         {
114             return message;
115         }
116 
117         @Override
118         public Credentials getCredentials()
119         {
120             return null;
121         }
122 
123         @Override
124         public byte[] getMessageAsBytes() throws MuleException
125         {
126             return new byte[0];
127         }
128 
129         @Override
130         public Object transformMessage() throws TransformerException
131         {
132             return null;
133         }
134 
135         @Override
136         public Object transformMessage(Class outputType) throws TransformerException
137         {
138             return null;
139         }
140 
141         @Override
142         @Deprecated
143         public byte[] transformMessageToBytes() throws TransformerException
144         {
145             return new byte[0];
146         }
147 
148         @Override
149         public String transformMessageToString() throws TransformerException
150         {
151             return null;
152         }
153 
154         @Override
155         public String getMessageAsString() throws MuleException
156         {
157             return null;
158         }
159 
160         @Override
161         public <T> T transformMessage(DataType<T> outputType) throws TransformerException
162         {
163             return null;
164         }
165 
166         @Override
167         public String getMessageAsString(String encoding) throws MuleException
168         {
169             return null;
170         }
171 
172         @Override
173         public String getId()
174         {
175             return null;
176         }
177 
178         @Override
179         public Object getProperty(String key)
180         {
181             return null;
182         }
183 
184         @Override
185         public Object getProperty(String key, Object defaultValue)
186         {
187             return null;
188         }
189 
190         @Override
191         public MuleSession getSession()
192         {
193             return null;
194         }
195 
196         @Override
197         public FlowConstruct getFlowConstruct()
198         {
199             return null;
200         }
201 
202         @Override
203         public boolean isStopFurtherProcessing()
204         {
205             return false;
206         }
207 
208         @Override
209         public void setStopFurtherProcessing(boolean stopFurtherProcessing)
210         {
211             // no action
212         }
213 
214         @Override
215         public int getTimeout()
216         {
217             return 0;
218         }
219 
220         @Override
221         public void setTimeout(int timeout)
222         {
223             // no action
224         }
225 
226         @Override
227         public OutputStream getOutputStream()
228         {
229             return null;
230         }
231 
232         @Override
233         public String getEncoding()
234         {
235             return null;
236         }
237 
238         @Override
239         public MuleContext getMuleContext()
240         {
241             return null;
242         }
243 
244         @Override
245         public void assertAccess(boolean write)
246         {
247             // no action
248         }
249 
250         @Override
251         public void resetAccessControl()
252         {
253             // no action
254         }
255 
256         @Override
257         public ThreadSafeAccess newThreadCopy()
258         {
259             if (threadSafeEvent)
260             {
261                 return new DummyEvent();
262             }
263             else
264             {
265                 return this;
266             }
267         }
268 
269         @Override
270         public ProcessingTime getProcessingTime()
271         {
272             return null;
273         }
274 
275         @Override
276         public MessageExchangePattern getExchangePattern()
277         {
278             return null;
279         }
280         
281         @Override
282         public boolean isTransacted()
283         {
284             return false;
285         }
286 
287         @Override
288         public URI getMessageSourceURI()
289         {
290             return URI.create("test://test");
291         }
292         
293         @Override
294         public String getMessageSourceName()
295         {
296             return "test";
297         }
298         
299         @Override
300         public ReplyToHandler getReplyToHandler()
301         {
302             return null;
303         }
304 
305         @Override
306         public Object getReplyToDestination()
307         {
308             return null;
309         }
310 
311         @Override
312         public void captureReplyToDestination()
313         {
314         }
315         
316         @Override
317         public boolean isSynchronous()
318         {
319             return false;
320         }
321     }
322 
323 }