Spring/spring-ws
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed tests.

Browse Source
This commit is contained in:
Arjen Poutsma
2010-02-10 15:41:43 +00:00
parent b157817ae6
commit b4fa00032d
6 changed files with 201 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
core/src/test/java/org/springframework/ws/server/endpoint/adapter/MarshallingMethodEndpointAdapterTest.java
View File

@@ -17,9 +17,9 @@
package org.springframework.ws.server.endpoint.adapter;
import java.lang.reflect.Method;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import junit.framework.TestCase;
import org.easymock.MockControl;
import org.springframework.oxm.Marshaller;
import org.springframework.oxm.Unmarshaller;
import org.springframework.ws.MockWebServiceMessage;
@@ -28,136 +28,146 @@ import org.springframework.ws.context.DefaultMessageContext;
import org.springframework.ws.context.MessageContext;
import org.springframework.ws.server.endpoint.MethodEndpoint;
public class MarshallingMethodEndpointAdapterTest extends TestCase {
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.easymock.EasyMock.*;
public class MarshallingMethodEndpointAdapterTest {
private MarshallingMethodEndpointAdapter adapter;
private boolean noResponseInvoked;
private MockControl marshallerControl;
private Marshaller marshallerMock;
private MockControl unmarshallerControl;
private Unmarshaller unmarshallerMock;
private MessageContext messageContext;
private boolean responseInvoked;
@Override
protected void setUp() throws Exception {
@Before
public void setUp() throws Exception {
adapter = new MarshallingMethodEndpointAdapter();
marshallerControl = MockControl.createControl(Marshaller.class);
marshallerMock = (Marshaller) marshallerControl.getMock();
marshallerMock = createMock(Marshaller.class);
adapter.setMarshaller(marshallerMock);
unmarshallerControl = MockControl.createControl(Unmarshaller.class);
unmarshallerMock = (Unmarshaller) unmarshallerControl.getMock();
unmarshallerMock = createMock(Unmarshaller.class);
adapter.setUnmarshaller(unmarshallerMock);
adapter.afterPropertiesSet();
MockWebServiceMessage request = new MockWebServiceMessage("<request/>");
messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
}
@Test
public void testNoResponse() throws Exception {
Method noResponse = getClass().getMethod("noResponse", new Class[]{MyType.class});
MethodEndpoint methodEndpoint = new MethodEndpoint(this, noResponse);
unmarshallerMock.unmarshal(messageContext.getRequest().getPayloadSource());
unmarshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
unmarshallerControl.setReturnValue(new MyType());
marshallerControl.replay();
unmarshallerControl.replay();
assertFalse("Method invoked", noResponseInvoked);
expect(unmarshallerMock.unmarshal(isA(Source.class))).andReturn(new MyType());
replay(marshallerMock, unmarshallerMock);
Assert.assertFalse("Method invoked", noResponseInvoked);
adapter.invoke(messageContext, methodEndpoint);
assertTrue("Method not invoked", noResponseInvoked);
marshallerControl.verify();
unmarshallerControl.verify();
Assert.assertTrue("Method not invoked", noResponseInvoked);
verify(marshallerMock, unmarshallerMock);
}
@Test
public void testNoRequestPayload() throws Exception {
MockWebServiceMessage request = new MockWebServiceMessage();
messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
Method noResponse = getClass().getMethod("noResponse", new Class[]{MyType.class});
MethodEndpoint methodEndpoint = new MethodEndpoint(this, noResponse);
marshallerControl.replay();
unmarshallerControl.replay();
assertFalse("Method invoked", noResponseInvoked);
replay(marshallerMock, unmarshallerMock);
Assert.assertFalse("Method invoked", noResponseInvoked);
adapter.invoke(messageContext, methodEndpoint);
assertTrue("Method not invoked", noResponseInvoked);
marshallerControl.verify();
unmarshallerControl.verify();
Assert.assertTrue("Method not invoked", noResponseInvoked);
verify(marshallerMock, unmarshallerMock);
}
@Test
public void testResponse() throws Exception {
Method response = getClass().getMethod("response", new Class[]{MyType.class});
MethodEndpoint methodEndpoint = new MethodEndpoint(this, response);
unmarshallerMock.unmarshal(messageContext.getRequest().getPayloadSource());
unmarshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
unmarshallerControl.setReturnValue(new MyType());
marshallerMock.marshal(new MyType(), messageContext.getResponse().getPayloadResult());
marshallerControl.setMatcher(MockControl.ALWAYS_MATCHER);
marshallerControl.replay();
unmarshallerControl.replay();
assertFalse("Method invoked", responseInvoked);
adapter.invoke(messageContext, methodEndpoint);
assertTrue("Method not invoked", responseInvoked);
marshallerControl.verify();
unmarshallerControl.verify();
expect(unmarshallerMock.unmarshal(isA(Source.class))).andReturn(new MyType());
marshallerMock.marshal(isA(MyType.class), isA(Result.class));
replay(marshallerMock, unmarshallerMock);
Assert.assertFalse("Method invoked", responseInvoked);
adapter.invoke(messageContext, methodEndpoint);
Assert.assertTrue("Method not invoked", responseInvoked);
verify(marshallerMock, unmarshallerMock);
}
@Test
public void testSupportedNoResponse() throws NoSuchMethodException {
Method noResponse = getClass().getMethod("noResponse", new Class[]{MyType.class});
MethodEndpoint methodEndpoint = new MethodEndpoint(this, noResponse);
unmarshallerControl.expectAndReturn(unmarshallerMock.supports(MyType.class), true);
marshallerControl.replay();
unmarshallerControl.replay();
assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
marshallerControl.verify();
unmarshallerControl.verify();
expect(unmarshallerMock.supports(MyType.class)).andReturn(true);
replay(marshallerMock, unmarshallerMock);
Assert.assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
verify(marshallerMock, unmarshallerMock);
}
@Test
public void testSupportedResponse() throws NoSuchMethodException {
Method response = getClass().getMethod("response", new Class[]{MyType.class});
MethodEndpoint methodEndpoint = new MethodEndpoint(this, response);
unmarshallerControl.expectAndReturn(unmarshallerMock.supports(MyType.class), true);
marshallerControl.expectAndReturn(marshallerMock.supports(MyType.class), true);
marshallerControl.replay();
unmarshallerControl.replay();
assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
marshallerControl.verify();
unmarshallerControl.verify();
expect(unmarshallerMock.supports(MyType.class)).andReturn(true);
expect(marshallerMock.supports(MyType.class)).andReturn(true);
replay(marshallerMock, unmarshallerMock);
Assert.assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
verify(marshallerMock, unmarshallerMock);
}
@Test
public void testUnsupportedMethodMultipleParams() throws NoSuchMethodException {
Method unsupported = getClass().getMethod("unsupportedMultipleParams", new Class[]{String.class, String.class});
marshallerControl.replay();
unmarshallerControl.replay();
assertFalse("Method supported", adapter.supportsInternal(new MethodEndpoint(this, unsupported)));
marshallerControl.verify();
unmarshallerControl.verify();
replay(marshallerMock, unmarshallerMock);
Assert.assertFalse("Method supported", adapter.supportsInternal(new MethodEndpoint(this, unsupported)));
verify(marshallerMock, unmarshallerMock);
}
@Test
public void testUnsupportedMethodWrongParam() throws NoSuchMethodException {
Method unsupported = getClass().getMethod("unsupportedWrongParam", new Class[]{String.class});
unmarshallerControl.expectAndReturn(unmarshallerMock.supports(String.class), false);
marshallerControl.expectAndReturn(marshallerMock.supports(String.class), true);
marshallerControl.replay();
unmarshallerControl.replay();
assertFalse("Method supported", adapter.supportsInternal(new MethodEndpoint(this, unsupported)));
marshallerControl.verify();
unmarshallerControl.verify();
expect(unmarshallerMock.supports(String.class)).andReturn(false);
expect(marshallerMock.supports(String.class)).andReturn(true);
replay(marshallerMock, unmarshallerMock);
Assert.assertFalse("Method supported", adapter.supportsInternal(new MethodEndpoint(this, unsupported)));
verify(marshallerMock, unmarshallerMock);
}
@Test
public void testUnsupportedMethodWrongReturnType() throws NoSuchMethodException {
Method unsupported = getClass().getMethod("unsupportedWrongParam", new Class[]{String.class});
marshallerControl.expectAndReturn(marshallerMock.supports(String.class), false);
marshallerControl.replay();
unmarshallerControl.replay();
assertFalse("Method supported", adapter.supportsInternal(new MethodEndpoint(this, unsupported)));
marshallerControl.verify();
unmarshallerControl.verify();
expect(marshallerMock.supports(String.class)).andReturn(false);
replay(marshallerMock, unmarshallerMock);
Assert.assertFalse("Method supported", adapter.supportsInternal(new MethodEndpoint(this, unsupported)));
verify(marshallerMock, unmarshallerMock);
}
public void noResponse(MyType type) {

32
core/src/test/java/org/springframework/ws/server/endpoint/adapter/MessageEndpointAdapterTest.java
View File

@@ -16,39 +16,47 @@
package org.springframework.ws.server.endpoint.adapter;
import junit.framework.TestCase;
import org.easymock.MockControl;
import org.springframework.ws.MockWebServiceMessageFactory;
import org.springframework.ws.context.DefaultMessageContext;
import org.springframework.ws.context.MessageContext;
import org.springframework.ws.server.endpoint.MessageEndpoint;
public class MessageEndpointAdapterTest extends TestCase {
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.easymock.EasyMock.*;
public class MessageEndpointAdapterTest {
private MessageEndpointAdapter adapter;
private MockControl endpointControl;
private MessageEndpoint endpointMock;
@Override
protected void setUp() throws Exception {
@Before
public void setUp() throws Exception {
adapter = new MessageEndpointAdapter();
endpointControl = MockControl.createControl(MessageEndpoint.class);
endpointMock = (MessageEndpoint) endpointControl.getMock();
endpointMock = createMock(MessageEndpoint.class);
}
@Test
public void testSupports() throws Exception {
assertTrue("MessageEndpointAdapter does not support MessageEndpoint", adapter.supports(endpointMock));
Assert.assertTrue("MessageEndpointAdapter does not support MessageEndpoint", adapter.supports(endpointMock));
}
@Test
public void testInvoke() throws Exception {
MessageContext context = new DefaultMessageContext(new MockWebServiceMessageFactory());
endpointMock.invoke(context);
endpointControl.replay();
replay(endpointMock);
adapter.invoke(context, endpointMock);
endpointControl.verify();
verify(endpointMock);
}
}

28
core/src/test/java/org/springframework/ws/server/endpoint/adapter/MessageMethodEndpointAdapterTest.java
View File

@@ -16,13 +16,16 @@
package org.springframework.ws.server.endpoint.adapter;
import junit.framework.TestCase;
import org.springframework.ws.MockWebServiceMessageFactory;
import org.springframework.ws.context.DefaultMessageContext;
import org.springframework.ws.context.MessageContext;
import org.springframework.ws.server.endpoint.MethodEndpoint;
public class MessageMethodEndpointAdapterTest extends TestCase {
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class MessageMethodEndpointAdapterTest {
private MessageMethodEndpointAdapter adapter;
@@ -30,32 +33,37 @@ public class MessageMethodEndpointAdapterTest extends TestCase {
private MessageContext messageContext;
@Override
protected void setUp() throws Exception {
@Before
public void setUp() throws Exception {
adapter = new MessageMethodEndpointAdapter();
messageContext = new DefaultMessageContext(new MockWebServiceMessageFactory());
}
@Test
public void testSupported() throws NoSuchMethodException {
MethodEndpoint methodEndpoint = new MethodEndpoint(this, "supported", new Class[]{MessageContext.class});
assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
Assert.assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
}
@Test
public void testUnsupportedMethodMultipleParams() throws NoSuchMethodException {
assertFalse("Method supported", adapter.supportsInternal(new MethodEndpoint(this, "unsupportedMultipleParams",
new Class[]{MessageContext.class, MessageContext.class})));
Assert.assertFalse("Method supported", adapter.supportsInternal(
new MethodEndpoint(this, "unsupportedMultipleParams",
new Class[]{MessageContext.class, MessageContext.class})));
}
@Test
public void testUnsupportedMethodWrongParam() throws NoSuchMethodException {
assertFalse("Method supported",
Assert.assertFalse("Method supported",
adapter.supportsInternal(new MethodEndpoint(this, "unsupportedWrongParam", new Class[]{String.class})));
}
@Test
public void testInvokeSupported() throws Exception {
MethodEndpoint methodEndpoint = new MethodEndpoint(this, "supported", new Class[]{MessageContext.class});
assertFalse("Method invoked", supportedInvoked);
Assert.assertFalse("Method invoked", supportedInvoked);
adapter.invoke(messageContext, methodEndpoint);
assertTrue("Method not invoked", supportedInvoked);
Assert.assertTrue("Method not invoked", supportedInvoked);
}
public void supported(MessageContext context) {

44
core/src/test/java/org/springframework/ws/server/endpoint/adapter/PayloadEndpointAdapterTest.java
View File

@@ -24,33 +24,37 @@ import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.custommonkey.xmlunit.XMLTestCase;
import org.easymock.MockControl;
import org.springframework.ws.MockWebServiceMessage;
import org.springframework.ws.MockWebServiceMessageFactory;
import org.springframework.ws.context.DefaultMessageContext;
import org.springframework.ws.context.MessageContext;
import org.springframework.ws.server.endpoint.PayloadEndpoint;
public class PayloadEndpointAdapterTest extends XMLTestCase {
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
import static org.easymock.EasyMock.*;
public class PayloadEndpointAdapterTest {
private PayloadEndpointAdapter adapter;
private PayloadEndpoint endpointMock;
private MockControl endpointControl;
@Override
protected void setUp() throws Exception {
@Before
public void setUp() throws Exception {
adapter = new PayloadEndpointAdapter();
endpointControl = MockControl.createControl(PayloadEndpoint.class);
endpointMock = (PayloadEndpoint) endpointControl.getMock();
endpointMock = createMock(PayloadEndpoint.class);
}
@Test
public void testSupports() throws Exception {
assertTrue("PayloadEndpointAdapter does not support PayloadEndpoint", adapter.supports(endpointMock));
Assert.assertTrue("PayloadEndpointAdapter does not support PayloadEndpoint", adapter.supports(endpointMock));
}
@Test
public void testInvoke() throws Exception {
MockWebServiceMessage request = new MockWebServiceMessage("<request/>");
final Transformer transformer = TransformerFactory.newInstance().newTransformer();
@@ -66,19 +70,23 @@ public class PayloadEndpointAdapterTest extends XMLTestCase {
MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
adapter.invoke(messageContext, endpoint);
MockWebServiceMessage response = (MockWebServiceMessage) messageContext.getResponse();
assertNotNull("No response created", response);
Assert.assertNotNull("No response created", response);
assertXMLEqual("Invalid payload", "<response/>", response.getPayloadAsString());
}
@Test
public void testInvokeNoResponse() throws Exception {
MessageContext messageContext = new DefaultMessageContext(new MockWebServiceMessageFactory());
endpointMock.invoke(messageContext.getRequest().getPayloadSource());
endpointControl.setMatcher(MockControl.ALWAYS_MATCHER);
endpointControl.setReturnValue(null);
endpointControl.replay();
MockWebServiceMessage request = new MockWebServiceMessage("<request/>");
MessageContext messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
expect(endpointMock.invoke(isA(Source.class))).andReturn(null);
replay(endpointMock);
adapter.invoke(messageContext, endpointMock);
endpointControl.verify();
assertFalse("Response created", messageContext.hasResponse());
verify(endpointMock);
Assert.assertFalse("Response created", messageContext.hasResponse());
}
}

36
core/src/test/java/org/springframework/ws/server/endpoint/adapter/PayloadMethodEndpointAdapterTest.java
View File

@@ -20,7 +20,6 @@ import javax.xml.transform.Source;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;
import junit.framework.TestCase;
import org.springframework.ws.MockWebServiceMessage;
import org.springframework.ws.MockWebServiceMessageFactory;
import org.springframework.ws.WebServiceMessage;
@@ -28,7 +27,11 @@ import org.springframework.ws.context.DefaultMessageContext;
import org.springframework.ws.context.MessageContext;
import org.springframework.ws.server.endpoint.MethodEndpoint;
public class PayloadMethodEndpointAdapterTest extends TestCase {
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class PayloadMethodEndpointAdapterTest {
private PayloadMethodEndpointAdapter adapter;
@@ -38,51 +41,58 @@ public class PayloadMethodEndpointAdapterTest extends TestCase {
private MessageContext messageContext;
@Override
protected void setUp() throws Exception {
@Before
public void setUp() throws Exception {
adapter = new PayloadMethodEndpointAdapter();
messageContext = new DefaultMessageContext(new MockWebServiceMessageFactory());
}
@Test
public void testSupportedNoResponse() throws NoSuchMethodException {
MethodEndpoint methodEndpoint = new MethodEndpoint(this, "noResponse", new Class[]{DOMSource.class});
assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
Assert.assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
}
@Test
public void testSupportedResponse() throws NoSuchMethodException {
MethodEndpoint methodEndpoint = new MethodEndpoint(this, "response", new Class[]{StreamSource.class});
assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
Assert.assertTrue("Method unsupported", adapter.supportsInternal(methodEndpoint));
}
@Test
public void testUnsupportedMethodMultipleParams() throws NoSuchMethodException {
assertFalse("Method supported", adapter.supportsInternal(
Assert.assertFalse("Method supported", adapter.supportsInternal(
new MethodEndpoint(this, "unsupportedMultipleParams", new Class[]{Source.class, Source.class})));
}
@Test
public void testUnsupportedMethodWrongReturnType() throws NoSuchMethodException {
assertFalse("Method supported", adapter.supportsInternal(
Assert.assertFalse("Method supported", adapter.supportsInternal(
new MethodEndpoint(this, "unsupportedWrongReturnType", new Class[]{Source.class})));
}
@Test
public void testUnsupportedMethodWrongParam() throws NoSuchMethodException {
assertFalse("Method supported",
Assert.assertFalse("Method supported",
adapter.supportsInternal(new MethodEndpoint(this, "unsupportedWrongParam", new Class[]{String.class})));
}
@Test
public void testNoResponse() throws Exception {
MethodEndpoint methodEndpoint = new MethodEndpoint(this, "noResponse", new Class[]{DOMSource.class});
assertFalse("Method invoked", noResponseInvoked);
Assert.assertFalse("Method invoked", noResponseInvoked);
adapter.invoke(messageContext, methodEndpoint);
assertTrue("Method not invoked", noResponseInvoked);
Assert.assertTrue("Method not invoked", noResponseInvoked);
}
@Test
public void testResponse() throws Exception {
WebServiceMessage request = new MockWebServiceMessage("<request/>");
messageContext = new DefaultMessageContext(request, new MockWebServiceMessageFactory());
MethodEndpoint methodEndpoint = new MethodEndpoint(this, "response", new Class[]{StreamSource.class});
assertFalse("Method invoked", responseInvoked);
Assert.assertFalse("Method invoked", responseInvoked);
adapter.invoke(messageContext, methodEndpoint);
assertTrue("Method not invoked", responseInvoked);
Assert.assertTrue("Method not invoked", responseInvoked);
}
public void noResponse(DOMSource request) {

54
core/src/test/java/org/springframework/ws/server/endpoint/adapter/XPathParamAnnotationMethodEndpointAdapterTest.java
View File

@@ -32,7 +32,9 @@ import org.springframework.ws.server.endpoint.annotation.XPathParam;
import org.springframework.xml.transform.StringResult;
import org.springframework.xml.transform.StringSource;
import junit.framework.TestCase;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
@@ -41,7 +43,7 @@ import org.w3c.dom.Text;
import static org.easymock.EasyMock.*;
public class XPathParamAnnotationMethodEndpointAdapterTest extends TestCase {
public class XPathParamAnnotationMethodEndpointAdapterTest {
private static final String CONTENTS = "<root><child><text>text</text><number>42.0</number></child></root>";
@@ -53,49 +55,57 @@ public class XPathParamAnnotationMethodEndpointAdapterTest extends TestCase {
private boolean namespacesInvoked;
@Override
protected void setUp() throws Exception {
@Before
public void setUp() throws Exception {
adapter = new XPathParamAnnotationMethodEndpointAdapter();
adapter.afterPropertiesSet();
}
@Test
public void testUnsupportedInvalidParam() throws NoSuchMethodException {
MethodEndpoint endpoint = new MethodEndpoint(this, "unsupportedInvalidParamType", new Class[]{Integer.TYPE});
assertFalse("Method supported", adapter.supports(endpoint));
Assert.assertFalse("Method supported", adapter.supports(endpoint));
}
@Test
public void testUnsupportedInvalidReturnType() throws NoSuchMethodException {
MethodEndpoint endpoint = new MethodEndpoint(this, "unsupportedInvalidReturnType", new Class[]{String.class});
assertFalse("Method supported", adapter.supports(endpoint));
Assert.assertFalse("Method supported", adapter.supports(endpoint));
}
@Test
public void testUnsupportedInvalidParams() throws NoSuchMethodException {
MethodEndpoint endpoint =
new MethodEndpoint(this, "unsupportedInvalidParams", new Class[]{String.class, String.class});
assertFalse("Method supported", adapter.supports(endpoint));
Assert.assertFalse("Method supported", adapter.supports(endpoint));
}
@Test
public void testSupportedTypes() throws NoSuchMethodException {
MethodEndpoint endpoint = new MethodEndpoint(this, "supportedTypes",
new Class[]{Boolean.TYPE, Double.TYPE, Node.class, NodeList.class, String.class});
assertTrue("Not all types supported", adapter.supports(endpoint));
Assert.assertTrue("Not all types supported", adapter.supports(endpoint));
}
@Test
public void testSupportsStringSource() throws NoSuchMethodException {
MethodEndpoint endpoint = new MethodEndpoint(this, "supportedStringSource", new Class[]{String.class});
assertTrue("StringSource method not supported", adapter.supports(endpoint));
Assert.assertTrue("StringSource method not supported", adapter.supports(endpoint));
}
@Test
public void testSupportsSource() throws NoSuchMethodException {
MethodEndpoint endpoint = new MethodEndpoint(this, "supportedSource", new Class[]{String.class});
assertTrue("Source method not supported", adapter.supports(endpoint));
Assert.assertTrue("Source method not supported", adapter.supports(endpoint));
}
@Test
public void testSupportsVoid() throws NoSuchMethodException {
MethodEndpoint endpoint = new MethodEndpoint(this, "supportedVoid", new Class[]{String.class});
assertTrue("void method not supported", adapter.supports(endpoint));
Assert.assertTrue("void method not supported", adapter.supports(endpoint));
}
@Test
public void testInvokeTypes() throws Exception {
WebServiceMessage messageMock = createMock(WebServiceMessage.class);
expect(messageMock.getPayloadSource()).andReturn(new StringSource(CONTENTS));
@@ -106,11 +116,12 @@ public class XPathParamAnnotationMethodEndpointAdapterTest extends TestCase {
MethodEndpoint endpoint = new MethodEndpoint(this, "supportedTypes",
new Class[]{Boolean.TYPE, Double.TYPE, Node.class, NodeList.class, String.class});
adapter.invoke(messageContext, endpoint);
assertTrue("Method not invoked", supportedTypesInvoked);
Assert.assertTrue("Method not invoked", supportedTypesInvoked);
verify(messageMock, factoryMock);
}
@Test
public void testInvokeSource() throws Exception {
WebServiceMessage requestMock = createMock(WebServiceMessage.class);
WebServiceMessage responseMock = createMock(WebServiceMessage.class);
@@ -123,11 +134,12 @@ public class XPathParamAnnotationMethodEndpointAdapterTest extends TestCase {
MessageContext messageContext = new DefaultMessageContext(requestMock, factoryMock);
MethodEndpoint endpoint = new MethodEndpoint(this, "supportedSource", new Class[]{String.class});
adapter.invoke(messageContext, endpoint);
assertTrue("Method not invoked", supportedSourceInvoked);
Assert.assertTrue("Method not invoked", supportedSourceInvoked);
verify(requestMock, responseMock, factoryMock);
}
@Test
public void testInvokeVoidDom() throws Exception {
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
@@ -159,7 +171,7 @@ public class XPathParamAnnotationMethodEndpointAdapterTest extends TestCase {
MessageContext messageContext = new DefaultMessageContext(requestMock, factoryMock);
MethodEndpoint endpoint = new MethodEndpoint(this, "namespaces", new Class[]{Node.class});
adapter.invoke(messageContext, endpoint);
assertTrue("Method not invoked", namespacesInvoked);
Assert.assertTrue("Method not invoked", namespacesInvoked);
}
public void supportedVoid(@XPathParam("/")String param1) {
@@ -180,12 +192,12 @@ public class XPathParamAnnotationMethodEndpointAdapterTest extends TestCase {
@XPathParam("/root/*")NodeList param4,
@XPathParam("/root/child/text")String param5) {
supportedTypesInvoked = true;
assertTrue("Invalid boolean value", param1);
assertEquals("Invalid double value", 42D, param2, 0.00001D);
assertEquals("Invalid Node value", "child", param3.getLocalName());
assertEquals("Invalid NodeList value", 1, param4.getLength());
assertEquals("Invalid Node value", "child", param4.item(0).getLocalName());
assertEquals("Invalid Node value", "text", param5);
Assert.assertTrue("Invalid boolean value", param1);
Assert.assertEquals("Invalid double value", 42D, param2, 0.00001D);
Assert.assertEquals("Invalid Node value", "child", param3.getLocalName());
Assert.assertEquals("Invalid NodeList value", 1, param4.getLength());
Assert.assertEquals("Invalid Node value", "child", param4.item(0).getLocalName());
Assert.assertEquals("Invalid Node value", "text", param5);
}
public void unsupportedInvalidParams(@XPathParam("/")String param1, String param2) {
@@ -201,6 +213,6 @@ public class XPathParamAnnotationMethodEndpointAdapterTest extends TestCase {
public void namespaces(@XPathParam(".")Node param) {
namespacesInvoked = true;
assertEquals("Invalid parameter", "child", param.getLocalName());
Assert.assertEquals("Invalid parameter", "child", param.getLocalName());
}
}