View Javadoc

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