View Javadoc

1   /*
2    * $Id: MuleEndpointConfigurationTestCase.java 22551 2011-07-25 06:32:00Z 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.test.integration;
12  
13  import org.mule.DefaultMuleEvent;
14  import org.mule.DefaultMuleMessage;
15  import org.mule.MessageExchangePattern;
16  import org.mule.api.MuleEvent;
17  import org.mule.api.endpoint.ImmutableEndpoint;
18  import org.mule.api.endpoint.InboundEndpoint;
19  import org.mule.api.endpoint.OutboundEndpoint;
20  import org.mule.api.processor.MessageProcessor;
21  import org.mule.api.routing.OutboundRouter;
22  import org.mule.api.routing.OutboundRouterCollection;
23  import org.mule.api.service.Service;
24  import org.mule.construct.Flow;
25  import org.mule.endpoint.DefaultInboundEndpoint;
26  import org.mule.module.xml.transformer.ObjectToXml;
27  import org.mule.service.ServiceCompositeMessageSource;
28  import org.mule.tck.AbstractServiceAndFlowTestCase;
29  import org.mule.tck.MuleTestUtils;
30  import org.mule.transport.tcp.TcpConnector;
31  import org.mule.transport.vm.VMConnector;
32  
33  import java.util.Arrays;
34  import java.util.Collection;
35  import java.util.List;
36  
37  import org.junit.Test;
38  import org.junit.runners.Parameterized.Parameters;
39  
40  import static org.junit.Assert.assertEquals;
41  import static org.junit.Assert.assertFalse;
42  import static org.junit.Assert.assertNotNull;
43  import static org.junit.Assert.assertTrue;
44  import static org.junit.Assert.fail;
45  
46  /**
47   * Test the creation of various targets from the service descriptor
48   */
49  public class MuleEndpointConfigurationTestCase extends AbstractServiceAndFlowTestCase
50  {
51      @Parameters
52      public static Collection<Object[]> parameters()
53      {
54          return Arrays.asList(new Object[][]{
55              {ConfigVariant.SERVICE, "org/mule/test/integration/test-endpoints-config-service.xml"},
56              {ConfigVariant.FLOW, "org/mule/test/integration/test-endpoints-config-flow.xml"}});
57      }
58  
59      public MuleEndpointConfigurationTestCase(ConfigVariant variant, String configResources)
60      {
61          super(variant, configResources);
62      }
63  
64      @Test
65      public void testComponent3RouterEndpoints() throws Exception
66      {
67          Object serviceFlow = muleContext.getRegistry().lookupObject("TestComponent3");
68  
69          if (serviceFlow instanceof Service)
70          {
71              assertNotNull(serviceFlow);
72              OutboundRouterCollection outboundRouter = (OutboundRouterCollection) ((Service) serviceFlow).getOutboundMessageProcessor();
73              assertNotNull(outboundRouter);
74              assertEquals(2, outboundRouter.getRoutes().size());
75              // first Router
76              OutboundRouter router1 = (OutboundRouter) outboundRouter.getRoutes().get(0);
77              assertEquals(1, router1.getRoutes().size());
78              ImmutableEndpoint endpoint = (ImmutableEndpoint) router1.getRoutes().get(0);
79              assertEquals("tcp", endpoint.getConnector().getProtocol().toLowerCase());
80              assertEquals("tcp://localhost:60201", endpoint.getEndpointURI().getAddress());
81              assertTrue(endpoint instanceof OutboundEndpoint);
82  
83              // second Router
84              OutboundRouter router2 = (OutboundRouter) outboundRouter.getRoutes().get(1);
85              assertEquals(2, router2.getRoutes().size());
86              endpoint = (ImmutableEndpoint) router2.getRoutes().get(0);
87              assertEquals("udp", endpoint.getConnector().getProtocol().toLowerCase());
88              assertEquals("udp://localhost:56731", endpoint.getEndpointURI().getAddress());
89              assertTrue(endpoint instanceof OutboundEndpoint);
90              endpoint = (ImmutableEndpoint) router2.getRoutes().get(1);
91              assertEquals("test", endpoint.getConnector().getProtocol().toLowerCase());
92              assertEquals("test.queue2", endpoint.getEndpointURI().getAddress());
93              assertTrue(endpoint instanceof OutboundEndpoint);
94  
95          }
96          else if (serviceFlow instanceof Flow)
97          {
98              assertNotNull(serviceFlow);
99              List<MessageProcessor> messageProcessors = ((Flow) serviceFlow).getMessageProcessors();
100 
101             assertNotNull(messageProcessors);
102             assertEquals(2, messageProcessors.size());
103 
104             // <all> Router
105             OutboundRouter allRouter = (OutboundRouter) messageProcessors.get(1);
106             assertEquals(3, allRouter.getRoutes().size());
107             ImmutableEndpoint endpoint = (ImmutableEndpoint) allRouter.getRoutes().get(0);
108             assertEquals("tcp", endpoint.getConnector().getProtocol().toLowerCase());
109             assertEquals("tcp://localhost:60201", endpoint.getEndpointURI().getAddress());
110             assertTrue(endpoint instanceof OutboundEndpoint);
111 
112             endpoint = (ImmutableEndpoint) allRouter.getRoutes().get(1);
113             assertEquals("udp", endpoint.getConnector().getProtocol().toLowerCase());
114             assertEquals("udp://localhost:56731", endpoint.getEndpointURI().getAddress());
115             assertTrue(endpoint instanceof OutboundEndpoint);
116 
117             endpoint = (ImmutableEndpoint) allRouter.getRoutes().get(2);
118             assertEquals("test", endpoint.getConnector().getProtocol().toLowerCase());
119             assertEquals("test.queue2", endpoint.getEndpointURI().getAddress());
120             assertTrue(endpoint instanceof OutboundEndpoint);
121 
122         }
123         else
124         {
125             fail("Unexpected Object");
126         }
127     }
128 
129     @Test
130     public void testComponent4InboundEndpoint() throws Exception
131     {
132         Object serviceFlow = muleContext.getRegistry().lookupObject("TestComponent4");
133 
134         if (serviceFlow instanceof Service)
135         {
136             assertNotNull(serviceFlow);
137             assertNotNull(((ServiceCompositeMessageSource) ((Service) serviceFlow).getMessageSource()).getEndpoints());
138             assertEquals(1,
139                 ((ServiceCompositeMessageSource) ((Service) serviceFlow).getMessageSource()).getEndpoints()
140                     .size());
141             ImmutableEndpoint endpoint = ((ServiceCompositeMessageSource) ((Service) serviceFlow).getMessageSource()).getEndpoints()
142                 .get(0);
143             assertNotNull(endpoint);
144             assertEquals(VMConnector.VM, endpoint.getConnector().getProtocol().toLowerCase());
145             assertEquals("queue4", endpoint.getEndpointURI().getAddress());
146             assertFalse(endpoint.getTransformers().isEmpty());
147             assertTrue(endpoint.getTransformers().get(0) instanceof ObjectToXml);
148             assertTrue(endpoint instanceof InboundEndpoint);
149         }
150         else if (serviceFlow instanceof Flow)
151         {
152             assertNotNull(serviceFlow);
153             assertNotNull(((Flow) serviceFlow).getMessageSource());
154             assertEquals(2,
155                 ((DefaultInboundEndpoint) ((Flow) serviceFlow).getMessageSource()).getMessageProcessors()
156                     .size());
157             ImmutableEndpoint endpoint = ((DefaultInboundEndpoint) ((Flow) serviceFlow).getMessageSource());
158             assertNotNull(endpoint);
159             assertEquals(VMConnector.VM, endpoint.getConnector().getProtocol().toLowerCase());
160             assertEquals("queue4", endpoint.getEndpointURI().getAddress());
161             assertFalse(endpoint.getTransformers().isEmpty());
162             assertTrue(endpoint.getTransformers().get(0) instanceof ObjectToXml);
163             assertTrue(endpoint instanceof InboundEndpoint);
164         }
165         else
166         {
167             fail("Unexpected Object");
168         }
169     }
170 
171     @Test
172     public void testComponent4OutboundEndpoint() throws Exception
173     {
174         Object serviceFlow = muleContext.getRegistry().lookupObject("TestComponent4");
175         if (serviceFlow instanceof Service)
176         {
177             assertNotNull(serviceFlow);
178             OutboundRouterCollection outboundRouter = (OutboundRouterCollection) ((Service) serviceFlow).getOutboundMessageProcessor();
179             assertNotNull(outboundRouter);
180             assertEquals(1, outboundRouter.getRoutes().size());
181             // first Router
182             OutboundRouter router = (OutboundRouter) outboundRouter.getRoutes().get(0);
183             assertEquals(1, router.getRoutes().size());
184             ImmutableEndpoint endpoint = (ImmutableEndpoint) router.getRoutes().get(0);
185             assertEquals("udp", endpoint.getConnector().getProtocol().toLowerCase());
186             assertEquals("udp://localhost:56731", endpoint.getEndpointURI().getAddress());
187             // cannot get this to work and get axis tests to work
188             // (axis seems to use undefined transformers in some strange way)
189             // assertTrue(TransformerUtils.isDefined(endpoint.getTransformers()));
190             assertTrue(endpoint instanceof OutboundEndpoint);
191         }
192         else if (serviceFlow instanceof Flow)
193         {
194             assertNotNull(serviceFlow);
195             List<MessageProcessor> messageProcessors = ((Flow) serviceFlow).getMessageProcessors();
196             assertNotNull(messageProcessors);
197 
198             ImmutableEndpoint endpoint = (ImmutableEndpoint) messageProcessors.get(1);
199             assertEquals("udp", endpoint.getConnector().getProtocol().toLowerCase());
200             assertEquals("udp://localhost:56731", endpoint.getEndpointURI().getAddress());
201             // cannot get this to work and get axis tests to work
202             // (axis seems to use undefined transformers in some strange way)
203             // assertTrue(TransformerUtils.isDefined(endpoint.getTransformers()));
204             assertTrue(endpoint instanceof OutboundEndpoint);
205         }
206         else
207         {
208             fail("Unexpected Object");
209         }
210     }
211 
212     @Test
213     public void testComponent5RouterEndpoints() throws Exception
214     {
215         Object serviceFlow = muleContext.getRegistry().lookupObject("TestComponent5");
216         if (serviceFlow instanceof Service)
217         {
218             assertNotNull(serviceFlow);
219             OutboundRouterCollection outboundRouter = (OutboundRouterCollection) ((Service) serviceFlow).getOutboundMessageProcessor();
220             assertNotNull(outboundRouter);
221             assertEquals(1, outboundRouter.getRoutes().size());
222             // first Router
223             OutboundRouter router = (OutboundRouter) outboundRouter.getRoutes().get(0);
224             assertEquals(1, router.getRoutes().size());
225             ImmutableEndpoint endpoint = (ImmutableEndpoint) router.getRoutes().get(0);
226             assertEquals(TcpConnector.TCP, endpoint.getConnector().getProtocol().toLowerCase());
227             assertEquals("tcp://localhost:45431", endpoint.getEndpointURI().getAddress());
228             // cannot get this to work and get axis tests to work
229             // (axis seems to use undefined transformers in some strange way)
230             // assertTrue(TransformerUtils.isDefined(endpoint.getTransformers()));
231             assertTrue(endpoint instanceof OutboundEndpoint);
232         }
233         else if (serviceFlow instanceof Flow)
234         {
235             assertNotNull(serviceFlow);
236             List<MessageProcessor> messageProcessors = ((Flow) serviceFlow).getMessageProcessors();
237             assertNotNull(messageProcessors);
238 
239             ImmutableEndpoint endpoint = (ImmutableEndpoint) messageProcessors.get(1);
240             assertEquals(TcpConnector.TCP, endpoint.getConnector().getProtocol().toLowerCase());
241             assertEquals("tcp://localhost:45431", endpoint.getEndpointURI().getAddress());
242             // cannot get this to work and get axis tests to work
243             // (axis seems to use undefined transformers in some strange way)
244             // assertTrue(TransformerUtils.isDefined(endpoint.getTransformers()));
245             assertTrue(endpoint instanceof OutboundEndpoint);
246         }
247         else
248         {
249             fail("Unexpected Object");
250         }
251     }
252 
253     @Test
254     public void testEndpointFromURI() throws Exception
255     {
256         ImmutableEndpoint ep = muleContext.getEndpointFactory().getInboundEndpoint(
257             "test://hello?exchangePattern=request-response&responseTimeout=2002&connector=testConnector1");
258         assertEquals(MessageExchangePattern.REQUEST_RESPONSE, ep.getExchangePattern());
259         assertEquals(2002, ep.getResponseTimeout());
260         assertTrue(ep instanceof InboundEndpoint);
261 
262         // Test MuleEvent timeout proporgation
263         MuleEvent event = new DefaultMuleEvent(new DefaultMuleMessage("hello", muleContext),
264             (InboundEndpoint) ep, MuleTestUtils.getTestSession(muleContext));
265         assertEquals(2002, event.getTimeout());
266 
267         ImmutableEndpoint ep2 = muleContext.getEndpointFactory().getInboundEndpoint(
268             "test://hello?connector=testConnector1");
269 
270         event = new DefaultMuleEvent(new DefaultMuleMessage("hello", muleContext), (InboundEndpoint) ep2,
271             MuleTestUtils.getTestSession(muleContext));
272         // default event timeout set in the test config file
273         assertEquals(1001, event.getTimeout());
274     }
275 }