View Javadoc

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