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

Extract base class AbstractNamedValueArgumentResolver

Browse Source 
Closes gh-28395
This commit is contained in:
rstoyanchev
2022-04-29 17:34:16 +01:00
parent d91b840d0e
commit f8ac5985bd
6 changed files with 382 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
spring-web/src/test/java/org/springframework/web/service/invoker/PathVariableArgumentResolverTests.java
View File

@@ -42,106 +42,86 @@ class PathVariableArgumentResolverTests {
@Test
void shouldResolvePathVariableWithNameFromParameter() {
void stringVariable() {
this.service.execute("test");
assertPathVariable("id", "test");
}
@Test
void shouldResolvePathVariableWithNameFromAnnotationName() {
this.service.executeNamed("test");
assertPathVariable("id", "test");
}
@Test
void shouldResolvePathVariableNameFromValue() {
this.service.executeNamedWithValue("test");
assertPathVariable("id", "test");
}
@Test
void shouldOverrideNameIfValuePresentInAnnotation() {
this.service.executeValueNamed("test");
assertPathVariable("id", "test");
}
@Test
void shouldResolvePathVariableWithConversion() {
void objectVariable() {
this.service.execute(Boolean.TRUE);
assertPathVariable("id", "true");
}
@Test
void shouldResolvePathVariableFromOptionalArgumentWithConversion() {
this.service.executeOptional(Optional.of(Boolean.TRUE));
assertPathVariable("id", "true");
void namedVariable() {
this.service.executeNamed("test");
assertPathVariable("id", "test");
}
@SuppressWarnings("ConstantConditions")
@Test
void nullVariableRequired() {
assertThatIllegalArgumentException().isThrownBy(() -> this.service.execute(null));
}
@Test
void shouldResolvePathVariableFromOptionalArgument() {
void nullVariableNotRequired() {
this.service.executeNotRequired(null);
assertPathVariable("id", null);
}
@Test
void optionalStringVariable() {
this.service.execute(Optional.of("test"));
assertPathVariable("id", "test");
}
@Test
void shouldThrowExceptionForNull() {
assertThatIllegalArgumentException().isThrownBy(() -> this.service.executeNamedWithValue(null));
void optionalObjectVariable() {
this.service.executeOptional(Optional.of(Boolean.TRUE));
assertPathVariable("id", "true");
}
@Test
void shouldThrowExceptionForEmptyOptional() {
void optionalEmpty() {
this.service.executeOptional(Optional.empty());
assertPathVariable("id", null);
}
@Test
void optionalEmptyOnObjectArgument() {
assertThatIllegalArgumentException().isThrownBy(() -> this.service.execute(Optional.empty()));
}
@Test
void shouldIgnoreNullWithConversionServiceWhenNotRequired() {
this.service.executeNotRequired(null);
assertThat(getActualUriVariables().get("id")).isNull();
}
@Test
void shouldIgnoreNullWhenNotRequired() {
this.service.executeNotRequired(null);
assertPathVariable("id", null);
}
@Test
void shouldIgnoreEmptyOptionalWhenNotRequired() {
this.service.executeOptionalNotRequired(Optional.empty());
assertPathVariable("id", null);
}
@Test
void shouldResolvePathVariablesFromMap() {
this.service.executeValueMap(Map.of("id", "test"));
void mapOfVariables() {
this.service.executeMap(Map.of("id", "test"));
assertPathVariable("id", "test");
}
@Test
void shouldResolvePathVariableFromOptionalMapValue() {
this.service.executeOptionalValueMap(Map.of("id", Optional.of("test")));
void mapOfVariablesIsNull() {
assertThatIllegalArgumentException().isThrownBy(() -> this.service.executeMap(null));
}
@Test
void mapOfVariablesHasOptionalValue() {
this.service.executeMapWithOptionalValue(Map.of("id", Optional.of("test")));
assertPathVariable("id", "test");
}
@Test
void shouldIgnoreNullMapValue() {
this.service.executeValueMap(null);
assertThat(getActualUriVariables()).isEmpty();
}
@Test
void shouldThrowExceptionForEmptyOptionalMapValue() {
assertThatIllegalArgumentException()
.isThrownBy(() -> this.service.executeOptionalValueMap(Map.of("id", Optional.empty())));
void mapOfVariablesHasOptionalEmpty() {
this.service.executeMapWithOptionalValue(Map.of("id", Optional.empty()));
assertPathVariable("id", null);
}
@SuppressWarnings("SameParameterValue")
private void assertPathVariable(String name, @Nullable String expectedValue) {
assertThat(getActualUriVariables().get(name)).isEqualTo(expectedValue);
}
private Map<String, String> getActualUriVariables() {
return this.clientAdapter.getRequestValues().getUriVariables();
assertThat(this.clientAdapter.getRequestValues().getUriVariables().get(name))
.isEqualTo(expectedValue);
}
@@ -151,6 +131,12 @@ class PathVariableArgumentResolverTests {
@GetExchange
void execute(@PathVariable String id);
@GetExchange
void execute(@PathVariable Object id);
@GetExchange
void executeNamed(@PathVariable(name = "id") String employeeId);
@GetExchange
void executeNotRequired(@Nullable @PathVariable(required = false) String id);
@@ -158,28 +144,10 @@ class PathVariableArgumentResolverTests {
void executeOptional(@PathVariable Optional<Boolean> id);
@GetExchange
void executeOptionalNotRequired(@PathVariable(required = false) Optional<String> id);
void executeMap(@Nullable @PathVariable Map<String, String> map);
@GetExchange
void executeNamedWithValue(@Nullable @PathVariable(name = "test", value = "id") String employeeId);
@GetExchange
void executeNamed(@PathVariable(name = "id") String employeeId);
@GetExchange
void executeValueNamed(@PathVariable("id") String employeeId);
@GetExchange
void execute(@PathVariable Object id);
@GetExchange
void execute(@PathVariable Boolean id);
@GetExchange
void executeValueMap(@Nullable @PathVariable Map<String, String> map);
@GetExchange
void executeOptionalValueMap(@PathVariable Map<String, Optional<String>> map);
void executeMapWithOptionalValue(@PathVariable Map<String, Optional<String>> map);
}
}

109
spring-web/src/test/java/org/springframework/web/service/invoker/RequestHeaderArgumentResolverTests.java
View File

@@ -23,8 +23,8 @@ import java.util.Optional;
import org.apache.groovy.util.Maps;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.lang.Nullable;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.service.annotation.GetExchange;
@@ -56,43 +56,25 @@ class RequestHeaderArgumentResolverTests {
assertRequestHeaders("id", "true");
}
@Test
void namedHeader() {
this.service.executeNamed("test");
assertRequestHeaders("id", "test");
}
@Test
void listHeader() {
this.service.execute(List.of("test1", Boolean.TRUE, "test3"));
this.service.executeList(List.of("test1", Boolean.TRUE, "test3"));
assertRequestHeaders("multiValueHeader", "test1", "true", "test3");
}
@Test
void arrayHeader() {
this.service.execute("test1", Boolean.FALSE, "test3");
this.service.executeArray("test1", Boolean.FALSE, "test3");
assertRequestHeaders("multiValueHeader", "test1", "false", "test3");
}
@Test
void mapHeader() {
this.service.executeMap(Maps.of("header1", "true", "header2", "false"));
assertRequestHeaders("header1", "true");
assertRequestHeaders("header2", "false");
}
@Test
void mapHeaderNull() {
this.service.executeMap(null);
assertThat(getActualHeaders()).isEmpty();
}
@Test
void mapWithOptional() {
this.service.executeOptionalMapValue(Map.of("id", Optional.of("test")));
void namedHeader() {
this.service.executeNamed("test");
assertRequestHeaders("id", "test");
}
@SuppressWarnings("ConstantConditions")
@Test
void nullHeaderRequired() {
assertThatIllegalArgumentException().isThrownBy(() -> this.service.executeString(null));
@@ -101,18 +83,23 @@ class RequestHeaderArgumentResolverTests {
@Test
void nullHeaderNotRequired() {
this.service.executeNotRequired(null);
assertThat(getActualHeaders().get("id")).isNull();
assertRequestHeaders("id");
}
@Test
void nullHeaderWithDefaultValue() {
this.service.executeWithDefaultValue(null);
assertRequestHeaders("id", "default");
}
@Test
void optional() {
void optionalStringHeader() {
this.service.executeOptional(Optional.of("test"));
assertRequestHeaders("id", "test");
}
@Test
void optionalWithConversion() {
void optionalObjectHeader() {
this.service.executeOptional(Optional.of(Boolean.TRUE));
assertRequestHeaders("id", "true");
}
@@ -120,27 +107,41 @@ class RequestHeaderArgumentResolverTests {
@Test
void optionalEmpty() {
this.service.executeOptional(Optional.empty());
assertThat(getActualHeaders().get("id")).isNull();
assertRequestHeaders("id");
}
@Test
void defaultValueWithNull() {
this.service.executeWithDefaultValue(null);
assertRequestHeaders("id", "default");
}
@Test
void defaultValueWithOptional() {
void optionalEmpthyWithDefaultValue() {
this.service.executeOptionalWithDefaultValue(Optional.empty());
assertRequestHeaders("id", "default");
}
private void assertRequestHeaders(String key, String... values) {
assertThat(getActualHeaders().get(key)).containsOnly(values);
@Test
void mapOfHeaders() {
this.service.executeMap(Maps.of("header1", "true", "header2", "false"));
assertRequestHeaders("header1", "true");
assertRequestHeaders("header2", "false");
}
private HttpHeaders getActualHeaders() {
return this.clientAdapter.getRequestValues().getHeaders();
@Test
void mapOfHeadersIsNull() {
assertThatIllegalArgumentException().isThrownBy(() -> this.service.executeMap(null));
}
@Test
void mapOfHeadersHasOptionalValue() {
this.service.executeMapWithOptionalValue(Map.of("id", Optional.of("test")));
assertRequestHeaders("id", "test");
}
private void assertRequestHeaders(String key, String... values) {
List<String> actualValues = this.clientAdapter.getRequestValues().getHeaders().get(key);
if (ObjectUtils.isEmpty(values)) {
assertThat(actualValues).isNull();
}
else {
assertThat(actualValues).containsOnly(values);
}
}
@@ -148,38 +149,38 @@ class RequestHeaderArgumentResolverTests {
private interface Service {
@GetExchange
void executeString(@Nullable @RequestHeader String id);
void executeString(@RequestHeader String id);
@GetExchange
void execute(@RequestHeader Object id);
@GetExchange
void executeList(@RequestHeader List<Object> multiValueHeader);
@GetExchange
void executeArray(@RequestHeader Object... multiValueHeader);
@GetExchange
void executeNamed(@RequestHeader(name = "id") String employeeId);
@GetExchange
void execute(@RequestHeader List<Object> multiValueHeader);
@GetExchange
void execute(@RequestHeader Object... multiValueHeader);
@GetExchange
void executeMap(@Nullable @RequestHeader Map<String, String> id);
@GetExchange
void executeOptionalMapValue(@RequestHeader Map<String, Optional<String>> headers);
@GetExchange
void executeNotRequired(@Nullable @RequestHeader(required = false) String id);
@GetExchange
void executeOptional(@RequestHeader Optional<Object> id);
void executeWithDefaultValue(@Nullable @RequestHeader(defaultValue = "default") String id);
@GetExchange
void executeWithDefaultValue(@Nullable @RequestHeader(defaultValue = "default") String id);
void executeOptional(@RequestHeader Optional<Object> id);
@GetExchange
void executeOptionalWithDefaultValue(@RequestHeader(defaultValue = "default") Optional<Object> id);
@GetExchange
void executeMap(@Nullable @RequestHeader Map<String, String> id);
@GetExchange
void executeMapWithOptionalValue(@RequestHeader Map<String, Optional<String>> headers);
}
}