View Javadoc

1   /*
2    * $Id: MulticastingRouterTestCase.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.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.MuleTestUtils;
22  import org.mule.tck.junit4.AbstractMuleContextTestCase;
23  
24  import com.mockobjects.dynamic.Mock;
25  
26  import java.util.ArrayList;
27  import java.util.List;
28  
29  import org.junit.Test;
30  
31  import static junit.framework.Assert.assertTrue;
32  import static org.junit.Assert.assertEquals;
33  import static org.junit.Assert.assertNotNull;
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(), muleContext));
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, muleContext);
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(), muleContext));
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, muleContext);
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(), muleContext));
155         assertNotNull(result);
156         assertEquals(getPayload(message), getPayload(result.getMessage()));
157         mockendpoint1.verify();
158         mockendpoint2.verify();
159     }
160 
161     private String getPayload(MuleMessage message) throws Exception
162     {
163         Object payload = message.getPayload();
164         if (payload instanceof List)
165         {
166             payload = ((List<?>) payload).get(0);
167         }
168         return payload.toString();
169     }
170 }