Merge branch '5.0.x'

Author: snicoll

spring-ws-core/src/test/java/org/springframework/ws/transport/http/AbstractHttpSenderConnectionTests.java

@@ -17,15 +17,31 @@
 package org.springframework.ws.transport.http;
 
 import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
 import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
 import java.util.Random;
+import java.util.zip.GZIPOutputStream;
 
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.io.input.BoundedInputStream;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.mockito.ArgumentCaptor;
 
+import org.springframework.core.io.ClassPathResource;
+import org.springframework.core.io.Resource;
+import org.springframework.util.MultiValueMap;
+import org.springframework.util.StreamUtils;
 import org.springframework.ws.WebServiceMessage;
 import org.springframework.ws.WebServiceMessageFactory;
 
@@ -35,7 +51,10 @@
 import static org.mockito.Mockito.when;
 
 /**
+ * Tests for {@link AbstractHttpSenderConnection}.
+ *
  * @author Andreas Veithen
+ * @author Stephane Nicoll
  */
 class AbstractHttpSenderConnectionTests {
 
@@ -45,15 +64,17 @@ class AbstractHttpSenderConnectionTests {
 	 * @param chunking Specifies whether the test should simulate a response with chunking
 	 * enabled.
 	 */
-	private void testSupportsStreaming(boolean chunking) throws Exception {
+	@ParameterizedTest
+	@ValueSource(booleans = { true, false })
+	void connectionSupportsStreaming(boolean chunking) throws Exception {
 		byte[] content = new byte[16 * 1024];
 		new Random().nextBytes(content);
 		BoundedInputStream rawInputStream = BoundedInputStream.builder()
 			.setInputStream(new ByteArrayInputStream(content))
 			.get();
 		AbstractHttpSenderConnection connection = spy(AbstractHttpSenderConnection.class);
 		when(connection.getResponseCode()).thenReturn(200);
-		// Simulate response with chunking enabled
+		// Simulate response with chunking if necessary
 		when(connection.getResponseContentLength()).thenReturn(chunking ? -1L : content.length);
 		when(connection.getRawResponseInputStream()).thenReturn(rawInputStream);
 		when(connection.getResponseHeaders(any())).thenReturn(Collections.emptyIterator());
@@ -72,13 +93,86 @@ private void testSupportsStreaming(boolean chunking) throws Exception {
 	}
 
 	@Test
-	void testSupportsStreamingWithChunkingEnabled() throws Exception {
-		testSupportsStreaming(true);
+	void gzipResponseIsDecodedIfNecessary() throws IOException {
+		ClassPathResource response = new ClassPathResource("soapRequest.xml", getClass());
+		long responseSize = StreamUtils.copyToByteArray(response.getInputStream()).length;
+		MultiValueMap<String, String> responseHeaders = MultiValueMap.fromSingleValue(
+				Map.of(HttpTransportConstants.HEADER_CONTENT_ENCODING, HttpTransportConstants.CONTENT_ENCODING_GZIP,
+						HttpTransportConstants.HEADER_CONTENT_LENGTH, String.valueOf(responseSize)));
+		AbstractHttpSenderConnection connection = new TestHttpClientConnection(
+				new ByteArrayInputStream(compress(response)), responseHeaders);
+		assertThat(connection.hasResponse()).isTrue();
+		assertThat(StreamUtils.copyToString(connection.getResponseInputStream(), StandardCharsets.UTF_8))
+			.isEqualTo(StreamUtils.copyToString(response.getInputStream(), StandardCharsets.UTF_8));
 	}
 
-	@Test
-	void testSupportsStreamingWithChunkingDisabled() throws Exception {
-		testSupportsStreaming(false);
+	private byte[] compress(Resource resource) throws IOException {
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		try (InputStream in = resource.getInputStream(); GZIPOutputStream gzipOut = new GZIPOutputStream(out);) {
+			StreamUtils.copy(in, gzipOut);
+		}
+		return out.toByteArray();
+	}
+
+	private static final class TestHttpClientConnection extends AbstractHttpSenderConnection {
+
+		private final InputStream rawResponseInputStream;
+
+		private final MultiValueMap<String, String> responseHeaders;
+
+		public TestHttpClientConnection(InputStream rawResponseInputStream,
+				MultiValueMap<String, String> responseHeaders) {
+			this.rawResponseInputStream = rawResponseInputStream;
+			this.responseHeaders = responseHeaders;
+		}
+
+		@Override
+		protected int getResponseCode() {
+			return HttpTransportConstants.STATUS_OK;
+		}
+
+		@Override
+		protected String getResponseMessage() {
+			return "";
+		}
+
+		@Override
+		protected long getResponseContentLength() {
+			return Long.parseLong(
+					this.responseHeaders.getOrDefault(HttpTransportConstants.HEADER_CONTENT_LENGTH, List.of("-1"))
+						.get(0));
+		}
+
+		@Override
+		protected InputStream getRawResponseInputStream() {
+			return this.rawResponseInputStream;
+		}
+
+		@Override
+		protected OutputStream getRequestOutputStream() {
+			throw new UnsupportedOperationException();
+		}
+
+		@Override
+		public Iterator<String> getResponseHeaderNames() {
+			return this.responseHeaders.keySet().iterator();
+		}
+
+		@Override
+		public Iterator<String> getResponseHeaders(String name) {
+			return this.responseHeaders.getOrDefault(name, Collections.emptyList()).iterator();
+		}
+
+		@Override
+		public void addRequestHeader(String name, String value) {
+
+		}
+
+		@Override
+		public URI getUri() throws URISyntaxException {
+			return null;
+		}
+
 	}
 
 }