/* | |
* 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.spi; | |
import junit.framework.TestCase; | |
import org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite; | |
import org.apache.axis2.jaxws.description.impl.DescriptionUtils; | |
import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType; | |
import javax.jws.HandlerChain; | |
import javax.jws.WebService; | |
import javax.xml.namespace.QName; | |
import javax.xml.ws.Service; | |
import javax.xml.ws.WebServiceClient; | |
import javax.xml.ws.handler.Handler; | |
import javax.xml.ws.handler.HandlerResolver; | |
import javax.xml.ws.handler.PortInfo; | |
import javax.xml.ws.soap.SOAPBinding; | |
import java.io.File; | |
import java.io.InputStream; | |
import java.net.URL; | |
import java.util.ArrayList; | |
import java.util.Iterator; | |
import java.util.List; | |
/** | |
* Verify that handler chains specified using the HandlerChainsType in a sparse | |
* composite are correctly applied to Services and Ports on the client requester. | |
*/ | |
public class ClientMetadataHandlerChainTest extends TestCase { | |
static String namespaceURI = "http://www.apache.org/test/namespace"; | |
static String svcLocalPart = "DummyService"; | |
static private String portLocalPart = "DummyPort"; | |
private static int uniqueService = 0; | |
/** | |
* Test creating a service without a sparse composite. This verifies pre-existing default | |
* behavior. | |
*/ | |
public void testServiceAndPortNoComposite() { | |
QName serviceQName = new QName(namespaceURI, svcLocalPart); | |
QName portQName = new QName(namespaceURI, portLocalPart); | |
Service service = Service.create(serviceQName); | |
HandlerResolver resolver = service.getHandlerResolver(); | |
assertNotNull(resolver); | |
PortInfo pi = new DummyPortInfo(); | |
List<Handler> list = resolver.getHandlerChain(pi); | |
assertEquals(0, list.size()); | |
ClientMetadataHandlerChainTestSEI port = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class); | |
// Verify that ports created under the service have no handlers from the sparse composite | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
assertEquals(0, portHandlers.size()); | |
} | |
/** | |
* Test creating a service with a sparse composite that contains handler configuration | |
* information for this service delegate. Verify that the handlers are included in the | |
* chain. | |
*/ | |
public void testServiceWithComposite() { | |
QName serviceQName = new QName(namespaceURI, svcLocalPart); | |
QName portQName = new QName(namespaceURI, portLocalPart); | |
// Create a composite with a JAXB Handler Config | |
DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType handlerChainsType = getHandlerChainsType(); | |
sparseComposite.setHandlerChainsType(handlerChainsType); | |
ServiceDelegate.setServiceMetadata(sparseComposite); | |
Service service = Service.create(serviceQName); | |
ClientMetadataHandlerChainTestSEI port = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class); | |
// Verify the HandlerResolver on the service knows about the handlers in the sparse composite | |
HandlerResolver resolver = service.getHandlerResolver(); | |
assertNotNull(resolver); | |
PortInfo pi = new DummyPortInfo(); | |
List<Handler> list = resolver.getHandlerChain(pi); | |
assertEquals(2, list.size()); | |
// Verify that ports created under the service have handlers | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
assertEquals(2, portHandlers.size()); | |
assertTrue(containSameHandlers(portHandlers, list)); | |
// Verify that a subsequent port are different and that they also gets the correct handlers | |
ClientMetadataHandlerChainTestSEI port2 = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider2 = (BindingProvider) port2; | |
Binding binding2 = (Binding) bindingProvider2.getBinding(); | |
List<Handler> portHandlers2 = binding2.getHandlerChain(); | |
assertNotSame(port, port2); | |
assertEquals(2, portHandlers2.size()); | |
assertTrue(containSameHandlers(portHandlers2, list)); | |
} | |
/** | |
* Set a sparse composite on a specific Port. Verify that instances of that Port have the | |
* correct handlers associated and other Ports do not. | |
*/ | |
public void testPortWithComposite() { | |
QName serviceQName = new QName(namespaceURI, svcLocalPart); | |
QName portQName = new QName(namespaceURI, portLocalPart); | |
Service service = Service.create(serviceQName); | |
// Create a composite with a JAXB Handler Config | |
DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType handlerChainsType = getHandlerChainsType(); | |
sparseComposite.setHandlerChainsType(handlerChainsType); | |
ServiceDelegate.setPortMetadata(sparseComposite); | |
ClientMetadataHandlerChainTestSEI port = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class); | |
// Verify the HandlerResolver on the service knows about the handlers in the sparse composite | |
HandlerResolver resolver = service.getHandlerResolver(); | |
assertNotNull(resolver); | |
PortInfo pi = new DummyPortInfo(); | |
List<Handler> list = resolver.getHandlerChain(pi); | |
assertEquals(2, list.size()); | |
// Verify that the port created with the sparse metadata has those handlers | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
assertEquals(2, portHandlers.size()); | |
assertTrue(containSameHandlers(portHandlers, list)); | |
// Verify that a creating another instance of the same port also gets those handlers | |
ClientMetadataHandlerChainTestSEI port2 = service.getPort(portQName, ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider2 = (BindingProvider) port2; | |
Binding binding2 = (Binding) bindingProvider2.getBinding(); | |
List<Handler> portHandlers2 = binding2.getHandlerChain(); | |
assertNotSame(port, port2); | |
assertEquals(2, portHandlers2.size()); | |
assertTrue(containSameHandlers(portHandlers2, list)); | |
// Verify that createing a different port doesn't get the handlers | |
QName portQName3 = new QName(namespaceURI, portLocalPart + "3"); | |
ClientMetadataHandlerChainTestSEI port3 = service.getPort(portQName3, ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider3 = (BindingProvider) port3; | |
Binding binding3 = (Binding) bindingProvider3.getBinding(); | |
List<Handler> portHandlers3 = binding3.getHandlerChain(); | |
assertEquals(0, portHandlers3.size()); | |
// Verify setting the metadata on a different port (a different QName) will get handlers. | |
QName portQName4 = new QName(namespaceURI, portLocalPart + "4"); | |
ServiceDelegate.setPortMetadata(sparseComposite); | |
ClientMetadataHandlerChainTestSEI port4 = service.getPort(portQName4, ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider4 = (BindingProvider) port4; | |
Binding binding4 = (Binding) bindingProvider4.getBinding(); | |
List<Handler> portHandlers4 = binding4.getHandlerChain(); | |
assertEquals(2, portHandlers4.size()); | |
// Verify the service handler resolver knows about boths sets of handlers | |
// attached to the two different port QNames and none are attached for the third port | |
List<Handler> listForPort = resolver.getHandlerChain(pi); | |
assertEquals(2, listForPort.size()); | |
PortInfo pi4 = new DummyPortInfo(portQName4); | |
List<Handler> listForPort4 = resolver.getHandlerChain(pi4); | |
assertEquals(2, listForPort4.size()); | |
PortInfo pi3 = new DummyPortInfo(portQName3); | |
List<Handler> listForPort3 = resolver.getHandlerChain(pi3); | |
assertEquals(0, listForPort3.size()); | |
} | |
/** | |
* Verify that handlers specified in a sparse compoiste on the service are only associated with | |
* that specific service delegate (i.e. Service instance), even if the QNames are the same | |
* across two instances of a Service. | |
*/ | |
public void testMultipleServiceDelgatesServiceComposite() { | |
try { | |
// Need to cache the ServiceDescriptions so that they are shared | |
// across the two instances of the same Service. | |
ClientMetadataTest.installCachingFactory(); | |
QName serviceQName = new QName(namespaceURI, svcLocalPart); | |
PortInfo pi = new DummyPortInfo(); | |
// Create a Service specifying a sparse composite and verify the | |
// ports under that service get the correct handlers associated. | |
DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType handlerChainsType = getHandlerChainsType(); | |
sparseComposite.setHandlerChainsType(handlerChainsType); | |
ServiceDelegate.setServiceMetadata(sparseComposite); | |
Service service1 = Service.create(serviceQName); | |
// Create a second instance of the same Service, but without | |
// metadata. Ports created under that service should not get handler's associated. | |
Service service2 = Service.create(serviceQName); | |
// No ports created yet, so there should be no relevant handler | |
// chains. | |
HandlerResolver resolver1 = service1.getHandlerResolver(); | |
List<Handler> list1 = resolver1.getHandlerChain(pi); | |
assertEquals(0, list1.size()); | |
// Create the port, it should get handlers. | |
QName portQName1 = new QName(namespaceURI, portLocalPart); | |
ClientMetadataHandlerChainTestSEI port1 = | |
service1.getPort(portQName1, ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider1 = (BindingProvider) port1; | |
Binding binding1 = (Binding) bindingProvider1.getBinding(); | |
List<Handler> portHandlers1 = binding1.getHandlerChain(); | |
assertEquals(2, portHandlers1.size()); | |
// Refresh the handler list from the resolver after the port is created | |
list1 = resolver1.getHandlerChain(pi); | |
assertTrue(containSameHandlers(portHandlers1, list1)); | |
// Make sure the 2nd Service instance doesn't have handlers | |
// associated with it | |
HandlerResolver resolver2 = service2.getHandlerResolver(); | |
List<Handler> list2 = resolver2.getHandlerChain(pi); | |
assertEquals(0, list2.size()); | |
// Make sure the same port created under the 2nd service also | |
// doesn't have handlers | |
ClientMetadataHandlerChainTestSEI port2 = | |
service2.getPort(portQName1, ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider2 = (BindingProvider) port2; | |
Binding binding2 = (Binding) bindingProvider2.getBinding(); | |
List<Handler> portHandlers2 = binding2.getHandlerChain(); | |
assertEquals(0, portHandlers2.size()); | |
} | |
finally { | |
ClientMetadataTest.restoreOriginalFactory(); | |
} | |
} | |
/** | |
* Verify that handlers specified in a sparse compoiste on the port are only associated with | |
* that port on that specific service delegate (i.e. Service instance), even if the QNames are the same | |
* across two instances of a Service. | |
*/ | |
public void testMultipleServiceDelgatesPortComposite() { | |
try { | |
// Need to cache the ServiceDescriptions so that they are shared | |
// across the two instances of the same Service. | |
ClientMetadataTest.installCachingFactory(); | |
QName serviceQName = new QName(namespaceURI, svcLocalPart); | |
PortInfo pi = new DummyPortInfo(); | |
// Create two instances of the same Service | |
Service service1 = Service.create(serviceQName); | |
Service service2 = Service.create(serviceQName); | |
// No ports created yet, so there should be no relevant handler | |
// chains. | |
HandlerResolver resolver1 = service1.getHandlerResolver(); | |
List<Handler> list1 = resolver1.getHandlerChain(pi); | |
assertEquals(0, list1.size()); | |
// Create a Port specifying a sparse composite and verify the | |
// port gets the correct handlers associated. | |
DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType handlerChainsType = getHandlerChainsType(); | |
sparseComposite.setHandlerChainsType(handlerChainsType); | |
ServiceDelegate.setPortMetadata(sparseComposite); | |
QName portQName1 = new QName(namespaceURI, portLocalPart); | |
ClientMetadataHandlerChainTestSEI port1 = | |
service1.getPort(portQName1, ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider1 = (BindingProvider) port1; | |
Binding binding1 = (Binding) bindingProvider1.getBinding(); | |
List<Handler> portHandlers1 = binding1.getHandlerChain(); | |
assertEquals(2, portHandlers1.size()); | |
// Refresh the handler list from the resolver after the port is created | |
list1 = resolver1.getHandlerChain(pi); | |
assertTrue(containSameHandlers(portHandlers1, list1)); | |
// Make sure the 2nd Service instance doesn't have handlers | |
// associated with it | |
HandlerResolver resolver2 = service2.getHandlerResolver(); | |
List<Handler> list2 = resolver2.getHandlerChain(pi); | |
assertEquals(0, list2.size()); | |
// Make sure the same port created under the 2nd service also | |
// doesn't have handlers | |
ClientMetadataHandlerChainTestSEI port2 = | |
service2.getPort(portQName1, ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider2 = (BindingProvider) port2; | |
Binding binding2 = (Binding) bindingProvider2.getBinding(); | |
List<Handler> portHandlers2 = binding2.getHandlerChain(); | |
assertEquals(0, portHandlers2.size()); | |
} | |
finally { | |
ClientMetadataTest.restoreOriginalFactory(); | |
} | |
} | |
/** | |
* Verify that the original functionality of specifying a HandlerChain annotation with a | |
* file member works as it should. | |
*/ | |
public void testHandlerChainOnSEI() { | |
QName serviceQN = new QName(namespaceURI, svcLocalPart); | |
Service service = Service.create(serviceQN); | |
ClientMetadataHandlerChainTestSEIWithHC port = service.getPort(ClientMetadataHandlerChainTestSEIWithHC.class); | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
assertEquals(1, portHandlers.size()); | |
assertTrue(containsHandlerChainAnnotationHandlers(portHandlers)); | |
} | |
/** | |
* Verify that handler information in a sparse composite on the Port will override any handler chain | |
* annotation on the SEI. | |
*/ | |
public void testSEIHandlerChainOverrideOnPort() { | |
QName serviceQN = new QName(namespaceURI, svcLocalPart + uniqueService++); | |
Service service = Service.create(serviceQN); | |
// The SEI has a HandlerChain annotation, but the sparse metadata should override it | |
DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType handlerChainsType = getHandlerChainsType(); | |
sparseComposite.setHandlerChainsType(handlerChainsType); | |
ServiceDelegate.setPortMetadata(sparseComposite); | |
ClientMetadataHandlerChainTestSEIWithHC port = service.getPort(ClientMetadataHandlerChainTestSEIWithHC.class); | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
assertEquals(2, portHandlers.size()); | |
assertTrue(containsSparseCompositeHandlers(portHandlers)); | |
} | |
/** | |
* Verify that handler information in a sparse composite on the Service will override any handler chain | |
* annotation on the SEI. | |
*/ | |
public void testSEIHandlerChainOverrideOnService() { | |
QName serviceQN = new QName(namespaceURI, svcLocalPart + uniqueService++); | |
// The SEI has a HandlerChain annotation, but the sparse metadata should override it | |
DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType handlerChainsType = getHandlerChainsType(); | |
sparseComposite.setHandlerChainsType(handlerChainsType); | |
ServiceDelegate.setServiceMetadata(sparseComposite); | |
Service service = Service.create(serviceQN); | |
ClientMetadataHandlerChainTestSEIWithHC port = service.getPort(ClientMetadataHandlerChainTestSEIWithHC.class); | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
assertEquals(2, portHandlers.size()); | |
assertTrue(containsSparseCompositeHandlers(portHandlers)); | |
} | |
/** | |
* Set different composites on the Service and the Port that specify different | |
* HandlerChainsType values. | |
*/ | |
public void testCompositeOnServiceAndPort() { | |
QName serviceQN = new QName(namespaceURI, svcLocalPart + uniqueService++); | |
// Create a service with a composite specifying handlers | |
DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType handlerChainsType = getHandlerChainsType(); | |
sparseComposite.setHandlerChainsType(handlerChainsType); | |
ServiceDelegate.setServiceMetadata(sparseComposite); | |
Service service = Service.create(serviceQN); | |
// Create a port with a composite specifying different handlers | |
DescriptionBuilderComposite portComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType portHandlerChainsType = getHandlerChainsType("ClientMetadataHandlerChainTest.xml"); | |
portComposite.setHandlerChainsType(portHandlerChainsType); | |
ServiceDelegate.setPortMetadata(portComposite); | |
ClientMetadataHandlerChainTestSEI port = service.getPort(ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
// If there is a HandlerChainsType composite specified on both the Service and the Port, | |
// then the composite specified on the Port should be the one used to associate the | |
// handlers for that Port. | |
assertEquals(1, portHandlers.size()); | |
assertTrue(containsHandlerChainAnnotationHandlers(portHandlers)); | |
} | |
/** | |
* Verfiy that a HandlerChain annotation on the Service is associated with the Port | |
*/ | |
public void testGeneratedServiceWithHC() { | |
ClientMetadataHandlerChainTestServiceWithHC service = new ClientMetadataHandlerChainTestServiceWithHC(); | |
ClientMetadataHandlerChainTestSEI port = service.getPort(ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
assertEquals(1, portHandlers.size()); | |
assertTrue(containsHandlerChainAnnotationHandlers(portHandlers)); | |
} | |
/** | |
* Verfiy that given a HandlerChain annotation on the Service and a Port and a sparse composite | |
* on the Port associates the handlers from the sparse composite on the Port. | |
*/ | |
public void testGeneratedServiceWithHCPortOverride() { | |
ClientMetadataHandlerChainTestServiceWithHC service = new ClientMetadataHandlerChainTestServiceWithHC(); | |
// Set a HandlerChainsType on the sparse composite for the Port creation; it should override the | |
// HandlerChain annotation on the Service. | |
DescriptionBuilderComposite sparseComposite = new DescriptionBuilderComposite(); | |
HandlerChainsType handlerChainsType = getHandlerChainsType(); | |
sparseComposite.setHandlerChainsType(handlerChainsType); | |
ServiceDelegate.setPortMetadata(sparseComposite); | |
ClientMetadataHandlerChainTestSEI port = service.getPort(ClientMetadataHandlerChainTestSEI.class); | |
BindingProvider bindingProvider = (BindingProvider) port; | |
Binding binding = (Binding) bindingProvider.getBinding(); | |
List<Handler> portHandlers = binding.getHandlerChain(); | |
assertEquals(2, portHandlers.size()); | |
assertTrue(containsSparseCompositeHandlers(portHandlers)); | |
} | |
// ============================================================================================= | |
// Helper methods and classes | |
// ============================================================================================= | |
private boolean containsSparseCompositeHandlers(List<Handler> handlerList) { | |
List<Class> inputHandlerClasses = handlerClasses(handlerList); | |
// These are the handlers defined in the HandlerChainsType placed on the sparse composite | |
List<Class> compositeHandlerClasses = new ArrayList<Class>(); | |
compositeHandlerClasses.add(org.apache.axis2.jaxws.spi.handler.DummySOAPHandler.class); | |
compositeHandlerClasses.add(org.apache.axis2.jaxws.spi.handler.DummyLogicalHandler.class); | |
if (inputHandlerClasses.size() != compositeHandlerClasses.size()) { | |
return false; | |
} | |
if (inputHandlerClasses.containsAll(compositeHandlerClasses)) { | |
return true; | |
} else { | |
return false; | |
} | |
} | |
/** | |
* Answer if the List contains the same handlers as defined in the SEI | |
* via the HandlerChain.file annotation memeber. | |
* | |
* @param portHandlers List of handlers | |
* @return true if the list matches what was defined on the SEI via the | |
* HandlerChain annotation; false otherwise. | |
*/ | |
private boolean containsHandlerChainAnnotationHandlers(List<Handler> portHandlers) { | |
List<Class> portHandlerClasses = handlerClasses(portHandlers); | |
List<Class> seiHandlerClasses = new ArrayList<Class>(); | |
seiHandlerClasses.add(ClientMetadataHandlerChainHandler.class); | |
if (portHandlerClasses.size() != seiHandlerClasses.size()) { | |
return false; | |
} | |
if (portHandlerClasses.containsAll(seiHandlerClasses)) { | |
return true; | |
} else { | |
return false; | |
} | |
} | |
/** | |
* Answer if two List<Handler> arguments contain the same handler Class files. | |
* @param list1 | |
* @param list2 | |
* @return | |
*/ | |
private boolean containSameHandlers(List<Handler> list1, List<Handler> list2) { | |
if (list1.size() != list2.size()) { | |
return false; | |
} | |
List<Class> list1HandlerClasses = handlerClasses(list1); | |
List<Class> list2HandlerClasses = handlerClasses(list2); | |
if (list1HandlerClasses.containsAll(list2HandlerClasses)) { | |
return true; | |
} else { | |
return false; | |
} | |
} | |
private List<Class> handlerClasses(List<Handler> listOfHandlers) { | |
List<Class> handlerClasses = new ArrayList<Class>(); | |
Iterator<Handler> handlerIterator = listOfHandlers.iterator(); | |
while (handlerIterator.hasNext()) { | |
handlerClasses.add(handlerIterator.next().getClass()); | |
} | |
return handlerClasses; | |
} | |
private HandlerChainsType getHandlerChainsType() { | |
return getHandlerChainsType("handler.xml"); | |
} | |
private HandlerChainsType getHandlerChainsType(String fileName) { | |
InputStream is = getXMLFileStream(fileName); | |
assertNotNull(is); | |
HandlerChainsType returnHCT = DescriptionUtils.loadHandlerChains(is, this.getClass().getClassLoader()); | |
assertNotNull(returnHCT); | |
return returnHCT; | |
} | |
private InputStream getXMLFileStream(String fileName) { | |
InputStream is = null; | |
String configLoc = null; | |
try { | |
String sep = "/"; | |
configLoc = sep + "test-resources" + sep + "configuration" + sep + "handlers" + sep + fileName; | |
String baseDir = new File(System.getProperty("basedir",".")).getCanonicalPath(); | |
is = new File(baseDir + configLoc).toURL().openStream(); | |
} | |
catch(Exception e) { | |
e.printStackTrace(); | |
} | |
return is; | |
} | |
public class DummyPortInfo implements PortInfo { | |
private QName portQN; | |
private QName serviceQN; | |
public DummyPortInfo() { | |
this.portQN = new QName("http://www.apache.org/test/namespace", "DummyPort"); | |
this.serviceQN = new QName("http://www.apache.org/test/namespace", "DummyService"); | |
} | |
public DummyPortInfo(QName portQN) { | |
this(); | |
this.portQN = portQN; | |
} | |
public String getBindingID() { | |
return SOAPBinding.SOAP11HTTP_BINDING; | |
} | |
public QName getPortName() { | |
return portQN; | |
} | |
public QName getServiceName() { | |
return serviceQN; | |
} | |
} | |
} | |
@WebService | |
interface ClientMetadataHandlerChainTestSEI { | |
public String echo(String toEcho); | |
} | |
@WebService | |
@HandlerChain(file="ClientMetadataHandlerChainTest.xml") | |
interface ClientMetadataHandlerChainTestSEIWithHC { | |
public String echo(String toEcho); | |
} | |
@WebServiceClient | |
@HandlerChain(file="ClientMetadataHandlerChainTest.xml") | |
class ClientMetadataHandlerChainTestServiceWithHC extends javax.xml.ws.Service { | |
public ClientMetadataHandlerChainTestServiceWithHC() { | |
super(null, | |
new QName(ClientMetadataHandlerChainTest.namespaceURI, ClientMetadataHandlerChainTest.svcLocalPart)); | |
} | |
public ClientMetadataHandlerChainTestServiceWithHC(URL wsdlLocation, QName serviceName) { | |
super(wsdlLocation, serviceName); | |
} | |
} |