View Javadoc

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