1   /*
2    * Copyright 2005-2010 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.endpoint.adapter;
18  
19  import java.io.IOException;
20  import java.util.Arrays;
21  import java.util.Collections;
22  
23  import org.springframework.core.MethodParameter;
24  import org.springframework.ws.MockWebServiceMessage;
25  import org.springframework.ws.MockWebServiceMessageFactory;
26  import org.springframework.ws.context.DefaultMessageContext;
27  import org.springframework.ws.context.MessageContext;
28  import org.springframework.ws.server.endpoint.MethodEndpoint;
29  import org.springframework.ws.server.endpoint.adapter.method.MethodArgumentResolver;
30  import org.springframework.ws.server.endpoint.adapter.method.MethodReturnValueHandler;
31  
32  import org.junit.Before;
33  import org.junit.Test;
34  
35  import static org.easymock.EasyMock.*;
36  import static org.junit.Assert.*;
37  
38  /** @author Arjen Poutsma */
39  public class DefaultMethodEndpointAdapterTest {
40  
41      private DefaultMethodEndpointAdapter adapter;
42  
43      private MethodArgumentResolver argumentResolver1;
44  
45      private MethodArgumentResolver argumentResolver2;
46  
47      private MethodReturnValueHandler returnValueHandler;
48  
49      private MethodEndpoint supportedEndpoint;
50  
51      private MethodEndpoint unsupportedEndpoint;
52  
53      private MethodEndpoint exceptionEndpoint;
54  
55      private String supportedArgument;
56  
57      @Before
58      public void setUp() throws Exception {
59          adapter = new DefaultMethodEndpointAdapter();
60          argumentResolver1 = createMock("stringResolver", MethodArgumentResolver.class);
61          argumentResolver2 = createMock("intResolver", MethodArgumentResolver.class);
62          returnValueHandler = createMock(MethodReturnValueHandler.class);
63          adapter.setMethodArgumentResolvers(Arrays.asList(argumentResolver1, argumentResolver2));
64          adapter.setMethodReturnValueHandlers(Collections.singletonList(returnValueHandler));
65          supportedEndpoint = new MethodEndpoint(this, "supported", String.class, Integer.class);
66          unsupportedEndpoint = new MethodEndpoint(this, "unsupported", String.class);
67          exceptionEndpoint = new MethodEndpoint(this, "exception", String.class);
68      }
69  
70      @Test
71      public void initDefaultStrategies() throws Exception {
72          adapter = new DefaultMethodEndpointAdapter();
73          adapter.setBeanClassLoader(DefaultMethodEndpointAdapterTest.class.getClassLoader());
74          adapter.afterPropertiesSet();
75  
76          assertFalse("No default MethodArgumentResolvers loaded", adapter.getMethodArgumentResolvers().isEmpty());
77          assertFalse("No default MethodReturnValueHandlers loaded", adapter.getMethodReturnValueHandlers().isEmpty());
78      }
79  
80      @Test
81      public void supportsSupported() throws Exception {
82          expect(argumentResolver1.supportsParameter(isA(MethodParameter.class))).andReturn(true);
83          expect(argumentResolver1.supportsParameter(isA(MethodParameter.class))).andReturn(false);
84          expect(argumentResolver2.supportsParameter(isA(MethodParameter.class))).andReturn(true);
85          expect(returnValueHandler.supportsReturnType(isA(MethodParameter.class))).andReturn(true);
86  
87          replay(argumentResolver1, argumentResolver2, returnValueHandler);
88  
89          boolean result = adapter.supports(supportedEndpoint);
90          assertTrue("adapter does not support method", result);
91  
92          verify(argumentResolver1, argumentResolver2, returnValueHandler);
93      }
94  
95      @Test
96      public void supportsUnsupportedParameter() throws Exception {
97          expect(argumentResolver1.supportsParameter(isA(MethodParameter.class))).andReturn(false);
98          expect(argumentResolver2.supportsParameter(isA(MethodParameter.class))).andReturn(false);
99  
100         replay(argumentResolver1, argumentResolver2, returnValueHandler);
101 
102 
103         boolean result = adapter.supports(unsupportedEndpoint);
104         assertFalse("adapter does not support method", result);
105 
106         verify(argumentResolver1, argumentResolver2, returnValueHandler);
107     }
108 
109     @Test
110     public void supportsUnsupportedReturnType() throws Exception {
111         expect(argumentResolver1.supportsParameter(isA(MethodParameter.class))).andReturn(true);
112         expect(returnValueHandler.supportsReturnType(isA(MethodParameter.class))).andReturn(false);
113 
114         replay(argumentResolver1, argumentResolver2, returnValueHandler);
115 
116         boolean result = adapter.supports(unsupportedEndpoint);
117         assertFalse("adapter does not support method", result);
118 
119         verify(argumentResolver1, argumentResolver2, returnValueHandler);
120     }
121 
122     @Test
123     public void invokeSupported() throws Exception {
124         MockWebServiceMessage request = new MockWebServiceMessage("<root xmlns='http://springframework.org'/>");
125         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
126 
127         String value = "Foo";
128 
129         // arg 0
130         expect(argumentResolver1.supportsParameter(isA(MethodParameter.class))).andReturn(true);
131         expect(argumentResolver1.resolveArgument(eq(messageContext), isA(MethodParameter.class))).andReturn(value);
132 
133         // arg 1
134         expect(argumentResolver1.supportsParameter(isA(MethodParameter.class))).andReturn(false);
135         expect(argumentResolver2.supportsParameter(isA(MethodParameter.class))).andReturn(true);
136         expect(argumentResolver2.resolveArgument(eq(messageContext), isA(MethodParameter.class))).andReturn(new Integer(42));
137 
138         expect(returnValueHandler.supportsReturnType(isA(MethodParameter.class))).andReturn(true);
139         returnValueHandler.handleReturnValue(eq(messageContext), isA(MethodParameter.class), eq(value));
140 
141         replay(argumentResolver1, argumentResolver2, returnValueHandler);
142 
143         adapter.invoke(messageContext, supportedEndpoint);
144         assertEquals("Invalid argument passed", value, supportedArgument);
145 
146         verify(argumentResolver1, argumentResolver2, returnValueHandler);
147     }
148 
149     @Test
150     public void invokeException() throws Exception {
151         MockWebServiceMessage request = new MockWebServiceMessage("<root xmlns='http://springframework.org'/>");
152         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
153 
154         String value = "Foo";
155 
156         expect(argumentResolver1.supportsParameter(isA(MethodParameter.class))).andReturn(true);
157         expect(argumentResolver1.resolveArgument(eq(messageContext), isA(MethodParameter.class))).andReturn(value);
158 
159 
160         replay(argumentResolver1, argumentResolver2, returnValueHandler);
161 
162         try {
163             adapter.invoke(messageContext, exceptionEndpoint);
164             fail("IOException expected");
165         }
166         catch (IOException expected) {
167             // expected
168         }
169         assertEquals("Invalid argument passed", value, supportedArgument);
170 
171         verify(argumentResolver1, argumentResolver2, returnValueHandler);
172     }
173 
174     public String supported(String s, Integer i) {
175         supportedArgument = s;
176         return s;
177 
178     }
179 
180     public String unsupported(String s) {
181         return s;
182     }
183 
184     public String exception(String s) throws IOException {
185         supportedArgument = s;
186         throw new IOException(s);
187     }
188 }