View Javadoc
1   /*
2    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
3    * The software in this package is published under the terms of the CPAL v1.0
4    * license, a copy of which has been included with this distribution in the
5    * LICENSE.txt file.
6    */
7   package org.mule.routing.outbound;
8   
9   import static junit.framework.Assert.assertTrue;
10  import static org.junit.Assert.assertEquals;
11  import static org.junit.Assert.assertNotNull;
12  
13  import org.mule.DefaultMuleMessage;
14  import org.mule.api.MuleEvent;
15  import org.mule.api.MuleMessage;
16  import org.mule.api.MuleMessageCollection;
17  import org.mule.api.MuleSession;
18  import org.mule.api.config.MuleProperties;
19  import org.mule.api.endpoint.OutboundEndpoint;
20  import org.mule.api.processor.MessageProcessor;
21  import org.mule.api.transport.PropertyScope;
22  import org.mule.routing.CorrelationMode;
23  import org.mule.routing.filters.RegExFilter;
24  import org.mule.tck.MuleTestUtils;
25  import org.mule.tck.junit4.AbstractMuleContextTestCase;
26  
27  import com.mockobjects.dynamic.ConstraintMatcher;
28  import com.mockobjects.dynamic.Mock;
29  
30  import java.util.ArrayList;
31  import java.util.List;
32  
33  import org.junit.Test;
34  
35  public class MulticastingRouterTestCase extends AbstractMuleContextTestCase
36  {
37      public MulticastingRouterTestCase()
38      {
39          setStartContext(true);
40      }
41  
42      @Test
43      public void testMulticastingRouterAsync() throws Exception
44      {
45          Mock session = MuleTestUtils.getMockSession();
46          session.matchAndReturn("getFlowConstruct", getTestService());
47          RegExFilter filter = new RegExFilter("(.*) Message");
48  
49          OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", "test://test1", null, filter, null);
50          assertNotNull(endpoint1);
51  
52          OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", "test://test2", null, filter, null);
53          assertNotNull(endpoint2);
54          Mock mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
55          Mock mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
56  
57          MulticastingRouter router = createObject(MulticastingRouter.class);
58  
59          List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
60          endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
61          endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
62          router.setRoutes(endpoints);
63  
64          MuleMessage message = new DefaultMuleMessage(TEST_MESSAGE, muleContext);
65  
66          assertTrue(router.isMatch(message));
67  
68          mockendpoint1.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
69          mockendpoint2.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
70          router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
71          mockendpoint1.verify();
72          mockendpoint2.verify();
73  
74      }
75  
76      @Test
77      public void testMulticastingRouterSync() throws Exception
78      {
79          Mock session = MuleTestUtils.getMockSession();
80          session.matchAndReturn("getFlowConstruct", getTestService());
81          session.matchAndReturn("setFlowConstruct", RouterTestUtils.getArgListCheckerFlowConstruct(), null);
82  
83          OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", 
84              "test://Test1Provider?exchangePattern=request-response");
85          assertNotNull(endpoint1);
86  
87          OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", 
88              "test://Test2Provider?exchangePattern=request-response");
89          assertNotNull(endpoint2);
90          Mock mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
91          Mock mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
92  
93          MulticastingRouter router = createObject(MulticastingRouter.class);
94          RegExFilter filter = new RegExFilter("(.*) Message");
95          router.setFilter(filter);
96          List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
97          endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
98          endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
99          router.setRoutes(endpoints);
100 
101         assertEquals(filter, router.getFilter());
102 
103         MuleMessage message = new DefaultMuleMessage(TEST_MESSAGE, muleContext);
104 
105         assertTrue(router.isMatch(message));
106 
107         MuleEvent event = new OutboundRoutingTestEvent(message, null);
108 
109         mockendpoint1.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
110         mockendpoint2.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
111         MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
112         assertNotNull(result);
113         MuleMessage resultMessage = result.getMessage();
114         assertNotNull(resultMessage);
115         assertTrue(resultMessage instanceof MuleMessageCollection);
116         assertEquals(2, ((MuleMessageCollection)resultMessage).size());
117         mockendpoint1.verify();
118         mockendpoint2.verify();
119     }
120 
121     @Test
122     public void testMulticastingRouterMixedSyncAsync() throws Exception
123     {
124         Mock session = MuleTestUtils.getMockSession();
125         session.matchAndReturn("getFlowConstruct", getTestService());
126         session.matchAndReturn("setFlowConstruct", RouterTestUtils.getArgListCheckerFlowConstruct(), null);
127 
128         OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", 
129             "test://Test1Provider?exchangePattern=request-response");
130         assertNotNull(endpoint1);
131 
132         OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", 
133             "test://Test2Provider?exchangePattern=request-response");
134         assertNotNull(endpoint2);
135 
136         Mock mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
137         Mock mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
138 
139         MulticastingRouter router = createObject(MulticastingRouter.class);
140         
141         List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
142         endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
143         endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
144         router.setRoutes(endpoints);
145 
146 
147         MuleMessage message = new DefaultMuleMessage(TEST_MESSAGE, muleContext);
148 
149         assertTrue(router.isMatch(message));
150         MuleEvent event = new OutboundRoutingTestEvent(message, null);
151 
152         mockendpoint1.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
153         mockendpoint2.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
154         MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
155         assertNotNull(result);
156         assertEquals(getPayload(message), getPayload(result.getMessage()));
157         mockendpoint1.verify();
158         mockendpoint2.verify();
159     }
160     
161     @Test
162     public void testMulticastingRouterCorrelationIdPropagation() throws Exception
163     {
164         Mock session = MuleTestUtils.getMockSession();
165         session.matchAndReturn("getFlowConstruct", getTestService());
166         RegExFilter filter = new RegExFilter("(.*) Message");
167 
168         OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", "test://test1", null, filter, null);
169         assertNotNull(endpoint1);
170 
171         OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", "test://test2", null, filter, null);
172         assertNotNull(endpoint2);
173         Mock mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
174         Mock mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
175 
176         MulticastingRouter router = createObject(MulticastingRouter.class);
177 
178         List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
179         endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
180         endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
181         router.setRoutes(endpoints);
182         router.setEnableCorrelation(CorrelationMode.NEVER);
183 
184         MuleMessage message = new DefaultMuleMessage(TEST_MESSAGE, muleContext);
185         message.setProperty(MuleProperties.MULE_CORRELATION_ID_PROPERTY, "MyCustomCorrelationId", PropertyScope.INBOUND);
186 
187         assertTrue(router.isMatch(message));
188         
189         ConstraintMatcher expectedCorrelationId = new ConstraintMatcher(){
190             public boolean matches(Object[] args)
191             {
192                 boolean argsMatch=args.length == 1 && args[0] instanceof MuleEvent;
193                 if(argsMatch)
194                 {
195                     MuleEvent event=(MuleEvent) args[0];
196                     String correlationId=event.getMessage().getOutboundProperty(MuleProperties.MULE_CORRELATION_ID_PROPERTY);
197                     return correlationId!=null && correlationId.equals("MyCustomCorrelationId");
198                 }
199                 return false;
200             }
201 
202             public Object[] getConstraints()
203             {
204                 return new String[] {"Outbound Correlation ID property should be set."};
205             }
206         };
207         mockendpoint1.expect("process", expectedCorrelationId);
208         mockendpoint2.expect("process", expectedCorrelationId);
209         router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
210         mockendpoint1.verify();
211         mockendpoint2.verify();
212 
213     }
214 
215 
216     private String getPayload(MuleMessage message) throws Exception
217     {
218         Object payload = message.getPayload();
219         if (payload instanceof List)
220         {
221             payload = ((List<?>) payload).get(0);
222         }
223         return payload.toString();
224     }
225 }