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

HttpMessageConverter.supports() is split into canRead/canWrite.

Browse Source 
HttpMessageConverter.write() now allows for a specific content type.
This commit is contained in:
Arjen Poutsma
2009-11-27 13:23:15 +00:00
parent 18c63f70c4
commit dc0613f487
22 changed files with 628 additions and 518 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
org.springframework.web/src/test/java/org/springframework/http/converter/BufferedImageHttpMessageConverterTests.java
View File

@@ -42,8 +42,15 @@ public class BufferedImageHttpMessageConverterTests {
}
@Test
public void supports() {
assertTrue("Image not supported", converter.supports(BufferedImage.class));
public void canRead() {
assertTrue("Image not supported", converter.canRead(BufferedImage.class, null));
assertTrue("Image not supported", converter.canRead(BufferedImage.class, new MediaType("image", "png")));
}
@Test
public void canWrite() {
assertTrue("Image not supported", converter.canWrite(BufferedImage.class, null));
assertTrue("Image not supported", converter.canWrite(BufferedImage.class, new MediaType("image", "png")));
}
@Test
@@ -60,11 +67,25 @@ public class BufferedImageHttpMessageConverterTests {
@Test
public void write() throws IOException {
Resource logo = new ClassPathResource("logo.jpg", BufferedImageHttpMessageConverterTests.class);
MediaType contentType = new MediaType("image", "png");
converter.setContentType(contentType);
BufferedImage body = ImageIO.read(logo.getFile());
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(body, outputMessage);
MediaType contentType = new MediaType("image", "png");
converter.write(body, contentType, outputMessage);
assertEquals("Invalid content type", contentType, outputMessage.getHeaders().getContentType());
assertTrue("Invalid size", outputMessage.getBodyAsBytes().length > 0);
BufferedImage result = ImageIO.read(new ByteArrayInputStream(outputMessage.getBodyAsBytes()));
assertEquals("Invalid height", 500, result.getHeight());
assertEquals("Invalid width", 750, result.getWidth());
}
@Test
public void writeDefaultContentType() throws IOException {
Resource logo = new ClassPathResource("logo.jpg", BufferedImageHttpMessageConverterTests.class);
MediaType contentType = new MediaType("image", "png");
converter.setDefaultContentType(contentType);
BufferedImage body = ImageIO.read(logo.getFile());
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(body, contentType, outputMessage);
assertEquals("Invalid content type", contentType, outputMessage.getHeaders().getContentType());
assertTrue("Invalid size", outputMessage.getBodyAsBytes().length > 0);
BufferedImage result = ImageIO.read(new ByteArrayInputStream(outputMessage.getBodyAsBytes()));

6
org.springframework.web/src/test/java/org/springframework/http/converter/ByteArrayHttpMessageConverterTests.java
View File

@@ -26,9 +26,7 @@ import org.springframework.http.MediaType;
import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
/**
* @author Arjen Poutsma
*/
/** @author Arjen Poutsma */
public class ByteArrayHttpMessageConverterTests {
private ByteArrayHttpMessageConverter converter;
@@ -51,7 +49,7 @@ public class ByteArrayHttpMessageConverterTests {
public void write() throws IOException {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
byte[] body = new byte[]{0x1, 0x2};
converter.write(body, outputMessage);
converter.write(body, null, outputMessage);
assertArrayEquals("Invalid result", body, outputMessage.getBodyAsBytes());
assertEquals("Invalid content-type", new MediaType("application", "octet-stream"),
outputMessage.getHeaders().getContentType());

6
org.springframework.web/src/test/java/org/springframework/http/converter/FormHttpMessageConverterTests.java
View File

@@ -30,9 +30,7 @@ import org.springframework.http.MockHttpOutputMessage;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
/**
* @author Arjen Poutsma
*/
/** @author Arjen Poutsma */
public class FormHttpMessageConverterTests {
private FormHttpMessageConverter converter;
@@ -67,7 +65,7 @@ public class FormHttpMessageConverterTests {
body.add("name 2", "value 2+2");
body.add("name 3", null);
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(body, outputMessage);
converter.write(body, null, outputMessage);
Charset iso88591 = Charset.forName("ISO-8859-1");
assertEquals("Invalid result", "name+1=value+1&name+2=value+2%2B1&name+2=value+2%2B2&name+3",
outputMessage.getBodyAsString(iso88591));

14
org.springframework.web/src/test/java/org/springframework/http/converter/StringHttpMessageConverterTests.java
View File

@@ -18,7 +18,6 @@ package org.springframework.http.converter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Collections;
import static org.junit.Assert.*;
import org.junit.Before;
@@ -28,9 +27,7 @@ import org.springframework.http.MediaType;
import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
/**
* @author Arjen Poutsma
*/
/** @author Arjen Poutsma */
public class StringHttpMessageConverterTests {
private StringHttpMessageConverter converter;
@@ -55,7 +52,7 @@ public class StringHttpMessageConverterTests {
Charset iso88591 = Charset.forName("ISO-8859-1");
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
String body = "H\u00e9llo W\u00f6rld";
converter.write(body, outputMessage);
converter.write(body, null, outputMessage);
assertEquals("Invalid result", body, outputMessage.getBodyAsString(iso88591));
assertEquals("Invalid content-type", new MediaType("text", "plain", iso88591),
outputMessage.getHeaders().getContentType());
@@ -67,13 +64,12 @@ public class StringHttpMessageConverterTests {
@Test
public void writeUTF8() throws IOException {
Charset utf8 = Charset.forName("UTF-8");
converter.setSupportedMediaTypes(Collections.singletonList(new MediaType("text", "plain", utf8)));
MediaType contentType = new MediaType("text", "plain", utf8);
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
String body = "H\u00e9llo W\u00f6rld";
converter.write(body, outputMessage);
converter.write(body, contentType, outputMessage);
assertEquals("Invalid result", body, outputMessage.getBodyAsString(utf8));
assertEquals("Invalid content-type", new MediaType("text", "plain", utf8),
outputMessage.getHeaders().getContentType());
assertEquals("Invalid content-type", contentType, outputMessage.getHeaders().getContentType());
assertEquals("Invalid content-length", body.getBytes(utf8).length,
outputMessage.getHeaders().getContentLength());
assertFalse("Invalid accept-charset", outputMessage.getHeaders().getAcceptCharset().isEmpty());

8
org.springframework.web/src/test/java/org/springframework/http/converter/json/MappingJacksonHttpMessageConverterTests.java
View File

@@ -39,7 +39,7 @@ public class MappingJacksonHttpMessageConverterTests {
public void setUp() {
converter = new MappingJacksonHttpMessageConverter<MyBean>();
}
@Test
public void supports() {
assertTrue(converter.supports(MyBean.class));
@@ -68,10 +68,10 @@ public class MappingJacksonHttpMessageConverterTests {
"{\"bytes\":\"AQI=\",\"array\":[\"Foo\",\"Bar\"],\"number\":42,\"string\":\"Foo\",\"bool\":true,\"fraction\":42.0}";
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
HashMap<String,Object> result = converter.read(HashMap.class, inputMessage);
HashMap<String, Object> result = converter.read(HashMap.class, inputMessage);
assertEquals("Foo", result.get("string"));
assertEquals(42, result.get("number"));
assertEquals(42D, (Double)result.get("fraction"), 0D);
assertEquals(42D, (Double) result.get("fraction"), 0D);
List array = new ArrayList();
array.add("Foo");
array.add("Bar");
@@ -90,7 +90,7 @@ public class MappingJacksonHttpMessageConverterTests {
body.setArray(new String[]{"Foo", "Bar"});
body.setBool(true);
body.setBytes(new byte[]{0x1, 0x2});
converter.write(body, outputMessage);
converter.write(body, null, outputMessage);
Charset utf8 = Charset.forName("UTF-8");
String result = outputMessage.getBodyAsString(utf8);
assertTrue(result.contains("\"string\":\"Foo\""));

2
org.springframework.web/src/test/java/org/springframework/http/converter/xml/MarshallingHttpMessageConverterTests.java
View File

@@ -68,7 +68,7 @@ public class MarshallingHttpMessageConverterTests {
marshaller.marshal(eq(body), isA(StreamResult.class));
replay(marshaller, unmarshaller);
converter.write(body, outputMessage);
converter.write(body, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "xml"),
outputMessage.getHeaders().getContentType());
verify(marshaller, unmarshaller);

2
org.springframework.web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java
View File

@@ -94,7 +94,7 @@ public class SourceHttpMessageConverterTests {
SourceHttpMessageConverter<Source> converter = new SourceHttpMessageConverter<Source>();
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(domSource, outputMessage);
converter.write(domSource, null, outputMessage);
assertXMLEqual("Invalid result", "<root>Hello World</root>",
outputMessage.getBodyAsString(Charset.forName("UTF-8")));
assertEquals("Invalid content-type", new MediaType("application", "xml"),

71
org.springframework.web/src/test/java/org/springframework/web/client/RestTemplateTests.java
View File

@@ -20,7 +20,6 @@ import java.io.IOException;
import java.net.URI;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -36,9 +35,7 @@ import org.springframework.http.MediaType;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.converter.ByteArrayHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter;
/** @author Arjen Poutsma */
@SuppressWarnings("unchecked")
@@ -65,18 +62,7 @@ public class RestTemplateTests {
converter = createMock(HttpMessageConverter.class);
template = new RestTemplate(requestFactory);
template.setErrorHandler(errorHandler);
template.setMessageConverters(new HttpMessageConverter<?>[]{converter});
}
@Test
public void getSupportedMessageBodyConverters() {
ByteArrayHttpMessageConverter byteArrayConverter = new ByteArrayHttpMessageConverter();
StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
template.setMessageConverters(new HttpMessageConverter<?>[]{byteArrayConverter, stringConverter});
List<HttpMessageConverter<String>> result = template.getSupportedMessageConverters(String.class);
assertEquals("Invalid amount of String converters", 1, result.size());
assertEquals("Invalid String converters", stringConverter, result.get(0));
template.setMessageConverters(Collections.<HttpMessageConverter<?>>singletonList(converter));
}
@Test
@@ -136,9 +122,9 @@ public class RestTemplateTests {
@Test
public void getForObject() throws Exception {
expect(converter.supports(String.class)).andReturn(true).times(2);
expect(converter.canRead(String.class, null)).andReturn(true);
MediaType textPlain = new MediaType("text", "plain");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain)).times(2);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.GET)).andReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
@@ -147,6 +133,7 @@ public class RestTemplateTests {
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
expect(response.getHeaders()).andReturn(responseHeaders);
expect(converter.canRead(String.class, textPlain)).andReturn(true);
String expected = "Hello World";
expect(converter.read(String.class, response)).andReturn(expected);
response.close();
@@ -160,28 +147,11 @@ public class RestTemplateTests {
verifyMocks();
}
@Test
public void getForObjectUnsupportedClass() throws Exception {
expect(converter.supports(String.class)).andReturn(false);
replayMocks();
try {
template.getForObject("http://example.com/{p}", String.class, "resource");
fail("IllegalArgumentException expected");
}
catch (IllegalArgumentException ex) {
// expected
}
verifyMocks();
}
@Test
public void getUnsupportedMediaType() throws Exception {
expect(converter.supports(String.class)).andReturn(true).times(2);
expect(converter.canRead(String.class, null)).andReturn(true);
MediaType supportedMediaType = new MediaType("foo", "bar");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(supportedMediaType)).times(2);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(supportedMediaType));
expect(requestFactory.createRequest(new URI("http://example.com/resource"), HttpMethod.GET)).andReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders);
@@ -191,6 +161,7 @@ public class RestTemplateTests {
MediaType contentType = new MediaType("bar", "baz");
responseHeaders.setContentType(contentType);
expect(response.getHeaders()).andReturn(responseHeaders);
expect(converter.canRead(String.class, contentType)).andReturn(false);
response.close();
replayMocks();
@@ -224,10 +195,10 @@ public class RestTemplateTests {
@Test
public void postForLocation() throws Exception {
expect(converter.supports(String.class)).andReturn(true).times(2);
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
String helloWorld = "Hello World";
converter.write(helloWorld, request);
expect(converter.canWrite(String.class, null)).andReturn(true);
converter.write(helloWorld, null, request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
@@ -246,10 +217,10 @@ public class RestTemplateTests {
@Test
public void postForLocationNoLocation() throws Exception {
expect(converter.supports(String.class)).andReturn(true).times(2);
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
String helloWorld = "Hello World";
converter.write(helloWorld, request);
expect(converter.canWrite(String.class, null)).andReturn(true);
converter.write(helloWorld, null, request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
@@ -284,21 +255,22 @@ public class RestTemplateTests {
@Test
public void postForObject() throws Exception {
expect(converter.supports(String.class)).andReturn(true).times(2);
expect(converter.supports(Integer.class)).andReturn(true).times(2);
MediaType textPlain = new MediaType("text", "plain");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain)).times(2);
expect(converter.canRead(Integer.class, null)).andReturn(true);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(this.request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(this.request.getHeaders()).andReturn(requestHeaders);
String request = "Hello World";
converter.write(request, this.request);
expect(converter.canWrite(String.class, null)).andReturn(true);
converter.write(request, null, this.request);
expect(this.request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
expect(response.getHeaders()).andReturn(responseHeaders);
Integer expected = 42;
expect(converter.canRead(Integer.class, textPlain)).andReturn(true);
expect(converter.read(Integer.class, response)).andReturn(expected);
response.close();
@@ -313,9 +285,9 @@ public class RestTemplateTests {
@Test
public void postForObjectNull() throws Exception {
expect(converter.supports(Integer.class)).andReturn(true).times(2);
MediaType textPlain = new MediaType("text", "plain");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain)).times(2);
expect(converter.canRead(Integer.class, null)).andReturn(true);
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(textPlain));
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.POST)).andReturn(request);
HttpHeaders requestHeaders = new HttpHeaders();
expect(request.getHeaders()).andReturn(requestHeaders).times(2);
@@ -324,6 +296,7 @@ public class RestTemplateTests {
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(textPlain);
expect(response.getHeaders()).andReturn(responseHeaders);
expect(converter.canRead(Integer.class, textPlain)).andReturn(true);
expect(converter.read(Integer.class, response)).andReturn(null);
response.close();
@@ -336,10 +309,10 @@ public class RestTemplateTests {
@Test
public void put() throws Exception {
expect(converter.supports(String.class)).andReturn(true).times(2);
expect(converter.canWrite(String.class, null)).andReturn(true);
expect(requestFactory.createRequest(new URI("http://example.com"), HttpMethod.PUT)).andReturn(request);
String helloWorld = "Hello World";
converter.write(helloWorld, request);
converter.write(helloWorld, null, request);
expect(request.execute()).andReturn(response);
expect(errorHandler.hasError(response)).andReturn(false);
response.close();
@@ -402,7 +375,7 @@ public class RestTemplateTests {
@Test
public void ioException() throws Exception {
expect(converter.supports(String.class)).andReturn(true).times(2);
expect(converter.canRead(String.class, null)).andReturn(true);
MediaType mediaType = new MediaType("foo", "bar");
expect(converter.getSupportedMediaTypes()).andReturn(Collections.singletonList(mediaType));
expect(requestFactory.createRequest(new URI("http://example.com/resource"), HttpMethod.GET)).andReturn(request);