View Javadoc

1   /*
2    * $Id: MulticastingRouterTestCase.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.MuleMessageCollection;
17  import org.mule.api.MuleSession;
18  import org.mule.api.endpoint.OutboundEndpoint;
19  import org.mule.api.processor.MessageProcessor;
20  import org.mule.routing.filters.RegExFilter;
21  import org.mule.tck.AbstractMuleTestCase;
22  import org.mule.tck.MuleTestUtils;
23  
24  import com.mockobjects.dynamic.Mock;
25  
26  import java.util.ArrayList;
27  import java.util.List;
28  
29  public class MulticastingRouterTestCase extends AbstractMuleTestCase
30  {
31      public MulticastingRouterTestCase()
32      {
33          setStartContext(true);
34      }
35  
36      public void testMulticastingRouterAsync() throws Exception
37      {
38          Mock session = MuleTestUtils.getMockSession();
39          session.matchAndReturn("getFlowConstruct", getTestService());
40          RegExFilter filter = new RegExFilter("(.*) Message");
41  
42          OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", "test://test1", null, filter, null);
43          assertNotNull(endpoint1);
44  
45          OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", "test://test2", null, filter, null);
46          assertNotNull(endpoint2);
47          Mock mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
48          Mock mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
49  
50          MulticastingRouter router = createObject(MulticastingRouter.class);
51  
52          List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
53          endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
54          endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
55          router.setRoutes(endpoints);
56  
57          MuleMessage message = new DefaultMuleMessage(TEST_MESSAGE, muleContext);
58  
59          assertTrue(router.isMatch(message));
60  
61          mockendpoint1.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
62          mockendpoint2.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
63          router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
64          mockendpoint1.verify();
65          mockendpoint2.verify();
66  
67      }
68  
69      public void testMulticastingRouterSync() throws Exception
70      {
71          Mock session = MuleTestUtils.getMockSession();
72          session.matchAndReturn("getFlowConstruct", getTestService());
73          session.matchAndReturn("setFlowConstruct", RouterTestUtils.getArgListCheckerFlowConstruct(), null);
74  
75          OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", 
76              "test://Test1Provider?exchangePattern=request-response");
77          assertNotNull(endpoint1);
78  
79          OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", 
80              "test://Test2Provider?exchangePattern=request-response");
81          assertNotNull(endpoint2);
82          Mock mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
83          Mock mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
84  
85          MulticastingRouter router = createObject(MulticastingRouter.class);
86          RegExFilter filter = new RegExFilter("(.*) Message");
87          router.setFilter(filter);
88          List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
89          endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
90          endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
91          router.setRoutes(endpoints);
92  
93          assertEquals(filter, router.getFilter());
94  
95          MuleMessage message = new DefaultMuleMessage(TEST_MESSAGE, muleContext);
96  
97          assertTrue(router.isMatch(message));
98  
99          MuleEvent event = new OutboundRoutingTestEvent(message, null);
100 
101         mockendpoint1.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
102         mockendpoint2.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
103         MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
104         assertNotNull(result);
105         MuleMessage resultMessage = result.getMessage();
106         assertNotNull(resultMessage);
107         assertTrue(resultMessage instanceof MuleMessageCollection);
108         assertEquals(2, ((MuleMessageCollection)resultMessage).size());
109         mockendpoint1.verify();
110         mockendpoint2.verify();
111     }
112 
113     public void testMulticastingRouterMixedSyncAsync() throws Exception
114     {
115         Mock session = MuleTestUtils.getMockSession();
116         session.matchAndReturn("getFlowConstruct", getTestService());
117         session.matchAndReturn("setFlowConstruct", RouterTestUtils.getArgListCheckerFlowConstruct(), null);
118 
119         OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", 
120             "test://Test1Provider?exchangePattern=request-response");
121         assertNotNull(endpoint1);
122 
123         OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", 
124             "test://Test2Provider?exchangePattern=request-response");
125         assertNotNull(endpoint2);
126 
127         Mock mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
128         Mock mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
129 
130         MulticastingRouter router = createObject(MulticastingRouter.class);
131         
132         List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
133         endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
134         endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
135         router.setRoutes(endpoints);
136 
137 
138         MuleMessage message = new DefaultMuleMessage(TEST_MESSAGE, muleContext);
139 
140         assertTrue(router.isMatch(message));
141         MuleEvent event = new OutboundRoutingTestEvent(message, null);
142 
143         mockendpoint1.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
144         mockendpoint2.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
145         MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
146         assertNotNull(result);
147         assertEquals(getPayload(message), getPayload(result.getMessage()));
148         mockendpoint1.verify();
149         mockendpoint2.verify();
150     }
151 
152     private String getPayload(MuleMessage message) throws Exception
153     {
154         Object payload = message.getPayload();
155         if (payload instanceof List)
156         {
157             payload = ((List<?>) payload).get(0);
158         }
159         return payload.toString();
160     }
161 }