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 org.mule.DefaultMuleMessage;
10  import org.mule.api.MuleEvent;
11  import org.mule.api.MuleMessage;
12  import org.mule.api.MuleSession;
13  import org.mule.api.endpoint.ImmutableEndpoint;
14  import org.mule.api.endpoint.OutboundEndpoint;
15  import org.mule.api.processor.MessageProcessor;
16  import org.mule.routing.LoggingCatchAllStrategy;
17  import org.mule.routing.filters.PayloadTypeFilter;
18  import org.mule.tck.MuleTestUtils;
19  import org.mule.tck.junit4.AbstractMuleContextTestCase;
20  import org.mule.tck.testmodels.fruit.Apple;
21  
22  import com.mockobjects.dynamic.Mock;
23  
24  import java.util.ArrayList;
25  import java.util.HashMap;
26  import java.util.List;
27  import java.util.Map;
28  
29  import org.junit.Test;
30  
31  import static org.junit.Assert.assertEquals;
32  import static org.junit.Assert.assertNotNull;
33  import static org.junit.Assert.assertNull;
34  import static org.junit.Assert.assertTrue;
35  
36  public class ChainingRouterTestCase extends AbstractMuleContextTestCase
37  {
38      public ChainingRouterTestCase()
39      {
40          setStartContext(true);
41      }
42  
43      private Mock session;
44      private ChainingRouter router;
45      private List<OutboundEndpoint> endpoints;
46      private Mock mockendpoint1;
47      private Mock mockendpoint2;
48      private Mock mockendpoint3;
49  
50      @Override
51      protected void doSetUp() throws Exception
52      {
53          super.doSetUp();
54          session = MuleTestUtils.getMockSession();
55          router = new ChainingRouter();
56          router.setMuleContext(muleContext);
57  
58          DefaultOutboundRouterCollection messageRouter = new DefaultOutboundRouterCollection();
59          messageRouter.setCatchAllStrategy(new LoggingCatchAllStrategy());
60  
61          OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", 
62              "test://test?exchangePattern=request-response");
63          assertNotNull(endpoint1);
64  
65          OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", 
66              "test://test?exchangePattern=request-response");
67          assertNotNull(endpoint2);
68  
69          mockendpoint1 = RouterTestUtils.getMockEndpoint(endpoint1);
70          mockendpoint2 = RouterTestUtils.getMockEndpoint(endpoint2);
71          PayloadTypeFilter filter = new PayloadTypeFilter(String.class);
72          router.setFilter(filter);
73          endpoints = new ArrayList<OutboundEndpoint>();
74          endpoints.add((OutboundEndpoint) mockendpoint1.proxy());
75          endpoints.add((OutboundEndpoint) mockendpoint2.proxy());
76          router.setRoutes(new ArrayList<MessageProcessor>(endpoints));
77  
78          assertEquals(filter, router.getFilter());
79          session.matchAndReturn("getFlowConstruct", getTestService("TEST", Apple.class));
80      }
81  
82      @Test
83      public void testChainingOutboundRouterSynchronous() throws Exception
84      {
85          MuleMessage message = new DefaultMuleMessage("test event", muleContext);
86          assertTrue(router.isMatch(message));
87  
88          MuleEvent event = new OutboundRoutingTestEvent(message, (MuleSession)session.proxy());
89  
90          mockendpoint1.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
91          mockendpoint2.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
92          final MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
93          assertNotNull("This is a sync call, we need a result returned.", result);
94          assertEquals(message, result.getMessage());
95          mockendpoint1.verify();
96          mockendpoint2.verify();
97      }
98  
99      @Test
100     public void testChainingOutboundRouterSynchronousWithTemplate() throws Exception
101     {
102         OutboundEndpoint endpoint3 = getTestOutboundEndpoint("Test3Provider", 
103             "test://foo?[barValue]&exchangePattern=request-response");
104         assertNotNull(endpoint3);
105         mockendpoint3 = RouterTestUtils.getMockEndpoint(endpoint3);
106         router.addRoute((OutboundEndpoint) mockendpoint3.proxy());
107 
108         Map<String, Object> m = new HashMap<String, Object>();
109         m.put("barValue", "bar");
110         MuleMessage message = new DefaultMuleMessage("test event", m, muleContext);
111         assertTrue(router.isMatch(message));
112         MuleEvent event = new OutboundRoutingTestEvent(message, (MuleSession)session.proxy());
113 
114         ImmutableEndpoint ep = (ImmutableEndpoint) router.getRoute(2, event);
115         assertEquals("test://foo?bar&exchangePattern=request-response", ep.getEndpointURI().toString());
116 
117         mockendpoint1.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
118         mockendpoint2.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
119         mockendpoint3.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
120         final MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
121         assertNotNull("This is a sync call, we need a result returned.", result);
122         assertEquals(message, result.getMessage());
123         mockendpoint1.verify();
124         mockendpoint2.verify();
125         mockendpoint3.verify();
126     }
127 
128     @Test
129     public void testChainingOutboundRouterAsynchronous() throws Exception
130     {
131         OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", "test://test");
132         assertNotNull(endpoint1);
133 
134         OutboundEndpoint endpoint2 = getTestOutboundEndpoint("Test2Provider", "test://test");
135         assertNotNull(endpoint2);
136 
137         Mock mep1 = RouterTestUtils.getMockEndpoint(endpoint1);
138         Mock mep2 = RouterTestUtils.getMockEndpoint(endpoint2);
139         endpoints.clear();
140         endpoints.add((OutboundEndpoint) mep1.proxy());
141         endpoints.add((OutboundEndpoint) mep2.proxy());
142         router.setRoutes(new ArrayList<MessageProcessor>(endpoints));
143         MuleMessage message = new DefaultMuleMessage("test event", muleContext);
144         assertTrue(router.isMatch(message));
145 
146         message = new DefaultMuleMessage("test event", muleContext);
147          MuleEvent event = new OutboundRoutingTestEvent(message, (MuleSession)session.proxy());
148 
149         mep1.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
150         mep2.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), null);
151         final MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
152         assertNull("Async call shouldn't return any result.", result);
153         mep1.verify();
154         mep2.verify();
155     }
156 
157     /**
158      * One of the targets returns null and breaks the chain
159      */
160     @Test
161     public void testBrokenChain() throws Exception
162     {
163         MuleMessage message = new DefaultMuleMessage("test event", muleContext);
164         OutboundEndpoint endpoint1 = endpoints.get(0);
165         mockendpoint1.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), null);
166         MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
167         mockendpoint1.verify();
168         assertNull(result);
169     }
170 }