diff --git a/spring-integration-http/src/main/java/org/springframework/integration/http/support/DefaultHttpHeaderMapper.java b/spring-integration-http/src/main/java/org/springframework/integration/http/support/DefaultHttpHeaderMapper.java index c7efc097c4..b0d8e4d2b0 100644 --- a/spring-integration-http/src/main/java/org/springframework/integration/http/support/DefaultHttpHeaderMapper.java +++ b/spring-integration-http/src/main/java/org/springframework/integration/http/support/DefaultHttpHeaderMapper.java @@ -388,7 +388,7 @@ public class DefaultHttpHeaderMapper implements HeaderMapper { : StringUtils.commaDelimitedListToStringArray((String) value); Set allowedMethods = new HashSet(); for (String next : values) { - allowedMethods.add(HttpMethod.valueOf(next)); + allowedMethods.add(HttpMethod.valueOf(next.trim())); } target.setAllow(allowedMethods); } diff --git a/spring-integration-http/src/test/java/org/springframework/integration/http/support/DefaultHttpHeaderMapperFromMessageInboundTests.java b/spring-integration-http/src/test/java/org/springframework/integration/http/support/DefaultHttpHeaderMapperFromMessageInboundTests.java new file mode 100644 index 0000000000..b86465cd01 --- /dev/null +++ b/spring-integration-http/src/test/java/org/springframework/integration/http/support/DefaultHttpHeaderMapperFromMessageInboundTests.java @@ -0,0 +1,246 @@ +/** + * + */ +package org.springframework.integration.http.support; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.assertTrue; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; + +import org.junit.Ignore; +import org.junit.Test; + +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; +import org.springframework.integration.MessageHeaders; +import org.springframework.integration.mapping.HeaderMapper; +import org.springframework.util.CollectionUtils; + +import com.sun.jndi.toolkit.url.Uri; + +/** + * @author ozhurakousky + * + */ +public class DefaultHttpHeaderMapperFromMessageInboundTests { + + // Allow tests + @Test(expected=IllegalArgumentException.class) + public void validateAllowWithWrongMethodName(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Allow", "bar"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + } + + @Test + public void validateAllowAsString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Allow", "GET"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(1, headers.getAllow().size()); + assertEquals(HttpMethod.GET, headers.getAllow().iterator().next()); + } + + @Test + public void validateAllowAsHttpMethod(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Allow", HttpMethod.GET); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(1, headers.getAllow().size()); + assertEquals(HttpMethod.GET, headers.getAllow().iterator().next()); + } + + @Test + public void validateAllowAsDelimitedString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Allow", "GET, POST"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAllow().size()); + assertTrue(headers.getAllow().contains(HttpMethod.GET)); + assertTrue(headers.getAllow().contains(HttpMethod.POST)); + } + + @Test + public void validateAllowAsStringArray(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Allow", new String[]{"GET", "POST"}); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAllow().size()); + assertTrue(headers.getAllow().contains(HttpMethod.GET)); + assertTrue(headers.getAllow().contains(HttpMethod.POST)); + } + + @Test + @Ignore // we may want to allow that for consistency + public void validateAllowAsHttpMethodArray(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Allow", new HttpMethod[]{HttpMethod.GET, HttpMethod.POST}); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAllow().size()); + assertTrue(headers.getAllow().contains(HttpMethod.GET)); + assertTrue(headers.getAllow().contains(HttpMethod.POST)); + } + + @Test + public void validateAllowAsCollectionOfString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Allow", CollectionUtils.arrayToList(new String[]{"GET", "POST"})); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAllow().size()); + assertTrue(headers.getAllow().contains(HttpMethod.GET)); + assertTrue(headers.getAllow().contains(HttpMethod.POST)); + } + + @Test + public void validateAllowAsCollectionOfHttpMethods(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Allow", CollectionUtils.arrayToList(new HttpMethod[]{HttpMethod.GET, HttpMethod.POST})); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAllow().size()); + assertTrue(headers.getAllow().contains(HttpMethod.GET)); + assertTrue(headers.getAllow().contains(HttpMethod.POST)); + } + + // Cache-Control tested as part of DefaultHttpHeaderMapperFromMessageOutboundTests + // Content-Length tested as part of DefaultHttpHeaderMapperFromMessageOutboundTests + // Content-Type tested as part of DefaultHttpHeaderMapperFromMessageOutboundTests + // Date tested as part of DefaultHttpHeaderMapperFromMessageOutboundTests + + // ETag tests + + @Test + public void validateETag(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("ETag", "1234"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals("1234", headers.getETag()); + } + + // Expires tests + + @Test + public void validateExpiresAsNumber() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Expires", 12345678); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getExpires()); + } + + @Test + public void validateExpiresAsString() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Expires", "12345678"); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getExpires()); + } + @Test + public void validateExpiresAsDate() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Expires", new Date(12345678)); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getExpires()); + } + + // Last-Modified tests + + @Test + public void validateLastModifiedAsNumber() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Last-Modified", 12345678); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getLastModified()); + } + + @Test + public void validateLastModifiedAsString() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Last-Modified", "12345678"); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getLastModified()); + } + @Test + public void validateLastModifiedAsDate() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Last-Modified", new Date(12345678)); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getLastModified()); + } + + // Location tests + + @Test + public void validateLocation() throws Exception{ + HeaderMapper mapper = DefaultHttpHeaderMapper.inboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Location", "http://foo.com"); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + assertEquals(new Uri("http://foo.com").toString(), headers.getLocation().toString()); + } + + // Pragma tested as part of DefaultHttpHeaderMapperFromMessageOutboundTests +} diff --git a/spring-integration-http/src/test/java/org/springframework/integration/http/support/DefaultHttpHeaderMapperFromMessageOutboundTests.java b/spring-integration-http/src/test/java/org/springframework/integration/http/support/DefaultHttpHeaderMapperFromMessageOutboundTests.java new file mode 100644 index 0000000000..453897f441 --- /dev/null +++ b/spring-integration-http/src/test/java/org/springframework/integration/http/support/DefaultHttpHeaderMapperFromMessageOutboundTests.java @@ -0,0 +1,443 @@ +/** + * + */ +package org.springframework.integration.http.support; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.assertTrue; + +import java.nio.charset.Charset; +import java.nio.charset.UnsupportedCharsetException; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; + +import org.junit.Ignore; +import org.junit.Test; + +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import org.springframework.integration.MessageHeaders; +import org.springframework.integration.mapping.HeaderMapper; +import org.springframework.util.CollectionUtils; + +/** + * @author ozhurakousky + * + */ +public class DefaultHttpHeaderMapperFromMessageOutboundTests { + + // ACCEPT tests + @Test(expected=IllegalArgumentException.class) + public void validateAcceptHeaderWithNoSlash(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept", "bar"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + } + + @Test + public void validateAcceptHeaderSingleString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept", "bar/foo"); + + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals("bar", headers.getAccept().get(0).getType()); + assertEquals("foo", headers.getAccept().get(0).getSubtype()); + } + + @Test + public void validateAcceptHeaderSingleMediaType(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept", new MediaType("bar", "foo")); + + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals("bar", headers.getAccept().get(0).getType()); + assertEquals("foo", headers.getAccept().get(0).getSubtype()); + } + + @Test + public void validateAcceptHeaderMultipleAsDelimitedString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept", "bar/foo, text/xml"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAccept().size()); + assertEquals("bar/foo", headers.getAccept().get(0).toString()); + assertEquals("text/xml", headers.getAccept().get(1).toString()); + } + + @Test + public void validateAcceptHeaderMultipleAsStringArray(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept", new String[]{"bar/foo", "text/xml"}); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAccept().size()); + assertEquals("bar/foo", headers.getAccept().get(0).toString()); + assertEquals("text/xml", headers.getAccept().get(1).toString()); + } + + @Test + public void validateAcceptHeaderMultipleAsStringCollection(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept", CollectionUtils.arrayToList(new String[]{"bar/foo", "text/xml"})); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAccept().size()); + assertEquals("bar/foo", headers.getAccept().get(0).toString()); + assertEquals("text/xml", headers.getAccept().get(1).toString()); + } + + @Test + public void validateAcceptHeaderMultipleAsMediatypeCollection(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept", + CollectionUtils.arrayToList(new MediaType[]{new MediaType("bar", "foo"), new MediaType("text", "xml")})); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAccept().size()); + assertEquals("bar/foo", headers.getAccept().get(0).toString()); + assertEquals("text/xml", headers.getAccept().get(1).toString()); + } + + // ACCEPT_CHARSET tests + + @Test(expected=UnsupportedCharsetException.class) + public void validateAcceptCharsetHeaderWithWrongCharset(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept-Charset", "foo"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + } + + @Test + public void validateAcceptCharsetHeaderSingleString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept-Charset", "UTF-8"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(1, headers.getAcceptCharset().size()); + assertEquals("UTF-8", headers.getAcceptCharset().get(0).displayName()); + } + + @Test + public void validateAcceptCharsetHeaderSingleCharset(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept-Charset", Charset.forName("UTF-8")); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(1, headers.getAcceptCharset().size()); + assertEquals("UTF-8", headers.getAcceptCharset().get(0).displayName()); + } + @Test + @Ignore // Since we allow coma delimited strings for ACCEPT, we may allow it here + public void validateAcceptCharsetHeaderMultipleAsDelimitedString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept-Charset", "UTF-8, ISO-8859-1"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAcceptCharset().size()); + // validate contains since the order is not enforsed + assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))); + assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))); + } + + @Test + @Ignore // we may want to support String[] as well + public void validateAcceptCharsetHeaderMultipleAsStringArray(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept-Charset", new String[]{"UTF-8", "ISO-8859-1"}); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAcceptCharset().size()); + // validate contains since the order is not enforsed + assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))); + assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))); + } + + @Test + public void validateAcceptCharsetHeaderMultipleAsCollectionOfStrings(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept-Charset", CollectionUtils.arrayToList(new String[]{"UTF-8", "ISO-8859-1"})); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAcceptCharset().size()); + // validate contains since the order is not enforsed + assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))); + assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))); + } + @Test + public void validateAcceptCharsetHeaderMultipleAsCollectionOfCharsets(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Accept-Charset", + CollectionUtils.arrayToList(new Charset[]{Charset.forName("UTF-8"), Charset.forName("ISO-8859-1")})); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(2, headers.getAcceptCharset().size()); + // validate contains since the order is not enforsed + assertTrue(headers.getAcceptCharset().contains(Charset.forName("UTF-8"))); + assertTrue(headers.getAcceptCharset().contains(Charset.forName("ISO-8859-1"))); + } + + // Cache-Control tests + + @Test + public void validateCacheControl(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Cache-Control", "foo"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals("foo", headers.getCacheControl()); + } + + // Content-Length tests + + @Test + public void validateContentLengthAsString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Content-Length", "1"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(1, headers.getContentLength()); + } + + @Test + public void validateContentLengthAsNumber(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Content-Length", 1); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals(1, headers.getContentLength()); + } + + @Test(expected=NumberFormatException.class) + public void validateContentLengthAsNonNumericString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Content-Length", "foo"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + } + + // Content-Type test + + @Test(expected=IllegalArgumentException.class) + public void validateContentTypeWrongValue(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Content-Type", "foo"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + } + + @Test + public void validateContentTypeAsString(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Content-Type", "text/html"); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals("text", headers.getContentType().getType()); + assertEquals("html", headers.getContentType().getSubtype()); + } + + @Test + public void validateContentTypeAsMediaType(){ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Content-Type", new MediaType("text", "html")); + HttpHeaders headers = new HttpHeaders(); + + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals("text", headers.getContentType().getType()); + assertEquals("html", headers.getContentType().getSubtype()); + } + + // Date test + + @Test + public void validateDateAsNumber() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Date", 12345678); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getDate()); + } + + @Test + public void validateDateAsString() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Date", "12345678"); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getDate()); + } + @Test + public void validateDateAsDate() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Date", new Date(12345678)); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getDate()); + } + + // If-Modified-Since tests + + @Test + public void validateIfModifiedSinceAsNumber() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("If-Modified-Since", 12345678); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getIfNotModifiedSince()); + } + + @Test + public void validateIfModifiedSinceAsString() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("If-Modified-Since", "12345678"); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getIfNotModifiedSince()); + } + @Test + public void validateIfModifiedSinceAsDate() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("If-Modified-Since", new Date(12345678)); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US); + + assertEquals(simpleDateFormat.parse("Thu, 01 Jan 1970 03:25:45 GMT").getTime(), headers.getIfNotModifiedSince()); + } + + // If-None-Match + + @Test + public void validateIfNoneMatch() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("If-None-Match", "1234567"); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + assertEquals(1, headers.getIfNoneMatch().size()); + assertEquals("1234567", headers.getIfNoneMatch().get(0)); + } + + @Test + public void validateIfNoneMatchAsDelimitedString() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("If-None-Match", "1234567, 123"); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + assertEquals(2, headers.getIfNoneMatch().size()); + assertEquals("1234567", headers.getIfNoneMatch().get(0)); + assertEquals("123", headers.getIfNoneMatch().get(1)); + } + + @Test + @Ignore // we may want to support it or throw exception + public void validateIfNoneMatchAsStringArray() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("If-None-Match", new String[]{"1234567", "123"}); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + assertEquals(2, headers.getIfNoneMatch().size()); + assertEquals("1234567", headers.getIfNoneMatch().get(0)); + assertEquals("123", headers.getIfNoneMatch().get(1)); + } + + @Test + public void validateIfNoneMatchAsStringCollection() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("If-None-Match", CollectionUtils.arrayToList(new String[]{"1234567", "123"})); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + + assertEquals(2, headers.getIfNoneMatch().size()); + assertEquals("1234567", headers.getIfNoneMatch().get(0)); + assertEquals("123", headers.getIfNoneMatch().get(1)); + } + + // Pragma tests + @Test + public void validatePragma() throws ParseException{ + HeaderMapper mapper = DefaultHttpHeaderMapper.outboundMapper(); + Map messageHeaders = new HashMap(); + messageHeaders.put("Pragma", "foo"); + HttpHeaders headers = new HttpHeaders(); + mapper.fromHeaders(new MessageHeaders(messageHeaders), headers); + assertEquals("foo", headers.getPragma()); + } +}