1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
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
130 expect(argumentResolver1.supportsParameter(isA(MethodParameter.class))).andReturn(true);
131 expect(argumentResolver1.resolveArgument(eq(messageContext), isA(MethodParameter.class))).andReturn(value);
132
133
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
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 }