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;
18  
19  import javax.xml.soap.MessageFactory;
20  import javax.xml.stream.XMLOutputFactory;
21  import javax.xml.stream.XMLStreamConstants;
22  import javax.xml.stream.XMLStreamReader;
23  import javax.xml.stream.XMLStreamWriter;
24  import javax.xml.transform.Transformer;
25  import javax.xml.transform.TransformerFactory;
26  
27  import org.springframework.ws.context.DefaultMessageContext;
28  import org.springframework.ws.context.MessageContext;
29  import org.springframework.ws.soap.axiom.AxiomSoapMessage;
30  import org.springframework.ws.soap.axiom.AxiomSoapMessageFactory;
31  import org.springframework.ws.soap.saaj.SaajSoapMessage;
32  import org.springframework.ws.soap.saaj.SaajSoapMessageFactory;
33  import org.springframework.xml.transform.StringResult;
34  import org.springframework.xml.transform.StringSource;
35  
36  import org.apache.axiom.om.OMAbstractFactory;
37  import org.apache.axiom.soap.SOAPFactory;
38  import org.junit.Test;
39  
40  import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
41  import static org.junit.Assert.*;
42  
43  /**
44   * Test case for AbstractStaxStreamPayloadEndpoint.
45   *
46   * @see AbstractStaxStreamPayloadEndpoint
47   */
48  @SuppressWarnings("Since15")
49  public class StaxStreamPayloadEndpointTest extends AbstractMessageEndpointTestCase {
50  
51      @Override
52      protected MessageEndpoint createNoResponseEndpoint() {
53          return new AbstractStaxStreamPayloadEndpoint() {
54              @Override
55              protected void invokeInternal(XMLStreamReader streamReader, XMLStreamWriter streamWriter) throws Exception {
56                  assertNotNull("No StreamReader passed", streamReader);
57              }
58          };
59      }
60  
61      @Override
62      protected MessageEndpoint createNoRequestPayloadEndpoint() {
63          return new AbstractStaxStreamPayloadEndpoint() {
64              @Override
65              protected void invokeInternal(XMLStreamReader streamReader, XMLStreamWriter streamWriter) throws Exception {
66                  assertNull("StreamReader passed", streamReader);
67              }
68          };
69      }
70  
71      @Override
72      protected MessageEndpoint createResponseEndpoint() {
73          return new AbstractStaxStreamPayloadEndpoint() {
74              @Override
75              protected void invokeInternal(XMLStreamReader streamReader, XMLStreamWriter streamWriter) throws Exception {
76                  assertNotNull("No streamReader passed", streamReader);
77                  assertNotNull("No streamWriter passed", streamReader);
78                  assertEquals("Not a start element", XMLStreamConstants.START_ELEMENT, streamReader.next());
79                  assertEquals("Invalid start event local name", REQUEST_ELEMENT, streamReader.getLocalName());
80                  assertEquals("Invalid start event namespace", NAMESPACE_URI, streamReader.getNamespaceURI());
81                  assertTrue("streamReader has no next element", streamReader.hasNext());
82                  assertEquals("Not a end element", XMLStreamConstants.END_ELEMENT, streamReader.next());
83                  assertEquals("Invalid end event local name", REQUEST_ELEMENT, streamReader.getLocalName());
84                  assertEquals("Invalid end event namespace", NAMESPACE_URI, streamReader.getNamespaceURI());
85                  streamWriter.setDefaultNamespace(NAMESPACE_URI);
86                  streamWriter.writeStartElement(NAMESPACE_URI, RESPONSE_ELEMENT);
87                  streamWriter.writeDefaultNamespace(NAMESPACE_URI);
88                  streamWriter.writeEndElement();
89                  streamWriter.flush();
90                  streamWriter.close();
91              }
92  
93              @Override
94              protected XMLOutputFactory createXmlOutputFactory() {
95                  XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
96                  outputFactory.setProperty("javax.xml.stream.isRepairingNamespaces", Boolean.TRUE);
97                  return outputFactory;
98              }
99          };
100     }
101 
102     @Test
103     public void testSaajResponse() throws Exception {
104         Transformer transformer = TransformerFactory.newInstance().newTransformer();
105         MessageFactory messageFactory = MessageFactory.newInstance();
106         SaajSoapMessage request = new SaajSoapMessage(messageFactory.createMessage());
107         transformer.transform(new StringSource(REQUEST), request.getPayloadResult());
108         SaajSoapMessageFactory soapMessageFactory = new SaajSoapMessageFactory();
109         soapMessageFactory.afterPropertiesSet();
110         MessageContext context = new DefaultMessageContext(request, soapMessageFactory);
111 
112         MessageEndpoint endpoint = createResponseEndpoint();
113         endpoint.invoke(context);
114         assertTrue("context has not response", context.hasResponse());
115         StringResult stringResult = new StringResult();
116         transformer.transform(context.getResponse().getPayloadSource(), stringResult);
117         assertXMLEqual(RESPONSE, stringResult.toString());
118     }
119 
120     @Test
121     public void testAxiomResponse() throws Exception {
122         Transformer transformer = TransformerFactory.newInstance().newTransformer();
123         SOAPFactory axiomFactory = OMAbstractFactory.getSOAP11Factory();
124         AxiomSoapMessage request = new AxiomSoapMessage(axiomFactory);
125         transformer.transform(new StringSource(REQUEST), request.getPayloadResult());
126         AxiomSoapMessageFactory soapMessageFactory = new AxiomSoapMessageFactory();
127         soapMessageFactory.afterPropertiesSet();
128         MessageContext context = new DefaultMessageContext(request, soapMessageFactory);
129 
130         MessageEndpoint endpoint = createResponseEndpoint();
131         endpoint.invoke(context);
132         assertTrue("context has not response", context.hasResponse());
133         StringResult stringResult = new StringResult();
134         transformer.transform(context.getResponse().getPayloadSource(), stringResult);
135         assertXMLEqual(RESPONSE, stringResult.toString());
136     }
137 
138     @Test
139     public void testAxiomNoResponse() throws Exception {
140         Transformer transformer = TransformerFactory.newInstance().newTransformer();
141         SOAPFactory axiomFactory = OMAbstractFactory.getSOAP11Factory();
142         AxiomSoapMessage request = new AxiomSoapMessage(axiomFactory);
143         transformer.transform(new StringSource(REQUEST), request.getPayloadResult());
144         AxiomSoapMessageFactory soapMessageFactory = new AxiomSoapMessageFactory();
145         soapMessageFactory.afterPropertiesSet();
146         MessageContext context = new DefaultMessageContext(request, soapMessageFactory);
147 
148         MessageEndpoint endpoint = createNoResponseEndpoint();
149         endpoint.invoke(context);
150         assertFalse("context has response", context.hasResponse());
151     }
152 
153     @Test
154     public void testAxiomResponseNoPayloadCaching() throws Exception {
155         Transformer transformer = TransformerFactory.newInstance().newTransformer();
156         SOAPFactory axiomFactory = OMAbstractFactory.getSOAP11Factory();
157         AxiomSoapMessage request = new AxiomSoapMessage(axiomFactory);
158         transformer.transform(new StringSource(REQUEST), request.getPayloadResult());
159         AxiomSoapMessageFactory soapMessageFactory = new AxiomSoapMessageFactory();
160         soapMessageFactory.setPayloadCaching(false);
161         soapMessageFactory.afterPropertiesSet();
162         MessageContext context = new DefaultMessageContext(request, soapMessageFactory);
163 
164         MessageEndpoint endpoint = createResponseEndpoint();
165         endpoint.invoke(context);
166         assertTrue("context has not response", context.hasResponse());
167 
168         StringResult stringResult = new StringResult();
169         transformer.transform(context.getResponse().getPayloadSource(), stringResult);
170         assertXMLEqual(RESPONSE, stringResult.toString());
171     }
172 
173     @Test
174     public void testAxiomNoResponseNoPayloadCaching() throws Exception {
175         Transformer transformer = TransformerFactory.newInstance().newTransformer();
176         SOAPFactory axiomFactory = OMAbstractFactory.getSOAP11Factory();
177         AxiomSoapMessage request = new AxiomSoapMessage(axiomFactory);
178         transformer.transform(new StringSource(REQUEST), request.getPayloadResult());
179         AxiomSoapMessageFactory soapMessageFactory = new AxiomSoapMessageFactory();
180         soapMessageFactory.setPayloadCaching(false);
181         soapMessageFactory.afterPropertiesSet();
182         MessageContext context = new DefaultMessageContext(request, soapMessageFactory);
183 
184         MessageEndpoint endpoint = createNoResponseEndpoint();
185         endpoint.invoke(context);
186         assertFalse("context has response", context.hasResponse());
187     }
188 
189 
190 }