GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Improve conditional requests support 

Prior to this commit, Spring MVC and Spring WebFlux would not support
conditional requests with `If-Match` preconditions. As underlined in the
RFC9110 Section 13.1, those are related to the `If-None-Match`
conditions, but this time only performing requests if the resource
matches the given ETag.

This feature, and in general the `"*"` request Etag, are generally
useful to prevent "lost updates" when performing a POST/PUT request: we
want to ensure that we're updating a version with a known version or
create a new resource only if it doesn't exist already.

This commit adds `If-Match` conditional requests support and ensures
that both `If-Match` and `If-None-Match` work well with `"*"` request
ETags.

We can't rely on `checkNotModified(null)`, as the compiler can't decide
between method variants accepting an ETag `String` or a Last Modified
`long`. Instead, developers should use empty ETags `""` to signal that
no resource is known on the server side.

Closes gh-24881
pull/28674/head
Brian Clozel 4 years ago
parent
a3d3667e64
commit
0783f0762d
7 changed files with 851 additions and 737 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 167
      spring-web/src/main/java/org/springframework/web/context/request/ServletWebRequest.java
  2. 169
      spring-web/src/main/java/org/springframework/web/server/adapter/DefaultServerWebExchange.java
  3. 410
      spring-web/src/test/java/org/springframework/web/context/request/ServletWebRequestHttpMethodsTests.java
  4. 1
      spring-web/src/test/java/org/springframework/web/filter/ShallowEtagHeaderFilterTests.java
  5. 12
      spring-web/src/testFixtures/java/org/springframework/web/testfixture/http/server/reactive/MockServerHttpRequest.java
  6. 10
      spring-webflux/src/main/java/org/springframework/web/reactive/function/server/ServerRequest.java
  7. 819
      spring-webflux/src/test/java/org/springframework/web/reactive/function/server/DefaultServerRequestTests.java

167
spring-web/src/main/java/org/springframework/web/context/request/ServletWebRequest.java
Unescape View File

@ -1,5 +1,5 @@ @@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 the original author or authors.
* Copyright 2002-2022 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -206,97 +206,80 @@ public class ServletWebRequest extends ServletRequestAttributes implements Nativ @@ -206,97 +206,80 @@ public class ServletWebRequest extends ServletRequestAttributes implements Nativ
}
@Override
public boolean checkNotModified(@Nullable String etag, long lastModifiedTimestamp) {
public boolean checkNotModified(@Nullable String eTag, long lastModifiedTimestamp) {
HttpServletResponse response = getResponse();
if (this.notModified || (response != null && HttpStatus.OK.value() != response.getStatus())) {
return this.notModified;
}
// Evaluate conditions in order of precedence.
// See https://tools.ietf.org/html/rfc7232#section-6
if (validateIfUnmodifiedSince(lastModifiedTimestamp)) {
if (this.notModified && response != null) {
response.setStatus(HttpStatus.PRECONDITION_FAILED.value());
}
// See https://datatracker.ietf.org/doc/html/rfc9110#section-13.2.2
if (validateIfMatch(eTag)) {
updateResponseStateChanging();
return this.notModified;
}
boolean validated = validateIfNoneMatch(etag);
if (!validated) {
validateIfModifiedSince(lastModifiedTimestamp);
// 2) If-Unmodified-Since
else if (validateIfUnmodifiedSince(lastModifiedTimestamp)) {
updateResponseStateChanging();
return this.notModified;
}
// Update response
if (response != null) {
boolean isHttpGetOrHead = SAFE_METHODS.contains(getRequest().getMethod());
if (this.notModified) {
response.setStatus(isHttpGetOrHead ?
HttpStatus.NOT_MODIFIED.value() : HttpStatus.PRECONDITION_FAILED.value());
}
if (isHttpGetOrHead) {
if (lastModifiedTimestamp > 0 && parseDateValue(response.getHeader(HttpHeaders.LAST_MODIFIED)) == -1) {
response.setDateHeader(HttpHeaders.LAST_MODIFIED, lastModifiedTimestamp);
}
if (StringUtils.hasLength(etag) && response.getHeader(HttpHeaders.ETAG) == null) {
response.setHeader(HttpHeaders.ETAG, padEtagIfNecessary(etag));
}
}
// 3) If-None-Match
if (!validateIfNoneMatch(eTag)) {
// 4) If-Modified-Since
validateIfModifiedSince(lastModifiedTimestamp);
}
updateResponseIdempotent(eTag, lastModifiedTimestamp);
return this.notModified;
}
private boolean validateIfUnmodifiedSince(long lastModifiedTimestamp) {
if (lastModifiedTimestamp < 0) {
private boolean validateIfMatch(@Nullable String eTag) {
Enumeration<String> ifMatchHeaders = getRequest().getHeaders(HttpHeaders.IF_MATCH);
if (SAFE_METHODS.contains(getRequest().getMethod())) {
return false;
}
long ifUnmodifiedSince = parseDateHeader(HttpHeaders.IF_UNMODIFIED_SINCE);
if (ifUnmodifiedSince == -1) {
if (!ifMatchHeaders.hasMoreElements()) {
return false;
}
// We will perform this validation...
this.notModified = (ifUnmodifiedSince < (lastModifiedTimestamp / 1000 * 1000));
this.notModified = matchRequestedETags(ifMatchHeaders, eTag, false);
return true;
}
private boolean validateIfNoneMatch(@Nullable String etag) {
if (!StringUtils.hasLength(etag)) {
return false;
}
Enumeration<String> ifNoneMatch;
try {
ifNoneMatch = getRequest().getHeaders(HttpHeaders.IF_NONE_MATCH);
}
catch (IllegalArgumentException ex) {
return false;
}
if (!ifNoneMatch.hasMoreElements()) {
private boolean validateIfNoneMatch(@Nullable String eTag) {
Enumeration<String> ifNoneMatchHeaders = getRequest().getHeaders(HttpHeaders.IF_NONE_MATCH);
if (!ifNoneMatchHeaders.hasMoreElements()) {
return false;
}
this.notModified = !matchRequestedETags(ifNoneMatchHeaders, eTag, true);
return true;
}
// We will perform this validation...
etag = padEtagIfNecessary(etag);
if (etag.startsWith("W/")) {
etag = etag.substring(2);
}
while (ifNoneMatch.hasMoreElements()) {
String clientETags = ifNoneMatch.nextElement();
Matcher etagMatcher = ETAG_HEADER_VALUE_PATTERN.matcher(clientETags);
// Compare weak/strong ETags as per https://tools.ietf.org/html/rfc7232#section-2.3
while (etagMatcher.find()) {
if (StringUtils.hasLength(etagMatcher.group()) && etag.equals(etagMatcher.group(3))) {
this.notModified = true;
break;
private boolean matchRequestedETags(Enumeration<String> requestedETags, @Nullable String eTag, boolean weakCompare) {
eTag = padEtagIfNecessary(eTag);
while (requestedETags.hasMoreElements()) {
// Compare weak/strong ETags as per https://datatracker.ietf.org/doc/html/rfc9110#section-8.8.3
Matcher eTagMatcher = ETAG_HEADER_VALUE_PATTERN.matcher(requestedETags.nextElement());
while (eTagMatcher.find()) {
// only consider "lost updates" checks for unsafe HTTP methods
if ("*".equals(eTagMatcher.group()) && StringUtils.hasLength(eTag)
&& !SAFE_METHODS.contains(getRequest().getMethod())) {
return false;
}
if (weakCompare) {
if (eTagWeakMatch(eTag, eTagMatcher.group(1))) {
return false;
}
}
else {
if (eTagStrongMatch(eTag, eTagMatcher.group(1))) {
return false;
}
}
}
}
return true;
}
private String padEtagIfNecessary(String etag) {
@Nullable
private String padEtagIfNecessary(@Nullable String etag) {
if (!StringUtils.hasLength(etag)) {
return etag;
}
@ -306,6 +289,44 @@ public class ServletWebRequest extends ServletRequestAttributes implements Nativ @@ -306,6 +289,44 @@ public class ServletWebRequest extends ServletRequestAttributes implements Nativ
return "\"" + etag + "\"";
}
private boolean eTagStrongMatch(@Nullable String first, @Nullable String second) {
if (!StringUtils.hasLength(first) || first.startsWith("W/")) {
return false;
}
return first.equals(second);
}
private boolean eTagWeakMatch(@Nullable String first, @Nullable String second) {
if (!StringUtils.hasLength(first) || !StringUtils.hasLength(second)) {
return false;
}
if (first.startsWith("W/")) {
first = first.substring(2);
}
if (second.startsWith("W/")) {
second = second.substring(2);
}
return first.equals(second);
}
private void updateResponseStateChanging() {
if (this.notModified && getResponse() != null) {
getResponse().setStatus(HttpStatus.PRECONDITION_FAILED.value());
}
}
private boolean validateIfUnmodifiedSince(long lastModifiedTimestamp) {
if (lastModifiedTimestamp < 0) {
return false;
}
long ifUnmodifiedSince = parseDateHeader(HttpHeaders.IF_UNMODIFIED_SINCE);
if (ifUnmodifiedSince == -1) {
return false;
}
this.notModified = (ifUnmodifiedSince < (lastModifiedTimestamp / 1000 * 1000));
return true;
}
private boolean validateIfModifiedSince(long lastModifiedTimestamp) {
if (lastModifiedTimestamp < 0) {
return false;
@ -319,6 +340,24 @@ public class ServletWebRequest extends ServletRequestAttributes implements Nativ @@ -319,6 +340,24 @@ public class ServletWebRequest extends ServletRequestAttributes implements Nativ
return true;
}
private void updateResponseIdempotent(String eTag, long lastModifiedTimestamp) {
if (getResponse() != null) {
boolean isHttpGetOrHead = SAFE_METHODS.contains(getRequest().getMethod());
if (this.notModified) {
getResponse().setStatus(isHttpGetOrHead ?
HttpStatus.NOT_MODIFIED.value() : HttpStatus.PRECONDITION_FAILED.value());
}
if (isHttpGetOrHead) {
if (lastModifiedTimestamp > 0 && parseDateValue(getResponse().getHeader(HttpHeaders.LAST_MODIFIED)) == -1) {
getResponse().setDateHeader(HttpHeaders.LAST_MODIFIED, lastModifiedTimestamp);
}
if (StringUtils.hasLength(eTag) && getResponse().getHeader(HttpHeaders.ETAG) == null) {
getResponse().setHeader(HttpHeaders.ETAG, padEtagIfNecessary(eTag));
}
}
}
}
public boolean isNotModified() {
return this.notModified;
}

169
spring-web/src/main/java/org/springframework/web/server/adapter/DefaultServerWebExchange.java
Unescape View File

@ -1,5 +1,5 @@ @@ -1,5 +1,5 @@
/*
* Copyright 2002-2019 the original author or authors.
* Copyright 2002-2022 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -57,6 +57,7 @@ import org.springframework.web.server.session.WebSessionManager; @@ -57,6 +57,7 @@ import org.springframework.web.server.session.WebSessionManager;
* Default implementation of {@link ServerWebExchange}.
*
* @author Rossen Stoyanchev
* @author Brian Clozel
* @since 5.0
*/
public class DefaultServerWebExchange implements ServerWebExchange {
@ -249,102 +250,148 @@ public class DefaultServerWebExchange implements ServerWebExchange { @@ -249,102 +250,148 @@ public class DefaultServerWebExchange implements ServerWebExchange {
}
@Override
public boolean checkNotModified(@Nullable String etag, Instant lastModified) {
public boolean checkNotModified(@Nullable String eTag, Instant lastModified) {
HttpStatusCode status = getResponse().getStatusCode();
if (this.notModified || (status != null && !HttpStatus.OK.equals(status))) {
return this.notModified;
}
// Evaluate conditions in order of precedence.
// See https://tools.ietf.org/html/rfc7232#section-6
if (validateIfUnmodifiedSince(lastModified)) {
if (this.notModified) {
getResponse().setStatusCode(HttpStatus.PRECONDITION_FAILED);
}
// See https://datatracker.ietf.org/doc/html/rfc9110#section-13.2.2
// 1) If-Match
if (validateIfMatch(eTag)) {
updateResponseStateChanging();
return this.notModified;
}
boolean validated = validateIfNoneMatch(etag);
if (!validated) {
// 2) If-Unmodified-Since
else if (validateIfUnmodifiedSince(lastModified)) {
updateResponseStateChanging();
return this.notModified;
}
// 3) If-None-Match
if (!validateIfNoneMatch(eTag)) {
// 4) If-Modified-Since
validateIfModifiedSince(lastModified);
}
updateResponseIdempotent(eTag, lastModified);
return this.notModified;
}
// Update response
boolean isHttpGetOrHead = SAFE_METHODS.contains(getRequest().getMethod());
if (this.notModified) {
getResponse().setStatusCode(isHttpGetOrHead ?
HttpStatus.NOT_MODIFIED : HttpStatus.PRECONDITION_FAILED);
private boolean validateIfMatch(@Nullable String eTag) {
try {
if (SAFE_METHODS.contains(getRequest().getMethod())) {
return false;
}
if (CollectionUtils.isEmpty(getRequest().getHeaders().get(HttpHeaders.IF_MATCH))) {
return false;
}
this.notModified = matchRequestedETags(getRequestHeaders().getIfMatch(), eTag, false);
}
if (isHttpGetOrHead) {
if (lastModified.isAfter(Instant.EPOCH) && getResponseHeaders().getLastModified() == -1) {
getResponseHeaders().setLastModified(lastModified.toEpochMilli());
catch (IllegalArgumentException ex) {
return false;
}
return true;
}
private boolean matchRequestedETags(List<String> requestedETags, @Nullable String eTag, boolean weakCompare) {
eTag = padEtagIfNecessary(eTag);
for (String clientEtag : requestedETags) {
// only consider "lost updates" checks for unsafe HTTP methods
if ("*".equals(clientEtag) && StringUtils.hasLength(eTag)
&& !SAFE_METHODS.contains(getRequest().getMethod())) {
return false;
}
if (StringUtils.hasLength(etag) && getResponseHeaders().getETag() == null) {
getResponseHeaders().setETag(padEtagIfNecessary(etag));
// Compare weak/strong ETags as per https://datatracker.ietf.org/doc/html/rfc9110#section-8.8.3
if (weakCompare) {
if (eTagWeakMatch(eTag, clientEtag)) {
return false;
}
}
else {
if (eTagStrongMatch(eTag, clientEtag)) {
return false;
}
}
}
return true;
}
return this.notModified;
@Nullable
private String padEtagIfNecessary(@Nullable String etag) {
if (!StringUtils.hasLength(etag)) {
return etag;
}
if ((etag.startsWith("\"") || etag.startsWith("W/\"")) && etag.endsWith("\"")) {
return etag;
}
return "\"" + etag + "\"";
}
private boolean validateIfUnmodifiedSince(Instant lastModified) {
if (lastModified.isBefore(Instant.EPOCH)) {
private boolean eTagStrongMatch(@Nullable String first, @Nullable String second) {
if (!StringUtils.hasLength(first) || first.startsWith("W/")) {
return false;
}
long ifUnmodifiedSince = getRequestHeaders().getIfUnmodifiedSince();
if (ifUnmodifiedSince == -1) {
return first.equals(second);
}
private boolean eTagWeakMatch(@Nullable String first, @Nullable String second) {
if (!StringUtils.hasLength(first) || !StringUtils.hasLength(second)) {
return false;
}
// We will perform this validation...
Instant sinceInstant = Instant.ofEpochMilli(ifUnmodifiedSince);
this.notModified = sinceInstant.isBefore(lastModified.truncatedTo(ChronoUnit.SECONDS));
return true;
if (first.startsWith("W/")) {
first = first.substring(2);
}
if (second.startsWith("W/")) {
second = second.substring(2);
}
return first.equals(second);
}
private boolean validateIfNoneMatch(@Nullable String etag) {
if (!StringUtils.hasLength(etag)) {
return false;
private void updateResponseStateChanging() {
if (this.notModified) {
getResponse().setStatusCode(HttpStatus.PRECONDITION_FAILED);
}
List<String> ifNoneMatch;
}
private boolean validateIfNoneMatch(@Nullable String eTag) {
try {
ifNoneMatch = getRequestHeaders().getIfNoneMatch();
if (CollectionUtils.isEmpty(getRequest().getHeaders().get(HttpHeaders.IF_NONE_MATCH))) {
return false;
}
this.notModified = !matchRequestedETags(getRequestHeaders().getIfNoneMatch(), eTag, true);
}
catch (IllegalArgumentException ex) {
return false;
}
if (ifNoneMatch.isEmpty()) {
return false;
}
// We will perform this validation...
etag = padEtagIfNecessary(etag);
if (etag.startsWith("W/")) {
etag = etag.substring(2);
return true;
}
private void updateResponseIdempotent(@Nullable String eTag, Instant lastModified) {
boolean isSafeMethod = SAFE_METHODS.contains(getRequest().getMethod());
if (this.notModified) {
getResponse().setStatusCode(isSafeMethod ?
HttpStatus.NOT_MODIFIED : HttpStatus.PRECONDITION_FAILED);
}
for (String clientEtag : ifNoneMatch) {
// Compare weak/strong ETags as per https://tools.ietf.org/html/rfc7232#section-2.3
if (StringUtils.hasLength(clientEtag)) {
if (clientEtag.startsWith("W/")) {
clientEtag = clientEtag.substring(2);
}
if (clientEtag.equals(etag)) {
this.notModified = true;
break;
}
if (isSafeMethod) {
if (lastModified.isAfter(Instant.EPOCH) && getResponseHeaders().getLastModified() == -1) {
getResponseHeaders().setLastModified(lastModified.toEpochMilli());
}
if (StringUtils.hasLength(eTag) && getResponseHeaders().getETag() == null) {
getResponseHeaders().setETag(padEtagIfNecessary(eTag));
}
}
return true;
}
private String padEtagIfNecessary(String etag) {
if (!StringUtils.hasLength(etag)) {
return etag;
private boolean validateIfUnmodifiedSince(Instant lastModified) {
if (lastModified.isBefore(Instant.EPOCH)) {
return false;
}
if ((etag.startsWith("\"") || etag.startsWith("W/\"")) && etag.endsWith("\"")) {
return etag;
long ifUnmodifiedSince = getRequestHeaders().getIfUnmodifiedSince();
if (ifUnmodifiedSince == -1) {
return false;
}
return "\"" + etag + "\"";
Instant sinceInstant = Instant.ofEpochMilli(ifUnmodifiedSince);
this.notModified = sinceInstant.isBefore(lastModified.truncatedTo(ChronoUnit.SECONDS));
return true;
}
private boolean validateIfModifiedSince(Instant lastModified) {

410
spring-web/src/test/java/org/springframework/web/context/request/ServletWebRequestHttpMethodsTests.java
Unescape View File

@ -20,12 +20,17 @@ import java.lang.annotation.ElementType; @@ -20,12 +20,17 @@ import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.time.Instant;
import java.time.ZonedDateTime;
import java.util.Date;
import java.time.temporal.ChronoUnit;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.lang.Nullable;
import org.springframework.web.testfixture.servlet.MockHttpServletRequest;
import org.springframework.web.testfixture.servlet.MockHttpServletResponse;
@ -44,313 +49,272 @@ class ServletWebRequestHttpMethodsTests { @@ -44,313 +49,272 @@ class ServletWebRequestHttpMethodsTests {
private static final String CURRENT_TIME = "Wed, 9 Apr 2014 09:57:42 GMT";
private static final Instant NOW = Instant.now();
private final MockHttpServletRequest servletRequest = new MockHttpServletRequest();
private final MockHttpServletResponse servletResponse = new MockHttpServletResponse();
private final ServletWebRequest request = new ServletWebRequest(servletRequest, servletResponse);
private final Date currentDate = new Date();
@ParameterizedHttpMethodTest
void checkNotModifiedNon2xxStatus(String method) {
setUpRequest(method);
long epochTime = currentDate.getTime();
servletRequest.addHeader("If-Modified-Since", epochTime);
servletResponse.setStatus(304);
assertThat(request.checkNotModified(epochTime)).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("Last-Modified")).isNull();
@Test
void ifMatchWildcardShouldMatchWhenETagPresent() {
setUpRequest("PUT");
servletRequest.addHeader(HttpHeaders.IF_MATCH, "*");
assertThat(request.checkNotModified("\"SomeETag\"")).isFalse();
}
@ParameterizedHttpMethodTest // SPR-13516
void checkNotModifiedInvalidStatus(String method) {
setUpRequest(method);
long epochTime = currentDate.getTime();
servletRequest.addHeader("If-Modified-Since", epochTime);
servletResponse.setStatus(0);
assertThat(request.checkNotModified(epochTime)).isFalse();
@Test
void ifMatchWildcardShouldMatchETagMissing() {
setUpRequest("PUT");
servletRequest.addHeader(HttpHeaders.IF_MATCH, "*");
assertThat(request.checkNotModified("")).isTrue();
assertPreconditionFailed();
}
@ParameterizedHttpMethodTest // SPR-14559
void checkNotModifiedInvalidIfNoneMatchHeader(String method) {
setUpRequest(method);
String etag = "\"etagvalue\"";
servletRequest.addHeader("If-None-Match", "missingquotes");
assertThat(request.checkNotModified(etag)).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(etag);
@Test
void ifMatchValueShouldMatchWhenETagMatches() {
setUpRequest("PUT");
servletRequest.addHeader(HttpHeaders.IF_MATCH, "\"first\"");
servletRequest.addHeader(HttpHeaders.IF_MATCH, "\"second\"");
assertThat(request.checkNotModified("\"second\"")).isFalse();
}
@ParameterizedHttpMethodTest
void checkNotModifiedHeaderAlreadySet(String method) {
setUpRequest(method);
long epochTime = currentDate.getTime();
servletRequest.addHeader("If-Modified-Since", epochTime);
servletResponse.addHeader("Last-Modified", CURRENT_TIME);
assertThat(request.checkNotModified(epochTime)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeaders("Last-Modified").size()).isEqualTo(1);
assertThat(servletResponse.getHeader("Last-Modified")).isEqualTo(CURRENT_TIME);
@Test
void ifMatchValueShouldRejectWhenETagDoesNotMatch() {
setUpRequest("PUT");
servletRequest.addHeader(HttpHeaders.IF_MATCH, "\"first\"");
assertThat(request.checkNotModified("\"second\"")).isTrue();
assertPreconditionFailed();
}
@ParameterizedHttpMethodTest
void checkNotModifiedTimestamp(String method) {
setUpRequest(method);
long epochTime = currentDate.getTime();
servletRequest.addHeader("If-Modified-Since", epochTime);
assertThat(request.checkNotModified(epochTime)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getDateHeader("Last-Modified") / 1000).isEqualTo(currentDate.getTime() / 1000);
@Test
void ifMatchValueShouldUseStrongComparison() {
setUpRequest("PUT");
String eTag = "\"spring\"";
servletRequest.addHeader(HttpHeaders.IF_MATCH, "W/" + eTag);
assertThat(request.checkNotModified(eTag)).isTrue();
assertPreconditionFailed();
}
@ParameterizedHttpMethodTest
void checkModifiedTimestamp(String method) {
@SafeHttpMethodsTest
void ifMatchShouldOnlyBeConsideredForUnsafeMethods(String method) {
setUpRequest(method);
servletRequest.addHeader(HttpHeaders.IF_MATCH, "*");
assertThat(request.checkNotModified("\"spring\"")).isFalse();
}
long oneMinuteAgo = currentDate.getTime() - (1000 * 60);
servletRequest.addHeader("If-Modified-Since", oneMinuteAgo);
assertThat(request.checkNotModified(currentDate.getTime())).isFalse();
@Test
void ifUnModifiedSinceShouldMatchValueWhenLater() {
setUpRequest("PUT");
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
Instant oneMinuteAgo = now.minus(1, ChronoUnit.MINUTES);
servletRequest.addHeader(HttpHeaders.IF_UNMODIFIED_SINCE, now.toEpochMilli());
assertThat(request.checkNotModified(oneMinuteAgo.toEpochMilli())).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getDateHeader("Last-Modified") / 1000).isEqualTo(currentDate.getTime() / 1000);
assertThat(servletResponse.getHeader(HttpHeaders.LAST_MODIFIED)).isNull();
}
@ParameterizedHttpMethodTest
void checkNotModifiedETag(String method) {
setUpRequest(method);
String etag = "\"Foo\"";
servletRequest.addHeader("If-None-Match", etag);
@Test
void ifUnModifiedSinceShouldNotMatchValueWhenEarlier() {
setUpRequest("PUT");
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
Instant oneMinuteAgo = now.minus(1, ChronoUnit.MINUTES);
servletRequest.addHeader(HttpHeaders.IF_UNMODIFIED_SINCE, oneMinuteAgo.toEpochMilli());
assertThat(request.checkNotModified(now.toEpochMilli())).isTrue();
assertPreconditionFailed();
}
@SafeHttpMethodsTest
void ifNoneMatchShouldMatchIdenticalETagValue(String method) {
setUpRequest(method);
String etag = "\"spring\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etag);
assertThat(request.checkNotModified(etag)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(etag);
assertNotModified(etag, null);
}
@ParameterizedHttpMethodTest
void checkNotModifiedETagWithSeparatorChars(String method) {
@SafeHttpMethodsTest
void ifNoneMatchShouldMatchETagWithSeparatorChar(String method) {
setUpRequest(method);
String etag = "\"Foo, Bar\"";
servletRequest.addHeader("If-None-Match", etag);
String etag = "\"spring,framework\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etag);
assertThat(request.checkNotModified(etag)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(etag);
assertNotModified(etag, null);
}
@ParameterizedHttpMethodTest
void checkModifiedETag(String method) {
@SafeHttpMethodsTest
void ifNoneMatchShouldNotMatchDifferentETag(String method) {
setUpRequest(method);
String currentETag = "\"Foo\"";
String oldETag = "Bar";
servletRequest.addHeader("If-None-Match", oldETag);
assertThat(request.checkNotModified(currentETag)).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(currentETag);
String etag = "\"framework\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, "\"spring\"");
assertThat(request.checkNotModified(etag)).isFalse();
assertOkWithETag(etag);
}
@ParameterizedHttpMethodTest
void checkNotModifiedUnpaddedETag(String method) {
@SafeHttpMethodsTest
// SPR-14559
void ifNoneMatchShouldNotFailForUnquotedETag(String method) {
setUpRequest(method);
String etag = "Foo";
String paddedETag = String.format("\"%s\"", etag);
servletRequest.addHeader("If-None-Match", paddedETag);
assertThat(request.checkNotModified(etag)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(paddedETag);
String etag = "\"etagvalue\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, "missingquotes");
assertThat(request.checkNotModified(etag)).isFalse();
assertOkWithETag(etag);
}
@ParameterizedHttpMethodTest
void checkModifiedUnpaddedETag(String method) {
@SafeHttpMethodsTest
void ifNoneMatchShouldMatchPaddedETag(String method) {
setUpRequest(method);
String currentETag = "Foo";
String oldETag = "Bar";
servletRequest.addHeader("If-None-Match", oldETag);
assertThat(request.checkNotModified(currentETag)).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(String.format("\"%s\"", currentETag));
String etag = "spring";
String paddedEtag = String.format("\"%s\"", etag);
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, paddedEtag);
assertThat(request.checkNotModified(etag)).isTrue();
assertNotModified(paddedEtag, null);
}
@ParameterizedHttpMethodTest
void checkNotModifiedWildcardIsIgnored(String method) {
@SafeHttpMethodsTest
void ifNoneMatchShouldIgnoreWildcard(String method) {
setUpRequest(method);
String etag = "\"Foo\"";
servletRequest.addHeader("If-None-Match", "*");
String etag = "\"spring\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, "*");
assertThat(request.checkNotModified(etag)).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(etag);
assertOkWithETag(etag);
}
@ParameterizedHttpMethodTest
void checkNotModifiedETagAndTimestamp(String method) {
setUpRequest(method);
String etag = "\"Foo\"";
servletRequest.addHeader("If-None-Match", etag);
servletRequest.addHeader("If-Modified-Since", currentDate.getTime());
assertThat(request.checkNotModified(etag, currentDate.getTime())).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(etag);
assertThat(servletResponse.getDateHeader("Last-Modified") / 1000).isEqualTo(currentDate.getTime() / 1000);
@Test
void ifNoneMatchShouldRejectWildcardForUnsafeMethods() {
setUpRequest("PUT");
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, "*");
assertThat(request.checkNotModified("\"spring\"")).isTrue();
assertPreconditionFailed();
}
@ParameterizedHttpMethodTest // SPR-14224
void checkNotModifiedETagAndModifiedTimestamp(String method) {
@SafeHttpMethodsTest
void ifNoneMatchValueShouldUseWeakComparison(String method) {
setUpRequest(method);
String etag = "\"Foo\"";
servletRequest.addHeader("If-None-Match", etag);
long currentEpoch = currentDate.getTime();
long oneMinuteAgo = currentEpoch - (1000 * 60);
servletRequest.addHeader("If-Modified-Since", oneMinuteAgo);
assertThat(request.checkNotModified(etag, currentEpoch)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(etag);
assertThat(servletResponse.getDateHeader("Last-Modified") / 1000).isEqualTo(currentDate.getTime() / 1000);
String etag = "\"spring\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, "W/" + etag);
assertThat(request.checkNotModified(etag)).isTrue();
assertNotModified(etag, null);
}
@ParameterizedHttpMethodTest
void checkModifiedETagAndNotModifiedTimestamp(String method) {
@SafeHttpMethodsTest
void ifModifiedSinceShouldMatchIfDatesEqual(String method) {
setUpRequest(method);
String currentETag = "\"Foo\"";
String oldETag = "\"Bar\"";
servletRequest.addHeader("If-None-Match", oldETag);
long epochTime = currentDate.getTime();
servletRequest.addHeader("If-Modified-Since", epochTime);
assertThat(request.checkNotModified(currentETag, epochTime)).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(currentETag);
assertThat(servletResponse.getDateHeader("Last-Modified") / 1000).isEqualTo(currentDate.getTime() / 1000);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, NOW.toEpochMilli());
assertThat(request.checkNotModified(NOW.toEpochMilli())).isTrue();
assertNotModified(null, NOW);
}
@ParameterizedHttpMethodTest
void checkNotModifiedETagWeakStrong(String method) {
@SafeHttpMethodsTest
void ifModifiedSinceShouldNotMatchIfDateAfter(String method) {
setUpRequest(method);
String etag = "\"Foo\"";
String weakETag = String.format("W/%s", etag);
servletRequest.addHeader("If-None-Match", etag);
assertThat(request.checkNotModified(weakETag)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(weakETag);
Instant oneMinuteLater = NOW.plus(1, ChronoUnit.MINUTES);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, NOW.toEpochMilli());
assertThat(request.checkNotModified(oneMinuteLater.toEpochMilli())).isFalse();
assertOkWithLastModified(oneMinuteLater);
}
@ParameterizedHttpMethodTest
void checkNotModifiedETagStrongWeak(String method) {
@SafeHttpMethodsTest
void ifModifiedSinceShouldNotOverrideResponseStatus(String method) {
setUpRequest(method);
String etag = "\"Foo\"";
servletRequest.addHeader("If-None-Match", String.format("W/%s", etag));
assertThat(request.checkNotModified(etag)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(etag);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, NOW.toEpochMilli());
servletResponse.setStatus(304);
assertThat(request.checkNotModified(NOW.toEpochMilli())).isFalse();
assertNotModified(null, null);
}
@ParameterizedHttpMethodTest
void checkNotModifiedMultipleETags(String method) {
@SafeHttpMethodsTest
// SPR-13516
void ifModifiedSinceShouldNotFailForInvalidResponseStatus(String method) {
setUpRequest(method);
String etag = "\"Bar\"";
String multipleETags = String.format("\"Foo\", %s", etag);
servletRequest.addHeader("If-None-Match", multipleETags);
assertThat(request.checkNotModified(etag)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getHeader("ETag")).isEqualTo(etag);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, NOW.toEpochMilli());
servletResponse.setStatus(0);
assertThat(request.checkNotModified(NOW.toEpochMilli())).isFalse();
}
@ParameterizedHttpMethodTest
void checkNotModifiedTimestampWithLengthPart(String method) {
@SafeHttpMethodsTest
void ifModifiedSinceShouldNotFailForTimestampWithLengthPart(String method) {
setUpRequest(method);
long epochTime = ZonedDateTime.parse(CURRENT_TIME, RFC_1123_DATE_TIME).toInstant().toEpochMilli();
servletRequest.setMethod("GET");
servletRequest.addHeader("If-Modified-Since", "Wed, 09 Apr 2014 09:57:42 GMT; length=13774");
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, "Wed, 09 Apr 2014 09:57:42 GMT; length=13774");
assertThat(request.checkNotModified(epochTime)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(304);
assertThat(servletResponse.getDateHeader("Last-Modified") / 1000).isEqualTo(epochTime / 1000);
assertNotModified(null, Instant.ofEpochMilli(epochTime));
}
@ParameterizedHttpMethodTest
void checkModifiedTimestampWithLengthPart(String method) {
@SafeHttpMethodsTest
void IfNoneMatchAndIfNotModifiedSinceShouldMatchWhenSameETagAndDate(String method) {
setUpRequest(method);
String etag = "\"spring\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etag);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, NOW.toEpochMilli());
assertThat(request.checkNotModified(etag, NOW.toEpochMilli())).isTrue();
assertNotModified(etag, NOW);
}
long epochTime = ZonedDateTime.parse(CURRENT_TIME, RFC_1123_DATE_TIME).toInstant().toEpochMilli();
servletRequest.setMethod("GET");
servletRequest.addHeader("If-Modified-Since", "Wed, 08 Apr 2014 09:57:42 GMT; length=13774");
assertThat(request.checkNotModified(epochTime)).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getDateHeader("Last-Modified") / 1000).isEqualTo(epochTime / 1000);
@SafeHttpMethodsTest
void IfNoneMatchAndIfNotModifiedSinceShouldMatchWhenSameETagAndLaterDate(String method) {
setUpRequest(method);
String etag = "\"spring\"";
Instant oneMinuteLater = NOW.plus(1, ChronoUnit.MINUTES);
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etag);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, oneMinuteLater.toEpochMilli());
assertThat(request.checkNotModified(etag, NOW.toEpochMilli())).isTrue();
assertNotModified(etag, NOW);
}
@ParameterizedHttpMethodTest
void checkNotModifiedTimestampConditionalPut(String method) {
@SafeHttpMethodsTest
void IfNoneMatchAndIfNotModifiedSinceShouldNotMatchWhenDifferentETag(String method) {
setUpRequest(method);
String etag = "\"framework\"";
Instant oneMinuteLater = NOW.plus(1, ChronoUnit.MINUTES);
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, "\"spring\"");
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, oneMinuteLater.toEpochMilli());
assertThat(request.checkNotModified(etag, NOW.toEpochMilli())).isFalse();
assertOkWithETag(etag);
assertOkWithLastModified(NOW);
}
long currentEpoch = currentDate.getTime();
long oneMinuteAgo = currentEpoch - (1000 * 60);
servletRequest.setMethod("PUT");
servletRequest.addHeader("If-UnModified-Since", currentEpoch);
assertThat(request.checkNotModified(oneMinuteAgo)).isFalse();
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getHeader("Last-Modified")).isNull();
private void setUpRequest(String method) {
this.servletRequest.setMethod(method);
this.servletRequest.setRequestURI("https://example.org");
}
@ParameterizedHttpMethodTest
void checkNotModifiedTimestampConditionalPutConflict(String method) {
setUpRequest(method);
private void assertPreconditionFailed() {
assertThat(this.servletResponse.getStatus()).isEqualTo(HttpStatus.PRECONDITION_FAILED.value());
}
long currentEpoch = currentDate.getTime();
long oneMinuteAgo = currentEpoch - (1000 * 60);
servletRequest.setMethod("PUT");
servletRequest.addHeader("If-UnModified-Since", oneMinuteAgo);
private void assertNotModified(@Nullable String eTag, @Nullable Instant lastModified) {
assertThat(this.servletResponse.getStatus()).isEqualTo(HttpStatus.NOT_MODIFIED.value());
if (eTag != null) {
assertThat(servletResponse.getHeader(HttpHeaders.ETAG)).isEqualTo(eTag);
}
if (lastModified != null) {
assertThat(servletResponse.getDateHeader(HttpHeaders.LAST_MODIFIED) / 1000)
.isEqualTo(lastModified.toEpochMilli() / 1000);
}
}
assertThat(request.checkNotModified(currentEpoch)).isTrue();
assertThat(servletResponse.getStatus()).isEqualTo(412);
assertThat(servletResponse.getHeader("Last-Modified")).isNull();
private void assertOkWithETag(String eTag) {
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getHeader(HttpHeaders.ETAG)).isEqualTo(eTag);
}
private void setUpRequest(String method) {
this.servletRequest.setMethod(method);
this.servletRequest.setRequestURI("https://example.org");
private void assertOkWithLastModified(Instant lastModified) {
assertThat(servletResponse.getStatus()).isEqualTo(200);
assertThat(servletResponse.getDateHeader(HttpHeaders.LAST_MODIFIED) / 1000)
.isEqualTo(lastModified.toEpochMilli() / 1000);
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ParameterizedTest(name = "[{index}] {0}")
@ValueSource(strings = { "GET", "HEAD" })
@interface ParameterizedHttpMethodTest {
@ValueSource(strings = {"GET", "HEAD"})
@interface SafeHttpMethodsTest {
}
}

1
spring-web/src/test/java/org/springframework/web/filter/ShallowEtagHeaderFilterTests.java
Unescape View File

@ -30,6 +30,7 @@ import org.springframework.web.testfixture.servlet.MockHttpServletResponse; @@ -30,6 +30,7 @@ import org.springframework.web.testfixture.servlet.MockHttpServletResponse;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Tests for {@link ShallowEtagHeaderFilter}.
* @author Arjen Poutsma
* @author Brian Clozel
* @author Juergen Hoeller

12
spring-web/src/testFixtures/java/org/springframework/web/testfixture/http/server/reactive/MockServerHttpRequest.java
Unescape View File

@ -360,6 +360,12 @@ public final class MockServerHttpRequest extends AbstractServerHttpRequest { @@ -360,6 +360,12 @@ public final class MockServerHttpRequest extends AbstractServerHttpRequest {
*/
B ifUnmodifiedSince(long ifUnmodifiedSince);
/**
* Set the values of the {@code If-Match} header.
* @param ifMatches the new value of the header
*/
B ifMatch(String... ifMatches);
/**
* Set the values of the {@code If-None-Match} header.
* @param ifNoneMatches the new value of the header
@ -556,6 +562,12 @@ public final class MockServerHttpRequest extends AbstractServerHttpRequest { @@ -556,6 +562,12 @@ public final class MockServerHttpRequest extends AbstractServerHttpRequest {
return this;
}
@Override
public BodyBuilder ifMatch(String... ifMatches) {
this.headers.setIfMatch(Arrays.asList(ifMatches));
return this;
}
@Override
public BodyBuilder ifNoneMatch(String... ifNoneMatches) {
this.headers.setIfNoneMatch(Arrays.asList(ifNoneMatches));

10
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/ServerRequest.java
Unescape View File

@ -1,5 +1,5 @@ @@ -1,5 +1,5 @@
/*
* Copyright 2002-2020 the original author or authors.
* Copyright 2002-2022 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -352,13 +352,14 @@ public interface ServerRequest { @@ -352,13 +352,14 @@ public interface ServerRequest {
* also with conditional POST/PUT/DELETE requests.
* <p><strong>Note:</strong> you can use either
* this {@link #checkNotModified(Instant)} method; or
* {@code #checkNotModified(String)}. If you want enforce both
* {@code #checkNotModified(String)}. If you want to enforce both
* a strong entity tag and a Last-Modified value,
* as recommended by the HTTP specification,
* then you should use {@link #checkNotModified(Instant, String)}.
* @param etag the entity tag that the application determined
* for the underlying resource. This parameter will be padded
* with quotes (") if necessary.
* with quotes (") if necessary. Use an empty string {@code ""}
* for no value.
* @return a corresponding response if the request qualifies as not
* modified, or an empty result otherwise
* @since 5.2.5
@ -391,7 +392,8 @@ public interface ServerRequest { @@ -391,7 +392,8 @@ public interface ServerRequest {
* application determined for the underlying resource
* @param etag the entity tag that the application determined
* for the underlying resource. This parameter will be padded
* with quotes (") if necessary.
* with quotes (") if necessary. Use an empty string {@code ""}
* for no value.
* @return a corresponding response if the request qualifies as not
* modified, or an empty result otherwise.
* @since 5.2.5

819
spring-webflux/src/test/java/org/springframework/web/reactive/function/server/DefaultServerRequestTests.java
Unescape View File

@ -1,5 +1,5 @@ @@ -1,5 +1,5 @@
/*
* Copyright 2002-2020 the original author or authors.
* Copyright 2002-2022 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -34,7 +34,9 @@ import java.util.List; @@ -34,7 +34,9 @@ import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalLong;
import java.util.function.Consumer;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
@ -58,6 +60,7 @@ import org.springframework.http.codec.HttpMessageReader; @@ -58,6 +60,7 @@ import org.springframework.http.codec.HttpMessageReader;
import org.springframework.http.codec.json.Jackson2JsonDecoder;
import org.springframework.http.codec.multipart.FormFieldPart;
import org.springframework.http.codec.multipart.Part;
import org.springframework.lang.Nullable;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.server.ServerWebInputException;
@ -70,7 +73,10 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException @@ -70,7 +73,10 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException
import static org.springframework.web.reactive.function.BodyExtractors.toMono;
/**
* Tests for {@link DefaultServerRequest} and {@link ServerRequest}.
*
* @author Arjen Poutsma
* @author Brian Clozel
*/
public class DefaultServerRequestTests {
@ -237,139 +243,148 @@ public class DefaultServerRequestTests { @@ -237,139 +243,148 @@ public class DefaultServerRequestTests {
}
@Test
public void body() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
@Nested
class BodyTests {
@Test
public void body() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
Mono<String> resultMono = request.body(toMono(String.class));
assertThat(resultMono.block()).isEqualTo("foo");
}
@Test
public void bodyToMono() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
Mono<String> resultMono = request.bodyToMono(String.class);
assertThat(resultMono.block()).isEqualTo("foo");
}
@Test
public void bodyToMonoParameterizedTypeReference() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
ParameterizedTypeReference<String> typeReference = new ParameterizedTypeReference<>() {
};
Mono<String> resultMono = request.bodyToMono(typeReference);
assertThat(resultMono.block()).isEqualTo("foo");
}
@Test
public void bodyToMonoDecodingException() {
byte[] bytes = "{\"invalid\":\"json\" ".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_JSON);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.POST, "https://example.com/invalid")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
Mono<Map<String, String>> resultMono = request.bodyToMono(
new ParameterizedTypeReference<Map<String, String>>() {
});
StepVerifier.create(resultMono)
.expectError(ServerWebInputException.class)
.verify();
}
@Test
public void bodyToFlux() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
Flux<String> resultFlux = request.bodyToFlux(String.class);
assertThat(resultFlux.collectList().block()).isEqualTo(Collections.singletonList("foo"));
}
@Test
public void bodyToFluxParameterizedTypeReference() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
ParameterizedTypeReference<String> typeReference = new ParameterizedTypeReference<>() {
};
Flux<String> resultFlux = request.bodyToFlux(typeReference);
assertThat(resultFlux.collectList().block()).isEqualTo(Collections.singletonList("foo"));
}
@Test
public void bodyUnacceptable() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = createRequest(mockRequest);
Flux<String> resultFlux = request.bodyToFlux(String.class);
StepVerifier.create(resultFlux)
.expectError(UnsupportedMediaTypeStatusException.class)
.verify();
}
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
Mono<String> resultMono = request.body(toMono(String.class));
assertThat(resultMono.block()).isEqualTo("foo");
}
@Test
public void bodyToMono() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
Mono<String> resultMono = request.bodyToMono(String.class);
assertThat(resultMono.block()).isEqualTo("foo");
}
@Test
public void bodyToMonoParameterizedTypeReference() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
ParameterizedTypeReference<String> typeReference = new ParameterizedTypeReference<>() {};
Mono<String> resultMono = request.bodyToMono(typeReference);
assertThat(resultMono.block()).isEqualTo("foo");
}
@Test
public void bodyToMonoDecodingException() {
byte[] bytes = "{\"invalid\":\"json\" ".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.APPLICATION_JSON);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.POST, "https://example.com/invalid")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
Mono<Map<String, String>> resultMono = request.bodyToMono(
new ParameterizedTypeReference<Map<String, String>>() {});
StepVerifier.create(resultMono)
.expectError(ServerWebInputException.class)
.verify();
}
@Test
public void bodyToFlux() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
Flux<String> resultFlux = request.bodyToFlux(String.class);
assertThat(resultFlux.collectList().block()).isEqualTo(Collections.singletonList("foo"));
}
@Test
public void bodyToFluxParameterizedTypeReference() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), messageReaders);
ParameterizedTypeReference<String> typeReference = new ParameterizedTypeReference<>() {};
Flux<String> resultFlux = request.bodyToFlux(typeReference);
assertThat(resultFlux.collectList().block()).isEqualTo(Collections.singletonList("foo"));
}
@Test
public void bodyUnacceptable() {
byte[] bytes = "foo".getBytes(StandardCharsets.UTF_8);
DefaultDataBuffer dataBuffer = DefaultDataBufferFactory.sharedInstance.wrap(ByteBuffer.wrap(bytes));
Flux<DataBuffer> body = Flux.just(dataBuffer);
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.TEXT_PLAIN);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.GET, "https://example.com?foo=bar")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Flux<String> resultFlux = request.bodyToFlux(String.class);
StepVerifier.create(resultFlux)
.expectError(UnsupportedMediaTypeStatusException.class)
.verify();
}
@Test
public void formData() {
@ -383,7 +398,7 @@ public class DefaultServerRequestTests { @@ -383,7 +398,7 @@ public class DefaultServerRequestTests {
.method(HttpMethod.GET, "https://example.com")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
DefaultServerRequest request = createRequest(mockRequest);
Mono<MultiValueMap<String, String>> resultData = request.formData();
StepVerifier.create(resultData)
@ -416,7 +431,7 @@ public class DefaultServerRequestTests { @@ -416,7 +431,7 @@ public class DefaultServerRequestTests {
.method(HttpMethod.GET, "https://example.com")
.headers(httpHeaders)
.body(body);
DefaultServerRequest request = new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
DefaultServerRequest request = createRequest(mockRequest);
Mono<MultiValueMap<String, Part>> resultData = request.multipartData();
StepVerifier.create(resultData)
@ -438,259 +453,293 @@ public class DefaultServerRequestTests { @@ -438,259 +453,293 @@ public class DefaultServerRequestTests {
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkNotModifiedTimestamp(String method) throws Exception {
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
HttpHeaders headers = new HttpHeaders();
headers.setIfModifiedSince(now);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(now);
StepVerifier.create(result)
.assertNext(serverResponse -> {
assertThat(serverResponse.statusCode()).isEqualTo(HttpStatus.NOT_MODIFIED);
assertThat(serverResponse.headers().getLastModified()).isEqualTo(now.toEpochMilli());
})
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkModifiedTimestamp(String method) {
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
Instant oneMinuteAgo = now.minus(1, ChronoUnit.MINUTES);
HttpHeaders headers = new HttpHeaders();
headers.setIfModifiedSince(oneMinuteAgo);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(now);
StepVerifier.create(result)
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkNotModifiedETag(String method) {
String eTag = "\"Foo\"";
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch(eTag);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.assertNext(serverResponse -> {
assertThat(serverResponse.statusCode()).isEqualTo(HttpStatus.NOT_MODIFIED);
private DefaultServerRequest createRequest(MockServerHttpRequest mockRequest) {
return new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
}
@Nested
class CheckNotModifiedTests {
@Test
void ifMatchWildcardShouldMatchWhenETagPresent() {
MockServerHttpRequest mockRequest = MockServerHttpRequest.put("/")
.header(HttpHeaders.IF_MATCH, "*").build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified("\"SomeETag\"");
StepVerifier.create(result)
.verifyComplete();
}
@Test
void ifMatchWildcardShouldMatchWhenETagMissing() {
MockServerHttpRequest mockRequest = MockServerHttpRequest.put("/")
.header(HttpHeaders.IF_MATCH, "*").build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified("");
StepVerifier.create(result)
.assertNext(assertPreconditionFailed())
.verifyComplete();
}
@Test
void ifMatchValueShouldMatchWhenETagMatches() {
MockServerHttpRequest mockRequest = MockServerHttpRequest.put("/")
.ifMatch("\"first\"", "\"second\"").build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified("\"second\"");
StepVerifier.create(result).verifyComplete();
}
@Test
void ifMatchValueShouldNotMatchWhenETagDoesNotMatch() {
MockServerHttpRequest mockRequest = MockServerHttpRequest.put("/")
.header(HttpHeaders.IF_MATCH, "\"first\"", "\"second\"").build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified("\"third\"");
StepVerifier.create(result)
.assertNext(assertPreconditionFailed())
.verifyComplete();
}
@Test
void ifMatchValueShouldUseStrongComparison() {
String eTag = "\"spring\"";
MockServerHttpRequest mockRequest = MockServerHttpRequest.put("/")
.header(HttpHeaders.IF_MATCH, "W/" + eTag).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.assertNext(assertPreconditionFailed())
.verifyComplete();
}
@Test
void ifMatchShouldOnlyBeConsideredForUnsafeMethods() {
MockServerHttpRequest mockRequest = MockServerHttpRequest.get("/")
.header(HttpHeaders.IF_MATCH, "*").build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified("\"spring\"");
StepVerifier.create(result).verifyComplete();
}
@Test
void ifUnModifiedSinceShouldMatchValueWhenLater() {
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
Instant oneMinuteAgo = now.minus(1, ChronoUnit.MINUTES);
MockServerHttpRequest mockRequest = MockServerHttpRequest.put("/")
.ifUnmodifiedSince(now.toEpochMilli()).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(oneMinuteAgo);
StepVerifier.create(result).verifyComplete();
}
@Test
void ifUnModifiedSinceShouldNotMatchValueWhenEarlier() {
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
Instant oneMinuteAgo = now.minus(1, ChronoUnit.MINUTES);
MockServerHttpRequest mockRequest = MockServerHttpRequest.put("/")
.ifUnmodifiedSince(oneMinuteAgo.toEpochMilli()).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(now);
StepVerifier.create(result)
.assertNext(assertPreconditionFailed())
.verifyComplete();
}
@SafeHttpMethodsTest
void ifNoneMatchShouldMatchIdenticalETagValue(String method) {
String eTag = "\"Foo\"";
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch(eTag).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.assertNext(assertNotModified(eTag, null))
.verifyComplete();
}
@SafeHttpMethodsTest
void ifNoneMatchShouldMatchETagWithSeparatorChar(String method) {
String eTag = "\"Foo, Bar\"";
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch(eTag).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.assertNext(assertNotModified(eTag, null))
.verifyComplete();
}
@SafeHttpMethodsTest
void ifNoneMatchShouldNotMatchDifferentETag(String method) {
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch("Bar").build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified("\"Foo\"");
StepVerifier.create(result).verifyComplete();
}
@SafeHttpMethodsTest
void ifNoneMatchShouldMatchPaddedETag(String method) {
String eTag = "Foo";
String paddedEtag = String.format("\"%s\"", eTag);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch(paddedEtag).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.assertNext(assertNotModified(paddedEtag, null))
.verifyComplete();
}
@SafeHttpMethodsTest
void ifNoneMatchValueShouldUseWeakComparison(String method) {
String eTag = "\"spring\"";
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch("W/" + eTag).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.assertNext(assertNotModified(eTag, null))
.verifyComplete();
}
@SafeHttpMethodsTest
void ifNoneMatchShouldIgnoreWildcard(String method) {
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch("*").build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified("\"spring\"");
StepVerifier.create(result).verifyComplete();
}
@Test
void ifNoneMatchShouldRejectWildcardForUnsafeMethods() {
MockServerHttpRequest mockRequest = MockServerHttpRequest.put("/")
.ifNoneMatch("*").build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified("\"spring\"");
StepVerifier.create(result)
.assertNext(assertPreconditionFailed())
.verifyComplete();
}
@SafeHttpMethodsTest
void ifModifiedSinceShouldMatchIfDatesEqual(String method) {
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifModifiedSince(now.toEpochMilli()).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(now);
StepVerifier.create(result)
.assertNext(assertNotModified(null, now))
.verifyComplete();
}
@SafeHttpMethodsTest
void ifModifiedSinceShouldNotMatchIfDateAfter(String method) {
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
Instant oneMinuteAgo = now.minus(1, ChronoUnit.MINUTES);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifModifiedSince(oneMinuteAgo.toEpochMilli()).build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(now);
StepVerifier.create(result).verifyComplete();
}
@SafeHttpMethodsTest
void IfNoneMatchAndIfNotModifiedSinceShouldMatchWhenSameETagAndDate(String method) {
String eTag = "\"Foo\"";
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch(eTag).ifModifiedSince(now.toEpochMilli())
.build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(now, eTag);
StepVerifier.create(result)
.assertNext(assertNotModified(eTag, now))
.verifyComplete();
}
@SafeHttpMethodsTest
void IfNoneMatchAndIfNotModifiedSinceShouldMatchWhenSameETagAndLaterDate(String method) {
String eTag = "\"Foo\"";
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
Instant oneMinuteAgo = now.minus(1, ChronoUnit.MINUTES);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch(eTag).ifModifiedSince(oneMinuteAgo.toEpochMilli())
.build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(now, eTag);
StepVerifier.create(result)
.assertNext(assertNotModified(eTag, now))
.verifyComplete();
}
@SafeHttpMethodsTest
void IfNoneMatchAndIfNotModifiedSinceShouldNotMatchWhenDifferentETag(String method) {
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.ifNoneMatch("\"Bar\"").ifModifiedSince(now.toEpochMilli())
.build();
DefaultServerRequest request = createRequest(mockRequest);
Mono<ServerResponse> result = request.checkNotModified(now, "\"Foo\"");
StepVerifier.create(result).verifyComplete();
}
private Consumer<ServerResponse> assertPreconditionFailed() {
return serverResponse -> assertThat(serverResponse.statusCode()).isEqualTo(HttpStatus.PRECONDITION_FAILED);
}
private Consumer<ServerResponse> assertNotModified(@Nullable String eTag, @Nullable Instant lastModified) {
return serverResponse -> {
assertThat(serverResponse.statusCode()).isEqualTo(HttpStatus.NOT_MODIFIED);
if (eTag != null) {
assertThat(serverResponse.headers().getETag()).isEqualTo(eTag);
})
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkNotModifiedETagWithSeparatorChars(String method) {
String eTag = "\"Foo, Bar\"";
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch(eTag);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.assertNext(serverResponse -> {
assertThat(serverResponse.statusCode()).isEqualTo(HttpStatus.NOT_MODIFIED);
assertThat(serverResponse.headers().getETag()).isEqualTo(eTag);
})
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkModifiedETag(String method) {
String currentETag = "\"Foo\"";
String oldEtag = "Bar";
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch(oldEtag);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(currentETag);
StepVerifier.create(result)
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkNotModifiedUnpaddedETag(String method) {
String eTag = "Foo";
String paddedEtag = String.format("\"%s\"", eTag);
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch(paddedEtag);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.assertNext(serverResponse -> {
assertThat(serverResponse.statusCode()).isEqualTo(HttpStatus.NOT_MODIFIED);
assertThat(serverResponse.headers().getETag()).isEqualTo(paddedEtag);
})
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkModifiedUnpaddedETag(String method) {
String currentETag = "Foo";
String oldEtag = "Bar";
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch(oldEtag);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(currentETag);
StepVerifier.create(result)
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkNotModifiedWildcardIsIgnored(String method) {
String eTag = "\"Foo\"";
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch("*");
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(eTag);
StepVerifier.create(result)
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkNotModifiedETagAndTimestamp(String method) {
String eTag = "\"Foo\"";
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch(eTag);
headers.setIfModifiedSince(now);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(now, eTag);
StepVerifier.create(result)
.assertNext(serverResponse -> {
assertThat(serverResponse.statusCode()).isEqualTo(HttpStatus.NOT_MODIFIED);
assertThat(serverResponse.headers().getETag()).isEqualTo(eTag);
assertThat(serverResponse.headers().getLastModified()).isEqualTo(now.toEpochMilli());
})
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkNotModifiedETagAndModifiedTimestamp(String method) {
String eTag = "\"Foo\"";
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
Instant oneMinuteAgo = now.minus(1, ChronoUnit.MINUTES);
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch(eTag);
headers.setIfModifiedSince(oneMinuteAgo);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(now, eTag);
StepVerifier.create(result)
.assertNext(serverResponse -> {
assertThat(serverResponse.statusCode()).isEqualTo(HttpStatus.NOT_MODIFIED);
assertThat(serverResponse.headers().getETag()).isEqualTo(eTag);
assertThat(serverResponse.headers().getLastModified()).isEqualTo(now.toEpochMilli());
})
.verifyComplete();
}
@ParameterizedHttpMethodTest
void checkModifiedETagAndNotModifiedTimestamp(String method) throws Exception {
String currentETag = "\"Foo\"";
String oldEtag = "\"Bar\"";
Instant now = Instant.now().truncatedTo(ChronoUnit.SECONDS);
HttpHeaders headers = new HttpHeaders();
headers.setIfNoneMatch(oldEtag);
headers.setIfModifiedSince(now);
MockServerHttpRequest mockRequest = MockServerHttpRequest
.method(HttpMethod.valueOf(method), "/")
.headers(headers)
.build();
DefaultServerRequest request =
new DefaultServerRequest(MockServerWebExchange.from(mockRequest), Collections.emptyList());
Mono<ServerResponse> result = request.checkNotModified(now, currentETag);
StepVerifier.create(result)
.verifyComplete();
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ParameterizedTest(name = "[{index}] {0}")
@ValueSource(strings = {"GET", "HEAD"})
@interface ParameterizedHttpMethodTest {
}
if (lastModified != null) {
assertThat(serverResponse.headers().getLastModified()).isEqualTo(lastModified.toEpochMilli());
}
};
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@ParameterizedTest(name = "[{index}] {0}")
@ValueSource(strings = {"GET", "HEAD"})
@interface SafeHttpMethodsTest {
}
}

Write Preview
Loading…
Cancel
Save