1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
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
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
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
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 }