1
2
3
4
5
6
7
8
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
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
142
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 }