1   /*
2    * $Id: OutboundMessageRouterTestCase.java 12181 2008-06-26 20:05:55Z dirk.olmes $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.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.MuleMessage;
15  import org.mule.api.MuleSession;
16  import org.mule.api.endpoint.ImmutableEndpoint;
17  import org.mule.api.endpoint.OutboundEndpoint;
18  import org.mule.api.routing.RoutingException;
19  import org.mule.routing.LoggingCatchAllStrategy;
20  import org.mule.routing.filters.PayloadTypeFilter;
21  import org.mule.tck.AbstractMuleTestCase;
22  import org.mule.tck.MuleTestUtils;
23  import org.mule.transport.DefaultMessageAdapter;
24  
25  import com.mockobjects.dynamic.C;
26  import com.mockobjects.dynamic.Mock;
27  
28  import java.util.ArrayList;
29  import java.util.List;
30  
31  public class OutboundMessageRouterTestCase extends AbstractMuleTestCase
32  {
33      public void testOutboundMessageRouter() throws Exception
34      {
35          Mock session = MuleTestUtils.getMockSession();
36          session.matchAndReturn("getService", getTestService());
37          
38          DefaultOutboundRouterCollection messageRouter = new DefaultOutboundRouterCollection();
39          messageRouter.setCatchAllStrategy(new LoggingCatchAllStrategy());
40          assertNotNull(messageRouter.getCatchAllStrategy());
41  
42          ImmutableEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider");
43          assertNotNull(endpoint1);
44  
45          ImmutableEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider");
46          assertNotNull(endpoint2);
47  
48          FilteringOutboundRouter router1 = new FilteringOutboundRouter();
49          PayloadTypeFilter filter = new PayloadTypeFilter(String.class);
50          router1.setFilter(filter);
51          List endpoints = new ArrayList();
52          endpoints.add(endpoint1);
53          router1.setEndpoints(endpoints);
54  
55          FilteringOutboundRouter router2 = new FilteringOutboundRouter();
56          PayloadTypeFilter filter2 = new PayloadTypeFilter();
57          filter2.setExpectedType(Exception.class);
58          router2.setFilter(filter2);
59          endpoints = new ArrayList();
60          endpoints.add(endpoint2);
61          router2.setEndpoints(endpoints);
62  
63          messageRouter.addRouter(router1);
64          assertEquals(1, messageRouter.getRouters().size());
65          assertNotNull(messageRouter.removeRouter(router1));
66          assertEquals(0, messageRouter.getRouters().size());
67          List list = new ArrayList();
68          list.add(router1);
69          list.add(router2);
70          messageRouter.setRouters(list);
71  
72          MuleMessage message = new DefaultMuleMessage("test event");
73  
74          session.expect("dispatchEvent", C.eq(message, endpoint1));
75          messageRouter.route(message, (MuleSession)session.proxy(), false);
76          session.verify();
77  
78          message = new DefaultMuleMessage(new IllegalArgumentException());
79  
80          session.expectAndReturn("getService", getTestService());
81          session.expect("dispatchEvent", C.eq(message, endpoint2));
82          messageRouter.route(message, (MuleSession)session.proxy(), false);
83          session.verify();
84  
85          FilteringOutboundRouter router3 = new FilteringOutboundRouter();
86          router3.setFilter(new PayloadTypeFilter(Object.class));
87          endpoints = new ArrayList();
88          endpoints.add(endpoint2);
89          router3.setEndpoints(endpoints);
90          messageRouter.addRouter(router3);
91  
92          // now the message should be routed twice to different endpoints
93          message = new DefaultMuleMessage("testing multiple routing");
94          session.expectAndReturn("getService", getTestService());
95          session.expectAndReturn("getService", getTestService());
96  
97          session.expect("dispatchEvent", C.eq(message, endpoint1));
98          session.expect("dispatchEvent", C.eq(message, endpoint2));
99          messageRouter.setMatchAll(true);
100         messageRouter.route(message, (MuleSession)session.proxy(), false);
101         session.verify();
102     }
103 
104     public void testRouterWithCatchAll() throws Exception
105     {
106         final int[] count1 = new int[]{0};
107         final int[] count2 = new int[]{0};
108         final int[] catchAllCount = new int[]{0};
109 
110         DefaultOutboundRouterCollection messageRouter = new DefaultOutboundRouterCollection();
111 
112         FilteringOutboundRouter filterRouter1 = new FilteringOutboundRouter()
113         {
114             public MuleMessage route(MuleMessage message, MuleSession session, boolean synchronous)
115                 throws RoutingException
116             {
117                 count1[0]++;
118                 return message;
119             }
120         };
121 
122         FilteringOutboundRouter filterRouter2 = new FilteringOutboundRouter()
123         {
124             public MuleMessage route(MuleMessage message, MuleSession session, boolean synchronous)
125                 throws RoutingException
126             {
127                 count2[0]++;
128                 return message;
129             }
130         };
131 
132         filterRouter1.setFilter(new PayloadTypeFilter(Exception.class));
133         filterRouter2.setFilter(new PayloadTypeFilter(StringBuffer.class));
134         messageRouter.addRouter(filterRouter1);
135         messageRouter.addRouter(filterRouter2);
136 
137         LoggingCatchAllStrategy strategy = new LoggingCatchAllStrategy()
138         {
139             public MuleMessage catchMessage(MuleMessage message, MuleSession session, boolean synchronous)
140                 throws RoutingException
141             {
142                 catchAllCount[0]++;
143                 return null;
144             }
145         };
146 
147         messageRouter.setCatchAllStrategy(strategy);
148 
149         MuleSession session = getTestSession(getTestService(), muleContext);
150 
151         messageRouter.route(new DefaultMuleMessage("hello"), session, true);
152         assertEquals(1, catchAllCount[0]);
153         assertEquals(0, count1[0]);
154         assertEquals(0, count2[0]);
155 
156         messageRouter.route(new DefaultMuleMessage(new StringBuffer()), session, true);
157         assertEquals(1, catchAllCount[0]);
158         assertEquals(0, count1[0]);
159         assertEquals(1, count2[0]);
160 
161         messageRouter.route(new DefaultMuleMessage(new Exception()), session, true);
162         assertEquals(1, catchAllCount[0]);
163         assertEquals(1, count1[0]);
164         assertEquals(1, count2[0]);
165     }
166 
167     public void testCorrelation() throws Exception
168     {
169         FilteringOutboundRouter filterRouter = new FilteringOutboundRouter();
170         MuleSession session = getTestSession(getTestService(), muleContext);
171         MuleMessage message = new DefaultMuleMessage(new DefaultMessageAdapter(new StringBuffer()));
172         OutboundEndpoint endpoint = getTestOutboundEndpoint("test");
173         filterRouter.setMessageProperties(session, message, endpoint);
174         assertNotNull(message.getCorrelationId());
175     }
176 }