1   /*
2    * Copyright 2005 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.server;
18  
19  import java.util.Collections;
20  
21  import junit.framework.TestCase;
22  import org.easymock.MockControl;
23  import org.springframework.context.support.StaticApplicationContext;
24  import org.springframework.ws.MockWebServiceMessage;
25  import org.springframework.ws.NoEndpointFoundException;
26  import org.springframework.ws.WebServiceMessageFactory;
27  import org.springframework.ws.context.DefaultMessageContext;
28  import org.springframework.ws.context.MessageContext;
29  import org.springframework.ws.server.endpoint.adapter.PayloadEndpointAdapter;
30  import org.springframework.ws.server.endpoint.mapping.PayloadRootQNameEndpointMapping;
31  import org.springframework.ws.soap.server.endpoint.SimpleSoapExceptionResolver;
32  
33  public class MessageDispatcherTest extends TestCase {
34  
35      private MessageDispatcher dispatcher;
36  
37      private MessageContext messageContext;
38  
39      private MockControl factoryControl;
40  
41      private WebServiceMessageFactory factoryMock;
42  
43      protected void setUp() throws Exception {
44          dispatcher = new MessageDispatcher();
45          factoryControl = MockControl.createControl(WebServiceMessageFactory.class);
46          factoryMock = (WebServiceMessageFactory) factoryControl.getMock();
47          messageContext = new DefaultMessageContext(new MockWebServiceMessage(), factoryMock);
48      }
49  
50      public void testGetEndpoint() throws Exception {
51          MockControl mappingControl = MockControl.createControl(EndpointMapping.class);
52          EndpointMapping mappingMock = (EndpointMapping) mappingControl.getMock();
53          dispatcher.setEndpointMappings(Collections.singletonList(mappingMock));
54  
55          EndpointInvocationChain chain = new EndpointInvocationChain(new Object());
56  
57          mappingControl.expectAndReturn(mappingMock.getEndpoint(messageContext), chain);
58  
59          mappingControl.replay();
60          factoryControl.replay();
61          EndpointInvocationChain result = dispatcher.getEndpoint(messageContext);
62          mappingControl.verify();
63          factoryControl.verify();
64          assertEquals("getEndpoint returns invalid EndpointInvocationChain", chain, result);
65      }
66  
67      public void testGetEndpointAdapterSupportedEndpoint() throws Exception {
68          MockControl adapterControl = MockControl.createControl(EndpointAdapter.class);
69          EndpointAdapter adapterMock = (EndpointAdapter) adapterControl.getMock();
70          dispatcher.setEndpointAdapters(Collections.singletonList(adapterMock));
71  
72          Object endpoint = new Object();
73          adapterControl.expectAndReturn(adapterMock.supports(endpoint), true);
74          adapterControl.replay();
75          factoryControl.replay();
76          EndpointAdapter result = dispatcher.getEndpointAdapter(endpoint);
77          adapterControl.verify();
78          factoryControl.verify();
79          assertEquals("getEnpointAdapter returns invalid EndpointAdapter", adapterMock, result);
80      }
81  
82      public void testGetEndpointAdapterUnsupportedEndpoint() throws Exception {
83          MockControl adapterControl = MockControl.createControl(EndpointAdapter.class);
84          EndpointAdapter adapterMock = (EndpointAdapter) adapterControl.getMock();
85          dispatcher.setEndpointAdapters(Collections.singletonList(adapterMock));
86  
87          Object endpoint = new Object();
88          adapterControl.expectAndReturn(adapterMock.supports(endpoint), false);
89          adapterControl.replay();
90          factoryControl.replay();
91          try {
92              dispatcher.getEndpointAdapter(endpoint);
93              fail("getEndpointAdapter does not throw IllegalStateException for unsupported endpoint");
94          }
95          catch (IllegalStateException ex) {
96              // Expected
97          }
98          adapterControl.verify();
99          factoryControl.verify();
100     }
101 
102     public void testResolveException() throws Exception {
103         final Exception ex = new Exception();
104         EndpointMapping endpointMapping = new EndpointMapping() {
105 
106             public EndpointInvocationChain getEndpoint(MessageContext messageContext) throws Exception {
107                 throw ex;
108             }
109         };
110         dispatcher.setEndpointMappings(Collections.singletonList(endpointMapping));
111         EndpointExceptionResolver resolver = new EndpointExceptionResolver() {
112 
113             public boolean resolveException(MessageContext givenMessageContext,
114                                             Object givenEndpoint,
115                                             Exception givenException) {
116                 assertEquals("Invalid message context", messageContext, givenMessageContext);
117                 assertNull("Invalid endpoint", givenEndpoint);
118                 assertEquals("Invalid exception", ex, givenException);
119                 givenMessageContext.getResponse();
120                 return true;
121             }
122 
123         };
124         dispatcher.setEndpointExceptionResolvers(Collections.singletonList(resolver));
125         factoryControl.expectAndReturn(factoryMock.createWebServiceMessage(), new MockWebServiceMessage());
126         factoryControl.replay();
127 
128         dispatcher.dispatch(messageContext);
129         assertNotNull("processEndpointException sets no response", messageContext.getResponse());
130         factoryControl.verify();
131     }
132 
133     public void testProcessUnsupportedEndpointException() throws Exception {
134         MockControl resolverControl = MockControl.createControl(EndpointExceptionResolver.class);
135         EndpointExceptionResolver resolverMock = (EndpointExceptionResolver) resolverControl.getMock();
136         dispatcher.setEndpointExceptionResolvers(Collections.singletonList(resolverMock));
137 
138         Object endpoint = new Object();
139         Exception ex = new Exception();
140 
141         resolverControl.expectAndReturn(resolverMock.resolveException(messageContext, endpoint, ex), false);
142 
143         resolverControl.replay();
144         try {
145             dispatcher.processEndpointException(messageContext, endpoint, ex);
146         }
147         catch (Exception result) {
148             assertEquals("processEndpointException throws invalid exception", ex, result);
149         }
150         resolverControl.verify();
151     }
152 
153     public void testNormalFlow() throws Exception {
154         MockControl adapterControl = MockControl.createControl(EndpointAdapter.class);
155         EndpointAdapter adapterMock = (EndpointAdapter) adapterControl.getMock();
156         dispatcher.setEndpointAdapters(Collections.singletonList(adapterMock));
157 
158         Object endpoint = new Object();
159         adapterControl.expectAndReturn(adapterMock.supports(endpoint), true);
160 
161         MockControl mappingControl = MockControl.createControl(EndpointMapping.class);
162         EndpointMapping mappingMock = (EndpointMapping) mappingControl.getMock();
163         dispatcher.setEndpointMappings(Collections.singletonList(mappingMock));
164 
165         MockControl interceptorControl = MockControl.createStrictControl(EndpointInterceptor.class);
166         EndpointInterceptor interceptorMock1 = (EndpointInterceptor) interceptorControl.getMock();
167         EndpointInterceptor interceptorMock2 = (EndpointInterceptor) interceptorControl.getMock();
168 
169         interceptorControl.expectAndReturn(interceptorMock1.handleRequest(messageContext, endpoint), true);
170         interceptorControl.expectAndReturn(interceptorMock2.handleRequest(messageContext, endpoint), true);
171         adapterMock.invoke(messageContext, endpoint);
172         interceptorControl.expectAndReturn(interceptorMock2.handleResponse(messageContext, endpoint), true);
173         interceptorControl.expectAndReturn(interceptorMock1.handleResponse(messageContext, endpoint), true);
174 
175         EndpointInvocationChain chain =
176                 new EndpointInvocationChain(endpoint, new EndpointInterceptor[]{interceptorMock1, interceptorMock2});
177 
178         mappingControl.expectAndReturn(mappingMock.getEndpoint(messageContext), chain);
179         factoryControl.expectAndReturn(factoryMock.createWebServiceMessage(), new MockWebServiceMessage());
180 
181         mappingControl.replay();
182         interceptorControl.replay();
183         adapterControl.replay();
184         factoryControl.replay();
185         //  response required for interceptor invocation
186         messageContext.getResponse();
187         dispatcher.dispatch(messageContext);
188 
189         mappingControl.verify();
190         interceptorControl.verify();
191         adapterControl.verify();
192         factoryControl.verify();
193     }
194 
195     public void testFlowNoResponse() throws Exception {
196         MockControl adapterControl = MockControl.createControl(EndpointAdapter.class);
197         EndpointAdapter adapterMock = (EndpointAdapter) adapterControl.getMock();
198         dispatcher.setEndpointAdapters(Collections.singletonList(adapterMock));
199 
200         Object endpoint = new Object();
201         adapterControl.expectAndReturn(adapterMock.supports(endpoint), true);
202 
203         MockControl mappingControl = MockControl.createControl(EndpointMapping.class);
204         EndpointMapping mappingMock = (EndpointMapping) mappingControl.getMock();
205         dispatcher.setEndpointMappings(Collections.singletonList(mappingMock));
206 
207         MockControl interceptorControl = MockControl.createStrictControl(EndpointInterceptor.class);
208         EndpointInterceptor interceptorMock1 = (EndpointInterceptor) interceptorControl.getMock();
209         EndpointInterceptor interceptorMock2 = (EndpointInterceptor) interceptorControl.getMock();
210 
211         EndpointInvocationChain chain =
212                 new EndpointInvocationChain(endpoint, new EndpointInterceptor[]{interceptorMock1, interceptorMock2});
213         mappingControl.expectAndReturn(mappingMock.getEndpoint(messageContext), chain);
214 
215         interceptorControl.expectAndReturn(interceptorMock1.handleRequest(messageContext, endpoint), true);
216         interceptorControl.expectAndReturn(interceptorMock2.handleRequest(messageContext, endpoint), true);
217         adapterMock.invoke(messageContext, endpoint);
218 
219         mappingControl.replay();
220         interceptorControl.replay();
221         adapterControl.replay();
222         factoryControl.replay();
223 
224         dispatcher.dispatch(messageContext);
225 
226         mappingControl.verify();
227         interceptorControl.verify();
228         adapterControl.verify();
229         factoryControl.verify();
230     }
231 
232     public void testInterceptedRequestFlow() throws Exception {
233         MockControl adapterControl = MockControl.createControl(EndpointAdapter.class);
234         EndpointAdapter adapterMock = (EndpointAdapter) adapterControl.getMock();
235         dispatcher.setEndpointAdapters(Collections.singletonList(adapterMock));
236 
237         MockControl mappingControl = MockControl.createControl(EndpointMapping.class);
238         EndpointMapping mappingMock = (EndpointMapping) mappingControl.getMock();
239         dispatcher.setEndpointMappings(Collections.singletonList(mappingMock));
240 
241         MockControl interceptorControl = MockControl.createStrictControl(EndpointInterceptor.class);
242         EndpointInterceptor interceptorMock1 = (EndpointInterceptor) interceptorControl.getMock();
243         EndpointInterceptor interceptorMock2 = (EndpointInterceptor) interceptorControl.getMock();
244 
245         Object endpoint = new Object();
246         interceptorControl.expectAndReturn(interceptorMock1.handleRequest(messageContext, endpoint), false);
247         interceptorControl.expectAndReturn(interceptorMock1.handleResponse(messageContext, endpoint), true);
248 
249         EndpointInvocationChain chain =
250                 new EndpointInvocationChain(endpoint, new EndpointInterceptor[]{interceptorMock1, interceptorMock2});
251 
252         mappingControl.expectAndReturn(mappingMock.getEndpoint(messageContext), chain);
253         factoryControl.expectAndReturn(factoryMock.createWebServiceMessage(), new MockWebServiceMessage());
254 
255         mappingControl.replay();
256         interceptorControl.replay();
257         adapterControl.replay();
258         factoryControl.replay();
259 
260         //  response required for interceptor invocation
261         messageContext.getResponse();
262 
263         dispatcher.dispatch(messageContext);
264 
265         mappingControl.verify();
266         interceptorControl.verify();
267         adapterControl.verify();
268         factoryControl.verify();
269     }
270 
271     public void testInterceptedResponseFlow() throws Exception {
272         MockControl adapterControl = MockControl.createControl(EndpointAdapter.class);
273         EndpointAdapter adapterMock = (EndpointAdapter) adapterControl.getMock();
274         dispatcher.setEndpointAdapters(Collections.singletonList(adapterMock));
275 
276         MockControl mappingControl = MockControl.createControl(EndpointMapping.class);
277         EndpointMapping mappingMock = (EndpointMapping) mappingControl.getMock();
278         dispatcher.setEndpointMappings(Collections.singletonList(mappingMock));
279 
280         MockControl interceptorControl = MockControl.createStrictControl(EndpointInterceptor.class);
281         EndpointInterceptor interceptorMock1 = (EndpointInterceptor) interceptorControl.getMock();
282         EndpointInterceptor interceptorMock2 = (EndpointInterceptor) interceptorControl.getMock();
283 
284         Object endpoint = new Object();
285         interceptorControl.expectAndReturn(interceptorMock1.handleRequest(messageContext, endpoint), true);
286         interceptorControl.expectAndReturn(interceptorMock2.handleRequest(messageContext, endpoint), false);
287         interceptorControl.expectAndReturn(interceptorMock2.handleResponse(messageContext, endpoint), false);
288 
289         EndpointInvocationChain chain =
290                 new EndpointInvocationChain(endpoint, new EndpointInterceptor[]{interceptorMock1, interceptorMock2});
291 
292         mappingControl.expectAndReturn(mappingMock.getEndpoint(messageContext), chain);
293         factoryControl.expectAndReturn(factoryMock.createWebServiceMessage(), new MockWebServiceMessage());
294 
295         mappingControl.replay();
296         interceptorControl.replay();
297         adapterControl.replay();
298         factoryControl.replay();
299         //  response required for interceptor invocation
300         messageContext.getResponse();
301 
302         dispatcher.dispatch(messageContext);
303 
304         mappingControl.verify();
305         interceptorControl.verify();
306         adapterControl.verify();
307         factoryControl.verify();
308     }
309 
310     public void testFaultFlow() throws Exception {
311         MockControl adapterControl = MockControl.createControl(EndpointAdapter.class);
312         EndpointAdapter adapterMock = (EndpointAdapter) adapterControl.getMock();
313         dispatcher.setEndpointAdapters(Collections.singletonList(adapterMock));
314 
315         Object endpoint = new Object();
316         adapterControl.expectAndReturn(adapterMock.supports(endpoint), true);
317 
318         MockControl mappingControl = MockControl.createControl(EndpointMapping.class);
319         EndpointMapping mappingMock = (EndpointMapping) mappingControl.getMock();
320         dispatcher.setEndpointMappings(Collections.singletonList(mappingMock));
321 
322         MockControl interceptorControl = MockControl.createStrictControl(EndpointInterceptor.class);
323         EndpointInterceptor interceptorMock = (EndpointInterceptor) interceptorControl.getMock();
324 
325         interceptorControl.expectAndReturn(interceptorMock.handleRequest(messageContext, endpoint), true);
326         adapterMock.invoke(messageContext, endpoint);
327         interceptorControl.expectAndReturn(interceptorMock.handleFault(messageContext, endpoint), true);
328 
329         EndpointInvocationChain chain =
330                 new EndpointInvocationChain(endpoint, new EndpointInterceptor[]{interceptorMock});
331 
332         mappingControl.expectAndReturn(mappingMock.getEndpoint(messageContext), chain);
333         MockWebServiceMessage response = new MockWebServiceMessage();
334         response.setFault(true);
335         factoryControl.expectAndReturn(factoryMock.createWebServiceMessage(), response);
336 
337         mappingControl.replay();
338         interceptorControl.replay();
339         adapterControl.replay();
340         factoryControl.replay();
341         //  response required for interceptor invocation
342         messageContext.getResponse();
343         dispatcher.dispatch(messageContext);
344 
345         mappingControl.verify();
346         interceptorControl.verify();
347         adapterControl.verify();
348         factoryControl.verify();
349     }
350 
351     public void testNoEndpointFound() throws Exception {
352         dispatcher.setEndpointMappings(Collections.EMPTY_LIST);
353         try {
354             dispatcher.receive(messageContext);
355             fail("NoEndpointFoundException expected");
356         }
357         catch (NoEndpointFoundException ex) {
358             // expected
359         }
360     }
361 
362     public void testDetectStrategies() throws Exception {
363         StaticApplicationContext applicationContext = new StaticApplicationContext();
364         applicationContext.registerSingleton("mapping", PayloadRootQNameEndpointMapping.class);
365         applicationContext.registerSingleton("adapter", PayloadEndpointAdapter.class);
366         applicationContext.registerSingleton("resolver", SimpleSoapExceptionResolver.class);
367         dispatcher.setApplicationContext(applicationContext);
368         assertEquals("Invalid amount of mappings detected", 1, dispatcher.getEndpointMappings().size());
369         assertTrue("Invalid mappings detected",
370                 dispatcher.getEndpointMappings().get(0) instanceof PayloadRootQNameEndpointMapping);
371         assertEquals("Invalid amount of adapters detected", 1, dispatcher.getEndpointAdapters().size());
372         assertTrue("Invalid mappings detected",
373                 dispatcher.getEndpointAdapters().get(0) instanceof PayloadEndpointAdapter);
374         assertEquals("Invalid amount of resolvers detected", 1, dispatcher.getEndpointExceptionResolvers().size());
375         assertTrue("Invalid mappings detected",
376                 dispatcher.getEndpointExceptionResolvers().get(0) instanceof SimpleSoapExceptionResolver);
377     }
378 
379     public void testDefaultStrategies() throws Exception {
380         StaticApplicationContext applicationContext = new StaticApplicationContext();
381         dispatcher.setApplicationContext(applicationContext);
382     }
383 
384 }