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.OutboundEndpoint;
14  import org.mule.api.processor.MessageProcessor;
15  import org.mule.api.transformer.TransformerException;
16  import org.mule.routing.filters.PayloadTypeFilter;
17  import org.mule.tck.MuleTestUtils;
18  import org.mule.tck.junit4.AbstractMuleContextTestCase;
19  import org.mule.transformer.AbstractTransformer;
20  import org.mule.util.CollectionUtils;
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.assertNotSame;
34  import static org.junit.Assert.assertTrue;
35  
36  public class FilteringOutboundRouterTestCase extends AbstractMuleContextTestCase
37  {
38      public FilteringOutboundRouterTestCase()
39      {
40          setStartContext(true);
41      }
42  
43      @Test
44      public void testFilteringOutboundRouterAsync() throws Exception
45      {
46          Mock session = MuleTestUtils.getMockSession();
47          session.matchAndReturn("getFlowConstruct", getTestService());
48          
49          OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", 
50              "test://Test1Provider?exchangePattern=request-response");
51          assertNotNull(endpoint1);
52  
53          Mock mockEndpoint = RouterTestUtils.getMockEndpoint(endpoint1);
54          FilteringOutboundRouter router = new FilteringOutboundRouter();
55          PayloadTypeFilter filter = new PayloadTypeFilter(String.class);
56          router.setFilter(filter);
57          List<MessageProcessor> endpoints = new ArrayList<MessageProcessor>();
58          endpoints.add((OutboundEndpoint) mockEndpoint.proxy());
59          router.setRoutes(endpoints);
60  
61          // Default is now true
62          assertTrue(router.isUseTemplates());
63          assertEquals(filter, router.getFilter());
64  
65          MuleMessage message = new DefaultMuleMessage("test event", muleContext);
66  
67          assertTrue(router.isMatch(message));
68  
69          //session.expect("dispatchEvent", C.eq(message, endpoint1));
70          mockEndpoint.expect("process", RouterTestUtils.getArgListCheckerMuleEvent());
71          router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
72          mockEndpoint.verify();
73          //session.verify();
74  
75  
76          //Test with transform
77          message = new DefaultMuleMessage(new Exception("test event"), muleContext);
78  
79          assertTrue(!router.isMatch(message));
80  
81          router.setTransformers(
82              CollectionUtils.singletonList(
83                  new AbstractTransformer()
84                  {
85                      @Override
86                      public Object doTransform(Object src, String encoding) throws TransformerException
87                      {
88                          return ((Exception)src).getMessage();
89                      }
90                  }
91              )
92          );
93  
94          assertTrue(router.isMatch(message));
95      }
96  
97      @Test
98      public void testFilteringOutboundRouterSync() throws Exception
99      {
100         Mock session = MuleTestUtils.getMockSession();
101         session.matchAndReturn("getFlowConstruct", getTestService());
102 
103         OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", 
104             "test://Test1Provider?exchangePattern=request-response");
105         assertNotNull(endpoint1);
106         Mock mockEndpoint = RouterTestUtils.getMockEndpoint(endpoint1);
107         FilteringOutboundRouter router = new FilteringOutboundRouter();
108         PayloadTypeFilter filter = new PayloadTypeFilter(String.class);
109         router.setFilter(filter);
110         List<OutboundEndpoint> endpoints = new ArrayList<OutboundEndpoint>();
111         endpoints.add((OutboundEndpoint) mockEndpoint.proxy());
112         router.setRoutes(new ArrayList<MessageProcessor>(endpoints));
113 
114         // Default is now true
115         assertTrue(router.isUseTemplates());
116         assertEquals(filter, router.getFilter());
117 
118         MuleMessage message = new DefaultMuleMessage("test event", muleContext);
119         MuleEvent event = new OutboundRoutingTestEvent(message, null);
120         mockEndpoint.expectAndReturn("process", RouterTestUtils.getArgListCheckerMuleEvent(), event);
121         MuleEvent result = router.route(new OutboundRoutingTestEvent(message, (MuleSession)session.proxy()));
122         assertNotNull(result);
123         assertEquals(message, result.getMessage());
124         session.verify();
125     }
126 
127     @Test
128     public void testFilteringOutboundRouterWithTemplates() throws Exception
129     {
130         OutboundEndpoint endpoint1 = getTestOutboundEndpoint("Test1Provider", "test://foo?[barValue]");
131         assertNotNull(endpoint1);
132 
133         FilteringOutboundRouter router = new FilteringOutboundRouter();
134         router.setMuleContext(muleContext);
135         PayloadTypeFilter filter = new PayloadTypeFilter(String.class);
136         router.setFilter(filter);
137         List<OutboundEndpoint> endpoints = new ArrayList<OutboundEndpoint>();
138         endpoints.add(endpoint1);
139         router.setRoutes(new ArrayList<MessageProcessor>(endpoints));
140 
141         assertTrue(router.isUseTemplates());
142         assertEquals(filter, router.getFilter());
143 
144         Map<String, Object> m = new HashMap<String, Object>();
145         m.put("barValue", "bar");
146         MuleMessage message = new DefaultMuleMessage("test event", m, muleContext);
147         MuleEvent event = new OutboundRoutingTestEvent(message, null);
148 
149         assertTrue(router.isMatch(message));
150         OutboundEndpoint ep = (OutboundEndpoint) router.getRoute(0, event);
151         // MULE-2690: assert that templated targets are not mutated
152         assertNotSame(endpoint1, ep);
153         // assert that the returned endpoint has a resolved URI
154         assertEquals("test://foo?bar", ep.getEndpointURI().toString());
155     }
156 }