1   /*
2    * Copyright 2006 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.transport.http;
18  
19  import java.io.ByteArrayInputStream;
20  import java.io.InputStream;
21  import java.net.URI;
22  import javax.servlet.http.HttpServletResponse;
23  import javax.wsdl.Definition;
24  import javax.wsdl.factory.WSDLFactory;
25  import javax.wsdl.xml.WSDLReader;
26  import javax.xml.parsers.DocumentBuilder;
27  import javax.xml.parsers.DocumentBuilderFactory;
28  
29  import org.custommonkey.xmlunit.XMLTestCase;
30  import org.easymock.MockControl;
31  import org.springframework.core.io.ClassPathResource;
32  import org.springframework.mock.web.MockHttpServletRequest;
33  import org.springframework.mock.web.MockHttpServletResponse;
34  import org.springframework.ws.wsdl.WsdlDefinition;
35  import org.springframework.ws.wsdl.wsdl11.SimpleWsdl11Definition;
36  import org.springframework.xml.transform.StringSource;
37  import org.w3c.dom.Document;
38  import org.xml.sax.InputSource;
39  
40  public class WsdlDefinitionHandlerAdapterTest extends XMLTestCase {
41  
42      private WsdlDefinitionHandlerAdapter adapter;
43  
44      private MockControl definitionControl;
45  
46      private WsdlDefinition definitionMock;
47  
48      private MockHttpServletRequest request;
49  
50      private MockHttpServletResponse response;
51  
52      protected void setUp() throws Exception {
53          adapter = new WsdlDefinitionHandlerAdapter();
54          definitionControl = MockControl.createControl(WsdlDefinition.class);
55          definitionMock = (WsdlDefinition) definitionControl.getMock();
56          adapter.afterPropertiesSet();
57          request = new MockHttpServletRequest();
58          response = new MockHttpServletResponse();
59      }
60  
61      public void testHandleGet() throws Exception {
62          request.setMethod("GET");
63          String definition = "<definition xmlns='http://schemas.xmlsoap.org/wsdl/'/>";
64          definitionControl.expectAndReturn(definitionMock.getSource(), new StringSource(definition));
65          definitionControl.replay();
66          adapter.handle(request, response, definitionMock);
67          assertXMLEqual(definition, response.getContentAsString());
68          definitionControl.verify();
69      }
70  
71      public void testHandleNonGet() throws Exception {
72          request.setMethod("POST");
73          definitionControl.replay();
74          adapter.handle(request, response, definitionMock);
75          definitionControl.verify();
76          assertEquals("METHOD_NOT_ALLOWED expected", HttpServletResponse.SC_METHOD_NOT_ALLOWED, response.getStatus());
77  
78      }
79  
80      public void testTransformLocations() throws Exception {
81          adapter.setTransformLocations(true);
82          request.setMethod("GET");
83          request.setScheme("http");
84          request.setServerName("example.com");
85          request.setServerPort(8080);
86          request.setContextPath("/context");
87          request.setServletPath("/service.wsdl");
88          request.setPathInfo(null);
89          request.setRequestURI("/context/service.wsdl");
90          definitionControl.replay();
91  
92          DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
93          documentBuilderFactory.setNamespaceAware(true);
94          DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
95          Document result = documentBuilder.parse(getClass().getResourceAsStream("wsdl11-input.wsdl"));
96          adapter.transformLocations(result, request);
97          Document expectedDocument = documentBuilder.parse(getClass().getResourceAsStream("wsdl11-expected.wsdl"));
98          assertXMLEqual("Invalid result", expectedDocument, result);
99  
100         definitionControl.verify();
101     }
102 
103     public void testTransformLocationFullUrl() throws Exception {
104         request.setScheme("http");
105         request.setServerName("example.com");
106         request.setServerPort(8080);
107         request.setContextPath("/context");
108         request.setPathInfo("/service.wsdl");
109         request.setRequestURI("/context/service.wsdl");
110         String oldLocation = "http://localhost:8080/context/service";
111 
112         String result = adapter.transformLocation(oldLocation, request);
113         assertNotNull("No result", result);
114         assertEquals("Invalid result", new URI("http://example.com:8080/context/service"), new URI(result));
115     }
116 
117     public void testTransformLocationEmptyContextFullUrl() throws Exception {
118         request.setScheme("http");
119         request.setServerName("example.com");
120         request.setServerPort(8080);
121         request.setContextPath("");
122         request.setRequestURI("/service.wsdl");
123         String oldLocation = "http://localhost:8080/service";
124 
125         String result = adapter.transformLocation(oldLocation, request);
126         assertNotNull("No result", result);
127         assertEquals("Invalid result", new URI("http://example.com:8080/service"), new URI(result));
128     }
129 
130     public void testTransformLocationRelativeUrl() throws Exception {
131         request.setScheme("http");
132         request.setServerName("example.com");
133         request.setServerPort(8080);
134         request.setContextPath("/context");
135         request.setPathInfo("/service.wsdl");
136         request.setRequestURI("/context/service.wsdl");
137         String oldLocation = "/service";
138 
139         String result = adapter.transformLocation(oldLocation, request);
140         assertNotNull("No result", result);
141         assertEquals("Invalid result", new URI("http://example.com:8080/context/service"), new URI(result));
142     }
143 
144     public void testTransformLocationEmptyContextRelativeUrl() throws Exception {
145         request.setScheme("http");
146         request.setServerName("example.com");
147         request.setServerPort(8080);
148         request.setContextPath("");
149         request.setRequestURI("/service.wsdl");
150         String oldLocation = "/service";
151 
152         String result = adapter.transformLocation(oldLocation, request);
153         assertNotNull("No result", result);
154         assertEquals("Invalid result", new URI("http://example.com:8080/service"), new URI(result));
155     }
156 
157     public void testHandleSimpleWsdl11DefinitionWithoutTransformLocations() throws Exception {
158         adapter.setTransformLocations(false);
159         request.setMethod("GET");
160         request.setScheme("http");
161         request.setServerName("example.com");
162         request.setServerPort(8080);
163         request.setContextPath("/context");
164         request.setServletPath("/service.wsdl");
165         request.setPathInfo(null);
166         request.setRequestURI("/context/service.wsdl");
167 
168         SimpleWsdl11Definition definition =
169                 new SimpleWsdl11Definition(new ClassPathResource("echo-input.wsdl", getClass()));
170 
171         adapter.handle(request, response, definition);
172         InputStream inputStream = new ByteArrayInputStream(response.getContentAsByteArray());
173 
174         WSDLFactory factory = WSDLFactory.newInstance();
175         WSDLReader reader = factory.newWSDLReader();
176         Definition wsdl4jDefinition = reader.readWSDL(null, new InputSource(inputStream));
177         assertNotNull("No definition read", wsdl4jDefinition);
178 
179         inputStream = new ByteArrayInputStream(response.getContentAsByteArray());
180         DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
181         documentBuilderFactory.setNamespaceAware(true);
182         DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
183         Document resultingDocument = documentBuilder.parse(inputStream);
184 
185         documentBuilder = documentBuilderFactory.newDocumentBuilder();
186         Document expectedDocument = documentBuilder.parse(getClass().getResourceAsStream("echo-input.wsdl"));
187         assertXMLEqual("Invalid WSDL returned", expectedDocument, resultingDocument);
188     }
189 
190     public void testHandleSimpleWsdl11DefinitionWithTransformLocation() throws Exception {
191         adapter.setTransformLocations(true);
192         request.setMethod("GET");
193         request.setScheme("http");
194         request.setServerName("example.com");
195         request.setServerPort(8080);
196         request.setContextPath("/context");
197         request.setServletPath("/service.wsdl");
198         request.setPathInfo(null);
199         request.setRequestURI("/context/service.wsdl");
200 
201         SimpleWsdl11Definition definition =
202                 new SimpleWsdl11Definition(new ClassPathResource("echo-input.wsdl", getClass()));
203 
204         adapter.handle(request, response, definition);
205         InputStream inputStream = new ByteArrayInputStream(response.getContentAsByteArray());
206 
207         WSDLFactory factory = WSDLFactory.newInstance();
208         WSDLReader reader = factory.newWSDLReader();
209         Definition wsdl4jDefinition = reader.readWSDL(null, new InputSource(inputStream));
210         assertNotNull("No definition read", wsdl4jDefinition);
211 
212         inputStream = new ByteArrayInputStream(response.getContentAsByteArray());
213         DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
214         documentBuilderFactory.setNamespaceAware(true);
215         DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
216         Document resultingDocument = documentBuilder.parse(inputStream);
217 
218         documentBuilder = documentBuilderFactory.newDocumentBuilder();
219         Document expectedDocument = documentBuilder.parse(getClass().getResourceAsStream("echo-expected.wsdl"));
220         assertXMLEqual("Invalid WSDL returned", expectedDocument, resultingDocument);
221     }
222 
223 }