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

Migrate JUnit 4 assertions to AssertJ

Browse Source 
Migrate all existing JUnit 4 `assert...` based assertions to AssertJ
and add a checkstyle rule to ensure they don't return.

See gh-23022
This commit is contained in:
Phillip Webb
2019-05-23 15:51:39 -07:00
parent 95a9d46a87
commit 9d74da006c
1636 changed files with 37861 additions and 40390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
spring-web/src/test/java/org/springframework/http/ContentDispositionTests.java
View File

@@ -26,8 +26,8 @@ import org.junit.Test;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
/**
* Unit tests for {@link ContentDisposition}
@@ -40,45 +40,45 @@ public class ContentDispositionTests {
public void parse() {
ContentDisposition disposition = ContentDisposition
.parse("form-data; name=\"foo\"; filename=\"foo.txt\"; size=123");
assertEquals(ContentDisposition.builder("form-data")
.name("foo").filename("foo.txt").size(123L).build(), disposition);
assertThat(disposition).isEqualTo(ContentDisposition.builder("form-data")
.name("foo").filename("foo.txt").size(123L).build());
}
@Test
public void parseType() {
ContentDisposition disposition = ContentDisposition.parse("form-data");
assertEquals(ContentDisposition.builder("form-data").build(), disposition);
assertThat(disposition).isEqualTo(ContentDisposition.builder("form-data").build());
}
@Test
public void parseUnquotedFilename() {
ContentDisposition disposition = ContentDisposition
.parse("form-data; filename=unquoted");
assertEquals(ContentDisposition.builder("form-data").filename("unquoted").build(), disposition);
assertThat(disposition).isEqualTo(ContentDisposition.builder("form-data").filename("unquoted").build());
}
@Test // SPR-16091
public void parseFilenameWithSemicolon() {
ContentDisposition disposition = ContentDisposition
.parse("attachment; filename=\"filename with ; semicolon.txt\"");
assertEquals(ContentDisposition.builder("attachment")
.filename("filename with ; semicolon.txt").build(), disposition);
assertThat(disposition).isEqualTo(ContentDisposition.builder("attachment")
.filename("filename with ; semicolon.txt").build());
}
@Test
public void parseAndIgnoreEmptyParts() {
ContentDisposition disposition = ContentDisposition
.parse("form-data; name=\"foo\";; ; filename=\"foo.txt\"; size=123");
assertEquals(ContentDisposition.builder("form-data")
.name("foo").filename("foo.txt").size(123L).build(), disposition);
assertThat(disposition).isEqualTo(ContentDisposition.builder("form-data")
.name("foo").filename("foo.txt").size(123L).build());
}
@Test
public void parseEncodedFilename() {
ContentDisposition disposition = ContentDisposition
.parse("form-data; name=\"name\"; filename*=UTF-8''%E4%B8%AD%E6%96%87.txt");
assertEquals(ContentDisposition.builder("form-data").name("name")
.filename("中文.txt", StandardCharsets.UTF_8).build(), disposition);
assertThat(disposition).isEqualTo(ContentDisposition.builder("form-data").name("name")
.filename("中文.txt", StandardCharsets.UTF_8).build());
}
@Test
@@ -106,10 +106,10 @@ public class ContentDispositionTests {
"modification-date=\"Tue, 13 Feb 2007 10:15:30 -0500\"; " +
"read-date=\"Wed, 14 Feb 2007 10:15:30 -0500\"");
DateTimeFormatter formatter = DateTimeFormatter.RFC_1123_DATE_TIME;
assertEquals(ContentDisposition.builder("attachment")
assertThat(disposition).isEqualTo(ContentDisposition.builder("attachment")
.creationDate(ZonedDateTime.parse("Mon, 12 Feb 2007 10:15:30 -0500", formatter))
.modificationDate(ZonedDateTime.parse("Tue, 13 Feb 2007 10:15:30 -0500", formatter))
.readDate(ZonedDateTime.parse("Wed, 14 Feb 2007 10:15:30 -0500", formatter)).build(), disposition);
.readDate(ZonedDateTime.parse("Wed, 14 Feb 2007 10:15:30 -0500", formatter)).build());
}
@Test
@@ -118,23 +118,22 @@ public class ContentDispositionTests {
.parse("attachment; creation-date=\"-1\"; modification-date=\"-1\"; " +
"read-date=\"Wed, 14 Feb 2007 10:15:30 -0500\"");
DateTimeFormatter formatter = DateTimeFormatter.RFC_1123_DATE_TIME;
assertEquals(ContentDisposition.builder("attachment")
.readDate(ZonedDateTime.parse("Wed, 14 Feb 2007 10:15:30 -0500", formatter)).build(), disposition);
assertThat(disposition).isEqualTo(ContentDisposition.builder("attachment")
.readDate(ZonedDateTime.parse("Wed, 14 Feb 2007 10:15:30 -0500", formatter)).build());
}
@Test
public void headerValue() {
ContentDisposition disposition = ContentDisposition.builder("form-data")
.name("foo").filename("foo.txt").size(123L).build();
assertEquals("form-data; name=\"foo\"; filename=\"foo.txt\"; size=123", disposition.toString());
assertThat(disposition.toString()).isEqualTo("form-data; name=\"foo\"; filename=\"foo.txt\"; size=123");
}
@Test
public void headerValueWithEncodedFilename() {
ContentDisposition disposition = ContentDisposition.builder("form-data")
.name("name").filename("中文.txt", StandardCharsets.UTF_8).build();
assertEquals("form-data; name=\"name\"; filename*=UTF-8''%E4%B8%AD%E6%96%87.txt",
disposition.toString());
assertThat(disposition.toString()).isEqualTo("form-data; name=\"name\"; filename*=UTF-8''%E4%B8%AD%E6%96%87.txt");
}
@Test // SPR-14547
@@ -145,10 +144,10 @@ public class ContentDispositionTests {
String result = (String)ReflectionUtils.invokeMethod(encode, null, "test.txt",
StandardCharsets.US_ASCII);
assertEquals("test.txt", result);
assertThat(result).isEqualTo("test.txt");
result = (String)ReflectionUtils.invokeMethod(encode, null, "中文.txt", StandardCharsets.UTF_8);
assertEquals("UTF-8''%E4%B8%AD%E6%96%87.txt", result);
assertThat(result).isEqualTo("UTF-8''%E4%B8%AD%E6%96%87.txt");
}
@Test
@@ -167,10 +166,10 @@ public class ContentDispositionTests {
ReflectionUtils.makeAccessible(decode);
String result = (String)ReflectionUtils.invokeMethod(decode, null, "test.txt");
assertEquals("test.txt", result);
assertThat(result).isEqualTo("test.txt");
result = (String)ReflectionUtils.invokeMethod(decode, null, "UTF-8''%E4%B8%AD%E6%96%87.txt");
assertEquals("中文.txt", result);
assertThat(result).isEqualTo("中文.txt");
}
@Test

73
spring-web/src/test/java/org/springframework/http/HttpEntityTests.java
View File

@@ -23,10 +23,7 @@ import org.junit.Test;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -37,8 +34,8 @@ public class HttpEntityTests {
public void noHeaders() {
String body = "foo";
HttpEntity<String> entity = new HttpEntity<>(body);
assertSame(body, entity.getBody());
assertTrue(entity.getHeaders().isEmpty());
assertThat(entity.getBody()).isSameAs(body);
assertThat(entity.getHeaders().isEmpty()).isTrue();
}
@Test
@@ -47,9 +44,9 @@ public class HttpEntityTests {
headers.setContentType(MediaType.TEXT_PLAIN);
String body = "foo";
HttpEntity<String> entity = new HttpEntity<>(body, headers);
assertEquals(body, entity.getBody());
assertEquals(MediaType.TEXT_PLAIN, entity.getHeaders().getContentType());
assertEquals("text/plain", entity.getHeaders().getFirst("Content-Type"));
assertThat(entity.getBody()).isEqualTo(body);
assertThat(entity.getHeaders().getContentType()).isEqualTo(MediaType.TEXT_PLAIN);
assertThat(entity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
}
@Test
@@ -58,9 +55,9 @@ public class HttpEntityTests {
map.set("Content-Type", "text/plain");
String body = "foo";
HttpEntity<String> entity = new HttpEntity<>(body, map);
assertEquals(body, entity.getBody());
assertEquals(MediaType.TEXT_PLAIN, entity.getHeaders().getContentType());
assertEquals("text/plain", entity.getHeaders().getFirst("Content-Type"));
assertThat(entity.getBody()).isEqualTo(body);
assertThat(entity.getHeaders().getContentType()).isEqualTo(MediaType.TEXT_PLAIN);
assertThat(entity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
}
@Test
@@ -71,19 +68,19 @@ public class HttpEntityTests {
MultiValueMap<String, String> map2 = new LinkedMultiValueMap<>();
map2.set("Content-Type", "application/json");
assertTrue(new HttpEntity<>().equals(new HttpEntity<Object>()));
assertFalse(new HttpEntity<>(map1).equals(new HttpEntity<Object>()));
assertFalse(new HttpEntity<>().equals(new HttpEntity<Object>(map2)));
assertThat(new HttpEntity<>().equals(new HttpEntity<Object>())).isTrue();
assertThat(new HttpEntity<>(map1).equals(new HttpEntity<Object>())).isFalse();
assertThat(new HttpEntity<>().equals(new HttpEntity<Object>(map2))).isFalse();
assertTrue(new HttpEntity<>(map1).equals(new HttpEntity<Object>(map1)));
assertFalse(new HttpEntity<>(map1).equals(new HttpEntity<Object>(map2)));
assertThat(new HttpEntity<>(map1).equals(new HttpEntity<Object>(map1))).isTrue();
assertThat(new HttpEntity<>(map1).equals(new HttpEntity<Object>(map2))).isFalse();
assertTrue(new HttpEntity<String>(null, null).equals(new HttpEntity<String>(null, null)));
assertFalse(new HttpEntity<>("foo", null).equals(new HttpEntity<String>(null, null)));
assertFalse(new HttpEntity<String>(null, null).equals(new HttpEntity<>("bar", null)));
assertThat(new HttpEntity<String>(null, null).equals(new HttpEntity<String>(null, null))).isTrue();
assertThat(new HttpEntity<>("foo", null).equals(new HttpEntity<String>(null, null))).isFalse();
assertThat(new HttpEntity<String>(null, null).equals(new HttpEntity<>("bar", null))).isFalse();
assertTrue(new HttpEntity<>("foo", map1).equals(new HttpEntity<String>("foo", map1)));
assertFalse(new HttpEntity<>("foo", map1).equals(new HttpEntity<String>("bar", map1)));
assertThat(new HttpEntity<>("foo", map1).equals(new HttpEntity<String>("foo", map1))).isTrue();
assertThat(new HttpEntity<>("foo", map1).equals(new HttpEntity<String>("bar", map1))).isFalse();
}
@Test
@@ -95,15 +92,15 @@ public class HttpEntityTests {
ResponseEntity<String> responseEntity = new ResponseEntity<>(body, headers, HttpStatus.OK);
ResponseEntity<String> responseEntity2 = new ResponseEntity<>(body, headers, HttpStatus.OK);
assertEquals(body, responseEntity.getBody());
assertEquals(MediaType.TEXT_PLAIN, responseEntity.getHeaders().getContentType());
assertEquals("text/plain", responseEntity.getHeaders().getFirst("Content-Type"));
assertEquals("text/plain", responseEntity.getHeaders().getFirst("Content-Type"));
assertThat(responseEntity.getBody()).isEqualTo(body);
assertThat(responseEntity.getHeaders().getContentType()).isEqualTo(MediaType.TEXT_PLAIN);
assertThat(responseEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
assertThat(responseEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
assertFalse(httpEntity.equals(responseEntity));
assertFalse(responseEntity.equals(httpEntity));
assertTrue(responseEntity.equals(responseEntity2));
assertTrue(responseEntity2.equals(responseEntity));
assertThat(httpEntity.equals(responseEntity)).isFalse();
assertThat(responseEntity.equals(httpEntity)).isFalse();
assertThat(responseEntity.equals(responseEntity2)).isTrue();
assertThat(responseEntity2.equals(responseEntity)).isTrue();
}
@Test
@@ -115,15 +112,15 @@ public class HttpEntityTests {
RequestEntity<String> requestEntity = new RequestEntity<>(body, headers, HttpMethod.GET, new URI("/"));
RequestEntity<String> requestEntity2 = new RequestEntity<>(body, headers, HttpMethod.GET, new URI("/"));
assertEquals(body, requestEntity.getBody());
assertEquals(MediaType.TEXT_PLAIN, requestEntity.getHeaders().getContentType());
assertEquals("text/plain", requestEntity.getHeaders().getFirst("Content-Type"));
assertEquals("text/plain", requestEntity.getHeaders().getFirst("Content-Type"));
assertThat(requestEntity.getBody()).isEqualTo(body);
assertThat(requestEntity.getHeaders().getContentType()).isEqualTo(MediaType.TEXT_PLAIN);
assertThat(requestEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
assertThat(requestEntity.getHeaders().getFirst("Content-Type")).isEqualTo("text/plain");
assertFalse(httpEntity.equals(requestEntity));
assertFalse(requestEntity.equals(httpEntity));
assertTrue(requestEntity.equals(requestEntity2));
assertTrue(requestEntity2.equals(requestEntity));
assertThat(httpEntity.equals(requestEntity)).isFalse();
assertThat(requestEntity.equals(httpEntity)).isFalse();
assertThat(requestEntity.equals(requestEntity2)).isTrue();
assertThat(requestEntity2.equals(requestEntity)).isTrue();
}
}

210
spring-web/src/test/java/org/springframework/http/HttpHeadersTests.java
View File

@@ -38,11 +38,6 @@ import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for {@link org.springframework.http.HttpHeaders}.
@@ -88,8 +83,8 @@ public class HttpHeadersTests {
mediaTypes.add(mediaType1);
mediaTypes.add(mediaType2);
headers.setAccept(mediaTypes);
assertEquals("Invalid Accept header", mediaTypes, headers.getAccept());
assertEquals("Invalid Accept header", "text/html, text/plain", headers.getFirst("Accept"));
assertThat(headers.getAccept()).as("Invalid Accept header").isEqualTo(mediaTypes);
assertThat(headers.getFirst("Accept")).as("Invalid Accept header").isEqualTo("text/html, text/plain");
}
@Test // SPR-9655
@@ -97,7 +92,7 @@ public class HttpHeadersTests {
headers.add("Accept", "text/html");
headers.add("Accept", "text/plain");
List<MediaType> expected = Arrays.asList(new MediaType("text", "html"), new MediaType("text", "plain"));
assertEquals("Invalid Accept header", expected, headers.getAccept());
assertThat(headers.getAccept()).as("Invalid Accept header").isEqualTo(expected);
}
@Test // SPR-14506
@@ -106,7 +101,7 @@ public class HttpHeadersTests {
headers.add("Accept", "text/plain,text/csv");
List<MediaType> expected = Arrays.asList(new MediaType("text", "html"), new MediaType("text", "pdf"),
new MediaType("text", "plain"), new MediaType("text", "csv"));
assertEquals("Invalid Accept header", expected, headers.getAccept());
assertThat(headers.getAccept()).as("Invalid Accept header").isEqualTo(expected);
}
@Test
@@ -117,79 +112,78 @@ public class HttpHeadersTests {
charsets.add(charset1);
charsets.add(charset2);
headers.setAcceptCharset(charsets);
assertEquals("Invalid Accept header", charsets, headers.getAcceptCharset());
assertEquals("Invalid Accept header", "utf-8, iso-8859-1", headers.getFirst("Accept-Charset"));
assertThat(headers.getAcceptCharset()).as("Invalid Accept header").isEqualTo(charsets);
assertThat(headers.getFirst("Accept-Charset")).as("Invalid Accept header").isEqualTo("utf-8, iso-8859-1");
}
@Test
public void acceptCharsetWildcard() {
headers.set("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
assertEquals("Invalid Accept header", Arrays.asList(StandardCharsets.ISO_8859_1, StandardCharsets.UTF_8),
headers.getAcceptCharset());
assertThat(headers.getAcceptCharset()).as("Invalid Accept header").isEqualTo(Arrays.asList(StandardCharsets.ISO_8859_1, StandardCharsets.UTF_8));
}
@Test
public void allow() {
EnumSet<HttpMethod> methods = EnumSet.of(HttpMethod.GET, HttpMethod.POST);
headers.setAllow(methods);
assertEquals("Invalid Allow header", methods, headers.getAllow());
assertEquals("Invalid Allow header", "GET,POST", headers.getFirst("Allow"));
assertThat(headers.getAllow()).as("Invalid Allow header").isEqualTo(methods);
assertThat(headers.getFirst("Allow")).as("Invalid Allow header").isEqualTo("GET,POST");
}
@Test
public void contentLength() {
long length = 42L;
headers.setContentLength(length);
assertEquals("Invalid Content-Length header", length, headers.getContentLength());
assertEquals("Invalid Content-Length header", "42", headers.getFirst("Content-Length"));
assertThat(headers.getContentLength()).as("Invalid Content-Length header").isEqualTo(length);
assertThat(headers.getFirst("Content-Length")).as("Invalid Content-Length header").isEqualTo("42");
}
@Test
public void contentType() {
MediaType contentType = new MediaType("text", "html", StandardCharsets.UTF_8);
headers.setContentType(contentType);
assertEquals("Invalid Content-Type header", contentType, headers.getContentType());
assertEquals("Invalid Content-Type header", "text/html;charset=UTF-8", headers.getFirst("Content-Type"));
assertThat(headers.getContentType()).as("Invalid Content-Type header").isEqualTo(contentType);
assertThat(headers.getFirst("Content-Type")).as("Invalid Content-Type header").isEqualTo("text/html;charset=UTF-8");
}
@Test
public void location() throws URISyntaxException {
URI location = new URI("https://www.example.com/hotels");
headers.setLocation(location);
assertEquals("Invalid Location header", location, headers.getLocation());
assertEquals("Invalid Location header", "https://www.example.com/hotels", headers.getFirst("Location"));
assertThat(headers.getLocation()).as("Invalid Location header").isEqualTo(location);
assertThat(headers.getFirst("Location")).as("Invalid Location header").isEqualTo("https://www.example.com/hotels");
}
@Test
public void eTag() {
String eTag = "\"v2.6\"";
headers.setETag(eTag);
assertEquals("Invalid ETag header", eTag, headers.getETag());
assertEquals("Invalid ETag header", "\"v2.6\"", headers.getFirst("ETag"));
assertThat(headers.getETag()).as("Invalid ETag header").isEqualTo(eTag);
assertThat(headers.getFirst("ETag")).as("Invalid ETag header").isEqualTo("\"v2.6\"");
}
@Test
public void host() {
InetSocketAddress host = InetSocketAddress.createUnresolved("localhost", 8080);
headers.setHost(host);
assertEquals("Invalid Host header", host, headers.getHost());
assertEquals("Invalid Host header", "localhost:8080", headers.getFirst("Host"));
assertThat(headers.getHost()).as("Invalid Host header").isEqualTo(host);
assertThat(headers.getFirst("Host")).as("Invalid Host header").isEqualTo("localhost:8080");
}
@Test
public void hostNoPort() {
InetSocketAddress host = InetSocketAddress.createUnresolved("localhost", 0);
headers.setHost(host);
assertEquals("Invalid Host header", host, headers.getHost());
assertEquals("Invalid Host header", "localhost", headers.getFirst("Host"));
assertThat(headers.getHost()).as("Invalid Host header").isEqualTo(host);
assertThat(headers.getFirst("Host")).as("Invalid Host header").isEqualTo("localhost");
}
@Test
public void ipv6Host() {
InetSocketAddress host = InetSocketAddress.createUnresolved("[::1]", 0);
headers.setHost(host);
assertEquals("Invalid Host header", host, headers.getHost());
assertEquals("Invalid Host header", "[::1]", headers.getFirst("Host"));
assertThat(headers.getHost()).as("Invalid Host header").isEqualTo(host);
assertThat(headers.getFirst("Host")).as("Invalid Host header").isEqualTo("[::1]");
}
@Test
@@ -202,8 +196,8 @@ public class HttpHeadersTests {
public void ifMatch() {
String ifMatch = "\"v2.6\"";
headers.setIfMatch(ifMatch);
assertEquals("Invalid If-Match header", ifMatch, headers.getIfMatch().get(0));
assertEquals("Invalid If-Match header", "\"v2.6\"", headers.getFirst("If-Match"));
assertThat(headers.getIfMatch().get(0)).as("Invalid If-Match header").isEqualTo(ifMatch);
assertThat(headers.getFirst("If-Match")).as("Invalid If-Match header").isEqualTo("\"v2.6\"");
}
@Test
@@ -216,8 +210,8 @@ public class HttpHeadersTests {
public void ifMatchMultipleHeaders() {
headers.add(HttpHeaders.IF_MATCH, "\"v2,0\"");
headers.add(HttpHeaders.IF_MATCH, "W/\"v2,1\", \"v2,2\"");
assertEquals("Invalid If-Match header", "\"v2,0\"", headers.get(HttpHeaders.IF_MATCH).get(0));
assertEquals("Invalid If-Match header", "W/\"v2,1\", \"v2,2\"", headers.get(HttpHeaders.IF_MATCH).get(1));
assertThat(headers.get(HttpHeaders.IF_MATCH).get(0)).as("Invalid If-Match header").isEqualTo("\"v2,0\"");
assertThat(headers.get(HttpHeaders.IF_MATCH).get(1)).as("Invalid If-Match header").isEqualTo("W/\"v2,1\", \"v2,2\"");
assertThat(headers.getIfMatch()).contains("\"v2,0\"", "W/\"v2,1\"", "\"v2,2\"");
}
@@ -225,16 +219,16 @@ public class HttpHeadersTests {
public void ifNoneMatch() {
String ifNoneMatch = "\"v2.6\"";
headers.setIfNoneMatch(ifNoneMatch);
assertEquals("Invalid If-None-Match header", ifNoneMatch, headers.getIfNoneMatch().get(0));
assertEquals("Invalid If-None-Match header", "\"v2.6\"", headers.getFirst("If-None-Match"));
assertThat(headers.getIfNoneMatch().get(0)).as("Invalid If-None-Match header").isEqualTo(ifNoneMatch);
assertThat(headers.getFirst("If-None-Match")).as("Invalid If-None-Match header").isEqualTo("\"v2.6\"");
}
@Test
public void ifNoneMatchWildCard() {
String ifNoneMatch = "*";
headers.setIfNoneMatch(ifNoneMatch);
assertEquals("Invalid If-None-Match header", ifNoneMatch, headers.getIfNoneMatch().get(0));
assertEquals("Invalid If-None-Match header", "*", headers.getFirst("If-None-Match"));
assertThat(headers.getIfNoneMatch().get(0)).as("Invalid If-None-Match header").isEqualTo(ifNoneMatch);
assertThat(headers.getFirst("If-None-Match")).as("Invalid If-None-Match header").isEqualTo("*");
}
@Test
@@ -246,7 +240,7 @@ public class HttpHeadersTests {
ifNoneMatchList.add(ifNoneMatch2);
headers.setIfNoneMatch(ifNoneMatchList);
assertThat(headers.getIfNoneMatch()).contains("\"v2.6\"", "\"v2.7\"", "\"v2.8\"");
assertEquals("Invalid If-None-Match header", "\"v2.6\", \"v2.7\", \"v2.8\"", headers.getFirst("If-None-Match"));
assertThat(headers.getFirst("If-None-Match")).as("Invalid If-None-Match header").isEqualTo("\"v2.6\", \"v2.7\", \"v2.8\"");
}
@Test
@@ -255,12 +249,12 @@ public class HttpHeadersTests {
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setDate(date);
assertEquals("Invalid Date header", date, headers.getDate());
assertEquals("Invalid Date header", "Thu, 18 Dec 2008 10:20:00 GMT", headers.getFirst("date"));
assertThat(headers.getDate()).as("Invalid Date header").isEqualTo(date);
assertThat(headers.getFirst("date")).as("Invalid Date header").isEqualTo("Thu, 18 Dec 2008 10:20:00 GMT");
// RFC 850
headers.set("Date", "Thu, 18 Dec 2008 10:20:00 GMT");
assertEquals("Invalid Date header", date, headers.getDate());
assertThat(headers.getDate()).as("Invalid Date header").isEqualTo(date);
}
@Test
@@ -278,8 +272,8 @@ public class HttpHeadersTests {
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setDate(date);
assertEquals("Invalid Date header", "Thu, 18 Dec 2008 10:20:00 GMT", headers.getFirst("date"));
assertEquals("Invalid Date header", date, headers.getDate());
assertThat(headers.getFirst("date")).as("Invalid Date header").isEqualTo("Thu, 18 Dec 2008 10:20:00 GMT");
assertThat(headers.getDate()).as("Invalid Date header").isEqualTo(date);
}
finally {
Locale.setDefault(defaultLocale);
@@ -292,9 +286,8 @@ public class HttpHeadersTests {
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setLastModified(date);
assertEquals("Invalid Last-Modified header", date, headers.getLastModified());
assertEquals("Invalid Last-Modified header", "Thu, 18 Dec 2008 10:20:00 GMT",
headers.getFirst("last-modified"));
assertThat(headers.getLastModified()).as("Invalid Last-Modified header").isEqualTo(date);
assertThat(headers.getFirst("last-modified")).as("Invalid Last-Modified header").isEqualTo("Thu, 18 Dec 2008 10:20:00 GMT");
}
@Test
@@ -303,22 +296,22 @@ public class HttpHeadersTests {
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setExpires(date);
assertEquals("Invalid Expires header", date, headers.getExpires());
assertEquals("Invalid Expires header", "Thu, 18 Dec 2008 10:20:00 GMT", headers.getFirst("expires"));
assertThat(headers.getExpires()).as("Invalid Expires header").isEqualTo(date);
assertThat(headers.getFirst("expires")).as("Invalid Expires header").isEqualTo("Thu, 18 Dec 2008 10:20:00 GMT");
}
@Test
public void expiresZonedDateTime() {
ZonedDateTime zonedDateTime = ZonedDateTime.of(2008, 12, 18, 10, 20, 0, 0, ZoneId.of("GMT"));
headers.setExpires(zonedDateTime);
assertEquals("Invalid Expires header", zonedDateTime.toInstant().toEpochMilli(), headers.getExpires());
assertEquals("Invalid Expires header", "Thu, 18 Dec 2008 10:20:00 GMT", headers.getFirst("expires"));
assertThat(headers.getExpires()).as("Invalid Expires header").isEqualTo(zonedDateTime.toInstant().toEpochMilli());
assertThat(headers.getFirst("expires")).as("Invalid Expires header").isEqualTo("Thu, 18 Dec 2008 10:20:00 GMT");
}
@Test // SPR-10648 (example is from INT-3063)
public void expiresInvalidDate() {
headers.set("Expires", "-1");
assertEquals(-1, headers.getExpires());
assertThat(headers.getExpires()).isEqualTo(-1);
}
@Test
@@ -327,68 +320,67 @@ public class HttpHeadersTests {
calendar.setTimeZone(TimeZone.getTimeZone("CET"));
long date = calendar.getTimeInMillis();
headers.setIfModifiedSince(date);
assertEquals("Invalid If-Modified-Since header", date, headers.getIfModifiedSince());
assertEquals("Invalid If-Modified-Since header", "Thu, 18 Dec 2008 10:20:00 GMT",
headers.getFirst("if-modified-since"));
assertThat(headers.getIfModifiedSince()).as("Invalid If-Modified-Since header").isEqualTo(date);
assertThat(headers.getFirst("if-modified-since")).as("Invalid If-Modified-Since header").isEqualTo("Thu, 18 Dec 2008 10:20:00 GMT");
}
@Test // SPR-14144
public void invalidIfModifiedSinceHeader() {
headers.set(HttpHeaders.IF_MODIFIED_SINCE, "0");
assertEquals(-1, headers.getIfModifiedSince());
assertThat(headers.getIfModifiedSince()).isEqualTo(-1);
headers.set(HttpHeaders.IF_MODIFIED_SINCE, "-1");
assertEquals(-1, headers.getIfModifiedSince());
assertThat(headers.getIfModifiedSince()).isEqualTo(-1);
headers.set(HttpHeaders.IF_MODIFIED_SINCE, "XXX");
assertEquals(-1, headers.getIfModifiedSince());
assertThat(headers.getIfModifiedSince()).isEqualTo(-1);
}
@Test
public void pragma() {
String pragma = "no-cache";
headers.setPragma(pragma);
assertEquals("Invalid Pragma header", pragma, headers.getPragma());
assertEquals("Invalid Pragma header", "no-cache", headers.getFirst("pragma"));
assertThat(headers.getPragma()).as("Invalid Pragma header").isEqualTo(pragma);
assertThat(headers.getFirst("pragma")).as("Invalid Pragma header").isEqualTo("no-cache");
}
@Test
public void cacheControl() {
headers.setCacheControl("no-cache");
assertEquals("Invalid Cache-Control header", "no-cache", headers.getCacheControl());
assertEquals("Invalid Cache-Control header", "no-cache", headers.getFirst("cache-control"));
assertThat(headers.getCacheControl()).as("Invalid Cache-Control header").isEqualTo("no-cache");
assertThat(headers.getFirst("cache-control")).as("Invalid Cache-Control header").isEqualTo("no-cache");
}
@Test
public void cacheControlBuilder() {
headers.setCacheControl(CacheControl.noCache());
assertEquals("Invalid Cache-Control header", "no-cache", headers.getCacheControl());
assertEquals("Invalid Cache-Control header", "no-cache", headers.getFirst("cache-control"));
assertThat(headers.getCacheControl()).as("Invalid Cache-Control header").isEqualTo("no-cache");
assertThat(headers.getFirst("cache-control")).as("Invalid Cache-Control header").isEqualTo("no-cache");
}
@Test
public void cacheControlEmpty() {
headers.setCacheControl(CacheControl.empty());
assertNull("Invalid Cache-Control header", headers.getCacheControl());
assertNull("Invalid Cache-Control header", headers.getFirst("cache-control"));
assertThat(headers.getCacheControl()).as("Invalid Cache-Control header").isNull();
assertThat(headers.getFirst("cache-control")).as("Invalid Cache-Control header").isNull();
}
@Test
public void cacheControlAllValues() {
headers.add(HttpHeaders.CACHE_CONTROL, "max-age=1000, public");
headers.add(HttpHeaders.CACHE_CONTROL, "s-maxage=1000");
assertEquals("max-age=1000, public, s-maxage=1000", headers.getCacheControl());
assertThat(headers.getCacheControl()).isEqualTo("max-age=1000, public, s-maxage=1000");
}
@Test
public void contentDisposition() {
ContentDisposition disposition = headers.getContentDisposition();
assertNotNull(disposition);
assertEquals("Invalid Content-Disposition header", ContentDisposition.empty(), headers.getContentDisposition());
assertThat(disposition).isNotNull();
assertThat(headers.getContentDisposition()).as("Invalid Content-Disposition header").isEqualTo(ContentDisposition.empty());
disposition = ContentDisposition.builder("attachment").name("foo").filename("foo.txt").size(123L).build();
headers.setContentDisposition(disposition);
assertEquals("Invalid Content-Disposition header", disposition, headers.getContentDisposition());
assertThat(headers.getContentDisposition()).as("Invalid Content-Disposition header").isEqualTo(disposition);
}
@Test // SPR-11917
@@ -399,11 +391,11 @@ public class HttpHeadersTests {
@Test
public void accessControlAllowCredentials() {
assertFalse(headers.getAccessControlAllowCredentials());
assertThat(headers.getAccessControlAllowCredentials()).isFalse();
headers.setAccessControlAllowCredentials(false);
assertFalse(headers.getAccessControlAllowCredentials());
assertThat(headers.getAccessControlAllowCredentials()).isFalse();
headers.setAccessControlAllowCredentials(true);
assertTrue(headers.getAccessControlAllowCredentials());
assertThat(headers.getAccessControlAllowCredentials()).isTrue();
}
@Test
@@ -412,7 +404,7 @@ public class HttpHeadersTests {
assertThat(allowedHeaders).isEmpty();
headers.setAccessControlAllowHeaders(Arrays.asList("header1", "header2"));
allowedHeaders = headers.getAccessControlAllowHeaders();
assertEquals(allowedHeaders, Arrays.asList("header1", "header2"));
assertThat(Arrays.asList("header1", "header2")).isEqualTo(allowedHeaders);
}
@Test
@@ -422,7 +414,7 @@ public class HttpHeadersTests {
headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "header1, header2");
headers.add(HttpHeaders.ACCESS_CONTROL_ALLOW_HEADERS, "header3");
allowedHeaders = headers.getAccessControlAllowHeaders();
assertEquals(Arrays.asList("header1", "header2", "header3"), allowedHeaders);
assertThat(allowedHeaders).isEqualTo(Arrays.asList("header1", "header2", "header3"));
}
@Test
@@ -431,14 +423,14 @@ public class HttpHeadersTests {
assertThat(allowedMethods).isEmpty();
headers.setAccessControlAllowMethods(Arrays.asList(HttpMethod.GET, HttpMethod.POST));
allowedMethods = headers.getAccessControlAllowMethods();
assertEquals(allowedMethods, Arrays.asList(HttpMethod.GET, HttpMethod.POST));
assertThat(Arrays.asList(HttpMethod.GET, HttpMethod.POST)).isEqualTo(allowedMethods);
}
@Test
public void accessControlAllowOrigin() {
assertNull(headers.getAccessControlAllowOrigin());
assertThat(headers.getAccessControlAllowOrigin()).isNull();
headers.setAccessControlAllowOrigin("*");
assertEquals("*", headers.getAccessControlAllowOrigin());
assertThat(headers.getAccessControlAllowOrigin()).isEqualTo("*");
}
@Test
@@ -447,14 +439,14 @@ public class HttpHeadersTests {
assertThat(exposedHeaders).isEmpty();
headers.setAccessControlExposeHeaders(Arrays.asList("header1", "header2"));
exposedHeaders = headers.getAccessControlExposeHeaders();
assertEquals(exposedHeaders, Arrays.asList("header1", "header2"));
assertThat(Arrays.asList("header1", "header2")).isEqualTo(exposedHeaders);
}
@Test
public void accessControlMaxAge() {
assertEquals(-1, headers.getAccessControlMaxAge());
assertThat(headers.getAccessControlMaxAge()).isEqualTo(-1);
headers.setAccessControlMaxAge(3600);
assertEquals(3600, headers.getAccessControlMaxAge());
assertThat(headers.getAccessControlMaxAge()).isEqualTo(3600);
}
@Test
@@ -463,21 +455,21 @@ public class HttpHeadersTests {
assertThat(requestHeaders).isEmpty();
headers.setAccessControlRequestHeaders(Arrays.asList("header1", "header2"));
requestHeaders = headers.getAccessControlRequestHeaders();
assertEquals(requestHeaders, Arrays.asList("header1", "header2"));
assertThat(Arrays.asList("header1", "header2")).isEqualTo(requestHeaders);
}
@Test
public void accessControlRequestMethod() {
assertNull(headers.getAccessControlRequestMethod());
assertThat(headers.getAccessControlRequestMethod()).isNull();
headers.setAccessControlRequestMethod(HttpMethod.POST);
assertEquals(HttpMethod.POST, headers.getAccessControlRequestMethod());
assertThat(headers.getAccessControlRequestMethod()).isEqualTo(HttpMethod.POST);
}
@Test
public void acceptLanguage() {
String headerValue = "fr-ch, fr;q=0.9, en-*;q=0.8, de;q=0.7, *;q=0.5";
headers.setAcceptLanguage(Locale.LanguageRange.parse(headerValue));
assertEquals(headerValue, headers.getFirst(HttpHeaders.ACCEPT_LANGUAGE));
assertThat(headers.getFirst(HttpHeaders.ACCEPT_LANGUAGE)).isEqualTo(headerValue);
List<Locale.LanguageRange> expectedRanges = Arrays.asList(
new Locale.LanguageRange("fr-ch"),
@@ -486,30 +478,30 @@ public class HttpHeadersTests {
new Locale.LanguageRange("de", 0.7),
new Locale.LanguageRange("*", 0.5)
);
assertEquals(expectedRanges, headers.getAcceptLanguage());
assertEquals(Locale.forLanguageTag("fr-ch"), headers.getAcceptLanguageAsLocales().get(0));
assertThat(headers.getAcceptLanguage()).isEqualTo(expectedRanges);
assertThat(headers.getAcceptLanguageAsLocales().get(0)).isEqualTo(Locale.forLanguageTag("fr-ch"));
headers.setAcceptLanguageAsLocales(Collections.singletonList(Locale.FRANCE));
assertEquals(Locale.FRANCE, headers.getAcceptLanguageAsLocales().get(0));
assertThat(headers.getAcceptLanguageAsLocales().get(0)).isEqualTo(Locale.FRANCE);
}
@Test // SPR-15603
public void acceptLanguageWithEmptyValue() throws Exception {
this.headers.set(HttpHeaders.ACCEPT_LANGUAGE, "");
assertEquals(Collections.emptyList(), this.headers.getAcceptLanguageAsLocales());
assertThat(this.headers.getAcceptLanguageAsLocales()).isEqualTo(Collections.emptyList());
}
@Test
public void contentLanguage() {
headers.setContentLanguage(Locale.FRANCE);
assertEquals(Locale.FRANCE, headers.getContentLanguage());
assertEquals("fr-FR", headers.getFirst(HttpHeaders.CONTENT_LANGUAGE));
assertThat(headers.getContentLanguage()).isEqualTo(Locale.FRANCE);
assertThat(headers.getFirst(HttpHeaders.CONTENT_LANGUAGE)).isEqualTo("fr-FR");
}
@Test
public void contentLanguageSerialized() {
headers.set(HttpHeaders.CONTENT_LANGUAGE, "de, en_CA");
assertEquals("Expected one (first) locale", Locale.GERMAN, headers.getContentLanguage());
assertThat(headers.getContentLanguage()).as("Expected one (first) locale").isEqualTo(Locale.GERMAN);
}
@Test
@@ -529,24 +521,24 @@ public class HttpHeadersTests {
ZonedDateTime date = ZonedDateTime.of(2017, 6, 2, 2, 22, 0, 0, ZoneId.of("GMT"));
headers.setZonedDateTime(HttpHeaders.DATE, date);
assertThat(headers.getFirst(HttpHeaders.DATE)).isEqualTo("Fri, 02 Jun 2017 02:22:00 GMT");
assertTrue(headers.getFirstZonedDateTime(HttpHeaders.DATE).isEqual(date));
assertThat(headers.getFirstZonedDateTime(HttpHeaders.DATE).isEqual(date)).isTrue();
headers.clear();
headers.add(HttpHeaders.DATE, "Fri, 02 Jun 2017 02:22:00 GMT");
headers.add(HttpHeaders.DATE, "Sat, 18 Dec 2010 10:20:00 GMT");
assertTrue(headers.getFirstZonedDateTime(HttpHeaders.DATE).isEqual(date));
assertEquals(Arrays.asList("Fri, 02 Jun 2017 02:22:00 GMT",
"Sat, 18 Dec 2010 10:20:00 GMT"), headers.get(HttpHeaders.DATE));
assertThat(headers.getFirstZonedDateTime(HttpHeaders.DATE).isEqual(date)).isTrue();
assertThat(headers.get(HttpHeaders.DATE)).isEqualTo(Arrays.asList("Fri, 02 Jun 2017 02:22:00 GMT",
"Sat, 18 Dec 2010 10:20:00 GMT"));
// obsolete RFC 850 format
headers.clear();
headers.set(HttpHeaders.DATE, "Friday, 02-Jun-17 02:22:00 GMT");
assertTrue(headers.getFirstZonedDateTime(HttpHeaders.DATE).isEqual(date));
assertThat(headers.getFirstZonedDateTime(HttpHeaders.DATE).isEqual(date)).isTrue();
// ANSI C's asctime() format
headers.clear();
headers.set(HttpHeaders.DATE, "Fri Jun 02 02:22:00 2017");
assertTrue(headers.getFirstZonedDateTime(HttpHeaders.DATE).isEqual(date));
assertThat(headers.getFirstZonedDateTime(HttpHeaders.DATE).isEqual(date)).isTrue();
}
@Test
@@ -555,10 +547,10 @@ public class HttpHeadersTests {
String password = "bar";
headers.setBasicAuth(username, password);
String authorization = headers.getFirst(HttpHeaders.AUTHORIZATION);
assertNotNull(authorization);
assertTrue(authorization.startsWith("Basic "));
assertThat(authorization).isNotNull();
assertThat(authorization.startsWith("Basic ")).isTrue();
byte[] result = Base64.getDecoder().decode(authorization.substring(6).getBytes(StandardCharsets.ISO_8859_1));
assertEquals("foo:bar", new String(result, StandardCharsets.ISO_8859_1));
assertThat(new String(result, StandardCharsets.ISO_8859_1)).isEqualTo("foo:bar");
}
@Test
@@ -574,7 +566,7 @@ public class HttpHeadersTests {
headers.setBearerAuth(token);
String authorization = headers.getFirst(HttpHeaders.AUTHORIZATION);
assertEquals("Bearer foo", authorization);
assertThat(authorization).isEqualTo("Bearer foo");
}
@Test
@@ -582,13 +574,13 @@ public class HttpHeadersTests {
String headerName = "MyHeader";
String headerValue = "value";
assertTrue(headers.isEmpty());
assertThat(headers.isEmpty()).isTrue();
headers.add(headerName, headerValue);
assertTrue(headers.containsKey(headerName));
assertThat(headers.containsKey(headerName)).isTrue();
headers.keySet().removeIf(key -> key.equals(headerName));
assertTrue(headers.isEmpty());
assertThat(headers.isEmpty()).isTrue();
headers.add(headerName, headerValue);
assertEquals(headerValue, headers.get(headerName).get(0));
assertThat(headers.get(headerName).get(0)).isEqualTo(headerValue);
}
@Test
@@ -596,13 +588,13 @@ public class HttpHeadersTests {
String headerName = "MyHeader";
String headerValue = "value";
assertTrue(headers.isEmpty());
assertThat(headers.isEmpty()).isTrue();
headers.add(headerName, headerValue);
assertTrue(headers.containsKey(headerName));
assertThat(headers.containsKey(headerName)).isTrue();
headers.entrySet().removeIf(entry -> entry.getKey().equals(headerName));
assertTrue(headers.isEmpty());
assertThat(headers.isEmpty()).isTrue();
headers.add(headerName, headerValue);
assertEquals(headerValue, headers.get(headerName).get(0));
assertThat(headers.get(headerName).get(0)).isEqualTo(headerValue);
}
}

49
spring-web/src/test/java/org/springframework/http/HttpRangeTests.java
View File

@@ -27,8 +27,8 @@ import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.InputStreamResource;
import org.springframework.core.io.support.ResourceRegion;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -61,48 +61,48 @@ public class HttpRangeTests {
@Test
public void byteRange() {
HttpRange range = HttpRange.createByteRange(0, 499);
assertEquals(0, range.getRangeStart(1000));
assertEquals(499, range.getRangeEnd(1000));
assertThat(range.getRangeStart(1000)).isEqualTo(0);
assertThat(range.getRangeEnd(1000)).isEqualTo(499);
}
@Test
public void byteRangeWithoutLastPosition() {
HttpRange range = HttpRange.createByteRange(9500);
assertEquals(9500, range.getRangeStart(10000));
assertEquals(9999, range.getRangeEnd(10000));
assertThat(range.getRangeStart(10000)).isEqualTo(9500);
assertThat(range.getRangeEnd(10000)).isEqualTo(9999);
}
@Test
public void byteRangeOfZeroLength() {
HttpRange range = HttpRange.createByteRange(9500, 9500);
assertEquals(9500, range.getRangeStart(10000));
assertEquals(9500, range.getRangeEnd(10000));
assertThat(range.getRangeStart(10000)).isEqualTo(9500);
assertThat(range.getRangeEnd(10000)).isEqualTo(9500);
}
@Test
public void suffixRange() {
HttpRange range = HttpRange.createSuffixRange(500);
assertEquals(500, range.getRangeStart(1000));
assertEquals(999, range.getRangeEnd(1000));
assertThat(range.getRangeStart(1000)).isEqualTo(500);
assertThat(range.getRangeEnd(1000)).isEqualTo(999);
}
@Test
public void suffixRangeShorterThanRepresentation() {
HttpRange range = HttpRange.createSuffixRange(500);
assertEquals(0, range.getRangeStart(350));
assertEquals(349, range.getRangeEnd(350));
assertThat(range.getRangeStart(350)).isEqualTo(0);
assertThat(range.getRangeEnd(350)).isEqualTo(349);
}
@Test
public void parseRanges() {
List<HttpRange> ranges = HttpRange.parseRanges("bytes=0-0,500-,-1");
assertEquals(3, ranges.size());
assertEquals(0, ranges.get(0).getRangeStart(1000));
assertEquals(0, ranges.get(0).getRangeEnd(1000));
assertEquals(500, ranges.get(1).getRangeStart(1000));
assertEquals(999, ranges.get(1).getRangeEnd(1000));
assertEquals(999, ranges.get(2).getRangeStart(1000));
assertEquals(999, ranges.get(2).getRangeEnd(1000));
assertThat(ranges.size()).isEqualTo(3);
assertThat(ranges.get(0).getRangeStart(1000)).isEqualTo(0);
assertThat(ranges.get(0).getRangeEnd(1000)).isEqualTo(0);
assertThat(ranges.get(1).getRangeStart(1000)).isEqualTo(500);
assertThat(ranges.get(1).getRangeEnd(1000)).isEqualTo(999);
assertThat(ranges.get(2).getRangeStart(1000)).isEqualTo(999);
assertThat(ranges.get(2).getRangeEnd(1000)).isEqualTo(999);
}
@Test
@@ -114,7 +114,7 @@ public class HttpRangeTests {
atLimit.append(",").append(i).append("-").append(i + 1);
}
List<HttpRange> ranges = HttpRange.parseRanges(atLimit.toString());
assertEquals(100, ranges.size());
assertThat(ranges.size()).isEqualTo(100);
// 2. Above limit..
StringBuilder aboveLimit = new StringBuilder("bytes=0-0");
@@ -131,7 +131,7 @@ public class HttpRangeTests {
ranges.add(HttpRange.createByteRange(0, 499));
ranges.add(HttpRange.createByteRange(9500));
ranges.add(HttpRange.createSuffixRange(500));
assertEquals("Invalid Range header", "bytes=0-499, 9500-, -500", HttpRange.toString(ranges));
assertThat(HttpRange.toString(ranges)).as("Invalid Range header").isEqualTo("bytes=0-499, 9500-, -500");
}
@Test
@@ -140,9 +140,9 @@ public class HttpRangeTests {
ByteArrayResource resource = new ByteArrayResource(bytes);
HttpRange range = HttpRange.createByteRange(0, 5);
ResourceRegion region = range.toResourceRegion(resource);
assertEquals(resource, region.getResource());
assertEquals(0L, region.getPosition());
assertEquals(6L, region.getCount());
assertThat(region.getResource()).isEqualTo(resource);
assertThat(region.getPosition()).isEqualTo(0L);
assertThat(region.getCount()).isEqualTo(6L);
}
@Test
@@ -163,7 +163,6 @@ public class HttpRangeTests {
}
@Test
@SuppressWarnings("unchecked")
public void toResourceRegionExceptionLength() throws IOException {
InputStreamResource resource = mock(InputStreamResource.class);
given(resource.contentLength()).willThrow(IOException.class);
@@ -180,7 +179,7 @@ public class HttpRangeTests {
// 1. Below length
List<HttpRange> belowLengthRanges = HttpRange.parseRanges("bytes=0-1,2-3");
List<ResourceRegion> regions = HttpRange.toResourceRegions(belowLengthRanges, resource);
assertEquals(2, regions.size());
assertThat(regions.size()).isEqualTo(2);
// 2. At length
List<HttpRange> atLengthRanges = HttpRange.parseRanges("bytes=0-1,2-4");

11
spring-web/src/test/java/org/springframework/http/HttpStatusTests.java
View File

@@ -22,8 +22,7 @@ import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/** @author Arjen Poutsma */
public class HttpStatusTests {
@@ -107,8 +106,8 @@ public class HttpStatusTests {
for (Map.Entry<Integer, String> entry : statusCodes.entrySet()) {
int value = entry.getKey();
HttpStatus status = HttpStatus.valueOf(value);
assertEquals("Invalid value", value, status.value());
assertEquals("Invalid name for [" + value + "]", entry.getValue(), status.name());
assertThat(status.value()).as("Invalid value").isEqualTo(value);
assertThat(status.name()).as("Invalid name for [" + value + "]").isEqualTo(entry.getValue());
}
}
@@ -120,8 +119,8 @@ public class HttpStatusTests {
if (value == 302 || value == 413 || value == 414) {
continue;
}
assertTrue("Map has no value for [" + value + "]", statusCodes.containsKey(value));
assertEquals("Invalid name for [" + value + "]", statusCodes.get(value), status.name());
assertThat(statusCodes.containsKey(value)).as("Map has no value for [" + value + "]").isTrue();
assertThat(status.name()).as("Invalid name for [" + value + "]").isEqualTo(statusCodes.get(value));
}
}
}

18
spring-web/src/test/java/org/springframework/http/MediaTypeFactoryTests.java
View File

@@ -20,9 +20,7 @@ import org.junit.Test;
import org.springframework.core.io.Resource;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -31,17 +29,17 @@ public class MediaTypeFactoryTests {
@Test
public void getMediaType() {
assertEquals(MediaType.APPLICATION_XML, MediaTypeFactory.getMediaType("file.xml").get());
assertEquals(MediaType.parseMediaType("application/javascript"), MediaTypeFactory.getMediaType("file.js").get());
assertEquals(MediaType.parseMediaType("text/css"), MediaTypeFactory.getMediaType("file.css").get());
assertFalse(MediaTypeFactory.getMediaType("file.foobar").isPresent());
assertThat(MediaTypeFactory.getMediaType("file.xml").get()).isEqualTo(MediaType.APPLICATION_XML);
assertThat(MediaTypeFactory.getMediaType("file.js").get()).isEqualTo(MediaType.parseMediaType("application/javascript"));
assertThat(MediaTypeFactory.getMediaType("file.css").get()).isEqualTo(MediaType.parseMediaType("text/css"));
assertThat(MediaTypeFactory.getMediaType("file.foobar").isPresent()).isFalse();
}
@Test
public void nullParameter() {
assertFalse(MediaTypeFactory.getMediaType((String) null).isPresent());
assertFalse(MediaTypeFactory.getMediaType((Resource) null).isPresent());
assertTrue(MediaTypeFactory.getMediaTypes(null).isEmpty());
assertThat(MediaTypeFactory.getMediaType((String) null).isPresent()).isFalse();
assertThat(MediaTypeFactory.getMediaType((Resource) null).isPresent()).isFalse();
assertThat(MediaTypeFactory.getMediaTypes(null).isEmpty()).isTrue();
}
}

183
spring-web/src/test/java/org/springframework/http/MediaTypeTests.java
View File

@@ -27,13 +27,10 @@ import org.junit.Test;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.support.DefaultConversionService;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.within;
/**
* @author Arjen Poutsma
@@ -45,7 +42,7 @@ public class MediaTypeTests {
public void testToString() throws Exception {
MediaType mediaType = new MediaType("text", "plain", 0.7);
String result = mediaType.toString();
assertEquals("Invalid toString() returned", "text/plain;q=0.7", result);
assertThat(result).as("Invalid toString() returned").isEqualTo("text/plain;q=0.7");
}
@Test
@@ -63,16 +60,16 @@ public class MediaTypeTests {
@Test
public void getDefaultQualityValue() {
MediaType mediaType = new MediaType("text", "plain");
assertEquals("Invalid quality value", 1, mediaType.getQualityValue(), 0D);
assertThat(mediaType.getQualityValue()).as("Invalid quality value").isCloseTo(1D, within(0D));
}
@Test
public void parseMediaType() throws Exception {
String s = "audio/*; q=0.2";
MediaType mediaType = MediaType.parseMediaType(s);
assertEquals("Invalid type", "audio", mediaType.getType());
assertEquals("Invalid subtype", "*", mediaType.getSubtype());
assertEquals("Invalid quality factor", 0.2D, mediaType.getQualityValue(), 0D);
assertThat(mediaType.getType()).as("Invalid type").isEqualTo("audio");
assertThat(mediaType.getSubtype()).as("Invalid subtype").isEqualTo("*");
assertThat(mediaType.getQualityValue()).as("Invalid quality factor").isCloseTo(0.2D, within(0D));
}
@Test
@@ -145,21 +142,21 @@ public class MediaTypeTests {
public void parseURLConnectionMediaType() throws Exception {
String s = "*; q=.2";
MediaType mediaType = MediaType.parseMediaType(s);
assertEquals("Invalid type", "*", mediaType.getType());
assertEquals("Invalid subtype", "*", mediaType.getSubtype());
assertEquals("Invalid quality factor", 0.2D, mediaType.getQualityValue(), 0D);
assertThat(mediaType.getType()).as("Invalid type").isEqualTo("*");
assertThat(mediaType.getSubtype()).as("Invalid subtype").isEqualTo("*");
assertThat(mediaType.getQualityValue()).as("Invalid quality factor").isCloseTo(0.2D, within(0D));
}
@Test
public void parseMediaTypes() throws Exception {
String s = "text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c";
List<MediaType> mediaTypes = MediaType.parseMediaTypes(s);
assertNotNull("No media types returned", mediaTypes);
assertEquals("Invalid amount of media types", 4, mediaTypes.size());
assertThat(mediaTypes).as("No media types returned").isNotNull();
assertThat(mediaTypes.size()).as("Invalid amount of media types").isEqualTo(4);
mediaTypes = MediaType.parseMediaTypes("");
assertNotNull("No media types returned", mediaTypes);
assertEquals("Invalid amount of media types", 0, mediaTypes.size());
assertThat(mediaTypes).as("No media types returned").isNotNull();
assertThat(mediaTypes.size()).as("Invalid amount of media types").isEqualTo(0);
}
@Test
@@ -171,11 +168,11 @@ public class MediaTypeTests {
MediaType audioBasic07 = new MediaType("audio", "basic", 0.7);
// equal
assertEquals("Invalid comparison result", 0, audioBasic.compareTo(audioBasic));
assertEquals("Invalid comparison result", 0, audio.compareTo(audio));
assertEquals("Invalid comparison result", 0, audioBasicLevel.compareTo(audioBasicLevel));
assertThat(audioBasic.compareTo(audioBasic)).as("Invalid comparison result").isEqualTo(0);
assertThat(audio.compareTo(audio)).as("Invalid comparison result").isEqualTo(0);
assertThat(audioBasicLevel.compareTo(audioBasicLevel)).as("Invalid comparison result").isEqualTo(0);
assertTrue("Invalid comparison result", audioBasicLevel.compareTo(audio) > 0);
assertThat(audioBasicLevel.compareTo(audio) > 0).as("Invalid comparison result").isTrue();
List<MediaType> expected = new ArrayList<>();
expected.add(audio);
@@ -192,7 +189,7 @@ public class MediaTypeTests {
Collections.sort(result);
for (int j = 0; j < result.size(); j++) {
assertSame("Invalid media type at " + j + ", run " + i, expected.get(j), result.get(j));
assertThat(result.get(j)).as("Invalid media type at " + j + ", run " + i).isSameAs(expected.get(j));
}
}
}
@@ -202,33 +199,33 @@ public class MediaTypeTests {
MediaType m1 = MediaType.parseMediaType("text/html; q=0.7; charset=iso-8859-1");
MediaType m2 = MediaType.parseMediaType("text/html; charset=iso-8859-1; q=0.7");
assertEquals("Media types not equal", m1, m2);
assertEquals("compareTo() not consistent with equals", 0, m1.compareTo(m2));
assertEquals("compareTo() not consistent with equals", 0, m2.compareTo(m1));
assertThat(m2).as("Media types not equal").isEqualTo(m1);
assertThat(m1.compareTo(m2)).as("compareTo() not consistent with equals").isEqualTo(0);
assertThat(m2.compareTo(m1)).as("compareTo() not consistent with equals").isEqualTo(0);
m1 = MediaType.parseMediaType("text/html; q=0.7; charset=iso-8859-1");
m2 = MediaType.parseMediaType("text/html; Q=0.7; charset=iso-8859-1");
assertEquals("Media types not equal", m1, m2);
assertEquals("compareTo() not consistent with equals", 0, m1.compareTo(m2));
assertEquals("compareTo() not consistent with equals", 0, m2.compareTo(m1));
assertThat(m2).as("Media types not equal").isEqualTo(m1);
assertThat(m1.compareTo(m2)).as("compareTo() not consistent with equals").isEqualTo(0);
assertThat(m2.compareTo(m1)).as("compareTo() not consistent with equals").isEqualTo(0);
}
@Test
public void compareToCaseSensitivity() {
MediaType m1 = new MediaType("audio", "basic");
MediaType m2 = new MediaType("Audio", "Basic");
assertEquals("Invalid comparison result", 0, m1.compareTo(m2));
assertEquals("Invalid comparison result", 0, m2.compareTo(m1));
assertThat(m1.compareTo(m2)).as("Invalid comparison result").isEqualTo(0);
assertThat(m2.compareTo(m1)).as("Invalid comparison result").isEqualTo(0);
m1 = new MediaType("audio", "basic", Collections.singletonMap("foo", "bar"));
m2 = new MediaType("audio", "basic", Collections.singletonMap("Foo", "bar"));
assertEquals("Invalid comparison result", 0, m1.compareTo(m2));
assertEquals("Invalid comparison result", 0, m2.compareTo(m1));
assertThat(m1.compareTo(m2)).as("Invalid comparison result").isEqualTo(0);
assertThat(m2.compareTo(m1)).as("Invalid comparison result").isEqualTo(0);
m1 = new MediaType("audio", "basic", Collections.singletonMap("foo", "bar"));
m2 = new MediaType("audio", "basic", Collections.singletonMap("foo", "Bar"));
assertTrue("Invalid comparison result", m1.compareTo(m2) != 0);
assertTrue("Invalid comparison result", m2.compareTo(m1) != 0);
assertThat(m1.compareTo(m2) != 0).as("Invalid comparison result").isTrue();
assertThat(m2.compareTo(m1) != 0).as("Invalid comparison result").isTrue();
}
@@ -248,43 +245,43 @@ public class MediaTypeTests {
Comparator<MediaType> comp = MediaType.SPECIFICITY_COMPARATOR;
// equal
assertEquals("Invalid comparison result", 0, comp.compare(audioBasic,audioBasic));
assertEquals("Invalid comparison result", 0, comp.compare(audio, audio));
assertEquals("Invalid comparison result", 0, comp.compare(audio07, audio07));
assertEquals("Invalid comparison result", 0, comp.compare(audio03, audio03));
assertEquals("Invalid comparison result", 0, comp.compare(audioBasicLevel, audioBasicLevel));
assertThat(comp.compare(audioBasic, audioBasic)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audio, audio)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audio07, audio07)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audio03, audio03)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audioBasicLevel, audioBasicLevel)).as("Invalid comparison result").isEqualTo(0);
// specific to unspecific
assertTrue("Invalid comparison result", comp.compare(audioBasic, audio) < 0);
assertTrue("Invalid comparison result", comp.compare(audioBasic, all) < 0);
assertTrue("Invalid comparison result", comp.compare(audio, all) < 0);
assertTrue("Invalid comparison result", comp.compare(MediaType.APPLICATION_XHTML_XML, allXml) < 0);
assertThat(comp.compare(audioBasic, audio) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audioBasic, all) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio, all) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(MediaType.APPLICATION_XHTML_XML, allXml) < 0).as("Invalid comparison result").isTrue();
// unspecific to specific
assertTrue("Invalid comparison result", comp.compare(audio, audioBasic) > 0);
assertTrue("Invalid comparison result", comp.compare(allXml, MediaType.APPLICATION_XHTML_XML) > 0);
assertTrue("Invalid comparison result", comp.compare(all, audioBasic) > 0);
assertTrue("Invalid comparison result", comp.compare(all, audio) > 0);
assertThat(comp.compare(audio, audioBasic) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(allXml, MediaType.APPLICATION_XHTML_XML) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(all, audioBasic) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(all, audio) > 0).as("Invalid comparison result").isTrue();
// qualifiers
assertTrue("Invalid comparison result", comp.compare(audio, audio07) < 0);
assertTrue("Invalid comparison result", comp.compare(audio07, audio) > 0);
assertTrue("Invalid comparison result", comp.compare(audio07, audio03) < 0);
assertTrue("Invalid comparison result", comp.compare(audio03, audio07) > 0);
assertTrue("Invalid comparison result", comp.compare(audio03, all) < 0);
assertTrue("Invalid comparison result", comp.compare(all, audio03) > 0);
assertThat(comp.compare(audio, audio07) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio07, audio) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio07, audio03) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio03, audio07) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio03, all) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(all, audio03) > 0).as("Invalid comparison result").isTrue();
// other parameters
assertTrue("Invalid comparison result", comp.compare(audioBasic, audioBasicLevel) > 0);
assertTrue("Invalid comparison result", comp.compare(audioBasicLevel, audioBasic) < 0);
assertThat(comp.compare(audioBasic, audioBasicLevel) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audioBasicLevel, audioBasic) < 0).as("Invalid comparison result").isTrue();
// different types
assertEquals("Invalid comparison result", 0, comp.compare(audioBasic, textHtml));
assertEquals("Invalid comparison result", 0, comp.compare(textHtml, audioBasic));
assertThat(comp.compare(audioBasic, textHtml)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(textHtml, audioBasic)).as("Invalid comparison result").isEqualTo(0);
// different subtypes
assertEquals("Invalid comparison result", 0, comp.compare(audioBasic, audioWave));
assertEquals("Invalid comparison result", 0, comp.compare(audioWave, audioBasic));
assertThat(comp.compare(audioBasic, audioWave)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audioWave, audioBasic)).as("Invalid comparison result").isEqualTo(0);
}
@Test
@@ -312,7 +309,7 @@ public class MediaTypeTests {
MediaType.sortBySpecificity(result);
for (int j = 0; j < result.size(); j++) {
assertSame("Invalid media type at " + j, expected.get(j), result.get(j));
assertThat(result.get(j)).as("Invalid media type at " + j).isSameAs(expected.get(j));
}
}
}
@@ -332,7 +329,7 @@ public class MediaTypeTests {
MediaType.sortBySpecificity(result);
for (int i = 0; i < result.size(); i++) {
assertSame("Invalid media type at " + i, expected.get(i), result.get(i));
assertThat(result.get(i)).as("Invalid media type at " + i).isSameAs(expected.get(i));
}
}
@@ -352,43 +349,43 @@ public class MediaTypeTests {
Comparator<MediaType> comp = MediaType.QUALITY_VALUE_COMPARATOR;
// equal
assertEquals("Invalid comparison result", 0, comp.compare(audioBasic,audioBasic));
assertEquals("Invalid comparison result", 0, comp.compare(audio, audio));
assertEquals("Invalid comparison result", 0, comp.compare(audio07, audio07));
assertEquals("Invalid comparison result", 0, comp.compare(audio03, audio03));
assertEquals("Invalid comparison result", 0, comp.compare(audioBasicLevel, audioBasicLevel));
assertThat(comp.compare(audioBasic, audioBasic)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audio, audio)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audio07, audio07)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audio03, audio03)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audioBasicLevel, audioBasicLevel)).as("Invalid comparison result").isEqualTo(0);
// specific to unspecific
assertTrue("Invalid comparison result", comp.compare(audioBasic, audio) < 0);
assertTrue("Invalid comparison result", comp.compare(audioBasic, all) < 0);
assertTrue("Invalid comparison result", comp.compare(audio, all) < 0);
assertTrue("Invalid comparison result", comp.compare(MediaType.APPLICATION_XHTML_XML, allXml) < 0);
assertThat(comp.compare(audioBasic, audio) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audioBasic, all) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio, all) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(MediaType.APPLICATION_XHTML_XML, allXml) < 0).as("Invalid comparison result").isTrue();
// unspecific to specific
assertTrue("Invalid comparison result", comp.compare(audio, audioBasic) > 0);
assertTrue("Invalid comparison result", comp.compare(all, audioBasic) > 0);
assertTrue("Invalid comparison result", comp.compare(all, audio) > 0);
assertTrue("Invalid comparison result", comp.compare(allXml, MediaType.APPLICATION_XHTML_XML) > 0);
assertThat(comp.compare(audio, audioBasic) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(all, audioBasic) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(all, audio) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(allXml, MediaType.APPLICATION_XHTML_XML) > 0).as("Invalid comparison result").isTrue();
// qualifiers
assertTrue("Invalid comparison result", comp.compare(audio, audio07) < 0);
assertTrue("Invalid comparison result", comp.compare(audio07, audio) > 0);
assertTrue("Invalid comparison result", comp.compare(audio07, audio03) < 0);
assertTrue("Invalid comparison result", comp.compare(audio03, audio07) > 0);
assertTrue("Invalid comparison result", comp.compare(audio03, all) > 0);
assertTrue("Invalid comparison result", comp.compare(all, audio03) < 0);
assertThat(comp.compare(audio, audio07) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio07, audio) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio07, audio03) < 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio03, audio07) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audio03, all) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(all, audio03) < 0).as("Invalid comparison result").isTrue();
// other parameters
assertTrue("Invalid comparison result", comp.compare(audioBasic, audioBasicLevel) > 0);
assertTrue("Invalid comparison result", comp.compare(audioBasicLevel, audioBasic) < 0);
assertThat(comp.compare(audioBasic, audioBasicLevel) > 0).as("Invalid comparison result").isTrue();
assertThat(comp.compare(audioBasicLevel, audioBasic) < 0).as("Invalid comparison result").isTrue();
// different types
assertEquals("Invalid comparison result", 0, comp.compare(audioBasic, textHtml));
assertEquals("Invalid comparison result", 0, comp.compare(textHtml, audioBasic));
assertThat(comp.compare(audioBasic, textHtml)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(textHtml, audioBasic)).as("Invalid comparison result").isEqualTo(0);
// different subtypes
assertEquals("Invalid comparison result", 0, comp.compare(audioBasic, audioWave));
assertEquals("Invalid comparison result", 0, comp.compare(audioWave, audioBasic));
assertThat(comp.compare(audioBasic, audioWave)).as("Invalid comparison result").isEqualTo(0);
assertThat(comp.compare(audioWave, audioBasic)).as("Invalid comparison result").isEqualTo(0);
}
@Test
@@ -416,7 +413,7 @@ public class MediaTypeTests {
MediaType.sortByQualityValue(result);
for (int j = 0; j < result.size(); j++) {
assertSame("Invalid media type at " + j, expected.get(j), result.get(j));
assertThat(result.get(j)).as("Invalid media type at " + j).isSameAs(expected.get(j));
}
}
}
@@ -436,23 +433,23 @@ public class MediaTypeTests {
MediaType.sortBySpecificity(result);
for (int i = 0; i < result.size(); i++) {
assertSame("Invalid media type at " + i, expected.get(i), result.get(i));
assertThat(result.get(i)).as("Invalid media type at " + i).isSameAs(expected.get(i));
}
}
@Test
public void testWithConversionService() {
ConversionService conversionService = new DefaultConversionService();
assertTrue(conversionService.canConvert(String.class, MediaType.class));
assertThat(conversionService.canConvert(String.class, MediaType.class)).isTrue();
MediaType mediaType = MediaType.parseMediaType("application/xml");
assertEquals(mediaType, conversionService.convert("application/xml", MediaType.class));
assertThat(conversionService.convert("application/xml", MediaType.class)).isEqualTo(mediaType);
}
@Test
public void isConcrete() {
assertTrue("text/plain not concrete", MediaType.TEXT_PLAIN.isConcrete());
assertFalse("*/* concrete", MediaType.ALL.isConcrete());
assertFalse("text/* concrete", new MediaType("text", "*").isConcrete());
assertThat(MediaType.TEXT_PLAIN.isConcrete()).as("text/plain not concrete").isTrue();
assertThat(MediaType.ALL.isConcrete()).as("*/* concrete").isFalse();
assertThat(new MediaType("text", "*").isConcrete()).as("text/* concrete").isFalse();
}
}

65
spring-web/src/test/java/org/springframework/http/RequestEntityTests.java
View File

@@ -29,10 +29,7 @@ import org.junit.Test;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.web.util.UriTemplate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link org.springframework.http.RequestEntity}.
@@ -52,11 +49,11 @@ public class RequestEntityTests {
RequestEntity.method(HttpMethod.GET, url)
.header(headerName, headerValue).body(entity);
assertNotNull(requestEntity);
assertEquals(HttpMethod.GET, requestEntity.getMethod());
assertTrue(requestEntity.getHeaders().containsKey(headerName));
assertEquals(headerValue, requestEntity.getHeaders().getFirst(headerName));
assertEquals(entity, requestEntity.getBody());
assertThat(requestEntity).isNotNull();
assertThat(requestEntity.getMethod()).isEqualTo(HttpMethod.GET);
assertThat(requestEntity.getHeaders().containsKey(headerName)).isTrue();
assertThat(requestEntity.getHeaders().getFirst(headerName)).isEqualTo(headerValue);
assertThat(requestEntity.getBody()).isEqualTo(entity);
}
@Test
@@ -71,7 +68,7 @@ public class RequestEntityTests {
uri = new UriTemplate(url).expand(host, path);
RequestEntity<?> entity = RequestEntity.get(uri).build();
assertEquals(expected, entity.getUrl());
assertThat(entity.getUrl()).isEqualTo(expected);
Map<String, String> uriVariables = new HashMap<>(2);
uriVariables.put("host", host);
@@ -79,7 +76,7 @@ public class RequestEntityTests {
uri = new UriTemplate(url).expand(uriVariables);
entity = RequestEntity.get(uri).build();
assertEquals(expected, entity.getUrl());
assertThat(entity.getUrl()).isEqualTo(expected);
}
@Test
@@ -87,11 +84,11 @@ public class RequestEntityTests {
RequestEntity<Void> requestEntity = RequestEntity.get(URI.create("https://example.com")).accept(
MediaType.IMAGE_GIF, MediaType.IMAGE_JPEG, MediaType.IMAGE_PNG).build();
assertNotNull(requestEntity);
assertEquals(HttpMethod.GET, requestEntity.getMethod());
assertTrue(requestEntity.getHeaders().containsKey("Accept"));
assertEquals("image/gif, image/jpeg, image/png", requestEntity.getHeaders().getFirst("Accept"));
assertNull(requestEntity.getBody());
assertThat(requestEntity).isNotNull();
assertThat(requestEntity.getMethod()).isEqualTo(HttpMethod.GET);
assertThat(requestEntity.getHeaders().containsKey("Accept")).isTrue();
assertThat(requestEntity.getHeaders().getFirst("Accept")).isEqualTo("image/gif, image/jpeg, image/png");
assertThat(requestEntity.getBody()).isNull();
}
@Test
@@ -111,19 +108,19 @@ public class RequestEntityTests {
contentType(contentType).
build();
assertNotNull(responseEntity);
assertEquals(HttpMethod.POST, responseEntity.getMethod());
assertEquals(new URI("https://example.com"), responseEntity.getUrl());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getMethod()).isEqualTo(HttpMethod.POST);
assertThat(responseEntity.getUrl()).isEqualTo(new URI("https://example.com"));
HttpHeaders responseHeaders = responseEntity.getHeaders();
assertEquals("text/plain", responseHeaders.getFirst("Accept"));
assertEquals("utf-8", responseHeaders.getFirst("Accept-Charset"));
assertEquals("Thu, 01 Jan 1970 00:00:12 GMT", responseHeaders.getFirst("If-Modified-Since"));
assertEquals(ifNoneMatch, responseHeaders.getFirst("If-None-Match"));
assertEquals(String.valueOf(contentLength), responseHeaders.getFirst("Content-Length"));
assertEquals(contentType.toString(), responseHeaders.getFirst("Content-Type"));
assertThat(responseHeaders.getFirst("Accept")).isEqualTo("text/plain");
assertThat(responseHeaders.getFirst("Accept-Charset")).isEqualTo("utf-8");
assertThat(responseHeaders.getFirst("If-Modified-Since")).isEqualTo("Thu, 01 Jan 1970 00:00:12 GMT");
assertThat(responseHeaders.getFirst("If-None-Match")).isEqualTo(ifNoneMatch);
assertThat(responseHeaders.getFirst("Content-Length")).isEqualTo(String.valueOf(contentLength));
assertThat(responseHeaders.getFirst("Content-Type")).isEqualTo(contentType.toString());
assertNull(responseEntity.getBody());
assertThat(responseEntity.getBody()).isNull();
}
@Test
@@ -131,25 +128,25 @@ public class RequestEntityTests {
URI url = new URI("https://example.com");
RequestEntity<?> entity = RequestEntity.get(url).build();
assertEquals(HttpMethod.GET, entity.getMethod());
assertThat(entity.getMethod()).isEqualTo(HttpMethod.GET);
entity = RequestEntity.post(url).build();
assertEquals(HttpMethod.POST, entity.getMethod());
assertThat(entity.getMethod()).isEqualTo(HttpMethod.POST);
entity = RequestEntity.head(url).build();
assertEquals(HttpMethod.HEAD, entity.getMethod());
assertThat(entity.getMethod()).isEqualTo(HttpMethod.HEAD);
entity = RequestEntity.options(url).build();
assertEquals(HttpMethod.OPTIONS, entity.getMethod());
assertThat(entity.getMethod()).isEqualTo(HttpMethod.OPTIONS);
entity = RequestEntity.put(url).build();
assertEquals(HttpMethod.PUT, entity.getMethod());
assertThat(entity.getMethod()).isEqualTo(HttpMethod.PUT);
entity = RequestEntity.patch(url).build();
assertEquals(HttpMethod.PATCH, entity.getMethod());
assertThat(entity.getMethod()).isEqualTo(HttpMethod.PATCH);
entity = RequestEntity.delete(url).build();
assertEquals(HttpMethod.DELETE, entity.getMethod());
assertThat(entity.getMethod()).isEqualTo(HttpMethod.DELETE);
}
@@ -160,7 +157,7 @@ public class RequestEntityTests {
ParameterizedTypeReference<?> typeReference = new ParameterizedTypeReference<List<String>>() {};
RequestEntity<?> entity = RequestEntity.post(url).body(body, typeReference.getType());
assertEquals(typeReference.getType(), entity.getType());
assertThat(entity.getType()).isEqualTo(typeReference.getType());
}
}

14
spring-web/src/test/java/org/springframework/http/ResponseCookieTests.java
View File

@@ -21,7 +21,6 @@ import java.time.Duration;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
/**
* Unit tests for {@link ResponseCookie}.
@@ -31,14 +30,13 @@ public class ResponseCookieTests {
@Test
public void defaultValues() {
assertEquals("id=1fWa", ResponseCookie.from("id", "1fWa").build().toString());
assertThat(ResponseCookie.from("id", "1fWa").build().toString()).isEqualTo("id=1fWa");
}
@Test
public void httpOnlyStrictSecureWithDomainAndPath() {
assertEquals("id=1fWa; Path=/projects; Domain=spring.io; Secure; HttpOnly; SameSite=strict",
ResponseCookie.from("id", "1fWa").domain("spring.io").path("/projects")
.httpOnly(true).secure(true).sameSite("strict").build().toString());
assertThat(ResponseCookie.from("id", "1fWa").domain("spring.io").path("/projects")
.httpOnly(true).secure(true).sameSite("strict").build().toString()).isEqualTo("id=1fWa; Path=/projects; Domain=spring.io; Secure; HttpOnly; SameSite=strict");
}
@Test
@@ -59,11 +57,9 @@ public class ResponseCookieTests {
@Test
public void maxAge0() {
assertEquals("id=1fWa; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT",
ResponseCookie.from("id", "1fWa").maxAge(Duration.ofSeconds(0)).build().toString());
assertThat(ResponseCookie.from("id", "1fWa").maxAge(Duration.ofSeconds(0)).build().toString()).isEqualTo("id=1fWa; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT");
assertEquals("id=1fWa; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT",
ResponseCookie.from("id", "1fWa").maxAge(0).build().toString());
assertThat(ResponseCookie.from("id", "1fWa").maxAge(0).build().toString()).isEqualTo("id=1fWa; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT");
}
}

160
spring-web/src/test/java/org/springframework/http/ResponseEntityTests.java
View File

@@ -25,11 +25,6 @@ import java.util.concurrent.TimeUnit;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
/**
* @author Arjen Poutsma
@@ -48,23 +43,23 @@ public class ResponseEntityTests {
ResponseEntity<Integer> responseEntity =
ResponseEntity.status(HttpStatus.OK).header(headerName, headerValue1, headerValue2).body(entity);
assertNotNull(responseEntity);
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertTrue(responseEntity.getHeaders().containsKey(headerName));
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseEntity.getHeaders().containsKey(headerName)).isTrue();
List<String> list = responseEntity.getHeaders().get(headerName);
assertEquals(2, list.size());
assertEquals(headerValue1, list.get(0));
assertEquals(headerValue2, list.get(1));
assertEquals(entity, responseEntity.getBody());
assertThat(list.size()).isEqualTo(2);
assertThat(list.get(0)).isEqualTo(headerValue1);
assertThat(list.get(1)).isEqualTo(headerValue2);
assertThat((int) responseEntity.getBody()).isEqualTo((int) entity);
}
@Test
public void okNoBody() {
ResponseEntity<Void> responseEntity = ResponseEntity.ok().build();
assertNotNull(responseEntity);
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertNull(responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseEntity.getBody()).isNull();
}
@Test
@@ -72,9 +67,9 @@ public class ResponseEntityTests {
Integer entity = 42;
ResponseEntity<Integer> responseEntity = ResponseEntity.ok(entity);
assertNotNull(responseEntity);
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertEquals(entity, responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat((int) responseEntity.getBody()).isEqualTo((int) entity);
}
@Test
@@ -82,18 +77,18 @@ public class ResponseEntityTests {
Integer entity = 42;
ResponseEntity<Integer> responseEntity = ResponseEntity.of(Optional.of(entity));
assertNotNull(responseEntity);
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertEquals(entity, responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat((int) responseEntity.getBody()).isEqualTo((int) entity);
}
@Test
public void ofEmptyOptional() {
ResponseEntity<Integer> responseEntity = ResponseEntity.of(Optional.empty());
assertNotNull(responseEntity);
assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode());
assertNull(responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
assertThat(responseEntity.getBody()).isNull();
}
@Test
@@ -101,12 +96,11 @@ public class ResponseEntityTests {
URI location = new URI("location");
ResponseEntity<Void> responseEntity = ResponseEntity.created(location).build();
assertNotNull(responseEntity);
assertEquals(HttpStatus.CREATED, responseEntity.getStatusCode());
assertTrue(responseEntity.getHeaders().containsKey("Location"));
assertEquals(location.toString(),
responseEntity.getHeaders().getFirst("Location"));
assertNull(responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.CREATED);
assertThat(responseEntity.getHeaders().containsKey("Location")).isTrue();
assertThat(responseEntity.getHeaders().getFirst("Location")).isEqualTo(location.toString());
assertThat(responseEntity.getBody()).isNull();
ResponseEntity.created(location).header("MyResponseHeader", "MyValue").body("Hello World");
}
@@ -115,54 +109,54 @@ public class ResponseEntityTests {
public void acceptedNoBody() throws URISyntaxException {
ResponseEntity<Void> responseEntity = ResponseEntity.accepted().build();
assertNotNull(responseEntity);
assertEquals(HttpStatus.ACCEPTED, responseEntity.getStatusCode());
assertNull(responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
assertThat(responseEntity.getBody()).isNull();
}
@Test // SPR-14939
public void acceptedNoBodyWithAlternativeBodyType() throws URISyntaxException {
ResponseEntity<String> responseEntity = ResponseEntity.accepted().build();
assertNotNull(responseEntity);
assertEquals(HttpStatus.ACCEPTED, responseEntity.getStatusCode());
assertNull(responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
assertThat(responseEntity.getBody()).isNull();
}
@Test
public void noContent() throws URISyntaxException {
ResponseEntity<Void> responseEntity = ResponseEntity.noContent().build();
assertNotNull(responseEntity);
assertEquals(HttpStatus.NO_CONTENT, responseEntity.getStatusCode());
assertNull(responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.NO_CONTENT);
assertThat(responseEntity.getBody()).isNull();
}
@Test
public void badRequest() throws URISyntaxException {
ResponseEntity<Void> responseEntity = ResponseEntity.badRequest().build();
assertNotNull(responseEntity);
assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode());
assertNull(responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
assertThat(responseEntity.getBody()).isNull();
}
@Test
public void notFound() throws URISyntaxException {
ResponseEntity<Void> responseEntity = ResponseEntity.notFound().build();
assertNotNull(responseEntity);
assertEquals(HttpStatus.NOT_FOUND, responseEntity.getStatusCode());
assertNull(responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
assertThat(responseEntity.getBody()).isNull();
}
@Test
public void unprocessableEntity() throws URISyntaxException {
ResponseEntity<String> responseEntity = ResponseEntity.unprocessableEntity().body("error");
assertNotNull(responseEntity);
assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, responseEntity.getStatusCode());
assertEquals("error", responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.UNPROCESSABLE_ENTITY);
assertThat(responseEntity.getBody()).isEqualTo("error");
}
@Test
@@ -179,32 +173,30 @@ public class ResponseEntityTests {
contentType(contentType).
build();
assertNotNull(responseEntity);
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
HttpHeaders responseHeaders = responseEntity.getHeaders();
assertEquals("GET", responseHeaders.getFirst("Allow"));
assertEquals("Thu, 01 Jan 1970 00:00:12 GMT",
responseHeaders.getFirst("Last-Modified"));
assertEquals(location.toASCIIString(),
responseHeaders.getFirst("Location"));
assertEquals(String.valueOf(contentLength), responseHeaders.getFirst("Content-Length"));
assertEquals(contentType.toString(), responseHeaders.getFirst("Content-Type"));
assertThat(responseHeaders.getFirst("Allow")).isEqualTo("GET");
assertThat(responseHeaders.getFirst("Last-Modified")).isEqualTo("Thu, 01 Jan 1970 00:00:12 GMT");
assertThat(responseHeaders.getFirst("Location")).isEqualTo(location.toASCIIString());
assertThat(responseHeaders.getFirst("Content-Length")).isEqualTo(String.valueOf(contentLength));
assertThat(responseHeaders.getFirst("Content-Type")).isEqualTo(contentType.toString());
assertNull(responseEntity.getBody());
assertThat((Object) responseEntity.getBody()).isNull();
}
@Test
public void Etagheader() throws URISyntaxException {
ResponseEntity<Void> responseEntity = ResponseEntity.ok().eTag("\"foo\"").build();
assertEquals("\"foo\"", responseEntity.getHeaders().getETag());
assertThat(responseEntity.getHeaders().getETag()).isEqualTo("\"foo\"");
responseEntity = ResponseEntity.ok().eTag("foo").build();
assertEquals("\"foo\"", responseEntity.getHeaders().getETag());
assertThat(responseEntity.getHeaders().getETag()).isEqualTo("\"foo\"");
responseEntity = ResponseEntity.ok().eTag("W/\"foo\"").build();
assertEquals("W/\"foo\"", responseEntity.getHeaders().getETag());
assertThat(responseEntity.getHeaders().getETag()).isEqualTo("W/\"foo\"");
}
@Test
@@ -215,10 +207,10 @@ public class ResponseEntityTests {
ResponseEntity<Void> responseEntity = ResponseEntity.ok().headers(customHeaders).build();
HttpHeaders responseHeaders = responseEntity.getHeaders();
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertEquals(1, responseHeaders.size());
assertEquals(1, responseHeaders.get("X-CustomHeader").size());
assertEquals("vale", responseHeaders.getFirst("X-CustomHeader"));
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseHeaders.size()).isEqualTo(1);
assertThat(responseHeaders.get("X-CustomHeader").size()).isEqualTo(1);
assertThat(responseHeaders.getFirst("X-CustomHeader")).isEqualTo("vale");
}
@@ -229,9 +221,9 @@ public class ResponseEntityTests {
ResponseEntity<Void> responseEntityWithNullHeaders =
ResponseEntity.ok().headers(null).build();
assertEquals(HttpStatus.OK, responseEntityWithEmptyHeaders.getStatusCode());
assertTrue(responseEntityWithEmptyHeaders.getHeaders().isEmpty());
assertEquals(responseEntityWithEmptyHeaders.toString(), responseEntityWithNullHeaders.toString());
assertThat(responseEntityWithEmptyHeaders.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseEntityWithEmptyHeaders.getHeaders().isEmpty()).isTrue();
assertThat(responseEntityWithNullHeaders.toString()).isEqualTo(responseEntityWithEmptyHeaders.toString());
}
@Test
@@ -243,10 +235,10 @@ public class ResponseEntityTests {
.cacheControl(CacheControl.empty())
.body(entity);
assertNotNull(responseEntity);
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertFalse(responseEntity.getHeaders().containsKey(HttpHeaders.CACHE_CONTROL));
assertEquals(entity, responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseEntity.getHeaders().containsKey(HttpHeaders.CACHE_CONTROL)).isFalse();
assertThat((int) responseEntity.getBody()).isEqualTo((int) entity);
}
@Test
@@ -259,10 +251,10 @@ public class ResponseEntityTests {
mustRevalidate().proxyRevalidate().sMaxAge(30, TimeUnit.MINUTES))
.body(entity);
assertNotNull(responseEntity);
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertTrue(responseEntity.getHeaders().containsKey(HttpHeaders.CACHE_CONTROL));
assertEquals(entity, responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseEntity.getHeaders().containsKey(HttpHeaders.CACHE_CONTROL)).isTrue();
assertThat((int) responseEntity.getBody()).isEqualTo((int) entity);
String cacheControlHeader = responseEntity.getHeaders().getCacheControl();
assertThat(cacheControlHeader).isEqualTo(
"max-age=3600, must-revalidate, private, proxy-revalidate, s-maxage=1800");
@@ -277,10 +269,10 @@ public class ResponseEntityTests {
.cacheControl(CacheControl.noStore())
.body(entity);
assertNotNull(responseEntity);
assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
assertTrue(responseEntity.getHeaders().containsKey(HttpHeaders.CACHE_CONTROL));
assertEquals(entity, responseEntity.getBody());
assertThat(responseEntity).isNotNull();
assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(responseEntity.getHeaders().containsKey(HttpHeaders.CACHE_CONTROL)).isTrue();
assertThat((int) responseEntity.getBody()).isEqualTo((int) entity);
String cacheControlHeader = responseEntity.getHeaders().getCacheControl();
assertThat(cacheControlHeader).isEqualTo("no-store");
@@ -291,8 +283,8 @@ public class ResponseEntityTests {
Integer entity = 42;
ResponseEntity<Integer> responseEntity = ResponseEntity.status(200).body(entity);
assertEquals(200, responseEntity.getStatusCode().value());
assertEquals(entity, responseEntity.getBody());
assertThat(responseEntity.getStatusCode().value()).isEqualTo(200);
assertThat((int) responseEntity.getBody()).isEqualTo((int) entity);
}
@Test
@@ -300,8 +292,8 @@ public class ResponseEntityTests {
Integer entity = 42;
ResponseEntity<Integer> responseEntity = ResponseEntity.status(299).body(entity);
assertEquals(299, responseEntity.getStatusCodeValue());
assertEquals(entity, responseEntity.getBody());
assertThat(responseEntity.getStatusCodeValue()).isEqualTo(299);
assertThat((int) responseEntity.getBody()).isEqualTo((int) entity);
}
}

34
spring-web/src/test/java/org/springframework/http/client/AbstractAsyncHttpRequestFactoryTestCase.java
View File

@@ -36,10 +36,9 @@ import org.springframework.util.StreamUtils;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@SuppressWarnings("deprecation")
public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractMockWebServerTestCase {
@@ -69,12 +68,12 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractMo
public void status() throws Exception {
URI uri = new URI(baseUrl + "/status/notfound");
AsyncClientHttpRequest request = this.factory.createAsyncRequest(uri, HttpMethod.GET);
assertEquals("Invalid HTTP method", HttpMethod.GET, request.getMethod());
assertEquals("Invalid HTTP URI", uri, request.getURI());
assertThat(request.getMethod()).as("Invalid HTTP method").isEqualTo(HttpMethod.GET);
assertThat(request.getURI()).as("Invalid HTTP URI").isEqualTo(uri);
Future<ClientHttpResponse> futureResponse = request.executeAsync();
ClientHttpResponse response = futureResponse.get();
try {
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, response.getStatusCode());
assertThat(response.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.NOT_FOUND);
}
finally {
response.close();
@@ -85,14 +84,14 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractMo
public void statusCallback() throws Exception {
URI uri = new URI(baseUrl + "/status/notfound");
AsyncClientHttpRequest request = this.factory.createAsyncRequest(uri, HttpMethod.GET);
assertEquals("Invalid HTTP method", HttpMethod.GET, request.getMethod());
assertEquals("Invalid HTTP URI", uri, request.getURI());
assertThat(request.getMethod()).as("Invalid HTTP method").isEqualTo(HttpMethod.GET);
assertThat(request.getURI()).as("Invalid HTTP URI").isEqualTo(uri);
ListenableFuture<ClientHttpResponse> listenableFuture = request.executeAsync();
listenableFuture.addCallback(new ListenableFutureCallback<ClientHttpResponse>() {
@Override
public void onSuccess(ClientHttpResponse result) {
try {
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, result.getStatusCode());
assertThat(result.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.NOT_FOUND);
}
catch (IOException ex) {
throw new AssertionError(ex.getMessage(), ex);
@@ -105,7 +104,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractMo
});
ClientHttpResponse response = listenableFuture.get();
try {
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, response.getStatusCode());
assertThat(response.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.NOT_FOUND);
}
finally {
response.close();
@@ -115,7 +114,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractMo
@Test
public void echo() throws Exception {
AsyncClientHttpRequest request = this.factory.createAsyncRequest(new URI(baseUrl + "/echo"), HttpMethod.PUT);
assertEquals("Invalid HTTP method", HttpMethod.PUT, request.getMethod());
assertThat(request.getMethod()).as("Invalid HTTP method").isEqualTo(HttpMethod.PUT);
String headerName = "MyHeader";
String headerValue1 = "value1";
request.getHeaders().add(headerName, headerValue1);
@@ -135,12 +134,11 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractMo
Future<ClientHttpResponse> futureResponse = request.executeAsync();
ClientHttpResponse response = futureResponse.get();
try {
assertEquals("Invalid status code", HttpStatus.OK, response.getStatusCode());
assertTrue("Header not found", response.getHeaders().containsKey(headerName));
assertEquals("Header value not found", Arrays.asList(headerValue1, headerValue2),
response.getHeaders().get(headerName));
assertThat(response.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.OK);
assertThat(response.getHeaders().containsKey(headerName)).as("Header not found").isTrue();
assertThat(response.getHeaders().get(headerName)).as("Header value not found").isEqualTo(Arrays.asList(headerValue1, headerValue2));
byte[] result = FileCopyUtils.copyToByteArray(response.getBody());
assertTrue("Invalid body", Arrays.equals(body, result));
assertThat(Arrays.equals(body, result)).as("Invalid body").isTrue();
}
finally {
response.close();
@@ -209,8 +207,8 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractMo
}
Future<ClientHttpResponse> futureResponse = request.executeAsync();
response = futureResponse.get();
assertEquals("Invalid response status", HttpStatus.OK, response.getStatusCode());
assertEquals("Invalid method", path.toUpperCase(Locale.ENGLISH), request.getMethod().name());
assertThat(response.getStatusCode()).as("Invalid response status").isEqualTo(HttpStatus.OK);
assertThat(request.getMethod().name()).as("Invalid method").isEqualTo(path.toUpperCase(Locale.ENGLISH));
}
finally {
if (response != null) {
@@ -225,7 +223,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractMo
AsyncClientHttpRequest request = this.factory.createAsyncRequest(uri, HttpMethod.GET);
Future<ClientHttpResponse> futureResponse = request.executeAsync();
futureResponse.cancel(true);
assertTrue(futureResponse.isCancelled());
assertThat(futureResponse.isCancelled()).isTrue();
}

27
spring-web/src/test/java/org/springframework/http/client/AbstractHttpRequestFactoryTestCase.java
View File

@@ -33,11 +33,9 @@ import org.springframework.http.StreamingHttpOutputMessage;
import org.springframework.util.FileCopyUtils;
import org.springframework.util.StreamUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Arjen Poutsma
@@ -70,18 +68,18 @@ public abstract class AbstractHttpRequestFactoryTestCase extends AbstractMockWeb
public void status() throws Exception {
URI uri = new URI(baseUrl + "/status/notfound");
ClientHttpRequest request = factory.createRequest(uri, HttpMethod.GET);
assertEquals("Invalid HTTP method", HttpMethod.GET, request.getMethod());
assertEquals("Invalid HTTP URI", uri, request.getURI());
assertThat(request.getMethod()).as("Invalid HTTP method").isEqualTo(HttpMethod.GET);
assertThat(request.getURI()).as("Invalid HTTP URI").isEqualTo(uri);
try (ClientHttpResponse response = request.execute()) {
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, response.getStatusCode());
assertThat(response.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.NOT_FOUND);
}
}
@Test
public void echo() throws Exception {
ClientHttpRequest request = factory.createRequest(new URI(baseUrl + "/echo"), HttpMethod.PUT);
assertEquals("Invalid HTTP method", HttpMethod.PUT, request.getMethod());
assertThat(request.getMethod()).as("Invalid HTTP method").isEqualTo(HttpMethod.PUT);
String headerName = "MyHeader";
String headerValue1 = "value1";
@@ -100,12 +98,11 @@ public abstract class AbstractHttpRequestFactoryTestCase extends AbstractMockWeb
}
try (ClientHttpResponse response = request.execute()) {
assertEquals("Invalid status code", HttpStatus.OK, response.getStatusCode());
assertTrue("Header not found", response.getHeaders().containsKey(headerName));
assertEquals("Header value not found", Arrays.asList(headerValue1, headerValue2),
response.getHeaders().get(headerName));
assertThat(response.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.OK);
assertThat(response.getHeaders().containsKey(headerName)).as("Header not found").isTrue();
assertThat(response.getHeaders().get(headerName)).as("Header value not found").isEqualTo(Arrays.asList(headerValue1, headerValue2));
byte[] result = FileCopyUtils.copyToByteArray(response.getBody());
assertArrayEquals("Invalid body", body, result);
assertThat(Arrays.equals(body, result)).as("Invalid body").isTrue();
}
}
@@ -170,8 +167,8 @@ public abstract class AbstractHttpRequestFactoryTestCase extends AbstractMockWeb
}
}
response = request.execute();
assertEquals("Invalid response status", HttpStatus.OK, response.getStatusCode());
assertEquals("Invalid method", path.toUpperCase(Locale.ENGLISH), request.getMethod().name());
assertThat(response.getStatusCode()).as("Invalid response status").isEqualTo(HttpStatus.OK);
assertThat(request.getMethod().name()).as("Invalid method").isEqualTo(path.toUpperCase(Locale.ENGLISH));
}
finally {
if (response != null) {
@@ -186,7 +183,7 @@ public abstract class AbstractHttpRequestFactoryTestCase extends AbstractMockWeb
ClientHttpRequest request = factory.createRequest(uri, HttpMethod.GET);
try (ClientHttpResponse response = request.execute()) {
assertEquals("Invalid status code", HttpStatus.OK, response.getStatusCode());
assertThat(response.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.OK);
}
}

4
spring-web/src/test/java/org/springframework/http/client/BufferedSimpleHttpRequestFactoryTests.java
View File

@@ -27,7 +27,7 @@ import org.junit.Test;
import org.springframework.http.HttpMethod;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
public class BufferedSimpleHttpRequestFactoryTests extends AbstractHttpRequestFactoryTestCase {
@@ -70,7 +70,7 @@ public class BufferedSimpleHttpRequestFactoryTests extends AbstractHttpRequestFa
private void testRequestBodyAllowed(URL uri, String httpMethod, boolean allowed) throws IOException {
HttpURLConnection connection = new TestHttpURLConnection(uri);
((SimpleClientHttpRequestFactory) this.factory).prepareConnection(connection, httpMethod);
assertEquals(allowed, connection.getDoOutput());
assertThat(connection.getDoOutput()).isEqualTo(allowed);
}

23
spring-web/src/test/java/org/springframework/http/client/BufferingClientHttpRequestFactoryTests.java
View File

@@ -25,8 +25,7 @@ import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.util.FileCopyUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
public class BufferingClientHttpRequestFactoryTests extends AbstractHttpRequestFactoryTestCase {
@@ -38,7 +37,7 @@ public class BufferingClientHttpRequestFactoryTests extends AbstractHttpRequestF
@Test
public void repeatableRead() throws Exception {
ClientHttpRequest request = factory.createRequest(new URI(baseUrl + "/echo"), HttpMethod.PUT);
assertEquals("Invalid HTTP method", HttpMethod.PUT, request.getMethod());
assertThat(request.getMethod()).as("Invalid HTTP method").isEqualTo(HttpMethod.PUT);
String headerName = "MyHeader";
String headerValue1 = "value1";
request.getHeaders().add(headerName, headerValue1);
@@ -49,21 +48,19 @@ public class BufferingClientHttpRequestFactoryTests extends AbstractHttpRequestF
FileCopyUtils.copy(body, request.getBody());
ClientHttpResponse response = request.execute();
try {
assertEquals("Invalid status code", HttpStatus.OK, response.getStatusCode());
assertEquals("Invalid status code", HttpStatus.OK, response.getStatusCode());
assertThat(response.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.OK);
assertThat(response.getStatusCode()).as("Invalid status code").isEqualTo(HttpStatus.OK);
assertTrue("Header not found", response.getHeaders().containsKey(headerName));
assertTrue("Header not found", response.getHeaders().containsKey(headerName));
assertThat(response.getHeaders().containsKey(headerName)).as("Header not found").isTrue();
assertThat(response.getHeaders().containsKey(headerName)).as("Header not found").isTrue();
assertEquals("Header value not found", Arrays.asList(headerValue1, headerValue2),
response.getHeaders().get(headerName));
assertEquals("Header value not found", Arrays.asList(headerValue1, headerValue2),
response.getHeaders().get(headerName));
assertThat(response.getHeaders().get(headerName)).as("Header value not found").isEqualTo(Arrays.asList(headerValue1, headerValue2));
assertThat(response.getHeaders().get(headerName)).as("Header value not found").isEqualTo(Arrays.asList(headerValue1, headerValue2));
byte[] result = FileCopyUtils.copyToByteArray(response.getBody());
assertTrue("Invalid body", Arrays.equals(body, result));
assertThat(Arrays.equals(body, result)).as("Invalid body").isTrue();
FileCopyUtils.copyToByteArray(response.getBody());
assertTrue("Invalid body", Arrays.equals(body, result));
assertThat(Arrays.equals(body, result)).as("Invalid body").isTrue();
}
finally {
response.close();

16
spring-web/src/test/java/org/springframework/http/client/HttpComponentsAsyncClientHttpRequestFactoryTests.java
View File

@@ -26,9 +26,7 @@ import org.junit.Test;
import org.springframework.http.HttpMethod;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -59,8 +57,7 @@ public class HttpComponentsAsyncClientHttpRequestFactoryTests extends AbstractAs
HttpComponentsAsyncClientHttpRequest request = (HttpComponentsAsyncClientHttpRequest)
factory.createAsyncRequest(uri, HttpMethod.GET);
assertNull("No custom config should be set with a custom HttpAsyncClient",
request.getHttpContext().getAttribute(HttpClientContext.REQUEST_CONFIG));
assertThat(request.getHttpContext().getAttribute(HttpClientContext.REQUEST_CONFIG)).as("No custom config should be set with a custom HttpAsyncClient").isNull();
}
@Test
@@ -74,19 +71,18 @@ public class HttpComponentsAsyncClientHttpRequestFactoryTests extends AbstractAs
HttpComponentsAsyncClientHttpRequest request = (HttpComponentsAsyncClientHttpRequest)
factory.createAsyncRequest(uri, HttpMethod.GET);
assertNull("No custom config should be set with a custom HttpClient",
request.getHttpContext().getAttribute(HttpClientContext.REQUEST_CONFIG));
assertThat(request.getHttpContext().getAttribute(HttpClientContext.REQUEST_CONFIG)).as("No custom config should be set with a custom HttpClient").isNull();
factory.setConnectionRequestTimeout(4567);
HttpComponentsAsyncClientHttpRequest request2 = (HttpComponentsAsyncClientHttpRequest)
factory.createAsyncRequest(uri, HttpMethod.GET);
Object requestConfigAttribute = request2.getHttpContext().getAttribute(HttpClientContext.REQUEST_CONFIG);
assertNotNull(requestConfigAttribute);
assertThat(requestConfigAttribute).isNotNull();
RequestConfig requestConfig = (RequestConfig) requestConfigAttribute;
assertEquals(4567, requestConfig.getConnectionRequestTimeout());
assertThat(requestConfig.getConnectionRequestTimeout()).isEqualTo(4567);
// No way to access the request config of the HTTP client so no way to "merge" our customizations
assertEquals(-1, requestConfig.getConnectTimeout());
assertThat(requestConfig.getConnectTimeout()).isEqualTo(-1);
}
}

45
spring-web/src/test/java/org/springframework/http/client/HttpComponentsClientHttpRequestFactoryTests.java
View File

@@ -30,10 +30,7 @@ import org.junit.Test;
import org.springframework.http.HttpMethod;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.withSettings;
@@ -68,13 +65,12 @@ public class HttpComponentsClientHttpRequestFactoryTests extends AbstractHttpReq
hrf.createRequest(uri, HttpMethod.GET);
Object config = request.getHttpContext().getAttribute(HttpClientContext.REQUEST_CONFIG);
assertNotNull("Request config should be set", config);
assertTrue("Wrong request config type" + config.getClass().getName(),
RequestConfig.class.isInstance(config));
assertThat(config).as("Request config should be set").isNotNull();
assertThat(RequestConfig.class.isInstance(config)).as("Wrong request config type" + config.getClass().getName()).isTrue();
RequestConfig requestConfig = (RequestConfig) config;
assertEquals("Wrong custom connection timeout", 1234, requestConfig.getConnectTimeout());
assertEquals("Wrong custom connection request timeout", 4321, requestConfig.getConnectionRequestTimeout());
assertEquals("Wrong custom socket timeout", 4567, requestConfig.getSocketTimeout());
assertThat(requestConfig.getConnectTimeout()).as("Wrong custom connection timeout").isEqualTo(1234);
assertThat(requestConfig.getConnectionRequestTimeout()).as("Wrong custom connection request timeout").isEqualTo(4321);
assertThat(requestConfig.getSocketTimeout()).as("Wrong custom socket timeout").isEqualTo(4567);
}
@Test
@@ -86,14 +82,14 @@ public class HttpComponentsClientHttpRequestFactoryTests extends AbstractHttpReq
given(configurable.getConfig()).willReturn(defaultConfig);
HttpComponentsClientHttpRequestFactory hrf = new HttpComponentsClientHttpRequestFactory(client);
assertSame("Default client configuration is expected", defaultConfig, retrieveRequestConfig(hrf));
assertThat(retrieveRequestConfig(hrf)).as("Default client configuration is expected").isSameAs(defaultConfig);
hrf.setConnectionRequestTimeout(4567);
RequestConfig requestConfig = retrieveRequestConfig(hrf);
assertNotNull(requestConfig);
assertEquals(4567, requestConfig.getConnectionRequestTimeout());
assertThat(requestConfig).isNotNull();
assertThat(requestConfig.getConnectionRequestTimeout()).isEqualTo(4567);
// Default connection timeout merged
assertEquals(1234, requestConfig.getConnectTimeout());
assertThat(requestConfig.getConnectTimeout()).isEqualTo(1234);
}
@Test
@@ -109,9 +105,9 @@ public class HttpComponentsClientHttpRequestFactoryTests extends AbstractHttpReq
hrf.setConnectTimeout(5000);
RequestConfig requestConfig = retrieveRequestConfig(hrf);
assertEquals(5000, requestConfig.getConnectTimeout());
assertEquals(6789, requestConfig.getConnectionRequestTimeout());
assertEquals(-1, requestConfig.getSocketTimeout());
assertThat(requestConfig.getConnectTimeout()).isEqualTo(5000);
assertThat(requestConfig.getConnectionRequestTimeout()).isEqualTo(6789);
assertThat(requestConfig.getSocketTimeout()).isEqualTo(-1);
}
@Test
@@ -132,9 +128,9 @@ public class HttpComponentsClientHttpRequestFactoryTests extends AbstractHttpReq
hrf.setReadTimeout(5000);
RequestConfig requestConfig = retrieveRequestConfig(hrf);
assertEquals(-1, requestConfig.getConnectTimeout());
assertEquals(-1, requestConfig.getConnectionRequestTimeout());
assertEquals(5000, requestConfig.getSocketTimeout());
assertThat(requestConfig.getConnectTimeout()).isEqualTo(-1);
assertThat(requestConfig.getConnectionRequestTimeout()).isEqualTo(-1);
assertThat(requestConfig.getSocketTimeout()).isEqualTo(5000);
// Update the Http client so that it returns an updated config
RequestConfig updatedDefaultConfig = RequestConfig.custom()
@@ -142,9 +138,9 @@ public class HttpComponentsClientHttpRequestFactoryTests extends AbstractHttpReq
given(configurable.getConfig()).willReturn(updatedDefaultConfig);
hrf.setReadTimeout(7000);
RequestConfig requestConfig2 = retrieveRequestConfig(hrf);
assertEquals(1234, requestConfig2.getConnectTimeout());
assertEquals(-1, requestConfig2.getConnectionRequestTimeout());
assertEquals(7000, requestConfig2.getSocketTimeout());
assertThat(requestConfig2.getConnectTimeout()).isEqualTo(1234);
assertThat(requestConfig2.getConnectionRequestTimeout()).isEqualTo(-1);
assertThat(requestConfig2.getSocketTimeout()).isEqualTo(7000);
}
private RequestConfig retrieveRequestConfig(HttpComponentsClientHttpRequestFactory factory) throws Exception {
@@ -170,7 +166,8 @@ public class HttpComponentsClientHttpRequestFactoryTests extends AbstractHttpReq
private void testRequestBodyAllowed(URI uri, HttpMethod method, boolean allowed) {
HttpUriRequest request = ((HttpComponentsClientHttpRequestFactory) this.factory).createHttpUriRequest(method, uri);
assertEquals(allowed, request instanceof HttpEntityEnclosingRequest);
Object actual = request instanceof HttpEntityEnclosingRequest;
assertThat(actual).isEqualTo(allowed);
}
}

33
spring-web/src/test/java/org/springframework/http/client/InterceptingClientHttpRequestFactoryTests.java
View File

@@ -34,10 +34,7 @@ import org.springframework.http.HttpRequest;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.support.HttpRequestWrapper;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -65,11 +62,11 @@ public class InterceptingClientHttpRequestFactoryTests {
ClientHttpRequest request = requestFactory.createRequest(new URI("https://example.com"), HttpMethod.GET);
ClientHttpResponse response = request.execute();
assertTrue(((NoOpInterceptor) interceptors.get(0)).invoked);
assertTrue(((NoOpInterceptor) interceptors.get(1)).invoked);
assertTrue(((NoOpInterceptor) interceptors.get(2)).invoked);
assertTrue(requestMock.executed);
assertSame(responseMock, response);
assertThat(((NoOpInterceptor) interceptors.get(0)).invoked).isTrue();
assertThat(((NoOpInterceptor) interceptors.get(1)).invoked).isTrue();
assertThat(((NoOpInterceptor) interceptors.get(2)).invoked).isTrue();
assertThat(requestMock.executed).isTrue();
assertThat(response).isSameAs(responseMock);
}
@Test
@@ -89,9 +86,9 @@ public class InterceptingClientHttpRequestFactoryTests {
ClientHttpRequest request = requestFactory.createRequest(new URI("https://example.com"), HttpMethod.GET);
ClientHttpResponse response = request.execute();
assertFalse(((NoOpInterceptor) interceptors.get(1)).invoked);
assertFalse(requestMock.executed);
assertSame(responseMock, response);
assertThat(((NoOpInterceptor) interceptors.get(1)).invoked).isFalse();
assertThat(requestMock.executed).isFalse();
assertThat(response).isSameAs(responseMock);
}
@Test
@@ -114,9 +111,9 @@ public class InterceptingClientHttpRequestFactoryTests {
@Override
public ClientHttpResponse execute() throws IOException {
List<String> headerValues = getHeaders().get(headerName);
assertEquals(2, headerValues.size());
assertEquals(headerValue, headerValues.get(0));
assertEquals(otherValue, headerValues.get(1));
assertThat(headerValues.size()).isEqualTo(2);
assertThat(headerValues.get(0)).isEqualTo(headerValue);
assertThat(headerValues.get(1)).isEqualTo(otherValue);
return super.execute();
}
};
@@ -150,7 +147,7 @@ public class InterceptingClientHttpRequestFactoryTests {
requestFactoryMock = new RequestFactoryMock() {
@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
assertEquals(changedUri, uri);
assertThat(uri).isEqualTo(changedUri);
return super.createRequest(uri, httpMethod);
}
};
@@ -183,7 +180,7 @@ public class InterceptingClientHttpRequestFactoryTests {
requestFactoryMock = new RequestFactoryMock() {
@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
assertEquals(changedMethod, httpMethod);
assertThat(httpMethod).isEqualTo(changedMethod);
return super.createRequest(uri, httpMethod);
}
};
@@ -212,7 +209,7 @@ public class InterceptingClientHttpRequestFactoryTests {
ClientHttpRequest request = requestFactory.createRequest(new URI("https://example.com"), HttpMethod.GET);
request.execute();
assertTrue(Arrays.equals(changedBody, requestMock.body.toByteArray()));
assertThat(Arrays.equals(changedBody, requestMock.body.toByteArray())).isTrue();
}

51
spring-web/src/test/java/org/springframework/http/client/MultipartBodyBuilderTests.java
View File

@@ -30,8 +30,7 @@ import org.springframework.http.client.MultipartBodyBuilder.PublisherEntity;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -61,36 +60,34 @@ public class MultipartBodyBuilderTests {
MultiValueMap<String, HttpEntity<?>> result = builder.build();
assertEquals(5, result.size());
assertThat(result.size()).isEqualTo(5);
HttpEntity<?> resultEntity = result.getFirst("key");
assertNotNull(resultEntity);
assertEquals(multipartData, resultEntity.getBody());
assertEquals("bar", resultEntity.getHeaders().getFirst("foo"));
assertThat(resultEntity).isNotNull();
assertThat(resultEntity.getBody()).isEqualTo(multipartData);
assertThat(resultEntity.getHeaders().getFirst("foo")).isEqualTo("bar");
resultEntity = result.getFirst("logo");
assertNotNull(resultEntity);
assertEquals(logo, resultEntity.getBody());
assertEquals("qux", resultEntity.getHeaders().getFirst("baz"));
assertThat(resultEntity).isNotNull();
assertThat(resultEntity.getBody()).isEqualTo(logo);
assertThat(resultEntity.getHeaders().getFirst("baz")).isEqualTo("qux");
resultEntity = result.getFirst("entity");
assertNotNull(resultEntity);
assertEquals("body", resultEntity.getBody());
assertEquals("bar", resultEntity.getHeaders().getFirst("foo"));
assertEquals("qux", resultEntity.getHeaders().getFirst("baz"));
assertThat(resultEntity).isNotNull();
assertThat(resultEntity.getBody()).isEqualTo("body");
assertThat(resultEntity.getHeaders().getFirst("foo")).isEqualTo("bar");
assertThat(resultEntity.getHeaders().getFirst("baz")).isEqualTo("qux");
resultEntity = result.getFirst("publisherClass");
assertNotNull(resultEntity);
assertEquals(publisher, resultEntity.getBody());
assertEquals(ResolvableType.forClass(String.class),
((PublisherEntity<?,?>) resultEntity).getResolvableType());
assertEquals("qux", resultEntity.getHeaders().getFirst("baz"));
assertThat(resultEntity).isNotNull();
assertThat(resultEntity.getBody()).isEqualTo(publisher);
assertThat(((PublisherEntity<?, ?>) resultEntity).getResolvableType()).isEqualTo(ResolvableType.forClass(String.class));
assertThat(resultEntity.getHeaders().getFirst("baz")).isEqualTo("qux");
resultEntity = result.getFirst("publisherPtr");
assertNotNull(resultEntity);
assertEquals(publisher, resultEntity.getBody());
assertEquals(ResolvableType.forClass(String.class),
((PublisherEntity<?,?>) resultEntity).getResolvableType());
assertEquals("qux", resultEntity.getHeaders().getFirst("baz"));
assertThat(resultEntity).isNotNull();
assertThat(resultEntity.getBody()).isEqualTo(publisher);
assertThat(((PublisherEntity<?, ?>) resultEntity).getResolvableType()).isEqualTo(ResolvableType.forClass(String.class));
assertThat(resultEntity.getHeaders().getFirst("baz")).isEqualTo("qux");
}
@Test // SPR-16601
@@ -101,8 +98,8 @@ public class MultipartBodyBuilderTests {
builder.asyncPart("publisherClass", publisher, String.class).header("baz", "qux");
HttpEntity<?> entity = builder.build().getFirst("publisherClass");
assertNotNull(entity);
assertEquals(PublisherEntity.class, entity.getClass());
assertThat(entity).isNotNull();
assertThat(entity.getClass()).isEqualTo(PublisherEntity.class);
// Now build a new MultipartBodyBuilder, as BodyInserters.fromMultipartData would do...
@@ -110,8 +107,8 @@ public class MultipartBodyBuilderTests {
builder.part("publisherClass", entity);
entity = builder.build().getFirst("publisherClass");
assertNotNull(entity);
assertEquals(PublisherEntity.class, entity.getClass());
assertThat(entity).isNotNull();
assertThat(entity.getClass()).isEqualTo(PublisherEntity.class);
}
}

9
spring-web/src/test/java/org/springframework/http/client/SimpleClientHttpResponseTests.java
View File

@@ -27,7 +27,6 @@ import org.junit.Test;
import org.springframework.util.StreamUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willDoNothing;
@@ -56,7 +55,7 @@ public class SimpleClientHttpResponseTests {
assertThat(StreamUtils.copyToString(responseStream, StandardCharsets.UTF_8)).isEqualTo("Spring");
this.response.close();
assertTrue(is.isClosed());
assertThat(is.isClosed()).isTrue();
verify(this.connection, never()).disconnect();
}
@@ -74,7 +73,7 @@ public class SimpleClientHttpResponseTests {
this.response.close();
assertThat(is.available()).isEqualTo(0);
assertTrue(is.isClosed());
assertThat(is.isClosed()).isTrue();
verify(this.connection, never()).disconnect();
}
@@ -91,7 +90,7 @@ public class SimpleClientHttpResponseTests {
this.response.close();
assertThat(is.available()).isEqualTo(0);
assertTrue(is.isClosed());
assertThat(is.isClosed()).isTrue();
verify(this.connection, never()).disconnect();
}
@@ -117,7 +116,7 @@ public class SimpleClientHttpResponseTests {
this.response.close();
assertThat(is.available()).isEqualTo(0);
assertTrue(is.isClosed());
assertThat(is.isClosed()).isTrue();
verify(this.connection, never()).disconnect();
}

8
spring-web/src/test/java/org/springframework/http/client/StreamingSimpleClientHttpRequestFactoryTests.java
View File

@@ -28,7 +28,7 @@ import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -57,9 +57,9 @@ public class StreamingSimpleClientHttpRequestFactoryTests extends AbstractHttpRe
try {
ClientHttpRequest request = factory.createRequest(new URI(baseUrl + "/echo"), HttpMethod.GET);
response = request.execute();
assertEquals("Invalid response status", HttpStatus.OK, response.getStatusCode());
assertThat(response.getStatusCode()).as("Invalid response status").isEqualTo(HttpStatus.OK);
HttpHeaders responseHeaders = response.getHeaders();
assertEquals("Custom header invalid", headerValue, responseHeaders.getFirst(headerName));
assertThat(responseHeaders.getFirst(headerName)).as("Custom header invalid").isEqualTo(headerValue);
}
finally {
if (response != null) {
@@ -86,7 +86,7 @@ public class StreamingSimpleClientHttpRequestFactoryTests extends AbstractHttpRe
body.write(buffer);
}
response = request.execute();
assertEquals("Invalid response status", HttpStatus.OK, response.getStatusCode());
assertThat(response.getStatusCode()).as("Invalid response status").isEqualTo(HttpStatus.OK);
}
finally {
if (response != null) {

33
spring-web/src/test/java/org/springframework/http/client/reactive/ReactorResourceFactoryTests.java
View File

@@ -22,10 +22,7 @@ import reactor.netty.http.HttpResources;
import reactor.netty.resources.ConnectionProvider;
import reactor.netty.resources.LoopResources;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -50,13 +47,13 @@ public class ReactorResourceFactoryTests {
this.resourceFactory.afterPropertiesSet();
HttpResources globalResources = HttpResources.get();
assertSame(globalResources, this.resourceFactory.getConnectionProvider());
assertSame(globalResources, this.resourceFactory.getLoopResources());
assertFalse(globalResources.isDisposed());
assertThat(this.resourceFactory.getConnectionProvider()).isSameAs(globalResources);
assertThat(this.resourceFactory.getLoopResources()).isSameAs(globalResources);
assertThat(globalResources.isDisposed()).isFalse();
this.resourceFactory.destroy();
assertTrue(globalResources.isDisposed());
assertThat(globalResources.isDisposed()).isTrue();
}
@Test
@@ -67,7 +64,7 @@ public class ReactorResourceFactoryTests {
this.resourceFactory.addGlobalResourcesConsumer(httpResources -> invoked.set(true));
this.resourceFactory.afterPropertiesSet();
assertTrue(invoked.get());
assertThat(invoked.get()).isTrue();
this.resourceFactory.destroy();
}
@@ -80,17 +77,17 @@ public class ReactorResourceFactoryTests {
ConnectionProvider connectionProvider = this.resourceFactory.getConnectionProvider();
LoopResources loopResources = this.resourceFactory.getLoopResources();
assertNotSame(HttpResources.get(), connectionProvider);
assertNotSame(HttpResources.get(), loopResources);
assertThat(connectionProvider).isNotSameAs(HttpResources.get());
assertThat(loopResources).isNotSameAs(HttpResources.get());
// The below does not work since ConnectionPoolProvider simply checks if pool is empty.
// assertFalse(connectionProvider.isDisposed());
assertFalse(loopResources.isDisposed());
assertThat(loopResources.isDisposed()).isFalse();
this.resourceFactory.destroy();
assertTrue(connectionProvider.isDisposed());
assertTrue(loopResources.isDisposed());
assertThat(connectionProvider.isDisposed()).isTrue();
assertThat(loopResources.isDisposed()).isTrue();
}
@Test
@@ -104,8 +101,8 @@ public class ReactorResourceFactoryTests {
ConnectionProvider connectionProvider = this.resourceFactory.getConnectionProvider();
LoopResources loopResources = this.resourceFactory.getLoopResources();
assertSame(this.connectionProvider, connectionProvider);
assertSame(this.loopResources, loopResources);
assertThat(connectionProvider).isSameAs(this.connectionProvider);
assertThat(loopResources).isSameAs(this.loopResources);
verifyNoMoreInteractions(this.connectionProvider, this.loopResources);
@@ -128,8 +125,8 @@ public class ReactorResourceFactoryTests {
ConnectionProvider connectionProvider = this.resourceFactory.getConnectionProvider();
LoopResources loopResources = this.resourceFactory.getLoopResources();
assertSame(this.connectionProvider, connectionProvider);
assertSame(this.loopResources, loopResources);
assertThat(connectionProvider).isSameAs(this.connectionProvider);
assertThat(loopResources).isSameAs(this.loopResources);
verifyNoMoreInteractions(this.connectionProvider, this.loopResources);

8
spring-web/src/test/java/org/springframework/http/client/support/BasicAuthorizationInterceptorTests.java
View File

@@ -26,8 +26,8 @@ import org.springframework.http.client.ClientHttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
@@ -51,14 +51,14 @@ public class BasicAuthorizationInterceptorTests {
public void createWhenUsernameIsNullShouldUseEmptyUsername() throws Exception {
BasicAuthorizationInterceptor interceptor = new BasicAuthorizationInterceptor(
null, "password");
assertEquals("", new DirectFieldAccessor(interceptor).getPropertyValue("username"));
assertThat(new DirectFieldAccessor(interceptor).getPropertyValue("username")).isEqualTo("");
}
@Test
public void createWhenPasswordIsNullShouldUseEmptyPassword() throws Exception {
BasicAuthorizationInterceptor interceptor = new BasicAuthorizationInterceptor(
"username", null);
assertEquals("", new DirectFieldAccessor(interceptor).getPropertyValue("password"));
assertThat(new DirectFieldAccessor(interceptor).getPropertyValue("password")).isEqualTo("");
}
@Test
@@ -70,7 +70,7 @@ public class BasicAuthorizationInterceptorTests {
new BasicAuthorizationInterceptor("spring", "boot").intercept(request, body,
execution);
verify(execution).execute(request, body);
assertEquals("Basic c3ByaW5nOmJvb3Q=", request.getHeaders().getFirst("Authorization"));
assertThat(request.getHeaders().getFirst("Authorization")).isEqualTo("Basic c3ByaW5nOmJvb3Q=");
}
}

8
spring-web/src/test/java/org/springframework/http/client/support/ProxyFactoryBeanTests.java
View File

@@ -22,8 +22,8 @@ import java.net.Proxy;
import org.junit.Before;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
/**
* @author Arjen Poutsma
@@ -70,10 +70,10 @@ public class ProxyFactoryBeanTests {
Proxy result = factoryBean.getObject();
assertEquals(type, result.type());
assertThat(result.type()).isEqualTo(type);
InetSocketAddress address = (InetSocketAddress) result.address();
assertEquals(hostname, address.getHostName());
assertEquals(port, address.getPort());
assertThat(address.getHostName()).isEqualTo(hostname);
assertThat(address.getPort()).isEqualTo(port);
}
}

40
spring-web/src/test/java/org/springframework/http/codec/EncoderHttpMessageWriterTests.java
View File

@@ -44,9 +44,7 @@ import org.springframework.util.ReflectionUtils;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.springframework.core.ResolvableType.forClass;
@@ -86,7 +84,7 @@ public class EncoderHttpMessageWriterTests {
public void getWritableMediaTypes() {
configureEncoder(MimeTypeUtils.TEXT_HTML, MimeTypeUtils.TEXT_XML);
HttpMessageWriter<?> writer = new EncoderHttpMessageWriter<>(this.encoder);
assertEquals(Arrays.asList(TEXT_HTML, TEXT_XML), writer.getWritableMediaTypes());
assertThat(writer.getWritableMediaTypes()).isEqualTo(Arrays.asList(TEXT_HTML, TEXT_XML));
}
@Test
@@ -95,8 +93,8 @@ public class EncoderHttpMessageWriterTests {
HttpMessageWriter<?> writer = new EncoderHttpMessageWriter<>(this.encoder);
given(this.encoder.canEncode(forClass(String.class), TEXT_HTML)).willReturn(true);
assertTrue(writer.canWrite(forClass(String.class), TEXT_HTML));
assertFalse(writer.canWrite(forClass(String.class), TEXT_XML));
assertThat(writer.canWrite(forClass(String.class), TEXT_HTML)).isTrue();
assertThat(writer.canWrite(forClass(String.class), TEXT_XML)).isFalse();
}
@Test
@@ -105,8 +103,8 @@ public class EncoderHttpMessageWriterTests {
HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
writer.write(Flux.empty(), forClass(String.class), TEXT_PLAIN, this.response, NO_HINTS);
assertEquals(TEXT_PLAIN, response.getHeaders().getContentType());
assertEquals(TEXT_PLAIN, this.mediaTypeCaptor.getValue());
assertThat(response.getHeaders().getContentType()).isEqualTo(TEXT_PLAIN);
assertThat(this.mediaTypeCaptor.getValue()).isEqualTo(TEXT_PLAIN);
}
@Test
@@ -126,8 +124,8 @@ public class EncoderHttpMessageWriterTests {
HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
writer.write(Flux.empty(), forClass(String.class), negotiatedMediaType, this.response, NO_HINTS);
assertEquals(defaultContentType, this.response.getHeaders().getContentType());
assertEquals(defaultContentType, this.mediaTypeCaptor.getValue());
assertThat(this.response.getHeaders().getContentType()).isEqualTo(defaultContentType);
assertThat(this.mediaTypeCaptor.getValue()).isEqualTo(defaultContentType);
}
@Test
@@ -136,8 +134,8 @@ public class EncoderHttpMessageWriterTests {
HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
writer.write(Flux.empty(), forClass(String.class), TEXT_HTML, response, NO_HINTS);
assertEquals(new MediaType("text", "html", UTF_8), this.response.getHeaders().getContentType());
assertEquals(new MediaType("text", "html", UTF_8), this.mediaTypeCaptor.getValue());
assertThat(this.response.getHeaders().getContentType()).isEqualTo(new MediaType("text", "html", UTF_8));
assertThat(this.mediaTypeCaptor.getValue()).isEqualTo(new MediaType("text", "html", UTF_8));
}
@Test
@@ -147,8 +145,8 @@ public class EncoderHttpMessageWriterTests {
HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
writer.write(Flux.empty(), forClass(String.class), negotiatedMediaType, this.response, NO_HINTS);
assertEquals(negotiatedMediaType, this.response.getHeaders().getContentType());
assertEquals(negotiatedMediaType, this.mediaTypeCaptor.getValue());
assertThat(this.response.getHeaders().getContentType()).isEqualTo(negotiatedMediaType);
assertThat(this.mediaTypeCaptor.getValue()).isEqualTo(negotiatedMediaType);
}
@Test
@@ -160,8 +158,8 @@ public class EncoderHttpMessageWriterTests {
HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
writer.write(Flux.empty(), forClass(String.class), TEXT_PLAIN, this.response, NO_HINTS);
assertEquals(outputMessageMediaType, this.response.getHeaders().getContentType());
assertEquals(outputMessageMediaType, this.mediaTypeCaptor.getValue());
assertThat(this.response.getHeaders().getContentType()).isEqualTo(outputMessageMediaType);
assertThat(this.mediaTypeCaptor.getValue()).isEqualTo(outputMessageMediaType);
}
@Test
@@ -172,7 +170,7 @@ public class EncoderHttpMessageWriterTests {
HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
writer.write(Mono.just("body"), forClass(String.class), TEXT_PLAIN, this.response, NO_HINTS).block();
assertEquals(4, this.response.getHeaders().getContentLength());
assertThat(this.response.getHeaders().getContentLength()).isEqualTo(4);
}
@Test // gh-22952
@@ -192,7 +190,7 @@ public class EncoderHttpMessageWriterTests {
HttpMessageWriter<String> writer = new EncoderHttpMessageWriter<>(this.encoder);
writer.write(Mono.empty(), forClass(String.class), TEXT_PLAIN, this.response, NO_HINTS).block();
StepVerifier.create(this.response.getBody()).expectComplete();
assertEquals(0, this.response.getHeaders().getContentLength());
assertThat(this.response.getHeaders().getContentLength()).isEqualTo(0);
}
@Test // gh-22936
@@ -205,9 +203,9 @@ public class EncoderHttpMessageWriterTests {
Method method = ReflectionUtils.findMethod(writer.getClass(), "isStreamingMediaType", MediaType.class);
ReflectionUtils.makeAccessible(method);
assertTrue((Boolean) method.invoke(writer, streamingMediaType));
assertFalse((Boolean) method.invoke(writer, new MediaType(TEXT_PLAIN, Collections.singletonMap("streaming", "false"))));
assertFalse((Boolean) method.invoke(writer, TEXT_HTML));
assertThat((boolean) (Boolean) method.invoke(writer, streamingMediaType)).isTrue();
assertThat((boolean) (Boolean) method.invoke(writer, new MediaType(TEXT_PLAIN, Collections.singletonMap("streaming", "false")))).isFalse();
assertThat((boolean) (Boolean) method.invoke(writer, TEXT_HTML)).isFalse();
}
private void configureEncoder(MimeType... mimeTypes) {

53
spring-web/src/test/java/org/springframework/http/codec/FormHttpMessageReaderTests.java
View File

@@ -36,10 +36,7 @@ import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Sebastien Deleuze
@@ -51,29 +48,29 @@ public class FormHttpMessageReaderTests extends AbstractLeakCheckingTestCase {
@Test
public void canRead() {
assertTrue(this.reader.canRead(
assertThat(this.reader.canRead(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, String.class),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isTrue();
assertTrue(this.reader.canRead(
assertThat(this.reader.canRead(
ResolvableType.forInstance(new LinkedMultiValueMap<String, String>()),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isTrue();
assertFalse(this.reader.canRead(
assertThat(this.reader.canRead(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, Object.class),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isFalse();
assertFalse(this.reader.canRead(
assertThat(this.reader.canRead(
ResolvableType.forClassWithGenerics(MultiValueMap.class, Object.class, String.class),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isFalse();
assertFalse(this.reader.canRead(
assertThat(this.reader.canRead(
ResolvableType.forClassWithGenerics(Map.class, String.class, String.class),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isFalse();
assertFalse(this.reader.canRead(
assertThat(this.reader.canRead(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, String.class),
MediaType.MULTIPART_FORM_DATA));
MediaType.MULTIPART_FORM_DATA)).isFalse();
}
@Test
@@ -82,13 +79,13 @@ public class FormHttpMessageReaderTests extends AbstractLeakCheckingTestCase {
MockServerHttpRequest request = request(body);
MultiValueMap<String, String> result = this.reader.readMono(null, request, null).block();
assertEquals("Invalid result", 3, result.size());
assertEquals("Invalid result", "value 1", result.getFirst("name 1"));
assertThat(result.size()).as("Invalid result").isEqualTo(3);
assertThat(result.getFirst("name 1")).as("Invalid result").isEqualTo("value 1");
List<String> values = result.get("name 2");
assertEquals("Invalid result", 2, values.size());
assertEquals("Invalid result", "value 2+1", values.get(0));
assertEquals("Invalid result", "value 2+2", values.get(1));
assertNull("Invalid result", result.getFirst("name 3"));
assertThat(values.size()).as("Invalid result").isEqualTo(2);
assertThat(values.get(0)).as("Invalid result").isEqualTo("value 2+1");
assertThat(values.get(1)).as("Invalid result").isEqualTo("value 2+2");
assertThat(result.getFirst("name 3")).as("Invalid result").isNull();
}
@Test
@@ -97,13 +94,13 @@ public class FormHttpMessageReaderTests extends AbstractLeakCheckingTestCase {
MockServerHttpRequest request = request(body);
MultiValueMap<String, String> result = this.reader.read(null, request, null).single().block();
assertEquals("Invalid result", 3, result.size());
assertEquals("Invalid result", "value 1", result.getFirst("name 1"));
assertThat(result.size()).as("Invalid result").isEqualTo(3);
assertThat(result.getFirst("name 1")).as("Invalid result").isEqualTo("value 1");
List<String> values = result.get("name 2");
assertEquals("Invalid result", 2, values.size());
assertEquals("Invalid result", "value 2+1", values.get(0));
assertEquals("Invalid result", "value 2+2", values.get(1));
assertNull("Invalid result", result.getFirst("name 3"));
assertThat(values.size()).as("Invalid result").isEqualTo(2);
assertThat(values.get(0)).as("Invalid result").isEqualTo("value 2+1");
assertThat(values.get(1)).as("Invalid result").isEqualTo("value 2+2");
assertThat(result.getFirst("name 3")).as("Invalid result").isNull();
}
@Test

34
spring-web/src/test/java/org/springframework/http/codec/FormHttpMessageWriterTests.java
View File

@@ -35,9 +35,7 @@ import org.springframework.mock.http.server.reactive.test.MockServerHttpResponse
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Sebastien Deleuze
@@ -49,30 +47,30 @@ public class FormHttpMessageWriterTests extends AbstractLeakCheckingTestCase {
@Test
public void canWrite() {
assertTrue(this.writer.canWrite(
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, String.class),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isTrue();
// No generic information
assertTrue(this.writer.canWrite(
assertThat(this.writer.canWrite(
ResolvableType.forInstance(new LinkedMultiValueMap<String, String>()),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isTrue();
assertFalse(this.writer.canWrite(
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, Object.class),
null));
null)).isFalse();
assertFalse(this.writer.canWrite(
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(MultiValueMap.class, Object.class, String.class),
null));
null)).isFalse();
assertFalse(this.writer.canWrite(
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(Map.class, String.class, String.class),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isFalse();
assertFalse(this.writer.canWrite(
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, String.class),
MediaType.MULTIPART_FORM_DATA));
MediaType.MULTIPART_FORM_DATA)).isFalse();
}
@Test
@@ -91,15 +89,15 @@ public class FormHttpMessageWriterTests extends AbstractLeakCheckingTestCase {
.expectComplete()
.verify();
HttpHeaders headers = response.getHeaders();
assertEquals("application/x-www-form-urlencoded;charset=UTF-8", headers.getContentType().toString());
assertEquals(expected.length(), headers.getContentLength());
assertThat(headers.getContentType().toString()).isEqualTo("application/x-www-form-urlencoded;charset=UTF-8");
assertThat(headers.getContentLength()).isEqualTo(expected.length());
}
private Consumer<DataBuffer> stringConsumer(String expected) {
return dataBuffer -> {
String value = DataBufferTestUtils.dumpString(dataBuffer, StandardCharsets.UTF_8);
DataBufferUtils.release(dataBuffer);
assertEquals(expected, value);
assertThat(value).isEqualTo(expected);
};
}

3
spring-web/src/test/java/org/springframework/http/codec/ResourceHttpMessageWriterTests.java
View File

@@ -36,7 +36,6 @@ import org.springframework.util.MimeTypeUtils;
import org.springframework.util.StringUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertArrayEquals;
import static org.springframework.http.MediaType.TEXT_PLAIN;
import static org.springframework.mock.http.server.reactive.test.MockServerHttpRequest.get;
@@ -124,7 +123,7 @@ public class ResourceHttpMessageWriterTests {
"resource content.",
"--" + boundary + "--"
};
assertArrayEquals(expected, actualRanges);
assertThat(actualRanges).isEqualTo(expected);
})
.expectComplete()
.verify();

63
spring-web/src/test/java/org/springframework/http/codec/ServerSentEventHttpMessageReaderTests.java
View File

@@ -32,10 +32,7 @@ import org.springframework.http.MediaType;
import org.springframework.http.codec.json.Jackson2JsonDecoder;
import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link ServerSentEventHttpMessageReader}.
@@ -50,14 +47,14 @@ public class ServerSentEventHttpMessageReaderTests extends AbstractLeakCheckingT
@Test
public void cantRead() {
assertFalse(messageReader.canRead(ResolvableType.forClass(Object.class), new MediaType("foo", "bar")));
assertFalse(messageReader.canRead(ResolvableType.forClass(Object.class), null));
assertThat(messageReader.canRead(ResolvableType.forClass(Object.class), new MediaType("foo", "bar"))).isFalse();
assertThat(messageReader.canRead(ResolvableType.forClass(Object.class), null)).isFalse();
}
@Test
public void canRead() {
assertTrue(messageReader.canRead(ResolvableType.forClass(Object.class), new MediaType("text", "event-stream")));
assertTrue(messageReader.canRead(ResolvableType.forClass(ServerSentEvent.class), new MediaType("foo", "bar")));
assertThat(messageReader.canRead(ResolvableType.forClass(Object.class), new MediaType("text", "event-stream"))).isTrue();
assertThat(messageReader.canRead(ResolvableType.forClass(ServerSentEvent.class), new MediaType("foo", "bar"))).isTrue();
}
@Test
@@ -74,18 +71,18 @@ public class ServerSentEventHttpMessageReaderTests extends AbstractLeakCheckingT
StepVerifier.create(events)
.consumeNextWith(event -> {
assertEquals("c42", event.id());
assertEquals("foo", event.event());
assertEquals(Duration.ofMillis(123), event.retry());
assertEquals("bla\nbla bla\nbla bla bla", event.comment());
assertEquals("bar", event.data());
assertThat(event.id()).isEqualTo("c42");
assertThat(event.event()).isEqualTo("foo");
assertThat(event.retry()).isEqualTo(Duration.ofMillis(123));
assertThat(event.comment()).isEqualTo("bla\nbla bla\nbla bla bla");
assertThat(event.data()).isEqualTo("bar");
})
.consumeNextWith(event -> {
assertEquals("c43", event.id());
assertEquals("bar", event.event());
assertEquals(Duration.ofMillis(456), event.retry());
assertNull(event.comment());
assertEquals("baz", event.data());
assertThat(event.id()).isEqualTo("c43");
assertThat(event.event()).isEqualTo("bar");
assertThat(event.retry()).isEqualTo(Duration.ofMillis(456));
assertThat(event.comment()).isNull();
assertThat(event.data()).isEqualTo("baz");
})
.expectComplete()
.verify();
@@ -106,18 +103,18 @@ public class ServerSentEventHttpMessageReaderTests extends AbstractLeakCheckingT
StepVerifier.create(events)
.consumeNextWith(event -> {
assertEquals("c42", event.id());
assertEquals("foo", event.event());
assertEquals(Duration.ofMillis(123), event.retry());
assertEquals("bla\nbla bla\nbla bla bla", event.comment());
assertEquals("bar", event.data());
assertThat(event.id()).isEqualTo("c42");
assertThat(event.event()).isEqualTo("foo");
assertThat(event.retry()).isEqualTo(Duration.ofMillis(123));
assertThat(event.comment()).isEqualTo("bla\nbla bla\nbla bla bla");
assertThat(event.data()).isEqualTo("bar");
})
.consumeNextWith(event -> {
assertEquals("c43", event.id());
assertEquals("bar", event.event());
assertEquals(Duration.ofMillis(456), event.retry());
assertNull(event.comment());
assertEquals("baz", event.data());
assertThat(event.id()).isEqualTo("c43");
assertThat(event.event()).isEqualTo("bar");
assertThat(event.retry()).isEqualTo(Duration.ofMillis(456));
assertThat(event.comment()).isNull();
assertThat(event.data()).isEqualTo("baz");
})
.expectComplete()
.verify();
@@ -150,12 +147,12 @@ public class ServerSentEventHttpMessageReaderTests extends AbstractLeakCheckingT
StepVerifier.create(data)
.consumeNextWith(pojo -> {
assertEquals("foofoo", pojo.getFoo());
assertEquals("barbar", pojo.getBar());
assertThat(pojo.getFoo()).isEqualTo("foofoo");
assertThat(pojo.getBar()).isEqualTo("barbar");
})
.consumeNextWith(pojo -> {
assertEquals("foofoofoo", pojo.getFoo());
assertEquals("barbarbar", pojo.getBar());
assertThat(pojo.getFoo()).isEqualTo("foofoofoo");
assertThat(pojo.getBar()).isEqualTo("barbarbar");
})
.expectComplete()
.verify();
@@ -172,7 +169,7 @@ public class ServerSentEventHttpMessageReaderTests extends AbstractLeakCheckingT
.cast(String.class)
.block(Duration.ZERO);
assertEquals(body, actual);
assertThat(actual).isEqualTo(body);
}
@Test

24
spring-web/src/test/java/org/springframework/http/codec/ServerSentEventHttpMessageWriterTests.java
View File

@@ -39,9 +39,7 @@ import org.springframework.http.codec.json.Jackson2JsonEncoder;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.mock.http.server.reactive.test.MockServerHttpResponse;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.core.ResolvableType.forClass;
/**
@@ -70,15 +68,15 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll
@Test
public void canWrite() {
assertTrue(this.messageWriter.canWrite(forClass(Object.class), null));
assertFalse(this.messageWriter.canWrite(forClass(Object.class), new MediaType("foo", "bar")));
assertThat(this.messageWriter.canWrite(forClass(Object.class), null)).isTrue();
assertThat(this.messageWriter.canWrite(forClass(Object.class), new MediaType("foo", "bar"))).isFalse();
assertTrue(this.messageWriter.canWrite(null, MediaType.TEXT_EVENT_STREAM));
assertTrue(this.messageWriter.canWrite(forClass(ServerSentEvent.class), new MediaType("foo", "bar")));
assertThat(this.messageWriter.canWrite(null, MediaType.TEXT_EVENT_STREAM)).isTrue();
assertThat(this.messageWriter.canWrite(forClass(ServerSentEvent.class), new MediaType("foo", "bar"))).isTrue();
// SPR-15464
assertTrue(this.messageWriter.canWrite(ResolvableType.NONE, MediaType.TEXT_EVENT_STREAM));
assertFalse(this.messageWriter.canWrite(ResolvableType.NONE, new MediaType("foo", "bar")));
assertThat(this.messageWriter.canWrite(ResolvableType.NONE, MediaType.TEXT_EVENT_STREAM)).isTrue();
assertThat(this.messageWriter.canWrite(ResolvableType.NONE, new MediaType("foo", "bar"))).isFalse();
}
@Test
@@ -127,12 +125,12 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll
MediaType mediaType = new MediaType("text", "event-stream", charset);
testWrite(source, mediaType, outputMessage, String.class);
assertEquals(mediaType, outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).isEqualTo(mediaType);
StepVerifier.create(outputMessage.getBody())
.consumeNextWith(dataBuffer -> {
String value = DataBufferTestUtils.dumpString(dataBuffer, charset);
DataBufferUtils.release(dataBuffer);
assertEquals("data:\u00A3\n\n", value);
assertThat(value).isEqualTo("data:\u00A3\n\n");
})
.expectComplete()
.verify();
@@ -176,12 +174,12 @@ public class ServerSentEventHttpMessageWriterTests extends AbstractDataBufferAll
MediaType mediaType = new MediaType("text", "event-stream", charset);
testWrite(source, mediaType, outputMessage, Pojo.class);
assertEquals(mediaType, outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).isEqualTo(mediaType);
StepVerifier.create(outputMessage.getBody())
.consumeNextWith(dataBuffer -> {
String value = DataBufferTestUtils.dumpString(dataBuffer, charset);
DataBufferUtils.release(dataBuffer);
assertEquals("data:{\"foo\":\"foo\uD834\uDD1E\",\"bar\":\"bar\uD834\uDD1E\"}\n\n", value);
assertThat(value).isEqualTo("data:{\"foo\":\"foo\uD834\uDD1E\",\"bar\":\"bar\uD834\uDD1E\"}\n\n");
})
.expectComplete()
.verify();

11
spring-web/src/test/java/org/springframework/http/codec/cbor/Jackson2CborDecoderTests.java
View File

@@ -31,9 +31,8 @@ import org.springframework.http.codec.Pojo;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.MimeType;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.core.ResolvableType.forClass;
import static org.springframework.http.MediaType.APPLICATION_JSON;
@@ -59,11 +58,11 @@ public class Jackson2CborDecoderTests extends AbstractDecoderTestCase<Jackson2Cb
@Override
@Test
public void canDecode() {
assertTrue(decoder.canDecode(forClass(Pojo.class), CBOR_MIME_TYPE));
assertTrue(decoder.canDecode(forClass(Pojo.class), null));
assertThat(decoder.canDecode(forClass(Pojo.class), CBOR_MIME_TYPE)).isTrue();
assertThat(decoder.canDecode(forClass(Pojo.class), null)).isTrue();
assertFalse(decoder.canDecode(forClass(String.class), null));
assertFalse(decoder.canDecode(forClass(Pojo.class), APPLICATION_JSON));
assertThat(decoder.canDecode(forClass(String.class), null)).isFalse();
assertThat(decoder.canDecode(forClass(Pojo.class), APPLICATION_JSON)).isFalse();
}
@Override

18
spring-web/src/test/java/org/springframework/http/codec/cbor/Jackson2CborEncoderTests.java
View File

@@ -33,10 +33,8 @@ import org.springframework.http.codec.ServerSentEvent;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.MimeType;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.core.io.buffer.DataBufferUtils.release;
import static org.springframework.http.MediaType.APPLICATION_XML;
@@ -58,7 +56,7 @@ public class Jackson2CborEncoderTests extends AbstractLeakCheckingTestCase {
try {
Pojo actual = this.mapper.reader().forType(Pojo.class)
.readValue(DataBufferTestUtils.dumpBytes(dataBuffer));
assertEquals(expected, actual);
assertThat(actual).isEqualTo(expected);
release(dataBuffer);
}
catch (IOException ex) {
@@ -70,20 +68,20 @@ public class Jackson2CborEncoderTests extends AbstractLeakCheckingTestCase {
@Test
public void canEncode() {
ResolvableType pojoType = ResolvableType.forClass(Pojo.class);
assertTrue(this.encoder.canEncode(pojoType, CBOR_MIME_TYPE));
assertTrue(this.encoder.canEncode(pojoType, null));
assertThat(this.encoder.canEncode(pojoType, CBOR_MIME_TYPE)).isTrue();
assertThat(this.encoder.canEncode(pojoType, null)).isTrue();
// SPR-15464
assertTrue(this.encoder.canEncode(ResolvableType.NONE, null));
assertThat(this.encoder.canEncode(ResolvableType.NONE, null)).isTrue();
}
@Test
public void canNotEncode() {
assertFalse(this.encoder.canEncode(ResolvableType.forClass(String.class), null));
assertFalse(this.encoder.canEncode(ResolvableType.forClass(Pojo.class), APPLICATION_XML));
assertThat(this.encoder.canEncode(ResolvableType.forClass(String.class), null)).isFalse();
assertThat(this.encoder.canEncode(ResolvableType.forClass(Pojo.class), APPLICATION_XML)).isFalse();
ResolvableType sseType = ResolvableType.forClass(ServerSentEvent.class);
assertFalse(this.encoder.canEncode(sseType, CBOR_MIME_TYPE));
assertThat(this.encoder.canEncode(sseType, CBOR_MIME_TYPE)).isFalse();
}
@Test

31
spring-web/src/test/java/org/springframework/http/codec/json/Jackson2JsonDecoderTests.java
View File

@@ -47,11 +47,8 @@ import org.springframework.util.MimeType;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyMap;
import static java.util.Collections.singletonMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.springframework.core.ResolvableType.forClass;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.http.MediaType.APPLICATION_STREAM_JSON;
@@ -79,12 +76,12 @@ public class Jackson2JsonDecoderTests extends AbstractDecoderTestCase<Jackson2Js
@Override
@Test
public void canDecode() {
assertTrue(decoder.canDecode(forClass(Pojo.class), APPLICATION_JSON));
assertTrue(decoder.canDecode(forClass(Pojo.class), APPLICATION_STREAM_JSON));
assertTrue(decoder.canDecode(forClass(Pojo.class), null));
assertThat(decoder.canDecode(forClass(Pojo.class), APPLICATION_JSON)).isTrue();
assertThat(decoder.canDecode(forClass(Pojo.class), APPLICATION_STREAM_JSON)).isTrue();
assertThat(decoder.canDecode(forClass(Pojo.class), null)).isTrue();
assertFalse(decoder.canDecode(forClass(String.class), null));
assertFalse(decoder.canDecode(forClass(Pojo.class), APPLICATION_XML));
assertThat(decoder.canDecode(forClass(String.class), null)).isFalse();
assertThat(decoder.canDecode(forClass(Pojo.class), APPLICATION_XML)).isFalse();
}
@Test // SPR-15866
@@ -92,7 +89,7 @@ public class Jackson2JsonDecoderTests extends AbstractDecoderTestCase<Jackson2Js
MimeType textJavascript = new MimeType("text", "javascript", StandardCharsets.UTF_8);
Jackson2JsonDecoder decoder = new Jackson2JsonDecoder(new ObjectMapper(), textJavascript);
assertEquals(Collections.singletonList(textJavascript), decoder.getDecodableMimeTypes());
assertThat(decoder.getDecodableMimeTypes()).isEqualTo(Collections.singletonList(textJavascript));
}
@Test
@@ -149,9 +146,9 @@ public class Jackson2JsonDecoderTests extends AbstractDecoderTestCase<Jackson2Js
testDecode(input, elementType, step -> step
.consumeNextWith(o -> {
JacksonViewBean b = (JacksonViewBean) o;
assertEquals("with", b.getWithView1());
assertNull(b.getWithView2());
assertNull(b.getWithoutView());
assertThat(b.getWithView1()).isEqualTo("with");
assertThat(b.getWithView2()).isNull();
assertThat(b.getWithoutView()).isNull();
}), null, hints);
}
@@ -165,9 +162,9 @@ public class Jackson2JsonDecoderTests extends AbstractDecoderTestCase<Jackson2Js
testDecode(input, elementType, step -> step
.consumeNextWith(o -> {
JacksonViewBean b = (JacksonViewBean) o;
assertEquals("without", b.getWithoutView());
assertNull(b.getWithView1());
assertNull(b.getWithView2());
assertThat(b.getWithoutView()).isEqualTo("without");
assertThat(b.getWithView1()).isNull();
assertThat(b.getWithView2()).isNull();
})
.verifyComplete(), null, hints);
}
@@ -202,7 +199,7 @@ public class Jackson2JsonDecoderTests extends AbstractDecoderTestCase<Jackson2Js
Mono<DataBuffer> input = stringBuffer("{\"test\": 1}");
testDecode(input, TestObject.class, step -> step
.consumeNextWith(o -> assertEquals(1, o.getTest()))
.consumeNextWith(o -> assertThat(o.getTest()).isEqualTo(1))
.verifyComplete()
);
}

22
spring-web/src/test/java/org/springframework/http/codec/json/Jackson2JsonEncoderTests.java
View File

@@ -44,10 +44,8 @@ import org.springframework.util.MimeType;
import org.springframework.util.MimeTypeUtils;
import static java.util.Collections.singletonMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.http.MediaType.APPLICATION_OCTET_STREAM;
import static org.springframework.http.MediaType.APPLICATION_STREAM_JSON;
@@ -68,15 +66,15 @@ public class Jackson2JsonEncoderTests extends AbstractEncoderTestCase<Jackson2Js
@Test
public void canEncode() {
ResolvableType pojoType = ResolvableType.forClass(Pojo.class);
assertTrue(this.encoder.canEncode(pojoType, APPLICATION_JSON));
assertTrue(this.encoder.canEncode(pojoType, APPLICATION_STREAM_JSON));
assertTrue(this.encoder.canEncode(pojoType, null));
assertThat(this.encoder.canEncode(pojoType, APPLICATION_JSON)).isTrue();
assertThat(this.encoder.canEncode(pojoType, APPLICATION_STREAM_JSON)).isTrue();
assertThat(this.encoder.canEncode(pojoType, null)).isTrue();
// SPR-15464
assertTrue(this.encoder.canEncode(ResolvableType.NONE, null));
assertThat(this.encoder.canEncode(ResolvableType.NONE, null)).isTrue();
// SPR-15910
assertFalse(this.encoder.canEncode(ResolvableType.forClass(Object.class), APPLICATION_OCTET_STREAM));
assertThat(this.encoder.canEncode(ResolvableType.forClass(Object.class), APPLICATION_OCTET_STREAM)).isFalse();
}
@Override
@@ -98,7 +96,7 @@ public class Jackson2JsonEncoderTests extends AbstractEncoderTestCase<Jackson2Js
MimeType textJavascript = new MimeType("text", "javascript", StandardCharsets.UTF_8);
Jackson2JsonEncoder encoder = new Jackson2JsonEncoder(new ObjectMapper(), textJavascript);
assertEquals(Collections.singletonList(textJavascript), encoder.getEncodableMimeTypes());
assertThat(encoder.getEncodableMimeTypes()).isEqualTo(Collections.singletonList(textJavascript));
}
@Test
@@ -112,11 +110,11 @@ public class Jackson2JsonEncoderTests extends AbstractEncoderTestCase<Jackson2Js
@Test
public void canNotEncode() {
assertFalse(this.encoder.canEncode(ResolvableType.forClass(String.class), null));
assertFalse(this.encoder.canEncode(ResolvableType.forClass(Pojo.class), APPLICATION_XML));
assertThat(this.encoder.canEncode(ResolvableType.forClass(String.class), null)).isFalse();
assertThat(this.encoder.canEncode(ResolvableType.forClass(Pojo.class), APPLICATION_XML)).isFalse();
ResolvableType sseType = ResolvableType.forClass(ServerSentEvent.class);
assertFalse(this.encoder.canEncode(sseType, APPLICATION_JSON));
assertThat(this.encoder.canEncode(sseType, APPLICATION_JSON)).isFalse();
}
@Test

13
spring-web/src/test/java/org/springframework/http/codec/json/Jackson2SmileDecoderTests.java
View File

@@ -31,8 +31,7 @@ import org.springframework.http.codec.Pojo;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.MimeType;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.core.ResolvableType.forClass;
import static org.springframework.http.MediaType.APPLICATION_JSON;
@@ -59,12 +58,12 @@ public class Jackson2SmileDecoderTests extends AbstractDecoderTestCase<Jackson2S
@Override
@Test
public void canDecode() {
assertTrue(decoder.canDecode(forClass(Pojo.class), SMILE_MIME_TYPE));
assertTrue(decoder.canDecode(forClass(Pojo.class), STREAM_SMILE_MIME_TYPE));
assertTrue(decoder.canDecode(forClass(Pojo.class), null));
assertThat(decoder.canDecode(forClass(Pojo.class), SMILE_MIME_TYPE)).isTrue();
assertThat(decoder.canDecode(forClass(Pojo.class), STREAM_SMILE_MIME_TYPE)).isTrue();
assertThat(decoder.canDecode(forClass(Pojo.class), null)).isTrue();
assertFalse(decoder.canDecode(forClass(String.class), null));
assertFalse(decoder.canDecode(forClass(Pojo.class), APPLICATION_JSON));
assertThat(decoder.canDecode(forClass(String.class), null)).isFalse();
assertThat(decoder.canDecode(forClass(Pojo.class), APPLICATION_JSON)).isFalse();
}
@Override

22
spring-web/src/test/java/org/springframework/http/codec/json/Jackson2SmileEncoderTests.java
View File

@@ -36,9 +36,7 @@ import org.springframework.http.codec.ServerSentEvent;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.util.MimeType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.core.io.buffer.DataBufferUtils.release;
import static org.springframework.http.MediaType.APPLICATION_XML;
@@ -66,7 +64,7 @@ public class Jackson2SmileEncoderTests extends AbstractEncoderTestCase<Jackson2S
try {
Pojo actual = this.mapper.reader().forType(Pojo.class)
.readValue(DataBufferTestUtils.dumpBytes(dataBuffer));
assertEquals(expected, actual);
assertThat(actual).isEqualTo(expected);
release(dataBuffer);
}
catch (IOException ex) {
@@ -80,21 +78,21 @@ public class Jackson2SmileEncoderTests extends AbstractEncoderTestCase<Jackson2S
@Test
public void canEncode() {
ResolvableType pojoType = ResolvableType.forClass(Pojo.class);
assertTrue(this.encoder.canEncode(pojoType, SMILE_MIME_TYPE));
assertTrue(this.encoder.canEncode(pojoType, STREAM_SMILE_MIME_TYPE));
assertTrue(this.encoder.canEncode(pojoType, null));
assertThat(this.encoder.canEncode(pojoType, SMILE_MIME_TYPE)).isTrue();
assertThat(this.encoder.canEncode(pojoType, STREAM_SMILE_MIME_TYPE)).isTrue();
assertThat(this.encoder.canEncode(pojoType, null)).isTrue();
// SPR-15464
assertTrue(this.encoder.canEncode(ResolvableType.NONE, null));
assertThat(this.encoder.canEncode(ResolvableType.NONE, null)).isTrue();
}
@Test
public void canNotEncode() {
assertFalse(this.encoder.canEncode(ResolvableType.forClass(String.class), null));
assertFalse(this.encoder.canEncode(ResolvableType.forClass(Pojo.class), APPLICATION_XML));
assertThat(this.encoder.canEncode(ResolvableType.forClass(String.class), null)).isFalse();
assertThat(this.encoder.canEncode(ResolvableType.forClass(Pojo.class), APPLICATION_XML)).isFalse();
ResolvableType sseType = ResolvableType.forClass(ServerSentEvent.class);
assertFalse(this.encoder.canEncode(sseType, SMILE_MIME_TYPE));
assertThat(this.encoder.canEncode(sseType, SMILE_MIME_TYPE)).isFalse();
}
@Override
@@ -143,7 +141,7 @@ public class Jackson2SmileEncoderTests extends AbstractEncoderTestCase<Jackson2S
try {
Object actual = this.mapper.reader().forType(expectedType)
.readValue(dataBuffer.asInputStream());
assertEquals(expected, actual);
assertThat(actual).isEqualTo(expected);
}
catch (IOException e) {
throw new UncheckedIOException(e);

23
spring-web/src/test/java/org/springframework/http/codec/multipart/DefaultMultipartMessageReaderTests.java
View File

@@ -35,8 +35,7 @@ import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
import static java.util.Collections.emptyMap;
import static java.util.Collections.singletonMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.core.ResolvableType.forClass;
/**
@@ -54,7 +53,7 @@ public class DefaultMultipartMessageReaderTests extends AbstractDataBufferAlloca
@Test
public void canRead() {
assertTrue(this.reader.canRead(forClass(Part.class), MediaType.MULTIPART_FORM_DATA));
assertThat(this.reader.canRead(forClass(Part.class), MediaType.MULTIPART_FORM_DATA)).isTrue();
}
@Test
@@ -66,7 +65,7 @@ public class DefaultMultipartMessageReaderTests extends AbstractDataBufferAlloca
StepVerifier.create(result)
.consumeNextWith(part -> {
assertTrue(part.headers().isEmpty());
assertThat(part.headers().isEmpty()).isTrue();
part.content().subscribe(DataBufferUtils::release);
})
.verifyComplete();
@@ -129,18 +128,20 @@ public class DefaultMultipartMessageReaderTests extends AbstractDataBufferAlloca
}
private static void testBrowserFormField(Part part, String name, String value) {
assertTrue(part instanceof FormFieldPart);
assertEquals(name, part.name());
boolean condition = part instanceof FormFieldPart;
assertThat(condition).isTrue();
assertThat(part.name()).isEqualTo(name);
FormFieldPart formField = (FormFieldPart) part;
assertEquals(value, formField.value());
assertThat(formField.value()).isEqualTo(value);
}
private static void testBrowserFile(Part part, String name, String filename, String contents) {
try {
assertTrue(part instanceof FilePart);
assertEquals(name, part.name());
boolean condition = part instanceof FilePart;
assertThat(condition).isTrue();
assertThat(part.name()).isEqualTo(name);
FilePart file = (FilePart) part;
assertEquals(filename, file.filename());
assertThat(file.filename()).isEqualTo(filename);
Path tempFile = Files.createTempFile("DefaultMultipartMessageReaderTests", null);
@@ -170,7 +171,7 @@ public class DefaultMultipartMessageReaderTests extends AbstractDataBufferAlloca
private static void verifyContents(Path tempFile, String contents) {
try {
String result = String.join("", Files.readAllLines(tempFile));
assertEquals(contents, result);
assertThat(result).isEqualTo(contents);
}
catch (IOException ex) {
throw new AssertionError(ex);

115
spring-web/src/test/java/org/springframework/http/codec/multipart/MultipartHttpMessageWriterTests.java
View File

@@ -44,10 +44,7 @@ import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
import org.springframework.mock.http.server.reactive.test.MockServerHttpResponse;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -65,19 +62,19 @@ public class MultipartHttpMessageWriterTests extends AbstractLeakCheckingTestCas
@Test
public void canWrite() {
assertTrue(this.writer.canWrite(
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, Object.class),
MediaType.MULTIPART_FORM_DATA));
assertTrue(this.writer.canWrite(
MediaType.MULTIPART_FORM_DATA)).isTrue();
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, String.class),
MediaType.MULTIPART_FORM_DATA));
MediaType.MULTIPART_FORM_DATA)).isTrue();
assertFalse(this.writer.canWrite(
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(Map.class, String.class, Object.class),
MediaType.MULTIPART_FORM_DATA));
assertTrue(this.writer.canWrite(
MediaType.MULTIPART_FORM_DATA)).isFalse();
assertThat(this.writer.canWrite(
ResolvableType.forClassWithGenerics(MultiValueMap.class, String.class, Object.class),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isTrue();
}
@Test
@@ -114,53 +111,58 @@ public class MultipartHttpMessageWriterTests extends AbstractLeakCheckingTestCas
this.writer.write(result, null, MediaType.MULTIPART_FORM_DATA, this.response, hints).block(Duration.ofSeconds(5));
MultiValueMap<String, Part> requestParts = parse(hints);
assertEquals(7, requestParts.size());
assertThat(requestParts.size()).isEqualTo(7);
Part part = requestParts.getFirst("name 1");
assertTrue(part instanceof FormFieldPart);
assertEquals("name 1", part.name());
assertEquals("value 1", ((FormFieldPart) part).value());
boolean condition4 = part instanceof FormFieldPart;
assertThat(condition4).isTrue();
assertThat(part.name()).isEqualTo("name 1");
assertThat(((FormFieldPart) part).value()).isEqualTo("value 1");
List<Part> parts2 = requestParts.get("name 2");
assertEquals(2, parts2.size());
assertThat(parts2.size()).isEqualTo(2);
part = parts2.get(0);
assertTrue(part instanceof FormFieldPart);
assertEquals("name 2", part.name());
assertEquals("value 2+1", ((FormFieldPart) part).value());
boolean condition3 = part instanceof FormFieldPart;
assertThat(condition3).isTrue();
assertThat(part.name()).isEqualTo("name 2");
assertThat(((FormFieldPart) part).value()).isEqualTo("value 2+1");
part = parts2.get(1);
assertTrue(part instanceof FormFieldPart);
assertEquals("name 2", part.name());
assertEquals("value 2+2", ((FormFieldPart) part).value());
boolean condition2 = part instanceof FormFieldPart;
assertThat(condition2).isTrue();
assertThat(part.name()).isEqualTo("name 2");
assertThat(((FormFieldPart) part).value()).isEqualTo("value 2+2");
part = requestParts.getFirst("logo");
assertTrue(part instanceof FilePart);
assertEquals("logo", part.name());
assertEquals("logo.jpg", ((FilePart) part).filename());
assertEquals(MediaType.IMAGE_JPEG, part.headers().getContentType());
assertEquals(logo.getFile().length(), part.headers().getContentLength());
boolean condition1 = part instanceof FilePart;
assertThat(condition1).isTrue();
assertThat(part.name()).isEqualTo("logo");
assertThat(((FilePart) part).filename()).isEqualTo("logo.jpg");
assertThat(part.headers().getContentType()).isEqualTo(MediaType.IMAGE_JPEG);
assertThat(part.headers().getContentLength()).isEqualTo(logo.getFile().length());
part = requestParts.getFirst("utf8");
assertTrue(part instanceof FilePart);
assertEquals("utf8", part.name());
assertEquals("Hall\u00F6le.jpg", ((FilePart) part).filename());
assertEquals(MediaType.IMAGE_JPEG, part.headers().getContentType());
assertEquals(utf8.getFile().length(), part.headers().getContentLength());
boolean condition = part instanceof FilePart;
assertThat(condition).isTrue();
assertThat(part.name()).isEqualTo("utf8");
assertThat(((FilePart) part).filename()).isEqualTo("Hall\u00F6le.jpg");
assertThat(part.headers().getContentType()).isEqualTo(MediaType.IMAGE_JPEG);
assertThat(part.headers().getContentLength()).isEqualTo(utf8.getFile().length());
part = requestParts.getFirst("json");
assertEquals("json", part.name());
assertEquals(MediaType.APPLICATION_JSON, part.headers().getContentType());
assertThat(part.name()).isEqualTo("json");
assertThat(part.headers().getContentType()).isEqualTo(MediaType.APPLICATION_JSON);
String value = decodeToString(part);
assertEquals("{\"bar\":\"bar\"}", value);
assertThat(value).isEqualTo("{\"bar\":\"bar\"}");
part = requestParts.getFirst("publisher");
assertEquals("publisher", part.name());
assertThat(part.name()).isEqualTo("publisher");
value = decodeToString(part);
assertEquals("foobarbaz", value);
assertThat(value).isEqualTo("foobarbaz");
part = requestParts.getFirst("partPublisher");
assertEquals("partPublisher", part.name());
assertThat(part.name()).isEqualTo("partPublisher");
value = decodeToString(part);
assertEquals("AaBbCc", value);
assertThat(value).isEqualTo("AaBbCc");
}
@SuppressWarnings("ConstantConditions")
@@ -185,14 +187,15 @@ public class MultipartHttpMessageWriterTests extends AbstractLeakCheckingTestCas
this.writer.write(result, null, MediaType.MULTIPART_FORM_DATA, this.response, hints).block();
MultiValueMap<String, Part> requestParts = parse(hints);
assertEquals(1, requestParts.size());
assertThat(requestParts.size()).isEqualTo(1);
Part part = requestParts.getFirst("logo");
assertEquals("logo", part.name());
assertTrue(part instanceof FilePart);
assertEquals("logo.jpg", ((FilePart) part).filename());
assertEquals(MediaType.IMAGE_JPEG, part.headers().getContentType());
assertEquals(logo.getFile().length(), part.headers().getContentLength());
assertThat(part.name()).isEqualTo("logo");
boolean condition = part instanceof FilePart;
assertThat(condition).isTrue();
assertThat(((FilePart) part).filename()).isEqualTo("logo.jpg");
assertThat(part.headers().getContentType()).isEqualTo(MediaType.IMAGE_JPEG);
assertThat(part.headers().getContentLength()).isEqualTo(logo.getFile().length());
}
@Test // SPR-16402
@@ -235,22 +238,24 @@ public class MultipartHttpMessageWriterTests extends AbstractLeakCheckingTestCas
this.response, hints).block();
MultiValueMap<String, Part> requestParts = parse(hints);
assertEquals(2, requestParts.size());
assertThat(requestParts.size()).isEqualTo(2);
Part part = requestParts.getFirst("resource");
assertTrue(part instanceof FilePart);
assertEquals("spring.jpg", ((FilePart) part).filename());
assertEquals(logo.getFile().length(), part.headers().getContentLength());
boolean condition1 = part instanceof FilePart;
assertThat(condition1).isTrue();
assertThat(((FilePart) part).filename()).isEqualTo("spring.jpg");
assertThat(part.headers().getContentLength()).isEqualTo(logo.getFile().length());
part = requestParts.getFirst("buffers");
assertTrue(part instanceof FilePart);
assertEquals("buffers.jpg", ((FilePart) part).filename());
assertEquals(logo.getFile().length(), part.headers().getContentLength());
boolean condition = part instanceof FilePart;
assertThat(condition).isTrue();
assertThat(((FilePart) part).filename()).isEqualTo("buffers.jpg");
assertThat(part.headers().getContentLength()).isEqualTo(logo.getFile().length());
}
private MultiValueMap<String, Part> parse(Map<String, Object> hints) {
MediaType contentType = this.response.getHeaders().getContentType();
assertNotNull("No boundary found", contentType.getParameter("boundary"));
assertThat(contentType.getParameter("boundary")).as("No boundary found").isNotNull();
// see if Synchronoss NIO Multipart can read what we wrote
SynchronossPartHttpMessageReader synchronossReader = new SynchronossPartHttpMessageReader();
@@ -266,7 +271,7 @@ public class MultipartHttpMessageWriterTests extends AbstractLeakCheckingTestCas
MultiValueMap<String, Part> result = reader.readMono(elementType, request, hints)
.block(Duration.ofSeconds(5));
assertNotNull(result);
assertThat(result).isNotNull();
return result;
}

59
spring-web/src/test/java/org/springframework/http/codec/multipart/SynchronossPartHttpMessageReaderTests.java
View File

@@ -39,10 +39,7 @@ import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
import org.springframework.util.MultiValueMap;
import static java.util.Collections.emptyMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.core.ResolvableType.forClassWithGenerics;
import static org.springframework.http.HttpHeaders.CONTENT_TYPE;
import static org.springframework.http.MediaType.MULTIPART_FORM_DATA;
@@ -61,25 +58,25 @@ public class SynchronossPartHttpMessageReaderTests {
@Test
public void canRead() {
assertTrue(this.reader.canRead(
assertThat(this.reader.canRead(
forClassWithGenerics(MultiValueMap.class, String.class, Part.class),
MediaType.MULTIPART_FORM_DATA));
MediaType.MULTIPART_FORM_DATA)).isTrue();
assertFalse(this.reader.canRead(
assertThat(this.reader.canRead(
forClassWithGenerics(MultiValueMap.class, String.class, Object.class),
MediaType.MULTIPART_FORM_DATA));
MediaType.MULTIPART_FORM_DATA)).isFalse();
assertFalse(this.reader.canRead(
assertThat(this.reader.canRead(
forClassWithGenerics(MultiValueMap.class, String.class, String.class),
MediaType.MULTIPART_FORM_DATA));
MediaType.MULTIPART_FORM_DATA)).isFalse();
assertFalse(this.reader.canRead(
assertThat(this.reader.canRead(
forClassWithGenerics(Map.class, String.class, String.class),
MediaType.MULTIPART_FORM_DATA));
MediaType.MULTIPART_FORM_DATA)).isFalse();
assertFalse(this.reader.canRead(
assertThat(this.reader.canRead(
forClassWithGenerics(MultiValueMap.class, String.class, Part.class),
MediaType.APPLICATION_FORM_URLENCODED));
MediaType.APPLICATION_FORM_URLENCODED)).isFalse();
}
@Test
@@ -87,24 +84,26 @@ public class SynchronossPartHttpMessageReaderTests {
ServerHttpRequest request = generateMultipartRequest();
ResolvableType elementType = forClassWithGenerics(MultiValueMap.class, String.class, Part.class);
MultiValueMap<String, Part> parts = this.reader.readMono(elementType, request, emptyMap()).block();
assertEquals(2, parts.size());
assertThat(parts.size()).isEqualTo(2);
assertTrue(parts.containsKey("fooPart"));
assertThat(parts.containsKey("fooPart")).isTrue();
Part part = parts.getFirst("fooPart");
assertTrue(part instanceof FilePart);
assertEquals("fooPart", part.name());
assertEquals("foo.txt", ((FilePart) part).filename());
boolean condition1 = part instanceof FilePart;
assertThat(condition1).isTrue();
assertThat(part.name()).isEqualTo("fooPart");
assertThat(((FilePart) part).filename()).isEqualTo("foo.txt");
DataBuffer buffer = DataBufferUtils.join(part.content()).block();
assertEquals(12, buffer.readableByteCount());
assertThat(buffer.readableByteCount()).isEqualTo(12);
byte[] byteContent = new byte[12];
buffer.read(byteContent);
assertEquals("Lorem Ipsum.", new String(byteContent));
assertThat(new String(byteContent)).isEqualTo("Lorem Ipsum.");
assertTrue(parts.containsKey("barPart"));
assertThat(parts.containsKey("barPart")).isTrue();
part = parts.getFirst("barPart");
assertTrue(part instanceof FormFieldPart);
assertEquals("barPart", part.name());
assertEquals("bar", ((FormFieldPart) part).value());
boolean condition = part instanceof FormFieldPart;
assertThat(condition).isTrue();
assertThat(part.name()).isEqualTo("barPart");
assertThat(((FormFieldPart) part).value()).isEqualTo("bar");
}
@Test // SPR-16545
@@ -113,16 +112,16 @@ public class SynchronossPartHttpMessageReaderTests {
ResolvableType elementType = forClassWithGenerics(MultiValueMap.class, String.class, Part.class);
MultiValueMap<String, Part> parts = this.reader.readMono(elementType, request, emptyMap()).block();
assertNotNull(parts);
assertThat(parts).isNotNull();
FilePart part = (FilePart) parts.getFirst("fooPart");
assertNotNull(part);
assertThat(part).isNotNull();
File dest = new File(System.getProperty("java.io.tmpdir") + "/" + part.filename());
part.transferTo(dest).block(Duration.ofSeconds(5));
assertTrue(dest.exists());
assertEquals(12, dest.length());
assertTrue(dest.delete());
assertThat(dest.exists()).isTrue();
assertThat(dest.length()).isEqualTo(12);
assertThat(dest.delete()).isTrue();
}
@Test

13
spring-web/src/test/java/org/springframework/http/codec/protobuf/ProtobufDecoderTests.java
View File

@@ -36,9 +36,8 @@ import org.springframework.protobuf.SecondMsg;
import org.springframework.util.MimeType;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.core.ResolvableType.forClass;
import static org.springframework.core.io.buffer.DataBufferUtils.release;
@@ -73,11 +72,11 @@ public class ProtobufDecoderTests extends AbstractDecoderTestCase<ProtobufDecode
@Override
@Test
public void canDecode() {
assertTrue(this.decoder.canDecode(forClass(Msg.class), null));
assertTrue(this.decoder.canDecode(forClass(Msg.class), PROTOBUF_MIME_TYPE));
assertTrue(this.decoder.canDecode(forClass(Msg.class), MediaType.APPLICATION_OCTET_STREAM));
assertFalse(this.decoder.canDecode(forClass(Msg.class), MediaType.APPLICATION_JSON));
assertFalse(this.decoder.canDecode(forClass(Object.class), PROTOBUF_MIME_TYPE));
assertThat(this.decoder.canDecode(forClass(Msg.class), null)).isTrue();
assertThat(this.decoder.canDecode(forClass(Msg.class), PROTOBUF_MIME_TYPE)).isTrue();
assertThat(this.decoder.canDecode(forClass(Msg.class), MediaType.APPLICATION_OCTET_STREAM)).isTrue();
assertThat(this.decoder.canDecode(forClass(Msg.class), MediaType.APPLICATION_JSON)).isFalse();
assertThat(this.decoder.canDecode(forClass(Object.class), PROTOBUF_MIME_TYPE)).isFalse();
}
@Override

18
spring-web/src/test/java/org/springframework/http/codec/protobuf/ProtobufEncoderTests.java
View File

@@ -33,9 +33,7 @@ import org.springframework.protobuf.Msg;
import org.springframework.protobuf.SecondMsg;
import org.springframework.util.MimeType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.core.ResolvableType.forClass;
/**
@@ -61,11 +59,11 @@ public class ProtobufEncoderTests extends AbstractEncoderTestCase<ProtobufEncode
@Override
@Test
public void canEncode() {
assertTrue(this.encoder.canEncode(forClass(Msg.class), null));
assertTrue(this.encoder.canEncode(forClass(Msg.class), PROTOBUF_MIME_TYPE));
assertTrue(this.encoder.canEncode(forClass(Msg.class), MediaType.APPLICATION_OCTET_STREAM));
assertFalse(this.encoder.canEncode(forClass(Msg.class), MediaType.APPLICATION_JSON));
assertFalse(this.encoder.canEncode(forClass(Object.class), PROTOBUF_MIME_TYPE));
assertThat(this.encoder.canEncode(forClass(Msg.class), null)).isTrue();
assertThat(this.encoder.canEncode(forClass(Msg.class), PROTOBUF_MIME_TYPE)).isTrue();
assertThat(this.encoder.canEncode(forClass(Msg.class), MediaType.APPLICATION_OCTET_STREAM)).isTrue();
assertThat(this.encoder.canEncode(forClass(Msg.class), MediaType.APPLICATION_JSON)).isFalse();
assertThat(this.encoder.canEncode(forClass(Object.class), PROTOBUF_MIME_TYPE)).isFalse();
}
@Override
@@ -76,7 +74,7 @@ public class ProtobufEncoderTests extends AbstractEncoderTestCase<ProtobufEncode
testEncodeAll(input, Msg.class, step -> step
.consumeNextWith(dataBuffer -> {
try {
assertEquals(this.msg1, Msg.parseFrom(dataBuffer.asInputStream()));
assertThat(Msg.parseFrom(dataBuffer.asInputStream())).isEqualTo(this.msg1);
}
catch (IOException ex) {
@@ -102,7 +100,7 @@ public class ProtobufEncoderTests extends AbstractEncoderTestCase<ProtobufEncode
protected final Consumer<DataBuffer> expect(Msg msg) {
return dataBuffer -> {
try {
assertEquals(msg, Msg.parseDelimitedFrom(dataBuffer.asInputStream()));
assertThat(Msg.parseDelimitedFrom(dataBuffer.asInputStream())).isEqualTo(msg);
}
catch (IOException ex) {

76
spring-web/src/test/java/org/springframework/http/codec/support/ClientCodecConfigurerTests.java
View File

@@ -59,10 +59,7 @@ import org.springframework.http.codec.xml.Jaxb2XmlDecoder;
import org.springframework.http.codec.xml.Jaxb2XmlEncoder;
import org.springframework.util.MimeTypeUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.core.ResolvableType.forClass;
/**
@@ -80,17 +77,18 @@ public class ClientCodecConfigurerTests {
@Test
public void defaultReaders() {
List<HttpMessageReader<?>> readers = this.configurer.getReaders();
assertEquals(12, readers.size());
assertEquals(ByteArrayDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ByteBufferDecoder.class, getNextDecoder(readers).getClass());
assertEquals(DataBufferDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ResourceHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertThat(readers.size()).isEqualTo(12);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ByteArrayDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ByteBufferDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(DataBufferDecoder.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(ResourceHttpMessageReader.class);
assertStringDecoder(getNextDecoder(readers), true);
assertEquals(ProtobufDecoder.class, getNextDecoder(readers).getClass());
assertEquals(FormHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass()); // SPR-16804
assertEquals(Jackson2JsonDecoder.class, getNextDecoder(readers).getClass());
assertEquals(Jackson2SmileDecoder.class, getNextDecoder(readers).getClass());
assertEquals(Jaxb2XmlDecoder.class, getNextDecoder(readers).getClass());
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ProtobufDecoder.class);
// SPR-16804
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(FormHttpMessageReader.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jackson2JsonDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jackson2SmileDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jaxb2XmlDecoder.class);
assertSseReader(readers);
assertStringDecoder(getNextDecoder(readers), false);
}
@@ -98,17 +96,17 @@ public class ClientCodecConfigurerTests {
@Test
public void defaultWriters() {
List<HttpMessageWriter<?>> writers = this.configurer.getWriters();
assertEquals(11, writers.size());
assertEquals(ByteArrayEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ByteBufferEncoder.class, getNextEncoder(writers).getClass());
assertEquals(DataBufferEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ResourceHttpMessageWriter.class, writers.get(index.getAndIncrement()).getClass());
assertThat(writers.size()).isEqualTo(11);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(ByteArrayEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(ByteBufferEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(DataBufferEncoder.class);
assertThat(writers.get(index.getAndIncrement()).getClass()).isEqualTo(ResourceHttpMessageWriter.class);
assertStringEncoder(getNextEncoder(writers), true);
assertEquals(MultipartHttpMessageWriter.class, writers.get(this.index.getAndIncrement()).getClass());
assertEquals(ProtobufHttpMessageWriter.class, writers.get(index.getAndIncrement()).getClass());
assertEquals(Jackson2JsonEncoder.class, getNextEncoder(writers).getClass());
assertEquals(Jackson2SmileEncoder.class, getNextEncoder(writers).getClass());
assertEquals(Jaxb2XmlEncoder.class, getNextEncoder(writers).getClass());
assertThat(writers.get(this.index.getAndIncrement()).getClass()).isEqualTo(MultipartHttpMessageWriter.class);
assertThat(writers.get(index.getAndIncrement()).getClass()).isEqualTo(ProtobufHttpMessageWriter.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jackson2JsonEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jackson2SmileEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jaxb2XmlEncoder.class);
assertStringEncoder(getNextEncoder(writers), false);
}
@@ -117,52 +115,54 @@ public class ClientCodecConfigurerTests {
Jackson2JsonDecoder decoder = new Jackson2JsonDecoder();
this.configurer.defaultCodecs().jackson2JsonDecoder(decoder);
assertSame(decoder, this.configurer.getReaders().stream()
assertThat(this.configurer.getReaders().stream()
.filter(reader -> ServerSentEventHttpMessageReader.class.equals(reader.getClass()))
.map(reader -> (ServerSentEventHttpMessageReader) reader)
.findFirst()
.map(ServerSentEventHttpMessageReader::getDecoder)
.filter(e -> e == decoder).orElse(null));
.filter(e -> e == decoder).orElse(null)).isSameAs(decoder);
}
private Decoder<?> getNextDecoder(List<HttpMessageReader<?>> readers) {
HttpMessageReader<?> reader = readers.get(this.index.getAndIncrement());
assertEquals(DecoderHttpMessageReader.class, reader.getClass());
assertThat(reader.getClass()).isEqualTo(DecoderHttpMessageReader.class);
return ((DecoderHttpMessageReader<?>) reader).getDecoder();
}
private Encoder<?> getNextEncoder(List<HttpMessageWriter<?>> writers) {
HttpMessageWriter<?> writer = writers.get(this.index.getAndIncrement());
assertEquals(EncoderHttpMessageWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(EncoderHttpMessageWriter.class);
return ((EncoderHttpMessageWriter<?>) writer).getEncoder();
}
@SuppressWarnings("unchecked")
private void assertStringDecoder(Decoder<?> decoder, boolean textOnly) {
assertEquals(StringDecoder.class, decoder.getClass());
assertTrue(decoder.canDecode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN));
assertEquals(!textOnly, decoder.canDecode(forClass(String.class), MediaType.TEXT_EVENT_STREAM));
assertThat(decoder.getClass()).isEqualTo(StringDecoder.class);
assertThat(decoder.canDecode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN)).isTrue();
Object expected = !textOnly;
assertThat(decoder.canDecode(forClass(String.class), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
Flux<String> decoded = (Flux<String>) decoder.decode(
Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))),
ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap());
assertEquals(Arrays.asList("line1", "line2"), decoded.collectList().block(Duration.ZERO));
assertThat(decoded.collectList().block(Duration.ZERO)).isEqualTo(Arrays.asList("line1", "line2"));
}
private void assertStringEncoder(Encoder<?> encoder, boolean textOnly) {
assertEquals(CharSequenceEncoder.class, encoder.getClass());
assertTrue(encoder.canEncode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN));
assertEquals(!textOnly, encoder.canEncode(forClass(String.class), MediaType.TEXT_EVENT_STREAM));
assertThat(encoder.getClass()).isEqualTo(CharSequenceEncoder.class);
assertThat(encoder.canEncode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN)).isTrue();
Object expected = !textOnly;
assertThat(encoder.canEncode(forClass(String.class), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
}
private void assertSseReader(List<HttpMessageReader<?>> readers) {
HttpMessageReader<?> reader = readers.get(this.index.getAndIncrement());
assertEquals(ServerSentEventHttpMessageReader.class, reader.getClass());
assertThat(reader.getClass()).isEqualTo(ServerSentEventHttpMessageReader.class);
Decoder<?> decoder = ((ServerSentEventHttpMessageReader) reader).getDecoder();
assertNotNull(decoder);
assertEquals(Jackson2JsonDecoder.class, decoder.getClass());
assertThat(decoder).isNotNull();
assertThat(decoder.getClass()).isEqualTo(Jackson2JsonDecoder.class);
}
}

150
spring-web/src/test/java/org/springframework/http/codec/support/CodecConfigurerTests.java
View File

@@ -53,9 +53,7 @@ import org.springframework.http.codec.xml.Jaxb2XmlDecoder;
import org.springframework.http.codec.xml.Jaxb2XmlEncoder;
import org.springframework.util.MimeTypeUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
@@ -75,33 +73,33 @@ public class CodecConfigurerTests {
@Test
public void defaultReaders() {
List<HttpMessageReader<?>> readers = this.configurer.getReaders();
assertEquals(11, readers.size());
assertEquals(ByteArrayDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ByteBufferDecoder.class, getNextDecoder(readers).getClass());
assertEquals(DataBufferDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ResourceHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertThat(readers.size()).isEqualTo(11);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ByteArrayDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ByteBufferDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(DataBufferDecoder.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(ResourceHttpMessageReader.class);
assertStringDecoder(getNextDecoder(readers), true);
assertEquals(ProtobufDecoder.class, getNextDecoder(readers).getClass());
assertEquals(FormHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertEquals(Jackson2JsonDecoder.class, getNextDecoder(readers).getClass());
assertEquals(Jackson2SmileDecoder.class, getNextDecoder(readers).getClass());
assertEquals(Jaxb2XmlDecoder.class, getNextDecoder(readers).getClass());
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ProtobufDecoder.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(FormHttpMessageReader.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jackson2JsonDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jackson2SmileDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jaxb2XmlDecoder.class);
assertStringDecoder(getNextDecoder(readers), false);
}
@Test
public void defaultWriters() {
List<HttpMessageWriter<?>> writers = this.configurer.getWriters();
assertEquals(10, writers.size());
assertEquals(ByteArrayEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ByteBufferEncoder.class, getNextEncoder(writers).getClass());
assertEquals(DataBufferEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ResourceHttpMessageWriter.class, writers.get(index.getAndIncrement()).getClass());
assertThat(writers.size()).isEqualTo(10);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(ByteArrayEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(ByteBufferEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(DataBufferEncoder.class);
assertThat(writers.get(index.getAndIncrement()).getClass()).isEqualTo(ResourceHttpMessageWriter.class);
assertStringEncoder(getNextEncoder(writers), true);
assertEquals(ProtobufHttpMessageWriter.class, writers.get(index.getAndIncrement()).getClass());
assertEquals(Jackson2JsonEncoder.class, getNextEncoder(writers).getClass());
assertEquals(Jackson2SmileEncoder.class, getNextEncoder(writers).getClass());
assertEquals(Jaxb2XmlEncoder.class, getNextEncoder(writers).getClass());
assertThat(writers.get(index.getAndIncrement()).getClass()).isEqualTo(ProtobufHttpMessageWriter.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jackson2JsonEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jackson2SmileEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jaxb2XmlEncoder.class);
assertStringEncoder(getNextEncoder(writers), false);
}
@@ -127,22 +125,22 @@ public class CodecConfigurerTests {
List<HttpMessageReader<?>> readers = this.configurer.getReaders();
assertEquals(15, readers.size());
assertSame(customDecoder1, getNextDecoder(readers));
assertSame(customReader1, readers.get(this.index.getAndIncrement()));
assertEquals(ByteArrayDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ByteBufferDecoder.class, getNextDecoder(readers).getClass());
assertEquals(DataBufferDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ResourceHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertEquals(StringDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ProtobufDecoder.class, getNextDecoder(readers).getClass());
assertEquals(FormHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertSame(customDecoder2, getNextDecoder(readers));
assertSame(customReader2, readers.get(this.index.getAndIncrement()));
assertEquals(Jackson2JsonDecoder.class, getNextDecoder(readers).getClass());
assertEquals(Jackson2SmileDecoder.class, getNextDecoder(readers).getClass());
assertEquals(Jaxb2XmlDecoder.class, getNextDecoder(readers).getClass());
assertEquals(StringDecoder.class, getNextDecoder(readers).getClass());
assertThat(readers.size()).isEqualTo(15);
assertThat(getNextDecoder(readers)).isSameAs(customDecoder1);
assertThat(readers.get(this.index.getAndIncrement())).isSameAs(customReader1);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ByteArrayDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ByteBufferDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(DataBufferDecoder.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(ResourceHttpMessageReader.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(StringDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ProtobufDecoder.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(FormHttpMessageReader.class);
assertThat(getNextDecoder(readers)).isSameAs(customDecoder2);
assertThat(readers.get(this.index.getAndIncrement())).isSameAs(customReader2);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jackson2JsonDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jackson2SmileDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jaxb2XmlDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(StringDecoder.class);
}
@Test
@@ -167,21 +165,21 @@ public class CodecConfigurerTests {
List<HttpMessageWriter<?>> writers = this.configurer.getWriters();
assertEquals(14, writers.size());
assertSame(customEncoder1, getNextEncoder(writers));
assertSame(customWriter1, writers.get(this.index.getAndIncrement()));
assertEquals(ByteArrayEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ByteBufferEncoder.class, getNextEncoder(writers).getClass());
assertEquals(DataBufferEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ResourceHttpMessageWriter.class, writers.get(index.getAndIncrement()).getClass());
assertEquals(CharSequenceEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ProtobufHttpMessageWriter.class, writers.get(index.getAndIncrement()).getClass());
assertSame(customEncoder2, getNextEncoder(writers));
assertSame(customWriter2, writers.get(this.index.getAndIncrement()));
assertEquals(Jackson2JsonEncoder.class, getNextEncoder(writers).getClass());
assertEquals(Jackson2SmileEncoder.class, getNextEncoder(writers).getClass());
assertEquals(Jaxb2XmlEncoder.class, getNextEncoder(writers).getClass());
assertEquals(CharSequenceEncoder.class, getNextEncoder(writers).getClass());
assertThat(writers.size()).isEqualTo(14);
assertThat(getNextEncoder(writers)).isSameAs(customEncoder1);
assertThat(writers.get(this.index.getAndIncrement())).isSameAs(customWriter1);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(ByteArrayEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(ByteBufferEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(DataBufferEncoder.class);
assertThat(writers.get(index.getAndIncrement()).getClass()).isEqualTo(ResourceHttpMessageWriter.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(CharSequenceEncoder.class);
assertThat(writers.get(index.getAndIncrement()).getClass()).isEqualTo(ProtobufHttpMessageWriter.class);
assertThat(getNextEncoder(writers)).isSameAs(customEncoder2);
assertThat(writers.get(this.index.getAndIncrement())).isSameAs(customWriter2);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jackson2JsonEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jackson2SmileEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jaxb2XmlEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(CharSequenceEncoder.class);
}
@Test
@@ -208,11 +206,11 @@ public class CodecConfigurerTests {
List<HttpMessageReader<?>> readers = this.configurer.getReaders();
assertEquals(4, readers.size());
assertSame(customDecoder1, getNextDecoder(readers));
assertSame(customReader1, readers.get(this.index.getAndIncrement()));
assertSame(customDecoder2, getNextDecoder(readers));
assertSame(customReader2, readers.get(this.index.getAndIncrement()));
assertThat(readers.size()).isEqualTo(4);
assertThat(getNextDecoder(readers)).isSameAs(customDecoder1);
assertThat(readers.get(this.index.getAndIncrement())).isSameAs(customReader1);
assertThat(getNextDecoder(readers)).isSameAs(customDecoder2);
assertThat(readers.get(this.index.getAndIncrement())).isSameAs(customReader2);
}
@Test
@@ -239,11 +237,11 @@ public class CodecConfigurerTests {
List<HttpMessageWriter<?>> writers = this.configurer.getWriters();
assertEquals(4, writers.size());
assertSame(customEncoder1, getNextEncoder(writers));
assertSame(customWriter1, writers.get(this.index.getAndIncrement()));
assertSame(customEncoder2, getNextEncoder(writers));
assertSame(customWriter2, writers.get(this.index.getAndIncrement()));
assertThat(writers.size()).isEqualTo(4);
assertThat(getNextEncoder(writers)).isSameAs(customEncoder1);
assertThat(writers.get(this.index.getAndIncrement())).isSameAs(customWriter1);
assertThat(getNextEncoder(writers)).isSameAs(customEncoder2);
assertThat(writers.get(this.index.getAndIncrement())).isSameAs(customWriter2);
}
@Test
@@ -272,44 +270,46 @@ public class CodecConfigurerTests {
private Decoder<?> getNextDecoder(List<HttpMessageReader<?>> readers) {
HttpMessageReader<?> reader = readers.get(this.index.getAndIncrement());
assertEquals(DecoderHttpMessageReader.class, reader.getClass());
assertThat(reader.getClass()).isEqualTo(DecoderHttpMessageReader.class);
return ((DecoderHttpMessageReader<?>) reader).getDecoder();
}
private Encoder<?> getNextEncoder(List<HttpMessageWriter<?>> writers) {
HttpMessageWriter<?> writer = writers.get(this.index.getAndIncrement());
assertEquals(EncoderHttpMessageWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(EncoderHttpMessageWriter.class);
return ((EncoderHttpMessageWriter<?>) writer).getEncoder();
}
private void assertStringDecoder(Decoder<?> decoder, boolean textOnly) {
assertEquals(StringDecoder.class, decoder.getClass());
assertTrue(decoder.canDecode(ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN));
assertEquals(!textOnly, decoder.canDecode(ResolvableType.forClass(String.class), MediaType.TEXT_EVENT_STREAM));
assertThat(decoder.getClass()).isEqualTo(StringDecoder.class);
assertThat(decoder.canDecode(ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN)).isTrue();
Object expected = !textOnly;
assertThat(decoder.canDecode(ResolvableType.forClass(String.class), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
}
private void assertStringEncoder(Encoder<?> encoder, boolean textOnly) {
assertEquals(CharSequenceEncoder.class, encoder.getClass());
assertTrue(encoder.canEncode(ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN));
assertEquals(!textOnly, encoder.canEncode(ResolvableType.forClass(String.class), MediaType.TEXT_EVENT_STREAM));
assertThat(encoder.getClass()).isEqualTo(CharSequenceEncoder.class);
assertThat(encoder.canEncode(ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN)).isTrue();
Object expected = !textOnly;
assertThat(encoder.canEncode(ResolvableType.forClass(String.class), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
}
private void assertDecoderInstance(Decoder<?> decoder) {
assertSame(decoder, this.configurer.getReaders().stream()
assertThat(this.configurer.getReaders().stream()
.filter(writer -> writer instanceof DecoderHttpMessageReader)
.map(writer -> ((DecoderHttpMessageReader<?>) writer).getDecoder())
.filter(e -> decoder.getClass().equals(e.getClass()))
.findFirst()
.filter(e -> e == decoder).orElse(null));
.filter(e -> e == decoder).orElse(null)).isSameAs(decoder);
}
private void assertEncoderInstance(Encoder<?> encoder) {
assertSame(encoder, this.configurer.getWriters().stream()
assertThat(this.configurer.getWriters().stream()
.filter(writer -> writer instanceof EncoderHttpMessageWriter)
.map(writer -> ((EncoderHttpMessageWriter<?>) writer).getEncoder())
.filter(e -> encoder.getClass().equals(e.getClass()))
.findFirst()
.filter(e -> e == encoder).orElse(null));
.filter(e -> e == encoder).orElse(null)).isSameAs(encoder);
}

77
spring-web/src/test/java/org/springframework/http/codec/support/ServerCodecConfigurerTests.java
View File

@@ -60,10 +60,7 @@ import org.springframework.http.codec.xml.Jaxb2XmlDecoder;
import org.springframework.http.codec.xml.Jaxb2XmlEncoder;
import org.springframework.util.MimeTypeUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.core.ResolvableType.forClass;
/**
@@ -81,35 +78,35 @@ public class ServerCodecConfigurerTests {
@Test
public void defaultReaders() {
List<HttpMessageReader<?>> readers = this.configurer.getReaders();
assertEquals(13, readers.size());
assertEquals(ByteArrayDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ByteBufferDecoder.class, getNextDecoder(readers).getClass());
assertEquals(DataBufferDecoder.class, getNextDecoder(readers).getClass());
assertEquals(ResourceHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertThat(readers.size()).isEqualTo(13);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ByteArrayDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ByteBufferDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(DataBufferDecoder.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(ResourceHttpMessageReader.class);
assertStringDecoder(getNextDecoder(readers), true);
assertEquals(ProtobufDecoder.class, getNextDecoder(readers).getClass());
assertEquals(FormHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertEquals(DefaultMultipartMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertEquals(MultipartHttpMessageReader.class, readers.get(this.index.getAndIncrement()).getClass());
assertEquals(Jackson2JsonDecoder.class, getNextDecoder(readers).getClass());
assertEquals(Jackson2SmileDecoder.class, getNextDecoder(readers).getClass());
assertEquals(Jaxb2XmlDecoder.class, getNextDecoder(readers).getClass());
assertThat(getNextDecoder(readers).getClass()).isEqualTo(ProtobufDecoder.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(FormHttpMessageReader.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(DefaultMultipartMessageReader.class);
assertThat(readers.get(this.index.getAndIncrement()).getClass()).isEqualTo(MultipartHttpMessageReader.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jackson2JsonDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jackson2SmileDecoder.class);
assertThat(getNextDecoder(readers).getClass()).isEqualTo(Jaxb2XmlDecoder.class);
assertStringDecoder(getNextDecoder(readers), false);
}
@Test
public void defaultWriters() {
List<HttpMessageWriter<?>> writers = this.configurer.getWriters();
assertEquals(11, writers.size());
assertEquals(ByteArrayEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ByteBufferEncoder.class, getNextEncoder(writers).getClass());
assertEquals(DataBufferEncoder.class, getNextEncoder(writers).getClass());
assertEquals(ResourceHttpMessageWriter.class, writers.get(index.getAndIncrement()).getClass());
assertThat(writers.size()).isEqualTo(11);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(ByteArrayEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(ByteBufferEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(DataBufferEncoder.class);
assertThat(writers.get(index.getAndIncrement()).getClass()).isEqualTo(ResourceHttpMessageWriter.class);
assertStringEncoder(getNextEncoder(writers), true);
assertEquals(ProtobufHttpMessageWriter.class, writers.get(index.getAndIncrement()).getClass());
assertEquals(Jackson2JsonEncoder.class, getNextEncoder(writers).getClass());
assertEquals(Jackson2SmileEncoder.class, getNextEncoder(writers).getClass());
assertEquals(Jaxb2XmlEncoder.class, getNextEncoder(writers).getClass());
assertThat(writers.get(index.getAndIncrement()).getClass()).isEqualTo(ProtobufHttpMessageWriter.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jackson2JsonEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jackson2SmileEncoder.class);
assertThat(getNextEncoder(writers).getClass()).isEqualTo(Jaxb2XmlEncoder.class);
assertSseWriter(writers);
assertStringEncoder(getNextEncoder(writers), false);
}
@@ -119,52 +116,54 @@ public class ServerCodecConfigurerTests {
Jackson2JsonEncoder encoder = new Jackson2JsonEncoder();
this.configurer.defaultCodecs().jackson2JsonEncoder(encoder);
assertSame(encoder, this.configurer.getWriters().stream()
assertThat(this.configurer.getWriters().stream()
.filter(writer -> ServerSentEventHttpMessageWriter.class.equals(writer.getClass()))
.map(writer -> (ServerSentEventHttpMessageWriter) writer)
.findFirst()
.map(ServerSentEventHttpMessageWriter::getEncoder)
.filter(e -> e == encoder).orElse(null));
.filter(e -> e == encoder).orElse(null)).isSameAs(encoder);
}
private Decoder<?> getNextDecoder(List<HttpMessageReader<?>> readers) {
HttpMessageReader<?> reader = readers.get(this.index.getAndIncrement());
assertEquals(DecoderHttpMessageReader.class, reader.getClass());
assertThat(reader.getClass()).isEqualTo(DecoderHttpMessageReader.class);
return ((DecoderHttpMessageReader<?>) reader).getDecoder();
}
private Encoder<?> getNextEncoder(List<HttpMessageWriter<?>> writers) {
HttpMessageWriter<?> writer = writers.get(this.index.getAndIncrement());
assertEquals(EncoderHttpMessageWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(EncoderHttpMessageWriter.class);
return ((EncoderHttpMessageWriter<?>) writer).getEncoder();
}
@SuppressWarnings("unchecked")
private void assertStringDecoder(Decoder<?> decoder, boolean textOnly) {
assertEquals(StringDecoder.class, decoder.getClass());
assertTrue(decoder.canDecode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN));
assertEquals(!textOnly, decoder.canDecode(forClass(String.class), MediaType.TEXT_EVENT_STREAM));
assertThat(decoder.getClass()).isEqualTo(StringDecoder.class);
assertThat(decoder.canDecode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN)).isTrue();
Object expected = !textOnly;
assertThat(decoder.canDecode(forClass(String.class), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
Flux<String> flux = (Flux<String>) decoder.decode(
Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))),
ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap());
assertEquals(Arrays.asList("line1", "line2"), flux.collectList().block(Duration.ZERO));
assertThat(flux.collectList().block(Duration.ZERO)).isEqualTo(Arrays.asList("line1", "line2"));
}
private void assertStringEncoder(Encoder<?> encoder, boolean textOnly) {
assertEquals(CharSequenceEncoder.class, encoder.getClass());
assertTrue(encoder.canEncode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN));
assertEquals(!textOnly, encoder.canEncode(forClass(String.class), MediaType.TEXT_EVENT_STREAM));
assertThat(encoder.getClass()).isEqualTo(CharSequenceEncoder.class);
assertThat(encoder.canEncode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN)).isTrue();
Object expected = !textOnly;
assertThat(encoder.canEncode(forClass(String.class), MediaType.TEXT_EVENT_STREAM)).isEqualTo(expected);
}
private void assertSseWriter(List<HttpMessageWriter<?>> writers) {
HttpMessageWriter<?> writer = writers.get(this.index.getAndIncrement());
assertEquals(ServerSentEventHttpMessageWriter.class, writer.getClass());
assertThat(writer.getClass()).isEqualTo(ServerSentEventHttpMessageWriter.class);
Encoder<?> encoder = ((ServerSentEventHttpMessageWriter) writer).getEncoder();
assertNotNull(encoder);
assertEquals(Jackson2JsonEncoder.class, encoder.getClass());
assertThat(encoder).isNotNull();
assertThat(encoder.getClass()).isEqualTo(Jackson2JsonEncoder.class);
}
}

64
spring-web/src/test/java/org/springframework/http/codec/xml/Jaxb2XmlDecoderTests.java
View File

@@ -39,9 +39,7 @@ import org.springframework.http.codec.xml.jaxb.XmlType;
import org.springframework.http.codec.xml.jaxb.XmlTypeWithName;
import org.springframework.http.codec.xml.jaxb.XmlTypeWithNameAndNamespace;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Sebastien Deleuze
@@ -75,16 +73,16 @@ public class Jaxb2XmlDecoderTests extends AbstractLeakCheckingTestCase {
@Test
public void canDecode() {
assertTrue(this.decoder.canDecode(ResolvableType.forClass(Pojo.class),
MediaType.APPLICATION_XML));
assertTrue(this.decoder.canDecode(ResolvableType.forClass(Pojo.class),
MediaType.TEXT_XML));
assertFalse(this.decoder.canDecode(ResolvableType.forClass(Pojo.class),
MediaType.APPLICATION_JSON));
assertTrue(this.decoder.canDecode(ResolvableType.forClass(TypePojo.class),
MediaType.APPLICATION_XML));
assertFalse(this.decoder.canDecode(ResolvableType.forClass(getClass()),
MediaType.APPLICATION_XML));
assertThat(this.decoder.canDecode(ResolvableType.forClass(Pojo.class),
MediaType.APPLICATION_XML)).isTrue();
assertThat(this.decoder.canDecode(ResolvableType.forClass(Pojo.class),
MediaType.TEXT_XML)).isTrue();
assertThat(this.decoder.canDecode(ResolvableType.forClass(Pojo.class),
MediaType.APPLICATION_JSON)).isFalse();
assertThat(this.decoder.canDecode(ResolvableType.forClass(TypePojo.class),
MediaType.APPLICATION_XML)).isTrue();
assertThat(this.decoder.canDecode(ResolvableType.forClass(getClass()),
MediaType.APPLICATION_XML)).isFalse();
}
@Test
@@ -95,7 +93,7 @@ public class Jaxb2XmlDecoderTests extends AbstractLeakCheckingTestCase {
StepVerifier.create(result)
.consumeNextWith(events -> {
assertEquals(8, events.size());
assertThat(events.size()).isEqualTo(8);
assertStartElement(events.get(0), "pojo");
assertStartElement(events.get(1), "foo");
assertCharacters(events.get(2), "foofoo");
@@ -118,7 +116,7 @@ public class Jaxb2XmlDecoderTests extends AbstractLeakCheckingTestCase {
StepVerifier.create(result)
.consumeNextWith(events -> {
assertEquals(8, events.size());
assertThat(events.size()).isEqualTo(8);
assertStartElement(events.get(0), "pojo");
assertStartElement(events.get(1), "foo");
assertCharacters(events.get(2), "foo");
@@ -129,7 +127,7 @@ public class Jaxb2XmlDecoderTests extends AbstractLeakCheckingTestCase {
assertEndElement(events.get(7), "pojo");
})
.consumeNextWith(events -> {
assertEquals(8, events.size());
assertThat(events.size()).isEqualTo(8);
assertStartElement(events.get(0), "pojo");
assertStartElement(events.get(1), "foo");
assertCharacters(events.get(2), "foofoo");
@@ -144,18 +142,18 @@ public class Jaxb2XmlDecoderTests extends AbstractLeakCheckingTestCase {
}
private static void assertStartElement(XMLEvent event, String expectedLocalName) {
assertTrue(event.isStartElement());
assertEquals(expectedLocalName, event.asStartElement().getName().getLocalPart());
assertThat(event.isStartElement()).isTrue();
assertThat(event.asStartElement().getName().getLocalPart()).isEqualTo(expectedLocalName);
}
private static void assertEndElement(XMLEvent event, String expectedLocalName) {
assertTrue(event.isEndElement());
assertEquals(expectedLocalName, event.asEndElement().getName().getLocalPart());
assertThat(event.isEndElement()).isTrue();
assertThat(event.asEndElement().getName().getLocalPart()).isEqualTo(expectedLocalName);
}
private static void assertCharacters(XMLEvent event, String expectedData) {
assertTrue(event.isCharacters());
assertEquals(expectedData, event.asCharacters().getData());
assertThat(event.isCharacters()).isTrue();
assertThat(event.asCharacters().getData()).isEqualTo(expectedData);
}
@Test
@@ -224,22 +222,16 @@ public class Jaxb2XmlDecoderTests extends AbstractLeakCheckingTestCase {
@Test
public void toExpectedQName() {
assertEquals(new QName("pojo"), this.decoder.toQName(Pojo.class));
assertEquals(new QName("pojo"), this.decoder.toQName(TypePojo.class));
assertThat(this.decoder.toQName(Pojo.class)).isEqualTo(new QName("pojo"));
assertThat(this.decoder.toQName(TypePojo.class)).isEqualTo(new QName("pojo"));
assertEquals(new QName("namespace", "name"),
this.decoder.toQName(XmlRootElementWithNameAndNamespace.class));
assertEquals(new QName("namespace", "name"),
this.decoder.toQName(XmlRootElementWithName.class));
assertEquals(new QName("namespace", "xmlRootElement"),
this.decoder.toQName(XmlRootElement.class));
assertThat(this.decoder.toQName(XmlRootElementWithNameAndNamespace.class)).isEqualTo(new QName("namespace", "name"));
assertThat(this.decoder.toQName(XmlRootElementWithName.class)).isEqualTo(new QName("namespace", "name"));
assertThat(this.decoder.toQName(XmlRootElement.class)).isEqualTo(new QName("namespace", "xmlRootElement"));
assertEquals(new QName("namespace", "name"),
this.decoder.toQName(XmlTypeWithNameAndNamespace.class));
assertEquals(new QName("namespace", "name"),
this.decoder.toQName(XmlTypeWithName.class));
assertEquals(new QName("namespace", "xmlType"),
this.decoder.toQName(XmlType.class));
assertThat(this.decoder.toQName(XmlTypeWithNameAndNamespace.class)).isEqualTo(new QName("namespace", "name"));
assertThat(this.decoder.toQName(XmlTypeWithName.class)).isEqualTo(new QName("namespace", "name"));
assertThat(this.decoder.toQName(XmlType.class)).isEqualTo(new QName("namespace", "xmlType"));
}

26
spring-web/src/test/java/org/springframework/http/codec/xml/Jaxb2XmlEncoderTests.java
View File

@@ -36,8 +36,6 @@ import org.springframework.tests.XmlContent;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.springframework.core.io.buffer.DataBufferUtils.release;
/**
@@ -53,22 +51,22 @@ public class Jaxb2XmlEncoderTests extends AbstractEncoderTestCase<Jaxb2XmlEncode
@Override
@Test
public void canEncode() {
assertTrue(this.encoder.canEncode(ResolvableType.forClass(Pojo.class),
MediaType.APPLICATION_XML));
assertTrue(this.encoder.canEncode(ResolvableType.forClass(Pojo.class),
MediaType.TEXT_XML));
assertFalse(this.encoder.canEncode(ResolvableType.forClass(Pojo.class),
MediaType.APPLICATION_JSON));
assertThat(this.encoder.canEncode(ResolvableType.forClass(Pojo.class),
MediaType.APPLICATION_XML)).isTrue();
assertThat(this.encoder.canEncode(ResolvableType.forClass(Pojo.class),
MediaType.TEXT_XML)).isTrue();
assertThat(this.encoder.canEncode(ResolvableType.forClass(Pojo.class),
MediaType.APPLICATION_JSON)).isFalse();
assertTrue(this.encoder.canEncode(
ResolvableType.forClass(Jaxb2XmlDecoderTests.TypePojo.class),
MediaType.APPLICATION_XML));
assertThat(this.encoder.canEncode(
ResolvableType.forClass(Jaxb2XmlDecoderTests.TypePojo.class),
MediaType.APPLICATION_XML)).isTrue();
assertFalse(this.encoder.canEncode(ResolvableType.forClass(getClass()),
MediaType.APPLICATION_XML));
assertThat(this.encoder.canEncode(ResolvableType.forClass(getClass()),
MediaType.APPLICATION_XML)).isFalse();
// SPR-15464
assertFalse(this.encoder.canEncode(ResolvableType.NONE, null));
assertThat(this.encoder.canEncode(ResolvableType.NONE, null)).isFalse();
}
@Override

23
spring-web/src/test/java/org/springframework/http/codec/xml/XmlEventDecoderTests.java
View File

@@ -28,8 +28,7 @@ import reactor.test.StepVerifier;
import org.springframework.core.io.buffer.AbstractLeakCheckingTestCase;
import org.springframework.core.io.buffer.DataBuffer;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -51,7 +50,7 @@ public class XmlEventDecoderTests extends AbstractLeakCheckingTestCase {
this.decoder.decode(stringBuffer(XML), null, null, Collections.emptyMap());
StepVerifier.create(events)
.consumeNextWith(e -> assertTrue(e.isStartDocument()))
.consumeNextWith(e -> assertThat(e.isStartDocument()).isTrue())
.consumeNextWith(e -> assertStartElement(e, "pojo"))
.consumeNextWith(e -> assertStartElement(e, "foo"))
.consumeNextWith(e -> assertCharacters(e, "foofoo"))
@@ -72,7 +71,7 @@ public class XmlEventDecoderTests extends AbstractLeakCheckingTestCase {
this.decoder.decode(stringBuffer(XML), null, null, Collections.emptyMap());
StepVerifier.create(events)
.consumeNextWith(e -> assertTrue(e.isStartDocument()))
.consumeNextWith(e -> assertThat(e.isStartDocument()).isTrue())
.consumeNextWith(e -> assertStartElement(e, "pojo"))
.consumeNextWith(e -> assertStartElement(e, "foo"))
.consumeNextWith(e -> assertCharacters(e, "foofoo"))
@@ -81,7 +80,7 @@ public class XmlEventDecoderTests extends AbstractLeakCheckingTestCase {
.consumeNextWith(e -> assertCharacters(e, "barbar"))
.consumeNextWith(e -> assertEndElement(e, "bar"))
.consumeNextWith(e -> assertEndElement(e, "pojo"))
.consumeNextWith(e -> assertTrue(e.isEndDocument()))
.consumeNextWith(e -> assertThat(e.isEndDocument()).isTrue())
.expectComplete()
.verify();
}
@@ -96,7 +95,7 @@ public class XmlEventDecoderTests extends AbstractLeakCheckingTestCase {
this.decoder.decode(source, null, null, Collections.emptyMap());
StepVerifier.create(events)
.consumeNextWith(e -> assertTrue(e.isStartDocument()))
.consumeNextWith(e -> assertThat(e.isStartDocument()).isTrue())
.consumeNextWith(e -> assertStartElement(e, "pojo"))
.expectError(RuntimeException.class)
.verify();
@@ -119,18 +118,18 @@ public class XmlEventDecoderTests extends AbstractLeakCheckingTestCase {
}
private static void assertStartElement(XMLEvent event, String expectedLocalName) {
assertTrue(event.isStartElement());
assertEquals(expectedLocalName, event.asStartElement().getName().getLocalPart());
assertThat(event.isStartElement()).isTrue();
assertThat(event.asStartElement().getName().getLocalPart()).isEqualTo(expectedLocalName);
}
private static void assertEndElement(XMLEvent event, String expectedLocalName) {
assertTrue(event + " is no end element", event.isEndElement());
assertEquals(expectedLocalName, event.asEndElement().getName().getLocalPart());
assertThat(event.isEndElement()).as(event + " is no end element").isTrue();
assertThat(event.asEndElement().getName().getLocalPart()).isEqualTo(expectedLocalName);
}
private static void assertCharacters(XMLEvent event, String expectedData) {
assertTrue(event.isCharacters());
assertEquals(expectedData, event.asCharacters().getData());
assertThat(event.isCharacters()).isTrue();
assertThat(event.asCharacters().getData()).isEqualTo(expectedData);
}
private Mono<DataBuffer> stringBuffer(String value) {

33
spring-web/src/test/java/org/springframework/http/converter/BufferedImageHttpMessageConverterTests.java
View File

@@ -31,8 +31,7 @@ import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
import org.springframework.util.FileCopyUtils;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for BufferedImageHttpMessageConverter.
@@ -50,15 +49,15 @@ public class BufferedImageHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue("Image not supported", converter.canRead(BufferedImage.class, null));
assertTrue("Image not supported", converter.canRead(BufferedImage.class, new MediaType("image", "png")));
assertThat(converter.canRead(BufferedImage.class, null)).as("Image not supported").isTrue();
assertThat(converter.canRead(BufferedImage.class, new MediaType("image", "png"))).as("Image not supported").isTrue();
}
@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")));
assertTrue("Image not supported", converter.canWrite(BufferedImage.class, new MediaType("*", "*")));
assertThat(converter.canWrite(BufferedImage.class, null)).as("Image not supported").isTrue();
assertThat(converter.canWrite(BufferedImage.class, new MediaType("image", "png"))).as("Image not supported").isTrue();
assertThat(converter.canWrite(BufferedImage.class, new MediaType("*", "*"))).as("Image not supported").isTrue();
}
@Test
@@ -68,8 +67,8 @@ public class BufferedImageHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
inputMessage.getHeaders().setContentType(new MediaType("image", "jpeg"));
BufferedImage result = converter.read(BufferedImage.class, inputMessage);
assertEquals("Invalid height", 500, result.getHeight());
assertEquals("Invalid width", 750, result.getWidth());
assertThat(result.getHeight()).as("Invalid height").isEqualTo(500);
assertThat(result.getWidth()).as("Invalid width").isEqualTo(750);
}
@Test
@@ -79,11 +78,11 @@ public class BufferedImageHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
MediaType contentType = new MediaType("image", "png");
converter.write(body, contentType, outputMessage);
assertEquals("Invalid content type", contentType, outputMessage.getWrittenHeaders().getContentType());
assertTrue("Invalid size", outputMessage.getBodyAsBytes().length > 0);
assertThat(outputMessage.getWrittenHeaders().getContentType()).as("Invalid content type").isEqualTo(contentType);
assertThat(outputMessage.getBodyAsBytes().length > 0).as("Invalid size").isTrue();
BufferedImage result = ImageIO.read(new ByteArrayInputStream(outputMessage.getBodyAsBytes()));
assertEquals("Invalid height", 500, result.getHeight());
assertEquals("Invalid width", 750, result.getWidth());
assertThat(result.getHeight()).as("Invalid height").isEqualTo(500);
assertThat(result.getWidth()).as("Invalid width").isEqualTo(750);
}
@Test
@@ -94,11 +93,11 @@ public class BufferedImageHttpMessageConverterTests {
BufferedImage body = ImageIO.read(logo.getFile());
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(body, new MediaType("*", "*"), outputMessage);
assertEquals("Invalid content type", contentType, outputMessage.getWrittenHeaders().getContentType());
assertTrue("Invalid size", outputMessage.getBodyAsBytes().length > 0);
assertThat(outputMessage.getWrittenHeaders().getContentType()).as("Invalid content type").isEqualTo(contentType);
assertThat(outputMessage.getBodyAsBytes().length > 0).as("Invalid size").isTrue();
BufferedImage result = ImageIO.read(new ByteArrayInputStream(outputMessage.getBodyAsBytes()));
assertEquals("Invalid height", 500, result.getHeight());
assertEquals("Invalid width", 750, result.getWidth());
assertThat(result.getHeight()).as("Invalid height").isEqualTo(500);
assertThat(result.getWidth()).as("Invalid width").isEqualTo(750);
}
}

19
spring-web/src/test/java/org/springframework/http/converter/ByteArrayHttpMessageConverterTests.java
View File

@@ -25,9 +25,7 @@ import org.springframework.http.MediaType;
import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/** @author Arjen Poutsma */
public class ByteArrayHttpMessageConverterTests {
@@ -41,13 +39,13 @@ public class ByteArrayHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(converter.canRead(byte[].class, new MediaType("application", "octet-stream")));
assertThat(converter.canRead(byte[].class, new MediaType("application", "octet-stream"))).isTrue();
}
@Test
public void canWrite() {
assertTrue(converter.canWrite(byte[].class, new MediaType("application", "octet-stream")));
assertTrue(converter.canWrite(byte[].class, MediaType.ALL));
assertThat(converter.canWrite(byte[].class, new MediaType("application", "octet-stream"))).isTrue();
assertThat(converter.canWrite(byte[].class, MediaType.ALL)).isTrue();
}
@Test
@@ -56,7 +54,7 @@ public class ByteArrayHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
inputMessage.getHeaders().setContentType(new MediaType("application", "octet-stream"));
byte[] result = converter.read(byte[].class, inputMessage);
assertArrayEquals("Invalid result", body, result);
assertThat(result).as("Invalid result").isEqualTo(body);
}
@Test
@@ -64,10 +62,9 @@ public class ByteArrayHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
byte[] body = new byte[]{0x1, 0x2};
converter.write(body, null, outputMessage);
assertArrayEquals("Invalid result", body, outputMessage.getBodyAsBytes());
assertEquals("Invalid content-type", new MediaType("application", "octet-stream"),
outputMessage.getHeaders().getContentType());
assertEquals("Invalid content-length", 2, outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getBodyAsBytes()).as("Invalid result").isEqualTo(body);
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "octet-stream"));
assertThat(outputMessage.getHeaders().getContentLength()).as("Invalid content-length").isEqualTo(2);
}
}

106
spring-web/src/test/java/org/springframework/http/converter/FormHttpMessageConverterTests.java
View File

@@ -44,11 +44,6 @@ import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
@@ -63,21 +58,21 @@ public class FormHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(this.converter.canRead(MultiValueMap.class,
new MediaType("application", "x-www-form-urlencoded")));
assertFalse(this.converter.canRead(MultiValueMap.class,
new MediaType("multipart", "form-data")));
assertThat(this.converter.canRead(MultiValueMap.class,
new MediaType("application", "x-www-form-urlencoded"))).isTrue();
assertThat(this.converter.canRead(MultiValueMap.class,
new MediaType("multipart", "form-data"))).isFalse();
}
@Test
public void canWrite() {
assertTrue(this.converter.canWrite(MultiValueMap.class,
new MediaType("application", "x-www-form-urlencoded")));
assertTrue(this.converter.canWrite(MultiValueMap.class,
new MediaType("multipart", "form-data")));
assertTrue(this.converter.canWrite(MultiValueMap.class,
new MediaType("multipart", "form-data", StandardCharsets.UTF_8)));
assertTrue(this.converter.canWrite(MultiValueMap.class, MediaType.ALL));
assertThat(this.converter.canWrite(MultiValueMap.class,
new MediaType("application", "x-www-form-urlencoded"))).isTrue();
assertThat(this.converter.canWrite(MultiValueMap.class,
new MediaType("multipart", "form-data"))).isTrue();
assertThat(this.converter.canWrite(MultiValueMap.class,
new MediaType("multipart", "form-data", StandardCharsets.UTF_8))).isTrue();
assertThat(this.converter.canWrite(MultiValueMap.class, MediaType.ALL)).isTrue();
}
@Test
@@ -88,13 +83,13 @@ public class FormHttpMessageConverterTests {
new MediaType("application", "x-www-form-urlencoded", StandardCharsets.ISO_8859_1));
MultiValueMap<String, String> result = this.converter.read(null, inputMessage);
assertEquals("Invalid result", 3, result.size());
assertEquals("Invalid result", "value 1", result.getFirst("name 1"));
assertThat(result.size()).as("Invalid result").isEqualTo(3);
assertThat(result.getFirst("name 1")).as("Invalid result").isEqualTo("value 1");
List<String> values = result.get("name 2");
assertEquals("Invalid result", 2, values.size());
assertEquals("Invalid result", "value 2+1", values.get(0));
assertEquals("Invalid result", "value 2+2", values.get(1));
assertNull("Invalid result", result.getFirst("name 3"));
assertThat(values.size()).as("Invalid result").isEqualTo(2);
assertThat(values.get(0)).as("Invalid result").isEqualTo("value 2+1");
assertThat(values.get(1)).as("Invalid result").isEqualTo("value 2+2");
assertThat(result.getFirst("name 3")).as("Invalid result").isNull();
}
@Test
@@ -107,12 +102,9 @@ public class FormHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
this.converter.write(body, MediaType.APPLICATION_FORM_URLENCODED, outputMessage);
assertEquals("Invalid result", "name+1=value+1&name+2=value+2%2B1&name+2=value+2%2B2&name+3",
outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertEquals("Invalid content-type", "application/x-www-form-urlencoded;charset=UTF-8",
outputMessage.getHeaders().getContentType().toString());
assertEquals("Invalid content-length", outputMessage.getBodyAsBytes().length,
outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).as("Invalid result").isEqualTo("name+1=value+1&name+2=value+2%2B1&name+2=value+2%2B2&name+3");
assertThat(outputMessage.getHeaders().getContentType().toString()).as("Invalid content-type").isEqualTo("application/x-www-form-urlencoded;charset=UTF-8");
assertThat(outputMessage.getHeaders().getContentLength()).as("Invalid content-length").isEqualTo(outputMessage.getBodyAsBytes().length);
}
@Test
@@ -153,39 +145,39 @@ public class FormHttpMessageConverterTests {
FileUpload fileUpload = new FileUpload(fileItemFactory);
RequestContext requestContext = new MockHttpOutputMessageRequestContext(outputMessage);
List<FileItem> items = fileUpload.parseRequest(requestContext);
assertEquals(6, items.size());
assertThat(items.size()).isEqualTo(6);
FileItem item = items.get(0);
assertTrue(item.isFormField());
assertEquals("name 1", item.getFieldName());
assertEquals("value 1", item.getString());
assertThat(item.isFormField()).isTrue();
assertThat(item.getFieldName()).isEqualTo("name 1");
assertThat(item.getString()).isEqualTo("value 1");
item = items.get(1);
assertTrue(item.isFormField());
assertEquals("name 2", item.getFieldName());
assertEquals("value 2+1", item.getString());
assertThat(item.isFormField()).isTrue();
assertThat(item.getFieldName()).isEqualTo("name 2");
assertThat(item.getString()).isEqualTo("value 2+1");
item = items.get(2);
assertTrue(item.isFormField());
assertEquals("name 2", item.getFieldName());
assertEquals("value 2+2", item.getString());
assertThat(item.isFormField()).isTrue();
assertThat(item.getFieldName()).isEqualTo("name 2");
assertThat(item.getString()).isEqualTo("value 2+2");
item = items.get(3);
assertFalse(item.isFormField());
assertEquals("logo", item.getFieldName());
assertEquals("logo.jpg", item.getName());
assertEquals("image/jpeg", item.getContentType());
assertEquals(logo.getFile().length(), item.getSize());
assertThat(item.isFormField()).isFalse();
assertThat(item.getFieldName()).isEqualTo("logo");
assertThat(item.getName()).isEqualTo("logo.jpg");
assertThat(item.getContentType()).isEqualTo("image/jpeg");
assertThat(item.getSize()).isEqualTo(logo.getFile().length());
item = items.get(4);
assertFalse(item.isFormField());
assertEquals("utf8", item.getFieldName());
assertEquals("Hall\u00F6le.jpg", item.getName());
assertEquals("image/jpeg", item.getContentType());
assertEquals(logo.getFile().length(), item.getSize());
assertThat(item.isFormField()).isFalse();
assertThat(item.getFieldName()).isEqualTo("utf8");
assertThat(item.getName()).isEqualTo("Hall\u00F6le.jpg");
assertThat(item.getContentType()).isEqualTo("image/jpeg");
assertThat(item.getSize()).isEqualTo(logo.getFile().length());
item = items.get(5);
assertEquals("xml", item.getFieldName());
assertEquals("text/xml", item.getContentType());
assertThat(item.getFieldName()).isEqualTo("xml");
assertThat(item.getContentType()).isEqualTo("text/xml");
verify(outputMessage.getBody(), never()).close();
}
@@ -209,23 +201,23 @@ public class FormHttpMessageConverterTests {
this.converter.write(parts, new MediaType("multipart", "form-data", StandardCharsets.UTF_8), outputMessage);
final MediaType contentType = outputMessage.getHeaders().getContentType();
assertNotNull("No boundary found", contentType.getParameter("boundary"));
assertThat(contentType.getParameter("boundary")).as("No boundary found").isNotNull();
// see if Commons FileUpload can read what we wrote
FileItemFactory fileItemFactory = new DiskFileItemFactory();
FileUpload fileUpload = new FileUpload(fileItemFactory);
RequestContext requestContext = new MockHttpOutputMessageRequestContext(outputMessage);
List<FileItem> items = fileUpload.parseRequest(requestContext);
assertEquals(2, items.size());
assertThat(items.size()).isEqualTo(2);
FileItem item = items.get(0);
assertTrue(item.isFormField());
assertEquals("part1", item.getFieldName());
assertEquals("{\"string\":\"foo\"}", item.getString());
assertThat(item.isFormField()).isTrue();
assertThat(item.getFieldName()).isEqualTo("part1");
assertThat(item.getString()).isEqualTo("{\"string\":\"foo\"}");
item = items.get(1);
assertTrue(item.isFormField());
assertEquals("part2", item.getFieldName());
assertThat(item.isFormField()).isTrue();
assertThat(item.getFieldName()).isEqualTo("part2");
// With developer builds we get: <MyBean><string>foo</string></MyBean>
// But on CI server we get: <MyBean xmlns=""><string>foo</string></MyBean>

27
spring-web/src/test/java/org/springframework/http/converter/HttpMessageConverterTests.java
View File

@@ -24,8 +24,7 @@ import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Test-case for AbstractHttpMessageConverter.
@@ -41,9 +40,9 @@ public class HttpMessageConverterTests {
MediaType mediaType = new MediaType("foo", "bar");
HttpMessageConverter<MyType> converter = new MyHttpMessageConverter<>(mediaType);
assertTrue(converter.canRead(MyType.class, mediaType));
assertFalse(converter.canRead(MyType.class, new MediaType("foo", "*")));
assertFalse(converter.canRead(MyType.class, MediaType.ALL));
assertThat(converter.canRead(MyType.class, mediaType)).isTrue();
assertThat(converter.canRead(MyType.class, new MediaType("foo", "*"))).isFalse();
assertThat(converter.canRead(MyType.class, MediaType.ALL)).isFalse();
}
@Test
@@ -51,9 +50,9 @@ public class HttpMessageConverterTests {
MediaType mediaType = new MediaType("foo");
HttpMessageConverter<MyType> converter = new MyHttpMessageConverter<>(mediaType);
assertTrue(converter.canRead(MyType.class, new MediaType("foo", "bar")));
assertTrue(converter.canRead(MyType.class, new MediaType("foo", "*")));
assertFalse(converter.canRead(MyType.class, MediaType.ALL));
assertThat(converter.canRead(MyType.class, new MediaType("foo", "bar"))).isTrue();
assertThat(converter.canRead(MyType.class, new MediaType("foo", "*"))).isTrue();
assertThat(converter.canRead(MyType.class, MediaType.ALL)).isFalse();
}
@Test
@@ -61,9 +60,9 @@ public class HttpMessageConverterTests {
MediaType mediaType = new MediaType("foo", "bar");
HttpMessageConverter<MyType> converter = new MyHttpMessageConverter<>(mediaType);
assertTrue(converter.canWrite(MyType.class, mediaType));
assertTrue(converter.canWrite(MyType.class, new MediaType("foo", "*")));
assertTrue(converter.canWrite(MyType.class, MediaType.ALL));
assertThat(converter.canWrite(MyType.class, mediaType)).isTrue();
assertThat(converter.canWrite(MyType.class, new MediaType("foo", "*"))).isTrue();
assertThat(converter.canWrite(MyType.class, MediaType.ALL)).isTrue();
}
@Test
@@ -71,9 +70,9 @@ public class HttpMessageConverterTests {
MediaType mediaType = new MediaType("foo");
HttpMessageConverter<MyType> converter = new MyHttpMessageConverter<>(mediaType);
assertTrue(converter.canWrite(MyType.class, new MediaType("foo", "bar")));
assertTrue(converter.canWrite(MyType.class, new MediaType("foo", "*")));
assertTrue(converter.canWrite(MyType.class, MediaType.ALL));
assertThat(converter.canWrite(MyType.class, new MediaType("foo", "bar"))).isTrue();
assertThat(converter.canWrite(MyType.class, new MediaType("foo", "*"))).isTrue();
assertThat(converter.canWrite(MyType.class, MediaType.ALL)).isTrue();
}

67
spring-web/src/test/java/org/springframework/http/converter/ObjectToStringHttpMessageConverterTests.java
View File

@@ -34,13 +34,8 @@ import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.mock.web.test.MockHttpServletRequest;
import org.springframework.mock.web.test.MockHttpServletResponse;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
/**
* Test cases for {@link ObjectToStringHttpMessageConverter} class.
@@ -69,37 +64,37 @@ public class ObjectToStringHttpMessageConverterTests {
@Test
public void canRead() {
assertFalse(this.converter.canRead(Math.class, null));
assertFalse(this.converter.canRead(Resource.class, null));
assertThat(this.converter.canRead(Math.class, null)).isFalse();
assertThat(this.converter.canRead(Resource.class, null)).isFalse();
assertTrue(this.converter.canRead(Locale.class, null));
assertTrue(this.converter.canRead(BigInteger.class, null));
assertThat(this.converter.canRead(Locale.class, null)).isTrue();
assertThat(this.converter.canRead(BigInteger.class, null)).isTrue();
assertFalse(this.converter.canRead(BigInteger.class, MediaType.TEXT_HTML));
assertFalse(this.converter.canRead(BigInteger.class, MediaType.TEXT_XML));
assertFalse(this.converter.canRead(BigInteger.class, MediaType.APPLICATION_XML));
assertThat(this.converter.canRead(BigInteger.class, MediaType.TEXT_HTML)).isFalse();
assertThat(this.converter.canRead(BigInteger.class, MediaType.TEXT_XML)).isFalse();
assertThat(this.converter.canRead(BigInteger.class, MediaType.APPLICATION_XML)).isFalse();
}
@Test
public void canWrite() {
assertFalse(this.converter.canWrite(Math.class, null));
assertFalse(this.converter.canWrite(Resource.class, null));
assertThat(this.converter.canWrite(Math.class, null)).isFalse();
assertThat(this.converter.canWrite(Resource.class, null)).isFalse();
assertTrue(this.converter.canWrite(Locale.class, null));
assertTrue(this.converter.canWrite(Double.class, null));
assertThat(this.converter.canWrite(Locale.class, null)).isTrue();
assertThat(this.converter.canWrite(Double.class, null)).isTrue();
assertFalse(this.converter.canWrite(BigInteger.class, MediaType.TEXT_HTML));
assertFalse(this.converter.canWrite(BigInteger.class, MediaType.TEXT_XML));
assertFalse(this.converter.canWrite(BigInteger.class, MediaType.APPLICATION_XML));
assertThat(this.converter.canWrite(BigInteger.class, MediaType.TEXT_HTML)).isFalse();
assertThat(this.converter.canWrite(BigInteger.class, MediaType.TEXT_XML)).isFalse();
assertThat(this.converter.canWrite(BigInteger.class, MediaType.APPLICATION_XML)).isFalse();
assertTrue(this.converter.canWrite(BigInteger.class, MediaType.valueOf("text/*")));
assertThat(this.converter.canWrite(BigInteger.class, MediaType.valueOf("text/*"))).isTrue();
}
@Test
public void defaultCharset() throws IOException {
this.converter.write(Integer.valueOf(5), null, response);
assertEquals("ISO-8859-1", servletResponse.getCharacterEncoding());
assertThat(servletResponse.getCharacterEncoding()).isEqualTo("ISO-8859-1");
}
@Test
@@ -108,7 +103,7 @@ public class ObjectToStringHttpMessageConverterTests {
ObjectToStringHttpMessageConverter converter = new ObjectToStringHttpMessageConverter(cs, StandardCharsets.UTF_16);
converter.write((byte) 31, null, this.response);
assertEquals("UTF-16", this.servletResponse.getCharacterEncoding());
assertThat(this.servletResponse.getCharacterEncoding()).isEqualTo("UTF-16");
}
@Test
@@ -116,7 +111,7 @@ public class ObjectToStringHttpMessageConverterTests {
this.converter.setWriteAcceptCharset(true);
this.converter.write(new Date(), null, this.response);
assertNotNull(this.servletResponse.getHeader("Accept-Charset"));
assertThat(this.servletResponse.getHeader("Accept-Charset")).isNotNull();
}
@Test
@@ -124,7 +119,7 @@ public class ObjectToStringHttpMessageConverterTests {
this.converter.setWriteAcceptCharset(false);
this.converter.write(new Date(), null, this.response);
assertNull(this.servletResponse.getHeader("Accept-Charset"));
assertThat(this.servletResponse.getHeader("Accept-Charset")).isNull();
}
@Test
@@ -133,31 +128,31 @@ public class ObjectToStringHttpMessageConverterTests {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setContentType(MediaType.TEXT_PLAIN_VALUE);
request.setContent(shortValue.toString().getBytes(StringHttpMessageConverter.DEFAULT_CHARSET));
assertEquals(shortValue, this.converter.read(Short.class, new ServletServerHttpRequest(request)));
assertThat(this.converter.read(Short.class, new ServletServerHttpRequest(request))).isEqualTo(shortValue);
Float floatValue = Float.valueOf(123);
request = new MockHttpServletRequest();
request.setContentType(MediaType.TEXT_PLAIN_VALUE);
request.setCharacterEncoding("UTF-16");
request.setContent(floatValue.toString().getBytes("UTF-16"));
assertEquals(floatValue, this.converter.read(Float.class, new ServletServerHttpRequest(request)));
assertThat(this.converter.read(Float.class, new ServletServerHttpRequest(request))).isEqualTo(floatValue);
Long longValue = Long.valueOf(55819182821331L);
request = new MockHttpServletRequest();
request.setContentType(MediaType.TEXT_PLAIN_VALUE);
request.setCharacterEncoding("UTF-8");
request.setContent(longValue.toString().getBytes("UTF-8"));
assertEquals(longValue, this.converter.read(Long.class, new ServletServerHttpRequest(request)));
assertThat(this.converter.read(Long.class, new ServletServerHttpRequest(request))).isEqualTo(longValue);
}
@Test
public void write() throws IOException {
this.converter.write((byte) -8, null, this.response);
assertEquals("ISO-8859-1", this.servletResponse.getCharacterEncoding());
assertTrue(this.servletResponse.getContentType().startsWith(MediaType.TEXT_PLAIN_VALUE));
assertEquals(2, this.servletResponse.getContentLength());
assertArrayEquals(new byte[] { '-', '8' }, this.servletResponse.getContentAsByteArray());
assertThat(this.servletResponse.getCharacterEncoding()).isEqualTo("ISO-8859-1");
assertThat(this.servletResponse.getContentType().startsWith(MediaType.TEXT_PLAIN_VALUE)).isTrue();
assertThat(this.servletResponse.getContentLength()).isEqualTo(2);
assertThat(this.servletResponse.getContentAsByteArray()).isEqualTo(new byte[] { '-', '8' });
}
@Test
@@ -165,11 +160,11 @@ public class ObjectToStringHttpMessageConverterTests {
MediaType contentType = new MediaType("text", "plain", StandardCharsets.UTF_16);
this.converter.write(Integer.valueOf(958), contentType, this.response);
assertEquals("UTF-16", this.servletResponse.getCharacterEncoding());
assertTrue(this.servletResponse.getContentType().startsWith(MediaType.TEXT_PLAIN_VALUE));
assertEquals(8, this.servletResponse.getContentLength());
assertThat(this.servletResponse.getCharacterEncoding()).isEqualTo("UTF-16");
assertThat(this.servletResponse.getContentType().startsWith(MediaType.TEXT_PLAIN_VALUE)).isTrue();
assertThat(this.servletResponse.getContentLength()).isEqualTo(8);
// First two bytes: byte order mark
assertArrayEquals(new byte[] { -2, -1, 0, '9', 0, '5', 0, '8' }, this.servletResponse.getContentAsByteArray());
assertThat(this.servletResponse.getContentAsByteArray()).isEqualTo(new byte[] { -2, -1, 0, '9', 0, '5', 0, '8' });
}
@Test

27
spring-web/src/test/java/org/springframework/http/converter/ResourceHttpMessageConverterTests.java
View File

@@ -35,8 +35,6 @@ import org.springframework.util.FileCopyUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.given;
import static org.mockito.BDDMockito.willThrow;
@@ -54,13 +52,13 @@ public class ResourceHttpMessageConverterTests {
@Test
public void canReadResource() {
assertTrue(converter.canRead(Resource.class, new MediaType("application", "octet-stream")));
assertThat(converter.canRead(Resource.class, new MediaType("application", "octet-stream"))).isTrue();
}
@Test
public void canWriteResource() {
assertTrue(converter.canWrite(Resource.class, new MediaType("application", "octet-stream")));
assertTrue(converter.canWrite(Resource.class, MediaType.ALL));
assertThat(converter.canWrite(Resource.class, new MediaType("application", "octet-stream"))).isTrue();
assertThat(converter.canWrite(Resource.class, MediaType.ALL)).isTrue();
}
@Test
@@ -72,7 +70,7 @@ public class ResourceHttpMessageConverterTests {
ContentDisposition.builder("attachment").filename("yourlogo.jpg").build());
Resource actualResource = converter.read(Resource.class, inputMessage);
assertThat(FileCopyUtils.copyToByteArray(actualResource.getInputStream())).isEqualTo(body);
assertEquals("yourlogo.jpg", actualResource.getFilename());
assertThat(actualResource.getFilename()).isEqualTo("yourlogo.jpg");
}
@Test // SPR-13443
@@ -85,7 +83,7 @@ public class ResourceHttpMessageConverterTests {
Resource actualResource = converter.read(InputStreamResource.class, inputMessage);
assertThat(actualResource).isInstanceOf(InputStreamResource.class);
assertThat(actualResource.getInputStream()).isEqualTo(body);
assertEquals("yourlogo.jpg", actualResource.getFilename());
assertThat(actualResource.getFilename()).isEqualTo("yourlogo.jpg");
}
}
@@ -106,9 +104,8 @@ public class ResourceHttpMessageConverterTests {
Resource body = new ClassPathResource("logo.jpg", getClass());
converter.write(body, null, outputMessage);
assertEquals("Invalid content-type", MediaType.IMAGE_JPEG,
outputMessage.getHeaders().getContentType());
assertEquals("Invalid content-length", body.getFile().length(), outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(MediaType.IMAGE_JPEG);
assertThat(outputMessage.getHeaders().getContentLength()).as("Invalid content-length").isEqualTo(body.getFile().length());
}
@Test // SPR-10848
@@ -118,18 +115,17 @@ public class ResourceHttpMessageConverterTests {
Resource body = new ByteArrayResource(byteArray);
converter.write(body, null, outputMessage);
assertTrue(Arrays.equals(byteArray, outputMessage.getBodyAsBytes()));
assertThat(Arrays.equals(byteArray, outputMessage.getBodyAsBytes())).isTrue();
}
@Test // SPR-12999
@SuppressWarnings("unchecked")
public void writeContentNotGettingInputStream() throws Exception {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
Resource resource = mock(Resource.class);
given(resource.getInputStream()).willThrow(FileNotFoundException.class);
converter.write(resource, MediaType.APPLICATION_OCTET_STREAM, outputMessage);
assertEquals(0, outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getHeaders().getContentLength()).isEqualTo(0);
}
@Test // SPR-12999
@@ -142,11 +138,10 @@ public class ResourceHttpMessageConverterTests {
willThrow(new NullPointerException()).given(inputStream).close();
converter.write(resource, MediaType.APPLICATION_OCTET_STREAM, outputMessage);
assertEquals(0, outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getHeaders().getContentLength()).isEqualTo(0);
}
@Test // SPR-13620
@SuppressWarnings("unchecked")
public void writeContentInputStreamThrowingNullPointerException() throws Exception {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
Resource resource = mock(Resource.class);
@@ -155,7 +150,7 @@ public class ResourceHttpMessageConverterTests {
given(in.read(any())).willThrow(NullPointerException.class);
converter.write(resource, MediaType.APPLICATION_OCTET_STREAM, outputMessage);
assertEquals(0, outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getHeaders().getContentLength()).isEqualTo(0);
}
}

26
spring-web/src/test/java/org/springframework/http/converter/ResourceRegionHttpMessageConverterTests.java
View File

@@ -38,8 +38,6 @@ import org.springframework.http.MockHttpOutputMessage;
import org.springframework.util.StringUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Test cases for {@link ResourceRegionHttpMessageConverter} class.
@@ -52,29 +50,29 @@ public class ResourceRegionHttpMessageConverterTests {
@Test
public void canReadResource() {
assertFalse(converter.canRead(Resource.class, MediaType.APPLICATION_OCTET_STREAM));
assertFalse(converter.canRead(Resource.class, MediaType.ALL));
assertFalse(converter.canRead(List.class, MediaType.APPLICATION_OCTET_STREAM));
assertFalse(converter.canRead(List.class, MediaType.ALL));
assertThat(converter.canRead(Resource.class, MediaType.APPLICATION_OCTET_STREAM)).isFalse();
assertThat(converter.canRead(Resource.class, MediaType.ALL)).isFalse();
assertThat(converter.canRead(List.class, MediaType.APPLICATION_OCTET_STREAM)).isFalse();
assertThat(converter.canRead(List.class, MediaType.ALL)).isFalse();
}
@Test
public void canWriteResource() {
assertTrue(converter.canWrite(ResourceRegion.class, null, MediaType.APPLICATION_OCTET_STREAM));
assertTrue(converter.canWrite(ResourceRegion.class, null, MediaType.ALL));
assertFalse(converter.canWrite(Object.class, null, MediaType.ALL));
assertThat(converter.canWrite(ResourceRegion.class, null, MediaType.APPLICATION_OCTET_STREAM)).isTrue();
assertThat(converter.canWrite(ResourceRegion.class, null, MediaType.ALL)).isTrue();
assertThat(converter.canWrite(Object.class, null, MediaType.ALL)).isFalse();
}
@Test
public void canWriteResourceCollection() {
Type resourceRegionList = new ParameterizedTypeReference<List<ResourceRegion>>() {}.getType();
assertTrue(converter.canWrite(resourceRegionList, null, MediaType.APPLICATION_OCTET_STREAM));
assertTrue(converter.canWrite(resourceRegionList, null, MediaType.ALL));
assertThat(converter.canWrite(resourceRegionList, null, MediaType.APPLICATION_OCTET_STREAM)).isTrue();
assertThat(converter.canWrite(resourceRegionList, null, MediaType.ALL)).isTrue();
assertFalse(converter.canWrite(List.class, MediaType.APPLICATION_OCTET_STREAM));
assertFalse(converter.canWrite(List.class, MediaType.ALL));
assertThat(converter.canWrite(List.class, MediaType.APPLICATION_OCTET_STREAM)).isFalse();
assertThat(converter.canWrite(List.class, MediaType.ALL)).isFalse();
Type resourceObjectList = new ParameterizedTypeReference<List<Object>>() {}.getType();
assertFalse(converter.canWrite(resourceObjectList, null, MediaType.ALL));
assertThat(converter.canWrite(resourceObjectList, null, MediaType.ALL)).isFalse();
}
@Test

35
spring-web/src/test/java/org/springframework/http/converter/StringHttpMessageConverterTests.java
View File

@@ -27,8 +27,7 @@ import org.springframework.http.MediaType;
import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -52,13 +51,13 @@ public class StringHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(this.converter.canRead(String.class, MediaType.TEXT_PLAIN));
assertThat(this.converter.canRead(String.class, MediaType.TEXT_PLAIN)).isTrue();
}
@Test
public void canWrite() {
assertTrue(this.converter.canWrite(String.class, MediaType.TEXT_PLAIN));
assertTrue(this.converter.canWrite(String.class, MediaType.ALL));
assertThat(this.converter.canWrite(String.class, MediaType.TEXT_PLAIN)).isTrue();
assertThat(this.converter.canWrite(String.class, MediaType.ALL)).isTrue();
}
@Test
@@ -68,7 +67,7 @@ public class StringHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(TEXT_PLAIN_UTF_8);
String result = this.converter.read(String.class, inputMessage);
assertEquals("Invalid result", body, result);
assertThat(result).as("Invalid result").isEqualTo(body);
}
@Test
@@ -77,10 +76,10 @@ public class StringHttpMessageConverterTests {
this.converter.write(body, null, this.outputMessage);
HttpHeaders headers = this.outputMessage.getHeaders();
assertEquals(body, this.outputMessage.getBodyAsString(StandardCharsets.ISO_8859_1));
assertEquals(new MediaType("text", "plain", StandardCharsets.ISO_8859_1), headers.getContentType());
assertEquals(body.getBytes(StandardCharsets.ISO_8859_1).length, headers.getContentLength());
assertTrue(headers.getAcceptCharset().isEmpty());
assertThat(this.outputMessage.getBodyAsString(StandardCharsets.ISO_8859_1)).isEqualTo(body);
assertThat(headers.getContentType()).isEqualTo(new MediaType("text", "plain", StandardCharsets.ISO_8859_1));
assertThat(headers.getContentLength()).isEqualTo(body.getBytes(StandardCharsets.ISO_8859_1).length);
assertThat(headers.getAcceptCharset().isEmpty()).isTrue();
}
@Test
@@ -89,10 +88,10 @@ public class StringHttpMessageConverterTests {
this.converter.write(body, TEXT_PLAIN_UTF_8, this.outputMessage);
HttpHeaders headers = this.outputMessage.getHeaders();
assertEquals(body, this.outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertEquals(TEXT_PLAIN_UTF_8, headers.getContentType());
assertEquals(body.getBytes(StandardCharsets.UTF_8).length, headers.getContentLength());
assertTrue(headers.getAcceptCharset().isEmpty());
assertThat(this.outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo(body);
assertThat(headers.getContentType()).isEqualTo(TEXT_PLAIN_UTF_8);
assertThat(headers.getContentLength()).isEqualTo(body.getBytes(StandardCharsets.UTF_8).length);
assertThat(headers.getAcceptCharset().isEmpty()).isTrue();
}
@Test // SPR-8867
@@ -104,10 +103,10 @@ public class StringHttpMessageConverterTests {
headers.setContentType(TEXT_PLAIN_UTF_8);
this.converter.write(body, requestedContentType, this.outputMessage);
assertEquals(body, this.outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertEquals(TEXT_PLAIN_UTF_8, headers.getContentType());
assertEquals(body.getBytes(StandardCharsets.UTF_8).length, headers.getContentLength());
assertTrue(headers.getAcceptCharset().isEmpty());
assertThat(this.outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo(body);
assertThat(headers.getContentType()).isEqualTo(TEXT_PLAIN_UTF_8);
assertThat(headers.getContentLength()).isEqualTo(body.getBytes(StandardCharsets.UTF_8).length);
assertThat(headers.getAcceptCharset().isEmpty()).isTrue();
}
}

30
spring-web/src/test/java/org/springframework/http/converter/feed/AtomFeedHttpMessageConverterTests.java
View File

@@ -38,8 +38,6 @@ import org.springframework.http.MockHttpOutputMessage;
import org.springframework.tests.XmlContent;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Arjen Poutsma
@@ -57,14 +55,14 @@ public class AtomFeedHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(converter.canRead(Feed.class, new MediaType("application", "atom+xml")));
assertTrue(converter.canRead(Feed.class, new MediaType("application", "atom+xml", StandardCharsets.UTF_8)));
assertThat(converter.canRead(Feed.class, new MediaType("application", "atom+xml"))).isTrue();
assertThat(converter.canRead(Feed.class, new MediaType("application", "atom+xml", StandardCharsets.UTF_8))).isTrue();
}
@Test
public void canWrite() {
assertTrue(converter.canWrite(Feed.class, new MediaType("application", "atom+xml")));
assertTrue(converter.canWrite(Feed.class, new MediaType("application", "atom+xml", StandardCharsets.UTF_8)));
assertThat(converter.canWrite(Feed.class, new MediaType("application", "atom+xml"))).isTrue();
assertThat(converter.canWrite(Feed.class, new MediaType("application", "atom+xml", StandardCharsets.UTF_8))).isTrue();
}
@Test
@@ -73,18 +71,18 @@ public class AtomFeedHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(is);
inputMessage.getHeaders().setContentType(new MediaType("application", "atom+xml", StandardCharsets.UTF_8));
Feed result = converter.read(Feed.class, inputMessage);
assertEquals("title", result.getTitle());
assertEquals("subtitle", result.getSubtitle().getValue());
assertThat(result.getTitle()).isEqualTo("title");
assertThat(result.getSubtitle().getValue()).isEqualTo("subtitle");
List<?> entries = result.getEntries();
assertEquals(2, entries.size());
assertThat(entries.size()).isEqualTo(2);
Entry entry1 = (Entry) entries.get(0);
assertEquals("id1", entry1.getId());
assertEquals("title1", entry1.getTitle());
assertThat(entry1.getId()).isEqualTo("id1");
assertThat(entry1.getTitle()).isEqualTo("title1");
Entry entry2 = (Entry) entries.get(1);
assertEquals("id2", entry2.getId());
assertEquals("title2", entry2.getTitle());
assertThat(entry2.getId()).isEqualTo("id2");
assertThat(entry2.getTitle()).isEqualTo("title2");
}
@Test
@@ -108,8 +106,7 @@ public class AtomFeedHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(feed, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "atom+xml", StandardCharsets.UTF_8),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "atom+xml", StandardCharsets.UTF_8));
String expected = "<feed xmlns=\"http://www.w3.org/2005/Atom\">" + "<title>title</title>" +
"<entry><id>id1</id><title>title1</title></entry>" +
"<entry><id>id2</id><title>title2</title></entry></feed>";
@@ -128,8 +125,7 @@ public class AtomFeedHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(feed, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "atom+xml", Charset.forName(encoding)),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "atom+xml", Charset.forName(encoding)));
}
}

28
spring-web/src/test/java/org/springframework/http/converter/feed/RssChannelHttpMessageConverterTests.java
View File

@@ -35,8 +35,6 @@ import org.springframework.http.MockHttpOutputMessage;
import org.springframework.tests.XmlContent;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Arjen Poutsma
@@ -54,14 +52,14 @@ public class RssChannelHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(converter.canRead(Channel.class, new MediaType("application", "rss+xml")));
assertTrue(converter.canRead(Channel.class, new MediaType("application", "rss+xml", StandardCharsets.UTF_8)));
assertThat(converter.canRead(Channel.class, new MediaType("application", "rss+xml"))).isTrue();
assertThat(converter.canRead(Channel.class, new MediaType("application", "rss+xml", StandardCharsets.UTF_8))).isTrue();
}
@Test
public void canWrite() {
assertTrue(converter.canWrite(Channel.class, new MediaType("application", "rss+xml")));
assertTrue(converter.canWrite(Channel.class, new MediaType("application", "rss+xml", StandardCharsets.UTF_8)));
assertThat(converter.canWrite(Channel.class, new MediaType("application", "rss+xml"))).isTrue();
assertThat(converter.canWrite(Channel.class, new MediaType("application", "rss+xml", StandardCharsets.UTF_8))).isTrue();
}
@Test
@@ -70,18 +68,18 @@ public class RssChannelHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(is);
inputMessage.getHeaders().setContentType(new MediaType("application", "rss+xml", StandardCharsets.UTF_8));
Channel result = converter.read(Channel.class, inputMessage);
assertEquals("title", result.getTitle());
assertEquals("https://example.com", result.getLink());
assertEquals("description", result.getDescription());
assertThat(result.getTitle()).isEqualTo("title");
assertThat(result.getLink()).isEqualTo("https://example.com");
assertThat(result.getDescription()).isEqualTo("description");
List<?> items = result.getItems();
assertEquals(2, items.size());
assertThat(items.size()).isEqualTo(2);
Item item1 = (Item) items.get(0);
assertEquals("title1", item1.getTitle());
assertThat(item1.getTitle()).isEqualTo("title1");
Item item2 = (Item) items.get(1);
assertEquals("title2", item2.getTitle());
assertThat(item2.getTitle()).isEqualTo("title2");
}
@Test
@@ -105,8 +103,7 @@ public class RssChannelHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(channel, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "rss+xml", StandardCharsets.UTF_8),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "rss+xml", StandardCharsets.UTF_8));
String expected = "<rss version=\"2.0\">" +
"<channel><title>title</title><link>https://example.com</link><description>description</description>" +
"<item><title>title1</title></item>" +
@@ -132,8 +129,7 @@ public class RssChannelHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(channel, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "rss+xml", Charset.forName(encoding)),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "rss+xml", Charset.forName(encoding)));
}
}

27
spring-web/src/test/java/org/springframework/http/converter/json/GsonFactoryBeanTests.java
View File

@@ -22,8 +22,7 @@ import java.util.Date;
import com.google.gson.Gson;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* {@link GsonFactoryBean} tests.
@@ -44,7 +43,7 @@ public class GsonFactoryBeanTests {
Gson gson = this.factory.getObject();
StringBean bean = new StringBean();
String result = gson.toJson(bean);
assertEquals("{\"name\":null}", result);
assertThat(result).isEqualTo("{\"name\":null}");
}
@Test
@@ -54,7 +53,7 @@ public class GsonFactoryBeanTests {
Gson gson = this.factory.getObject();
StringBean bean = new StringBean();
String result = gson.toJson(bean);
assertEquals("{}", result);
assertThat(result).isEqualTo("{}");
}
@Test
@@ -65,7 +64,7 @@ public class GsonFactoryBeanTests {
StringBean bean = new StringBean();
bean.setName("Jason");
String result = gson.toJson(bean);
assertTrue(result.contains(" \"name\": \"Jason\""));
assertThat(result.contains(" \"name\": \"Jason\"")).isTrue();
}
@Test
@@ -76,7 +75,7 @@ public class GsonFactoryBeanTests {
StringBean bean = new StringBean();
bean.setName("Jason");
String result = gson.toJson(bean);
assertEquals("{\"name\":\"Jason\"}", result);
assertThat(result).isEqualTo("{\"name\":\"Jason\"}");
}
@Test
@@ -87,7 +86,7 @@ public class GsonFactoryBeanTests {
StringBean bean = new StringBean();
bean.setName("Bob=Bob");
String result = gson.toJson(bean);
assertEquals("{\"name\":\"Bob=Bob\"}", result);
assertThat(result).isEqualTo("{\"name\":\"Bob=Bob\"}");
}
@Test
@@ -98,7 +97,7 @@ public class GsonFactoryBeanTests {
StringBean bean = new StringBean();
bean.setName("Bob=Bob");
String result = gson.toJson(bean);
assertEquals("{\"name\":\"Bob\\u003dBob\"}", result);
assertThat(result).isEqualTo("{\"name\":\"Bob\\u003dBob\"}");
}
@Test
@@ -115,7 +114,7 @@ public class GsonFactoryBeanTests {
Date date = cal.getTime();
bean.setDate(date);
String result = gson.toJson(bean);
assertEquals("{\"date\":\"2014-01-01\"}", result);
assertThat(result).isEqualTo("{\"date\":\"2014-01-01\"}");
}
@Test
@@ -131,8 +130,8 @@ public class GsonFactoryBeanTests {
Date date = cal.getTime();
bean.setDate(date);
String result = gson.toJson(bean);
assertTrue(result.startsWith("{\"date\":\"Jan 1, 2014"));
assertTrue(result.endsWith("12:00:00 AM\"}"));
assertThat(result.startsWith("{\"date\":\"Jan 1, 2014")).isTrue();
assertThat(result.endsWith("12:00:00 AM\"}")).isTrue();
}
@Test
@@ -143,7 +142,7 @@ public class GsonFactoryBeanTests {
ByteArrayBean bean = new ByteArrayBean();
bean.setBytes(new byte[] {0x1, 0x2});
String result = gson.toJson(bean);
assertEquals("{\"bytes\":\"AQI\\u003d\"}", result);
assertThat(result).isEqualTo("{\"bytes\":\"AQI\\u003d\"}");
}
@Test
@@ -155,7 +154,7 @@ public class GsonFactoryBeanTests {
ByteArrayBean bean = new ByteArrayBean();
bean.setBytes(new byte[] {0x1, 0x2});
String result = gson.toJson(bean);
assertEquals("{\"bytes\":\"AQI=\"}", result);
assertThat(result).isEqualTo("{\"bytes\":\"AQI=\"}");
}
@Test
@@ -166,7 +165,7 @@ public class GsonFactoryBeanTests {
ByteArrayBean bean = new ByteArrayBean();
bean.setBytes(new byte[] {0x1, 0x2});
String result = gson.toJson(bean);
assertEquals("{\"bytes\":[1,2]}", result);
assertThat(result).isEqualTo("{\"bytes\":[1,2]}");
}

126
spring-web/src/test/java/org/springframework/http/converter/json/GsonHttpMessageConverterTests.java
View File

@@ -35,10 +35,9 @@ import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
import org.springframework.http.converter.HttpMessageNotReadableException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.within;
/**
* Gson 2.x converter tests.
@@ -53,20 +52,20 @@ public class GsonHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(this.converter.canRead(MyBean.class, new MediaType("application", "json")));
assertTrue(this.converter.canRead(Map.class, new MediaType("application", "json")));
assertThat(this.converter.canRead(MyBean.class, new MediaType("application", "json"))).isTrue();
assertThat(this.converter.canRead(Map.class, new MediaType("application", "json"))).isTrue();
}
@Test
public void canWrite() {
assertTrue(this.converter.canWrite(MyBean.class, new MediaType("application", "json")));
assertTrue(this.converter.canWrite(Map.class, new MediaType("application", "json")));
assertThat(this.converter.canWrite(MyBean.class, new MediaType("application", "json"))).isTrue();
assertThat(this.converter.canWrite(Map.class, new MediaType("application", "json"))).isTrue();
}
@Test
public void canReadAndWriteMicroformats() {
assertTrue(this.converter.canRead(MyBean.class, new MediaType("application", "vnd.test-micro-type+json")));
assertTrue(this.converter.canWrite(MyBean.class, new MediaType("application", "vnd.test-micro-type+json")));
assertThat(this.converter.canRead(MyBean.class, new MediaType("application", "vnd.test-micro-type+json"))).isTrue();
assertThat(this.converter.canWrite(MyBean.class, new MediaType("application", "vnd.test-micro-type+json"))).isTrue();
}
@Test
@@ -77,12 +76,13 @@ public class GsonHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
MyBean result = (MyBean) this.converter.read(MyBean.class, inputMessage);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
}
@Test
@@ -93,22 +93,23 @@ public class GsonHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
HashMap<String, Object> result = (HashMap<String, Object>) this.converter.read(HashMap.class, inputMessage);
assertEquals("Foo", result.get("string"));
assertThat(result.get("string")).isEqualTo("Foo");
Number n = (Number) result.get("number");
assertEquals(42, n.longValue());
assertThat(n.longValue()).isEqualTo(42);
n = (Number) result.get("fraction");
assertEquals(42D, n.doubleValue(), 0D);
assertThat(n.doubleValue()).isCloseTo(42D, within(0D));
List<String> array = new ArrayList<>();
array.add("Foo");
array.add("Bar");
assertEquals(array, result.get("array"));
assertEquals(Boolean.TRUE, result.get("bool"));
assertThat(result.get("array")).isEqualTo(array);
assertThat(result.get("bool")).isEqualTo(Boolean.TRUE);
byte[] bytes = new byte[2];
List<Number> resultBytes = (ArrayList<Number>)result.get("bytes");
for (int i = 0; i < 2; i++) {
bytes[i] = resultBytes.get(i).byteValue();
}
assertArrayEquals(new byte[] {0x1, 0x2}, bytes);
assertThat(bytes).isEqualTo(new byte[] {0x1, 0x2});
}
@Test
@@ -124,14 +125,13 @@ public class GsonHttpMessageConverterTests {
this.converter.write(body, null, outputMessage);
Charset utf8 = StandardCharsets.UTF_8;
String result = outputMessage.getBodyAsString(utf8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertTrue(result.contains("fraction\":42.0"));
assertTrue(result.contains("\"array\":[\"Foo\",\"Bar\"]"));
assertTrue(result.contains("\"bool\":true"));
assertTrue(result.contains("\"bytes\":[1,2]"));
assertEquals("Invalid content-type", new MediaType("application", "json", utf8),
outputMessage.getHeaders().getContentType());
assertThat(result.contains("\"string\":\"Foo\"")).isTrue();
assertThat(result.contains("\"number\":42")).isTrue();
assertThat(result.contains("fraction\":42.0")).isTrue();
assertThat(result.contains("\"array\":[\"Foo\",\"Bar\"]")).isTrue();
assertThat(result.contains("\"bool\":true")).isTrue();
assertThat(result.contains("\"bytes\":[1,2]")).isTrue();
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "json", utf8));
}
@Test
@@ -147,14 +147,13 @@ public class GsonHttpMessageConverterTests {
this.converter.write(body, MyBase.class, null, outputMessage);
Charset utf8 = StandardCharsets.UTF_8;
String result = outputMessage.getBodyAsString(utf8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertTrue(result.contains("fraction\":42.0"));
assertTrue(result.contains("\"array\":[\"Foo\",\"Bar\"]"));
assertTrue(result.contains("\"bool\":true"));
assertTrue(result.contains("\"bytes\":[1,2]"));
assertEquals("Invalid content-type", new MediaType("application", "json", utf8),
outputMessage.getHeaders().getContentType());
assertThat(result.contains("\"string\":\"Foo\"")).isTrue();
assertThat(result.contains("\"number\":42")).isTrue();
assertThat(result.contains("fraction\":42.0")).isTrue();
assertThat(result.contains("\"array\":[\"Foo\",\"Bar\"]")).isTrue();
assertThat(result.contains("\"bool\":true")).isTrue();
assertThat(result.contains("\"bytes\":[1,2]")).isTrue();
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "json", utf8));
}
@Test
@@ -163,8 +162,8 @@ public class GsonHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
String body = "H\u00e9llo W\u00f6rld";
this.converter.write(body, contentType, outputMessage);
assertEquals("Invalid result", "\"" + body + "\"", outputMessage.getBodyAsString(StandardCharsets.UTF_16BE));
assertEquals("Invalid content-type", contentType, outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_16BE)).as("Invalid result").isEqualTo(("\"" + body + "\""));
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(contentType);
}
@Test
@@ -188,14 +187,15 @@ public class GsonHttpMessageConverterTests {
Type genericType = beansList.getGenericType();
List<MyBean> results = (List<MyBean>) converter.read(genericType, MyBeanListHolder.class, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, genericType, new MediaType("application", "json"), outputMessage);
@@ -214,14 +214,15 @@ public class GsonHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
List<MyBean> results = (List<MyBean>) converter.read(beansList.getType(), null, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, beansList.getType(), new MediaType("application", "json"), outputMessage);
@@ -240,14 +241,15 @@ public class GsonHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
List<MyBean> results = (List<MyBean>) converter.read(beansList.getType(), null, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, baseList.getType(), new MediaType("application", "json"), outputMessage);
@@ -259,7 +261,7 @@ public class GsonHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
this.converter.setPrefixJson(true);
this.converter.writeInternal("foo", null, outputMessage);
assertEquals(")]}', \"foo\"", outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo(")]}', \"foo\"");
}
@Test
@@ -267,7 +269,7 @@ public class GsonHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
this.converter.setJsonPrefix(")))");
this.converter.writeInternal("foo", null, outputMessage);
assertEquals(")))\"foo\"", outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo(")))\"foo\"");
}

220
spring-web/src/test/java/org/springframework/http/converter/json/Jackson2ObjectMapperBuilderTests.java
View File

@@ -86,12 +86,6 @@ import org.springframework.util.StringUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Test class for {@link Jackson2ObjectMapperBuilder}.
@@ -116,15 +110,15 @@ public class Jackson2ObjectMapperBuilderTests {
@Test
public void defaultProperties() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
assertNotNull(objectMapper);
assertFalse(objectMapper.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION));
assertFalse(objectMapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertTrue(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertTrue(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
assertTrue(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_IS_GETTERS));
assertTrue(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_SETTERS));
assertFalse(objectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT));
assertTrue(objectMapper.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS));
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION)).isFalse();
assertThat(objectMapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isFalse();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_FIELDS)).isTrue();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_GETTERS)).isTrue();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_IS_GETTERS)).isTrue();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_SETTERS)).isTrue();
assertThat(objectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT)).isFalse();
assertThat(objectMapper.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)).isTrue();
}
@Test
@@ -132,15 +126,15 @@ public class Jackson2ObjectMapperBuilderTests {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().autoDetectFields(false)
.defaultViewInclusion(true).failOnUnknownProperties(true).failOnEmptyBeans(false)
.autoDetectGettersSetters(false).indentOutput(true).build();
assertNotNull(objectMapper);
assertTrue(objectMapper.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION));
assertTrue(objectMapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertFalse(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
assertFalse(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_IS_GETTERS));
assertFalse(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_SETTERS));
assertTrue(objectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT));
assertFalse(objectMapper.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS));
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION)).isTrue();
assertThat(objectMapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isTrue();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_FIELDS)).isFalse();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_GETTERS)).isFalse();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_IS_GETTERS)).isFalse();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_SETTERS)).isFalse();
assertThat(objectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT)).isTrue();
assertThat(objectMapper.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)).isFalse();
}
@Test
@@ -153,69 +147,69 @@ public class Jackson2ObjectMapperBuilderTests {
MapperFeature.AUTO_DETECT_GETTERS,
MapperFeature.AUTO_DETECT_SETTERS,
SerializationFeature.FAIL_ON_EMPTY_BEANS).build();
assertNotNull(objectMapper);
assertTrue(objectMapper.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION));
assertTrue(objectMapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertFalse(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
assertFalse(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_SETTERS));
assertTrue(objectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT));
assertFalse(objectMapper.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS));
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION)).isTrue();
assertThat(objectMapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isTrue();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_FIELDS)).isFalse();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_GETTERS)).isFalse();
assertThat(objectMapper.isEnabled(MapperFeature.AUTO_DETECT_SETTERS)).isFalse();
assertThat(objectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT)).isTrue();
assertThat(objectMapper.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)).isFalse();
}
@Test
public void setNotNullSerializationInclusion() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
assertSame(JsonInclude.Include.ALWAYS, objectMapper.getSerializationConfig().getSerializationInclusion());
assertThat(objectMapper.getSerializationConfig().getSerializationInclusion()).isSameAs(JsonInclude.Include.ALWAYS);
objectMapper = Jackson2ObjectMapperBuilder.json().serializationInclusion(JsonInclude.Include.NON_NULL).build();
assertSame(JsonInclude.Include.NON_NULL, objectMapper.getSerializationConfig().getSerializationInclusion());
assertThat(objectMapper.getSerializationConfig().getSerializationInclusion()).isSameAs(JsonInclude.Include.NON_NULL);
}
@Test
public void setNotDefaultSerializationInclusion() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
assertSame(JsonInclude.Include.ALWAYS, objectMapper.getSerializationConfig().getSerializationInclusion());
assertThat(objectMapper.getSerializationConfig().getSerializationInclusion()).isSameAs(JsonInclude.Include.ALWAYS);
objectMapper = Jackson2ObjectMapperBuilder.json().serializationInclusion(JsonInclude.Include.NON_DEFAULT).build();
assertSame(JsonInclude.Include.NON_DEFAULT, objectMapper.getSerializationConfig().getSerializationInclusion());
assertThat(objectMapper.getSerializationConfig().getSerializationInclusion()).isSameAs(JsonInclude.Include.NON_DEFAULT);
}
@Test
public void setNotEmptySerializationInclusion() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
assertSame(JsonInclude.Include.ALWAYS, objectMapper.getSerializationConfig().getSerializationInclusion());
assertThat(objectMapper.getSerializationConfig().getSerializationInclusion()).isSameAs(JsonInclude.Include.ALWAYS);
objectMapper = Jackson2ObjectMapperBuilder.json().serializationInclusion(JsonInclude.Include.NON_EMPTY).build();
assertSame(JsonInclude.Include.NON_EMPTY, objectMapper.getSerializationConfig().getSerializationInclusion());
assertThat(objectMapper.getSerializationConfig().getSerializationInclusion()).isSameAs(JsonInclude.Include.NON_EMPTY);
}
@Test
public void dateTimeFormatSetter() {
SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().dateFormat(dateFormat).build();
assertEquals(dateFormat, objectMapper.getSerializationConfig().getDateFormat());
assertEquals(dateFormat, objectMapper.getDeserializationConfig().getDateFormat());
assertThat(objectMapper.getSerializationConfig().getDateFormat()).isEqualTo(dateFormat);
assertThat(objectMapper.getDeserializationConfig().getDateFormat()).isEqualTo(dateFormat);
}
@Test
public void simpleDateFormatStringSetter() {
SimpleDateFormat dateFormat = new SimpleDateFormat(DATE_FORMAT);
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().simpleDateFormat(DATE_FORMAT).build();
assertEquals(dateFormat, objectMapper.getSerializationConfig().getDateFormat());
assertEquals(dateFormat, objectMapper.getDeserializationConfig().getDateFormat());
assertThat(objectMapper.getSerializationConfig().getDateFormat()).isEqualTo(dateFormat);
assertThat(objectMapper.getDeserializationConfig().getDateFormat()).isEqualTo(dateFormat);
}
@Test
public void localeSetter() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().locale(Locale.FRENCH).build();
assertEquals(Locale.FRENCH, objectMapper.getSerializationConfig().getLocale());
assertEquals(Locale.FRENCH, objectMapper.getDeserializationConfig().getLocale());
assertThat(objectMapper.getSerializationConfig().getLocale()).isEqualTo(Locale.FRENCH);
assertThat(objectMapper.getDeserializationConfig().getLocale()).isEqualTo(Locale.FRENCH);
}
@Test
public void timeZoneSetter() {
TimeZone timeZone = TimeZone.getTimeZone("Europe/Paris");
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().timeZone(timeZone).build();
assertEquals(timeZone, objectMapper.getSerializationConfig().getTimeZone());
assertEquals(timeZone, objectMapper.getDeserializationConfig().getTimeZone());
assertThat(objectMapper.getSerializationConfig().getTimeZone()).isEqualTo(timeZone);
assertThat(objectMapper.getDeserializationConfig().getTimeZone()).isEqualTo(timeZone);
}
@Test
@@ -223,8 +217,8 @@ public class Jackson2ObjectMapperBuilderTests {
String zoneId = "Europe/Paris";
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().timeZone(zoneId).build();
TimeZone timeZone = TimeZone.getTimeZone(zoneId);
assertEquals(timeZone, objectMapper.getSerializationConfig().getTimeZone());
assertEquals(timeZone, objectMapper.getDeserializationConfig().getTimeZone());
assertThat(objectMapper.getSerializationConfig().getTimeZone()).isEqualTo(timeZone);
assertThat(objectMapper.getDeserializationConfig().getTimeZone()).isEqualTo(timeZone);
}
@Test
@@ -241,7 +235,7 @@ public class Jackson2ObjectMapperBuilderTests {
module.addSerializer(Integer.class, serializer1);
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().modules(module).build();
Serializers serializers = getSerializerFactoryConfig(objectMapper).serializers().iterator().next();
assertSame(serializer1, serializers.findSerializer(null, SimpleType.construct(Integer.class), null));
assertThat(serializers.findSerializer(null, SimpleType.construct(Integer.class), null)).isSameAs(serializer1);
}
@Test
@@ -251,8 +245,7 @@ public class Jackson2ObjectMapperBuilderTests {
.modulesToInstall(CustomIntegerModule.class)
.build();
Serializers serializers = getSerializerFactoryConfig(objectMapper).serializers().iterator().next();
assertSame(CustomIntegerSerializer.class,
serializers.findSerializer(null, SimpleType.construct(Integer.class), null).getClass());
assertThat(serializers.findSerializer(null, SimpleType.construct(Integer.class), null).getClass()).isSameAs(CustomIntegerSerializer.class);
}
@Test
@@ -261,8 +254,7 @@ public class Jackson2ObjectMapperBuilderTests {
.modulesToInstall(new CustomIntegerModule())
.build();
Serializers serializers = getSerializerFactoryConfig(objectMapper).serializers().iterator().next();
assertSame(CustomIntegerSerializer.class,
serializers.findSerializer(null, SimpleType.construct(Integer.class), null).getClass());
assertThat(serializers.findSerializer(null, SimpleType.construct(Integer.class), null).getClass()).isSameAs(CustomIntegerSerializer.class);
}
@Test
@@ -271,17 +263,17 @@ public class Jackson2ObjectMapperBuilderTests {
Long timestamp = 1322903730000L;
DateTime dateTime = new DateTime(timestamp, DateTimeZone.UTC);
assertEquals(timestamp.toString(), new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8")).isEqualTo(timestamp.toString());
Path file = Paths.get("foo");
assertTrue(new String(objectMapper.writeValueAsBytes(file), "UTF-8").endsWith("foo\""));
assertThat(new String(objectMapper.writeValueAsBytes(file), "UTF-8").endsWith("foo\"")).isTrue();
Optional<String> optional = Optional.of("test");
assertEquals("\"test\"", new String(objectMapper.writeValueAsBytes(optional), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(optional), "UTF-8")).isEqualTo("\"test\"");
// Kotlin module
IntRange range = new IntRange(1, 3);
assertEquals("{\"start\":1,\"end\":3}", new String(objectMapper.writeValueAsBytes(range), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(range), "UTF-8")).isEqualTo("{\"start\":1,\"end\":3}");
}
@Test // SPR-12634
@@ -292,7 +284,7 @@ public class Jackson2ObjectMapperBuilderTests {
.modulesToInstall(new CustomIntegerModule())
.build();
DateTime dateTime = new DateTime(1322903730000L, DateTimeZone.UTC);
assertEquals("1322903730000", new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8")).isEqualTo("1322903730000");
assertThat(new String(objectMapper.writeValueAsBytes(new Integer(4)), "UTF-8")).contains("customid");
}
@@ -305,7 +297,7 @@ public class Jackson2ObjectMapperBuilderTests {
.modulesToInstall(CustomIntegerModule.class)
.build();
DateTime dateTime = new DateTime(1322903730000L, DateTimeZone.UTC);
assertEquals("1322903730000", new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8")).isEqualTo("1322903730000");
assertThat(new String(objectMapper.writeValueAsBytes(new Integer(4)), "UTF-8")).contains("customid");
}
@@ -316,7 +308,7 @@ public class Jackson2ObjectMapperBuilderTests {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json()
.serializerByType(Integer.class, new CustomIntegerSerializer()).build();
DateTime dateTime = new DateTime(1322903730000L, DateTimeZone.UTC);
assertEquals("1322903730000", new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8")).isEqualTo("1322903730000");
assertThat(new String(objectMapper.writeValueAsBytes(new Integer(4)), "UTF-8")).contains("customid");
}
@@ -329,7 +321,7 @@ public class Jackson2ObjectMapperBuilderTests {
builder.featuresToDisable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
ObjectMapper objectMapper = builder.build();
DemoPojo demoPojo = objectMapper.readValue(DATA, DemoPojo.class);
assertNotNull(demoPojo.getOffsetDateTime());
assertThat(demoPojo.getOffsetDateTime()).isNotNull();
}
@Test // gh-22740
@@ -341,14 +333,14 @@ public class Jackson2ObjectMapperBuilderTests {
barModule.addSerializer(new BarSerializer());
builder.modulesToInstall(fooModule, barModule);
ObjectMapper objectMapper = builder.build();
assertEquals(1, StreamSupport
.stream(getSerializerFactoryConfig(objectMapper).serializers().spliterator(), false)
.filter(s -> s.findSerializer(null, SimpleType.construct(Foo.class), null) != null)
.count());
assertEquals(1, StreamSupport
.stream(getSerializerFactoryConfig(objectMapper).serializers().spliterator(), false)
.filter(s -> s.findSerializer(null, SimpleType.construct(Bar.class), null) != null)
.count());
assertThat(StreamSupport
.stream(getSerializerFactoryConfig(objectMapper).serializers().spliterator(), false)
.filter(s -> s.findSerializer(null, SimpleType.construct(Foo.class), null) != null)
.count()).isEqualTo(1);
assertThat(StreamSupport
.stream(getSerializerFactoryConfig(objectMapper).serializers().spliterator(), false)
.filter(s -> s.findSerializer(null, SimpleType.construct(Bar.class), null) != null)
.count()).isEqualTo(1);
}
private static SerializerFactoryConfig getSerializerFactoryConfig(ObjectMapper objectMapper) {
@@ -363,8 +355,8 @@ public class Jackson2ObjectMapperBuilderTests {
public void propertyNamingStrategy() {
PropertyNamingStrategy strategy = new PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy();
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().propertyNamingStrategy(strategy).build();
assertSame(strategy, objectMapper.getSerializationConfig().getPropertyNamingStrategy());
assertSame(strategy, objectMapper.getDeserializationConfig().getPropertyNamingStrategy());
assertThat(objectMapper.getSerializationConfig().getPropertyNamingStrategy()).isSameAs(strategy);
assertThat(objectMapper.getDeserializationConfig().getPropertyNamingStrategy()).isSameAs(strategy);
}
@Test
@@ -374,9 +366,9 @@ public class Jackson2ObjectMapperBuilderTests {
.modules(new ArrayList<>()) // Disable well-known modules detection
.serializerByType(Boolean.class, serializer)
.build();
assertTrue(getSerializerFactoryConfig(objectMapper).hasSerializers());
assertThat(getSerializerFactoryConfig(objectMapper).hasSerializers()).isTrue();
Serializers serializers = getSerializerFactoryConfig(objectMapper).serializers().iterator().next();
assertSame(serializer, serializers.findSerializer(null, SimpleType.construct(Boolean.class), null));
assertThat(serializers.findSerializer(null, SimpleType.construct(Boolean.class), null)).isSameAs(serializer);
}
@Test
@@ -386,9 +378,9 @@ public class Jackson2ObjectMapperBuilderTests {
.modules(new ArrayList<>()) // Disable well-known modules detection
.deserializerByType(Date.class, deserializer)
.build();
assertTrue(getDeserializerFactoryConfig(objectMapper).hasDeserializers());
assertThat(getDeserializerFactoryConfig(objectMapper).hasDeserializers()).isTrue();
Deserializers deserializers = getDeserializerFactoryConfig(objectMapper).deserializers().iterator().next();
assertSame(deserializer, deserializers.findBeanDeserializer(SimpleType.construct(Date.class), null, null));
assertThat(deserializers.findBeanDeserializer(SimpleType.construct(Date.class), null, null)).isSameAs(deserializer);
}
@Test
@@ -400,8 +392,8 @@ public class Jackson2ObjectMapperBuilderTests {
.modules().mixIn(target, mixInSource)
.build();
assertEquals(1, objectMapper.mixInCount());
assertSame(mixInSource, objectMapper.findMixInClassFor(target));
assertThat(objectMapper.mixInCount()).isEqualTo(1);
assertThat(objectMapper.findMixInClassFor(target)).isSameAs(mixInSource);
}
@Test
@@ -415,8 +407,8 @@ public class Jackson2ObjectMapperBuilderTests {
.modules().mixIns(mixIns)
.build();
assertEquals(1, objectMapper.mixInCount());
assertSame(mixInSource, objectMapper.findMixInClassFor(target));
assertThat(objectMapper.mixInCount()).isEqualTo(1);
assertThat(objectMapper.findMixInClassFor(target)).isSameAs(mixInSource);
}
@Test
@@ -467,47 +459,47 @@ public class Jackson2ObjectMapperBuilderTests {
ObjectMapper mapper = new ObjectMapper();
builder.configure(mapper);
assertTrue(getSerializerFactoryConfig(mapper).hasSerializers());
assertTrue(getDeserializerFactoryConfig(mapper).hasDeserializers());
assertThat(getSerializerFactoryConfig(mapper).hasSerializers()).isTrue();
assertThat(getDeserializerFactoryConfig(mapper).hasDeserializers()).isTrue();
Serializers serializers = getSerializerFactoryConfig(mapper).serializers().iterator().next();
assertSame(serializer1, serializers.findSerializer(null, SimpleType.construct(Class.class), null));
assertSame(serializer2, serializers.findSerializer(null, SimpleType.construct(Boolean.class), null));
assertNull(serializers.findSerializer(null, SimpleType.construct(Number.class), null));
assertThat(serializers.findSerializer(null, SimpleType.construct(Class.class), null)).isSameAs(serializer1);
assertThat(serializers.findSerializer(null, SimpleType.construct(Boolean.class), null)).isSameAs(serializer2);
assertThat(serializers.findSerializer(null, SimpleType.construct(Number.class), null)).isNull();
Deserializers deserializers = getDeserializerFactoryConfig(mapper).deserializers().iterator().next();
assertSame(deserializer, deserializers.findBeanDeserializer(SimpleType.construct(Date.class), null, null));
assertThat(deserializers.findBeanDeserializer(SimpleType.construct(Date.class), null, null)).isSameAs(deserializer);
assertSame(annotationIntrospector, mapper.getSerializationConfig().getAnnotationIntrospector());
assertSame(annotationIntrospector, mapper.getDeserializationConfig().getAnnotationIntrospector());
assertThat(mapper.getSerializationConfig().getAnnotationIntrospector()).isSameAs(annotationIntrospector);
assertThat(mapper.getDeserializationConfig().getAnnotationIntrospector()).isSameAs(annotationIntrospector);
assertTrue(mapper.getSerializationConfig().isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS));
assertTrue(mapper.getDeserializationConfig().isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE));
assertTrue(mapper.getFactory().isEnabled(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER));
assertTrue(mapper.getFactory().isEnabled(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS));
assertThat(mapper.getSerializationConfig().isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)).isTrue();
assertThat(mapper.getDeserializationConfig().isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE)).isTrue();
assertThat(mapper.getFactory().isEnabled(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER)).isTrue();
assertThat(mapper.getFactory().isEnabled(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS)).isTrue();
assertFalse(mapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
assertFalse(mapper.getDeserializationConfig().isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION));
assertFalse(mapper.getDeserializationConfig().isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertFalse(mapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(mapper.getFactory().isEnabled(JsonParser.Feature.AUTO_CLOSE_SOURCE));
assertFalse(mapper.getFactory().isEnabled(JsonGenerator.Feature.QUOTE_FIELD_NAMES));
assertSame(JsonInclude.Include.NON_NULL, mapper.getSerializationConfig().getSerializationInclusion());
assertThat(mapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_GETTERS)).isFalse();
assertThat(mapper.getDeserializationConfig().isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION)).isFalse();
assertThat(mapper.getDeserializationConfig().isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isFalse();
assertThat(mapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS)).isFalse();
assertThat(mapper.getFactory().isEnabled(JsonParser.Feature.AUTO_CLOSE_SOURCE)).isFalse();
assertThat(mapper.getFactory().isEnabled(JsonGenerator.Feature.QUOTE_FIELD_NAMES)).isFalse();
assertThat(mapper.getSerializationConfig().getSerializationInclusion()).isSameAs(JsonInclude.Include.NON_NULL);
}
@Test
public void xmlMapper() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.xml().build();
assertNotNull(objectMapper);
assertEquals(XmlMapper.class, objectMapper.getClass());
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.getClass()).isEqualTo(XmlMapper.class);
}
@Test // gh-22428
public void xmlMapperAndCustomFactory() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.xml().factory(new MyXmlFactory()).build();
assertNotNull(objectMapper);
assertEquals(XmlMapper.class, objectMapper.getClass());
assertEquals(MyXmlFactory.class, objectMapper.getFactory().getClass());
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.getClass()).isEqualTo(XmlMapper.class);
assertThat(objectMapper.getFactory().getClass()).isEqualTo(MyXmlFactory.class);
}
@Test
@@ -515,16 +507,16 @@ public class Jackson2ObjectMapperBuilderTests {
Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json().indentOutput(true);
ObjectMapper jsonObjectMapper = builder.build();
ObjectMapper xmlObjectMapper = builder.createXmlMapper(true).build();
assertTrue(jsonObjectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT));
assertTrue(xmlObjectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT));
assertTrue(xmlObjectMapper.getClass().isAssignableFrom(XmlMapper.class));
assertThat(jsonObjectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT)).isTrue();
assertThat(xmlObjectMapper.isEnabled(SerializationFeature.INDENT_OUTPUT)).isTrue();
assertThat(xmlObjectMapper.getClass().isAssignableFrom(XmlMapper.class)).isTrue();
}
@Test // SPR-13975
public void defaultUseWrapper() throws JsonProcessingException {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.xml().defaultUseWrapper(false).build();
assertNotNull(objectMapper);
assertEquals(XmlMapper.class, objectMapper.getClass());
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.getClass()).isEqualTo(XmlMapper.class);
ListContainer<String> container = new ListContainer<>(Arrays.asList("foo", "bar"));
String output = objectMapper.writeValueAsString(container);
assertThat(output).contains("<list>foo</list><list>bar</list></ListContainer>");
@@ -533,22 +525,22 @@ public class Jackson2ObjectMapperBuilderTests {
@Test // SPR-14435
public void smile() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.smile().build();
assertNotNull(objectMapper);
assertEquals(SmileFactory.class, objectMapper.getFactory().getClass());
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.getFactory().getClass()).isEqualTo(SmileFactory.class);
}
@Test // SPR-14435
public void cbor() {
ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.cbor().build();
assertNotNull(objectMapper);
assertEquals(CBORFactory.class, objectMapper.getFactory().getClass());
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.getFactory().getClass()).isEqualTo(CBORFactory.class);
}
@Test // SPR-14435
public void factory() {
ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder().factory(new SmileFactory()).build();
assertNotNull(objectMapper);
assertEquals(SmileFactory.class, objectMapper.getFactory().getClass());
assertThat(objectMapper).isNotNull();
assertThat(objectMapper.getFactory().getClass()).isEqualTo(SmileFactory.class);
}

138
spring-web/src/test/java/org/springframework/http/converter/json/Jackson2ObjectMapperFactoryBeanTests.java
View File

@@ -66,12 +66,6 @@ import org.springframework.beans.FatalBeanException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Test cases for {@link Jackson2ObjectMapperFactoryBean}.
@@ -109,41 +103,41 @@ public class Jackson2ObjectMapperFactoryBeanTests {
ObjectMapper objectMapper = this.factory.getObject();
assertFalse(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
assertFalse(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_SETTERS));
assertFalse(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION));
assertFalse(objectMapper.getSerializationConfig().isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS));
assertTrue(objectMapper.getSerializationConfig().isEnabled(SerializationFeature.INDENT_OUTPUT));
assertSame(Include.ALWAYS, objectMapper.getSerializationConfig().getSerializationInclusion());
assertThat(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS)).isFalse();
assertThat(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS)).isFalse();
assertThat(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_GETTERS)).isFalse();
assertThat(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_SETTERS)).isFalse();
assertThat(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION)).isFalse();
assertThat(objectMapper.getSerializationConfig().isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)).isFalse();
assertThat(objectMapper.getSerializationConfig().isEnabled(SerializationFeature.INDENT_OUTPUT)).isTrue();
assertThat(objectMapper.getSerializationConfig().getSerializationInclusion()).isSameAs(Include.ALWAYS);
}
@Test
public void defaultSerializationInclusion() {
this.factory.afterPropertiesSet();
assertSame(Include.ALWAYS, this.factory.getObject().getSerializationConfig().getSerializationInclusion());
assertThat(this.factory.getObject().getSerializationConfig().getSerializationInclusion()).isSameAs(Include.ALWAYS);
}
@Test
public void nonNullSerializationInclusion() {
this.factory.setSerializationInclusion(Include.NON_NULL);
this.factory.afterPropertiesSet();
assertSame(Include.NON_NULL, this.factory.getObject().getSerializationConfig().getSerializationInclusion());
assertThat(this.factory.getObject().getSerializationConfig().getSerializationInclusion()).isSameAs(Include.NON_NULL);
}
@Test
public void nonDefaultSerializationInclusion() {
this.factory.setSerializationInclusion(Include.NON_DEFAULT);
this.factory.afterPropertiesSet();
assertSame(Include.NON_DEFAULT, this.factory.getObject().getSerializationConfig().getSerializationInclusion());
assertThat(this.factory.getObject().getSerializationConfig().getSerializationInclusion()).isSameAs(Include.NON_DEFAULT);
}
@Test
public void nonEmptySerializationInclusion() {
this.factory.setSerializationInclusion(Include.NON_EMPTY);
this.factory.afterPropertiesSet();
assertSame(Include.NON_EMPTY, this.factory.getObject().getSerializationConfig().getSerializationInclusion());
assertThat(this.factory.getObject().getSerializationConfig().getSerializationInclusion()).isSameAs(Include.NON_EMPTY);
}
@Test
@@ -151,8 +145,8 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.setDateFormat(this.dateFormat);
this.factory.afterPropertiesSet();
assertEquals(this.dateFormat, this.factory.getObject().getSerializationConfig().getDateFormat());
assertEquals(this.dateFormat, this.factory.getObject().getDeserializationConfig().getDateFormat());
assertThat(this.factory.getObject().getSerializationConfig().getDateFormat()).isEqualTo(this.dateFormat);
assertThat(this.factory.getObject().getDeserializationConfig().getDateFormat()).isEqualTo(this.dateFormat);
}
@Test
@@ -160,8 +154,8 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.setSimpleDateFormat(DATE_FORMAT);
this.factory.afterPropertiesSet();
assertEquals(this.dateFormat, this.factory.getObject().getSerializationConfig().getDateFormat());
assertEquals(this.dateFormat, this.factory.getObject().getDeserializationConfig().getDateFormat());
assertThat(this.factory.getObject().getSerializationConfig().getDateFormat()).isEqualTo(this.dateFormat);
assertThat(this.factory.getObject().getDeserializationConfig().getDateFormat()).isEqualTo(this.dateFormat);
}
@Test
@@ -169,8 +163,8 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.setLocale(Locale.FRENCH);
this.factory.afterPropertiesSet();
assertEquals(Locale.FRENCH, this.factory.getObject().getSerializationConfig().getLocale());
assertEquals(Locale.FRENCH, this.factory.getObject().getDeserializationConfig().getLocale());
assertThat(this.factory.getObject().getSerializationConfig().getLocale()).isEqualTo(Locale.FRENCH);
assertThat(this.factory.getObject().getDeserializationConfig().getLocale()).isEqualTo(Locale.FRENCH);
}
@Test
@@ -180,8 +174,8 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.setTimeZone(timeZone);
this.factory.afterPropertiesSet();
assertEquals(timeZone, this.factory.getObject().getSerializationConfig().getTimeZone());
assertEquals(timeZone, this.factory.getObject().getDeserializationConfig().getTimeZone());
assertThat(this.factory.getObject().getSerializationConfig().getTimeZone()).isEqualTo(timeZone);
assertThat(this.factory.getObject().getDeserializationConfig().getTimeZone()).isEqualTo(timeZone);
}
@Test
@@ -190,8 +184,8 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.afterPropertiesSet();
TimeZone timeZone = TimeZone.getTimeZone("GMT");
assertEquals(timeZone, this.factory.getObject().getSerializationConfig().getTimeZone());
assertEquals(timeZone, this.factory.getObject().getDeserializationConfig().getTimeZone());
assertThat(this.factory.getObject().getSerializationConfig().getTimeZone()).isEqualTo(timeZone);
assertThat(this.factory.getObject().getDeserializationConfig().getTimeZone()).isEqualTo(timeZone);
}
@Test
@@ -205,7 +199,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
ObjectMapper objectMapper = this.factory.getObject();
Serializers serializers = getSerializerFactoryConfig(objectMapper).serializers().iterator().next();
assertSame(serializer, serializers.findSerializer(null, SimpleType.construct(Integer.class), null));
assertThat(serializers.findSerializer(null, SimpleType.construct(Integer.class), null)).isSameAs(serializer);
}
@Test
@@ -215,7 +209,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
Long timestamp = 1322903730000L;
DateTime dateTime = new DateTime(timestamp, DateTimeZone.UTC);
assertEquals(timestamp.toString(), new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8")).isEqualTo(timestamp.toString());
}
@Test // SPR-12634
@@ -226,7 +220,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
ObjectMapper objectMapper = this.factory.getObject();
DateTime dateTime = new DateTime(1322903730000L, DateTimeZone.UTC);
assertEquals("1322903730000", new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8")).isEqualTo("1322903730000");
assertThat(new String(objectMapper.writeValueAsBytes(new Integer(4)), "UTF-8")).contains("customid");
}
@@ -240,7 +234,7 @@ public class Jackson2ObjectMapperFactoryBeanTests {
ObjectMapper objectMapper = this.factory.getObject();
DateTime dateTime = new DateTime(1322903730000L, DateTimeZone.UTC);
assertEquals("1322903730000", new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8"));
assertThat(new String(objectMapper.writeValueAsBytes(dateTime), "UTF-8")).isEqualTo("1322903730000");
assertThat(new String(objectMapper.writeValueAsBytes(new Integer(4)), "UTF-8")).contains("customid");
}
@@ -248,14 +242,14 @@ public class Jackson2ObjectMapperFactoryBeanTests {
public void simpleSetup() {
this.factory.afterPropertiesSet();
assertNotNull(this.factory.getObject());
assertTrue(this.factory.isSingleton());
assertEquals(ObjectMapper.class, this.factory.getObjectType());
assertThat(this.factory.getObject()).isNotNull();
assertThat(this.factory.isSingleton()).isTrue();
assertThat(this.factory.getObjectType()).isEqualTo(ObjectMapper.class);
}
@Test
public void undefinedObjectType() {
assertNull(this.factory.getObjectType());
assertThat((Object) this.factory.getObjectType()).isNull();
}
private static SerializerFactoryConfig getSerializerFactoryConfig(ObjectMapper objectMapper) {
@@ -272,8 +266,8 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.setPropertyNamingStrategy(strategy);
this.factory.afterPropertiesSet();
assertSame(strategy, this.factory.getObject().getSerializationConfig().getPropertyNamingStrategy());
assertSame(strategy, this.factory.getObject().getDeserializationConfig().getPropertyNamingStrategy());
assertThat(this.factory.getObject().getSerializationConfig().getPropertyNamingStrategy()).isSameAs(strategy);
assertThat(this.factory.getObject().getDeserializationConfig().getPropertyNamingStrategy()).isSameAs(strategy);
}
@Test
@@ -288,8 +282,8 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.afterPropertiesSet();
ObjectMapper objectMapper = this.factory.getObject();
assertEquals(1, objectMapper.mixInCount());
assertSame(mixinSource, objectMapper.findMixInClassFor(target));
assertThat(objectMapper.mixInCount()).isEqualTo(1);
assertThat(objectMapper.findMixInClassFor(target)).isSameAs(mixinSource);
}
@Test
@@ -310,8 +304,8 @@ public class Jackson2ObjectMapperFactoryBeanTests {
ObjectMapper objectMapper = new ObjectMapper();
this.factory.setObjectMapper(objectMapper);
assertTrue(this.factory.isSingleton());
assertEquals(ObjectMapper.class, this.factory.getObjectType());
assertThat(this.factory.isSingleton()).isTrue();
assertThat(this.factory.getObjectType()).isEqualTo(ObjectMapper.class);
Map<Class<?>, JsonDeserializer<?>> deserializers = new HashMap<>();
deserializers.put(Date.class, new DateDeserializer());
@@ -336,36 +330,36 @@ public class Jackson2ObjectMapperFactoryBeanTests {
JsonParser.Feature.AUTO_CLOSE_SOURCE,
JsonGenerator.Feature.QUOTE_FIELD_NAMES);
assertFalse(getSerializerFactoryConfig(objectMapper).hasSerializers());
assertFalse(getDeserializerFactoryConfig(objectMapper).hasDeserializers());
assertThat(getSerializerFactoryConfig(objectMapper).hasSerializers()).isFalse();
assertThat(getDeserializerFactoryConfig(objectMapper).hasDeserializers()).isFalse();
this.factory.setSerializationInclusion(Include.NON_NULL);
this.factory.afterPropertiesSet();
assertSame(objectMapper, this.factory.getObject());
assertTrue(getSerializerFactoryConfig(objectMapper).hasSerializers());
assertTrue(getDeserializerFactoryConfig(objectMapper).hasDeserializers());
assertThat(this.factory.getObject()).isSameAs(objectMapper);
assertThat(getSerializerFactoryConfig(objectMapper).hasSerializers()).isTrue();
assertThat(getDeserializerFactoryConfig(objectMapper).hasDeserializers()).isTrue();
Serializers serializers = getSerializerFactoryConfig(objectMapper).serializers().iterator().next();
assertSame(serializer1, serializers.findSerializer(null, SimpleType.construct(Class.class), null));
assertSame(serializer2, serializers.findSerializer(null, SimpleType.construct(Boolean.class), null));
assertNull(serializers.findSerializer(null, SimpleType.construct(Number.class), null));
assertThat(serializers.findSerializer(null, SimpleType.construct(Class.class), null)).isSameAs(serializer1);
assertThat(serializers.findSerializer(null, SimpleType.construct(Boolean.class), null)).isSameAs(serializer2);
assertThat(serializers.findSerializer(null, SimpleType.construct(Number.class), null)).isNull();
assertSame(annotationIntrospector, objectMapper.getSerializationConfig().getAnnotationIntrospector());
assertSame(annotationIntrospector, objectMapper.getDeserializationConfig().getAnnotationIntrospector());
assertThat(objectMapper.getSerializationConfig().getAnnotationIntrospector()).isSameAs(annotationIntrospector);
assertThat(objectMapper.getDeserializationConfig().getAnnotationIntrospector()).isSameAs(annotationIntrospector);
assertTrue(objectMapper.getSerializationConfig().isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS));
assertTrue(objectMapper.getDeserializationConfig().isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE));
assertTrue(objectMapper.getFactory().isEnabled(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER));
assertTrue(objectMapper.getFactory().isEnabled(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS));
assertThat(objectMapper.getSerializationConfig().isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)).isTrue();
assertThat(objectMapper.getDeserializationConfig().isEnabled(DeserializationFeature.UNWRAP_ROOT_VALUE)).isTrue();
assertThat(objectMapper.getFactory().isEnabled(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER)).isTrue();
assertThat(objectMapper.getFactory().isEnabled(JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS)).isTrue();
assertFalse(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_GETTERS));
assertFalse(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION));
assertFalse(objectMapper.getDeserializationConfig().isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES));
assertFalse(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS));
assertFalse(objectMapper.getFactory().isEnabled(JsonParser.Feature.AUTO_CLOSE_SOURCE));
assertFalse(objectMapper.getFactory().isEnabled(JsonGenerator.Feature.QUOTE_FIELD_NAMES));
assertSame(Include.NON_NULL, objectMapper.getSerializationConfig().getSerializationInclusion());
assertThat(objectMapper.getSerializationConfig().isEnabled(MapperFeature.AUTO_DETECT_GETTERS)).isFalse();
assertThat(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.DEFAULT_VIEW_INCLUSION)).isFalse();
assertThat(objectMapper.getDeserializationConfig().isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)).isFalse();
assertThat(objectMapper.getDeserializationConfig().isEnabled(MapperFeature.AUTO_DETECT_FIELDS)).isFalse();
assertThat(objectMapper.getFactory().isEnabled(JsonParser.Feature.AUTO_CLOSE_SOURCE)).isFalse();
assertThat(objectMapper.getFactory().isEnabled(JsonGenerator.Feature.QUOTE_FIELD_NAMES)).isFalse();
assertThat(objectMapper.getSerializationConfig().getSerializationInclusion()).isSameAs(Include.NON_NULL);
}
@Test
@@ -373,9 +367,9 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.setObjectMapper(new XmlMapper());
this.factory.afterPropertiesSet();
assertNotNull(this.factory.getObject());
assertTrue(this.factory.isSingleton());
assertEquals(XmlMapper.class, this.factory.getObjectType());
assertThat(this.factory.getObject()).isNotNull();
assertThat(this.factory.isSingleton()).isTrue();
assertThat(this.factory.getObjectType()).isEqualTo(XmlMapper.class);
}
@Test
@@ -383,9 +377,9 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.setCreateXmlMapper(true);
this.factory.afterPropertiesSet();
assertNotNull(this.factory.getObject());
assertTrue(this.factory.isSingleton());
assertEquals(XmlMapper.class, this.factory.getObjectType());
assertThat(this.factory.getObject()).isNotNull();
assertThat(this.factory.isSingleton()).isTrue();
assertThat(this.factory.getObjectType()).isEqualTo(XmlMapper.class);
}
@Test // SPR-14435
@@ -393,9 +387,9 @@ public class Jackson2ObjectMapperFactoryBeanTests {
this.factory.setFactory(new SmileFactory());
this.factory.afterPropertiesSet();
assertNotNull(this.factory.getObject());
assertTrue(this.factory.isSingleton());
assertEquals(SmileFactory.class, this.factory.getObject().getFactory().getClass());
assertThat(this.factory.getObject()).isNotNull();
assertThat(this.factory.isSingleton()).isTrue();
assertThat(this.factory.getObject().getFactory().getClass()).isEqualTo(SmileFactory.class);
}

126
spring-web/src/test/java/org/springframework/http/converter/json/JsonbHttpMessageConverterTests.java
View File

@@ -35,10 +35,9 @@ import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
import org.springframework.http.converter.HttpMessageNotReadableException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.within;
/**
* Integration tests for the JSON Binding API, running against Apache Johnzon.
@@ -53,20 +52,20 @@ public class JsonbHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(this.converter.canRead(MyBean.class, new MediaType("application", "json")));
assertTrue(this.converter.canRead(Map.class, new MediaType("application", "json")));
assertThat(this.converter.canRead(MyBean.class, new MediaType("application", "json"))).isTrue();
assertThat(this.converter.canRead(Map.class, new MediaType("application", "json"))).isTrue();
}
@Test
public void canWrite() {
assertTrue(this.converter.canWrite(MyBean.class, new MediaType("application", "json")));
assertTrue(this.converter.canWrite(Map.class, new MediaType("application", "json")));
assertThat(this.converter.canWrite(MyBean.class, new MediaType("application", "json"))).isTrue();
assertThat(this.converter.canWrite(Map.class, new MediaType("application", "json"))).isTrue();
}
@Test
public void canReadAndWriteMicroformats() {
assertTrue(this.converter.canRead(MyBean.class, new MediaType("application", "vnd.test-micro-type+json")));
assertTrue(this.converter.canWrite(MyBean.class, new MediaType("application", "vnd.test-micro-type+json")));
assertThat(this.converter.canRead(MyBean.class, new MediaType("application", "vnd.test-micro-type+json"))).isTrue();
assertThat(this.converter.canWrite(MyBean.class, new MediaType("application", "vnd.test-micro-type+json"))).isTrue();
}
@Test
@@ -77,12 +76,13 @@ public class JsonbHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
MyBean result = (MyBean) this.converter.read(MyBean.class, inputMessage);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
}
@Test
@@ -93,22 +93,23 @@ public class JsonbHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
HashMap<String, Object> result = (HashMap<String, Object>) this.converter.read(HashMap.class, inputMessage);
assertEquals("Foo", result.get("string"));
assertThat(result.get("string")).isEqualTo("Foo");
Number n = (Number) result.get("number");
assertEquals(42, n.longValue());
assertThat(n.longValue()).isEqualTo(42);
n = (Number) result.get("fraction");
assertEquals(42D, n.doubleValue(), 0D);
assertThat(n.doubleValue()).isCloseTo(42D, within(0D));
List<String> array = new ArrayList<>();
array.add("Foo");
array.add("Bar");
assertEquals(array, result.get("array"));
assertEquals(Boolean.TRUE, result.get("bool"));
assertThat(result.get("array")).isEqualTo(array);
assertThat(result.get("bool")).isEqualTo(Boolean.TRUE);
byte[] bytes = new byte[2];
List<Number> resultBytes = (ArrayList<Number>)result.get("bytes");
for (int i = 0; i < 2; i++) {
bytes[i] = resultBytes.get(i).byteValue();
}
assertArrayEquals(new byte[] {0x1, 0x2}, bytes);
assertThat(bytes).isEqualTo(new byte[] {0x1, 0x2});
}
@Test
@@ -124,14 +125,13 @@ public class JsonbHttpMessageConverterTests {
this.converter.write(body, null, outputMessage);
Charset utf8 = StandardCharsets.UTF_8;
String result = outputMessage.getBodyAsString(utf8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertTrue(result.contains("fraction\":42.0"));
assertTrue(result.contains("\"array\":[\"Foo\",\"Bar\"]"));
assertTrue(result.contains("\"bool\":true"));
assertTrue(result.contains("\"bytes\":[1,2]"));
assertEquals("Invalid content-type", new MediaType("application", "json", utf8),
outputMessage.getHeaders().getContentType());
assertThat(result.contains("\"string\":\"Foo\"")).isTrue();
assertThat(result.contains("\"number\":42")).isTrue();
assertThat(result.contains("fraction\":42.0")).isTrue();
assertThat(result.contains("\"array\":[\"Foo\",\"Bar\"]")).isTrue();
assertThat(result.contains("\"bool\":true")).isTrue();
assertThat(result.contains("\"bytes\":[1,2]")).isTrue();
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "json", utf8));
}
@Test
@@ -147,14 +147,13 @@ public class JsonbHttpMessageConverterTests {
this.converter.write(body, MyBase.class, null, outputMessage);
Charset utf8 = StandardCharsets.UTF_8;
String result = outputMessage.getBodyAsString(utf8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertTrue(result.contains("fraction\":42.0"));
assertTrue(result.contains("\"array\":[\"Foo\",\"Bar\"]"));
assertTrue(result.contains("\"bool\":true"));
assertTrue(result.contains("\"bytes\":[1,2]"));
assertEquals("Invalid content-type", new MediaType("application", "json", utf8),
outputMessage.getHeaders().getContentType());
assertThat(result.contains("\"string\":\"Foo\"")).isTrue();
assertThat(result.contains("\"number\":42")).isTrue();
assertThat(result.contains("fraction\":42.0")).isTrue();
assertThat(result.contains("\"array\":[\"Foo\",\"Bar\"]")).isTrue();
assertThat(result.contains("\"bool\":true")).isTrue();
assertThat(result.contains("\"bytes\":[1,2]")).isTrue();
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "json", utf8));
}
@Test
@@ -163,8 +162,8 @@ public class JsonbHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
String body = "H\u00e9llo W\u00f6rld";
this.converter.write(body, contentType, outputMessage);
assertEquals("Invalid result", body, outputMessage.getBodyAsString(StandardCharsets.UTF_16BE));
assertEquals("Invalid content-type", contentType, outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_16BE)).as("Invalid result").isEqualTo(body);
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(contentType);
}
@Test
@@ -188,14 +187,15 @@ public class JsonbHttpMessageConverterTests {
Type genericType = beansList.getGenericType();
List<MyBean> results = (List<MyBean>) converter.read(genericType, MyBeanListHolder.class, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, genericType, new MediaType("application", "json"), outputMessage);
@@ -213,14 +213,15 @@ public class JsonbHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
List<MyBean> results = (List<MyBean>) converter.read(beansList.getType(), null, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, beansList.getType(), new MediaType("application", "json"), outputMessage);
@@ -239,14 +240,15 @@ public class JsonbHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
List<MyBean> results = (List<MyBean>) converter.read(beansList.getType(), null, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, baseList.getType(), new MediaType("application", "json"), outputMessage);
@@ -258,7 +260,7 @@ public class JsonbHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
this.converter.setPrefixJson(true);
this.converter.writeInternal("foo", null, outputMessage);
assertEquals(")]}', foo", outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo(")]}', foo");
}
@Test
@@ -266,7 +268,7 @@ public class JsonbHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
this.converter.setJsonPrefix(")))");
this.converter.writeInternal("foo", null, outputMessage);
assertEquals(")))foo", outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo(")))foo");
}

138
spring-web/src/test/java/org/springframework/http/converter/json/MappingJackson2HttpMessageConverterTests.java
View File

@@ -44,9 +44,7 @@ import org.springframework.lang.Nullable;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.within;
/**
* Jackson 2.x converter tests.
@@ -64,20 +62,20 @@ public class MappingJackson2HttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(converter.canRead(MyBean.class, new MediaType("application", "json")));
assertTrue(converter.canRead(Map.class, new MediaType("application", "json")));
assertThat(converter.canRead(MyBean.class, new MediaType("application", "json"))).isTrue();
assertThat(converter.canRead(Map.class, new MediaType("application", "json"))).isTrue();
}
@Test
public void canWrite() {
assertTrue(converter.canWrite(MyBean.class, new MediaType("application", "json")));
assertTrue(converter.canWrite(Map.class, new MediaType("application", "json")));
assertThat(converter.canWrite(MyBean.class, new MediaType("application", "json"))).isTrue();
assertThat(converter.canWrite(Map.class, new MediaType("application", "json"))).isTrue();
}
@Test // SPR-7905
public void canReadAndWriteMicroformats() {
assertTrue(converter.canRead(MyBean.class, new MediaType("application", "vnd.test-micro-type+json")));
assertTrue(converter.canWrite(MyBean.class, new MediaType("application", "vnd.test-micro-type+json")));
assertThat(converter.canRead(MyBean.class, new MediaType("application", "vnd.test-micro-type+json"))).isTrue();
assertThat(converter.canWrite(MyBean.class, new MediaType("application", "vnd.test-micro-type+json"))).isTrue();
}
@Test
@@ -92,12 +90,12 @@ public class MappingJackson2HttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
MyBean result = (MyBean) converter.read(MyBean.class, inputMessage);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
}
@Test
@@ -113,15 +111,15 @@ public class MappingJackson2HttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
HashMap<String, Object> result = (HashMap<String, Object>) converter.read(HashMap.class, inputMessage);
assertEquals("Foo", result.get("string"));
assertEquals(42, result.get("number"));
assertEquals(42D, (Double) result.get("fraction"), 0D);
assertThat(result.get("string")).isEqualTo("Foo");
assertThat(result.get("number")).isEqualTo(42);
assertThat((Double) result.get("fraction")).isCloseTo(42D, within(0D));
List<String> array = new ArrayList<>();
array.add("Foo");
array.add("Bar");
assertEquals(array, result.get("array"));
assertEquals(Boolean.TRUE, result.get("bool"));
assertEquals("AQI=", result.get("bytes"));
assertThat(result.get("array")).isEqualTo(array);
assertThat(result.get("bool")).isEqualTo(Boolean.TRUE);
assertThat(result.get("bytes")).isEqualTo("AQI=");
}
@Test
@@ -136,14 +134,13 @@ public class MappingJackson2HttpMessageConverterTests {
body.setBytes(new byte[] {0x1, 0x2});
converter.write(body, null, outputMessage);
String result = outputMessage.getBodyAsString(StandardCharsets.UTF_8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertTrue(result.contains("fraction\":42.0"));
assertTrue(result.contains("\"array\":[\"Foo\",\"Bar\"]"));
assertTrue(result.contains("\"bool\":true"));
assertTrue(result.contains("\"bytes\":\"AQI=\""));
assertEquals("Invalid content-type", MediaType.APPLICATION_JSON,
outputMessage.getHeaders().getContentType());
assertThat(result.contains("\"string\":\"Foo\"")).isTrue();
assertThat(result.contains("\"number\":42")).isTrue();
assertThat(result.contains("fraction\":42.0")).isTrue();
assertThat(result.contains("\"array\":[\"Foo\",\"Bar\"]")).isTrue();
assertThat(result.contains("\"bool\":true")).isTrue();
assertThat(result.contains("\"bytes\":\"AQI=\"")).isTrue();
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(MediaType.APPLICATION_JSON);
}
@Test
@@ -158,14 +155,13 @@ public class MappingJackson2HttpMessageConverterTests {
body.setBytes(new byte[] {0x1, 0x2});
converter.write(body, MyBase.class, null, outputMessage);
String result = outputMessage.getBodyAsString(StandardCharsets.UTF_8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertTrue(result.contains("fraction\":42.0"));
assertTrue(result.contains("\"array\":[\"Foo\",\"Bar\"]"));
assertTrue(result.contains("\"bool\":true"));
assertTrue(result.contains("\"bytes\":\"AQI=\""));
assertEquals("Invalid content-type", MediaType.APPLICATION_JSON,
outputMessage.getHeaders().getContentType());
assertThat(result.contains("\"string\":\"Foo\"")).isTrue();
assertThat(result.contains("\"number\":42")).isTrue();
assertThat(result.contains("fraction\":42.0")).isTrue();
assertThat(result.contains("\"array\":[\"Foo\",\"Bar\"]")).isTrue();
assertThat(result.contains("\"bool\":true")).isTrue();
assertThat(result.contains("\"bytes\":\"AQI=\"")).isTrue();
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(MediaType.APPLICATION_JSON);
}
@Test
@@ -174,8 +170,8 @@ public class MappingJackson2HttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
String body = "H\u00e9llo W\u00f6rld";
converter.write(body, contentType, outputMessage);
assertEquals("Invalid result", "\"" + body + "\"", outputMessage.getBodyAsString(StandardCharsets.UTF_16BE));
assertEquals("Invalid content-type", contentType, outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_16BE)).as("Invalid result").isEqualTo(("\"" + body + "\""));
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(contentType);
}
@Test
@@ -221,14 +217,14 @@ public class MappingJackson2HttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "json"));
List<MyBean> results = (List<MyBean>) converter.read(List.class, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, new MediaType("application", "json"), outputMessage);
@@ -252,14 +248,14 @@ public class MappingJackson2HttpMessageConverterTests {
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
List<MyBean> results = (List<MyBean>) converter.read(beansList.getType(), null, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, beansList.getType(), new MediaType("application", "json"), outputMessage);
@@ -284,14 +280,14 @@ public class MappingJackson2HttpMessageConverterTests {
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
List<MyBean> results = (List<MyBean>) converter.read(beansList.getType(), null, inputMessage);
assertEquals(1, results.size());
assertThat(results.size()).isEqualTo(1);
MyBean result = results.get(0);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[] {"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[] {0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[] {"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[] {0x1, 0x2});
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(results, baseList.getType(), new MediaType("application", "json"), outputMessage);
@@ -308,8 +304,8 @@ public class MappingJackson2HttpMessageConverterTests {
this.converter.writeInternal(bean, null, outputMessage);
String result = outputMessage.getBodyAsString(StandardCharsets.UTF_8);
assertEquals("{" + NEWLINE_SYSTEM_PROPERTY +
" \"name\" : \"Jason\"" + NEWLINE_SYSTEM_PROPERTY + "}", result);
assertThat(result).isEqualTo(("{" + NEWLINE_SYSTEM_PROPERTY +
" \"name\" : \"Jason\"" + NEWLINE_SYSTEM_PROPERTY + "}"));
}
@Test
@@ -323,7 +319,7 @@ public class MappingJackson2HttpMessageConverterTests {
this.converter.writeInternal(bean, null, outputMessage);
String result = outputMessage.getBodyAsString(StandardCharsets.UTF_8);
assertEquals("{\ndata: \"name\" : \"Jason\"\ndata:}", result);
assertThat(result).isEqualTo("{\ndata: \"name\" : \"Jason\"\ndata:}");
}
@Test
@@ -332,7 +328,7 @@ public class MappingJackson2HttpMessageConverterTests {
this.converter.setPrefixJson(true);
this.converter.writeInternal("foo", null, outputMessage);
assertEquals(")]}', \"foo\"", outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo(")]}', \"foo\"");
}
@Test
@@ -341,7 +337,7 @@ public class MappingJackson2HttpMessageConverterTests {
this.converter.setJsonPrefix(")))");
this.converter.writeInternal("foo", null, outputMessage);
assertEquals(")))\"foo\"", outputMessage.getBodyAsString(StandardCharsets.UTF_8));
assertThat(outputMessage.getBodyAsString(StandardCharsets.UTF_8)).isEqualTo(")))\"foo\"");
}
@Test
@@ -408,8 +404,8 @@ public class MappingJackson2HttpMessageConverterTests {
this.converter.writeInternal(bean, MyInterface.class, outputMessage);
String result = outputMessage.getBodyAsString(StandardCharsets.UTF_8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertThat(result.contains("\"string\":\"Foo\"")).isTrue();
assertThat(result.contains("\"number\":42")).isTrue();
}
@Test // SPR-13318
@@ -430,10 +426,10 @@ public class MappingJackson2HttpMessageConverterTests {
this.converter.writeInternal(beans, typeReference.getType(), outputMessage);
String result = outputMessage.getBodyAsString(StandardCharsets.UTF_8);
assertTrue(result.contains("\"string\":\"Foo\""));
assertTrue(result.contains("\"number\":42"));
assertTrue(result.contains("\"string\":\"Bar\""));
assertTrue(result.contains("\"number\":123"));
assertThat(result.contains("\"string\":\"Foo\"")).isTrue();
assertThat(result.contains("\"number\":42")).isTrue();
assertThat(result.contains("\"string\":\"Bar\"")).isTrue();
assertThat(result.contains("\"number\":123")).isTrue();
}
@Test

16
spring-web/src/test/java/org/springframework/http/converter/json/SpringHandlerInstantiatorTests.java
View File

@@ -55,9 +55,7 @@ import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostP
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Test class for {@link SpringHandlerInstantiatorTests}.
@@ -87,34 +85,34 @@ public class SpringHandlerInstantiatorTests {
public void autowiredSerializer() throws JsonProcessingException {
User user = new User("bob");
String json = this.objectMapper.writeValueAsString(user);
assertEquals("{\"username\":\"BOB\"}", json);
assertThat(json).isEqualTo("{\"username\":\"BOB\"}");
}
@Test
public void autowiredDeserializer() throws IOException {
String json = "{\"username\":\"bob\"}";
User user = this.objectMapper.readValue(json, User.class);
assertEquals("BOB", user.getUsername());
assertThat(user.getUsername()).isEqualTo("BOB");
}
@Test
public void autowiredKeyDeserializer() throws IOException {
String json = "{\"credentials\":{\"bob\":\"admin\"}}";
SecurityRegistry registry = this.objectMapper.readValue(json, SecurityRegistry.class);
assertTrue(registry.getCredentials().keySet().contains("BOB"));
assertFalse(registry.getCredentials().keySet().contains("bob"));
assertThat(registry.getCredentials().keySet().contains("BOB")).isTrue();
assertThat(registry.getCredentials().keySet().contains("bob")).isFalse();
}
@Test
public void applicationContextAwaretypeResolverBuilder() throws JsonProcessingException {
this.objectMapper.writeValueAsString(new Group());
assertTrue(CustomTypeResolverBuilder.isAutowiredFiledInitialized);
assertThat(CustomTypeResolverBuilder.isAutowiredFiledInitialized).isTrue();
}
@Test
public void applicationContextAwareTypeIdResolver() throws JsonProcessingException {
this.objectMapper.writeValueAsString(new Group());
assertTrue(CustomTypeIdResolver.isAutowiredFiledInitialized);
assertThat(CustomTypeIdResolver.isAutowiredFiledInitialized).isTrue();
}

80
spring-web/src/test/java/org/springframework/http/converter/protobuf/ProtobufHttpMessageConverterTests.java
View File

@@ -31,11 +31,7 @@ import org.springframework.http.MockHttpOutputMessage;
import org.springframework.protobuf.Msg;
import org.springframework.protobuf.SecondMsg;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -78,35 +74,35 @@ public class ProtobufHttpMessageConverterTests {
@Test
public void extensionRegistryInitializerNull() {
ProtobufHttpMessageConverter converter = new ProtobufHttpMessageConverter((ExtensionRegistryInitializer)null);
assertNotNull(converter.extensionRegistry);
assertThat(converter.extensionRegistry).isNotNull();
}
@Test
public void extensionRegistryNull() {
ProtobufHttpMessageConverter converter = new ProtobufHttpMessageConverter((ExtensionRegistry)null);
assertNotNull(converter.extensionRegistry);
assertThat(converter.extensionRegistry).isNotNull();
}
@Test
public void canRead() {
assertTrue(this.converter.canRead(Msg.class, null));
assertTrue(this.converter.canRead(Msg.class, ProtobufHttpMessageConverter.PROTOBUF));
assertTrue(this.converter.canRead(Msg.class, MediaType.APPLICATION_JSON));
assertTrue(this.converter.canRead(Msg.class, MediaType.APPLICATION_XML));
assertTrue(this.converter.canRead(Msg.class, MediaType.TEXT_PLAIN));
assertThat(this.converter.canRead(Msg.class, null)).isTrue();
assertThat(this.converter.canRead(Msg.class, ProtobufHttpMessageConverter.PROTOBUF)).isTrue();
assertThat(this.converter.canRead(Msg.class, MediaType.APPLICATION_JSON)).isTrue();
assertThat(this.converter.canRead(Msg.class, MediaType.APPLICATION_XML)).isTrue();
assertThat(this.converter.canRead(Msg.class, MediaType.TEXT_PLAIN)).isTrue();
// only supported as an output format
assertFalse(this.converter.canRead(Msg.class, MediaType.TEXT_HTML));
assertThat(this.converter.canRead(Msg.class, MediaType.TEXT_HTML)).isFalse();
}
@Test
public void canWrite() {
assertTrue(this.converter.canWrite(Msg.class, null));
assertTrue(this.converter.canWrite(Msg.class, ProtobufHttpMessageConverter.PROTOBUF));
assertTrue(this.converter.canWrite(Msg.class, MediaType.APPLICATION_JSON));
assertTrue(this.converter.canWrite(Msg.class, MediaType.APPLICATION_XML));
assertTrue(this.converter.canWrite(Msg.class, MediaType.TEXT_PLAIN));
assertTrue(this.converter.canWrite(Msg.class, MediaType.TEXT_HTML));
assertThat(this.converter.canWrite(Msg.class, null)).isTrue();
assertThat(this.converter.canWrite(Msg.class, ProtobufHttpMessageConverter.PROTOBUF)).isTrue();
assertThat(this.converter.canWrite(Msg.class, MediaType.APPLICATION_JSON)).isTrue();
assertThat(this.converter.canWrite(Msg.class, MediaType.APPLICATION_XML)).isTrue();
assertThat(this.converter.canWrite(Msg.class, MediaType.TEXT_PLAIN)).isTrue();
assertThat(this.converter.canWrite(Msg.class, MediaType.TEXT_HTML)).isTrue();
}
@Test
@@ -115,7 +111,7 @@ public class ProtobufHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
inputMessage.getHeaders().setContentType(ProtobufHttpMessageConverter.PROTOBUF);
Message result = this.converter.read(Msg.class, inputMessage);
assertEquals(this.testMsg, result);
assertThat(result).isEqualTo(this.testMsg);
}
@Test
@@ -123,7 +119,7 @@ public class ProtobufHttpMessageConverterTests {
byte[] body = this.testMsg.toByteArray();
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
Message result = this.converter.read(Msg.class, inputMessage);
assertEquals(this.testMsg, result);
assertThat(result).isEqualTo(this.testMsg);
}
@Test
@@ -131,17 +127,17 @@ public class ProtobufHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
MediaType contentType = ProtobufHttpMessageConverter.PROTOBUF;
this.converter.write(this.testMsg, contentType, outputMessage);
assertEquals(contentType, outputMessage.getHeaders().getContentType());
assertTrue(outputMessage.getBodyAsBytes().length > 0);
assertThat(outputMessage.getHeaders().getContentType()).isEqualTo(contentType);
assertThat(outputMessage.getBodyAsBytes().length > 0).isTrue();
Message result = Msg.parseFrom(outputMessage.getBodyAsBytes());
assertEquals(this.testMsg, result);
assertThat(result).isEqualTo(this.testMsg);
String messageHeader =
outputMessage.getHeaders().getFirst(ProtobufHttpMessageConverter.X_PROTOBUF_MESSAGE_HEADER);
assertEquals("Msg", messageHeader);
assertThat(messageHeader).isEqualTo("Msg");
String schemaHeader =
outputMessage.getHeaders().getFirst(ProtobufHttpMessageConverter.X_PROTOBUF_SCHEMA_HEADER);
assertEquals("sample.proto", schemaHeader);
assertThat(schemaHeader).isEqualTo("sample.proto");
}
@Test
@@ -153,19 +149,19 @@ public class ProtobufHttpMessageConverterTests {
MediaType contentType = MediaType.APPLICATION_JSON;
this.converter.write(this.testMsg, contentType, outputMessage);
assertEquals(contentType, outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).isEqualTo(contentType);
final String body = outputMessage.getBodyAsString(Charset.forName("UTF-8"));
assertFalse("body is empty", body.isEmpty());
assertThat(body.isEmpty()).as("body is empty").isFalse();
Msg.Builder builder = Msg.newBuilder();
JsonFormat.parser().merge(body, builder);
assertEquals(this.testMsg, builder.build());
assertThat(builder.build()).isEqualTo(this.testMsg);
assertNull(outputMessage.getHeaders().getFirst(
ProtobufHttpMessageConverter.X_PROTOBUF_MESSAGE_HEADER));
assertNull(outputMessage.getHeaders().getFirst(
ProtobufHttpMessageConverter.X_PROTOBUF_SCHEMA_HEADER));
assertThat(outputMessage.getHeaders().getFirst(
ProtobufHttpMessageConverter.X_PROTOBUF_MESSAGE_HEADER)).isNull();
assertThat(outputMessage.getHeaders().getFirst(
ProtobufHttpMessageConverter.X_PROTOBUF_SCHEMA_HEADER)).isNull();
}
@Test
@@ -177,24 +173,24 @@ public class ProtobufHttpMessageConverterTests {
MediaType contentType = MediaType.APPLICATION_JSON_UTF8;
this.converter.write(this.testMsg, contentType, outputMessage);
assertEquals(contentType, outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).isEqualTo(contentType);
final String body = outputMessage.getBodyAsString(Charset.forName("UTF-8"));
assertFalse("body is empty", body.isEmpty());
assertThat(body.isEmpty()).as("body is empty").isFalse();
Msg.Builder builder = Msg.newBuilder();
JsonFormat.parser().merge(body, builder);
assertEquals(this.testMsg, builder.build());
assertThat(builder.build()).isEqualTo(this.testMsg);
assertNull(outputMessage.getHeaders().getFirst(
ProtobufHttpMessageConverter.X_PROTOBUF_MESSAGE_HEADER));
assertNull(outputMessage.getHeaders().getFirst(
ProtobufHttpMessageConverter.X_PROTOBUF_SCHEMA_HEADER));
assertThat(outputMessage.getHeaders().getFirst(
ProtobufHttpMessageConverter.X_PROTOBUF_MESSAGE_HEADER)).isNull();
assertThat(outputMessage.getHeaders().getFirst(
ProtobufHttpMessageConverter.X_PROTOBUF_SCHEMA_HEADER)).isNull();
}
@Test
public void defaultContentType() throws Exception {
assertEquals(ProtobufHttpMessageConverter.PROTOBUF, this.converter.getDefaultContentType(this.testMsg));
assertThat(this.converter.getDefaultContentType(this.testMsg)).isEqualTo(ProtobufHttpMessageConverter.PROTOBUF);
}
@Test
@@ -202,7 +198,7 @@ public class ProtobufHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
MediaType contentType = ProtobufHttpMessageConverter.PROTOBUF;
this.converter.write(this.testMsg, contentType, outputMessage);
assertEquals(-1, outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getHeaders().getContentLength()).isEqualTo(-1);
}
}

42
spring-web/src/test/java/org/springframework/http/converter/protobuf/ProtobufJsonFormatHttpMessageConverterTests.java
View File

@@ -29,9 +29,7 @@ import org.springframework.http.MockHttpOutputMessage;
import org.springframework.protobuf.Msg;
import org.springframework.protobuf.SecondMsg;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
@@ -62,29 +60,29 @@ public class ProtobufJsonFormatHttpMessageConverterTests {
@Test
public void extensionRegistryInitializerNull() {
ProtobufHttpMessageConverter converter = new ProtobufHttpMessageConverter((ExtensionRegistryInitializer)null);
assertNotNull(converter);
assertThat(converter).isNotNull();
}
@Test
public void extensionRegistryInitializer() {
ProtobufHttpMessageConverter converter = new ProtobufHttpMessageConverter((ExtensionRegistry)null);
assertNotNull(converter);
assertThat(converter).isNotNull();
}
@Test
public void canRead() {
assertTrue(this.converter.canRead(Msg.class, null));
assertTrue(this.converter.canRead(Msg.class, ProtobufHttpMessageConverter.PROTOBUF));
assertTrue(this.converter.canRead(Msg.class, MediaType.APPLICATION_JSON));
assertTrue(this.converter.canRead(Msg.class, MediaType.TEXT_PLAIN));
assertThat(this.converter.canRead(Msg.class, null)).isTrue();
assertThat(this.converter.canRead(Msg.class, ProtobufHttpMessageConverter.PROTOBUF)).isTrue();
assertThat(this.converter.canRead(Msg.class, MediaType.APPLICATION_JSON)).isTrue();
assertThat(this.converter.canRead(Msg.class, MediaType.TEXT_PLAIN)).isTrue();
}
@Test
public void canWrite() {
assertTrue(this.converter.canWrite(Msg.class, null));
assertTrue(this.converter.canWrite(Msg.class, ProtobufHttpMessageConverter.PROTOBUF));
assertTrue(this.converter.canWrite(Msg.class, MediaType.APPLICATION_JSON));
assertTrue(this.converter.canWrite(Msg.class, MediaType.TEXT_PLAIN));
assertThat(this.converter.canWrite(Msg.class, null)).isTrue();
assertThat(this.converter.canWrite(Msg.class, ProtobufHttpMessageConverter.PROTOBUF)).isTrue();
assertThat(this.converter.canWrite(Msg.class, MediaType.APPLICATION_JSON)).isTrue();
assertThat(this.converter.canWrite(Msg.class, MediaType.TEXT_PLAIN)).isTrue();
}
@Test
@@ -93,7 +91,7 @@ public class ProtobufJsonFormatHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
inputMessage.getHeaders().setContentType(ProtobufHttpMessageConverter.PROTOBUF);
Message result = this.converter.read(Msg.class, inputMessage);
assertEquals(this.testMsg, result);
assertThat(result).isEqualTo(this.testMsg);
}
@Test
@@ -101,7 +99,7 @@ public class ProtobufJsonFormatHttpMessageConverterTests {
byte[] body = this.testMsg.toByteArray();
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
Message result = this.converter.read(Msg.class, inputMessage);
assertEquals(this.testMsg, result);
assertThat(result).isEqualTo(this.testMsg);
}
@Test
@@ -109,22 +107,22 @@ public class ProtobufJsonFormatHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
MediaType contentType = ProtobufHttpMessageConverter.PROTOBUF;
this.converter.write(this.testMsg, contentType, outputMessage);
assertEquals(contentType, outputMessage.getHeaders().getContentType());
assertTrue(outputMessage.getBodyAsBytes().length > 0);
assertThat(outputMessage.getHeaders().getContentType()).isEqualTo(contentType);
assertThat(outputMessage.getBodyAsBytes().length > 0).isTrue();
Message result = Msg.parseFrom(outputMessage.getBodyAsBytes());
assertEquals(this.testMsg, result);
assertThat(result).isEqualTo(this.testMsg);
String messageHeader =
outputMessage.getHeaders().getFirst(ProtobufHttpMessageConverter.X_PROTOBUF_MESSAGE_HEADER);
assertEquals("Msg", messageHeader);
assertThat(messageHeader).isEqualTo("Msg");
String schemaHeader =
outputMessage.getHeaders().getFirst(ProtobufHttpMessageConverter.X_PROTOBUF_SCHEMA_HEADER);
assertEquals("sample.proto", schemaHeader);
assertThat(schemaHeader).isEqualTo("sample.proto");
}
@Test
public void defaultContentType() throws Exception {
assertEquals(ProtobufHttpMessageConverter.PROTOBUF, this.converter.getDefaultContentType(this.testMsg));
assertThat(this.converter.getDefaultContentType(this.testMsg)).isEqualTo(ProtobufHttpMessageConverter.PROTOBUF);
}
@Test
@@ -132,7 +130,7 @@ public class ProtobufJsonFormatHttpMessageConverterTests {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
MediaType contentType = ProtobufHttpMessageConverter.PROTOBUF;
this.converter.write(this.testMsg, contentType, outputMessage);
assertEquals(-1, outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getHeaders().getContentLength()).isEqualTo(-1);
}
}

36
spring-web/src/test/java/org/springframework/http/converter/smile/MappingJackson2SmileHttpMessageConverterTests.java
View File

@@ -26,10 +26,8 @@ import org.springframework.http.MediaType;
import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.MockHttpOutputMessage;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.within;
/**
* Jackson 2.x Smile converter tests.
@@ -44,16 +42,16 @@ public class MappingJackson2SmileHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(converter.canRead(MyBean.class, new MediaType("application", "x-jackson-smile")));
assertFalse(converter.canRead(MyBean.class, new MediaType("application", "json")));
assertFalse(converter.canRead(MyBean.class, new MediaType("application", "xml")));
assertThat(converter.canRead(MyBean.class, new MediaType("application", "x-jackson-smile"))).isTrue();
assertThat(converter.canRead(MyBean.class, new MediaType("application", "json"))).isFalse();
assertThat(converter.canRead(MyBean.class, new MediaType("application", "xml"))).isFalse();
}
@Test
public void canWrite() {
assertTrue(converter.canWrite(MyBean.class, new MediaType("application", "x-jackson-smile")));
assertFalse(converter.canWrite(MyBean.class, new MediaType("application", "json")));
assertFalse(converter.canWrite(MyBean.class, new MediaType("application", "xml")));
assertThat(converter.canWrite(MyBean.class, new MediaType("application", "x-jackson-smile"))).isTrue();
assertThat(converter.canWrite(MyBean.class, new MediaType("application", "json"))).isFalse();
assertThat(converter.canWrite(MyBean.class, new MediaType("application", "xml"))).isFalse();
}
@Test
@@ -68,12 +66,13 @@ public class MappingJackson2SmileHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(mapper.writeValueAsBytes(body));
inputMessage.getHeaders().setContentType(new MediaType("application", "x-jackson-smile"));
MyBean result = (MyBean) converter.read(MyBean.class, inputMessage);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[]{"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[]{0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[]{"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[]{0x1, 0x2});
}
@Test
@@ -87,9 +86,8 @@ public class MappingJackson2SmileHttpMessageConverterTests {
body.setBool(true);
body.setBytes(new byte[]{0x1, 0x2});
converter.write(body, null, outputMessage);
assertArrayEquals(mapper.writeValueAsBytes(body), outputMessage.getBodyAsBytes());
assertEquals("Invalid content-type", new MediaType("application", "x-jackson-smile"),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getBodyAsBytes()).isEqualTo(mapper.writeValueAsBytes(body));
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "x-jackson-smile"));
}

41
spring-web/src/test/java/org/springframework/http/converter/xml/Jaxb2CollectionHttpMessageConverterTests.java
View File

@@ -35,9 +35,8 @@ import org.springframework.core.io.Resource;
import org.springframework.http.MockHttpInputMessage;
import org.springframework.http.converter.HttpMessageNotReadableException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* Test fixture for {@link Jaxb2CollectionHttpMessageConverter}.
@@ -70,9 +69,9 @@ public class Jaxb2CollectionHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(converter.canRead(rootElementListType, null, null));
assertTrue(converter.canRead(rootElementSetType, null, null));
assertTrue(converter.canRead(typeSetType, null, null));
assertThat(converter.canRead(rootElementListType, null, null)).isTrue();
assertThat(converter.canRead(rootElementSetType, null, null)).isTrue();
assertThat(converter.canRead(typeSetType, null, null)).isTrue();
}
@Test
@@ -82,9 +81,9 @@ public class Jaxb2CollectionHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(content.getBytes("UTF-8"));
List<RootElement> result = (List<RootElement>) converter.read(rootElementListType, null, inputMessage);
assertEquals("Invalid result", 2, result.size());
assertEquals("Invalid result", "1", result.get(0).type.s);
assertEquals("Invalid result", "2", result.get(1).type.s);
assertThat(result.size()).as("Invalid result").isEqualTo(2);
assertThat(result.get(0).type.s).as("Invalid result").isEqualTo("1");
assertThat(result.get(1).type.s).as("Invalid result").isEqualTo("2");
}
@Test
@@ -94,9 +93,9 @@ public class Jaxb2CollectionHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(content.getBytes("UTF-8"));
Set<RootElement> result = (Set<RootElement>) converter.read(rootElementSetType, null, inputMessage);
assertEquals("Invalid result", 2, result.size());
assertTrue("Invalid result", result.contains(new RootElement("1")));
assertTrue("Invalid result", result.contains(new RootElement("2")));
assertThat(result.size()).as("Invalid result").isEqualTo(2);
assertThat(result.contains(new RootElement("1"))).as("Invalid result").isTrue();
assertThat(result.contains(new RootElement("2"))).as("Invalid result").isTrue();
}
@Test
@@ -106,9 +105,9 @@ public class Jaxb2CollectionHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(content.getBytes("UTF-8"));
List<TestType> result = (List<TestType>) converter.read(typeListType, null, inputMessage);
assertEquals("Invalid result", 2, result.size());
assertEquals("Invalid result", "1", result.get(0).s);
assertEquals("Invalid result", "2", result.get(1).s);
assertThat(result.size()).as("Invalid result").isEqualTo(2);
assertThat(result.get(0).s).as("Invalid result").isEqualTo("1");
assertThat(result.get(1).s).as("Invalid result").isEqualTo("2");
}
@Test
@@ -118,9 +117,9 @@ public class Jaxb2CollectionHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(content.getBytes("UTF-8"));
Set<TestType> result = (Set<TestType>) converter.read(typeSetType, null, inputMessage);
assertEquals("Invalid result", 2, result.size());
assertTrue("Invalid result", result.contains(new TestType("1")));
assertTrue("Invalid result", result.contains(new TestType("2")));
assertThat(result.size()).as("Invalid result").isEqualTo(2);
assertThat(result.contains(new TestType("1"))).as("Invalid result").isTrue();
assertThat(result.contains(new TestType("2"))).as("Invalid result").isTrue();
}
@Test
@@ -144,8 +143,8 @@ public class Jaxb2CollectionHttpMessageConverterTests {
try {
Collection<RootElement> result = converter.read(rootElementListType, null, inputMessage);
assertEquals(1, result.size());
assertEquals("", result.iterator().next().external);
assertThat(result.size()).isEqualTo(1);
assertThat(result.iterator().next().external).isEqualTo("");
}
catch (HttpMessageNotReadableException ex) {
// Some parsers raise an exception
@@ -172,8 +171,8 @@ public class Jaxb2CollectionHttpMessageConverterTests {
};
Collection<RootElement> result = c.read(rootElementListType, null, inputMessage);
assertEquals(1, result.size());
assertEquals("Foo Bar", result.iterator().next().external);
assertThat(result.size()).isEqualTo(1);
assertThat(result.iterator().next().external).isEqualTo("Foo Bar");
}
@Test

40
spring-web/src/test/java/org/springframework/http/converter/xml/Jaxb2RootElementHttpMessageConverterTests.java
View File

@@ -43,9 +43,6 @@ import org.springframework.tests.XmlContent;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.xmlunit.diff.ComparisonType.XML_STANDALONE;
import static org.xmlunit.diff.DifferenceEvaluators.Default;
import static org.xmlunit.diff.DifferenceEvaluators.chain;
@@ -82,21 +79,16 @@ public class Jaxb2RootElementHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue("Converter does not support reading @XmlRootElement",
converter.canRead(RootElement.class, null));
assertTrue("Converter does not support reading @XmlType",
converter.canRead(Type.class, null));
assertThat(converter.canRead(RootElement.class, null)).as("Converter does not support reading @XmlRootElement").isTrue();
assertThat(converter.canRead(Type.class, null)).as("Converter does not support reading @XmlType").isTrue();
}
@Test
public void canWrite() {
assertTrue("Converter does not support writing @XmlRootElement",
converter.canWrite(RootElement.class, null));
assertTrue("Converter does not support writing @XmlRootElement subclass",
converter.canWrite(RootElementSubclass.class, null));
assertTrue("Converter does not support writing @XmlRootElement subclass",
converter.canWrite(rootElementCglib.getClass(), null));
assertFalse("Converter supports writing @XmlType", converter.canWrite(Type.class, null));
assertThat(converter.canWrite(RootElement.class, null)).as("Converter does not support writing @XmlRootElement").isTrue();
assertThat(converter.canWrite(RootElementSubclass.class, null)).as("Converter does not support writing @XmlRootElement subclass").isTrue();
assertThat(converter.canWrite(rootElementCglib.getClass(), null)).as("Converter does not support writing @XmlRootElement subclass").isTrue();
assertThat(converter.canWrite(Type.class, null)).as("Converter supports writing @XmlType").isFalse();
}
@Test
@@ -104,7 +96,7 @@ public class Jaxb2RootElementHttpMessageConverterTests {
byte[] body = "<rootElement><type s=\"Hello World\"/></rootElement>".getBytes("UTF-8");
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
RootElement result = (RootElement) converter.read(RootElement.class, inputMessage);
assertEquals("Invalid result", "Hello World", result.type.s);
assertThat(result.type.s).as("Invalid result").isEqualTo("Hello World");
}
@Test
@@ -112,7 +104,7 @@ public class Jaxb2RootElementHttpMessageConverterTests {
byte[] body = "<rootElement><type s=\"Hello World\"/></rootElement>".getBytes("UTF-8");
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
RootElementSubclass result = (RootElementSubclass) converter.read(RootElementSubclass.class, inputMessage);
assertEquals("Invalid result", "Hello World", result.getType().s);
assertThat(result.getType().s).as("Invalid result").isEqualTo("Hello World");
}
@Test
@@ -120,7 +112,7 @@ public class Jaxb2RootElementHttpMessageConverterTests {
byte[] body = "<foo s=\"Hello World\"/>".getBytes("UTF-8");
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
Type result = (Type) converter.read(Type.class, inputMessage);
assertEquals("Invalid result", "Hello World", result.s);
assertThat(result.s).as("Invalid result").isEqualTo("Hello World");
}
@Test
@@ -134,7 +126,7 @@ public class Jaxb2RootElementHttpMessageConverterTests {
converter.setSupportDtd(true);
RootElement rootElement = (RootElement) converter.read(RootElement.class, inputMessage);
assertEquals("", rootElement.external);
assertThat(rootElement.external).isEqualTo("");
}
@Test
@@ -148,7 +140,7 @@ public class Jaxb2RootElementHttpMessageConverterTests {
this.converter.setProcessExternalEntities(true);
RootElement rootElement = (RootElement) converter.read(RootElement.class, inputMessage);
assertEquals("Foo Bar", rootElement.external);
assertThat(rootElement.external).isEqualTo("Foo Bar");
}
@Test
@@ -180,8 +172,7 @@ public class Jaxb2RootElementHttpMessageConverterTests {
public void writeXmlRootElement() throws Exception {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(rootElement, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "xml"),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "xml"));
DifferenceEvaluator ev = chain(Default, downgradeDifferencesToEqual(XML_STANDALONE));
assertThat(XmlContent.of(outputMessage.getBodyAsString(StandardCharsets.UTF_8)))
.isSimilarTo("<rootElement><type s=\"Hello World\"/></rootElement>", ev);
@@ -191,8 +182,7 @@ public class Jaxb2RootElementHttpMessageConverterTests {
public void writeXmlRootElementSubclass() throws Exception {
MockHttpOutputMessage outputMessage = new MockHttpOutputMessage();
converter.write(rootElementCglib, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "xml"),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "xml"));
DifferenceEvaluator ev = chain(Default, downgradeDifferencesToEqual(XML_STANDALONE));
assertThat(XmlContent.of(outputMessage.getBodyAsString(StandardCharsets.UTF_8)))
.isSimilarTo("<rootElement><type s=\"Hello World\"/></rootElement>", ev);
@@ -216,8 +206,8 @@ public class Jaxb2RootElementHttpMessageConverterTests {
MyJaxb2RootElementHttpMessageConverter myConverter = new MyJaxb2RootElementHttpMessageConverter();
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body);
MyRootElement result = (MyRootElement) myConverter.read(MyRootElement.class, inputMessage);
assertEquals("a", result.getElement().getField1());
assertEquals("b", result.getElement().getField2());
assertThat(result.getElement().getField1()).isEqualTo("a");
assertThat(result.getElement().getField2()).isEqualTo("b");
}

43
spring-web/src/test/java/org/springframework/http/converter/xml/MappingJackson2XmlHttpMessageConverterTests.java
View File

@@ -32,9 +32,7 @@ import org.springframework.http.converter.json.MappingJacksonValue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.within;
/**
* Jackson 2.x XML converter tests.
@@ -49,16 +47,16 @@ public class MappingJackson2XmlHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(converter.canRead(MyBean.class, new MediaType("application", "xml")));
assertTrue(converter.canRead(MyBean.class, new MediaType("text", "xml")));
assertTrue(converter.canRead(MyBean.class, new MediaType("application", "soap+xml")));
assertThat(converter.canRead(MyBean.class, new MediaType("application", "xml"))).isTrue();
assertThat(converter.canRead(MyBean.class, new MediaType("text", "xml"))).isTrue();
assertThat(converter.canRead(MyBean.class, new MediaType("application", "soap+xml"))).isTrue();
}
@Test
public void canWrite() {
assertTrue(converter.canWrite(MyBean.class, new MediaType("application", "xml")));
assertTrue(converter.canWrite(MyBean.class, new MediaType("text", "xml")));
assertTrue(converter.canWrite(MyBean.class, new MediaType("application", "soap+xml")));
assertThat(converter.canWrite(MyBean.class, new MediaType("application", "xml"))).isTrue();
assertThat(converter.canWrite(MyBean.class, new MediaType("text", "xml"))).isTrue();
assertThat(converter.canWrite(MyBean.class, new MediaType("application", "soap+xml"))).isTrue();
}
@Test
@@ -74,12 +72,12 @@ public class MappingJackson2XmlHttpMessageConverterTests {
MockHttpInputMessage inputMessage = new MockHttpInputMessage(body.getBytes("UTF-8"));
inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
MyBean result = (MyBean) converter.read(MyBean.class, inputMessage);
assertEquals("Foo", result.getString());
assertEquals(42, result.getNumber());
assertEquals(42F, result.getFraction(), 0F);
assertArrayEquals(new String[]{"Foo", "Bar"}, result.getArray());
assertTrue(result.isBool());
assertArrayEquals(new byte[]{0x1, 0x2}, result.getBytes());
assertThat(result.getString()).isEqualTo("Foo");
assertThat(result.getNumber()).isEqualTo(42);
assertThat(result.getFraction()).isCloseTo(42F, within(0F));
assertThat(result.getArray()).isEqualTo(new String[]{"Foo", "Bar"});
assertThat(result.isBool()).isTrue();
assertThat(result.getBytes()).isEqualTo(new byte[]{0x1, 0x2});
}
@Test
@@ -94,14 +92,13 @@ public class MappingJackson2XmlHttpMessageConverterTests {
body.setBytes(new byte[]{0x1, 0x2});
converter.write(body, null, outputMessage);
String result = outputMessage.getBodyAsString(StandardCharsets.UTF_8);
assertTrue(result.contains("<string>Foo</string>"));
assertTrue(result.contains("<number>42</number>"));
assertTrue(result.contains("<fraction>42.0</fraction>"));
assertTrue(result.contains("<array><array>Foo</array><array>Bar</array></array>"));
assertTrue(result.contains("<bool>true</bool>"));
assertTrue(result.contains("<bytes>AQI=</bytes>"));
assertEquals("Invalid content-type", new MediaType("application", "xml", StandardCharsets.UTF_8),
outputMessage.getHeaders().getContentType());
assertThat(result.contains("<string>Foo</string>")).isTrue();
assertThat(result.contains("<number>42</number>")).isTrue();
assertThat(result.contains("<fraction>42.0</fraction>")).isTrue();
assertThat(result.contains("<array><array>Foo</array><array>Bar</array></array>")).isTrue();
assertThat(result.contains("<bool>true</bool>")).isTrue();
assertThat(result.contains("<bytes>AQI=</bytes>")).isTrue();
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "xml", StandardCharsets.UTF_8));
}
@Test

21
spring-web/src/test/java/org/springframework/http/converter/xml/MarshallingHttpMessageConverterTests.java
View File

@@ -32,10 +32,8 @@ import org.springframework.oxm.MarshallingFailureException;
import org.springframework.oxm.Unmarshaller;
import org.springframework.oxm.UnmarshallingFailureException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.BDDMockito.given;
@@ -60,9 +58,9 @@ public class MarshallingHttpMessageConverterTests {
MarshallingHttpMessageConverter converter = new MarshallingHttpMessageConverter();
converter.setUnmarshaller(unmarshaller);
assertFalse(converter.canRead(Boolean.class, MediaType.TEXT_PLAIN));
assertFalse(converter.canRead(Integer.class, MediaType.TEXT_XML));
assertTrue(converter.canRead(String.class, MediaType.TEXT_XML));
assertThat(converter.canRead(Boolean.class, MediaType.TEXT_PLAIN)).isFalse();
assertThat(converter.canRead(Integer.class, MediaType.TEXT_XML)).isFalse();
assertThat(converter.canRead(String.class, MediaType.TEXT_XML)).isTrue();
}
@Test
@@ -75,9 +73,9 @@ public class MarshallingHttpMessageConverterTests {
MarshallingHttpMessageConverter converter = new MarshallingHttpMessageConverter();
converter.setMarshaller(marshaller);
assertFalse(converter.canWrite(Boolean.class, MediaType.TEXT_PLAIN));
assertFalse(converter.canWrite(Integer.class, MediaType.TEXT_XML));
assertTrue(converter.canWrite(String.class, MediaType.TEXT_XML));
assertThat(converter.canWrite(Boolean.class, MediaType.TEXT_PLAIN)).isFalse();
assertThat(converter.canWrite(Integer.class, MediaType.TEXT_XML)).isFalse();
assertThat(converter.canWrite(String.class, MediaType.TEXT_XML)).isTrue();
}
@Test
@@ -92,7 +90,7 @@ public class MarshallingHttpMessageConverterTests {
converter.setUnmarshaller(unmarshaller);
String result = (String) converter.read(Object.class, inputMessage);
assertEquals("Invalid result", body, result);
assertThat(result).as("Invalid result").isEqualTo(body);
}
@Test
@@ -136,8 +134,7 @@ public class MarshallingHttpMessageConverterTests {
MarshallingHttpMessageConverter converter = new MarshallingHttpMessageConverter(marshaller);
converter.write(body, null, outputMessage);
assertEquals("Invalid content-type", new MediaType("application", "xml"),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "xml"));
}
@Test

49
spring-web/src/test/java/org/springframework/http/converter/xml/SourceHttpMessageConverterTests.java
View File

@@ -49,9 +49,6 @@ import org.springframework.util.FileCopyUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Arjen Poutsma
@@ -79,15 +76,15 @@ public class SourceHttpMessageConverterTests {
@Test
public void canRead() {
assertTrue(converter.canRead(Source.class, new MediaType("application", "xml")));
assertTrue(converter.canRead(Source.class, new MediaType("application", "soap+xml")));
assertThat(converter.canRead(Source.class, new MediaType("application", "xml"))).isTrue();
assertThat(converter.canRead(Source.class, new MediaType("application", "soap+xml"))).isTrue();
}
@Test
public void canWrite() {
assertTrue(converter.canWrite(Source.class, new MediaType("application", "xml")));
assertTrue(converter.canWrite(Source.class, new MediaType("application", "soap+xml")));
assertTrue(converter.canWrite(Source.class, MediaType.ALL));
assertThat(converter.canWrite(Source.class, new MediaType("application", "xml"))).isTrue();
assertThat(converter.canWrite(Source.class, new MediaType("application", "soap+xml"))).isTrue();
assertThat(converter.canWrite(Source.class, MediaType.ALL)).isTrue();
}
@Test
@@ -96,7 +93,7 @@ public class SourceHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
DOMSource result = (DOMSource) converter.read(DOMSource.class, inputMessage);
Document document = (Document) result.getNode();
assertEquals("Invalid result", "root", document.getDocumentElement().getLocalName());
assertThat(document.getDocumentElement().getLocalName()).as("Invalid result").isEqualTo("root");
}
@Test
@@ -106,8 +103,8 @@ public class SourceHttpMessageConverterTests {
converter.setSupportDtd(true);
DOMSource result = (DOMSource) converter.read(DOMSource.class, inputMessage);
Document document = (Document) result.getNode();
assertEquals("Invalid result", "root", document.getDocumentElement().getLocalName());
assertNotEquals("Invalid result", "Foo Bar", document.getDocumentElement().getTextContent());
assertThat(document.getDocumentElement().getLocalName()).as("Invalid result").isEqualTo("root");
assertThat(document.getDocumentElement().getTextContent()).as("Invalid result").isNotEqualTo("Foo Bar");
}
@Test
@@ -158,7 +155,7 @@ public class SourceHttpMessageConverterTests {
@Override
public void characters(char[] ch, int start, int length) {
String s = new String(ch, start, length);
assertNotEquals("Invalid result", "Foo Bar", s);
assertThat(s).as("Invalid result").isNotEqualTo("Foo Bar");
}
});
reader.parse(inputSource);
@@ -200,12 +197,12 @@ public class SourceHttpMessageConverterTests {
inputMessage.getHeaders().setContentType(new MediaType("application", "xml"));
StAXSource result = (StAXSource) converter.read(StAXSource.class, inputMessage);
XMLStreamReader streamReader = result.getXMLStreamReader();
assertTrue(streamReader.hasNext());
assertThat(streamReader.hasNext()).isTrue();
streamReader.nextTag();
String s = streamReader.getLocalName();
assertEquals("root", s);
assertThat(s).isEqualTo("root");
s = streamReader.getElementText();
assertEquals("Hello World", s);
assertThat(s).isEqualTo("Hello World");
streamReader.close();
}
@@ -216,14 +213,14 @@ public class SourceHttpMessageConverterTests {
converter.setSupportDtd(true);
StAXSource result = (StAXSource) converter.read(StAXSource.class, inputMessage);
XMLStreamReader streamReader = result.getXMLStreamReader();
assertTrue(streamReader.hasNext());
assertThat(streamReader.hasNext()).isTrue();
streamReader.next();
streamReader.next();
String s = streamReader.getLocalName();
assertEquals("root", s);
assertThat(s).isEqualTo("root");
try {
s = streamReader.getElementText();
assertNotEquals("Foo Bar", s);
assertThat(s).isNotEqualTo("Foo Bar");
}
catch (XMLStreamException ex) {
// Some parsers raise a parse exception
@@ -254,11 +251,11 @@ public class SourceHttpMessageConverterTests {
StAXSource result = (StAXSource) this.converter.read(StAXSource.class, inputMessage);
XMLStreamReader streamReader = result.getXMLStreamReader();
assertTrue(streamReader.hasNext());
assertThat(streamReader.hasNext()).isTrue();
streamReader.next();
streamReader.next();
String s = streamReader.getLocalName();
assertEquals("root", s);
assertThat(s).isEqualTo("root");
assertThatExceptionOfType(XMLStreamException.class).isThrownBy(() ->
streamReader.getElementText())
.withMessageContaining("\"lol9\"");
@@ -294,10 +291,8 @@ public class SourceHttpMessageConverterTests {
converter.write(domSource, null, outputMessage);
assertThat(XmlContent.of(outputMessage.getBodyAsString(StandardCharsets.UTF_8)))
.isSimilarTo("<root>Hello World</root>");
assertEquals("Invalid content-type", new MediaType("application", "xml"),
outputMessage.getHeaders().getContentType());
assertEquals("Invalid content-length", outputMessage.getBodyAsBytes().length,
outputMessage.getHeaders().getContentLength());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "xml"));
assertThat(outputMessage.getHeaders().getContentLength()).as("Invalid content-length").isEqualTo(outputMessage.getBodyAsBytes().length);
}
@Test
@@ -309,8 +304,7 @@ public class SourceHttpMessageConverterTests {
converter.write(saxSource, null, outputMessage);
assertThat(XmlContent.of(outputMessage.getBodyAsString(StandardCharsets.UTF_8)))
.isSimilarTo("<root>Hello World</root>");
assertEquals("Invalid content-type", new MediaType("application", "xml"),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "xml"));
}
@Test
@@ -322,8 +316,7 @@ public class SourceHttpMessageConverterTests {
converter.write(streamSource, null, outputMessage);
assertThat(XmlContent.of(outputMessage.getBodyAsString(StandardCharsets.UTF_8)))
.isSimilarTo("<root>Hello World</root>");
assertEquals("Invalid content-type", new MediaType("application", "xml"),
outputMessage.getHeaders().getContentType());
assertThat(outputMessage.getHeaders().getContentType()).as("Invalid content-type").isEqualTo(new MediaType("application", "xml"));
}
}

29
spring-web/src/test/java/org/springframework/http/server/DefaultPathContainerTests.java
View File

@@ -26,8 +26,7 @@ import org.springframework.http.server.PathContainer.PathSegment;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link DefaultPathContainer}.
@@ -79,16 +78,16 @@ public class DefaultPathContainerTests {
PathContainer container = PathContainer.parsePath(rawValue);
if ("".equals(rawValue)) {
assertEquals(0, container.elements().size());
assertThat(container.elements().size()).isEqualTo(0);
return;
}
assertEquals(1, container.elements().size());
assertThat(container.elements().size()).isEqualTo(1);
PathSegment segment = (PathSegment) container.elements().get(0);
assertEquals("value: '" + rawValue + "'", rawValue, segment.value());
assertEquals("valueToMatch: '" + rawValue + "'", valueToMatch, segment.valueToMatch());
assertEquals("params: '" + rawValue + "'", params, segment.parameters());
assertThat(segment.value()).as("value: '" + rawValue + "'").isEqualTo(rawValue);
assertThat(segment.valueToMatch()).as("valueToMatch: '" + rawValue + "'").isEqualTo(valueToMatch);
assertThat(segment.parameters()).as("params: '" + rawValue + "'").isEqualTo(params);
}
@Test
@@ -116,26 +115,26 @@ public class DefaultPathContainerTests {
PathContainer path = PathContainer.parsePath(input);
assertEquals("value: '" + input + "'", value, path.value());
assertEquals("elements: " + input, expectedElements, path.elements().stream()
.map(PathContainer.Element::value).collect(Collectors.toList()));
assertThat(path.value()).as("value: '" + input + "'").isEqualTo(value);
assertThat(path.elements().stream()
.map(PathContainer.Element::value).collect(Collectors.toList())).as("elements: " + input).isEqualTo(expectedElements);
}
@Test
public void subPath() throws Exception {
// basic
PathContainer path = PathContainer.parsePath("/a/b/c");
assertSame(path, path.subPath(0));
assertEquals("/b/c", path.subPath(2).value());
assertEquals("/c", path.subPath(4).value());
assertThat(path.subPath(0)).isSameAs(path);
assertThat(path.subPath(2).value()).isEqualTo("/b/c");
assertThat(path.subPath(4).value()).isEqualTo("/c");
// root path
path = PathContainer.parsePath("/");
assertEquals("/", path.subPath(0).value());
assertThat(path.subPath(0).value()).isEqualTo("/");
// trailing slash
path = PathContainer.parsePath("/a/b/");
assertEquals("/b/", path.subPath(2).value());
assertThat(path.subPath(2).value()).isEqualTo("/b/");
}
}

15
spring-web/src/test/java/org/springframework/http/server/DefaultRequestPathTests.java
View File

@@ -19,7 +19,7 @@ import java.net.URI;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@link DefaultRequestPath}.
@@ -55,8 +55,9 @@ public class DefaultRequestPathTests {
URI uri = URI.create("http://localhost:8080" + fullPath);
RequestPath requestPath = RequestPath.parse(uri, contextPath);
assertEquals(contextPath.equals("/") ? "" : contextPath, requestPath.contextPath().value());
assertEquals(pathWithinApplication, requestPath.pathWithinApplication().value());
Object expected = contextPath.equals("/") ? "" : contextPath;
assertThat(requestPath.contextPath().value()).isEqualTo(expected);
assertThat(requestPath.pathWithinApplication().value()).isEqualTo(pathWithinApplication);
}
@Test
@@ -65,13 +66,13 @@ public class DefaultRequestPathTests {
URI uri = URI.create("http://localhost:8080/aA/bB/cC");
RequestPath requestPath = RequestPath.parse(uri, null);
assertEquals("", requestPath.contextPath().value());
assertEquals("/aA/bB/cC", requestPath.pathWithinApplication().value());
assertThat(requestPath.contextPath().value()).isEqualTo("");
assertThat(requestPath.pathWithinApplication().value()).isEqualTo("/aA/bB/cC");
requestPath = requestPath.modifyContextPath("/aA");
assertEquals("/aA", requestPath.contextPath().value());
assertEquals("/bB/cC", requestPath.pathWithinApplication().value());
assertThat(requestPath.contextPath().value()).isEqualTo("/aA");
assertThat(requestPath.pathWithinApplication().value()).isEqualTo("/bB/cC");
}
}

47
spring-web/src/test/java/org/springframework/http/server/ServletServerHttpRequestTests.java
View File

@@ -31,11 +31,7 @@ import org.springframework.http.MediaType;
import org.springframework.mock.web.test.MockHttpServletRequest;
import org.springframework.util.FileCopyUtils;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -58,7 +54,7 @@ public class ServletServerHttpRequestTests {
@Test
public void getMethod() {
mockRequest.setMethod("POST");
assertEquals("Invalid method", HttpMethod.POST, request.getMethod());
assertThat(request.getMethod()).as("Invalid method").isEqualTo(HttpMethod.POST);
}
@Test
@@ -69,7 +65,7 @@ public class ServletServerHttpRequestTests {
mockRequest.setServerPort(uri.getPort());
mockRequest.setRequestURI(uri.getPath());
mockRequest.setQueryString(uri.getQuery());
assertEquals(uri, request.getURI());
assertThat(request.getURI()).isEqualTo(uri);
}
@Test
@@ -80,7 +76,7 @@ public class ServletServerHttpRequestTests {
mockRequest.setServerPort(uri.getPort());
mockRequest.setRequestURI(uri.getPath());
mockRequest.setQueryString(uri.getQuery());
assertEquals(uri, request.getURI());
assertThat(request.getURI()).isEqualTo(uri);
}
@Test // SPR-16414
@@ -88,7 +84,7 @@ public class ServletServerHttpRequestTests {
mockRequest.setServerName("example.com");
mockRequest.setRequestURI("/path");
mockRequest.setQueryString("query=foo");
assertEquals(new URI("http://example.com/path?query=foo"), request.getURI());
assertThat(request.getURI()).isEqualTo(new URI("http://example.com/path?query=foo"));
}
@Test // SPR-16414
@@ -96,7 +92,7 @@ public class ServletServerHttpRequestTests {
mockRequest.setServerName("example.com");
mockRequest.setRequestURI("/path");
mockRequest.setQueryString("query=foo%%x");
assertEquals(new URI("http://example.com/path"), request.getURI());
assertThat(request.getURI()).isEqualTo(new URI("http://example.com/path"));
}
@Test // SPR-13876
@@ -108,7 +104,7 @@ public class ServletServerHttpRequestTests {
mockRequest.setServerPort(uri.getPort());
mockRequest.setRequestURI(uri.getRawPath());
mockRequest.setQueryString(uri.getRawQuery());
assertEquals(uri, request.getURI());
assertThat(request.getURI()).isEqualTo(uri);
}
@Test
@@ -122,14 +118,13 @@ public class ServletServerHttpRequestTests {
mockRequest.setCharacterEncoding("UTF-8");
HttpHeaders headers = request.getHeaders();
assertNotNull("No HttpHeaders returned", headers);
assertTrue("Invalid headers returned", headers.containsKey(headerName));
assertThat(headers).as("No HttpHeaders returned").isNotNull();
assertThat(headers.containsKey(headerName)).as("Invalid headers returned").isTrue();
List<String> headerValues = headers.get(headerName);
assertEquals("Invalid header values returned", 2, headerValues.size());
assertTrue("Invalid header values returned", headerValues.contains(headerValue1));
assertTrue("Invalid header values returned", headerValues.contains(headerValue2));
assertEquals("Invalid Content-Type", new MediaType("text", "plain", StandardCharsets.UTF_8),
headers.getContentType());
assertThat(headerValues.size()).as("Invalid header values returned").isEqualTo(2);
assertThat(headerValues.contains(headerValue1)).as("Invalid header values returned").isTrue();
assertThat(headerValues.contains(headerValue2)).as("Invalid header values returned").isTrue();
assertThat(headers.getContentType()).as("Invalid Content-Type").isEqualTo(new MediaType("text", "plain", StandardCharsets.UTF_8));
}
@Test
@@ -143,13 +138,13 @@ public class ServletServerHttpRequestTests {
mockRequest.setCharacterEncoding("");
HttpHeaders headers = request.getHeaders();
assertNotNull("No HttpHeaders returned", headers);
assertTrue("Invalid headers returned", headers.containsKey(headerName));
assertThat(headers).as("No HttpHeaders returned").isNotNull();
assertThat(headers.containsKey(headerName)).as("Invalid headers returned").isTrue();
List<String> headerValues = headers.get(headerName);
assertEquals("Invalid header values returned", 2, headerValues.size());
assertTrue("Invalid header values returned", headerValues.contains(headerValue1));
assertTrue("Invalid header values returned", headerValues.contains(headerValue2));
assertNull(headers.getContentType());
assertThat(headerValues.size()).as("Invalid header values returned").isEqualTo(2);
assertThat(headerValues.contains(headerValue1)).as("Invalid header values returned").isTrue();
assertThat(headerValues.contains(headerValue2)).as("Invalid header values returned").isTrue();
assertThat(headers.getContentType()).isNull();
}
@Test
@@ -158,7 +153,7 @@ public class ServletServerHttpRequestTests {
mockRequest.setContent(content);
byte[] result = FileCopyUtils.copyToByteArray(request.getBody());
assertArrayEquals("Invalid content returned", content, result);
assertThat(result).as("Invalid content returned").isEqualTo(content);
}
@Test
@@ -172,7 +167,7 @@ public class ServletServerHttpRequestTests {
byte[] result = FileCopyUtils.copyToByteArray(request.getBody());
byte[] content = "name+1=value+1&name+2=value+2%2B1&name+2=value+2%2B2&name+3".getBytes("UTF-8");
assertArrayEquals("Invalid content returned", content, result);
assertThat(result).as("Invalid content returned").isEqualTo(content);
}
}

30
spring-web/src/test/java/org/springframework/http/server/ServletServerHttpResponseTests.java
View File

@@ -29,9 +29,7 @@ import org.springframework.http.MediaType;
import org.springframework.mock.web.test.MockHttpServletResponse;
import org.springframework.util.FileCopyUtils;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -55,7 +53,7 @@ public class ServletServerHttpResponseTests {
@Test
public void setStatusCode() throws Exception {
response.setStatusCode(HttpStatus.NOT_FOUND);
assertEquals("Invalid status code", 404, mockResponse.getStatus());
assertThat(mockResponse.getStatus()).as("Invalid status code").isEqualTo(404);
}
@Test
@@ -69,13 +67,13 @@ public class ServletServerHttpResponseTests {
headers.setContentType(new MediaType("text", "plain", StandardCharsets.UTF_8));
response.close();
assertTrue("Header not set", mockResponse.getHeaderNames().contains(headerName));
assertThat(mockResponse.getHeaderNames().contains(headerName)).as("Header not set").isTrue();
List<String> headerValues = mockResponse.getHeaders(headerName);
assertTrue("Header not set", headerValues.contains(headerValue1));
assertTrue("Header not set", headerValues.contains(headerValue2));
assertEquals("Invalid Content-Type", "text/plain;charset=UTF-8", mockResponse.getHeader("Content-Type"));
assertEquals("Invalid Content-Type", "text/plain;charset=UTF-8", mockResponse.getContentType());
assertEquals("Invalid Content-Type", "UTF-8", mockResponse.getCharacterEncoding());
assertThat(headerValues.contains(headerValue1)).as("Header not set").isTrue();
assertThat(headerValues.contains(headerValue2)).as("Header not set").isTrue();
assertThat(mockResponse.getHeader("Content-Type")).as("Invalid Content-Type").isEqualTo("text/plain;charset=UTF-8");
assertThat(mockResponse.getContentType()).as("Invalid Content-Type").isEqualTo("text/plain;charset=UTF-8");
assertThat(mockResponse.getCharacterEncoding()).as("Invalid Content-Type").isEqualTo("UTF-8");
}
@Test
@@ -86,11 +84,11 @@ public class ServletServerHttpResponseTests {
this.mockResponse.addHeader(headerName, headerValue);
this.response = new ServletServerHttpResponse(this.mockResponse);
assertEquals(headerValue, this.response.getHeaders().getFirst(headerName));
assertEquals(Collections.singletonList(headerValue), this.response.getHeaders().get(headerName));
assertTrue(this.response.getHeaders().containsKey(headerName));
assertEquals(headerValue, this.response.getHeaders().getFirst(headerName));
assertEquals(headerValue, this.response.getHeaders().getAccessControlAllowOrigin());
assertThat(this.response.getHeaders().getFirst(headerName)).isEqualTo(headerValue);
assertThat(this.response.getHeaders().get(headerName)).isEqualTo(Collections.singletonList(headerValue));
assertThat(this.response.getHeaders().containsKey(headerName)).isTrue();
assertThat(this.response.getHeaders().getFirst(headerName)).isEqualTo(headerValue);
assertThat(this.response.getHeaders().getAccessControlAllowOrigin()).isEqualTo(headerValue);
}
@Test
@@ -98,7 +96,7 @@ public class ServletServerHttpResponseTests {
byte[] content = "Hello World".getBytes("UTF-8");
FileCopyUtils.copy(content, response.getBody());
assertArrayEquals("Invalid content written", content, mockResponse.getContentAsByteArray());
assertThat(mockResponse.getContentAsByteArray()).as("Invalid content written").isEqualTo(content);
}
}

59
spring-web/src/test/java/org/springframework/http/server/reactive/ChannelSendOperatorTests.java
View File

@@ -38,10 +38,7 @@ import reactor.test.StepVerifier;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.LeakAwareDataBufferFactory;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Rossen Stoyanchev
@@ -64,8 +61,8 @@ public class ChannelSendOperatorTests {
Mono<Void> completion = Mono.<String>error(error).as(this::sendOperator);
Signal<Void> signal = completion.materialize().block();
assertNotNull(signal);
assertSame("Unexpected signal: " + signal, error, signal.getThrowable());
assertThat(signal).isNotNull();
assertThat(signal.getThrowable()).as("Unexpected signal: " + signal).isSameAs(error);
}
@Test
@@ -73,11 +70,11 @@ public class ChannelSendOperatorTests {
Mono<Void> completion = Flux.<String>empty().as(this::sendOperator);
Signal<Void> signal = completion.materialize().block();
assertNotNull(signal);
assertTrue("Unexpected signal: " + signal, signal.isOnComplete());
assertThat(signal).isNotNull();
assertThat(signal.isOnComplete()).as("Unexpected signal: " + signal).isTrue();
assertEquals(0, this.writer.items.size());
assertTrue(this.writer.completed);
assertThat(this.writer.items.size()).isEqualTo(0);
assertThat(this.writer.completed).isTrue();
}
@Test
@@ -85,12 +82,12 @@ public class ChannelSendOperatorTests {
Mono<Void> completion = Flux.just("one").as(this::sendOperator);
Signal<Void> signal = completion.materialize().block();
assertNotNull(signal);
assertTrue("Unexpected signal: " + signal, signal.isOnComplete());
assertThat(signal).isNotNull();
assertThat(signal.isOnComplete()).as("Unexpected signal: " + signal).isTrue();
assertEquals(1, this.writer.items.size());
assertEquals("one", this.writer.items.get(0));
assertTrue(this.writer.completed);
assertThat(this.writer.items.size()).isEqualTo(1);
assertThat(this.writer.items.get(0)).isEqualTo("one");
assertThat(this.writer.completed).isTrue();
}
@@ -100,14 +97,14 @@ public class ChannelSendOperatorTests {
Mono<Void> completion = Flux.fromIterable(items).as(this::sendOperator);
Signal<Void> signal = completion.materialize().block();
assertNotNull(signal);
assertTrue("Unexpected signal: " + signal, signal.isOnComplete());
assertThat(signal).isNotNull();
assertThat(signal.isOnComplete()).as("Unexpected signal: " + signal).isTrue();
assertEquals(3, this.writer.items.size());
assertEquals("one", this.writer.items.get(0));
assertEquals("two", this.writer.items.get(1));
assertEquals("three", this.writer.items.get(2));
assertTrue(this.writer.completed);
assertThat(this.writer.items.size()).isEqualTo(3);
assertThat(this.writer.items.get(0)).isEqualTo("one");
assertThat(this.writer.items.get(1)).isEqualTo("two");
assertThat(this.writer.items.get(2)).isEqualTo("three");
assertThat(this.writer.completed).isTrue();
}
@Test
@@ -124,14 +121,14 @@ public class ChannelSendOperatorTests {
Mono<Void> completion = publisher.as(this::sendOperator);
Signal<Void> signal = completion.materialize().block();
assertNotNull(signal);
assertSame("Unexpected signal: " + signal, error, signal.getThrowable());
assertThat(signal).isNotNull();
assertThat(signal.getThrowable()).as("Unexpected signal: " + signal).isSameAs(error);
assertEquals(3, this.writer.items.size());
assertEquals("1", this.writer.items.get(0));
assertEquals("2", this.writer.items.get(1));
assertEquals("3", this.writer.items.get(2));
assertSame(error, this.writer.error);
assertThat(this.writer.items.size()).isEqualTo(3);
assertThat(this.writer.items.get(0)).isEqualTo("1");
assertThat(this.writer.items.get(1)).isEqualTo("2");
assertThat(this.writer.items.get(2)).isEqualTo("3");
assertThat(this.writer.error).isSameAs(error);
}
@Test // gh-22720
@@ -185,8 +182,8 @@ public class ChannelSendOperatorTests {
writeSubscriber.signalDemand(1); // Let cached signals ("foo" and error) be published..
}
catch (Throwable ex) {
assertNotNull(ex.getCause());
assertEquals("err", ex.getCause().getMessage());
assertThat(ex.getCause()).isNotNull();
assertThat(ex.getCause().getMessage()).isEqualTo("err");
}
bufferFactory.checkForLeaks();

20
spring-web/src/test/java/org/springframework/http/server/reactive/ContextPathCompositeHandlerTests.java
View File

@@ -30,10 +30,8 @@ import org.springframework.http.HttpStatus;
import org.springframework.mock.http.server.reactive.test.MockServerHttpRequest;
import org.springframework.mock.http.server.reactive.test.MockServerHttpResponse;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Unit tests for {@link ContextPathCompositeHandler}.
@@ -101,8 +99,8 @@ public class ContextPathCompositeHandlerTests {
new ContextPathCompositeHandler(map).handle(request, new MockServerHttpResponse());
assertTrue(handler.wasInvoked());
assertEquals("/yet/another/path", handler.getRequest().getPath().contextPath().value());
assertThat(handler.wasInvoked()).isTrue();
assertThat(handler.getRequest().getPath().contextPath().value()).isEqualTo("/yet/another/path");
}
@Test
@@ -117,7 +115,7 @@ public class ContextPathCompositeHandlerTests {
ServerHttpResponse response = testHandle("/yet/another/path", map);
assertNotInvoked(handler1, handler2);
assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
}
@Test // SPR-17144
@@ -138,8 +136,8 @@ public class ContextPathCompositeHandlerTests {
new ContextPathCompositeHandler(map).handle(request, response).block(Duration.ofSeconds(5));
assertNotInvoked(handler);
assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
assertTrue(commitInvoked.get());
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
assertThat(commitInvoked.get()).isTrue();
}
@@ -151,12 +149,12 @@ public class ContextPathCompositeHandlerTests {
}
private void assertInvoked(TestHttpHandler handler, String contextPath) {
assertTrue(handler.wasInvoked());
assertEquals(contextPath, handler.getRequest().getPath().contextPath().value());
assertThat(handler.wasInvoked()).isTrue();
assertThat(handler.getRequest().getPath().contextPath().value()).isEqualTo(contextPath);
}
private void assertNotInvoked(TestHttpHandler... handlers) {
Arrays.stream(handlers).forEach(handler -> assertFalse(handler.wasInvoked()));
Arrays.stream(handlers).forEach(handler -> assertThat(handler.wasInvoked()).isFalse());
}

14
spring-web/src/test/java/org/springframework/http/server/reactive/CookieIntegrationTests.java
View File

@@ -33,7 +33,6 @@ import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
/**
* @author Rossen Stoyanchev
@@ -50,7 +49,6 @@ public class CookieIntegrationTests extends AbstractHttpHandlerIntegrationTests
}
@SuppressWarnings("unchecked")
@Test
public void basicTest() throws Exception {
URI url = new URI("http://localhost:" + port);
@@ -59,18 +57,18 @@ public class CookieIntegrationTests extends AbstractHttpHandlerIntegrationTests
RequestEntity.get(url).header("Cookie", header).build(), Void.class);
Map<String, List<HttpCookie>> requestCookies = this.cookieHandler.requestCookies;
assertEquals(2, requestCookies.size());
assertThat(requestCookies.size()).isEqualTo(2);
List<HttpCookie> list = requestCookies.get("SID");
assertEquals(1, list.size());
assertEquals("31d4d96e407aad42", list.iterator().next().getValue());
assertThat(list.size()).isEqualTo(1);
assertThat(list.iterator().next().getValue()).isEqualTo("31d4d96e407aad42");
list = requestCookies.get("lang");
assertEquals(1, list.size());
assertEquals("en-US", list.iterator().next().getValue());
assertThat(list.size()).isEqualTo(1);
assertThat(list.iterator().next().getValue()).isEqualTo("en-US");
List<String> headerValues = response.getHeaders().get("Set-Cookie");
assertEquals(2, headerValues.size());
assertThat(headerValues.size()).isEqualTo(2);
List<String> cookie0 = splitCookie(headerValues.get(0));
assertThat(cookie0.remove("SID=31d4d96e407aad42")).as("SID").isTrue();

4
spring-web/src/test/java/org/springframework/http/server/reactive/EchoHandlerIntegrationTests.java
View File

@@ -26,7 +26,7 @@ import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import static org.junit.Assert.assertArrayEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -52,7 +52,7 @@ public class EchoHandlerIntegrationTests extends AbstractHttpHandlerIntegrationT
RequestEntity<byte[]> request = RequestEntity.post(new URI("http://localhost:" + port)).body(body);
ResponseEntity<byte[]> response = restTemplate.exchange(request, byte[].class);
assertArrayEquals(body, response.getBody());
assertThat(response.getBody()).isEqualTo(body);
}

8
spring-web/src/test/java/org/springframework/http/server/reactive/ErrorHandlerIntegrationTests.java
View File

@@ -27,7 +27,7 @@ import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.ResponseErrorHandler;
import org.springframework.web.client.RestTemplate;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -51,7 +51,7 @@ public class ErrorHandlerIntegrationTests extends AbstractHttpHandlerIntegration
URI url = new URI("http://localhost:" + port + "/response-body-error");
ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
}
@Test
@@ -62,7 +62,7 @@ public class ErrorHandlerIntegrationTests extends AbstractHttpHandlerIntegration
URI url = new URI("http://localhost:" + port + "/handling-error");
ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
}
@Test // SPR-15560
@@ -74,7 +74,7 @@ public class ErrorHandlerIntegrationTests extends AbstractHttpHandlerIntegration
URI url = new URI("http://localhost:" + port + "//");
ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
}

22
spring-web/src/test/java/org/springframework/http/server/reactive/HeadersAdaptersTests.java
View File

@@ -32,9 +32,7 @@ import org.springframework.util.CollectionUtils;
import org.springframework.util.LinkedCaseInsensitiveMap;
import org.springframework.util.MultiValueMap;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Unit tests for {@code HeadersAdapters} {@code MultiValueMap} implementations.
@@ -66,19 +64,19 @@ public class HeadersAdaptersTests {
@Test
public void getWithUnknownHeaderShouldReturnNull() {
assertNull(this.headers.get("Unknown"));
assertThat(this.headers.get("Unknown")).isNull();
}
@Test
public void getFirstWithUnknownHeaderShouldReturnNull() {
assertNull(this.headers.getFirst("Unknown"));
assertThat(this.headers.getFirst("Unknown")).isNull();
}
@Test
public void sizeWithMultipleValuesForHeaderShouldCountHeaders() {
this.headers.add("TestHeader", "first");
this.headers.add("TestHeader", "second");
assertEquals(1, this.headers.size());
assertThat(this.headers.size()).isEqualTo(1);
}
@Test
@@ -86,29 +84,29 @@ public class HeadersAdaptersTests {
this.headers.add("TestHeader", "first");
this.headers.add("OtherHeader", "test");
this.headers.add("TestHeader", "second");
assertEquals(2, this.headers.keySet().size());
assertThat(this.headers.keySet().size()).isEqualTo(2);
}
@Test
public void containsKeyShouldBeCaseInsensitive() {
this.headers.add("TestHeader", "first");
assertTrue(this.headers.containsKey("testheader"));
assertThat(this.headers.containsKey("testheader")).isTrue();
}
@Test
public void addShouldKeepOrdering() {
this.headers.add("TestHeader", "first");
this.headers.add("TestHeader", "second");
assertEquals("first", this.headers.getFirst("TestHeader"));
assertEquals("first", this.headers.get("TestHeader").get(0));
assertThat(this.headers.getFirst("TestHeader")).isEqualTo("first");
assertThat(this.headers.get("TestHeader").get(0)).isEqualTo("first");
}
@Test
public void putShouldOverrideExisting() {
this.headers.add("TestHeader", "first");
this.headers.put("TestHeader", Arrays.asList("override"));
assertEquals("override", this.headers.getFirst("TestHeader"));
assertEquals(1, this.headers.get("TestHeader").size());
assertThat(this.headers.getFirst("TestHeader")).isEqualTo("override");
assertThat(this.headers.get("TestHeader").size()).isEqualTo(1);
}
}

12
spring-web/src/test/java/org/springframework/http/server/reactive/ListenerReadPublisherTests.java
View File

@@ -23,7 +23,7 @@ import org.reactivestreams.Subscription;
import org.springframework.core.io.buffer.DataBuffer;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@@ -51,7 +51,7 @@ public class ListenerReadPublisherTests {
this.subscriber.getSubscription().request(2);
this.publisher.onDataAvailable();
assertEquals(2, this.publisher.getReadCalls());
assertThat(this.publisher.getReadCalls()).isEqualTo(2);
}
@Test // SPR-17410
@@ -61,8 +61,8 @@ public class ListenerReadPublisherTests {
this.publisher.onDataAvailable();
this.publisher.onError(new IllegalStateException());
assertEquals(2, this.publisher.getReadCalls());
assertEquals(1, this.publisher.getDiscardCalls());
assertThat(this.publisher.getReadCalls()).isEqualTo(2);
assertThat(this.publisher.getDiscardCalls()).isEqualTo(1);
}
@Test // SPR-17410
@@ -72,8 +72,8 @@ public class ListenerReadPublisherTests {
this.subscriber.setCancelOnNext(true);
this.publisher.onDataAvailable();
assertEquals(1, this.publisher.getReadCalls());
assertEquals(1, this.publisher.getDiscardCalls());
assertThat(this.publisher.getReadCalls()).isEqualTo(1);
assertThat(this.publisher.getDiscardCalls()).isEqualTo(1);
}

26
spring-web/src/test/java/org/springframework/http/server/reactive/ListenerWriteProcessorTests.java
View File

@@ -27,9 +27,7 @@ import org.reactivestreams.Subscription;
import org.springframework.core.io.buffer.DataBuffer;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
/**
@@ -50,7 +48,7 @@ public class ListenerWriteProcessorTests {
public void setup() {
this.processor.subscribe(this.resultSubscriber);
this.processor.onSubscribe(this.subscription);
assertEquals(1, subscription.getDemand());
assertThat(subscription.getDemand()).isEqualTo(1);
}
@@ -65,9 +63,9 @@ public class ListenerWriteProcessorTests {
// Send error while item cached
this.processor.onError(new IllegalStateException());
assertNotNull("Error should flow to result publisher", this.resultSubscriber.getError());
assertEquals(1, this.processor.getDiscardedBuffers().size());
assertSame(buffer, this.processor.getDiscardedBuffers().get(0));
assertThat(this.resultSubscriber.getError()).as("Error should flow to result publisher").isNotNull();
assertThat(this.processor.getDiscardedBuffers().size()).isEqualTo(1);
assertThat(this.processor.getDiscardedBuffers().get(0)).isSameAs(buffer);
}
@Test // SPR-17410
@@ -81,9 +79,9 @@ public class ListenerWriteProcessorTests {
DataBuffer buffer = mock(DataBuffer.class);
this.processor.onNext(buffer);
assertNotNull("Error should flow to result publisher", this.resultSubscriber.getError());
assertEquals(1, this.processor.getDiscardedBuffers().size());
assertSame(buffer, this.processor.getDiscardedBuffers().get(0));
assertThat(this.resultSubscriber.getError()).as("Error should flow to result publisher").isNotNull();
assertThat(this.processor.getDiscardedBuffers().size()).isEqualTo(1);
assertThat(this.processor.getDiscardedBuffers().get(0)).isSameAs(buffer);
}
@Test // SPR-17410
@@ -98,10 +96,10 @@ public class ListenerWriteProcessorTests {
DataBuffer buffer2 = mock(DataBuffer.class);
this.processor.onNext(buffer2);
assertNotNull("Error should flow to result publisher", this.resultSubscriber.getError());
assertEquals(2, this.processor.getDiscardedBuffers().size());
assertSame(buffer2, this.processor.getDiscardedBuffers().get(0));
assertSame(buffer1, this.processor.getDiscardedBuffers().get(1));
assertThat(this.resultSubscriber.getError()).as("Error should flow to result publisher").isNotNull();
assertThat(this.processor.getDiscardedBuffers().size()).isEqualTo(2);
assertThat(this.processor.getDiscardedBuffers().get(0)).isSameAs(buffer2);
assertThat(this.processor.getDiscardedBuffers().get(1)).isSameAs(buffer1);
}

29
spring-web/src/test/java/org/springframework/http/server/reactive/MultipartIntegrationTests.java
View File

@@ -40,8 +40,7 @@ import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebHandler;
import org.springframework.web.server.adapter.HttpWebHandlerAdapter;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Sebastien Deleuze
@@ -61,7 +60,7 @@ public class MultipartIntegrationTests extends AbstractHttpHandlerIntegrationTes
.contentType(MediaType.MULTIPART_FORM_DATA)
.body(generateBody());
ResponseEntity<Void> response = restTemplate.exchange(request, Void.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
}
private MultiValueMap<String, Object> generateBody() {
@@ -91,34 +90,36 @@ public class MultipartIntegrationTests extends AbstractHttpHandlerIntegrationTes
return exchange
.getMultipartData()
.doOnNext(parts -> {
assertEquals(2, parts.size());
assertTrue(parts.containsKey("fooPart"));
assertThat(parts.size()).isEqualTo(2);
assertThat(parts.containsKey("fooPart")).isTrue();
assertFooPart(parts.getFirst("fooPart"));
assertTrue(parts.containsKey("barPart"));
assertThat(parts.containsKey("barPart")).isTrue();
assertBarPart(parts.getFirst("barPart"));
})
.then();
}
private void assertFooPart(Part part) {
assertEquals("fooPart", part.name());
assertTrue(part instanceof FilePart);
assertEquals("foo.txt", ((FilePart) part).filename());
assertThat(part.name()).isEqualTo("fooPart");
boolean condition = part instanceof FilePart;
assertThat(condition).isTrue();
assertThat(((FilePart) part).filename()).isEqualTo("foo.txt");
StepVerifier.create(DataBufferUtils.join(part.content()))
.consumeNextWith(buffer -> {
assertEquals(12, buffer.readableByteCount());
assertThat(buffer.readableByteCount()).isEqualTo(12);
byte[] byteContent = new byte[12];
buffer.read(byteContent);
assertEquals("Lorem Ipsum.", new String(byteContent));
assertThat(new String(byteContent)).isEqualTo("Lorem Ipsum.");
})
.verifyComplete();
}
private void assertBarPart(Part part) {
assertEquals("barPart", part.name());
assertTrue(part instanceof FormFieldPart);
assertEquals("bar", ((FormFieldPart) part).value());
assertThat(part.name()).isEqualTo("barPart");
boolean condition = part instanceof FormFieldPart;
assertThat(condition).isTrue();
assertThat(((FormFieldPart) part).value()).isEqualTo("bar");
}
}

15
spring-web/src/test/java/org/springframework/http/server/reactive/RandomHandlerIntegrationTests.java
View File

@@ -31,9 +31,7 @@ import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Arjen Poutsma
@@ -67,10 +65,9 @@ public class RandomHandlerIntegrationTests extends AbstractHttpHandlerIntegratio
RequestEntity<byte[]> request = RequestEntity.post(new URI("http://localhost:" + port)).body(body);
ResponseEntity<byte[]> response = restTemplate.exchange(request, byte[].class);
assertNotNull(response.getBody());
assertEquals(RESPONSE_SIZE,
response.getHeaders().getContentLength());
assertEquals(RESPONSE_SIZE, response.getBody().length);
assertThat(response.getBody()).isNotNull();
assertThat(response.getHeaders().getContentLength()).isEqualTo(RESPONSE_SIZE);
assertThat(response.getBody().length).isEqualTo(RESPONSE_SIZE);
}
@@ -90,8 +87,8 @@ public class RandomHandlerIntegrationTests extends AbstractHttpHandlerIntegratio
reduce(0, (integer, dataBuffer) -> integer +
dataBuffer.readableByteCount()).
doOnSuccessOrError((size, throwable) -> {
assertNull(throwable);
assertEquals(REQUEST_SIZE, (long) size);
assertThat(throwable).isNull();
assertThat(size).isEqualTo(REQUEST_SIZE);
});
response.getHeaders().setContentLength(RESPONSE_SIZE);

18
spring-web/src/test/java/org/springframework/http/server/reactive/ServerHttpRequestIntegrationTests.java
View File

@@ -26,9 +26,7 @@ import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Sebastien Deleuze
@@ -45,7 +43,7 @@ public class ServerHttpRequestIntegrationTests extends AbstractHttpHandlerIntegr
URI url = new URI("http://localhost:" + port + "/foo?param=bar");
RequestEntity<Void> request = RequestEntity.post(url).build();
ResponseEntity<Void> response = new RestTemplate().exchange(request, Void.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
}
@@ -54,12 +52,12 @@ public class ServerHttpRequestIntegrationTests extends AbstractHttpHandlerIntegr
@Override
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
URI uri = request.getURI();
assertEquals("http", uri.getScheme());
assertNotNull(uri.getHost());
assertNotEquals(-1, uri.getPort());
assertNotNull(request.getRemoteAddress());
assertEquals("/foo", uri.getPath());
assertEquals("param=bar", uri.getQuery());
assertThat(uri.getScheme()).isEqualTo("http");
assertThat(uri.getHost()).isNotNull();
assertThat(uri.getPort()).isNotEqualTo((long) -1);
assertThat(request.getRemoteAddress()).isNotNull();
assertThat(uri.getPath()).isEqualTo("/foo");
assertThat(uri.getQuery()).isEqualTo("param=bar");
return Mono.empty();
}
}

43
spring-web/src/test/java/org/springframework/http/server/reactive/ServerHttpRequestTests.java
View File

@@ -34,9 +34,8 @@ import org.springframework.mock.web.test.MockHttpServletRequest;
import org.springframework.mock.web.test.MockHttpServletResponse;
import org.springframework.util.MultiValueMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.mockito.Mockito.mock;
/**
@@ -49,43 +48,43 @@ public class ServerHttpRequestTests {
@Test
public void queryParamsNone() throws Exception {
MultiValueMap<String, String> params = createHttpRequest("/path").getQueryParams();
assertEquals(0, params.size());
assertThat(params.size()).isEqualTo(0);
}
@Test
public void queryParams() throws Exception {
MultiValueMap<String, String> params = createHttpRequest("/path?a=A&b=B").getQueryParams();
assertEquals(2, params.size());
assertEquals(Collections.singletonList("A"), params.get("a"));
assertEquals(Collections.singletonList("B"), params.get("b"));
assertThat(params.size()).isEqualTo(2);
assertThat(params.get("a")).isEqualTo(Collections.singletonList("A"));
assertThat(params.get("b")).isEqualTo(Collections.singletonList("B"));
}
@Test
public void queryParamsWithMultipleValues() throws Exception {
MultiValueMap<String, String> params = createHttpRequest("/path?a=1&a=2").getQueryParams();
assertEquals(1, params.size());
assertEquals(Arrays.asList("1", "2"), params.get("a"));
assertThat(params.size()).isEqualTo(1);
assertThat(params.get("a")).isEqualTo(Arrays.asList("1", "2"));
}
@Test // SPR-15140
public void queryParamsWithEncodedValue() throws Exception {
MultiValueMap<String, String> params = createHttpRequest("/path?a=%20%2B+%C3%A0").getQueryParams();
assertEquals(1, params.size());
assertEquals(Collections.singletonList(" + \u00e0"), params.get("a"));
assertThat(params.size()).isEqualTo(1);
assertThat(params.get("a")).isEqualTo(Collections.singletonList(" + \u00e0"));
}
@Test
public void queryParamsWithEmptyValue() throws Exception {
MultiValueMap<String, String> params = createHttpRequest("/path?a=").getQueryParams();
assertEquals(1, params.size());
assertEquals(Collections.singletonList(""), params.get("a"));
assertThat(params.size()).isEqualTo(1);
assertThat(params.get("a")).isEqualTo(Collections.singletonList(""));
}
@Test
public void queryParamsWithNoValue() throws Exception {
MultiValueMap<String, String> params = createHttpRequest("/path?a").getQueryParams();
assertEquals(1, params.size());
assertEquals(Collections.singletonList(null), params.get("a"));
assertThat(params.size()).isEqualTo(1);
assertThat(params.get("a")).isEqualTo(Collections.singletonList(null));
}
@Test
@@ -93,22 +92,22 @@ public class ServerHttpRequestTests {
SslInfo sslInfo = mock(SslInfo.class);
ServerHttpRequest request = createHttpRequest("/").mutate().sslInfo(sslInfo).build();
assertSame(sslInfo, request.getSslInfo());
assertThat(request.getSslInfo()).isSameAs(sslInfo);
request = createHttpRequest("/").mutate().method(HttpMethod.DELETE).build();
assertEquals(HttpMethod.DELETE, request.getMethod());
assertThat(request.getMethod()).isEqualTo(HttpMethod.DELETE);
String baseUri = "https://aaa.org:8080/a";
request = createHttpRequest(baseUri).mutate().uri(URI.create("https://bbb.org:9090/b")).build();
assertEquals("https://bbb.org:9090/b", request.getURI().toString());
assertThat(request.getURI().toString()).isEqualTo("https://bbb.org:9090/b");
request = createHttpRequest(baseUri).mutate().path("/b/c/d").build();
assertEquals("https://aaa.org:8080/b/c/d", request.getURI().toString());
assertThat(request.getURI().toString()).isEqualTo("https://aaa.org:8080/b/c/d");
request = createHttpRequest(baseUri).mutate().path("/app/b/c/d").contextPath("/app").build();
assertEquals("https://aaa.org:8080/app/b/c/d", request.getURI().toString());
assertEquals("/app", request.getPath().contextPath().value());
assertThat(request.getURI().toString()).isEqualTo("https://aaa.org:8080/app/b/c/d");
assertThat(request.getPath().contextPath().value()).isEqualTo("/app");
}
@Test
@@ -122,8 +121,8 @@ public class ServerHttpRequestTests {
ServerHttpRequest request = createHttpRequest("/path?name=%E6%89%8E%E6%A0%B9");
request = request.mutate().path("/mutatedPath").build();
assertEquals("/mutatedPath", request.getURI().getRawPath());
assertEquals("name=%E6%89%8E%E6%A0%B9", request.getURI().getRawQuery());
assertThat(request.getURI().getRawPath()).isEqualTo("/mutatedPath");
assertThat(request.getURI().getRawQuery()).isEqualTo("name=%E6%89%8E%E6%A0%B9");
}
private ServerHttpRequest createHttpRequest(String uriString) throws Exception {

79
spring-web/src/test/java/org/springframework/http/server/reactive/ServerHttpResponseTests.java
View File

@@ -32,10 +32,7 @@ import org.springframework.core.io.buffer.DefaultDataBufferFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseCookie;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Rossen Stoyanchev
@@ -48,14 +45,14 @@ public class ServerHttpResponseTests {
TestServerHttpResponse response = new TestServerHttpResponse();
response.writeWith(Flux.just(wrap("a"), wrap("b"), wrap("c"))).block();
assertTrue(response.statusCodeWritten);
assertTrue(response.headersWritten);
assertTrue(response.cookiesWritten);
assertThat(response.statusCodeWritten).isTrue();
assertThat(response.headersWritten).isTrue();
assertThat(response.cookiesWritten).isTrue();
assertEquals(3, response.body.size());
assertEquals("a", new String(response.body.get(0).asByteBuffer().array(), StandardCharsets.UTF_8));
assertEquals("b", new String(response.body.get(1).asByteBuffer().array(), StandardCharsets.UTF_8));
assertEquals("c", new String(response.body.get(2).asByteBuffer().array(), StandardCharsets.UTF_8));
assertThat(response.body.size()).isEqualTo(3);
assertThat(new String(response.body.get(0).asByteBuffer().array(), StandardCharsets.UTF_8)).isEqualTo("a");
assertThat(new String(response.body.get(1).asByteBuffer().array(), StandardCharsets.UTF_8)).isEqualTo("b");
assertThat(new String(response.body.get(2).asByteBuffer().array(), StandardCharsets.UTF_8)).isEqualTo("c");
}
@Test // SPR-14952
@@ -64,12 +61,12 @@ public class ServerHttpResponseTests {
Flux<Flux<DefaultDataBuffer>> flux = Flux.just(Flux.just(wrap("foo")));
response.writeAndFlushWith(flux).block();
assertTrue(response.statusCodeWritten);
assertTrue(response.headersWritten);
assertTrue(response.cookiesWritten);
assertThat(response.statusCodeWritten).isTrue();
assertThat(response.headersWritten).isTrue();
assertThat(response.cookiesWritten).isTrue();
assertEquals(1, response.body.size());
assertEquals("foo", new String(response.body.get(0).asByteBuffer().array(), StandardCharsets.UTF_8));
assertThat(response.body.size()).isEqualTo(1);
assertThat(new String(response.body.get(0).asByteBuffer().array(), StandardCharsets.UTF_8)).isEqualTo("foo");
}
@Test
@@ -79,11 +76,11 @@ public class ServerHttpResponseTests {
IllegalStateException error = new IllegalStateException("boo");
response.writeWith(Flux.error(error)).onErrorResume(ex -> Mono.empty()).block();
assertFalse(response.statusCodeWritten);
assertFalse(response.headersWritten);
assertFalse(response.cookiesWritten);
assertFalse(response.getHeaders().containsKey(HttpHeaders.CONTENT_LENGTH));
assertTrue(response.body.isEmpty());
assertThat(response.statusCodeWritten).isFalse();
assertThat(response.headersWritten).isFalse();
assertThat(response.cookiesWritten).isFalse();
assertThat(response.getHeaders().containsKey(HttpHeaders.CONTENT_LENGTH)).isFalse();
assertThat(response.body.isEmpty()).isTrue();
}
@Test
@@ -91,10 +88,10 @@ public class ServerHttpResponseTests {
TestServerHttpResponse response = new TestServerHttpResponse();
response.setComplete().block();
assertTrue(response.statusCodeWritten);
assertTrue(response.headersWritten);
assertTrue(response.cookiesWritten);
assertTrue(response.body.isEmpty());
assertThat(response.statusCodeWritten).isTrue();
assertThat(response.headersWritten).isTrue();
assertThat(response.cookiesWritten).isTrue();
assertThat(response.body.isEmpty()).isTrue();
}
@Test
@@ -104,15 +101,15 @@ public class ServerHttpResponseTests {
response.beforeCommit(() -> Mono.fromRunnable(() -> response.getCookies().add(cookie.getName(), cookie)));
response.writeWith(Flux.just(wrap("a"), wrap("b"), wrap("c"))).block();
assertTrue(response.statusCodeWritten);
assertTrue(response.headersWritten);
assertTrue(response.cookiesWritten);
assertSame(cookie, response.getCookies().getFirst("ID"));
assertThat(response.statusCodeWritten).isTrue();
assertThat(response.headersWritten).isTrue();
assertThat(response.cookiesWritten).isTrue();
assertThat(response.getCookies().getFirst("ID")).isSameAs(cookie);
assertEquals(3, response.body.size());
assertEquals("a", new String(response.body.get(0).asByteBuffer().array(), StandardCharsets.UTF_8));
assertEquals("b", new String(response.body.get(1).asByteBuffer().array(), StandardCharsets.UTF_8));
assertEquals("c", new String(response.body.get(2).asByteBuffer().array(), StandardCharsets.UTF_8));
assertThat(response.body.size()).isEqualTo(3);
assertThat(new String(response.body.get(0).asByteBuffer().array(), StandardCharsets.UTF_8)).isEqualTo("a");
assertThat(new String(response.body.get(1).asByteBuffer().array(), StandardCharsets.UTF_8)).isEqualTo("b");
assertThat(new String(response.body.get(2).asByteBuffer().array(), StandardCharsets.UTF_8)).isEqualTo("c");
}
@Test
@@ -125,11 +122,11 @@ public class ServerHttpResponseTests {
});
response.setComplete().block();
assertTrue(response.statusCodeWritten);
assertTrue(response.headersWritten);
assertTrue(response.cookiesWritten);
assertTrue(response.body.isEmpty());
assertSame(cookie, response.getCookies().getFirst("ID"));
assertThat(response.statusCodeWritten).isTrue();
assertThat(response.headersWritten).isTrue();
assertThat(response.cookiesWritten).isTrue();
assertThat(response.body.isEmpty()).isTrue();
assertThat(response.getCookies().getFirst("ID")).isSameAs(cookie);
}
@@ -160,19 +157,19 @@ public class ServerHttpResponseTests {
@Override
public void applyStatusCode() {
assertFalse(this.statusCodeWritten);
assertThat(this.statusCodeWritten).isFalse();
this.statusCodeWritten = true;
}
@Override
protected void applyHeaders() {
assertFalse(this.headersWritten);
assertThat(this.headersWritten).isFalse();
this.headersWritten = true;
}
@Override
protected void applyCookies() {
assertFalse(this.cookiesWritten);
assertThat(this.cookiesWritten).isFalse();
this.cookiesWritten = true;
}

18
spring-web/src/test/java/org/springframework/http/server/reactive/ServerHttpsRequestIntegrationTests.java
View File

@@ -39,9 +39,7 @@ import org.springframework.http.server.reactive.bootstrap.HttpServer;
import org.springframework.http.server.reactive.bootstrap.ReactorHttpsServer;
import org.springframework.web.client.RestTemplate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.assertj.core.api.Assertions.assertThat;
/**
* HTTPS-specific integration test for {@link ServerHttpRequest}.
@@ -95,7 +93,7 @@ public class ServerHttpsRequestIntegrationTests {
URI url = new URI("https://localhost:" + port + "/foo?param=bar");
RequestEntity<Void> request = RequestEntity.post(url).build();
ResponseEntity<Void> response = this.restTemplate.exchange(request, Void.class);
assertEquals(HttpStatus.OK, response.getStatusCode());
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
}
public static class CheckRequestHandler implements HttpHandler {
@@ -103,12 +101,12 @@ public class ServerHttpsRequestIntegrationTests {
@Override
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
URI uri = request.getURI();
assertEquals("https", uri.getScheme());
assertNotNull(uri.getHost());
assertNotEquals(-1, uri.getPort());
assertNotNull(request.getRemoteAddress());
assertEquals("/foo", uri.getPath());
assertEquals("param=bar", uri.getQuery());
assertThat(uri.getScheme()).isEqualTo("https");
assertThat(uri.getHost()).isNotNull();
assertThat(uri.getPort()).isNotEqualTo((long) -1);
assertThat(request.getRemoteAddress()).isNotNull();
assertThat(uri.getPath()).isEqualTo("/foo");
assertThat(uri.getQuery()).isEqualTo("param=bar");
return Mono.empty();
}
}

4
spring-web/src/test/java/org/springframework/http/server/reactive/WriteOnlyHandlerIntegrationTests.java
View File

@@ -29,7 +29,7 @@ import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import static org.junit.Assert.assertArrayEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Violeta Georgieva
@@ -59,7 +59,7 @@ public class WriteOnlyHandlerIntegrationTests extends AbstractHttpHandlerIntegra
"".getBytes(StandardCharsets.UTF_8));
ResponseEntity<byte[]> response = restTemplate.exchange(request, byte[].class);
assertArrayEquals(body, response.getBody());
assertThat(response.getBody()).isEqualTo(body);
}
private byte[] randomBytes() {

11
spring-web/src/test/java/org/springframework/http/server/reactive/ZeroCopyIntegrationTests.java
View File

@@ -32,8 +32,7 @@ import org.springframework.http.server.reactive.bootstrap.ReactorHttpServer;
import org.springframework.http.server.reactive.bootstrap.UndertowHttpServer;
import org.springframework.web.client.RestTemplate;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assume.assumeTrue;
/**
@@ -61,10 +60,10 @@ public class ZeroCopyIntegrationTests extends AbstractHttpHandlerIntegrationTest
Resource logo = new ClassPathResource("spring.png", ZeroCopyIntegrationTests.class);
assertTrue(response.hasBody());
assertEquals(logo.contentLength(), response.getHeaders().getContentLength());
assertEquals(logo.contentLength(), response.getBody().length);
assertEquals(MediaType.IMAGE_PNG, response.getHeaders().getContentType());
assertThat(response.hasBody()).isTrue();
assertThat(response.getHeaders().getContentLength()).isEqualTo(logo.contentLength());
assertThat(response.getBody().length).isEqualTo(logo.contentLength());
assertThat(response.getHeaders().getContentType()).isEqualTo(MediaType.IMAGE_PNG);
}

28
spring-web/src/test/java/org/springframework/remoting/caucho/CauchoRemotingTests.java
View File

@@ -29,10 +29,9 @@ import org.springframework.tests.sample.beans.ITestBean;
import org.springframework.tests.sample.beans.TestBean;
import org.springframework.util.SocketUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Juergen Hoeller
@@ -55,8 +54,9 @@ public class CauchoRemotingTests {
factory.setServiceUrl("http://localhosta/testbean");
factory.afterPropertiesSet();
assertTrue("Correct singleton value", factory.isSingleton());
assertTrue(factory.getObject() instanceof ITestBean);
assertThat(factory.isSingleton()).as("Correct singleton value").isTrue();
boolean condition = factory.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
ITestBean bean = (ITestBean) factory.getObject();
assertThatExceptionOfType(RemoteAccessException.class).isThrownBy(() ->
@@ -73,8 +73,9 @@ public class CauchoRemotingTests {
factory.setOverloadEnabled(true);
factory.afterPropertiesSet();
assertTrue("Correct singleton value", factory.isSingleton());
assertTrue(factory.getObject() instanceof ITestBean);
assertThat(factory.isSingleton()).as("Correct singleton value").isTrue();
boolean condition = factory.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
ITestBean bean = (ITestBean) factory.getObject();
assertThatExceptionOfType(RemoteAccessException.class).isThrownBy(() ->
@@ -92,13 +93,14 @@ public class CauchoRemotingTests {
factory.setPassword("bean");
factory.setOverloadEnabled(true);
factory.afterPropertiesSet();
assertTrue("Correct singleton value", factory.isSingleton());
assertTrue(factory.getObject() instanceof ITestBean);
assertThat(factory.isSingleton()).as("Correct singleton value").isTrue();
boolean condition = factory.getObject() instanceof ITestBean;
assertThat(condition).isTrue();
ITestBean bean = (ITestBean) factory.getObject();
assertEquals("test", proxyFactory.user);
assertEquals("bean", proxyFactory.password);
assertTrue(proxyFactory.overloadEnabled);
assertThat(proxyFactory.user).isEqualTo("test");
assertThat(proxyFactory.password).isEqualTo("bean");
assertThat(proxyFactory.overloadEnabled).isTrue();
assertThatExceptionOfType(RemoteAccessException.class).isThrownBy(() ->
bean.setName("test"));
@@ -126,9 +128,9 @@ public class CauchoRemotingTests {
//client.setHessian2(true);
client.prepare();
ITestBean proxy = ProxyFactory.getProxy(ITestBean.class, client);
assertEquals("tb", proxy.getName());
assertThat(proxy.getName()).isEqualTo("tb");
proxy.setName("test");
assertEquals("test", proxy.getName());
assertThat(proxy.getName()).isEqualTo("test");
}
finally {
server.stop(Integer.MAX_VALUE);

39
spring-web/src/test/java/org/springframework/remoting/httpinvoker/HttpComponentsHttpInvokerRequestExecutorTests.java
View File

@@ -26,10 +26,7 @@ import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.withSettings;
@@ -46,7 +43,7 @@ public class HttpComponentsHttpInvokerRequestExecutorTests {
HttpInvokerClientConfiguration config = mockHttpInvokerClientConfiguration("https://fake-service");
HttpPost httpPost = executor.createHttpPost(config);
assertEquals(5000, httpPost.getConfig().getConnectTimeout());
assertThat(httpPost.getConfig().getConnectTimeout()).isEqualTo(5000);
}
@Test
@@ -56,7 +53,7 @@ public class HttpComponentsHttpInvokerRequestExecutorTests {
HttpInvokerClientConfiguration config = mockHttpInvokerClientConfiguration("https://fake-service");
HttpPost httpPost = executor.createHttpPost(config);
assertEquals(7000, httpPost.getConfig().getConnectionRequestTimeout());
assertThat(httpPost.getConfig().getConnectionRequestTimeout()).isEqualTo(7000);
}
@Test
@@ -66,7 +63,7 @@ public class HttpComponentsHttpInvokerRequestExecutorTests {
HttpInvokerClientConfiguration config = mockHttpInvokerClientConfiguration("https://fake-service");
HttpPost httpPost = executor.createHttpPost(config);
assertEquals(10000, httpPost.getConfig().getSocketTimeout());
assertThat(httpPost.getConfig().getSocketTimeout()).isEqualTo(10000);
}
@Test
@@ -81,14 +78,14 @@ public class HttpComponentsHttpInvokerRequestExecutorTests {
new HttpComponentsHttpInvokerRequestExecutor(client);
HttpInvokerClientConfiguration config = mockHttpInvokerClientConfiguration("https://fake-service");
HttpPost httpPost = executor.createHttpPost(config);
assertSame("Default client configuration is expected", defaultConfig, httpPost.getConfig());
assertThat(httpPost.getConfig()).as("Default client configuration is expected").isSameAs(defaultConfig);
executor.setConnectionRequestTimeout(4567);
HttpPost httpPost2 = executor.createHttpPost(config);
assertNotNull(httpPost2.getConfig());
assertEquals(4567, httpPost2.getConfig().getConnectionRequestTimeout());
assertThat(httpPost2.getConfig()).isNotNull();
assertThat(httpPost2.getConfig().getConnectionRequestTimeout()).isEqualTo(4567);
// Default connection timeout merged
assertEquals(1234, httpPost2.getConfig().getConnectTimeout());
assertThat(httpPost2.getConfig().getConnectTimeout()).isEqualTo(1234);
}
@Test
@@ -107,9 +104,9 @@ public class HttpComponentsHttpInvokerRequestExecutorTests {
HttpInvokerClientConfiguration config = mockHttpInvokerClientConfiguration("https://fake-service");
HttpPost httpPost = executor.createHttpPost(config);
RequestConfig requestConfig = httpPost.getConfig();
assertEquals(5000, requestConfig.getConnectTimeout());
assertEquals(6789, requestConfig.getConnectionRequestTimeout());
assertEquals(-1, requestConfig.getSocketTimeout());
assertThat(requestConfig.getConnectTimeout()).isEqualTo(5000);
assertThat(requestConfig.getConnectionRequestTimeout()).isEqualTo(6789);
assertThat(requestConfig.getSocketTimeout()).isEqualTo(-1);
}
@Test
@@ -132,9 +129,9 @@ public class HttpComponentsHttpInvokerRequestExecutorTests {
HttpInvokerClientConfiguration config = mockHttpInvokerClientConfiguration("https://fake-service");
HttpPost httpPost = executor.createHttpPost(config);
RequestConfig requestConfig = httpPost.getConfig();
assertEquals(-1, requestConfig.getConnectTimeout());
assertEquals(-1, requestConfig.getConnectionRequestTimeout());
assertEquals(5000, requestConfig.getSocketTimeout());
assertThat(requestConfig.getConnectTimeout()).isEqualTo(-1);
assertThat(requestConfig.getConnectionRequestTimeout()).isEqualTo(-1);
assertThat(requestConfig.getSocketTimeout()).isEqualTo(5000);
// Update the Http client so that it returns an updated config
RequestConfig updatedDefaultConfig = RequestConfig.custom()
@@ -143,9 +140,9 @@ public class HttpComponentsHttpInvokerRequestExecutorTests {
executor.setReadTimeout(7000);
HttpPost httpPost2 = executor.createHttpPost(config);
RequestConfig requestConfig2 = httpPost2.getConfig();
assertEquals(1234, requestConfig2.getConnectTimeout());
assertEquals(-1, requestConfig2.getConnectionRequestTimeout());
assertEquals(7000, requestConfig2.getSocketTimeout());
assertThat(requestConfig2.getConnectTimeout()).isEqualTo(1234);
assertThat(requestConfig2.getConnectionRequestTimeout()).isEqualTo(-1);
assertThat(requestConfig2.getSocketTimeout()).isEqualTo(7000);
}
@Test
@@ -160,7 +157,7 @@ public class HttpComponentsHttpInvokerRequestExecutorTests {
HttpInvokerClientConfiguration config = mockHttpInvokerClientConfiguration("https://fake-service");
HttpPost httpPost = executor.createHttpPost(config);
assertNull("custom request config should not be set", httpPost.getConfig());
assertThat(httpPost.getConfig()).as("custom request config should not be set").isNull();
}
private HttpInvokerClientConfiguration mockHttpInvokerClientConfiguration(String serviceUrl) {

8
spring-web/src/test/java/org/springframework/remoting/httpinvoker/HttpInvokerFactoryBeanIntegrationTests.java
View File

@@ -33,7 +33,7 @@ import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor;
import org.springframework.stereotype.Component;
import static org.junit.Assert.assertSame;
import static org.assertj.core.api.Assertions.assertThat;
/**
* @author Stephane Nicoll
@@ -45,7 +45,7 @@ public class HttpInvokerFactoryBeanIntegrationTests {
public void testLoadedConfigClass() {
ApplicationContext context = new AnnotationConfigApplicationContext(InvokerAutowiringConfig.class);
MyBean myBean = context.getBean("myBean", MyBean.class);
assertSame(context.getBean("myService"), myBean.myService);
assertThat(myBean.myService).isSameAs(context.getBean("myService"));
myBean.myService.handle();
myBean.myService.handleAsync();
}
@@ -57,7 +57,7 @@ public class HttpInvokerFactoryBeanIntegrationTests {
context.registerBeanDefinition("config", new RootBeanDefinition(InvokerAutowiringConfig.class.getName()));
context.refresh();
MyBean myBean = context.getBean("myBean", MyBean.class);
assertSame(context.getBean("myService"), myBean.myService);
assertThat(myBean.myService).isSameAs(context.getBean("myService"));
myBean.myService.handle();
myBean.myService.handleAsync();
}
@@ -69,7 +69,7 @@ public class HttpInvokerFactoryBeanIntegrationTests {
context.register(ConfigWithPlainFactoryBean.class);
context.refresh();
MyBean myBean = context.getBean("myBean", MyBean.class);
assertSame(context.getBean("myService"), myBean.myService);
assertThat(myBean.myService).isSameAs(context.getBean("myService"));
myBean.myService.handle();
myBean.myService.handleAsync();
}

90
spring-web/src/test/java/org/springframework/remoting/httpinvoker/HttpInvokerTests.java
View File

@@ -46,12 +46,9 @@ import org.springframework.remoting.support.RemoteInvocationResult;
import org.springframework.tests.sample.beans.ITestBean;
import org.springframework.tests.sample.beans.TestBean;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
/**
* @author Juergen Hoeller
@@ -85,7 +82,7 @@ public class HttpInvokerTests {
@Override
protected RemoteInvocationResult doExecuteRequest(
HttpInvokerClientConfiguration config, ByteArrayOutputStream baos) throws Exception {
assertEquals("https://myurl", config.getServiceUrl());
assertThat(config.getServiceUrl()).isEqualTo("https://myurl");
MockHttpServletRequest request = new MockHttpServletRequest();
MockHttpServletResponse response = new MockHttpServletResponse();
request.setContent(baos.toByteArray());
@@ -100,24 +97,24 @@ public class HttpInvokerTests {
pfb.afterPropertiesSet();
ITestBean proxy = (ITestBean) pfb.getObject();
assertEquals("myname", proxy.getName());
assertEquals(99, proxy.getAge());
assertThat(proxy.getName()).isEqualTo("myname");
assertThat(proxy.getAge()).isEqualTo(99);
proxy.setAge(50);
assertEquals(50, proxy.getAge());
assertThat(proxy.getAge()).isEqualTo(50);
proxy.setStringArray(new String[] {"str1", "str2"});
assertTrue(Arrays.equals(new String[] {"str1", "str2"}, proxy.getStringArray()));
assertThat(Arrays.equals(new String[] {"str1", "str2"}, proxy.getStringArray())).isTrue();
proxy.setSomeIntegerArray(new Integer[] {1, 2, 3});
assertTrue(Arrays.equals(new Integer[] {1, 2, 3}, proxy.getSomeIntegerArray()));
assertThat(Arrays.equals(new Integer[] {1, 2, 3}, proxy.getSomeIntegerArray())).isTrue();
proxy.setNestedIntegerArray(new Integer[][] {{1, 2, 3}, {4, 5, 6}});
Integer[][] integerArray = proxy.getNestedIntegerArray();
assertTrue(Arrays.equals(new Integer[] {1, 2, 3}, integerArray[0]));
assertTrue(Arrays.equals(new Integer[] {4, 5, 6}, integerArray[1]));
assertThat(Arrays.equals(new Integer[] {1, 2, 3}, integerArray[0])).isTrue();
assertThat(Arrays.equals(new Integer[] {4, 5, 6}, integerArray[1])).isTrue();
proxy.setSomeIntArray(new int[] {1, 2, 3});
assertTrue(Arrays.equals(new int[] {1, 2, 3}, proxy.getSomeIntArray()));
assertThat(Arrays.equals(new int[] {1, 2, 3}, proxy.getSomeIntArray())).isTrue();
proxy.setNestedIntArray(new int[][] {{1, 2, 3}, {4, 5, 6}});
int[][] intArray = proxy.getNestedIntArray();
assertTrue(Arrays.equals(new int[] {1, 2, 3}, intArray[0]));
assertTrue(Arrays.equals(new int[] {4, 5, 6}, intArray[1]));
assertThat(Arrays.equals(new int[] {1, 2, 3}, intArray[0])).isTrue();
assertThat(Arrays.equals(new int[] {4, 5, 6}, intArray[1])).isTrue();
assertThatIllegalStateException().isThrownBy(() ->
proxy.exceptional(new IllegalStateException()));
@@ -191,7 +188,7 @@ public class HttpInvokerTests {
protected RemoteInvocationResult doExecuteRequest(
HttpInvokerClientConfiguration config, ByteArrayOutputStream baos)
throws IOException, ClassNotFoundException {
assertEquals("https://myurl", config.getServiceUrl());
assertThat(config.getServiceUrl()).isEqualTo("https://myurl");
MockHttpServletRequest request = new MockHttpServletRequest();
request.addHeader("Compression", "gzip");
MockHttpServletResponse response = new MockHttpServletResponse();
@@ -217,10 +214,10 @@ public class HttpInvokerTests {
pfb.afterPropertiesSet();
ITestBean proxy = (ITestBean) pfb.getObject();
assertEquals("myname", proxy.getName());
assertEquals(99, proxy.getAge());
assertThat(proxy.getName()).isEqualTo("myname");
assertThat(proxy.getAge()).isEqualTo(99);
proxy.setAge(50);
assertEquals(50, proxy.getAge());
assertThat(proxy.getAge()).isEqualTo(50);
assertThatIllegalStateException().isThrownBy(() ->
proxy.exceptional(new IllegalStateException()));
@@ -261,7 +258,7 @@ public class HttpInvokerTests {
@Override
protected RemoteInvocationResult doExecuteRequest(
HttpInvokerClientConfiguration config, ByteArrayOutputStream baos) throws Exception {
assertEquals("https://myurl", config.getServiceUrl());
assertThat(config.getServiceUrl()).isEqualTo("https://myurl");
MockHttpServletRequest request = new MockHttpServletRequest();
MockHttpServletResponse response = new MockHttpServletResponse();
request.setContent(baos.toByteArray());
@@ -287,10 +284,10 @@ public class HttpInvokerTests {
pfb.afterPropertiesSet();
ITestBean proxy = (ITestBean) pfb.getObject();
assertEquals("myname", proxy.getName());
assertEquals(99, proxy.getAge());
assertThat(proxy.getName()).isEqualTo("myname");
assertThat(proxy.getAge()).isEqualTo(99);
proxy.setAge(50);
assertEquals(50, proxy.getAge());
assertThat(proxy.getAge()).isEqualTo(50);
assertThatIllegalStateException().isThrownBy(() ->
proxy.exceptional(new IllegalStateException()));
@@ -309,10 +306,10 @@ public class HttpInvokerTests {
@Override
public Object invoke(RemoteInvocation invocation, Object targetObject)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
assertNotNull(invocation.getAttributes());
assertEquals(1, invocation.getAttributes().size());
assertEquals("myValue", invocation.getAttributes().get("myKey"));
assertEquals("myValue", invocation.getAttribute("myKey"));
assertThat(invocation.getAttributes()).isNotNull();
assertThat(invocation.getAttributes().size()).isEqualTo(1);
assertThat(invocation.getAttributes().get("myKey")).isEqualTo("myValue");
assertThat(invocation.getAttribute("myKey")).isEqualTo("myValue");
return super.invoke(invocation, targetObject);
}
});
@@ -328,10 +325,10 @@ public class HttpInvokerTests {
invocation.addAttribute("myKey", "myValue");
assertThatIllegalStateException().isThrownBy(() ->
invocation.addAttribute("myKey", "myValue"));
assertNotNull(invocation.getAttributes());
assertEquals(1, invocation.getAttributes().size());
assertEquals("myValue", invocation.getAttributes().get("myKey"));
assertEquals("myValue", invocation.getAttribute("myKey"));
assertThat(invocation.getAttributes()).isNotNull();
assertThat(invocation.getAttributes().size()).isEqualTo(1);
assertThat(invocation.getAttributes().get("myKey")).isEqualTo("myValue");
assertThat(invocation.getAttribute("myKey")).isEqualTo("myValue");
return invocation;
}
});
@@ -340,7 +337,7 @@ public class HttpInvokerTests {
@Override
protected RemoteInvocationResult doExecuteRequest(
HttpInvokerClientConfiguration config, ByteArrayOutputStream baos) throws Exception {
assertEquals("https://myurl", config.getServiceUrl());
assertThat(config.getServiceUrl()).isEqualTo("https://myurl");
MockHttpServletRequest request = new MockHttpServletRequest();
MockHttpServletResponse response = new MockHttpServletResponse();
request.setContent(baos.toByteArray());
@@ -352,8 +349,8 @@ public class HttpInvokerTests {
pfb.afterPropertiesSet();
ITestBean proxy = (ITestBean) pfb.getObject();
assertEquals("myname", proxy.getName());
assertEquals(99, proxy.getAge());
assertThat(proxy.getName()).isEqualTo("myname");
assertThat(proxy.getAge()).isEqualTo(99);
}
@Test
@@ -367,9 +364,10 @@ public class HttpInvokerTests {
@Override
public Object invoke(RemoteInvocation invocation, Object targetObject)
throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
assertTrue(invocation instanceof TestRemoteInvocation);
assertNull(invocation.getAttributes());
assertNull(invocation.getAttribute("myKey"));
boolean condition = invocation instanceof TestRemoteInvocation;
assertThat(condition).isTrue();
assertThat(invocation.getAttributes()).isNull();
assertThat(invocation.getAttribute("myKey")).isNull();
return super.invoke(invocation, targetObject);
}
});
@@ -382,8 +380,8 @@ public class HttpInvokerTests {
@Override
public RemoteInvocation createRemoteInvocation(MethodInvocation methodInvocation) {
RemoteInvocation invocation = new TestRemoteInvocation(methodInvocation);
assertNull(invocation.getAttributes());
assertNull(invocation.getAttribute("myKey"));
assertThat(invocation.getAttributes()).isNull();
assertThat(invocation.getAttribute("myKey")).isNull();
return invocation;
}
});
@@ -392,7 +390,7 @@ public class HttpInvokerTests {
@Override
protected RemoteInvocationResult doExecuteRequest(
HttpInvokerClientConfiguration config, ByteArrayOutputStream baos) throws Exception {
assertEquals("https://myurl", config.getServiceUrl());
assertThat(config.getServiceUrl()).isEqualTo("https://myurl");
MockHttpServletRequest request = new MockHttpServletRequest();
MockHttpServletResponse response = new MockHttpServletResponse();
request.setContent(baos.toByteArray());
@@ -404,8 +402,8 @@ public class HttpInvokerTests {
pfb.afterPropertiesSet();
ITestBean proxy = (ITestBean) pfb.getObject();
assertEquals("myname", proxy.getName());
assertEquals(99, proxy.getAge());
assertThat(proxy.getName()).isEqualTo("myname");
assertThat(proxy.getAge()).isEqualTo(99);
}
@Test
@@ -427,10 +425,10 @@ public class HttpInvokerTests {
ITestBean proxy = (ITestBean) pfb.getObject();
// shouldn't go through to remote service
assertTrue(proxy.toString().contains("HTTP invoker"));
assertTrue(proxy.toString().contains(serviceUrl));
assertEquals(proxy.hashCode(), proxy.hashCode());
assertTrue(proxy.equals(proxy));
assertThat(proxy.toString().contains("HTTP invoker")).isTrue();
assertThat(proxy.toString().contains(serviceUrl)).isTrue();
assertThat(proxy.hashCode()).isEqualTo(proxy.hashCode());
assertThat(proxy.equals(proxy)).isTrue();
// should go through

10
spring-web/src/test/java/org/springframework/remoting/jaxws/JaxWsSupportTests.java
View File

@@ -36,9 +36,8 @@ import org.springframework.context.annotation.AnnotationConfigUtils;
import org.springframework.context.support.GenericApplicationContext;
import org.springframework.remoting.RemoteAccessException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Juergen Hoeller
@@ -96,11 +95,12 @@ public class JaxWsSupportTests {
ac.refresh();
OrderService orderService = ac.getBean("client", OrderService.class);
assertTrue(orderService instanceof BindingProvider);
boolean condition = orderService instanceof BindingProvider;
assertThat(condition).isTrue();
((BindingProvider) orderService).getRequestContext();
String order = orderService.getOrder(1000);
assertEquals("order 1000", order);
assertThat(order).isEqualTo("order 1000");
assertThatExceptionOfType(Exception.class).isThrownBy(() ->
orderService.getOrder(0))
.matches(ex -> ex instanceof OrderNotFoundException ||
@@ -109,7 +109,7 @@ public class JaxWsSupportTests {
ServiceAccessor serviceAccessor = ac.getBean("accessor", ServiceAccessor.class);
order = serviceAccessor.orderService.getOrder(1000);
assertEquals("order 1000", order);
assertThat(order).isEqualTo("order 1000");
assertThatExceptionOfType(Exception.class).isThrownBy(() ->
serviceAccessor.orderService.getOrder(0))
.matches(ex -> ex instanceof OrderNotFoundException ||

46
spring-web/src/test/java/org/springframework/web/accept/ContentNegotiationManagerFactoryBeanTests.java
View File

@@ -33,8 +33,8 @@ import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
/**
* Test fixture for {@link ContentNegotiationManagerFactoryBean} tests.
@@ -70,25 +70,21 @@ public class ContentNegotiationManagerFactoryBeanTests {
this.servletRequest.setRequestURI("/flower.gif");
assertEquals("Should be able to resolve file extensions by default",
Collections.singletonList(MediaType.IMAGE_GIF), manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).as("Should be able to resolve file extensions by default").isEqualTo(Collections.singletonList(MediaType.IMAGE_GIF));
this.servletRequest.setRequestURI("/flower.foobarbaz");
assertEquals("Should ignore unknown extensions by default",
ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST, manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).as("Should ignore unknown extensions by default").isEqualTo(ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST);
this.servletRequest.setRequestURI("/flower");
this.servletRequest.setParameter("format", "gif");
assertEquals("Should not resolve request parameters by default",
ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST, manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).as("Should not resolve request parameters by default").isEqualTo(ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST);
this.servletRequest.setRequestURI("/flower");
this.servletRequest.addHeader("Accept", MediaType.IMAGE_GIF_VALUE);
assertEquals("Should resolve Accept header by default",
Collections.singletonList(MediaType.IMAGE_GIF), manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).as("Should resolve Accept header by default").isEqualTo(Collections.singletonList(MediaType.IMAGE_GIF));
}
@Test
@@ -101,12 +97,11 @@ public class ContentNegotiationManagerFactoryBeanTests {
this.factoryBean.afterPropertiesSet();
ContentNegotiationManager manager = this.factoryBean.getObject();
assertEquals(strategies, manager.getStrategies());
assertThat(manager.getStrategies()).isEqualTo(strategies);
this.servletRequest.setRequestURI("/flower");
this.servletRequest.addParameter("format", "bar");
assertEquals(Collections.singletonList(new MediaType("application", "bar")),
manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(Collections.singletonList(new MediaType("application", "bar")));
}
@@ -118,15 +113,13 @@ public class ContentNegotiationManagerFactoryBeanTests {
ContentNegotiationManager manager = this.factoryBean.getObject();
this.servletRequest.setRequestURI("/flower.foo");
assertEquals(Collections.singletonList(new MediaType("application", "foo")),
manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(Collections.singletonList(new MediaType("application", "foo")));
this.servletRequest.setRequestURI("/flower.bar");
assertEquals(Collections.singletonList(new MediaType("application", "bar")),
manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(Collections.singletonList(new MediaType("application", "bar")));
this.servletRequest.setRequestURI("/flower.gif");
assertEquals(Collections.singletonList(MediaType.IMAGE_GIF), manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(Collections.singletonList(MediaType.IMAGE_GIF));
}
@Test // SPR-10170
@@ -157,8 +150,7 @@ public class ContentNegotiationManagerFactoryBeanTests {
this.servletRequest.setRequestURI("/flower");
this.servletRequest.addParameter("format", "json");
assertEquals(Collections.singletonList(MediaType.APPLICATION_JSON),
manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(Collections.singletonList(MediaType.APPLICATION_JSON));
}
@Test // SPR-10170
@@ -183,7 +175,7 @@ public class ContentNegotiationManagerFactoryBeanTests {
this.servletRequest.setRequestURI("/flower");
this.servletRequest.addHeader("Accept", MediaType.IMAGE_GIF_VALUE);
assertEquals(ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST, manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST);
}
@Test
@@ -192,11 +184,11 @@ public class ContentNegotiationManagerFactoryBeanTests {
this.factoryBean.afterPropertiesSet();
ContentNegotiationManager manager = this.factoryBean.getObject();
assertEquals(MediaType.APPLICATION_JSON, manager.resolveMediaTypes(this.webRequest).get(0));
assertThat(manager.resolveMediaTypes(this.webRequest).get(0)).isEqualTo(MediaType.APPLICATION_JSON);
// SPR-10513
this.servletRequest.addHeader("Accept", MediaType.ALL_VALUE);
assertEquals(MediaType.APPLICATION_JSON, manager.resolveMediaTypes(this.webRequest).get(0));
assertThat(manager.resolveMediaTypes(this.webRequest).get(0)).isEqualTo(MediaType.APPLICATION_JSON);
}
@Test // SPR-15367
@@ -206,10 +198,10 @@ public class ContentNegotiationManagerFactoryBeanTests {
this.factoryBean.afterPropertiesSet();
ContentNegotiationManager manager = this.factoryBean.getObject();
assertEquals(mediaTypes, manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(mediaTypes);
this.servletRequest.addHeader("Accept", MediaType.ALL_VALUE);
assertEquals(mediaTypes, manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(mediaTypes);
}
@Test // SPR-12286
@@ -218,12 +210,10 @@ public class ContentNegotiationManagerFactoryBeanTests {
this.factoryBean.afterPropertiesSet();
ContentNegotiationManager manager = this.factoryBean.getObject();
assertEquals(Collections.singletonList(MediaType.APPLICATION_JSON),
manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(Collections.singletonList(MediaType.APPLICATION_JSON));
this.servletRequest.addHeader("Accept", MediaType.ALL_VALUE);
assertEquals(Collections.singletonList(MediaType.APPLICATION_JSON),
manager.resolveMediaTypes(this.webRequest));
assertThat(manager.resolveMediaTypes(this.webRequest)).isEqualTo(Collections.singletonList(MediaType.APPLICATION_JSON));
}

22
spring-web/src/test/java/org/springframework/web/accept/HeaderContentNegotiationStrategyTests.java
View File

@@ -26,8 +26,8 @@ import org.springframework.web.HttpMediaTypeNotAcceptableException;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.ServletWebRequest;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.junit.Assert.assertEquals;
/**
* Test fixture for HeaderContentNegotiationStrategy tests.
@@ -49,11 +49,11 @@ public class HeaderContentNegotiationStrategyTests {
this.servletRequest.addHeader("Accept", "text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c");
List<MediaType> mediaTypes = this.strategy.resolveMediaTypes(this.webRequest);
assertEquals(4, mediaTypes.size());
assertEquals("text/html", mediaTypes.get(0).toString());
assertEquals("text/x-c", mediaTypes.get(1).toString());
assertEquals("text/x-dvi;q=0.8", mediaTypes.get(2).toString());
assertEquals("text/plain;q=0.5", mediaTypes.get(3).toString());
assertThat(mediaTypes.size()).isEqualTo(4);
assertThat(mediaTypes.get(0).toString()).isEqualTo("text/html");
assertThat(mediaTypes.get(1).toString()).isEqualTo("text/x-c");
assertThat(mediaTypes.get(2).toString()).isEqualTo("text/x-dvi;q=0.8");
assertThat(mediaTypes.get(3).toString()).isEqualTo("text/plain;q=0.5");
}
@Test // SPR-14506
@@ -62,11 +62,11 @@ public class HeaderContentNegotiationStrategyTests {
this.servletRequest.addHeader("Accept", "text/x-dvi; q=0.8, text/x-c");
List<MediaType> mediaTypes = this.strategy.resolveMediaTypes(this.webRequest);
assertEquals(4, mediaTypes.size());
assertEquals("text/html", mediaTypes.get(0).toString());
assertEquals("text/x-c", mediaTypes.get(1).toString());
assertEquals("text/x-dvi;q=0.8", mediaTypes.get(2).toString());
assertEquals("text/plain;q=0.5", mediaTypes.get(3).toString());
assertThat(mediaTypes.size()).isEqualTo(4);
assertThat(mediaTypes.get(0).toString()).isEqualTo("text/html");
assertThat(mediaTypes.get(1).toString()).isEqualTo("text/x-c");
assertThat(mediaTypes.get(2).toString()).isEqualTo("text/x-dvi;q=0.8");
assertThat(mediaTypes.get(3).toString()).isEqualTo("text/plain;q=0.5");
}
@Test

14
spring-web/src/test/java/org/springframework/web/accept/MappingContentNegotiationStrategyTests.java
View File

@@ -25,7 +25,7 @@ import org.junit.Test;
import org.springframework.http.MediaType;
import org.springframework.web.context.request.NativeWebRequest;
import static org.junit.Assert.assertEquals;
import static org.assertj.core.api.Assertions.assertThat;
/**
* A test fixture with a test sub-class of AbstractMappingContentNegotiationStrategy.
@@ -42,8 +42,8 @@ public class MappingContentNegotiationStrategyTests {
List<MediaType> mediaTypes = strategy.resolveMediaTypes(null);
assertEquals(1, mediaTypes.size());
assertEquals("application/json", mediaTypes.get(0).toString());
assertThat(mediaTypes.size()).isEqualTo(1);
assertThat(mediaTypes.get(0).toString()).isEqualTo("application/json");
}
@Test
@@ -53,7 +53,7 @@ public class MappingContentNegotiationStrategyTests {
List<MediaType> mediaTypes = strategy.resolveMediaTypes(null);
assertEquals(ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST, mediaTypes);
assertThat(mediaTypes).isEqualTo(ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST);
}
@Test
@@ -63,7 +63,7 @@ public class MappingContentNegotiationStrategyTests {
List<MediaType> mediaTypes = strategy.resolveMediaTypes(null);
assertEquals(ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST, mediaTypes);
assertThat(mediaTypes).isEqualTo(ContentNegotiationStrategy.MEDIA_TYPE_ALL_LIST);
}
@Test
@@ -73,8 +73,8 @@ public class MappingContentNegotiationStrategyTests {
List<MediaType> mediaTypes = strategy.resolveMediaTypes(null);
assertEquals(1, mediaTypes.size());
assertEquals("application/xml", mediaTypes.get(0).toString());
assertThat(mediaTypes.size()).isEqualTo(1);
assertThat(mediaTypes.get(0).toString()).isEqualTo("application/xml");
}

11
spring-web/src/test/java/org/springframework/web/accept/MappingMediaTypeFileExtensionResolverTests.java
View File

@@ -23,8 +23,7 @@ import org.junit.Test;
import org.springframework.http.MediaType;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Test fixture for {@link MappingMediaTypeFileExtensionResolver}.
@@ -40,8 +39,8 @@ public class MappingMediaTypeFileExtensionResolverTests {
MappingMediaTypeFileExtensionResolver resolver = new MappingMediaTypeFileExtensionResolver(mapping);
List<String> extensions = resolver.resolveFileExtensions(MediaType.APPLICATION_JSON);
assertEquals(1, extensions.size());
assertEquals("json", extensions.get(0));
assertThat(extensions.size()).isEqualTo(1);
assertThat(extensions.get(0)).isEqualTo("json");
}
@Test
@@ -50,7 +49,7 @@ public class MappingMediaTypeFileExtensionResolverTests {
MappingMediaTypeFileExtensionResolver resolver = new MappingMediaTypeFileExtensionResolver(mapping);
List<String> extensions = resolver.resolveFileExtensions(MediaType.TEXT_HTML);
assertTrue(extensions.isEmpty());
assertThat(extensions.isEmpty()).isTrue();
}
/**
@@ -63,7 +62,7 @@ public class MappingMediaTypeFileExtensionResolverTests {
MappingMediaTypeFileExtensionResolver resolver = new MappingMediaTypeFileExtensionResolver(mapping);
MediaType mediaType = resolver.lookupMediaType("JSON");
assertEquals(MediaType.APPLICATION_JSON, mediaType);
assertThat(mediaType).isEqualTo(MediaType.APPLICATION_JSON);
}
}

Some files were not shown because too many files have changed in this diff Show More