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.method;
18  
19  import java.lang.reflect.Method;
20  
21  import org.springframework.core.MethodParameter;
22  import org.springframework.ws.MockWebServiceMessage;
23  import org.springframework.ws.MockWebServiceMessageFactory;
24  import org.springframework.ws.context.DefaultMessageContext;
25  import org.springframework.ws.context.MessageContext;
26  import org.springframework.ws.server.endpoint.annotation.Namespace;
27  import org.springframework.ws.server.endpoint.annotation.Namespaces;
28  import org.springframework.ws.server.endpoint.annotation.XPathParam;
29  
30  import org.junit.Before;
31  import org.junit.Test;
32  import org.w3c.dom.Node;
33  import org.w3c.dom.NodeList;
34  
35  import static org.junit.Assert.*;
36  
37  @Namespaces(@Namespace(prefix = "tns", uri = "http://springframework.org/spring-ws"))
38  public class XPathParamMethodArgumentResolverTest {
39  
40      private static final String CONTENTS = "<root><child><text>text</text><number>42</number></child></root>";
41  
42      private XPathParamMethodArgumentResolver resolver;
43  
44      private MethodParameter booleanParameter;
45  
46      private MethodParameter doubleParameter;
47  
48      private MethodParameter nodeParameter;
49  
50      private MethodParameter nodeListParameter;
51  
52      private MethodParameter stringParameter;
53  
54      private MethodParameter convertedParameter;
55  
56      private MethodParameter unsupportedParameter;
57  
58      private MethodParameter namespaceMethodParameter;
59  
60      private MethodParameter namespaceClassParameter;
61  
62      @Before
63      public void setUp() throws Exception {
64          resolver = new XPathParamMethodArgumentResolver();
65          Method supportedTypes = getClass()
66                  .getMethod("supportedTypes", Boolean.TYPE, Double.TYPE, Node.class, NodeList.class, String.class);
67          booleanParameter = new MethodParameter(supportedTypes, 0);
68          doubleParameter = new MethodParameter(supportedTypes, 1);
69          nodeParameter = new MethodParameter(supportedTypes, 2);
70          nodeListParameter = new MethodParameter(supportedTypes, 3);
71          stringParameter = new MethodParameter(supportedTypes, 4);
72          convertedParameter = new MethodParameter(getClass().getMethod("convertedType", Integer.TYPE), 0);
73          unsupportedParameter = new MethodParameter(getClass().getMethod("unsupported", String.class), 0);
74          namespaceMethodParameter = new MethodParameter(getClass().getMethod("namespacesMethod", String.class), 0);
75          namespaceClassParameter = new MethodParameter(getClass().getMethod("namespacesClass", String.class), 0);
76      }
77  
78      @Test
79      public void supportsParameter() {
80          assertTrue("resolver does not support boolean parameter", resolver.supportsParameter(booleanParameter));
81          assertTrue("resolver does not support double parameter", resolver.supportsParameter(doubleParameter));
82          assertTrue("resolver does not support Node parameter", resolver.supportsParameter(nodeParameter));
83          assertTrue("resolver does not support NodeList parameter", resolver.supportsParameter(nodeListParameter));
84          assertTrue("resolver does not support String parameter", resolver.supportsParameter(stringParameter));
85          assertTrue("resolver does not support String parameter", resolver.supportsParameter(convertedParameter));
86          assertFalse("resolver supports parameter without @XPathParam", resolver.supportsParameter(unsupportedParameter));
87      }
88  
89      @Test
90      public void resolveBoolean() throws Exception {
91          MockWebServiceMessage request = new MockWebServiceMessage(CONTENTS);
92          MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
93  
94          Object result = resolver.resolveArgument(messageContext, booleanParameter);
95  
96          assertTrue("resolver does not return boolean", result instanceof Boolean);
97          Boolean b = (Boolean) result;
98          assertTrue("Invalid boolean value", b);
99      }
100     @Test
101     public void resolveDouble() throws Exception {
102         MockWebServiceMessage request = new MockWebServiceMessage(CONTENTS);
103         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
104 
105         Object result = resolver.resolveArgument(messageContext, doubleParameter);
106 
107         assertTrue("resolver does not return double", result instanceof Double);
108         Double d = (Double) result;
109         assertEquals("Invalid double value", 42D, d, 0D);
110     }
111 
112     @Test
113     public void resolveNode() throws Exception {
114         MockWebServiceMessage request = new MockWebServiceMessage(CONTENTS);
115         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
116 
117         Object result = resolver.resolveArgument(messageContext, nodeParameter);
118 
119         assertTrue("resolver does not return Node", result instanceof Node);
120         Node node  = (Node) result;
121         assertEquals("Invalid node value", "child", node.getLocalName());
122     }
123 
124     @Test
125     public void resolveNodeList() throws Exception {
126         MockWebServiceMessage request = new MockWebServiceMessage(CONTENTS);
127         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
128 
129         Object result = resolver.resolveArgument(messageContext, nodeListParameter);
130 
131         assertTrue("resolver does not return NodeList", result instanceof NodeList);
132         NodeList nodeList  = (NodeList) result;
133         assertEquals("Invalid NodeList value", 1, nodeList.getLength());
134         assertEquals("Invalid Node value", "child", nodeList.item(0).getLocalName());
135     }
136 
137     @Test
138     public void resolveString() throws Exception {
139         MockWebServiceMessage request = new MockWebServiceMessage(CONTENTS);
140         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
141 
142         Object result = resolver.resolveArgument(messageContext, stringParameter);
143 
144         assertTrue("resolver does not return String", result instanceof String);
145         String s  = (String) result;
146         assertEquals("Invalid string value", "text", s);
147     }
148     
149     @Test
150     public void resolveConvertedType() throws Exception {
151         MockWebServiceMessage request = new MockWebServiceMessage(CONTENTS);
152         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
153 
154         Object result = resolver.resolveArgument(messageContext, convertedParameter);
155 
156         assertTrue("resolver does not return String", result instanceof Integer);
157         Integer i  = (Integer) result;
158         assertEquals("Invalid integer value", new Integer(42), i);
159     }
160 
161     @Test
162     public void resolveNamespacesMethod() throws Exception {
163         MockWebServiceMessage request = new MockWebServiceMessage(
164                 "<root xmlns=\"http://springframework.org/spring-ws\">text</root>");
165         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
166 
167         Object result = resolver.resolveArgument(messageContext, namespaceMethodParameter);
168 
169         assertTrue("resolver does not return String", result instanceof String);
170         String s  = (String) result;
171         assertEquals("Invalid string value", "text", s);
172     }
173     
174     @Test
175     public void resolveNamespacesClass() throws Exception {
176         MockWebServiceMessage request = new MockWebServiceMessage(
177                 "<root xmlns=\"http://springframework.org/spring-ws\">text</root>");
178         MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
179 
180         Object result = resolver.resolveArgument(messageContext, namespaceClassParameter);
181 
182         assertTrue("resolver does not return String", result instanceof String);
183         String s  = (String) result;
184         assertEquals("Invalid string value", "text", s);
185     }
186 
187     public void unsupported(String s) {
188     }
189 
190     public void supportedTypes(@XPathParam("/root/child")boolean param1,
191                                @XPathParam("/root/child/number")double param2,
192                                @XPathParam("/root/child") Node param3,
193                                @XPathParam("/root/*") NodeList param4,
194                                @XPathParam("/root/child/text")String param5) {
195     }
196 
197     public void convertedType(@XPathParam("/root/child/number")int param) {
198     }
199 
200     @Namespaces(@Namespace(prefix = "tns", uri = "http://springframework.org/spring-ws"))
201     public void namespacesMethod(@XPathParam("/tns:root")String s) {
202     }
203 
204     public void namespacesClass(@XPathParam("/tns:root")String s) {
205     }
206 
207 }