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