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