| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.axis2.jaxws.message; |
| |
| import junit.framework.TestCase; |
| import org.apache.axiom.om.OMElement; |
| import org.apache.axiom.om.OMOutputFormat; |
| import org.apache.axiom.om.OMSourcedElement; |
| import org.apache.axiom.om.impl.llom.OMSourcedElementImpl; |
| import org.apache.axiom.soap.impl.builder.StAXSOAPModelBuilder; |
| import org.apache.axis2.datasource.jaxb.JAXBCustomBuilder; |
| import org.apache.axis2.datasource.jaxb.JAXBDSContext; |
| import org.apache.axis2.datasource.jaxb.JAXBDataSource; |
| import org.apache.axis2.jaxws.addressing.SubmissionEndpointReference; |
| import org.apache.axis2.jaxws.addressing.SubmissionEndpointReferenceBuilder; |
| import org.apache.axis2.jaxws.message.databinding.JAXBBlockContext; |
| import org.apache.axis2.jaxws.message.databinding.JAXBUtils; |
| import org.apache.axis2.jaxws.message.factory.JAXBBlockFactory; |
| import org.apache.axis2.jaxws.message.factory.MessageFactory; |
| import org.apache.axis2.jaxws.message.factory.SAAJConverterFactory; |
| import org.apache.axis2.jaxws.message.factory.XMLStringBlockFactory; |
| import org.apache.axis2.jaxws.message.util.SAAJConverter; |
| import org.apache.axis2.jaxws.registry.FactoryRegistry; |
| import org.apache.axis2.jaxws.unitTest.TestLogger; |
| |
| import test.EchoStringResponse; |
| import test.ObjectFactory; |
| |
| import javax.xml.bind.JAXBContext; |
| import javax.xml.namespace.QName; |
| import javax.xml.soap.SOAPEnvelope; |
| import javax.xml.soap.SOAPMessage; |
| import javax.xml.stream.XMLInputFactory; |
| import javax.xml.stream.XMLStreamReader; |
| import javax.xml.ws.wsaddressing.W3CEndpointReference; |
| import javax.xml.ws.wsaddressing.W3CEndpointReferenceBuilder; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.StringReader; |
| import java.util.TreeSet; |
| |
| /** |
| * MessageTests |
| * Tests to create and validate Message processing |
| * These are not client/server tests. |
| * Instead the tests simulate the processing of a Message during client/server processing. |
| */ |
| public class MessageTests extends TestCase { |
| |
| // String test variables |
| private static final String soap11env = "http://schemas.xmlsoap.org/soap/envelope/"; |
| private static final String soap12env = "http://www.w3.org/2003/05/soap-envelope"; |
| private static final String sampleEnvelopeHead11 = |
| "<soapenv:Envelope xmlns:soapenv=\"" + soap11env + "\">" + |
| "<soapenv:Header /><soapenv:Body>"; |
| |
| private static final String sampleEnvelopeHead12 = |
| "<soapenv:Envelope xmlns:soapenv=\"" + soap12env + "\">" + |
| "<soapenv:Header /><soapenv:Body>"; |
| |
| private static final String sampleEnvelopeTail = |
| "</soapenv:Body></soapenv:Envelope>"; |
| |
| private static final String sampleText = |
| "<pre:a xmlns:pre=\"urn://sample\">" + |
| "<b>Hello</b>" + |
| "<c>World</c>" + |
| "</pre:a>"; |
| |
| private static final String sampleDouble = |
| "<pre:a xmlns:pre=\"urn://sample\">" + |
| "<b>Hello</b>" + |
| "<c>World</c>" + |
| "</pre:a>" + |
| "<pre:aa xmlns:pre=\"urn://sample\">" + |
| "<b>Hello</b>" + |
| "<c>World</c>" + |
| "</pre:aa>"; |
| |
| private static final String sampleEnvelope11 = |
| sampleEnvelopeHead11 + |
| sampleText + |
| sampleEnvelopeTail; |
| |
| private static final String sampleEnvelope12 = |
| sampleEnvelopeHead12 + |
| sampleText + |
| sampleEnvelopeTail; |
| |
| private static final String sampleJAXBText = |
| "<echoStringResponse xmlns=\"http://test\">" + |
| "<echoStringReturn>sample return value</echoStringReturn>" + |
| "</echoStringResponse>"; |
| |
| private static final String sampleJAXBEnvelope11 = |
| sampleEnvelopeHead11 + |
| sampleJAXBText + |
| sampleEnvelopeTail; |
| |
| private static final String sampleJAXBEnvelope12 = |
| sampleEnvelopeHead12 + |
| sampleJAXBText + |
| sampleEnvelopeTail; |
| |
| private static final String sampleEnvelopeNoHeader11 = |
| "<soapenv:Envelope xmlns:soapenv=\""+ soap11env +"\">" + |
| "<soapenv:Body>" + |
| sampleText + |
| "</soapenv:Body></soapenv:Envelope>"; |
| |
| private static final String sampleEnvelopeNoHeader12 = |
| "<soapenv:Envelope xmlns:soapenv=\""+ soap12env +"\">" + |
| "<soapenv:Body>" + |
| sampleText + |
| "</soapenv:Body></soapenv:Envelope>"; |
| |
| |
| private static final QName sampleQName = new QName("urn://sample", "a"); |
| |
| private static XMLInputFactory inputFactory = XMLInputFactory.newInstance(); |
| |
| private W3CEndpointReference w3cEPR; |
| private SubmissionEndpointReference subEPR; |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| |
| W3CEndpointReferenceBuilder w3cBuilder = new W3CEndpointReferenceBuilder(); |
| w3cBuilder = w3cBuilder.address("http://somewhere.com/somehow"); |
| w3cBuilder = w3cBuilder.serviceName(new QName("http://test", "TestService")); |
| w3cBuilder = w3cBuilder.endpointName(new QName("http://test", "TestPort")); |
| w3cEPR = w3cBuilder.build(); |
| |
| SubmissionEndpointReferenceBuilder subBuilder = new SubmissionEndpointReferenceBuilder(); |
| subBuilder = subBuilder.address("http://somewhere.com/somehow"); |
| subBuilder = subBuilder.serviceName(new QName("http://test", "TestService")); |
| subBuilder = subBuilder.endpointName(new QName("http://test", "TestPort")); |
| subEPR = subBuilder.build(); |
| } |
| |
| public MessageTests() { |
| super(); |
| } |
| |
| public MessageTests(String arg0) { |
| super(arg0); |
| } |
| |
| /** |
| * Create a Block representing an XMLString and simulate a normal Dispatch<String> flow. In |
| * addition the test makes sure that the XMLString block is not expanded during this process. |
| * (Expanding the block degrades performance). |
| * |
| * @throws Exception |
| */ |
| public void testStringOutflow() throws Exception { |
| |
| // Create a SOAP 1.1 Message |
| MessageFactory mf = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.create(Protocol.soap11); |
| |
| // Get the BlockFactory |
| XMLStringBlockFactory f = |
| (XMLStringBlockFactory) FactoryRegistry.getFactory(XMLStringBlockFactory.class); |
| |
| // Create a Block using the sample string as the content. This simulates |
| // what occurs on the outbound JAX-WS dispatch<String> client |
| Block block = f.createFrom(sampleText, null, null); |
| |
| // Add the block to the message as normal body content. |
| m.setBodyBlock(block); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SPINE".equals(m.getXMLPartContentType())); |
| |
| // On an outbound flow, we need to convert the Message |
| // to an OMElement, specifically an OM SOAPEnvelope, |
| // so we can set it on the Axis2 MessageContext |
| org.apache.axiom.soap.SOAPEnvelope env = |
| (org.apache.axiom.soap.SOAPEnvelope) m.getAsOMElement(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| // PERFORMANCE CHECK: |
| // The element in the body should be an OMSourcedElement |
| OMElement o = env.getBody().getFirstElement(); |
| assertTrue(o instanceof OMSourcedElementImpl); |
| assertTrue(((OMSourcedElementImpl) o).isExpanded() == false); |
| |
| // Serialize the Envelope using the same mechanism as the |
| // HTTP client. |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| env.serializeAndConsume(baos, new OMOutputFormat()); |
| |
| String newText = baos.toString(); |
| TestLogger.logger.debug(newText); |
| assertTrue(newText.contains(sampleText)); |
| assertTrue(newText.contains("soap")); |
| assertTrue(newText.contains("Envelope")); |
| assertTrue(newText.contains("Body")); |
| } |
| |
| /** |
| * Create a Block representing an XMLString and simulate a normal Dispatch<String> flow with an |
| * application handler. |
| * |
| * @throws Exception |
| */ |
| public void testStringOutflow2() throws Exception { |
| |
| // Create a SOAP 1.1 Message |
| MessageFactory mf = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.create(Protocol.soap11); |
| |
| // Get the BlockFactory |
| XMLStringBlockFactory f = |
| (XMLStringBlockFactory) FactoryRegistry.getFactory(XMLStringBlockFactory.class); |
| |
| // Create a Block using the sample string as the content. This simulates |
| // what occurs on the outbound JAX-WS dispatch<String> client |
| Block block = f.createFrom(sampleText, null, null); |
| |
| // Add the block to the message as normal body content. |
| m.setBodyBlock(block); |
| |
| // If there is a JAX-WS handler, the Message is converted into a SOAPEnvelope |
| SOAPEnvelope soapEnvelope = m.getAsSOAPEnvelope(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SOAPENVELOPE".equals(m.getXMLPartContentType())); |
| |
| // Normally the handler would not touch the body...but for our scenario, assume that it |
| // does. |
| String name = soapEnvelope.getBody().getFirstChild().getLocalName(); |
| assertTrue("a".equals(name)); |
| |
| // The block should be consumed at this point |
| assertTrue(block.isConsumed()); |
| |
| // After the handler processing the message is obtained as an OM |
| OMElement om = m.getAsOMElement(); |
| |
| // Serialize the Envelope using the same mechanism as the |
| // HTTP client. |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| om.serializeAndConsume(baos, new OMOutputFormat()); |
| |
| // To check that the output is correct, get the String contents of the |
| // reader |
| String newText = baos.toString(); |
| TestLogger.logger.debug(newText); |
| assertTrue(newText.contains(sampleText)); |
| assertTrue(newText.contains("soap")); |
| assertTrue(newText.contains("Envelope")); |
| assertTrue(newText.contains("Body")); |
| |
| } |
| |
| /** |
| * Create a Block representing an empty XMLString and simulate a |
| * normal Dispatch<String> flow with an application handler. |
| * @throws Exception |
| * |
| * DISABLED THIS TEST. THE TEST IS NOT VALID BECAUSE AN ATTEMPT WAS |
| * MADE TO ADD A BLOCK THAT IS NOT AN ELEMENT. |
| */ |
| public void _testStringOutflowEmptyString() throws Exception { |
| |
| // Create a SOAP 1.1 Message |
| MessageFactory mf = (MessageFactory) |
| FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.create(Protocol.soap11); |
| |
| // Get the BlockFactory |
| XMLStringBlockFactory f = (XMLStringBlockFactory) |
| FactoryRegistry.getFactory(XMLStringBlockFactory.class); |
| |
| // Sample text is whitespace. There is no element |
| |
| String whiteSpaceText = "<!-- Comment -->"; |
| // Create a Block using the sample string as the content. This simulates |
| // what occurs on the outbound JAX-WS dispatch<String> client |
| Block block = f.createFrom(whiteSpaceText, null, null); |
| |
| // Add the block to the message as normal body content. |
| m.setBodyBlock(block); |
| |
| // If there is a JAX-WS handler, the Message is converted into a SOAPEnvelope |
| SOAPEnvelope soapEnvelope = m.getAsSOAPEnvelope(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SOAPENVELOPE".equals(m.getXMLPartContentType())); |
| |
| // Normally the handler would not touch the body...but for our scenario, |
| // assume that it does. |
| // The whitespace is not preserved, so there should be no first child in the body |
| assertTrue(soapEnvelope.getBody().getFirstChild() == null); |
| |
| // The block should be consumed at this point |
| assertTrue(block.isConsumed()); |
| |
| // After the handler processing the message is obtained as an OM |
| OMElement om = m.getAsOMElement(); |
| |
| // Serialize the Envelope using the same mechanism as the |
| // HTTP client. |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| om.serializeAndConsume(baos, new OMOutputFormat()); |
| |
| // To check that the output is correct, get the String contents of the |
| // reader |
| String newText = baos.toString(); |
| TestLogger.logger.debug(newText); |
| assertTrue(newText.contains("soap")); |
| assertTrue(newText.contains("Envelope")); |
| assertTrue(newText.contains("Body")); |
| |
| } |
| |
| /** |
| * Create a Block representing an XMLString with 2 elements and simulate a |
| * normal Dispatch<String> flow with an application handler. |
| * @throws Exception |
| * |
| * @REVIEW This test is disabled because (a) it fails and (b) we don't believe this |
| * is allowed due by WSI. |
| */ |
| public void _testStringOutflowDoubleElement() throws Exception { |
| |
| // Create a SOAP 1.1 Message |
| MessageFactory mf = (MessageFactory) |
| FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.create(Protocol.soap11); |
| |
| // Get the BlockFactory |
| XMLStringBlockFactory f = (XMLStringBlockFactory) |
| FactoryRegistry.getFactory(XMLStringBlockFactory.class); |
| |
| // Create a Block using the sample string as the content. This simulates |
| // what occurs on the outbound JAX-WS dispatch<String> client |
| // In this case the sample string contains 2 elements a and aa |
| Block block = f.createFrom(this.sampleDouble, null, null); |
| |
| // Add the block to the message as normal body content. |
| m.setBodyBlock(block); |
| |
| // If there is a JAX-WS handler, the Message is converted into a SOAPEnvelope |
| SOAPEnvelope soapEnvelope = m.getAsSOAPEnvelope(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SOAPENVELOPE".equals(m.getXMLPartContentType())); |
| |
| // Normally the handler would not touch the body...but for our scenario, |
| // assume that it does. |
| String name = soapEnvelope.getBody().getFirstChild().getLocalName(); |
| assertTrue("a".equals(name)); |
| name = soapEnvelope.getBody().getLastChild().getLocalName(); |
| assertTrue("aa".equals(name)); |
| |
| // The block should be consumed at this point |
| assertTrue(block.isConsumed()); |
| |
| // After the handler processing the message is obtained as an OM |
| OMElement om = m.getAsOMElement(); |
| |
| // Serialize the Envelope using the same mechanism as the |
| // HTTP client. |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| om.serializeAndConsume(baos, new OMOutputFormat()); |
| |
| // To check that the output is correct, get the String contents of the |
| // reader |
| String newText = baos.toString(); |
| TestLogger.logger.debug(newText); |
| assertTrue(newText.contains(sampleText)); |
| assertTrue(newText.contains("soap")); |
| assertTrue(newText.contains("Envelope")); |
| assertTrue(newText.contains("Body")); |
| |
| } |
| |
| /** |
| * Create a Block representing an XMLString and simulate a normal Dispatch<String> input flow |
| * |
| * @throws Exception |
| */ |
| public void testStringInflow_soap11() throws Exception { |
| _testStringInflow(sampleEnvelope11); |
| } |
| |
| public void testStringInflow_soap12() throws Exception { |
| _testStringInflow(sampleEnvelope12); |
| } |
| |
| public void _testStringInflow(String sampleEnvelope) throws Exception { |
| |
| // On inbound, there will already be an OM |
| // which represents the message. The following code simulates the input |
| // OM |
| StringReader sr = new StringReader(sampleEnvelope); |
| XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr); |
| StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(inflow, null); |
| OMElement omElement = builder.getSOAPEnvelope(); |
| |
| // The JAX-WS layer creates a Message from the OM |
| MessageFactory mf = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.createFrom(omElement, null); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| // Assuming no handlers are installed, the next thing that will happen |
| // is the proxy code will ask for the business object (String). |
| XMLStringBlockFactory blockFactory = |
| (XMLStringBlockFactory) FactoryRegistry.getFactory(XMLStringBlockFactory.class); |
| Block block = m.getBodyBlock(null, blockFactory); |
| Object bo = block.getBusinessObject(true); |
| assertTrue(bo instanceof String); |
| |
| // The block should be consumed |
| assertTrue(block.isConsumed()); |
| |
| // Check the String for accuracy |
| assertTrue(sampleText.equals(bo.toString())); |
| |
| } |
| |
| /** |
| * Create a Block representing an XMLString and simulate a normal Dispatch<String> input flow |
| * with a JAX-WS Handler |
| * |
| * @throws Exception |
| */ |
| public void testStringInflow2_soap11() throws Exception { |
| _testStringInflow2(sampleEnvelope11); |
| } |
| |
| public void testStringInflow2_soap12() throws Exception { |
| // Only run test if an SAAJ 1.3 MessageFactory is available |
| javax.xml.soap.MessageFactory mf = null; |
| try { |
| mf = getSAAJConverter().createMessageFactory(soap12env); |
| } catch (Exception e) { |
| } |
| if (mf != null) { |
| _testStringInflow2(sampleEnvelope12); |
| } |
| } |
| |
| public void _testStringInflow2(String sampleEnvelope) throws Exception { |
| |
| // On inbound, there will already be an OM |
| // which represents the message. The following code simulates the input |
| // OM |
| StringReader sr = new StringReader(sampleEnvelope); |
| XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr); |
| StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(inflow, null); |
| OMElement omElement = builder.getSOAPEnvelope(); |
| |
| // The JAX-WS layer creates a Message from the OM |
| MessageFactory mf = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.createFrom(omElement, null); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| // If there is a JAX-WS handler, the Message is converted into a SOAPEnvelope |
| SOAPEnvelope soapEnvelope = m.getAsSOAPEnvelope(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SOAPENVELOPE".equals(m.getXMLPartContentType())); |
| |
| // Normally the handler would not touch the body...but for our scenario, assume that it |
| // does. |
| String name = soapEnvelope.getBody().getFirstChild().getLocalName(); |
| assertTrue("a".equals(name)); |
| |
| // The next thing that will happen |
| // is the proxy code will ask for the business object (String). |
| XMLStringBlockFactory blockFactory = |
| (XMLStringBlockFactory) FactoryRegistry.getFactory(XMLStringBlockFactory.class); |
| Block block = m.getBodyBlock(null, blockFactory); |
| Object bo = block.getBusinessObject(true); |
| assertTrue(bo instanceof String); |
| |
| // The block should be consumed |
| assertTrue(block.isConsumed()); |
| |
| // Check the String for accuracy |
| assertTrue(sampleText.equals(bo.toString())); |
| |
| } |
| |
| /** |
| * Create a Block representing an XMLString and simulate a normal Dispatch<String> input flow |
| * with a JAX-WS Handler that needs the whole Message |
| * |
| * @throws Exception |
| */ |
| public void testStringInflow3_soap11() throws Exception { |
| _testStringInflow3(sampleEnvelope11); |
| } |
| |
| public void testStringInflow3_soap12() throws Exception { |
| // Only run test if an SAAJ 1.3 MessageFactory is available |
| javax.xml.soap.MessageFactory mf = null; |
| try { |
| mf = getSAAJConverter().createMessageFactory(soap12env); |
| } catch (Exception e) { |
| } |
| if (mf != null) { |
| _testStringInflow3(sampleEnvelope12); |
| } |
| } |
| |
| public void _testStringInflow3(String sampleEnvelope) throws Exception { |
| |
| // On inbound, there will already be an OM |
| // which represents the message. The following code simulates the input |
| // OM |
| StringReader sr = new StringReader(sampleEnvelope); |
| XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr); |
| StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(inflow, null); |
| OMElement omElement = builder.getSOAPEnvelope(); |
| |
| // The JAX-WS layer creates a Message from the OM |
| MessageFactory mf = (MessageFactory) FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.createFrom(omElement, null); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| // If there is a JAX-WS handler, the Message is converted into a SOAPEnvelope |
| SOAPMessage sm = m.getAsSOAPMessage(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SOAPENVELOPE".equals(m.getXMLPartContentType())); |
| |
| // Normally the handler would not touch the body...but for our scenario, assume that it |
| // does. |
| String name = sm.getSOAPBody().getFirstChild().getLocalName(); |
| assertTrue("a".equals(name)); |
| |
| // The next thing that will happen |
| // is the proxy code will ask for the business object (String). |
| XMLStringBlockFactory blockFactory = |
| (XMLStringBlockFactory) FactoryRegistry.getFactory(XMLStringBlockFactory.class); |
| Block block = m.getBodyBlock(null, blockFactory); |
| Object bo = block.getBusinessObject(true); |
| assertTrue(bo instanceof String); |
| |
| // The block should be consumed |
| assertTrue(block.isConsumed()); |
| |
| // Check the String for accuracy |
| assertTrue(sampleText.equals(bo.toString())); |
| |
| } |
| |
| /** |
| * Create a Block representing an XMLString, but this time use one that |
| * doesn't have a <soap:Header> element in it. |
| * @throws Exception |
| */ |
| public void testStringInflow4_soap11() throws Exception { |
| _testStringInflow4(sampleEnvelopeNoHeader11); |
| } |
| public void testStringInflow4_soap12() throws Exception { |
| _testStringInflow4(sampleEnvelopeNoHeader12); |
| } |
| public void _testStringInflow4(String sampleEnvelopeNoHeader) throws Exception { |
| // On inbound, there will already be an OM |
| // which represents the message. The following code simulates the input |
| // OM |
| StringReader sr = new StringReader(sampleEnvelopeNoHeader); |
| XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr); |
| StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(inflow, null); |
| OMElement omElement = builder.getSOAPEnvelope(); |
| |
| // The JAX-WS layer creates a Message from the OM |
| MessageFactory mf = (MessageFactory) |
| FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.createFrom(omElement, null); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| // The next thing that will happen |
| // is the proxy code will ask for the business object (String). |
| XMLStringBlockFactory blockFactory = |
| (XMLStringBlockFactory) FactoryRegistry.getFactory(XMLStringBlockFactory.class); |
| Block block = m.getBodyBlock(null, blockFactory); |
| Object bo = block.getBusinessObject(true); |
| assertTrue(bo instanceof String); |
| |
| // The block should be consumed |
| assertTrue(block.isConsumed()); |
| |
| // Check the String for accuracy |
| assertTrue(sampleText.equals(bo.toString())); |
| |
| } |
| |
| /** |
| * Create a JAXBBlock containing a JAX-B business object |
| * and simulate a normal Dispatch<Object> output flow |
| * @throws Exception |
| */ |
| public void testJAXBOutflow() throws Exception { |
| // Create a SOAP 1.1 Message |
| MessageFactory mf = (MessageFactory) |
| FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.create(Protocol.soap11); |
| |
| // Get the BlockFactory |
| JAXBBlockFactory bf = (JAXBBlockFactory) |
| FactoryRegistry.getFactory(JAXBBlockFactory.class); |
| |
| // Create the JAX-B object |
| ObjectFactory of = new ObjectFactory(); |
| EchoStringResponse obj = of.createEchoStringResponse(); |
| obj.setEchoStringReturn("sample return value"); |
| |
| // Create the JAXBContext |
| JAXBBlockContext context = |
| new JAXBBlockContext(EchoStringResponse.class.getPackage().getName()); |
| |
| // Create a JAXBBlock using the Echo object as the content. This simulates |
| // what occurs on the outbound JAX-WS Dispatch<Object> client |
| Block block = bf.createFrom(obj, context, null); |
| |
| // Add the block to the message as normal body content. |
| m.setBodyBlock(block); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SPINE".equals(m.getXMLPartContentType())); |
| |
| // On an outbound flow, we need to convert the Message |
| // to an OMElement, specifically an OM SOAPEnvelope, |
| // so we can set it on the Axis2 MessageContext |
| org.apache.axiom.soap.SOAPEnvelope env = |
| (org.apache.axiom.soap.SOAPEnvelope) m.getAsOMElement(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| // Serialize the Envelope using the same mechanism as the |
| // HTTP client. |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| env.serializeAndConsume(baos, new OMOutputFormat()); |
| |
| // To check that the output is correct, get the String contents of the |
| // reader |
| String newText = baos.toString(); |
| TestLogger.logger.debug(newText); |
| assertTrue(newText.contains(sampleJAXBText)); |
| assertTrue(newText.contains("soap")); |
| assertTrue(newText.contains("Envelope")); |
| assertTrue(newText.contains("Body")); |
| } |
| |
| /** |
| * Create a JAXBBlock containing a JAX-B business object |
| * and simulate a normal Dispatch<Object> output flow |
| * @throws Exception |
| */ |
| public void testJAXBOutflow_W3CEndpointReference() throws Exception { |
| // Create a SOAP 1.1 Message |
| MessageFactory mf = (MessageFactory) |
| FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.create(Protocol.soap11); |
| |
| // Get the BlockFactory |
| JAXBBlockFactory bf = (JAXBBlockFactory) |
| FactoryRegistry.getFactory(JAXBBlockFactory.class); |
| |
| // Create the JAX-B object... a W3CEndpointReference |
| W3CEndpointReference obj = w3cEPR; |
| |
| |
| // Create the JAXBContext |
| Class[] classes = new Class[] {W3CEndpointReference.class}; |
| //JAXBContext jaxbContext = JAXBContext.newInstance(classes); |
| //JAXBBlockContext context = new JAXBBlockContext(jaxbContext); |
| JAXBBlockContext context = new JAXBBlockContext("javax.xml.ws.wsaddressing"); |
| |
| System.out.println("JAXBContext= " + context); |
| |
| // Create a JAXBBlock using the Echo object as the content. This simulates |
| // what occurs on the outbound JAX-WS Dispatch<Object> client |
| Block block = bf.createFrom(obj, context, null); |
| |
| // Add the block to the message as normal body content. |
| m.setBodyBlock(block); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SPINE".equals(m.getXMLPartContentType())); |
| |
| // On an outbound flow, we need to convert the Message |
| // to an OMElement, specifically an OM SOAPEnvelope, |
| // so we can set it on the Axis2 MessageContext |
| org.apache.axiom.soap.SOAPEnvelope env = |
| (org.apache.axiom.soap.SOAPEnvelope) m.getAsOMElement(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| // Serialize the Envelope using the same mechanism as the |
| // HTTP client. |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| env.serializeAndConsume(baos, new OMOutputFormat()); |
| |
| // To check that the output is correct, get the String contents of the |
| // reader |
| String newText = baos.toString(); |
| System.out.println(newText); |
| assertTrue(newText.contains("http://somewhere.com/somehow")); |
| assertTrue(newText.contains("soap")); |
| assertTrue(newText.contains("Envelope")); |
| assertTrue(newText.contains("Body")); |
| } |
| |
| /** |
| * Same as JAXBOutputflow, but has an additional check |
| * to make sure that the JAXB serialization is deferrred |
| * until the actual serialization of the message. |
| * @throws Exception |
| */ |
| public void testJAXBOutflowPerf() throws Exception { |
| // Create a SOAP 1.1 Message |
| MessageFactory mf = (MessageFactory) |
| FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.create(Protocol.soap11); |
| |
| // Get the BlockFactory |
| JAXBBlockFactory bf = (JAXBBlockFactory) |
| FactoryRegistry.getFactory(JAXBBlockFactory.class); |
| |
| // Create the JAX-B object |
| ObjectFactory of = new ObjectFactory(); |
| EchoStringResponse obj = of.createEchoStringResponse(); |
| obj.setEchoStringReturn("sample return value"); |
| |
| // Create the JAXBContext |
| JAXBBlockContext context = |
| new JAXBBlockContext(EchoStringResponse.class.getPackage().getName()); |
| |
| // Create a JAXBBlock using the Echo object as the content. This simulates |
| // what occurs on the outbound JAX-WS Dispatch<Object> client |
| Block block = bf.createFrom(obj, context, null); |
| |
| // Add the block to the message as normal body content. |
| m.setBodyBlock(block); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SPINE".equals(m.getXMLPartContentType())); |
| |
| // On an outbound flow, we need to convert the Message |
| // to an OMElement, specifically an OM SOAPEnvelope, |
| // so we can set it on the Axis2 MessageContext |
| org.apache.axiom.soap.SOAPEnvelope env = |
| (org.apache.axiom.soap.SOAPEnvelope) m.getAsOMElement(); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| // PERFORMANCE CHECK: |
| // The element in the body should be an OMSourcedElement |
| OMElement o = env.getBody().getFirstElement(); |
| assertTrue(o instanceof OMSourcedElementImpl); |
| assertTrue(((OMSourcedElementImpl)o).isExpanded() == false); |
| |
| // Serialize the Envelope using the same mechanism as the |
| // HTTP client. |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| env.serializeAndConsume(baos, new OMOutputFormat()); |
| |
| // To check that the output is correct, get the String contents of the |
| // reader |
| String newText = baos.toString(); |
| TestLogger.logger.debug(newText); |
| assertTrue(newText.contains(sampleJAXBText)); |
| assertTrue(newText.contains("soap")); |
| assertTrue(newText.contains("Envelope")); |
| assertTrue(newText.contains("Body")); |
| } |
| |
| private final int NO_PERSIST = 0; |
| private final int PERSIST = 1; |
| private final int SAVE_AND_PERSIST = 2; |
| public void testJAXBInflow_soap11() throws Exception { |
| _testJAXBInflow(sampleJAXBEnvelope11, NO_PERSIST, false); |
| } |
| public void testJAXBInflow_soap11_withCustomBuilder() throws Exception { |
| _testJAXBInflow(sampleJAXBEnvelope11, NO_PERSIST, true); |
| } |
| public void testJAXBInflow_soap12() throws Exception { |
| _testJAXBInflow(sampleJAXBEnvelope12, NO_PERSIST, false); |
| } |
| public void testJAXBInflow_soap11_withPersist() throws Exception { |
| _testJAXBInflow(sampleJAXBEnvelope11, PERSIST, false); |
| } |
| public void testJAXBInflow_soap12_withPersist() throws Exception { |
| _testJAXBInflow(sampleJAXBEnvelope12, PERSIST, false); |
| } |
| public void testJAXBInflow_soap11_withSaveAndPersist() throws Exception { |
| _testJAXBInflow(sampleJAXBEnvelope11, SAVE_AND_PERSIST, false); |
| } |
| public void testJAXBInflow_soap12_withSaveAndPersist() throws Exception { |
| _testJAXBInflow(sampleJAXBEnvelope12, SAVE_AND_PERSIST, false); |
| } |
| public void _testJAXBInflow(String sampleJAXBEnvelope, int persist, boolean installJAXBCustomBuilder) throws Exception { |
| // Create a SOAP OM out of the sample incoming XML. This |
| // simulates what Axis2 will be doing with the inbound message. |
| StringReader sr = new StringReader(sampleJAXBEnvelope); |
| XMLStreamReader inflow = inputFactory.createXMLStreamReader(sr); |
| StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(inflow, null); |
| OMElement omElement = builder.getSOAPEnvelope(); |
| |
| JAXBDSContext jds = null; |
| if (installJAXBCustomBuilder) { |
| jds = new JAXBDSContext(EchoStringResponse.class.getPackage().getName()); |
| JAXBCustomBuilder jcb = new JAXBCustomBuilder(jds); |
| builder.registerCustomBuilderForPayload(jcb); |
| } |
| |
| // Create a SOAP 1.1 Message from the sample incoming XML |
| MessageFactory mf = (MessageFactory) |
| FactoryRegistry.getFactory(MessageFactory.class); |
| Message m = mf.createFrom(omElement, null); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| boolean isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "OM".equals(m.getXMLPartContentType())); |
| |
| if (installJAXBCustomBuilder) { |
| // The JAXBDSContext and the JAXBUtils access the JAXBContext |
| // for the "test" package. |
| // The JAXBContext creation is very expensive. |
| // However the JAXBContext can also be very large. |
| // |
| // For these reasons, the JAXBUtils code caches the JAXBContext values. |
| // And, the JAXBDSContext and JAXBUtils code use WeakReferences to refer |
| // to the JAXBContext (so that it is easily gc'd). |
| |
| // The following code checks makes sure that the caching and gc is correct. |
| |
| // Get the JAXBContext |
| JAXBContext context = jds.getJAXBContext(); |
| |
| // Get the identity hash code. This is an indicator of the unique memory pointer |
| // for the context. |
| int contextPointer = System.identityHashCode(context); |
| |
| // Release our access to the context. |
| // Now the only accesses in the system should be "soft refs" |
| context = null; |
| |
| // Force garbage collection |
| System.gc(); |
| |
| // Get a new context from JAXBUtils |
| TreeSet<String> packages = new TreeSet<String>(); |
| packages.add(EchoStringResponse.class.getPackage().getName()); |
| context = JAXBUtils.getJAXBContext(packages); |
| |
| // This new context should have a different pointer than the original |
| int contextPointer2 = System.identityHashCode(context); |
| |
| // The following statement is no longer valid. The |
| // JAXBContext is stored in a SoftReference (which will only |
| // get gc'd if memory is low). |
| //assertTrue(contextPointer != contextPointer2); |
| |
| // Release the hold on the context |
| context = null; |
| |
| // Now call JAXBUtils again to get a JAXBContext. |
| // Since there was no intervening gc(), it should return the cached value |
| context = JAXBUtils.getJAXBContext(packages); |
| int contextPointer3 = System.identityHashCode(context); |
| assertTrue(contextPointer3 == contextPointer2); |
| |
| |
| } |
| |
| String saveMsgText = ""; |
| if (persist == SAVE_AND_PERSIST) { |
| // Simulate saving the message so that it can be fully rebuilt. |
| saveMsgText = m.getAsOMElement().toString(); |
| } |
| |
| Object customBuiltObject = null; |
| if (installJAXBCustomBuilder) { |
| OMElement om = m.getAsOMElement(); |
| om = ((org.apache.axiom.soap.SOAPEnvelope) om).getBody().getFirstElement(); |
| if (om instanceof OMSourcedElement && |
| ((OMSourcedElement) om).getDataSource() instanceof JAXBDataSource) { |
| customBuiltObject = ((JAXBDataSource) ((OMSourcedElement) om).getDataSource()).getObject(); |
| } |
| } |
| |
| |
| // Get the BlockFactory |
| JAXBBlockFactory bf = (JAXBBlockFactory) |
| FactoryRegistry.getFactory(JAXBBlockFactory.class); |
| |
| // Create the JAXBContext instance that will be used |
| // to deserialize the JAX-B object content in the message. |
| JAXBBlockContext context = |
| new JAXBBlockContext(EchoStringResponse.class.getPackage().getName()); |
| |
| // Get the JAXBBlock that wraps the content |
| Block b = m.getBodyBlock(context, bf); |
| |
| // Check to see if the message is a fault. The client/server will always call this method. |
| // The Message must respond appropriately without doing a conversion. |
| isFault = m.isFault(); |
| assertTrue(!isFault); |
| assertTrue("XMLPart Representation is " + m.getXMLPartContentType(), |
| "SPINE".equals(m.getXMLPartContentType())); |
| |
| // Get the business object from the block, which should be a |
| // JAX-B object |
| Object bo = b.getBusinessObject(false); |
| m.setPostPivot(); |
| |
| // Simulate restoring the message |
| if (persist == SAVE_AND_PERSIST) { |
| sr = new StringReader(saveMsgText); |
| XMLStreamReader saveMsgReader = inputFactory.createXMLStreamReader(sr); |
| builder = new StAXSOAPModelBuilder(saveMsgReader, null); |
| omElement = builder.getSOAPEnvelope(); |
| m = mf.createFrom(omElement, null); |
| } |
| |
| if (installJAXBCustomBuilder) { |
| // If installed jaxb custom builder, then custom built object should be same object as the business object |
| assertTrue (customBuiltObject == bo); |
| } |
| |
| |
| // Check to make sure the right object was returned |
| assertNotNull(bo); |
| assertTrue(bo instanceof EchoStringResponse); |
| |
| // Check to make sure the content of that object is correct |
| EchoStringResponse esr = (EchoStringResponse) bo; |
| assertNotNull(esr.getEchoStringReturn()); |
| assertTrue(esr.getEchoStringReturn().equals("sample return value")); |
| |
| // Simulate outbound |
| if (persist == PERSIST) { |
| String persistMsg = m.getAsOMElement().toString(); |
| // We should be able to persist the message, |
| // and the persisted message WILL contain the echoStringResponse contents |
| assertTrue(persistMsg.contains("Body")); |
| assertTrue(persistMsg.contains("echoStringResponse")); |
| assertTrue(persistMsg.contains("sample return value")); |
| |
| } else if (persist == SAVE_AND_PERSIST) { |
| String persistMsg = m.getAsOMElement().toString(); |
| // We should be able to persist the message, |
| // and the persisted message WILL contain the echoStringResponse contents |
| assertTrue(persistMsg.contains("Body")); |
| assertTrue(persistMsg.contains("echoStringResponse")); |
| assertTrue(persistMsg.contains("sample return value")); |
| } |
| |
| // After persistance: Sandesha may inspect the body. Make sure this does not cause an error |
| org.apache.axiom.soap.SOAPEnvelope env = (org.apache.axiom.soap.SOAPEnvelope) m.getAsOMElement(); |
| QName qName = new QName("uri://fake", "fake"); |
| env.getBody().getFirstChildWithName(qName); |
| } |
| |
| SAAJConverter converter = null; |
| |
| private SAAJConverter getSAAJConverter() { |
| if (converter == null) { |
| SAAJConverterFactory factory = |
| (SAAJConverterFactory) FactoryRegistry.getFactory(SAAJConverterFactory.class); |
| converter = factory.getSAAJConverter(); |
| } |
| return converter; |
| } |
| } |
