View Javadoc

1   /*
2    * $Id: FirstSuccessfulTestCase.java 22597 2011-08-05 20:40:24Z dfeist $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.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.routing;
12  
13  import static org.junit.Assert.assertEquals;
14  import static org.junit.Assert.assertNull;
15  import static org.junit.Assert.assertTrue;
16  import static org.junit.Assert.fail;
17  
18  import org.mule.DefaultMuleEvent;
19  import org.mule.DefaultMuleMessage;
20  import org.mule.MessageExchangePattern;
21  import org.mule.api.DefaultMuleException;
22  import org.mule.api.MuleEvent;
23  import org.mule.api.MuleException;
24  import org.mule.api.MuleMessage;
25  import org.mule.api.MuleSession;
26  import org.mule.api.processor.MessageProcessor;
27  import org.mule.api.routing.CouldNotRouteOutboundMessageException;
28  import org.mule.message.DefaultExceptionPayload;
29  import org.mule.tck.junit4.AbstractMuleContextTestCase;
30  import org.mule.transformer.simple.StringAppendTransformer;
31  
32  import java.util.Arrays;
33  import java.util.List;
34  
35  import org.junit.Test;
36  
37  public class FirstSuccessfulTestCase extends AbstractMuleContextTestCase
38  {
39      private static final String EXCEPTION_SEEN = "EXCEPTION WAS SEEN";
40  
41      public FirstSuccessfulTestCase()
42      {
43          setStartContext(true);
44      }
45  
46      @Test
47      public void testFirstSuccessful() throws Exception
48      {
49          MuleSession session = getTestSession(getTestService(), muleContext);
50  
51          FirstSuccessful fs = createFirstSuccessfulRouter(new TestProcessor("abc"),
52              new TestProcessor("def"), new TestProcessor("ghi"));
53          fs.initialise();
54  
55          assertEquals("No abc", getPayload(fs, session, ""));
56          assertEquals("No def", getPayload(fs, session, "abc"));
57          assertEquals("No ghi", getPayload(fs, session, "abcdef"));
58          assertEquals(EXCEPTION_SEEN, getPayload(fs, session, "abcdefghi"));
59          assertEquals("No def", getPayload(fs, session, "ABC"));
60          assertEquals("No ghi", getPayload(fs, session, "ABCDEF"));
61          assertEquals(EXCEPTION_SEEN, getPayload(fs, session, "ABCDEFGHI"));
62      }
63  
64      @Test
65      public void testFailureExpression() throws Exception
66      {
67          MessageProcessor intSetter = new MessageProcessor()
68          {
69              @Override
70              public MuleEvent process(MuleEvent event) throws MuleException
71              {
72                  event.getMessage().setPayload(Integer.valueOf(1));
73                  return event;
74              }
75          };
76  
77          FirstSuccessful fs = createFirstSuccessfulRouter(intSetter, new StringAppendTransformer("abc"));
78          fs.setFailureExpression("#[payload-type:java.lang.Integer]");
79          fs.initialise();
80  
81          assertEquals("abc", fs.process(getTestEvent("")).getMessageAsString());
82      }
83  
84      @Test
85      public void testRouteReturnsNullEvent() throws Exception
86      {
87          MessageProcessor nullReturningMp = new MessageProcessor()
88          {
89              @Override
90              public MuleEvent process(MuleEvent event) throws MuleException
91              {
92                  return null;
93              }
94          };
95          FirstSuccessful fs = createFirstSuccessfulRouter(nullReturningMp);
96          fs.initialise();
97  
98          assertNull(fs.process(getTestEvent("")));
99      }
100 
101     @Test
102     public void testRouteReturnsNullMessage() throws Exception
103     {
104         MessageProcessor nullEventMp = new MessageProcessor()
105         {
106             @Override
107             public MuleEvent process(MuleEvent event) throws MuleException
108             {
109                 return new DefaultMuleEvent(null, event);
110             }
111         };
112         FirstSuccessful fs = createFirstSuccessfulRouter(nullEventMp);
113         fs.initialise();
114 
115         try
116         {
117             fs.process(getTestEvent(""));
118             fail("Exception expected");
119         }
120         catch (CouldNotRouteOutboundMessageException e)
121         {
122             // this one was expected
123         }
124     }
125 
126     @Test
127     public void testProcessingIsForcedOnSameThread() throws Exception
128     {
129         MessageProcessor checkForceSyncFlag = new MessageProcessor()
130         {
131             @Override
132             public MuleEvent process(MuleEvent event) throws MuleException
133             {
134                 assertTrue(event.isSynchronous());
135                 return event;
136             }
137         };
138         FirstSuccessful router = createFirstSuccessfulRouter(checkForceSyncFlag);
139         router.initialise();
140 
141         // the configured message processor will blow up if the router did not force processing
142         // on same thread
143         router.process(getTestEvent(TEST_MESSAGE));
144     }
145 
146     private FirstSuccessful createFirstSuccessfulRouter(MessageProcessor... processors) throws MuleException
147     {
148         FirstSuccessful fs = new FirstSuccessful();
149         fs.setMuleContext(muleContext);
150 
151         List<MessageProcessor> routes = Arrays.asList(processors);
152         fs.setRoutes(routes);
153 
154         return fs;
155     }
156 
157     private String getPayload(MessageProcessor mp, MuleSession session, String message) throws Exception
158     {
159         MuleMessage msg = new DefaultMuleMessage(message, muleContext);
160         try
161         {
162             MuleEvent event = mp.process(new DefaultMuleEvent(msg, MessageExchangePattern.REQUEST_RESPONSE, session));
163             MuleMessage returnedMessage = event.getMessage();
164             if (returnedMessage.getExceptionPayload() != null)
165             {
166                 return EXCEPTION_SEEN;
167             }
168             else
169             {
170                 return returnedMessage.getPayloadAsString();
171             }
172         }
173         catch (Exception ex)
174         {
175             return EXCEPTION_SEEN;
176         }
177     }
178 
179     private static class TestProcessor implements MessageProcessor
180     {
181         private String rejectIfMatches;
182 
183         TestProcessor(String rejectIfMatches)
184         {
185             this.rejectIfMatches = rejectIfMatches;
186         }
187 
188         @Override
189         public MuleEvent process(MuleEvent event) throws MuleException
190         {
191             try
192             {
193                 DefaultMuleMessage msg;
194                 String payload = event.getMessage().getPayloadAsString();
195                 if (payload.indexOf(rejectIfMatches) >= 0)
196                 {
197                     throw new DefaultMuleException("Saw " + rejectIfMatches);
198                 }
199                 else if (payload.toLowerCase().indexOf(rejectIfMatches) >= 0)
200                 {
201                     msg = new DefaultMuleMessage(null, muleContext);
202                     msg.setExceptionPayload(new DefaultExceptionPayload(new Exception()));
203                 }
204                 else
205                 {
206                     msg = new DefaultMuleMessage("No " + rejectIfMatches, muleContext);
207                 }
208                 return new DefaultMuleEvent(msg, MessageExchangePattern.ONE_WAY, event.getSession());
209             }
210             catch (Exception e)
211             {
212                 throw new DefaultMuleException(e);
213             }
214         }
215     }
216 }