/* | |
* 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.sample; | |
import java.io.BufferedReader; | |
import java.io.File; | |
import java.io.FileInputStream; | |
import java.io.FileNotFoundException; | |
import java.io.FileReader; | |
import java.io.FileWriter; | |
import java.io.IOException; | |
import java.io.StringWriter; | |
import java.util.ArrayList; | |
import java.util.List; | |
import java.util.concurrent.Future; | |
import javax.xml.namespace.QName; | |
import javax.xml.soap.SOAPFault; | |
import javax.xml.transform.Result; | |
import javax.xml.transform.Source; | |
import javax.xml.transform.Transformer; | |
import javax.xml.transform.TransformerFactory; | |
import javax.xml.transform.stream.StreamResult; | |
import javax.xml.transform.stream.StreamSource; | |
import javax.xml.ws.AsyncHandler; | |
import javax.xml.ws.Binding; | |
import javax.xml.ws.BindingProvider; | |
import javax.xml.ws.Dispatch; | |
import javax.xml.ws.Response; | |
import javax.xml.ws.Service; | |
import javax.xml.ws.handler.Handler; | |
import javax.xml.ws.handler.HandlerResolver; | |
import javax.xml.ws.handler.PortInfo; | |
import javax.xml.ws.soap.SOAPFaultException; | |
import junit.framework.Test; | |
import junit.framework.TestSuite; | |
import org.apache.axis2.jaxws.TestLogger; | |
import org.apache.axis2.jaxws.framework.AbstractTestCase; | |
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientLogicalHandler; | |
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientLogicalHandler2; | |
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientLogicalHandler3; | |
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientLogicalHandler4; | |
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersClientProtocolHandler; | |
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersHandlerFault_Exception; | |
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersHandlerPortType; | |
import org.apache.axis2.jaxws.sample.addnumbershandler.AddNumbersHandlerService; | |
import org.test.addnumbershandler.AddNumbersHandlerResponse; | |
public class AddNumbersHandlerTests extends AbstractTestCase { | |
String axisEndpoint = "http://localhost:6060/axis2/services/AddNumbersHandlerService.AddNumbersHandlerPortTypeImplPort"; | |
static File requestFile = null; | |
static { | |
String resourceDir = System.getProperty("basedir",".")+ | |
File.separator+"test-resources"+File.separator+"xml"; | |
requestFile = new File(resourceDir+File.separator+"addnumberstest.xml"); | |
} | |
private static final String filelogname = "AddNumbersHandlerTests.log"; | |
public static Test suite() { | |
return getTestSetup(new TestSuite(AddNumbersHandlerTests.class)); | |
} | |
/** | |
* Client app sends 10, 10 as params to sum. No client-side handlers are configured | |
* for this scenario. The server-side AddNumbersLogicalHandler is instantiated with a | |
* variable "deduction" with value 1. Upon class initialization using PostConstruct | |
* annotation, that internal variable is changed to value 2. The inbound AddNumbersLogicalHandler | |
* subtracts 1 from the first param, then outbound it subtracts 2 from the result sum. | |
* | |
* This test accomplishes three things (which also carry over to other tests since they all use | |
* the same endpoint and server-side handlers: | |
* 1) PostConstruct annotation honored in the handler framework for handler instantiation | |
* 2) AddNumbersLogicalHandler also sets two message context properties, one with APPLICATION | |
* scope, which the endpoint checks. | |
* 3) Handlers are sharing properties, both APPLICATION scoped and HANDLER scoped | |
* 3) General handler framework functionality; make sure handlers are instantiated and called | |
*/ | |
public void testAddNumbersHandler() { | |
try{ | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint); | |
int total = proxy.addNumbersHandler(10, 10); | |
assertEquals("With handler manipulation, total should be 3 less than a proper sumation.", 17, total); | |
TestLogger.logger.debug("Total (after handler manipulation) = " + total); | |
// also confirm that @PreDestroy method is called. Since it only makes sense to call it on the managed | |
// (server) side and just before the handler instance goes out of scope, we are creating a file in the | |
// @PreDestroy method, and will check for its existance here. If the file does not exist, it means | |
// @PreDestroy method was never called. The file is set to .deleteOnExit(), so no need to delete it. | |
File file = new File("AddNumbersProtocolHandler.preDestroy.txt"); | |
assertTrue("File AddNumbersProtocolHandler.preDestroy.txt does not exist, meaning the @PreDestroy method was not called.", file.exists()); | |
String log = readLogFile(); | |
String expected_calls = | |
"AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("----------------------------------"); | |
} catch(Exception e) { | |
e.printStackTrace(); | |
fail(e.getMessage()); | |
} | |
} | |
/** | |
* Client app sends MAXVALUE, MAXVALUE as params to add. | |
* No client-side handlers are configured for this scenario. | |
* The endpoint method (addNumbersHandler) will detect the possible overflow and | |
* throw an application exception, AddNumbersHandleFault_Exception. | |
* | |
* The server-side AddNumbersProtocolHandler will | |
* access the thrown exception using the "jaxws.webmethod.exception" | |
* property and add the stack trace string to fault string. | |
* | |
* The client should receive a AddNumbersHandlerFault_Exception that has a stack | |
* trace as part of the message. | |
* This test verifies the following: | |
* | |
* 1) Proper exception/fault processing when handlers are installed. | |
* 2) Access to the special "jaxws.webmethod.exception" | |
* 3) Proper exception call flow when an application exception is thrown. | |
*/ | |
public void testAddNumbersHandler_WithCheckedException() throws Exception { | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint); | |
AddNumbersHandlerFault_Exception expectedException = null; | |
Throwable t = null; | |
try { | |
proxy.addNumbersHandler(Integer.MAX_VALUE, Integer.MAX_VALUE); | |
} catch (Throwable e) { | |
// An exception is expected | |
t = e; | |
} | |
// Make sure the proper exception is thrown | |
if (t == null) { | |
fail("Expected AddNumbersHandlerFault_Exception to be thrown"); | |
} | |
if (t instanceof AddNumbersHandlerFault_Exception) { | |
expectedException = (AddNumbersHandlerFault_Exception) t; | |
} else { | |
fail("Expected AddNumbersHandlerFault_Exception to be thrown, " + | |
"but the exception is: " + t); | |
} | |
// also confirm that @PreDestroy method is called. Since it only makes sense to call it on the managed | |
// (server) side and just before the handler instance goes out of scope, we are creating a file in the | |
// @PreDestroy method, and will check for its existance here. If the file does not exist, it means | |
// @PreDestroy method was never called. The file is set to .deleteOnExit(), so no need to delete it. | |
File file = new File("AddNumbersProtocolHandler.preDestroy.txt"); | |
assertTrue("File AddNumbersProtocolHandler.preDestroy.txt does not exist, meaning the @PreDestroy method was not called.", file.exists()); | |
String log = readLogFile(); | |
String expected_calls = | |
"AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("Expected Exception is " + | |
expectedException.getMessage()); | |
// The outbound service handler adds the stack trace to the | |
// message. Make sure the stack trace contains the AddNumbersHandlerPortTypeImpl | |
assertTrue("A stack trace was not present in the returned exception's message:" + | |
expectedException.getMessage(), | |
expectedException.getMessage().indexOf("AddNumbersHandlerPortTypeImpl") > 0); | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
/** | |
* Client app sends MAXVALUE, MAXVALUE as params to add. | |
* No client-side handlers are configured for this scenario. | |
* The endpoint method (addNumbersHandler) will detect the possible overflow and | |
* throw an unchecked exception, NullPointerException. | |
* | |
* The server-side AddNumbersProtocolHandler will | |
* access the thrown exception using the "jaxws.webmethod.exception" | |
* property and add the stack trace string to fault string. | |
* | |
* The client should receive a SOAPFaultException that has a stack | |
* trace as part of the message. | |
* This test verifies the following: | |
* | |
* 1) Proper exception/fault processing when handlers are installed. | |
* 2) Access to the special "jaxws.webmethod.exception" | |
* 3) Proper exception call flow when an unchecked exception is thrown. | |
*/ | |
public void testAddNumbersHandler_WithUnCheckedException() throws Exception { | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint); | |
SOAPFaultException expectedException = null; | |
Throwable t = null; | |
try { | |
proxy.addNumbersHandler(-1000, Integer.MIN_VALUE); | |
} catch (Throwable e) { | |
// An exception is expected | |
t = e; | |
} | |
// Make sure the proper exception is thrown | |
if (t == null) { | |
fail("Expected AddNumbersHandlerFault_Exception to be thrown"); | |
} | |
if (t instanceof SOAPFaultException) { | |
expectedException = (SOAPFaultException) t; | |
} else { | |
fail("Expected SOAPFaultException to be thrown, " + | |
"but the exception is: " + t); | |
} | |
// also confirm that @PreDestroy method is called. Since it only makes sense to call it on the managed | |
// (server) side and just before the handler instance goes out of scope, we are creating a file in the | |
// @PreDestroy method, and will check for its existance here. If the file does not exist, it means | |
// @PreDestroy method was never called. The file is set to .deleteOnExit(), so no need to delete it. | |
File file = new File("AddNumbersProtocolHandler.preDestroy.txt"); | |
assertTrue("File AddNumbersProtocolHandler.preDestroy.txt does not exist, meaning the @PreDestroy method was not called.", file.exists()); | |
String log = readLogFile(); | |
String expected_calls = | |
"AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n"; | |
assertEquals(expected_calls, log); | |
// The outbound service handler adds the stack trace to the | |
// message. Make sure the stack trace contains the AddNumbersHandlerPortTypeImpl | |
TestLogger.logger.debug("Expected Exception is " + | |
expectedException.getMessage()); | |
SOAPFault fault = expectedException.getFault(); | |
assertTrue("A stack trace was not present in the returned exception's message:" + | |
fault.getFaultString(), | |
fault.getFaultString().indexOf("AddNumbersHandlerPortTypeImpl") > 0); | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
public void testAddNumbersHandlerDispatch() { | |
try { | |
QName serviceName = | |
new QName("http://org/test/addnumbershandler", "AddNumbersHandlerService"); | |
QName portName = | |
new QName("http://org/test/addnumbershandler", "AddNumbersHandlerPort"); | |
Service myService = Service.create(serviceName); | |
myService.addPort(portName, null, axisEndpoint); | |
Dispatch<Source> myDispatch = myService.createDispatch(portName, Source.class, | |
Service.Mode.MESSAGE); | |
// set handler chain for binding provider | |
Binding binding = ((BindingProvider) myDispatch).getBinding(); | |
// create a new list or use the existing one | |
List<Handler> handlers = binding.getHandlerChain(); | |
if (handlers == null) | |
handlers = new ArrayList<Handler>(); | |
handlers.add(new AddNumbersClientLogicalHandler()); | |
handlers.add(new AddNumbersClientProtocolHandler()); | |
binding.setHandlerChain(handlers); | |
//Invoke the Dispatch | |
TestLogger.logger.debug(">> Invoking Async Dispatch"); | |
Source response = myDispatch.invoke(createRequestSource()); | |
String resString = getString(response); | |
if (!resString.contains("<return>16</return>")) { | |
fail("Response string should contain <return>16</return>, but does not. The resString was: \"" + resString + "\""); | |
} | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n" | |
+ "AddNumbersClientProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientProtocolHandler CLOSE\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("----------------------------------"); | |
} catch (Exception e) { | |
e.printStackTrace(); | |
fail(); | |
} | |
} | |
public void testAddNumbersHandlerDispatchMyResolver() { | |
try { | |
QName serviceName = | |
new QName("http://org/test/addnumbershandler", "AddNumbersHandlerService"); | |
QName portName = | |
new QName("http://org/test/addnumbershandler", "AddNumbersHandlerPort"); | |
Service myService = Service.create(serviceName); | |
myService.setHandlerResolver(new MyHandlerResolver()); | |
myService.addPort(portName, null, axisEndpoint); | |
Dispatch<Source> myDispatch = myService.createDispatch(portName, Source.class, | |
Service.Mode.MESSAGE); | |
//Invoke the Dispatch | |
TestLogger.logger.debug(">> Invoking Async Dispatch"); | |
Source response = myDispatch.invoke(createRequestSource()); | |
String resString = getString(response); | |
if (!resString.contains("<return>16</return>")) { | |
fail("Response string should contain <return>16</return>, but does not. The resString was: \"" + resString + "\""); | |
} | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n" | |
+ "AddNumbersClientProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientProtocolHandler CLOSE\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("----------------------------------"); | |
} catch (Exception e) { | |
e.printStackTrace(); | |
fail(); | |
} | |
} | |
/* | |
* JAXWS 9.2.1.1 conformance test | |
*/ | |
public void testAddNumbersHandlerResolver() { | |
try { | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
service.setHandlerResolver(new MyHandlerResolver()); | |
BindingProvider p = (BindingProvider) proxy; | |
/* | |
* despite setting MyHandlerResolver on the service, we should get an empty | |
* list from the getBinding().getHandlerChain() call below. JAXWS 9.2.1.1 conformance | |
*/ | |
List<Handler> list = p.getBinding().getHandlerChain(); | |
assertTrue("List should be empty. We've not conformed to JAXWS 9.2.1.1.", list.isEmpty()); | |
String log = readLogFile(); | |
assertNull("log should be empty, since no handlers are in the list and we never called a service", log); | |
TestLogger.logger.debug("----------------------------------"); | |
} catch (Exception e) { | |
e.printStackTrace(); | |
fail(e.getMessage()); | |
} | |
} | |
public void testAddNumbersHandlerWithFault() { | |
try{ | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, | |
axisEndpoint); | |
// value 99 triggers the handler to throw an exception, but does | |
// NOT trigger the AddNumbersHandler.handlefault method. | |
// The spec does not call the handlefault method of a handler that | |
// causes a flow reversal | |
int total = proxy.addNumbersHandler(99,10); | |
fail("We should have got an exception due to the handler."); | |
} catch(Exception e) { | |
e.printStackTrace(); | |
assertTrue("Exception should be SOAPFaultException", e instanceof SOAPFaultException); | |
assertEquals(((SOAPFaultException)e).getMessage(), "I don't like the value 99"); | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 THROWING PROTOCOLEXCEPTION INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n"; | |
assertEquals(expected_calls, log); | |
} | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
/** | |
* testAddNumbersClientHandler performs the same tests as testAddNumbersHandler, except | |
* that two client-side handlers are also inserted into the flow. The inbound AddNumbersClientLogicalHandler | |
* checks that the properties set here in this method (the client app) and the properties set in the | |
* outbound AddNumbersClientProtocolHandler are accessible. These properties are also checked here in | |
* the client app. AddNumbersClientLogicalHandler also subtracts 1 from the sum on the inbound flow. | |
*/ | |
public void testAddNumbersClientHandler() { | |
try{ | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, | |
axisEndpoint); | |
p.getRequestContext().put("myClientKey", "myClientVal"); | |
List<Handler> handlers = p.getBinding().getHandlerChain(); | |
if (handlers == null) | |
handlers = new ArrayList<Handler>(); | |
handlers.add(new AddNumbersClientLogicalHandler()); | |
handlers.add(new AddNumbersClientProtocolHandler()); | |
p.getBinding().setHandlerChain(handlers); | |
int total = proxy.addNumbersHandler(10,10); | |
// see if I can get an APPLICATION scoped property set during outbound flow. I should be able to do this according to 4.2.1 | |
// TODO: assert is now commented out. This property is set by a client outbound handler, and I don't think it | |
// should be available on the request or response contexts. | |
//assertNotNull("Should be able to retrieve APPLICATION scoped property, but could not.", ((String)p.getRequestContext().get("AddNumbersClientProtocolHandlerOutboundAppScopedProperty"))); | |
// should NOT be able to get this HANDLER scoped property though | |
assertNull("Should not be able to retrieve HANDLER scoped property, but was able.", (String)p.getResponseContext().get("AddNumbersClientProtocolHandlerOutboundHandlerScopedProperty")); | |
// should be able to get this APPLICATION scoped property set during inbound flow | |
assertNotNull("Should be able to retrieve APPLICATION scoped property, but could not.", (String)p.getResponseContext().get("AddNumbersClientProtocolHandlerInboundAppScopedProperty")); | |
// should NOT be able to get this HANDLER scoped property though | |
assertNull("Should not be able to retrieve HANDLER scoped property, but was able.", (String)p.getResponseContext().get("AddNumbersClientProtocolHandlerInboundHandlerScopedProperty")); | |
// should be able to get this APPLICATION scoped property set by this client | |
assertNotNull("Should be able to retrieve APPLICATION scoped property, but could not.", (String)p.getRequestContext().get("myClientKey")); | |
assertEquals("With handler manipulation, total should be 4 less than a proper sumation.", 16, total); | |
TestLogger.logger.debug("Total (after handler manipulation) = " + total); | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n" | |
+ "AddNumbersClientProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientProtocolHandler CLOSE\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("----------------------------------"); | |
} catch(Exception e) { | |
e.printStackTrace(); | |
fail(); | |
} | |
} | |
/* | |
* uses a custom HandlerResolver instead of the default. MyHandlerResolver | |
* puts the AddNumbersClientLogicalHandler and AddNumbersClientProtocolHandler | |
* in the flow. Results should be the same as testAddNumbersClientHandler. | |
*/ | |
public void testAddNumbersClientHandlerMyResolver() { | |
try{ | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
service.setHandlerResolver(new MyHandlerResolver()); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, | |
axisEndpoint); | |
int total = proxy.addNumbersHandler(10,10); | |
assertEquals("With handler manipulation, total should be 4 less than a proper sumation.", | |
16, | |
total); | |
TestLogger.logger.debug("Total (after handler manipulation) = " + total); | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n" | |
+ "AddNumbersClientProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientProtocolHandler CLOSE\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("----------------------------------"); | |
} catch(Exception e) { | |
e.printStackTrace(); | |
fail(); | |
} | |
} | |
public void testAddNumbersClientProtoAndLogicalHandler() { | |
try{ | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, | |
axisEndpoint); | |
List<Handler> handlers = p.getBinding().getHandlerChain(); | |
if (handlers == null) | |
handlers = new ArrayList<Handler>(); | |
handlers.add(new AddNumbersClientLogicalHandler()); | |
handlers.add(new AddNumbersClientProtocolHandler()); | |
p.getBinding().setHandlerChain(handlers); | |
// value 102 triggers an endpoint exception, which will run through the server outbound | |
// handleFault methods, then client inbound handleFault methods | |
int total = proxy.addNumbersHandler(102,10); | |
fail("should have got an exception, but didn't"); | |
} catch(Exception e) { | |
e.printStackTrace(); | |
assertTrue("Exception should be SOAPFaultException", e instanceof SOAPFaultException); | |
//AXIS2-2417 - assertEquals(((SOAPFaultException)e).getMessage(), "AddNumbersLogicalHandler2 was here"); | |
assertTrue(((SOAPFaultException)e).getMessage().contains("Got value 101. " + | |
"AddNumbersHandlerPortTypeImpl.addNumbersHandler method is " + | |
"correctly throwing this exception as part of testing")); | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n" | |
+ "AddNumbersClientProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_FAULT_INBOUND\n" | |
+ "AddNumbersClientLogicalHandler HANDLE_FAULT_INBOUND\n" | |
+ "AddNumbersClientProtocolHandler CLOSE\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
} | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
public void testAddNumbersClientHandlerWithFault() { | |
try{ | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, | |
axisEndpoint); | |
List<Handler> handlers = p.getBinding().getHandlerChain(); | |
if (handlers == null) | |
handlers = new ArrayList<Handler>(); | |
handlers.add(new AddNumbersClientLogicalHandler4()); | |
handlers.add(new AddNumbersClientLogicalHandler3()); | |
handlers.add(new AddNumbersClientLogicalHandler()); | |
p.getBinding().setHandlerChain(handlers); | |
int total = proxy.addNumbersHandler(99,10); | |
fail("Should have got an exception, but we didn't."); | |
} catch(Exception e) { | |
e.printStackTrace(); | |
assertTrue("Exception should be SOAPFaultException", e instanceof SOAPFaultException); | |
assertEquals("I don't like the value 99", ((SOAPFaultException)e).getMessage()); | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler4 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientLogicalHandler3 HANDLE_FAULT_OUTBOUND\n" | |
+ "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientLogicalHandler3 HANDLE_FAULT_INBOUND\n" | |
+ "AddNumbersClientLogicalHandler3 RETURNING FALSE INBOUND\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n" | |
+ "AddNumbersClientLogicalHandler3 CLOSE\n" | |
+ "AddNumbersClientLogicalHandler4 CLOSE\n"; | |
assertEquals(expected_calls, log); | |
} | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
/** | |
* test results should be the same as testAddNumbersClientHandler, except that | |
* AddNumbersClientLogicalHandler2 doubles the first param on outbound. Async, of course. | |
* | |
*/ | |
public void testAddNumbersClientHandlerAsync() { | |
try{ | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider)proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, | |
axisEndpoint); | |
List<Handler> handlers = p.getBinding().getHandlerChain(); | |
if (handlers == null) | |
handlers = new ArrayList<Handler>(); | |
handlers.add(new AddNumbersClientLogicalHandler()); | |
handlers.add(new AddNumbersClientLogicalHandler2()); | |
handlers.add(new AddNumbersClientProtocolHandler()); | |
p.getBinding().setHandlerChain(handlers); | |
AddNumbersHandlerAsyncCallback callback = new AddNumbersHandlerAsyncCallback(); | |
Future<?> future = proxy.addNumbersHandlerAsync(10, 10, callback); | |
while (!future.isDone()) { | |
Thread.sleep(1000); | |
TestLogger.logger.debug("Async invocation incomplete"); | |
} | |
int total = callback.getResponseValue(); | |
assertEquals("With handler manipulation, total should be 26.", 26, total); | |
TestLogger.logger.debug("Total (after handler manipulation) = " + total); | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n" | |
+ "AddNumbersProtocolHandler PRE_DESTROY\n" | |
+ "AddNumbersClientProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersClientProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersClientProtocolHandler CLOSE\n" | |
+ "AddNumbersClientLogicalHandler2 CLOSE\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("----------------------------------"); | |
} catch(Exception e) { | |
e.printStackTrace(); | |
fail(e.toString()); | |
} | |
} | |
public void testAddNumbersHandlerHandlerResolver() { | |
try { | |
System.out.println("----------------------------------"); | |
System.out.println("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); // will give NPE: | |
List<Handler> handlers = service.getHandlerResolver() | |
.getHandlerChain(null); | |
assertNotNull( | |
"Default handlers list should not be null but empty.", | |
handlers); | |
String log = readLogFile(); | |
assertNull("log should be null since we did not call any services", log); | |
} catch (Exception e) { | |
e.printStackTrace(); | |
fail(e.getMessage()); | |
} | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
public void testOneWay() { | |
try { | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider bp = (BindingProvider) proxy; | |
bp.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, | |
axisEndpoint); | |
proxy.oneWayInt(11); | |
// one-way invocations run in their own thread, | |
// and we can't tell here in the client when it | |
// has completed. So, we need to wait long enough | |
// for the invocation to complete, so our log file | |
// is fully populated. | |
Thread.sleep(1000 * 5); // 5 seconds | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersLogicalHandler2 POST_CONSTRUCT\n" | |
+ "AddNumbersProtocolHandler2 GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler GET_HEADERS\n" | |
+ "AddNumbersProtocolHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersProtocolHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler2 HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler HANDLE_MESSAGE_INBOUND\n" | |
+ "AddNumbersLogicalHandler CLOSE\n" | |
+ "AddNumbersLogicalHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler2 CLOSE\n" | |
+ "AddNumbersProtocolHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
} catch (Exception e) { | |
e.printStackTrace(); | |
fail(e.getMessage()); | |
} | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
public void testOneWayWithProtocolException() { | |
Exception exception = null; | |
try { | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider) proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint); | |
p.getRequestContext().put("myClientKey", "myClientVal"); | |
List<Handler> handlers = p.getBinding().getHandlerChain(); | |
if (handlers == null) | |
handlers = new ArrayList<Handler>(); | |
handlers.add(new AddNumbersClientLogicalHandler()); | |
handlers.add(new AddNumbersClientProtocolHandler()); | |
p.getBinding().setHandlerChain(handlers); | |
BindingProvider bp = (BindingProvider) proxy; | |
bp.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint); | |
// value 99 will trigger exception from AddNumbersClientLogicalHandler | |
proxy.oneWayInt(99); | |
} catch (Exception e) { | |
e.printStackTrace(); | |
exception = e; | |
} | |
// exceptions on one-way invocations are suppressed by default | |
assertNull(exception); | |
// one-way invocations run in their own thread, | |
// and we can't tell here in the client when it | |
// has completed. So, we need to wait long enough | |
// for the invocation to complete, so our log file | |
// is fully populated. | |
try { | |
Thread.sleep(1000 * 5); // 5 seconds | |
} catch (InterruptedException ie) { | |
// nothing | |
} | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
public void testOneWayWithRuntimeException() { | |
Exception exception = null; | |
try { | |
TestLogger.logger.debug("----------------------------------"); | |
TestLogger.logger.debug("test: " + getName()); | |
AddNumbersHandlerService service = new AddNumbersHandlerService(); | |
AddNumbersHandlerPortType proxy = service.getAddNumbersHandlerPort(); | |
BindingProvider p = (BindingProvider) proxy; | |
p.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint); | |
p.getRequestContext().put("myClientKey", "myClientVal"); | |
List<Handler> handlers = p.getBinding().getHandlerChain(); | |
if (handlers == null) | |
handlers = new ArrayList<Handler>(); | |
handlers.add(new AddNumbersClientLogicalHandler()); | |
handlers.add(new AddNumbersClientProtocolHandler()); | |
p.getBinding().setHandlerChain(handlers); | |
BindingProvider bp = (BindingProvider) proxy; | |
bp.getRequestContext().put(BindingProvider.ENDPOINT_ADDRESS_PROPERTY, axisEndpoint); | |
// value 99 will trigger exception from AddNumbersClientLogicalHandler | |
proxy.oneWayInt(999); | |
} catch (Exception e) { | |
e.printStackTrace(); | |
exception = e; | |
} | |
// exceptions on one-way invocations are suppressed by default | |
assertNull(exception); | |
// one-way invocations run in their own thread, | |
// and we can't tell here in the client when it | |
// has completed. So, we need to wait long enough | |
// for the invocation to complete, so our log file | |
// is fully populated. | |
try { | |
Thread.sleep(1000 * 5); // 5 seconds | |
} catch (InterruptedException ie) { | |
// nothing | |
} | |
String log = readLogFile(); | |
String expected_calls = "AddNumbersClientLogicalHandler HANDLE_MESSAGE_OUTBOUND\n" | |
+ "AddNumbersClientLogicalHandler CLOSE\n"; | |
assertEquals(expected_calls, log); | |
TestLogger.logger.debug("----------------------------------"); | |
} | |
/* | |
* A callback implementation that can be used to collect the exceptions | |
*/ | |
class AddNumbersHandlerAsyncCallback implements AsyncHandler<AddNumbersHandlerResponse> { | |
private Exception exception; | |
private int retVal; | |
public void handleResponse(Response<AddNumbersHandlerResponse> response) { | |
try { | |
TestLogger.logger.debug("FaultyAsyncHandler.handleResponse() was called"); | |
AddNumbersHandlerResponse r = response.get(); | |
TestLogger.logger.debug("No exception was thrown from Response.get()"); | |
retVal = r.getReturn(); | |
} | |
catch (Exception e) { | |
TestLogger.logger.debug("An exception was thrown: " + e.getClass()); | |
exception = e; | |
} | |
} | |
public int getResponseValue() { | |
return retVal; | |
} | |
public Exception getException() { | |
return exception; | |
} | |
} | |
class MyHandlerResolver implements HandlerResolver { | |
public List<Handler> getHandlerChain(PortInfo portinfo) { | |
ArrayList<Handler> handlers = new ArrayList<Handler>(); | |
handlers.add(new AddNumbersClientLogicalHandler()); | |
handlers.add(new AddNumbersClientProtocolHandler()); | |
return handlers; | |
} | |
} | |
private String getString(Source source) throws Exception { | |
if (source == null) { | |
return null; | |
} | |
StringWriter writer = new StringWriter(); | |
Transformer t = TransformerFactory.newInstance().newTransformer(); | |
Result result = new StreamResult(writer); | |
t.transform(source, result); | |
return writer.getBuffer().toString(); | |
} | |
/** | |
* Create a Source request to be used by Dispatch<Source> | |
*/ | |
private Source createRequestSource() throws IOException { | |
FileInputStream fis = new FileInputStream(requestFile); | |
return new StreamSource(fis); | |
} | |
protected void setUp() { | |
File file = new File(filelogname); | |
file.delete(); // yes, delete for each retrieval, which should only happen once per test | |
} | |
private String readLogFile() { | |
try { | |
FileReader fr = new FileReader(filelogname); | |
BufferedReader inputStream = new BufferedReader(fr); | |
String line = null; | |
String ret = null; | |
while ((line = inputStream.readLine()) != null) { | |
if (ret == null) { | |
ret = ""; | |
} | |
ret = ret.concat(line + "\n"); | |
} | |
fr.close(); | |
return ret; | |
} catch (FileNotFoundException fnfe) { | |
// it's possible the test does not actually call any handlers and therefore | |
// no file would have been written. The test should account for this by | |
// assertNull on the return value from here | |
} catch (IOException ioe) { | |
ioe.printStackTrace(); | |
fail(ioe.getMessage()); | |
} | |
return null; | |
} | |
} |