View Javadoc

1   /*
2    * $Id: OutboundMessageRouterTestCase.java 19191 2010-08-25 21:05:23Z tcarlson $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.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.outbound;
12  
13  import org.mule.DefaultMuleMessage;
14  import org.mule.api.MuleEvent;
15  import org.mule.api.MuleMessage;
16  import org.mule.api.MuleSession;
17  import org.mule.api.endpoint.OutboundEndpoint;
18  import org.mule.api.processor.MessageProcessor;
19  import org.mule.api.routing.MatchableMessageProcessor;
20  import org.mule.api.routing.RoutingException;
21  import org.mule.routing.AbstractCatchAllStrategy;
22  import org.mule.routing.LoggingCatchAllStrategy;
23  import org.mule.routing.filters.PayloadTypeFilter;
24  import org.mule.tck.AbstractMuleTestCase;
25  import org.mule.tck.MuleTestUtils;
26  
27  import com.mockobjects.dynamic.Mock;
28  
29  import java.util.ArrayList;
30  import java.util.List;
31  
32  public class OutboundMessageRouterTestCase extends AbstractMuleTestCase
33  {
34      public OutboundMessageRouterTestCase()
35      {
36          setStartContext(true);        
37      }
38  
39      public void testOutboundMessageRouter() throws Exception
40      {
41          Mock session = MuleTestUtils.getMockSession();
42          session.matchAndReturn("getFlowConstruct", getTestService());
43          
44          DefaultOutboundRouterCollection messageRouter = createObject(DefaultOutboundRouterCollection.class);
45          messageRouter.setCatchAllStrategy(new LoggingCatchAllStrategy());
46          assertNotNull(messageRouter.getCatchAllStrategy());
47  
48          OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", 
49              "test://Test1Provider?exchangePattern=one-way");
50          assertNotNull(endpoint1);
51  
52          OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider");
53          assertNotNull(endpoint2);
54  
55          Mock mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
56          Mock mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
57  
58          FilteringOutboundRouter router1 = new FilteringOutboundRouter();
59          PayloadTypeFilter filter = new PayloadTypeFilter(String.class);
60          router1.setFilter(filter);
61          List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
62          endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
63          router1.setRoutes(endpoints);
64  
65          FilteringOutboundRouter router2 = new FilteringOutboundRouter();
66          PayloadTypeFilter filter2 = new PayloadTypeFilter();
67          filter2.setExpectedType(Exception.class);
68          router2.setFilter(filter2);
69          endpoints = new ArrayList<MessageProcessor>();
70          endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
71          router2.setRoutes(endpoints);
72  
73          messageRouter.addRoute(router1);
74          assertEquals(1, messageRouter.getRoutes().size());
75          messageRouter.removeRoute(router1);
76          assertEquals(0, messageRouter.getRoutes().size());
77          
78          List<MatchableMessageProcessor> list = new ArrayList<MatchableMessageProcessor>();
79          list.add(router1);
80          list.add(router2);
81          messageRouter.setMessageProcessors(list);
82  
83          MuleEvent event = getTestInboundEvent("test event", (MuleSession) session.proxy());
84  
85          mockendpoint1.expect("process",RouterTestUtils.getArgListCheckerMuleEvent());
86          messageRouter.process(event);
87          mockendpoint1.verify();
88  
89          event = getTestInboundEvent(new IllegalArgumentException(), (MuleSession) session.proxy());
90          
91          session.expectAndReturn("getFlowConstruct", getTestService());
92          mockendpoint2.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
93          messageRouter.process(event);
94          mockendpoint2.verify();
95  
96          FilteringOutboundRouter router3 = new FilteringOutboundRouter();
97          router3.setFilter(new PayloadTypeFilter(Object.class));
98          endpoints = new ArrayList<MessageProcessor>();
99          endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
100         router3.setRoutes(endpoints);
101         messageRouter.addRoute(router3);
102 
103         // now the message should be routed twice to different targets
104         event = getTestInboundEvent("testing multiple routing", (MuleSession) session.proxy());
105         session.expectAndReturn("getFlowConstruct", getTestService());
106         session.expectAndReturn("getFlowConstruct", getTestService());
107 
108         mockendpoint1.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
109         mockendpoint2.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
110 
111         messageRouter.setMatchAll(true);
112         messageRouter.process(event);
113         mockendpoint1.verify();
114         mockendpoint2.verify();
115     }
116 
117     public void testRouterWithCatchAll() throws Exception
118     {
119         final int[] count1 = new int[]{0};
120         final int[] count2 = new int[]{0};
121         final int[] catchAllCount = new int[]{0};
122 
123         DefaultOutboundRouterCollection messageRouter = new DefaultOutboundRouterCollection();
124 
125         FilteringOutboundRouter filterRouter1 = new FilteringOutboundRouter()
126         {
127             @Override
128             public MuleEvent route(MuleEvent event)
129                 throws RoutingException
130             {
131                 count1[0]++;
132                 return event;
133             }
134         };
135 
136         FilteringOutboundRouter filterRouter2 = new FilteringOutboundRouter()
137         {
138             @Override
139             public MuleEvent route(MuleEvent event)
140                 throws RoutingException
141             {
142                 count2[0]++;
143                 return event;
144             }
145         };
146 
147         filterRouter1.setFilter(new PayloadTypeFilter(Exception.class));
148         filterRouter2.setFilter(new PayloadTypeFilter(StringBuffer.class));
149         messageRouter.addRoute(filterRouter1);
150         messageRouter.addRoute(filterRouter2);
151 
152         AbstractCatchAllStrategy strategy = new AbstractCatchAllStrategy()
153         {
154             @Override
155             public MuleEvent doCatchMessage(MuleEvent event) throws RoutingException
156             {
157                 catchAllCount[0]++;
158                 return null;
159             }
160         };
161 
162         messageRouter.setCatchAllStrategy(strategy);
163 
164         MuleSession session = getTestSession(getTestService(), muleContext);
165 
166         MuleEvent event = getTestInboundEvent("hello");
167         messageRouter.process(event);
168         assertEquals(1, catchAllCount[0]);
169         assertEquals(0, count1[0]);
170         assertEquals(0, count2[0]);
171 
172         event = getTestInboundEvent(new StringBuffer());
173         messageRouter.process(event);
174         assertEquals(1, catchAllCount[0]);
175         assertEquals(0, count1[0]);
176         assertEquals(1, count2[0]);
177 
178         event = getTestInboundEvent(new Exception());
179         messageRouter.process(event);
180         assertEquals(1, catchAllCount[0]);
181         assertEquals(1, count1[0]);
182         assertEquals(1, count2[0]);
183     }
184 
185     public void testCorrelation() throws Exception
186     {
187         FilteringOutboundRouter filterRouter = new FilteringOutboundRouter();
188         MuleSession session = getTestSession(getTestService(), muleContext);
189         MuleMessage message = new DefaultMuleMessage(new StringBuffer(), muleContext);
190         OutboundEndpoint endpoint = getTestOutboundEndpoint("test");
191         filterRouter.setMessageProperties(session.getFlowConstruct(), message, endpoint);
192         assertNotNull(message.getCorrelationId());
193     }
194 }