View Javadoc

1   /*
2    * $Id: EndpointFactoryTestCase.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.endpoint;
12  
13  import org.mule.MessageExchangePattern;
14  import org.mule.api.MuleException;
15  import org.mule.api.endpoint.EndpointBuilder;
16  import org.mule.api.endpoint.EndpointFactory;
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.registry.Registry;
21  import org.mule.tck.junit4.AbstractMuleContextTestCase;
22  import org.mule.tck.testmodels.mule.TestConnector;
23  
24  import org.junit.Test;
25  
26  import static org.junit.Assert.assertEquals;
27  import static org.junit.Assert.assertNotNull;
28  import static org.junit.Assert.assertNotSame;
29  import static org.junit.Assert.assertTrue;
30  import static org.junit.Assert.fail;
31  
32  public class EndpointFactoryTestCase extends AbstractMuleContextTestCase
33  {
34  
35      @Test
36      public void testCreateInboundEndpoint() throws Exception
37      {
38          String uri = "test://address";
39          EndpointFactory endpointFactory = new DefaultEndpointFactory();
40          endpointFactory.setMuleContext(muleContext);
41          ImmutableEndpoint ep = endpointFactory.getInboundEndpoint(uri);
42          assertEquals(DefaultInboundEndpoint.class, ep.getClass());
43          assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
44          assertTrue(ep instanceof InboundEndpoint);
45      }
46  
47      @Test
48      public void testCreateInboundEndpointFromGlobalEndpoint() throws Exception
49      {
50          muleContext.getRegistry().registerEndpointBuilder("myGlobalEndpoint",
51                  new EndpointURIEndpointBuilder("test://address", muleContext));
52          String uri = "myGlobalEndpoint";
53          EndpointFactory endpointFactory = new DefaultEndpointFactory();
54          endpointFactory.setMuleContext(muleContext);
55          try
56          {
57              ImmutableEndpoint ep = endpointFactory.getInboundEndpoint(uri);
58              assertEquals(DefaultInboundEndpoint.class, ep.getClass());
59              assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
60              assertTrue(ep instanceof InboundEndpoint);
61          }
62          catch (Exception e)
63          {
64              fail("Unexpected exception: " + e.getMessage());
65          }
66      }
67  
68      @Test
69      public void testCreateInboundEndpointFromNamedConcreteEndpoint() throws Exception
70      {
71          muleContext.getRegistry().registerEndpointBuilder("&myNamedConcreateEndpoint",
72                  new EndpointURIEndpointBuilder("test://address", muleContext));
73          String uri = "&myNamedConcreateEndpoint";
74          EndpointFactory endpointFactory = new DefaultEndpointFactory();
75          endpointFactory.setMuleContext(muleContext);
76          ImmutableEndpoint ep = endpointFactory.getInboundEndpoint(uri);
77          assertEquals(DefaultInboundEndpoint.class, ep.getClass());
78          assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
79          assertTrue(ep instanceof InboundEndpoint);
80      }
81  
82      @Test
83      public void testCreateOutboundEndpoint() throws Exception
84      {
85          String uri = "test://address";
86          EndpointFactory endpointFactory = new DefaultEndpointFactory();
87          endpointFactory.setMuleContext(muleContext);
88          ImmutableEndpoint ep = endpointFactory.getOutboundEndpoint(uri);
89          assertEquals(DefaultOutboundEndpoint.class, ep.getClass());
90          assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
91          assertTrue(ep instanceof OutboundEndpoint);
92      }
93  
94      @Test
95      public void testCreateoutboundEndpointFromGlobalEndpoint() throws Exception
96      {
97          muleContext.getRegistry().registerEndpointBuilder("myGlobalEndpoint",
98                  new EndpointURIEndpointBuilder("test://address", muleContext));
99          String uri = "myGlobalEndpoint";
100         EndpointFactory endpointFactory = new DefaultEndpointFactory();
101         endpointFactory.setMuleContext(muleContext);
102         ImmutableEndpoint ep = endpointFactory.getOutboundEndpoint(uri);
103         assertEquals(DefaultOutboundEndpoint.class, ep.getClass());
104         assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
105         assertTrue(ep instanceof OutboundEndpoint);
106     }
107 
108     @Test
109     public void testCreateoutboundEndpointFromNamedConcreteEndpoint() throws Exception
110     {
111         muleContext.getRegistry().registerEndpointBuilder("&myNamedConcreateEndpoint",
112                 new EndpointURIEndpointBuilder("test://address", muleContext));
113         String uri = "&myNamedConcreateEndpoint";
114         EndpointFactory endpointFactory = new DefaultEndpointFactory();
115         endpointFactory.setMuleContext(muleContext);
116         ImmutableEndpoint ep = endpointFactory.getOutboundEndpoint(uri);
117         assertEquals(DefaultOutboundEndpoint.class, ep.getClass());
118         assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
119         assertTrue(ep instanceof OutboundEndpoint);
120     }
121 
122     @Test
123     public void testCreateInboundEndpointWithBuilder() throws Exception
124     {
125         EndpointBuilder builder = new EndpointURIEndpointBuilder("test://address", muleContext);
126         EndpointFactory endpointFactory = new DefaultEndpointFactory();
127         endpointFactory.setMuleContext(muleContext);
128         ImmutableEndpoint ep = endpointFactory.getInboundEndpoint(builder);
129         assertEquals(DefaultInboundEndpoint.class, ep.getClass());
130         assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
131         assertTrue(ep instanceof InboundEndpoint);
132     }
133 
134     @Test
135     public void testCreateOutboundEndpointWithBuilder() throws Exception
136     {
137         EndpointBuilder builder = new EndpointURIEndpointBuilder("test://address", muleContext);
138         EndpointFactory endpointFactory = new DefaultEndpointFactory();
139         endpointFactory.setMuleContext(muleContext);
140         ImmutableEndpoint ep = endpointFactory.getOutboundEndpoint(builder);
141         assertEquals(DefaultOutboundEndpoint.class, ep.getClass());
142         assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
143         assertTrue(ep instanceof OutboundEndpoint);
144     }
145 
146     @Test
147     public void testCreateEndpoint() throws MuleException
148     {
149         String uri = "test://address";
150         EndpointFactory endpointFactory = new DefaultEndpointFactory();
151         endpointFactory.setMuleContext(muleContext);
152         ImmutableEndpoint ep = endpointFactory.getInboundEndpoint(uri);
153         assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
154     }
155 
156     @Test
157     public void testCreateEndpointFromGlobalEndpoint() throws MuleException
158     {
159         Registry r = muleContext.getRegistry();
160         r.registerObject("myGlobalEndpoint", new EndpointURIEndpointBuilder("test://address", muleContext), muleContext);
161         String uri = "myGlobalEndpoint";
162         EndpointFactory endpointFactory = new DefaultEndpointFactory();
163         endpointFactory.setMuleContext(muleContext);
164         try
165         {
166             ImmutableEndpoint ep = endpointFactory.getInboundEndpoint(uri);
167             assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
168         }
169         catch (Exception e)
170         {
171             fail("Unexpected exception: " + e.getMessage());
172         }
173     }
174 
175     @Test
176     public void testCreateEndpointFromNamedConcreteEndpoint() throws MuleException
177     {
178         Registry r = muleContext.getRegistry();
179         r.registerObject("&myNamedConcreteEndpoint", new EndpointURIEndpointBuilder("test://address", muleContext));
180         String uri = "&myNamedConcreteEndpoint";
181         EndpointFactory endpointFactory = new DefaultEndpointFactory();
182         endpointFactory.setMuleContext(muleContext);
183         ImmutableEndpoint ep = endpointFactory.getInboundEndpoint(uri);
184         assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
185     }
186 
187     @Test
188     public void testCreateEndpointByCustomizingEndpointBuilder() throws MuleException
189     {
190         // Create and register two connectors
191         TestConnector testConnector1 = new TestConnector(muleContext);
192         testConnector1.setName("testConnector1");
193         TestConnector testConnector2 = new TestConnector(muleContext);
194         testConnector2.setName("testConnector2");
195         muleContext.getRegistry().registerConnector(testConnector1);
196         muleContext.getRegistry().registerConnector(testConnector2);
197 
198         String globalEndpointName = "concreteEndpoint";
199 
200         // Create and register a endpoint builder (global endpoint) with connector1
201         EndpointBuilder endpointBuilder = new EndpointURIEndpointBuilder("test://address", muleContext);
202         endpointBuilder.setConnector(testConnector1);
203         muleContext.getRegistry().registerObject(globalEndpointName, endpointBuilder);
204         EndpointFactory endpointFactory = new DefaultEndpointFactory();
205         endpointFactory.setMuleContext(muleContext);
206         // Test that DefaultEndpointFactory.getEndpointBuilder() returns a new
207         // EndpointBuilder instance equal to
208         // the one we registered earlier
209         EndpointBuilder endpointBuilder1 = endpointFactory.getEndpointBuilder(globalEndpointName);
210         assertNotSame(endpointBuilder1, endpointBuilder);
211         assertTrue(endpointBuilder1.equals(endpointBuilder));
212 
213         // Test that DefaultEndpointFactory.getEndpointBuilder() returns a new
214         // EndpointBuilder instance equal to
215         // the one we registered earlier
216         EndpointBuilder endpointBuilder2 = endpointFactory.getEndpointBuilder(globalEndpointName);
217         assertNotSame(endpointBuilder2, endpointBuilder);
218         assertTrue(endpointBuilder2.equals(endpointBuilder));
219 
220         // Check that all EndpointBuilder's returned are unique but equal
221         assertNotSame(endpointBuilder1, endpointBuilder2);
222         assertTrue(endpointBuilder1.equals(endpointBuilder2));
223         assertEquals(endpointBuilder1.hashCode(), endpointBuilder2.hashCode());
224 
225         // Test creating an endpoint from endpointBuilder1
226         endpointBuilder1.setExchangePattern(MessageExchangePattern.REQUEST_RESPONSE);
227         endpointBuilder1.setResponseTimeout(99);
228         ImmutableEndpoint ep = endpointFactory.getInboundEndpoint(endpointBuilder1);
229         assertEquals(ep.getEndpointURI().getUri().toString(), "test://address");
230         assertEquals(MessageExchangePattern.REQUEST_RESPONSE, ep.getExchangePattern());
231         assertEquals(99, ep.getResponseTimeout());
232         assertNotNull(ep.getConnector());
233         assertEquals(testConnector1, ep.getConnector());
234 
235         // Test creating an endpoint from endpointBuilder2
236         endpointBuilder2.setExchangePattern(MessageExchangePattern.ONE_WAY);
237         endpointBuilder2.setResponseTimeout(0);
238         endpointBuilder2.setConnector(testConnector2);
239         ImmutableEndpoint ep2 = endpointFactory.getInboundEndpoint(endpointBuilder2);
240         assertEquals(ep2.getEndpointURI().getUri().toString(), "test://address");
241         assertEquals(MessageExchangePattern.ONE_WAY, ep2.getExchangePattern());
242         assertEquals(0, ep2.getResponseTimeout());
243         assertNotNull(ep.getConnector());
244         assertEquals(testConnector2, ep2.getConnector());
245 
246         // Test creating a new endpoint from endpointBuilder1
247         ImmutableEndpoint ep3 = endpointFactory.getInboundEndpoint(endpointBuilder1);
248         assertEquals(ep3.getEndpointURI().getUri().toString(), "test://address");
249         assertTrue(ep3.getResponseTimeout() != 0);
250         assertEquals(MessageExchangePattern.REQUEST_RESPONSE, ep3.getExchangePattern());
251         assertNotNull(ep.getConnector());
252         assertEquals(testConnector1, ep3.getConnector());
253     }
254 
255 }