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

Align web.reactive.function with WebClient

Browse Source 
This commit changes web.reactive.function to reflect the introduction of
the new WebClient. Changes include:

- Request -> ServerRequest
- Response -> ServerResponse
- FilterFunction -> HandlerFilterFunction
- StrategiesSupplier -> HandlerStrategies
This commit is contained in:
Arjen Poutsma
2016-10-20 12:12:15 +02:00
parent 0cfb6b37f2
commit 7e907c1e83
29 changed files with 327 additions and 307 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/DefaultRequestTests.java → spring-web-reactive/src/test/java/org/springframework/web/reactive/function/DefaultServerRequestTests.java
View File

@@ -57,7 +57,7 @@ import static org.springframework.http.codec.BodyExtractors.toMono;
/**
* @author Arjen Poutsma
*/
public class DefaultRequestTests {
public class DefaultServerRequestTests {
private ServerHttpRequest mockRequest;
@@ -65,9 +65,9 @@ public class DefaultRequestTests {
private ServerWebExchange mockExchange;
private StrategiesSupplier mockStrategiesSupplier;
private HandlerStrategies mockHandlerStrategies;
private DefaultRequest defaultRequest;
private DefaultServerRequest defaultRequest;
@Before
public void createMocks() {
@@ -77,9 +77,9 @@ public class DefaultRequestTests {
mockExchange = mock(ServerWebExchange.class);
when(mockExchange.getRequest()).thenReturn(mockRequest);
when(mockExchange.getResponse()).thenReturn(mockResponse);
mockStrategiesSupplier = mock(StrategiesSupplier.class);
mockHandlerStrategies = mock(HandlerStrategies.class);
defaultRequest = new DefaultRequest(mockExchange, mockStrategiesSupplier);
defaultRequest = new DefaultServerRequest(mockExchange, mockHandlerStrategies);
}
@Test
@@ -149,7 +149,7 @@ public class DefaultRequestTests {
when(mockRequest.getHeaders()).thenReturn(httpHeaders);
Request.Headers headers = defaultRequest.headers();
ServerRequest.Headers headers = defaultRequest.headers();
assertEquals(accept, headers.accept());
assertEquals(acceptCharset, headers.acceptCharset());
assertEquals(OptionalLong.of(contentLength), headers.contentLength());
@@ -171,7 +171,7 @@ public class DefaultRequestTests {
Set<HttpMessageReader<?>> messageReaders = Collections
.singleton(new DecoderHttpMessageReader<String>(new StringDecoder()));
when(mockStrategiesSupplier.messageReaders()).thenReturn(messageReaders::stream);
when(mockHandlerStrategies.messageReaders()).thenReturn(messageReaders::stream);
Mono<String> resultMono = defaultRequest.body(toMono(String.class));
assertEquals("foo", resultMono.block());

64
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/DefaultResponseBuilderTests.java → spring-web-reactive/src/test/java/org/springframework/web/reactive/function/DefaultServerResponseBuilderTests.java
View File

@@ -61,137 +61,137 @@ import static org.mockito.Mockito.when;
/**
* @author Arjen Poutsma
*/
public class DefaultResponseBuilderTests {
public class DefaultServerResponseBuilderTests {
@Test
public void from() throws Exception {
Response<Void> other = Response.ok().header("foo", "bar").build();
Response<Void> result = Response.from(other).build();
ServerResponse<Void> other = ServerResponse.ok().header("foo", "bar").build();
ServerResponse<Void> result = ServerResponse.from(other).build();
assertEquals(HttpStatus.OK, result.statusCode());
assertEquals("bar", result.headers().getFirst("foo"));
}
@Test
public void status() throws Exception {
Response<Void> result = Response.status(HttpStatus.CREATED).build();
ServerResponse<Void> result = ServerResponse.status(HttpStatus.CREATED).build();
assertEquals(HttpStatus.CREATED, result.statusCode());
}
@Test
public void statusInt() throws Exception {
Response<Void> result = Response.status(201).build();
ServerResponse<Void> result = ServerResponse.status(201).build();
assertEquals(HttpStatus.CREATED, result.statusCode());
}
@Test
public void ok() throws Exception {
Response<Void> result = Response.ok().build();
ServerResponse<Void> result = ServerResponse.ok().build();
assertEquals(HttpStatus.OK, result.statusCode());
}
@Test
public void created() throws Exception {
URI location = URI.create("http://example.com");
Response<Void> result = Response.created(location).build();
ServerResponse<Void> result = ServerResponse.created(location).build();
assertEquals(HttpStatus.CREATED, result.statusCode());
assertEquals(location, result.headers().getLocation());
}
@Test
public void accepted() throws Exception {
Response<Void> result = Response.accepted().build();
ServerResponse<Void> result = ServerResponse.accepted().build();
assertEquals(HttpStatus.ACCEPTED, result.statusCode());
}
@Test
public void noContent() throws Exception {
Response<Void> result = Response.noContent().build();
ServerResponse<Void> result = ServerResponse.noContent().build();
assertEquals(HttpStatus.NO_CONTENT, result.statusCode());
}
@Test
public void badRequest() throws Exception {
Response<Void> result = Response.badRequest().build();
ServerResponse<Void> result = ServerResponse.badRequest().build();
assertEquals(HttpStatus.BAD_REQUEST, result.statusCode());
}
@Test
public void notFound() throws Exception {
Response<Void> result = Response.notFound().build();
ServerResponse<Void> result = ServerResponse.notFound().build();
assertEquals(HttpStatus.NOT_FOUND, result.statusCode());
}
@Test
public void unprocessableEntity() throws Exception {
Response<Void> result = Response.unprocessableEntity().build();
ServerResponse<Void> result = ServerResponse.unprocessableEntity().build();
assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, result.statusCode());
}
@Test
public void allow() throws Exception {
Response<Void> result = Response.ok().allow(HttpMethod.GET).build();
ServerResponse<Void> result = ServerResponse.ok().allow(HttpMethod.GET).build();
assertEquals(Collections.singleton(HttpMethod.GET), result.headers().getAllow());
}
@Test
public void contentLength() throws Exception {
Response<Void> result = Response.ok().contentLength(42).build();
ServerResponse<Void> result = ServerResponse.ok().contentLength(42).build();
assertEquals(42, result.headers().getContentLength());
}
@Test
public void contentType() throws Exception {
Response<Void> result = Response.ok().contentType(MediaType.APPLICATION_JSON).build();
ServerResponse<Void> result = ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).build();
assertEquals(MediaType.APPLICATION_JSON, result.headers().getContentType());
}
@Test
public void eTag() throws Exception {
Response<Void> result = Response.ok().eTag("foo").build();
ServerResponse<Void> result = ServerResponse.ok().eTag("foo").build();
assertEquals("\"foo\"", result.headers().getETag());
}
@Test
public void lastModified() throws Exception {
ZonedDateTime now = ZonedDateTime.now();
Response<Void> result = Response.ok().lastModified(now).build();
ServerResponse<Void> result = ServerResponse.ok().lastModified(now).build();
assertEquals(now.toInstant().toEpochMilli()/1000, result.headers().getLastModified()/1000);
}
@Test
public void cacheControlTag() throws Exception {
Response<Void> result = Response.ok().cacheControl(CacheControl.noCache()).build();
ServerResponse<Void> result = ServerResponse.ok().cacheControl(CacheControl.noCache()).build();
assertEquals("no-cache", result.headers().getCacheControl());
}
@Test
public void varyBy() throws Exception {
Response<Void> result = Response.ok().varyBy("foo").build();
ServerResponse<Void> result = ServerResponse.ok().varyBy("foo").build();
assertEquals(Collections.singletonList("foo"), result.headers().getVary());
}
@Test
public void statusCode() throws Exception {
HttpStatus statusCode = HttpStatus.ACCEPTED;
Response<Void> result = Response.status(statusCode).build();
ServerResponse<Void> result = ServerResponse.status(statusCode).build();
assertSame(statusCode, result.statusCode());
}
@Test
public void headers() throws Exception {
HttpHeaders headers = new HttpHeaders();
Response<Void> result = Response.ok().headers(headers).build();
ServerResponse<Void> result = ServerResponse.ok().headers(headers).build();
assertEquals(headers, result.headers());
}
@Test
public void build() throws Exception {
Response<Void> result = Response.status(201).header("MyKey", "MyValue").build();
ServerResponse<Void> result = ServerResponse.status(201).header("MyKey", "MyValue").build();
ServerWebExchange exchange = mock(ServerWebExchange.class);
MockServerHttpResponse response = new MockServerHttpResponse();
when(exchange.getResponse()).thenReturn(response);
StrategiesSupplier strategies = mock(StrategiesSupplier.class);
HandlerStrategies strategies = mock(HandlerStrategies.class);
result.writeTo(exchange, strategies).block();
assertEquals(201, response.getStatusCode().value());
@@ -203,12 +203,12 @@ public class DefaultResponseBuilderTests {
@Test
public void buildVoidPublisher() throws Exception {
Mono<Void> mono = Mono.empty();
Response<Mono<Void>> result = Response.ok().build(mono);
ServerResponse<Mono<Void>> result = ServerResponse.ok().build(mono);
ServerWebExchange exchange = mock(ServerWebExchange.class);
MockServerHttpResponse response = new MockServerHttpResponse();
when(exchange.getResponse()).thenReturn(response);
StrategiesSupplier strategies = mock(StrategiesSupplier.class);
HandlerStrategies strategies = mock(HandlerStrategies.class);
result.writeTo(exchange, strategies).block();
assertNull(response.getBody());
@@ -227,7 +227,7 @@ public class DefaultResponseBuilderTests {
return response.writeWith(Mono.just(buffer));
};
Response<String> result = Response.ok().body(writer, supplier);
ServerResponse<String> result = ServerResponse.ok().body(BodyInserter.of(writer, supplier));
assertEquals(body, result.body());
MockServerHttpRequest request =
@@ -239,7 +239,7 @@ public class DefaultResponseBuilderTests {
List<HttpMessageWriter<?>> messageWriters = new ArrayList<>();
messageWriters.add(new EncoderHttpMessageWriter<CharSequence>(new CharSequenceEncoder()));
StrategiesSupplier strategies = mock(StrategiesSupplier.class);
HandlerStrategies strategies = mock(HandlerStrategies.class);
when(strategies.messageWriters()).thenReturn(messageWriters::stream);
result.writeTo(exchange, strategies).block();
@@ -249,7 +249,7 @@ public class DefaultResponseBuilderTests {
@Test
public void render() throws Exception {
Map<String, Object> model = Collections.singletonMap("foo", "bar");
Response<Rendering> result = Response.ok().render("view", model);
ServerResponse<Rendering> result = ServerResponse.ok().render("view", model);
assertEquals("view", result.body().name());
assertEquals(model, result.body().model());
@@ -265,7 +265,7 @@ public class DefaultResponseBuilderTests {
List<ViewResolver> viewResolvers = new ArrayList<>();
viewResolvers.add(viewResolver);
StrategiesSupplier mockConfig = mock(StrategiesSupplier.class);
HandlerStrategies mockConfig = mock(HandlerStrategies.class);
when(mockConfig.viewResolvers()).thenReturn(viewResolvers::stream);
result.writeTo(exchange, mockConfig).block();
@@ -273,11 +273,11 @@ public class DefaultResponseBuilderTests {
@Test
public void renderObjectArray() throws Exception {
Response<Rendering> result =
Response.ok().render("name", this, Collections.emptyList(), "foo");
ServerResponse<Rendering> result =
ServerResponse.ok().render("name", this, Collections.emptyList(), "foo");
Map<String, Object> model = result.body().model();
assertEquals(2, model.size());
assertEquals(this, model.get("defaultResponseBuilderTests"));
assertEquals(this, model.get("defaultServerResponseBuilderTests"));
assertEquals("foo", model.get("string"));
}

16
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/DispatcherHandlerIntegrationTests.java
View File

@@ -45,7 +45,7 @@ import org.springframework.web.reactive.HandlerAdapter;
import org.springframework.web.reactive.HandlerMapping;
import org.springframework.web.reactive.config.WebReactiveConfigurationSupport;
import org.springframework.web.reactive.function.support.HandlerFunctionAdapter;
import org.springframework.web.reactive.function.support.ResponseResultHandler;
import org.springframework.web.reactive.function.support.ServerResponseResultHandler;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
@@ -121,7 +121,7 @@ public class DispatcherHandlerIntegrationTests extends AbstractHttpHandlerIntegr
public HandlerMapping handlerMapping(RouterFunction<?> routerFunction,
ApplicationContext applicationContext) {
return RouterFunctions.toHandlerMapping(routerFunction,
new StrategiesSupplier() {
new HandlerStrategies() {
@Override
public Supplier<Stream<HttpMessageReader<?>>> messageReaders() {
return () -> getMessageReaders().stream();
@@ -147,22 +147,22 @@ public class DispatcherHandlerIntegrationTests extends AbstractHttpHandlerIntegr
}
@Bean
public ResponseResultHandler responseResultHandler() {
return new ResponseResultHandler();
public ServerResponseResultHandler responseResultHandler() {
return new ServerResponseResultHandler();
}
}
private static class PersonHandler {
public Response<Publisher<Person>> mono(Request request) {
public ServerResponse<Publisher<Person>> mono(ServerRequest request) {
Person person = new Person("John");
return Response.ok().body(fromPublisher(Mono.just(person), Person.class));
return ServerResponse.ok().body(fromPublisher(Mono.just(person), Person.class));
}
public Response<Publisher<Person>> flux(Request request) {
public ServerResponse<Publisher<Person>> flux(ServerRequest request) {
Person person1 = new Person("John");
Person person2 = new Person("Jane");
return Response.ok().body(
return ServerResponse.ok().body(
fromPublisher(Flux.just(person1, person2), Person.class));
}

8
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/StrategiesSupplierTests.java → spring-web-reactive/src/test/java/org/springframework/web/reactive/function/HandlerStrategiesTests.java
View File

@@ -41,11 +41,11 @@ import static org.junit.Assert.*;
/**
* @author Arjen Poutsma
*/
public class StrategiesSupplierTests {
public class HandlerStrategiesTests {
@Test
public void empty() {
StrategiesSupplier strategies = StrategiesSupplier.empty().build();
HandlerStrategies strategies = HandlerStrategies.empty().build();
assertEquals(Optional.empty(), strategies.messageReaders().get().findFirst());
assertEquals(Optional.empty(), strategies.messageWriters().get().findFirst());
assertEquals(Optional.empty(), strategies.viewResolvers().get().findFirst());
@@ -56,7 +56,7 @@ public class StrategiesSupplierTests {
HttpMessageReader<?> messageReader = new DummyMessageReader();
HttpMessageWriter<?> messageWriter = new DummyMessageWriter();
StrategiesSupplier strategies = StrategiesSupplier.of(
HandlerStrategies strategies = HandlerStrategies.of(
() -> Stream.of(messageReader),
() -> Stream.of(messageWriter),
null);
@@ -77,7 +77,7 @@ public class StrategiesSupplierTests {
applicationContext.registerSingleton("messageReader", DummyMessageReader.class);
applicationContext.refresh();
StrategiesSupplier strategies = StrategiesSupplier.of(applicationContext);
HandlerStrategies strategies = HandlerStrategies.of(applicationContext);
assertTrue(strategies.messageReaders().get()
.allMatch(r -> r instanceof DummyMessageReader));
assertTrue(strategies.messageWriters().get()

10
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/HeadersWrapperTest.java
View File

@@ -30,7 +30,7 @@ import org.junit.Test;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpRange;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.support.RequestWrapper;
import org.springframework.web.reactive.function.support.ServerRequestWrapper;
import static org.junit.Assert.assertSame;
import static org.mockito.Mockito.mock;
@@ -41,15 +41,15 @@ import static org.mockito.Mockito.when;
*/
public class HeadersWrapperTest {
private Request.Headers mockHeaders;
private ServerRequest.Headers mockHeaders;
private RequestWrapper.HeadersWrapper wrapper;
private ServerRequestWrapper.HeadersWrapper wrapper;
@Before
public void createWrapper() {
mockHeaders = mock(Request.Headers.class);
wrapper = new RequestWrapper.HeadersWrapper(mockHeaders);
mockHeaders = mock(ServerRequest.Headers.class);
wrapper = new ServerRequestWrapper.HeadersWrapper(mockHeaders);
}
@Test

16
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/MockRequest.java → spring-web-reactive/src/test/java/org/springframework/web/reactive/function/MockServerRequest.java
View File

@@ -42,7 +42,7 @@ import org.springframework.util.MultiValueMap;
/**
* @author Arjen Poutsma
*/
public class MockRequest<T> implements Request {
public class MockServerRequest<T> implements ServerRequest {
private final HttpMethod method;
@@ -58,7 +58,7 @@ public class MockRequest<T> implements Request {
private final Map<String, String> pathVariables;
private MockRequest(HttpMethod method, URI uri,
private MockServerRequest(HttpMethod method, URI uri,
MockHeaders headers, T body, Map<String, Object> attributes,
MultiValueMap<String, String> queryParams,
Map<String, String> pathVariables) {
@@ -134,9 +134,9 @@ public class MockRequest<T> implements Request {
Builder<T> pathVariables(Map<String, String> pathVariables);
MockRequest<T> body(T body);
MockServerRequest<T> body(T body);
MockRequest<Void> build();
MockServerRequest<Void> build();
}
@@ -231,15 +231,15 @@ public class MockRequest<T> implements Request {
}
@Override
public MockRequest<T> body(T body) {
public MockServerRequest<T> body(T body) {
this.body = body;
return new MockRequest<T>(this.method, this.uri, this.headers, this.body,
return new MockServerRequest<T>(this.method, this.uri, this.headers, this.body,
this.attributes, this.queryParams, this.pathVariables);
}
@Override
public MockRequest<Void> build() {
return new MockRequest<Void>(this.method, this.uri, this.headers, null,
public MockServerRequest<Void> build() {
return new MockServerRequest<Void>(this.method, this.uri, this.headers, null,
this.attributes, this.queryParams, this.pathVariables);
}

12
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/PublisherHandlerFunctionIntegrationTests.java
View File

@@ -97,20 +97,20 @@ public class PublisherHandlerFunctionIntegrationTests
private static class PersonHandler {
public Response<Publisher<Person>> mono(Request request) {
public ServerResponse<Publisher<Person>> mono(ServerRequest request) {
Person person = new Person("John");
return Response.ok().body(fromPublisher(Mono.just(person), Person.class));
return ServerResponse.ok().body(fromPublisher(Mono.just(person), Person.class));
}
public Response<Publisher<Person>> postMono(Request request) {
public ServerResponse<Publisher<Person>> postMono(ServerRequest request) {
Mono<Person> personMono = request.body(toMono(Person.class));
return Response.ok().body(fromPublisher(personMono, Person.class));
return ServerResponse.ok().body(fromPublisher(personMono, Person.class));
}
public Response<Publisher<Person>> flux(Request request) {
public ServerResponse<Publisher<Person>> flux(ServerRequest request) {
Person person1 = new Person("John");
Person person2 = new Person("Jane");
return Response.ok().body(
return ServerResponse.ok().body(
fromPublisher(Flux.just(person1, person2), Person.class));
}

6
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/RequestPredicateTests.java
View File

@@ -32,7 +32,7 @@ public class RequestPredicateTests {
RequestPredicate predicate2 = request -> true;
RequestPredicate predicate3 = request -> false;
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
assertTrue(predicate1.and(predicate2).test(request));
assertTrue(predicate2.and(predicate1).test(request));
assertFalse(predicate1.and(predicate3).test(request));
@@ -43,7 +43,7 @@ public class RequestPredicateTests {
RequestPredicate predicate = request -> false;
RequestPredicate negated = predicate.negate();
MockRequest mockRequest = MockRequest.builder().build();
MockServerRequest mockRequest = MockServerRequest.builder().build();
assertTrue(negated.test(mockRequest));
predicate = request -> true;
@@ -58,7 +58,7 @@ public class RequestPredicateTests {
RequestPredicate predicate2 = request -> false;
RequestPredicate predicate3 = request -> false;
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
assertTrue(predicate1.or(predicate2).test(request));
assertTrue(predicate2.or(predicate1).test(request));
assertFalse(predicate2.or(predicate3).test(request));

37
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/RequestPredicatesTests.java
View File

@@ -35,7 +35,7 @@ public class RequestPredicatesTests {
@Test
public void all() throws Exception {
RequestPredicate predicate = RequestPredicates.all();
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
assertTrue(predicate.test(request));
}
@@ -43,10 +43,10 @@ public class RequestPredicatesTests {
public void method() throws Exception {
HttpMethod httpMethod = HttpMethod.GET;
RequestPredicate predicate = RequestPredicates.method(httpMethod);
MockRequest request = MockRequest.builder().method(httpMethod).build();
MockServerRequest request = MockServerRequest.builder().method(httpMethod).build();
assertTrue(predicate.test(request));
request = MockRequest.builder().method(HttpMethod.POST).build();
request = MockServerRequest.builder().method(HttpMethod.POST).build();
assertFalse(predicate.test(request));
}
@@ -55,31 +55,31 @@ public class RequestPredicatesTests {
URI uri = URI.create("http://localhost/path");
RequestPredicate predicate = RequestPredicates.GET("/p*");
MockRequest request = MockRequest.builder().method(HttpMethod.GET).uri(uri).build();
MockServerRequest request = MockServerRequest.builder().method(HttpMethod.GET).uri(uri).build();
assertTrue(predicate.test(request));
predicate = RequestPredicates.HEAD("/p*");
request = MockRequest.builder().method(HttpMethod.HEAD).uri(uri).build();
request = MockServerRequest.builder().method(HttpMethod.HEAD).uri(uri).build();
assertTrue(predicate.test(request));
predicate = RequestPredicates.POST("/p*");
request = MockRequest.builder().method(HttpMethod.POST).uri(uri).build();
request = MockServerRequest.builder().method(HttpMethod.POST).uri(uri).build();
assertTrue(predicate.test(request));
predicate = RequestPredicates.PUT("/p*");
request = MockRequest.builder().method(HttpMethod.PUT).uri(uri).build();
request = MockServerRequest.builder().method(HttpMethod.PUT).uri(uri).build();
assertTrue(predicate.test(request));
predicate = RequestPredicates.PATCH("/p*");
request = MockRequest.builder().method(HttpMethod.PATCH).uri(uri).build();
request = MockServerRequest.builder().method(HttpMethod.PATCH).uri(uri).build();
assertTrue(predicate.test(request));
predicate = RequestPredicates.DELETE("/p*");
request = MockRequest.builder().method(HttpMethod.DELETE).uri(uri).build();
request = MockServerRequest.builder().method(HttpMethod.DELETE).uri(uri).build();
assertTrue(predicate.test(request));
predicate = RequestPredicates.OPTIONS("/p*");
request = MockRequest.builder().method(HttpMethod.OPTIONS).uri(uri).build();
request = MockServerRequest.builder().method(HttpMethod.OPTIONS).uri(uri).build();
assertTrue(predicate.test(request));
}
@@ -88,10 +88,10 @@ public class RequestPredicatesTests {
public void path() throws Exception {
URI uri = URI.create("http://localhost/path");
RequestPredicate predicate = RequestPredicates.path("/p*");
MockRequest request = MockRequest.builder().uri(uri).build();
MockServerRequest request = MockServerRequest.builder().uri(uri).build();
assertTrue(predicate.test(request));
request = MockRequest.builder().build();
request = MockServerRequest.builder().build();
assertFalse(predicate.test(request));
}
@@ -104,10 +104,10 @@ public class RequestPredicatesTests {
return headers.header(name).equals(
Collections.singletonList(value));
});
MockRequest request = MockRequest.builder().header(name, value).build();
MockServerRequest request = MockServerRequest.builder().header(name, value).build();
assertTrue(predicate.test(request));
request = MockRequest.builder().build();
request = MockServerRequest.builder().build();
assertFalse(predicate.test(request));
}
@@ -115,10 +115,11 @@ public class RequestPredicatesTests {
public void contentType() throws Exception {
MediaType json = MediaType.APPLICATION_JSON;
RequestPredicate predicate = RequestPredicates.contentType(json);
MockRequest request = MockRequest.builder().header("Content-Type", json.toString()).build();
MockServerRequest
request = MockServerRequest.builder().header("Content-Type", json.toString()).build();
assertTrue(predicate.test(request));
request = MockRequest.builder().build();
request = MockServerRequest.builder().build();
assertFalse(predicate.test(request));
}
@@ -126,10 +127,10 @@ public class RequestPredicatesTests {
public void accept() throws Exception {
MediaType json = MediaType.APPLICATION_JSON;
RequestPredicate predicate = RequestPredicates.accept(json);
MockRequest request = MockRequest.builder().header("Accept", json.toString()).build();
MockServerRequest request = MockServerRequest.builder().header("Accept", json.toString()).build();
assertTrue(predicate.test(request));
request = MockRequest.builder().build();
request = MockServerRequest.builder().build();
assertFalse(predicate.test(request));
}

20
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/RouterFunctionTests.java
View File

@@ -33,14 +33,14 @@ public class RouterFunctionTests {
@Test
public void andSame() throws Exception {
HandlerFunction<Void> handlerFunction = request -> Response.ok().build();
HandlerFunction<Void> handlerFunction = request -> ServerResponse.ok().build();
RouterFunction<Void> routerFunction1 = request -> Optional.empty();
RouterFunction<Void> routerFunction2 = request -> Optional.of(handlerFunction);
RouterFunction<Void> result = routerFunction1.andSame(routerFunction2);
assertNotNull(result);
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
Optional<HandlerFunction<Void>> resultHandlerFunction = result.route(request);
assertTrue(resultHandlerFunction.isPresent());
assertEquals(handlerFunction, resultHandlerFunction.get());
@@ -48,14 +48,14 @@ public class RouterFunctionTests {
@Test
public void and() throws Exception {
HandlerFunction<String> handlerFunction = request -> Response.ok().body(fromObject("42"));
HandlerFunction<String> handlerFunction = request -> ServerResponse.ok().body(fromObject("42"));
RouterFunction<Void> routerFunction1 = request -> Optional.empty();
RouterFunction<String> routerFunction2 = request -> Optional.of(handlerFunction);
RouterFunction<?> result = routerFunction1.and(routerFunction2);
assertNotNull(result);
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
Optional<? extends HandlerFunction<?>> resultHandlerFunction = result.route(request);
assertTrue(resultHandlerFunction.isPresent());
assertEquals(handlerFunction, resultHandlerFunction.get());
@@ -63,21 +63,21 @@ public class RouterFunctionTests {
@Test
public void filter() throws Exception {
HandlerFunction<String> handlerFunction = request -> Response.ok().body(fromObject("42"));
HandlerFunction<String> handlerFunction = request -> ServerResponse.ok().body(fromObject("42"));
RouterFunction<String> routerFunction = request -> Optional.of(handlerFunction);
FilterFunction<String, Integer> filterFunction = (request, next) -> {
Response<String> response = next.handle(request);
HandlerFilterFunction<String, Integer> filterFunction = (request, next) -> {
ServerResponse<String> response = next.handle(request);
int i = Integer.parseInt(response.body());
return Response.ok().body(fromObject(i));
return ServerResponse.ok().body(fromObject(i));
};
RouterFunction<Integer> result = routerFunction.filter(filterFunction);
assertNotNull(result);
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
Optional<? extends HandlerFunction<?>> resultHandlerFunction = result.route(request);
assertTrue(resultHandlerFunction.isPresent());
Response<?> resultResponse = resultHandlerFunction.get().handle(request);
ServerResponse<?> resultResponse = resultHandlerFunction.get().handle(request);
assertEquals(42, resultResponse.body());
}

26
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/RouterFunctionsTests.java
View File

@@ -48,9 +48,9 @@ public class RouterFunctionsTests {
@Test
public void routeMatch() throws Exception {
HandlerFunction<Void> handlerFunction = request -> Response.ok().build();
HandlerFunction<Void> handlerFunction = request -> ServerResponse.ok().build();
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
RequestPredicate requestPredicate = mock(RequestPredicate.class);
when(requestPredicate.test(request)).thenReturn(true);
@@ -64,9 +64,9 @@ public class RouterFunctionsTests {
@Test
public void routeNoMatch() throws Exception {
HandlerFunction<Void> handlerFunction = request -> Response.ok().build();
HandlerFunction<Void> handlerFunction = request -> ServerResponse.ok().build();
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
RequestPredicate requestPredicate = mock(RequestPredicate.class);
when(requestPredicate.test(request)).thenReturn(false);
@@ -79,10 +79,10 @@ public class RouterFunctionsTests {
@Test
public void subrouteMatch() throws Exception {
HandlerFunction<Void> handlerFunction = request -> Response.ok().build();
HandlerFunction<Void> handlerFunction = request -> ServerResponse.ok().build();
RouterFunction<Void> routerFunction = request -> Optional.of(handlerFunction);
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
RequestPredicate requestPredicate = mock(RequestPredicate.class);
when(requestPredicate.test(request)).thenReturn(true);
@@ -96,10 +96,10 @@ public class RouterFunctionsTests {
@Test
public void subrouteNoMatch() throws Exception {
HandlerFunction<Void> handlerFunction = request -> Response.ok().build();
HandlerFunction<Void> handlerFunction = request -> ServerResponse.ok().build();
RouterFunction<Void> routerFunction = request -> Optional.of(handlerFunction);
MockRequest request = MockRequest.builder().build();
MockServerRequest request = MockServerRequest.builder().build();
RequestPredicate requestPredicate = mock(RequestPredicate.class);
when(requestPredicate.test(request)).thenReturn(false);
@@ -112,7 +112,7 @@ public class RouterFunctionsTests {
@Test
public void toHttpHandler() throws Exception {
StrategiesSupplier strategies = mock(StrategiesSupplier.class);
HandlerStrategies strategies = mock(HandlerStrategies.class);
when(strategies.messageReaders()).thenReturn(
() -> Collections.<HttpMessageReader<?>>emptyList().stream());
when(strategies.messageWriters()).thenReturn(
@@ -120,15 +120,15 @@ public class RouterFunctionsTests {
when(strategies.viewResolvers()).thenReturn(
() -> Collections.<ViewResolver>emptyList().stream());
Request request = mock(Request.class);
Response response = mock(Response.class);
ServerRequest request = mock(ServerRequest.class);
ServerResponse response = mock(ServerResponse.class);
when(response.writeTo(any(ServerWebExchange.class), eq(strategies))).thenReturn(Mono.empty());
HandlerFunction handlerFunction = mock(HandlerFunction.class);
when(handlerFunction.handle(any(Request.class))).thenReturn(response);
when(handlerFunction.handle(any(ServerRequest.class))).thenReturn(response);
RouterFunction routerFunction = mock(RouterFunction.class);
when(routerFunction.route(any(Request.class))).thenReturn(Optional.of(handlerFunction));
when(routerFunction.route(any(ServerRequest.class))).thenReturn(Optional.of(handlerFunction));
RequestPredicate requestPredicate = mock(RequestPredicate.class);
when(requestPredicate.test(request)).thenReturn(false);

12
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/SseHandlerFunctionIntegrationTests.java
View File

@@ -129,25 +129,25 @@ public class SseHandlerFunctionIntegrationTests
private static class SseHandler {
public Response<Publisher<String>> string(Request request) {
public ServerResponse<Publisher<String>> string(ServerRequest request) {
Flux<String> flux = Flux.interval(Duration.ofMillis(100)).map(l -> "foo " + l).take(2);
return Response.ok().body(fromServerSentEvents(flux, String.class));
return ServerResponse.ok().body(fromServerSentEvents(flux, String.class));
}
public Response<Publisher<Person>> person(Request request) {
public ServerResponse<Publisher<Person>> person(ServerRequest request) {
Flux<Person> flux = Flux.interval(Duration.ofMillis(100))
.map(l -> new Person("foo " + l)).take(2);
return Response.ok().body(fromServerSentEvents(flux, Person.class));
return ServerResponse.ok().body(fromServerSentEvents(flux, Person.class));
}
public Response<Publisher<ServerSentEvent<String>>> sse(Request request) {
public ServerResponse<Publisher<ServerSentEvent<String>>> sse(ServerRequest request) {
Flux<ServerSentEvent<String>> flux = Flux.interval(Duration.ofMillis(100))
.map(l -> ServerSentEvent.<String>builder().data("foo")
.id(Long.toString(l))
.comment("bar")
.build()).take(2);
return Response.ok().body(fromServerSentEvents(flux));
return ServerResponse.ok().body(fromServerSentEvents(flux));
}
}

16
spring-web-reactive/src/test/java/org/springframework/web/reactive/function/RequestWrapperTests.java → spring-web-reactive/src/test/java/org/springframework/web/reactive/function/support/ServerRequestWrapperTests.java
View File

@@ -14,7 +14,7 @@
* limitations under the License.
*/
package org.springframework.web.reactive.function;
package org.springframework.web.reactive.function.support;
import java.net.URI;
import java.util.Collections;
@@ -26,7 +26,7 @@ import org.junit.Before;
import org.junit.Test;
import org.springframework.http.HttpMethod;
import org.springframework.web.reactive.function.support.RequestWrapper;
import org.springframework.web.reactive.function.ServerRequest;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
@@ -36,16 +36,16 @@ import static org.mockito.Mockito.when;
/**
* @author Arjen Poutsma
*/
public class RequestWrapperTests {
public class ServerRequestWrapperTests {
private Request mockRequest;
private ServerRequest mockRequest;
private RequestWrapper wrapper;
private ServerRequestWrapper wrapper;
@Before
public void createWrapper() {
mockRequest = mock(Request.class);
wrapper = new RequestWrapper(mockRequest);
mockRequest = mock(ServerRequest.class);
wrapper = new ServerRequestWrapper(mockRequest);
}
@Test
@@ -79,7 +79,7 @@ public class RequestWrapperTests {
@Test
public void headers() throws Exception {
Request.Headers headers = mock(Request.Headers.class);
ServerRequest.Headers headers = mock(ServerRequest.Headers.class);
when(mockRequest.headers()).thenReturn(headers);
assertSame(headers, wrapper.headers());