1   /*
2    * Copyright 2006 the original author or authors.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.springframework.ws.client.core;
18  
19  import java.io.IOException;
20  import java.net.URI;
21  
22  import org.custommonkey.xmlunit.XMLTestCase;
23  import org.easymock.MockControl;
24  
25  import org.springframework.oxm.Marshaller;
26  import org.springframework.oxm.Unmarshaller;
27  import org.springframework.ws.MockWebServiceMessage;
28  import org.springframework.ws.MockWebServiceMessageFactory;
29  import org.springframework.ws.client.WebServiceTransportException;
30  import org.springframework.ws.client.support.destination.DestinationProvider;
31  import org.springframework.ws.client.support.interceptor.ClientInterceptor;
32  import org.springframework.ws.context.DefaultMessageContext;
33  import org.springframework.ws.context.MessageContext;
34  import org.springframework.ws.transport.FaultAwareWebServiceConnection;
35  import org.springframework.ws.transport.WebServiceConnection;
36  import org.springframework.ws.transport.WebServiceMessageSender;
37  import org.springframework.xml.transform.StringResult;
38  import org.springframework.xml.transform.StringSource;
39  
40  public class WebServiceTemplateTest extends XMLTestCase {
41  
42      private WebServiceTemplate template;
43  
44      private MockControl connectionControl;
45  
46      private FaultAwareWebServiceConnection connectionMock;
47  
48      private MockWebServiceMessageFactory messageFactory;
49  
50      protected void setUp() throws Exception {
51          template = new WebServiceTemplate();
52          messageFactory = new MockWebServiceMessageFactory();
53          template.setMessageFactory(messageFactory);
54          connectionControl = MockControl.createStrictControl(FaultAwareWebServiceConnection.class);
55          connectionMock = (FaultAwareWebServiceConnection) connectionControl.getMock();
56          final URI expectedUri = new URI("http://www.springframework.org/spring-ws");
57          connectionControl.expectAndDefaultReturn(connectionMock.getUri(), expectedUri);
58          template.setMessageSender(new WebServiceMessageSender() {
59  
60              public WebServiceConnection createConnection(URI uri) throws IOException {
61                  return connectionMock;
62              }
63  
64              public boolean supports(URI uri) {
65                  assertEquals("Invalid uri", expectedUri, uri);
66                  return true;
67              }
68          });
69          template.setDefaultUri(expectedUri.toString());
70      }
71  
72      public void testMarshalAndSendNoMarshallerSet() throws Exception {
73          connectionMock.close();
74          connectionControl.replay();
75          template.setMarshaller(null);
76          try {
77              template.marshalSendAndReceive(new Object());
78              fail("IllegalStateException expected");
79          }
80          catch (IllegalStateException ex) {
81              // expected behavior
82          }
83          connectionControl.verify();
84      }
85  
86      public void testMarshalAndSendNoUnmarshallerSet() throws Exception {
87          connectionMock.close();
88          connectionControl.replay();
89          template.setUnmarshaller(null);
90          try {
91              template.marshalSendAndReceive(new Object());
92              fail("IllegalStateException expected");
93          }
94          catch (IllegalStateException ex) {
95              // expected behavior
96          }
97          connectionControl.verify();
98      }
99  
100     public void testSendAndReceiveMessageResponse() throws Exception {
101         MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
102         WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
103         requestCallback.doWithMessage(null);
104         callbackControl.setMatcher(MockControl.ALWAYS_MATCHER);
105         callbackControl.replay();
106 
107         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
108         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
109         extractorMock.extractData(null);
110         extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
111         Object extracted = new Object();
112         extractorControl.setReturnValue(extracted);
113         extractorControl.replay();
114 
115         connectionMock.send(null);
116         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
117         connectionControl.expectAndReturn(connectionMock.hasError(), false);
118         connectionControl
119                 .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
120         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
121         connectionMock.close();
122         connectionControl.replay();
123 
124         Object result = template.sendAndReceive(requestCallback, extractorMock);
125         assertEquals("Invalid response", extracted, result);
126 
127         callbackControl.verify();
128         extractorControl.verify();
129         connectionControl.verify();
130     }
131 
132     public void testSendAndReceiveMessageNoResponse() throws Exception {
133         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
134         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
135         extractorControl.replay();
136 
137         connectionMock.send(null);
138         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
139         connectionControl.expectAndReturn(connectionMock.hasError(), false);
140         connectionControl.expectAndReturn(connectionMock.receive(messageFactory), null);
141         connectionMock.close();
142         connectionControl.replay();
143 
144         Object result = template.sendAndReceive(null, extractorMock);
145         assertNull("Invalid response", result);
146         extractorControl.verify();
147         connectionControl.verify();
148     }
149 
150     public void testSendAndReceiveMessageFault() throws Exception {
151         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
152         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
153         extractorControl.replay();
154 
155         MockControl faultResolverControl = MockControl.createControl(FaultMessageResolver.class);
156         FaultMessageResolver faultMessageResolverMock = (FaultMessageResolver) faultResolverControl.getMock();
157         template.setFaultMessageResolver(faultMessageResolverMock);
158         faultMessageResolverMock.resolveFault(null);
159         faultResolverControl.setMatcher(MockControl.ALWAYS_MATCHER);
160         faultResolverControl.replay();
161 
162         MockWebServiceMessage response = new MockWebServiceMessage("<response/>");
163         response.setFault(true);
164 
165         connectionMock.send(null);
166         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
167         connectionControl.expectAndReturn(connectionMock.hasError(), true);
168         connectionControl.expectAndReturn(connectionMock.hasFault(), true);
169         connectionControl
170                 .expectAndReturn(connectionMock.receive(messageFactory), response);
171         connectionControl.expectAndReturn(connectionMock.hasFault(), true);
172         connectionMock.close();
173         connectionControl.replay();
174 
175         Object result = template.sendAndReceive(null, extractorMock);
176         assertNull("Invalid response", result);
177 
178         extractorControl.verify();
179         connectionControl.verify();
180         faultResolverControl.verify();
181     }
182 
183     public void testSendAndReceiveConnectionError() throws Exception {
184         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
185         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
186         extractorControl.replay();
187 
188         template.setFaultMessageResolver(null);
189 
190         connectionMock.send(null);
191         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
192         connectionControl.expectAndReturn(connectionMock.hasError(), true);
193         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
194         String errorMessage = "errorMessage";
195         connectionControl.expectAndReturn(connectionMock.getErrorMessage(), errorMessage);
196         connectionMock.close();
197         connectionControl.replay();
198 
199         try {
200             template.sendAndReceive(null, extractorMock);
201             fail("Expected WebServiceTransportException");
202         }
203         catch (WebServiceTransportException ex) {
204             //expected
205             assertEquals("Invalid exception message", errorMessage, ex.getMessage());
206         }
207 
208         extractorControl.verify();
209         connectionControl.verify();
210     }
211 
212     public void testSendAndReceiveSourceResponse() throws Exception {
213         MockControl extractorControl = MockControl.createControl(SourceExtractor.class);
214         SourceExtractor extractorMock = (SourceExtractor) extractorControl.getMock();
215         extractorMock.extractData(null);
216         extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
217         Object extracted = new Object();
218         extractorControl.setReturnValue(extracted);
219         extractorControl.replay();
220 
221         connectionMock.send(null);
222         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
223         connectionControl.expectAndReturn(connectionMock.hasError(), false);
224         connectionControl
225                 .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
226         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
227         connectionMock.close();
228         connectionControl.replay();
229 
230         Object result = template.sendSourceAndReceive(new StringSource("<request />"), extractorMock);
231         assertEquals("Invalid response", extracted, result);
232 
233         extractorControl.verify();
234         connectionControl.verify();
235     }
236 
237     public void testSendAndReceiveSourceNoResponse() throws Exception {
238         MockControl extractorControl = MockControl.createControl(SourceExtractor.class);
239         SourceExtractor extractorMock = (SourceExtractor) extractorControl.getMock();
240         extractorControl.replay();
241 
242         connectionMock.send(null);
243         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
244         connectionControl.expectAndReturn(connectionMock.hasError(), false);
245         connectionControl.expectAndReturn(connectionMock.receive(messageFactory), null);
246         connectionMock.close();
247         connectionControl.replay();
248 
249         Object result = template.sendSourceAndReceive(new StringSource("<request />"), extractorMock);
250         assertNull("Invalid response", result);
251 
252         extractorControl.verify();
253         connectionControl.verify();
254     }
255 
256     public void testSendAndReceiveResultResponse() throws Exception {
257         connectionMock.send(null);
258         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
259         connectionControl.expectAndReturn(connectionMock.hasError(), false);
260         connectionControl
261                 .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
262         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
263         connectionMock.close();
264         connectionControl.replay();
265 
266         StringResult result = new StringResult();
267         boolean b = template.sendSourceAndReceiveToResult(new StringSource("<request />"), result);
268         assertTrue("Invalid result", b);
269 
270         connectionControl.verify();
271     }
272 
273     public void testSendAndReceiveResultNoResponse() throws Exception {
274         connectionMock.send(null);
275         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
276         connectionControl.expectAndReturn(connectionMock.hasError(), false);
277         connectionControl
278                 .expectAndReturn(connectionMock.receive(messageFactory), null);
279         connectionMock.close();
280         connectionControl.replay();
281 
282         StringResult result = new StringResult();
283         boolean b = template.sendSourceAndReceiveToResult(new StringSource("<request />"), result);
284         assertFalse("Invalid result", b);
285 
286         connectionControl.verify();
287     }
288 
289     public void testSendAndReceiveMarshalResponse() throws Exception {
290         MockControl marshallerControl = MockControl.createControl(Marshaller.class);
291         Marshaller marshallerMock = (Marshaller) marshallerControl.getMock();
292         template.setMarshaller(marshallerMock);
293         marshallerMock.marshal(null, null);
294         marshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
295         marshallerControl.replay();
296 
297         MockControl unmarshallerControl = MockControl.createControl(Unmarshaller.class);
298         Unmarshaller unmarshallerMock = (Unmarshaller) unmarshallerControl.getMock();
299         template.setUnmarshaller(unmarshallerMock);
300         unmarshallerMock.unmarshal(null);
301         unmarshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
302         Object unmarshalled = new Object();
303         unmarshallerControl.setReturnValue(unmarshalled);
304         unmarshallerControl.replay();
305 
306         connectionMock.send(null);
307         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
308         connectionControl.expectAndReturn(connectionMock.hasError(), false);
309         connectionControl
310                 .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
311         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
312         connectionMock.close();
313         connectionControl.replay();
314 
315         Object result = template.marshalSendAndReceive(new Object());
316         assertEquals("Invalid result", unmarshalled, result);
317 
318         connectionControl.verify();
319         marshallerControl.verify();
320         unmarshallerControl.verify();
321     }
322 
323     public void testSendAndReceiveMarshalNoResponse() throws Exception {
324         MockControl marshallerControl = MockControl.createControl(Marshaller.class);
325         Marshaller marshallerMock = (Marshaller) marshallerControl.getMock();
326         template.setMarshaller(marshallerMock);
327         marshallerMock.marshal(null, null);
328         marshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
329         marshallerControl.replay();
330 
331         connectionMock.send(null);
332         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
333         connectionControl.expectAndReturn(connectionMock.hasError(), false);
334         connectionControl.expectAndReturn(connectionMock.receive(messageFactory), null);
335         connectionMock.close();
336         connectionControl.replay();
337 
338         Object result = template.marshalSendAndReceive(new Object());
339         assertNull("Invalid result", result);
340 
341         connectionControl.verify();
342         marshallerControl.verify();
343     }
344 
345     public void testSendAndReceiveCustomUri() throws Exception {
346         final URI customUri = new URI("http://www.springframework.org/spring-ws/custom");
347         template.setMessageSender(new WebServiceMessageSender() {
348 
349             public WebServiceConnection createConnection(URI uri) throws IOException {
350                 return connectionMock;
351             }
352 
353             public boolean supports(URI uri) {
354                 assertEquals("Invalid uri", customUri, uri);
355                 return true;
356             }
357         });
358         MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
359         WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
360         requestCallback.doWithMessage(null);
361         callbackControl.setMatcher(MockControl.ALWAYS_MATCHER);
362         callbackControl.replay();
363 
364         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
365         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
366         extractorMock.extractData(null);
367         extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
368         Object extracted = new Object();
369         extractorControl.setReturnValue(extracted);
370         extractorControl.replay();
371 
372         connectionMock.send(null);
373         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
374         connectionControl.expectAndReturn(connectionMock.hasError(), false);
375         connectionControl
376                 .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
377         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
378         connectionMock.close();
379         connectionControl.replay();
380 
381         Object result = template.sendAndReceive(customUri.toString(), requestCallback, extractorMock);
382         assertEquals("Invalid response", extracted, result);
383 
384         callbackControl.verify();
385         extractorControl.verify();
386         connectionControl.verify();
387     }
388 
389     public void testInterceptors() throws Exception {
390         MockControl interceptorControl = MockControl.createControl(ClientInterceptor.class);
391         interceptorControl.setDefaultMatcher(MockControl.ALWAYS_MATCHER);
392         ClientInterceptor interceptorMock1 = (ClientInterceptor) interceptorControl.getMock();
393         ClientInterceptor interceptorMock2 = (ClientInterceptor) interceptorControl.getMock();
394         template.setInterceptors(new ClientInterceptor[]{interceptorMock1, interceptorMock2});
395         interceptorControl.expectAndReturn(interceptorMock1.handleRequest(null), true);
396         interceptorControl.expectAndReturn(interceptorMock2.handleRequest(null), true);
397         interceptorControl.expectAndReturn(interceptorMock2.handleResponse(null), true);
398         interceptorControl.expectAndReturn(interceptorMock1.handleResponse(null), true);
399         interceptorControl.replay();
400 
401         MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
402         WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
403         requestCallback.doWithMessage(null);
404         callbackControl.setMatcher(MockControl.ALWAYS_MATCHER);
405         callbackControl.replay();
406 
407         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
408         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
409         extractorMock.extractData(null);
410         extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
411         Object extracted = new Object();
412         extractorControl.setReturnValue(extracted);
413         extractorControl.replay();
414 
415         connectionMock.send(null);
416         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
417         connectionControl.expectAndReturn(connectionMock.hasError(), false);
418         connectionControl
419                 .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
420         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
421         connectionMock.close();
422         connectionControl.replay();
423 
424         Object result = template.sendAndReceive(requestCallback, extractorMock);
425         assertEquals("Invalid response", extracted, result);
426 
427         callbackControl.verify();
428         extractorControl.verify();
429         connectionControl.verify();
430         interceptorControl.verify();
431     }
432 
433     public void testInterceptorsIntercepted() throws Exception {
434         MessageContext messageContext = new DefaultMessageContext(messageFactory);
435 
436         MockControl interceptorControl = MockControl.createControl(ClientInterceptor.class);
437         ClientInterceptor interceptorMock1 = (ClientInterceptor) interceptorControl.getMock();
438         ClientInterceptor interceptorMock2 = (ClientInterceptor) interceptorControl.getMock();
439         template.setInterceptors(new ClientInterceptor[]{interceptorMock1, interceptorMock2});
440         interceptorControl.expectAndReturn(interceptorMock1.handleRequest(messageContext), false);
441         interceptorControl.expectAndReturn(interceptorMock1.handleResponse(messageContext), true);
442         interceptorControl.replay();
443 
444         MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
445         WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
446         requestCallback.doWithMessage(messageContext.getRequest());
447         callbackControl.replay();
448 
449         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
450         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
451         extractorMock.extractData(null);
452         extractorControl.setMatcher(MockControl.ALWAYS_MATCHER);
453         Object extracted = new Object();
454         extractorControl.setReturnValue(extracted);
455         extractorControl.replay();
456 
457         connectionMock.send(messageContext.getRequest());
458         connectionControl.expectAndReturn(connectionMock.hasError(), false);
459         connectionControl
460                 .expectAndReturn(connectionMock.receive(messageFactory), new MockWebServiceMessage("<response/>"));
461         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
462         connectionControl.replay();
463 
464         Object result = template.doSendAndReceive(messageContext, connectionMock, requestCallback, extractorMock);
465         assertEquals("Invalid response", extracted, result);
466 
467         callbackControl.verify();
468         extractorControl.verify();
469         connectionControl.verify();
470         interceptorControl.verify();
471     }
472 
473     public void testInterceptorsInterceptedCreateResponse() throws Exception {
474         MessageContext messageContext = new DefaultMessageContext(messageFactory);
475         // force creation of response
476         messageContext.getResponse();
477 
478         MockControl interceptorControl = MockControl.createControl(ClientInterceptor.class);
479         ClientInterceptor interceptorMock1 = (ClientInterceptor) interceptorControl.getMock();
480         ClientInterceptor interceptorMock2 = (ClientInterceptor) interceptorControl.getMock();
481         template.setInterceptors(new ClientInterceptor[]{interceptorMock1, interceptorMock2});
482         interceptorControl.expectAndReturn(interceptorMock1.handleRequest(messageContext), false);
483         interceptorControl.expectAndReturn(interceptorMock1.handleResponse(messageContext), true);
484         interceptorControl.replay();
485 
486         MockControl callbackControl = MockControl.createControl(WebServiceMessageCallback.class);
487         WebServiceMessageCallback requestCallback = (WebServiceMessageCallback) callbackControl.getMock();
488         requestCallback.doWithMessage(messageContext.getRequest());
489         callbackControl.replay();
490 
491         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
492         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
493         Object extracted = new Object();
494         extractorControl.expectAndReturn(extractorMock.extractData(messageContext.getResponse()), extracted);
495         extractorControl.replay();
496 
497         connectionControl.expectAndReturn(connectionMock.hasFault(), false);
498         connectionControl.replay();
499 
500         Object result = template.doSendAndReceive(messageContext, connectionMock, requestCallback, extractorMock);
501         assertEquals("Invalid response", extracted, result);
502 
503         callbackControl.verify();
504         extractorControl.verify();
505         connectionControl.verify();
506         interceptorControl.verify();
507     }
508 
509     public void testDestinationResolver() throws Exception {
510         MockControl providerControl = MockControl.createControl(DestinationProvider.class);
511         DestinationProvider providerMock = (DestinationProvider) providerControl.getMock();
512         final URI providerUri = new URI("http://www.springframework.org/spring-ws/destinationProvider");
513         providerControl.expectAndReturn(providerMock.getDestination(), providerUri);
514         template.setDestinationProvider(providerMock);
515         providerControl.replay();
516 
517         template.setMessageSender(new WebServiceMessageSender() {
518 
519             public WebServiceConnection createConnection(URI uri) throws IOException {
520                 return connectionMock;
521             }
522 
523             public boolean supports(URI uri) {
524                 assertEquals("Invalid uri", providerUri, uri);
525                 return true;
526             }
527         });
528 
529         MockControl extractorControl = MockControl.createControl(WebServiceMessageExtractor.class);
530         WebServiceMessageExtractor extractorMock = (WebServiceMessageExtractor) extractorControl.getMock();
531         extractorControl.replay();
532 
533         connectionControl.reset();
534         connectionControl.expectAndDefaultReturn(connectionMock.getUri(), providerUri);
535         connectionMock.send(null);
536         connectionControl.setMatcher(MockControl.ALWAYS_MATCHER);
537         connectionControl.expectAndReturn(connectionMock.hasError(), false);
538         connectionControl.expectAndReturn(connectionMock.receive(messageFactory), null);
539         connectionMock.close();
540         connectionControl.replay();
541 
542         Object result = template.sendAndReceive(null, extractorMock);
543         assertNull("Invalid response", result);
544         extractorControl.verify();
545         connectionControl.verify();
546         providerControl.verify();
547     }
548 
549 
550 }