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