SWS-351 - Arbitrary parameter injection for @Endpoints

core/src/main/java/org/springframework/ws/soap/server/endpoint/adapter/method/SoapMethodArgumentResolver.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2005-2010 the original author or authors.
+ *
+ * Licensed 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.springframework.ws.soap.server.endpoint.adapter.method;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.util.Assert;
+import org.springframework.ws.context.MessageContext;
+import org.springframework.ws.server.endpoint.adapter.method.MethodArgumentResolver;
+import org.springframework.ws.soap.SoapBody;
+import org.springframework.ws.soap.SoapEnvelope;
+import org.springframework.ws.soap.SoapHeader;
+import org.springframework.ws.soap.SoapMessage;
+
+/**
+ * Implementation of {@link MethodArgumentResolver} that supports {@link SoapMessage}, {@link SoapBody}, {@link
+ * SoapEnvelope}, and {@link SoapHeader}.
+ *
+ * @author Arjen Poutsma
+ * @since 2.0
+ */
+public class SoapMethodArgumentResolver implements MethodArgumentResolver {
+
+    public boolean supportsParameter(MethodParameter parameter) {
+        Class<?> parameterType = parameter.getParameterType();
+        return SoapMessage.class.equals(parameterType) || SoapBody.class.equals(parameterType) ||
+                SoapEnvelope.class.equals(parameterType) || SoapHeader.class.equals(parameterType);
+    }
+
+    public Object resolveArgument(MessageContext messageContext, MethodParameter parameter) {
+        Assert.isInstanceOf(SoapMessage.class, messageContext.getRequest());
+        SoapMessage request = (SoapMessage) messageContext.getRequest();
+
+        Class<?> parameterType = parameter.getParameterType();
+
+        if (SoapMessage.class.equals(parameterType)) {
+            return request;
+        }
+        else if (SoapBody.class.equals(parameterType)) {
+            return request.getSoapBody();
+        }
+        else if (SoapEnvelope.class.equals(parameterType)) {
+            return request.getEnvelope();
+        }
+        else if (SoapHeader.class.equals(parameterType)) {
+            return request.getSoapHeader();
+        }
+        // should not happen
+        throw new UnsupportedOperationException();
+    }
+}

core/src/test/java/org/springframework/ws/server/endpoint/adapter/method/StaxPayloadMethodArgumentResolverTest.java

@@ -30,8 +30,7 @@ import org.springframework.ws.server.endpoint.annotation.RequestPayload;
 import org.junit.Before;
 import org.junit.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 
 /** @author Arjen Poutsma */
 @SuppressWarnings("Since15")
@@ -43,11 +42,21 @@ public class StaxPayloadMethodArgumentResolverTest extends AbstractMethodArgumen
 
     private MethodParameter eventParameter;
 
+    private MethodParameter invalidParameter;
+
     @Before
     public void setUp() throws Exception {
         resolver = new StaxPayloadMethodArgumentResolver();
         streamParameter = new MethodParameter(getClass().getMethod("streamReader", XMLStreamReader.class), 0);
         eventParameter = new MethodParameter(getClass().getMethod("eventReader", XMLEventReader.class), 0);
+        invalidParameter = new MethodParameter(getClass().getMethod("invalid", XMLStreamReader.class), 0);
+    }
+
+    @Test
+    public void supportsParameter() {
+        assertTrue("resolver does not support XMLStreamReader", resolver.supportsParameter(streamParameter));
+        assertTrue("resolver does not support XMLEventReader", resolver.supportsParameter(eventParameter));
+        assertFalse("resolver supports invalid parameter", resolver.supportsParameter(invalidParameter));
     }
 
     @Test

core/src/test/java/org/springframework/ws/soap/server/endpoint/adapter/method/SoapMethodArgumentResolverTest.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2005-2010 the original author or authors.
+ *
+ * Licensed 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.springframework.ws.soap.server.endpoint.adapter.method;
+
+import org.springframework.core.MethodParameter;
+import org.springframework.ws.context.MessageContext;
+import org.springframework.ws.server.endpoint.adapter.method.AbstractMethodArgumentResolverTest;
+import org.springframework.ws.soap.SoapBody;
+import org.springframework.ws.soap.SoapEnvelope;
+import org.springframework.ws.soap.SoapHeader;
+import org.springframework.ws.soap.SoapMessage;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/** @author Arjen Poutsma */
+public class SoapMethodArgumentResolverTest extends AbstractMethodArgumentResolverTest {
+
+    private SoapMethodArgumentResolver resolver;
+
+    private MethodParameter soapMessageParameter;
+
+    private MethodParameter soapEnvelopeParameter;
+
+    private MethodParameter soapBodyParameter;
+
+    private MethodParameter soapHeaderParameter;
+
+    @Before
+    public void setUp() throws Exception {
+        resolver = new SoapMethodArgumentResolver();
+        soapMessageParameter = new MethodParameter(getClass().getMethod("soapMessage", SoapMessage.class), 0);
+        soapEnvelopeParameter = new MethodParameter(getClass().getMethod("soapEnvelope", SoapEnvelope.class), 0);
+        soapBodyParameter = new MethodParameter(getClass().getMethod("soapBody", SoapBody.class), 0);
+        soapHeaderParameter = new MethodParameter(getClass().getMethod("soapHeader", SoapHeader.class), 0);
+    }
+
+    @Test
+    public void supportsParameter() throws Exception {
+        assertTrue("resolver does not support SoapMessage", resolver.supportsParameter(soapMessageParameter));
+        assertTrue("resolver does not support SoapEnvelope", resolver.supportsParameter(soapEnvelopeParameter));
+        assertTrue("resolver does not support SoapBody", resolver.supportsParameter(soapBodyParameter));
+        assertTrue("resolver does not support SoapHeader", resolver.supportsParameter(soapHeaderParameter));
+    }
+
+    @Test
+    public void resolveSoapMessageSaaj() throws Exception {
+        MessageContext messageContext = createSaajMessageContext();
+
+        Object result = resolver.resolveArgument(messageContext, soapMessageParameter);
+
+        assertEquals(messageContext.getRequest(), result);
+    }
+
+    @Test
+    public void resolveSoapEnvelopeSaaj() throws Exception {
+        MessageContext messageContext = createSaajMessageContext();
+
+        Object result = resolver.resolveArgument(messageContext, soapEnvelopeParameter);
+
+        assertEquals(((SoapMessage)messageContext.getRequest()).getEnvelope(), result);
+    }
+
+    @Test
+    public void resolveSoapBodySaaj() throws Exception {
+        MessageContext messageContext = createSaajMessageContext();
+
+        Object result = resolver.resolveArgument(messageContext, soapBodyParameter);
+
+        assertEquals(((SoapMessage)messageContext.getRequest()).getSoapBody(), result);
+    }
+
+    @Test
+    public void resolveSoapHeaderSaaj() throws Exception {
+        MessageContext messageContext = createSaajMessageContext();
+
+        Object result = resolver.resolveArgument(messageContext, soapHeaderParameter);
+
+        assertEquals(((SoapMessage)messageContext.getRequest()).getSoapHeader(), result);
+    }
+
+    public void soapMessage(SoapMessage soapMessage) {
+
+    }
+
+    public void soapEnvelope(SoapEnvelope soapEnvelope) {
+    }
+
+    public void soapBody(SoapBody soapBody) {
+    }
+
+    public void soapHeader(SoapHeader soapHeader) {
+    }
+}