KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > objectweb > celtix > bus > jaxws > EndpointImplTest


1 package org.objectweb.celtix.bus.jaxws;
2
3
4 import java.lang.reflect.Method JavaDoc;
5 import java.util.List JavaDoc;
6 import java.util.Properties JavaDoc;
7
8 import javax.xml.namespace.QName JavaDoc;
9 import javax.xml.ws.Endpoint;
10 import javax.xml.ws.WebServiceContext;
11 import javax.xml.ws.WebServiceException;
12 import javax.xml.ws.handler.Handler;
13 import javax.xml.ws.spi.Provider;
14
15 import junit.framework.TestCase;
16
17 import org.mortbay.http.HttpContext;
18 import org.mortbay.http.HttpServer;
19 import org.mortbay.http.SocketListener;
20 import org.mortbay.util.InetAddrPort;
21 import org.objectweb.celtix.Bus;
22 import org.objectweb.celtix.BusException;
23 import org.objectweb.celtix.bindings.BindingManager;
24 import org.objectweb.celtix.bindings.DataBindingCallback;
25 import org.objectweb.celtix.bus.bindings.TestBinding;
26 import org.objectweb.celtix.bus.bindings.TestBindingFactory;
27 import org.objectweb.celtix.bus.jaxws.spi.ProviderImpl;
28 import org.objectweb.celtix.ws.addressing.EndpointReferenceType;
29 import org.objectweb.celtix.wsdl.EndpointReferenceUtils;
30 import org.objectweb.hello_world_soap_http.AnnotatedGreeterImpl;
31 import org.objectweb.hello_world_soap_http.HWSourcePayloadProvider;
32 import org.objectweb.hello_world_soap_http.HelloWorldServiceProvider;
33 import org.objectweb.hello_world_soap_http.NotAnnotatedProvider;
34
35 public class EndpointImplTest extends TestCase {
36     private String JavaDoc epfClassName;
37     private Bus bus;
38     private Endpoint endpoint;
39     private AnnotatedGreeterImpl servant;
40
41     public void setUp() throws Exception JavaDoc {
42         epfClassName = System.getProperty(Provider.JAXWSPROVIDER_PROPERTY);
43         System.setProperty(Provider.JAXWSPROVIDER_PROPERTY,
44                            ProviderImpl.JAXWS_PROVIDER);
45         bus = Bus.init();
46         BindingManager bm = bus.getBindingManager();
47         bm.registerBinding(TestBinding.TEST_BINDING, new TestBindingFactory(bus));
48         servant = new AnnotatedGreeterImpl();
49         endpoint = Endpoint.create(TestBinding.TEST_BINDING, servant);
50         
51
52     }
53
54     public void tearDown() throws Exception JavaDoc {
55         bus.shutdown(true);
56         if (null == epfClassName) {
57             Properties JavaDoc properties = System.getProperties();
58             properties.remove(Provider.JAXWSPROVIDER_PROPERTY);
59             System.setProperties(properties);
60         } else {
61             System.setProperty(Provider.JAXWSPROVIDER_PROPERTY, epfClassName);
62         }
63     }
64
65     public void testPublishUsingAddress() throws Exception JavaDoc {
66         assertNotNull(endpoint);
67         assertTrue(!endpoint.isPublished());
68         String JavaDoc address = "http://localhost:8080/test";
69         try {
70             endpoint.publish(address);
71         } catch (IllegalArgumentException JavaDoc ex) {
72             assertTrue(ex.getCause() instanceof BusException);
73             assertEquals("BINDING_INCOMPATIBLE_ADDRESS_EXC", ((BusException)ex.getCause()).getCode());
74         }
75         address = "test://localhost:7777/test";
76         endpoint.publish(address);
77         assertTrue(endpoint.isPublished());
78         endpoint.stop();
79         assertTrue(!endpoint.isPublished());
80         endpoint.stop();
81         assertTrue(!endpoint.isPublished());
82     }
83
84     public void testPublishUsingHttpContext() throws Exception JavaDoc {
85         
86         assertNotNull(endpoint);
87         assertTrue(!endpoint.isPublished());
88         
89         HttpServer server = new HttpServer();
90         SocketListener listener = new SocketListener(new InetAddrPort(27220));
91         server.addListener(listener);
92         try {
93             server.start();
94         } catch (Exception JavaDoc e) {
95             // TODO Auto-generated catch block
96
e.printStackTrace();
97         }
98         
99         HttpContext context = server.getContext("http://localhost:27220/test");
100         endpoint.publish(context);
101         assertTrue(endpoint.isPublished());
102         
103         listener.stop();
104         server.stop(true);
105         
106         
107     }
108     
109     public void testPublishUsingEndpointReferenceTypeContext() throws Exception JavaDoc {
110         
111         assertNotNull(endpoint);
112         assertTrue(!endpoint.isPublished());
113              
114         EndpointReferenceType context =
115             EndpointReferenceUtils.getEndpointReference("http://localhost:8080/test");
116         endpoint.publish(context);
117         
118         assertTrue(endpoint.isPublished());
119     }
120
121
122     public void testResourceInjectionApplicationContext() {
123         // WebServiceContext is specified by a resource annotation.
124
// This should be inject when the endpoing is published.
125
//i.e in context of Endpoint.publish.
126
//Such injection should not happen for Endpoint.create.
127
//JAX_WS Spec 5.2.1.
128

129         WebServiceContext ctx = servant.getContext();
130         assertNull(ctx);
131         try {
132             String JavaDoc address = "http://localhost:8080/test";
133             endpoint.publish(address);
134         } catch (IllegalArgumentException JavaDoc ex) {
135             assertTrue(ex.getCause() instanceof BusException);
136             assertEquals("BINDING_INCOMPATIBLE_ADDRESS_EXC", ((BusException)ex.getCause()).getCode());
137         }
138         ctx = servant.getContext();
139         assertNotNull(ctx);
140     }
141
142     public void testHandlerAnnotation() {
143
144         List JavaDoc<Handler> handlers = endpoint.getBinding().getHandlerChain();
145         assertNotNull(handlers);
146     }
147     
148     public void testCreateWithProvider() {
149         HelloWorldServiceProvider provider = new HelloWorldServiceProvider();
150         endpoint = Endpoint.create(TestBinding.TEST_BINDING, provider);
151         assertNotNull(endpoint);
152
153         EndpointImpl impl = (EndpointImpl)endpoint;
154         assertNotNull(impl.getWebServiceProvider());
155         assertEquals(DataBindingCallback.Mode.MESSAGE, impl.getServiceMode());
156     }
157     
158     public void testBadProvider() {
159         NotAnnotatedProvider badProvider = new NotAnnotatedProvider();
160         try {
161             Endpoint.create(TestBinding.TEST_BINDING, badProvider);
162             fail("Should have received a exception");
163         } catch (WebServiceException ex) {
164             // expected
165
}
166     }
167     
168     public void testGetMethod() {
169         QName JavaDoc opName = new QName JavaDoc("", "PutLastTradedPrice");
170         assertTrue(endpoint instanceof EndpointImpl);
171         EndpointImpl impl = (EndpointImpl)endpoint;
172         //Check if a method by a localPart of opName exists on the Implementor.
173
Method JavaDoc m = impl.getMethod(opName);
174         
175         assertNotNull(m);
176         
177         opName = new QName JavaDoc("", "putLastTradedPrice");
178         m = impl.getMethod(opName);
179         assertNull(m);
180         
181         //Test for provider
182
HelloWorldServiceProvider provider = new HelloWorldServiceProvider();
183         endpoint = Endpoint.create(TestBinding.TEST_BINDING, provider);
184         assertTrue(endpoint instanceof EndpointImpl);
185         impl = (EndpointImpl)endpoint;
186         opName = new QName JavaDoc("", "invoke");
187         //Check if a method by a localPart of opName exists on the Implementor.
188
m = impl.getMethod(opName);
189         assertNotNull(m);
190         assertEquals("invoke", m.getName());
191     }
192
193     public void testGetServiceMode() {
194         EndpointImpl impl = (EndpointImpl)endpoint;
195         assertNotNull(impl);
196         DataBindingCallback.Mode mode = impl.getServiceMode();
197         assertNotNull(mode);
198         assertEquals(DataBindingCallback.Mode.PARTS, mode);
199         
200         //Test for provider
201
HelloWorldServiceProvider provider = new HelloWorldServiceProvider();
202         endpoint = Endpoint.create(TestBinding.TEST_BINDING, provider);
203         assertTrue(endpoint instanceof EndpointImpl);
204         impl = (EndpointImpl)endpoint;
205
206         mode = impl.getServiceMode();
207         assertNotNull(mode);
208         assertEquals(DataBindingCallback.Mode.MESSAGE, mode);
209
210         HWSourcePayloadProvider provider1 = new HWSourcePayloadProvider();
211         endpoint = Endpoint.create(TestBinding.TEST_BINDING, provider1);
212         assertTrue(endpoint instanceof EndpointImpl);
213
214         impl = (EndpointImpl)endpoint;
215         mode = impl.getServiceMode();
216         assertNotNull(mode);
217         assertEquals(DataBindingCallback.Mode.PAYLOAD, mode);
218     }
219     
220     /*
221     public void testCreateDataBindingCallback() {
222         ObjectMessageContextImpl ctx = new ObjectMessageContextImpl();
223         EndpointImpl impl = (EndpointImpl)endpoint;
224         assertNotNull(impl);
225         DataBindingCallback cb =
226             impl.createDataBindingCallback(ctx, DataBindingCallback.Mode.PARTS);
227         assertNotNull(cb);
228         assertTrue(cb instanceof JAXBDataBindingCallback);
229         assertEquals(DataBindingCallback.Mode.PARTS, cb.getMode());
230         
231         //Test for provider
232         HelloWorldServiceProvider provider = new HelloWorldServiceProvider();
233         endpoint = Endpoint.create(TestBinding.TEST_BINDING, provider);
234         assertTrue(endpoint instanceof EndpointImpl);
235         impl = (EndpointImpl)endpoint;
236
237         cb = impl.createDataBindingCallback(ctx, DataBindingCallback.Mode.MESSAGE);
238         assertNotNull(cb);
239         assertTrue(cb instanceof DynamicDataBindingCallback);
240         assertEquals(DataBindingCallback.Mode.MESSAGE, cb.getMode());
241
242         HWSourcePayloadProvider provider1 = new HWSourcePayloadProvider();
243         endpoint = Endpoint.create(TestBinding.TEST_BINDING, provider1);
244         assertTrue(endpoint instanceof EndpointImpl);
245
246         impl = (EndpointImpl)endpoint;
247         cb = impl.createDataBindingCallback(ctx, DataBindingCallback.Mode.PAYLOAD);
248         assertNotNull(cb);
249         assertTrue(cb instanceof DynamicDataBindingCallback);
250         assertEquals(DataBindingCallback.Mode.PAYLOAD, cb.getMode());
251     }
252     */

253     
254     public void testGetWebServiceAnnotatedClass() {
255         EndpointImpl impl = (EndpointImpl)endpoint;
256         assertNotNull(impl);
257         List JavaDoc<Class JavaDoc<?>> classList = impl.getWebServiceAnnotatedClass();
258
259         assertNotNull(classList);
260         assertEquals(1, classList.size());
261         
262         //Test for provider
263
HelloWorldServiceProvider provider = new HelloWorldServiceProvider();
264         endpoint = Endpoint.create(TestBinding.TEST_BINDING, provider);
265         assertTrue(endpoint instanceof EndpointImpl);
266         impl = (EndpointImpl)endpoint;
267
268         classList = impl.getWebServiceAnnotatedClass();
269         assertNotNull(classList);
270         assertEquals(0, classList.size());
271     }
272     
273 }
274
Popular Tags