1
2
3
4
5
6
7
8
9
10
11 package org.mule.routing.outbound;
12
13 import org.mule.DefaultMuleMessage;
14 import org.mule.api.MuleException;
15 import org.mule.api.MuleMessage;
16 import org.mule.api.MuleSession;
17 import org.mule.api.endpoint.ImmutableEndpoint;
18 import org.mule.api.endpoint.OutboundEndpoint;
19 import org.mule.api.routing.CouldNotRouteOutboundMessageException;
20 import org.mule.api.routing.RoutingException;
21 import org.mule.message.DefaultExceptionPayload;
22 import org.mule.routing.LoggingCatchAllStrategy;
23 import org.mule.routing.filters.RegExFilter;
24 import org.mule.tck.AbstractMuleTestCase;
25 import org.mule.tck.MuleTestUtils;
26
27 import com.mockobjects.dynamic.C;
28 import com.mockobjects.dynamic.Mock;
29
30 import java.util.ArrayList;
31 import java.util.List;
32
33 public class ExceptionBasedRouterTestCase extends AbstractMuleTestCase
34 {
35
36
37
38
39
40 public void testSuccessfulExceptionRouter() throws Exception
41 {
42 Mock mockSession = MuleTestUtils.getMockSession();
43 mockSession.matchAndReturn("getService", getTestService());
44
45 DefaultOutboundRouterCollection messageRouter = new DefaultOutboundRouterCollection();
46 messageRouter.setCatchAllStrategy(new LoggingCatchAllStrategy());
47
48 ImmutableEndpoint endpoint1 = muleContext.getRegistry()
49 .lookupEndpointFactory()
50 .getOutboundEndpoint("test://Dummy1");
51
52 ImmutableEndpoint endpoint2 = muleContext.getRegistry()
53 .lookupEndpointFactory()
54 .getOutboundEndpoint("test://Dummy2");
55
56 ImmutableEndpoint endpoint3 = muleContext.getRegistry()
57 .lookupEndpointFactory()
58 .getOutboundEndpoint("test://Dummy3");
59
60 ExceptionBasedRouter router = new ExceptionBasedRouter();
61 RegExFilter filter = new RegExFilter("(.*) event");
62 router.setFilter(filter);
63 List endpoints = new ArrayList();
64 endpoints.add(endpoint1);
65 endpoints.add(endpoint2);
66 endpoints.add(endpoint3);
67 router.setEndpoints(endpoints);
68
69 assertEquals(filter, router.getFilter());
70
71 MuleMessage message = new DefaultMuleMessage("test event");
72
73 assertTrue(router.isMatch(message));
74
75 mockSession.expect("sendEvent", C.eq(message, endpoint1));
76 MuleMessage result = router.route(message, (MuleSession)mockSession.proxy(), false);
77 assertNull("Async call should've returned null.", result);
78 mockSession.verify();
79
80 message = new DefaultMuleMessage("test event");
81
82
83
84 mockSession.expectAndReturn("sendEvent", C.eq(message, endpoint1), message);
85 result = router.route(message, (MuleSession)mockSession.proxy(), true);
86 assertNotNull(result);
87 assertEquals(message, result);
88 mockSession.verify();
89 }
90
91
92
93
94
95 public void testBothFailing() throws Exception
96 {
97 Mock mockSession = MuleTestUtils.getMockSession();
98 mockSession.matchAndReturn("getService", getTestService());
99
100 ImmutableEndpoint endpoint1 = muleContext.getRegistry()
101 .lookupEndpointFactory()
102 .getOutboundEndpoint("test://AlwaysFail");
103
104 ImmutableEndpoint endpoint2 = muleContext.getRegistry()
105 .lookupEndpointFactory()
106 .getOutboundEndpoint("test://AlwaysFail");
107
108 ExceptionBasedRouter router = new ExceptionBasedRouter();
109 RegExFilter filter = new RegExFilter("(.*) event");
110 router.setFilter(filter);
111 List endpoints = new ArrayList();
112 endpoints.add(endpoint1);
113 endpoints.add(endpoint2);
114 router.setEndpoints(endpoints);
115
116 assertEquals(filter, router.getFilter());
117
118 MuleMessage message = new DefaultMuleMessage("test event");
119
120 assertTrue(router.isMatch(message));
121
122
123 MuleException rex = new RoutingException(message, endpoint1);
124 mockSession.expectAndThrow("sendEvent", C.args(C.eq(message), C.eq(endpoint1)), rex);
125 mockSession.expectAndThrow("dispatchEvent", C.args(C.eq(message), C.eq(endpoint2)), rex);
126 MuleSession session = (MuleSession)mockSession.proxy();
127 MuleMessage result = null;
128 try
129 {
130 result = router.route(message, session, false);
131 fail("Should have thrown exception as both endpoints would have failed");
132 }
133 catch (CouldNotRouteOutboundMessageException e)
134 {
135
136 }
137 assertNull("Async call should've returned null.", result);
138 mockSession.verify();
139
140 message = new DefaultMuleMessage("test event");
141
142 }
143
144
145
146
147
148 public void testFailFirstSuccessSecondSync() throws Exception
149 {
150 Mock mockSession = MuleTestUtils.getMockSession();
151 mockSession.matchAndReturn("getService", getTestService());
152
153 OutboundEndpoint endpoint1 = getTestOutboundEndpoint("TestFailEndpoint", "test://Failure");
154 OutboundEndpoint endpoint2 = getTestOutboundEndpoint("TestSuccessEndpoint", "test://Success");
155
156 ExceptionBasedRouter router = new ExceptionBasedRouter();
157 router.addEndpoint(endpoint1);
158 router.addEndpoint(endpoint2);
159
160 MuleMessage message = new DefaultMuleMessage("test event");
161 MuleMessage expectedResultMessage = new DefaultMuleMessage("Return event");
162
163 assertTrue(router.isMatch(message));
164
165 final MuleSession session = (MuleSession)mockSession.proxy();
166
167 MuleException rex = new RoutingException(message, endpoint1);
168
169 mockSession.expectAndThrow("sendEvent", C.args(C.eq(message), C.eq(endpoint1)), rex);
170
171 mockSession.expectAndReturn("sendEvent", C.args(C.eq(message), C.eq(endpoint2)),
172 expectedResultMessage);
173 MuleMessage actualResultMessage = router.route(message, session, true);
174 mockSession.verify();
175
176 assertEquals("Got an invalid return message.", expectedResultMessage, actualResultMessage);
177 }
178
179
180
181
182
183 public void testFailFirstSuccessSecondAsync() throws Exception
184 {
185 Mock mockSession = MuleTestUtils.getMockSession();
186 mockSession.matchAndReturn("getService", getTestService());
187
188 OutboundEndpoint endpoint1 = getTestOutboundEndpoint("TestFailEndpoint", "test://Failure");
189 OutboundEndpoint endpoint2 = getTestOutboundEndpoint("TestSuccessEndpoint", "test://Success");
190
191 ExceptionBasedRouter router = new ExceptionBasedRouter();
192 router.addEndpoint(endpoint1);
193 router.addEndpoint(endpoint2);
194
195 MuleMessage message = new DefaultMuleMessage("test event");
196 MuleMessage expectedResultMessage = new DefaultMuleMessage("Return event");
197
198 assertTrue(router.isMatch(message));
199
200 final MuleSession session = (MuleSession)mockSession.proxy();
201
202 MuleException rex = new RoutingException(message, endpoint1);
203
204 mockSession.expectAndThrow("sendEvent", C.args(C.eq(message), C.eq(endpoint1)), rex);
205
206 mockSession.expectAndReturn("dispatchEvent", C.args(C.eq(message), C.eq(endpoint2)),
207 expectedResultMessage);
208 MuleMessage actualResultMessage = router.route(message, session, false);
209 assertNull("Async call should not return any results.", actualResultMessage);
210 mockSession.verify();
211 }
212
213
214
215
216
217 public void testFirstHadExceptionPayloadSuccessSecondSyncWithExceptionPayload() throws Exception
218 {
219 Mock mockSession = MuleTestUtils.getMockSession();
220 mockSession.matchAndReturn("getService", getTestService());
221
222 OutboundEndpoint endpoint1 = getTestOutboundEndpoint("TestFailEndpoint", "test://Failure");
223 OutboundEndpoint endpoint2 = getTestOutboundEndpoint("TestSuccessEndpoint", "test://Success");
224
225 ExceptionBasedRouter router = new ExceptionBasedRouter();
226 router.addEndpoint(endpoint1);
227 router.addEndpoint(endpoint2);
228
229 MuleMessage message = new DefaultMuleMessage("test event");
230 MuleMessage expectedResultMessage = new DefaultMuleMessage("Return event");
231
232 assertTrue(router.isMatch(message));
233
234
235
236 MuleMessage exPayloadMessage = new DefaultMuleMessage("there was a failure");
237 exPayloadMessage.setExceptionPayload(new DefaultExceptionPayload(new RuntimeException()));
238
239 final MuleSession session = (MuleSession)mockSession.proxy();
240
241 mockSession.expectAndReturn("sendEvent", C.args(C.eq(message), C.eq(endpoint1)), exPayloadMessage);
242
243 mockSession.expectAndReturn("sendEvent", C.args(C.eq(message), C.eq(endpoint2)),
244 expectedResultMessage);
245 MuleMessage actualResultMessage = router.route(message, session, true);
246 mockSession.verify();
247
248 assertEquals("Got an invalid return message.", expectedResultMessage, actualResultMessage);
249 }
250 }