View Javadoc

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