View Javadoc

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