Alternative approach to MVC handling

Doesn't rely on manipulating the FunctionCatalog, and does type
conversion/coercion in the MVC layer.

spring-cloud-function-web/src/test/java/org/springframework/cloud/function/mvc/MvcRestApplicationTests.java

@@ -0,0 +1,397 @@
+/*
+ * Copyright 2016-2017 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.cloud.function.mvc;
+
+import java.net.URI;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.context.embedded.LocalServerPort;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.cloud.function.mvc.MvcRestApplicationTests.TestConfiguration;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.RequestEntity;
+import org.springframework.http.ResponseEntity;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.util.StringUtils;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * Tests for vanilla MVC handling (no function layer). Validates the MVC customizations
+ * that are added in this project independently of the specific concerns of function.
+ * 
+ * @author Dave Syer
+ *
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = TestConfiguration.class, webEnvironment = WebEnvironment.RANDOM_PORT)
+public class MvcRestApplicationTests {
+
+	private static final MediaType EVENT_STREAM = MediaType.valueOf("text/event-stream");
+	@LocalServerPort
+	private int port;
+	@Autowired
+	private TestRestTemplate rest;
+	@Autowired
+	private TestConfiguration test;
+
+	@Before
+	public void init() {
+		test.list.clear();
+	}
+
+	@Test
+	public void wordsSSE() throws Exception {
+		assertThat(rest.exchange(
+				RequestEntity.get(new URI("/words")).accept(EVENT_STREAM).build(),
+				String.class).getBody()).isEqualTo(sse("foo", "bar"));
+	}
+
+	@Test
+	public void wordsJson() throws Exception {
+		assertThat(rest
+				.exchange(RequestEntity.get(new URI("/words"))
+						.accept(MediaType.APPLICATION_JSON).build(), String.class)
+				.getBody()).isEqualTo("[\"foo\",\"bar\"]");
+	}
+
+	@Test
+	@Ignore("Fix error handling")
+	public void errorJson() throws Exception {
+		assertThat(rest
+				.exchange(RequestEntity.get(new URI("/bang"))
+						.accept(MediaType.APPLICATION_JSON).build(), String.class)
+				.getBody()).isEqualTo("[\"foo\"]");
+	}
+
+	@Test
+	public void words() throws Exception {
+		ResponseEntity<String> result = rest
+				.exchange(RequestEntity.get(new URI("/words")).build(), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(result.getBody()).isEqualTo("[\"foo\",\"bar\"]");
+	}
+
+	@Test
+	public void foos() throws Exception {
+		ResponseEntity<String> result = rest
+				.exchange(RequestEntity.get(new URI("/foos")).build(), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(result.getBody())
+				.isEqualTo("[{\"value\":\"foo\"},{\"value\":\"bar\"}]");
+	}
+
+	@Test
+	public void getMore() throws Exception {
+		ResponseEntity<String> result = rest
+				.exchange(RequestEntity.get(new URI("/get/more")).build(), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(result.getBody()).isEqualTo("[\"foo\",\"bar\"]");
+	}
+
+	@Test
+	@Ignore("Should this even work? Or do we need to be explicit about the JSON?")
+	public void updates() throws Exception {
+		ResponseEntity<String> result = rest.exchange(
+				RequestEntity.post(new URI("/updates")).body("one\ntwo"), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
+		assertThat(test.list).hasSize(2);
+		assertThat(result.getBody()).isEqualTo("onetwo");
+	}
+
+	@Test
+	public void updatesJson() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/updates")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"one\",\"two\"]"), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
+		assertThat(test.list).hasSize(2);
+		assertThat(result.getBody()).isEqualTo("[\"one\",\"two\"]");
+	}
+
+	@Test
+	public void addFoos() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/addFoos")).contentType(MediaType.APPLICATION_JSON)
+				.body("[{\"value\":\"foo\"},{\"value\":\"bar\"}]"), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
+		assertThat(test.list).hasSize(2);
+		assertThat(result.getBody())
+				.isEqualTo("[{\"value\":\"foo\"},{\"value\":\"bar\"}]");
+	}
+
+	@Test
+	public void timeout() throws Exception {
+		assertThat(rest
+				.exchange(RequestEntity.get(new URI("/timeout")).build(), String.class)
+				.getBody()).isEqualTo("[\"foo\"]");
+	}
+
+	@Test
+	public void emptyJson() throws Exception {
+		assertThat(rest
+				.exchange(RequestEntity.get(new URI("/empty"))
+						.accept(MediaType.APPLICATION_JSON).build(), String.class)
+				.getBody()).isEqualTo("[]");
+	}
+
+	@Test
+	public void sentences() throws Exception {
+		assertThat(rest
+				.exchange(RequestEntity.get(new URI("/sentences")).build(), String.class)
+				.getBody()).isEqualTo("[[\"go\",\"home\"],[\"come\",\"back\"]]");
+	}
+
+	@Test
+	public void sentencesAcceptAny() throws Exception {
+		assertThat(rest.exchange(
+				RequestEntity.get(new URI("/sentences")).accept(MediaType.ALL).build(),
+				String.class).getBody())
+						.isEqualTo("[[\"go\",\"home\"],[\"come\",\"back\"]]");
+	}
+
+	@Test
+	public void sentencesAcceptJson() throws Exception {
+		ResponseEntity<String> result = rest
+				.exchange(
+						RequestEntity.get(new URI("/sentences"))
+								.accept(MediaType.APPLICATION_JSON).build(),
+						String.class);
+		assertThat(result.getBody()).isEqualTo("[[\"go\",\"home\"],[\"come\",\"back\"]]");
+		assertThat(result.getHeaders().getContentType())
+				.isGreaterThanOrEqualTo(MediaType.APPLICATION_JSON);
+	}
+
+	@Test
+	public void uppercase() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/uppercase")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class);
+		assertThat(result.getBody()).isEqualTo("[\"[FOO]\",\"[BAR]\"]");
+	}
+
+	@Test
+	public void uppercaseFoos() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/upFoos")).contentType(MediaType.APPLICATION_JSON)
+				.body("[{\"value\":\"foo\"},{\"value\":\"bar\"}]"), String.class);
+		assertThat(result.getBody())
+				.isEqualTo("[{\"value\":\"FOO\"},{\"value\":\"BAR\"}]");
+	}
+
+	@Test
+	public void transform() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/transform")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class);
+		assertThat(result.getBody()).isEqualTo("[\"[FOO]\",\"[BAR]\"]");
+	}
+
+	@Test
+	public void postMore() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/post/more")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class);
+		assertThat(result.getBody()).isEqualTo("[\"[FOO]\",\"[BAR]\"]");
+	}
+
+	@Test
+	public void uppercaseGet() {
+		assertThat(rest.getForObject("/uppercase/foo", String.class)).isEqualTo("[FOO]");
+	}
+
+	@Test
+	public void convertGet() {
+		assertThat(rest.getForObject("/wrap/123", String.class)).isEqualTo("..123..");
+	}
+
+	@Test
+	public void convertGetJson() throws Exception {
+		assertThat(rest
+				.exchange(RequestEntity.get(new URI("/entity/321"))
+						.accept(MediaType.APPLICATION_JSON).build(), String.class)
+				.getBody()).isEqualTo("{\"value\":321}");
+	}
+
+	@Test
+	public void uppercaseJsonStream() throws Exception {
+		assertThat(rest
+				.exchange(RequestEntity.post(new URI("/maps"))
+						.contentType(MediaType.APPLICATION_JSON)
+						.body("[{\"value\":\"foo\"},{\"value\":\"bar\"}]"), String.class)
+				.getBody()).isEqualTo("[{\"value\":\"FOO\"},{\"value\":\"BAR\"}]");
+	}
+
+	@Test
+	public void uppercaseSSE() throws Exception {
+		assertThat(rest.exchange(RequestEntity.post(new URI("/uppercase"))
+				.accept(EVENT_STREAM).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class).getBody())
+						.isEqualTo(sse("[FOO]", "[BAR]"));
+	}
+
+	private String sse(String... values) {
+		return "data:" + StringUtils.arrayToDelimitedString(values, "\n\ndata:") + "\n\n";
+	}
+
+	@EnableAutoConfiguration
+	@RestController
+	@Configuration
+	public static class TestConfiguration {
+
+		private List<String> list = new ArrayList<>();
+
+		@PostMapping({ "/uppercase", "/transform", "/post/more" })
+		public Flux<?> uppercase(@RequestBody List<String> flux) {
+			return Flux.fromIterable(flux).log()
+					.map(value -> "[" + value.trim().toUpperCase() + "]");
+		}
+
+		@PostMapping("/upFoos")
+		public Flux<Foo> upFoos(@RequestBody List<Foo> list) {
+			return Flux.fromIterable(list).log()
+					.map(value -> new Foo(value.getValue().trim().toUpperCase()));
+		}
+
+		@GetMapping("/uppercase/{id}")
+		public Mono<?> uppercaseGet(@PathVariable String id) {
+			return Mono.just(id).map(value -> "[" + value.trim().toUpperCase() + "]");
+		}
+
+		@PostMapping("/wrap")
+		public Flux<?> wrap(@RequestBody Flux<Integer> flux) {
+			return flux.log().map(value -> ".." + value + "..");
+		}
+
+		@GetMapping("/wrap/{id}")
+		public Mono<?> wrapGet(@PathVariable int id) {
+			return Mono.just(id).log().map(value -> ".." + value + "..");
+		}
+
+		@GetMapping("/entity/{id}")
+		public Mono<Map<String, Object>> entity(@PathVariable Integer id) {
+			return Mono.just(id).log()
+					.map(value -> Collections.singletonMap("value", value));
+		}
+
+		@PostMapping("/maps")
+		public Flux<Map<String, String>> maps(
+				@RequestBody List<Map<String, String>> flux) {
+			return Flux.fromIterable(flux).map(value -> {
+				value.put("value", value.get("value").trim().toUpperCase());
+				return value;
+			});
+		}
+
+		@GetMapping({ "/words", "/get/more" })
+		public Flux<Object> words() {
+			return Flux.fromArray(new String[] { "foo", "bar" });
+		}
+
+		@GetMapping("/foos")
+		public Flux<Foo> foos() {
+			return Flux.just(new Foo("foo"), new Foo("bar"));
+		}
+
+		@PostMapping("/updates")
+		@ResponseStatus(HttpStatus.ACCEPTED)
+		public Flux<?> updates(@RequestBody List<String> list) {
+			Flux<String> flux = Flux.fromIterable(list).cache();
+			flux.subscribe(value -> this.list.add(value));
+			return flux;
+		}
+
+		@PostMapping("/addFoos")
+		@ResponseStatus(HttpStatus.ACCEPTED)
+		public Flux<Foo> addFoos(@RequestBody List<Foo> list) {
+			Flux<Foo> flux = Flux.fromIterable(list).cache();
+			flux.subscribe(value -> this.list.add(value.getValue()));
+			return flux;
+		}
+
+		@GetMapping("/bang")
+		public Flux<?> bang() {
+			return Flux.fromArray(new String[] { "foo", "bar" }).map(value -> {
+				if (value.equals("bar")) {
+					throw new RuntimeException("Bar");
+				}
+				return value;
+			});
+		}
+
+		@GetMapping("/empty")
+		public Flux<?> empty() {
+			return Flux.fromIterable(Collections.emptyList());
+		}
+
+		@GetMapping("/timeout")
+		public Flux<?> timeout() {
+			return Flux.defer(() -> Flux.<String>create(emitter -> {
+				emitter.next("foo");
+			}).timeout(Duration.ofMillis(100L), Flux.empty()));
+		}
+
+		@GetMapping("/sentences")
+		public Flux<List<String>> sentences() {
+			return Flux.just(Arrays.asList("go", "home"), Arrays.asList("come", "back"));
+		}
+
+	}
+
+	public static class Foo {
+		private String value;
+
+		public Foo(String value) {
+			this.value = value;
+		}
+
+		Foo() {
+		}
+
+		public String getValue() {
+			return value;
+		}
+
+		public void setValue(String value) {
+			this.value = value;
+		}
+	}
+}

spring-cloud-function-web/src/test/java/org/springframework/cloud/function/web/PrefixTests.java

@@ -56,7 +56,7 @@ public class PrefixTests {
 		ResponseEntity<String> result = rest
 				.exchange(RequestEntity.get(new URI("/functions/words")).build(), String.class);
 		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
-		assertThat(result.getBody()).isEqualTo("foobar");
+		assertThat(result.getBody()).isEqualTo("[\"foo\",\"bar\"]");
 	}
 
 	@EnableAutoConfiguration

spring-cloud-function-web/src/test/java/org/springframework/cloud/function/web/RestApplicationTests.java

@@ -16,6 +16,7 @@
 package org.springframework.cloud.function.web;
 
 import java.net.URI;
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -32,6 +33,7 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.boot.context.embedded.LocalServerPort;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -57,7 +59,7 @@ import reactor.core.publisher.Flux;
 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
 public class RestApplicationTests {
 
-	private static final MediaType EVENT_STREAM = MediaType.valueOf("text/event-stream");
+	private static final MediaType EVENT_STREAM = MediaType.TEXT_EVENT_STREAM;
 	@LocalServerPort
 	private int port;
 	@Autowired
@@ -104,7 +106,26 @@ public class RestApplicationTests {
 		ResponseEntity<String> result = rest
 				.exchange(RequestEntity.get(new URI("/words")).build(), String.class);
 		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
-		assertThat(result.getBody()).isEqualTo("foobar");
+		assertThat(result.getBody()).isEqualTo("[\"foo\",\"bar\"]");
+	}
+
+	@Test
+	public void foos() throws Exception {
+		ResponseEntity<String> result = rest
+				.exchange(RequestEntity.get(new URI("/foos")).build(), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(result.getBody())
+				.isEqualTo("[{\"value\":\"foo\"},{\"value\":\"bar\"}]");
+	}
+
+	@Test
+	public void qualifierFoos() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/foos")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
+		assertThat(result.getBody())
+				.isEqualTo("[{\"value\":\"[FOO]\"},{\"value\":\"[BAR]\"}]");
 	}
 
 	@Test
@@ -112,7 +133,7 @@ public class RestApplicationTests {
 		ResponseEntity<String> result = rest
 				.exchange(RequestEntity.get(new URI("/get/more")).build(), String.class);
 		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
-		assertThat(result.getBody()).isEqualTo("foobar");
+		assertThat(result.getBody()).isEqualTo("[\"foo\",\"bar\"]");
 	}
 
 	@Test
@@ -120,10 +141,11 @@ public class RestApplicationTests {
 		ResponseEntity<String> result = rest
 				.exchange(RequestEntity.get(new URI("/bareWords")).build(), String.class);
 		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK);
-		assertThat(result.getBody()).isEqualTo("foobar");
+		assertThat(result.getBody()).isEqualTo("[\"foo\",\"bar\"]");
 	}
 
 	@Test
+	@Ignore("Should this even work? Or do we need to be explicit about the JSON?")
 	public void updates() throws Exception {
 		ResponseEntity<String> result = rest.exchange(
 				RequestEntity.post(new URI("/updates")).body("one\ntwo"), String.class);
@@ -133,13 +155,34 @@ public class RestApplicationTests {
 	}
 
 	@Test
-	public void bareUpdates() throws Exception {
-		ResponseEntity<String> result = rest.exchange(
-				RequestEntity.post(new URI("/bareUpdates")).body("one\ntwo"),
-				String.class);
+	public void updatesJson() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/updates")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"one\",\"two\"]"), String.class);
 		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
 		assertThat(test.list).hasSize(2);
-		assertThat(result.getBody()).isEqualTo("onetwo");
+		assertThat(result.getBody()).isEqualTo("[\"one\",\"two\"]");
+	}
+
+	@Test
+	public void addFoos() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/addFoos")).contentType(MediaType.APPLICATION_JSON)
+				.body("[{\"value\":\"foo\"},{\"value\":\"bar\"}]"), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
+		assertThat(test.list).hasSize(2);
+		assertThat(result.getBody())
+				.isEqualTo("[{\"value\":\"foo\"},{\"value\":\"bar\"}]");
+	}
+
+	@Test
+	public void bareUpdates() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/bareUpdates")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"one\",\"two\"]"), String.class);
+		assertThat(result.getStatusCode()).isEqualTo(HttpStatus.ACCEPTED);
+		assertThat(test.list).hasSize(2);
+		assertThat(result.getBody()).isEqualTo("[\"one\",\"two\"]");
 	}
 
 	@Test
@@ -162,7 +205,7 @@ public class RestApplicationTests {
 	public void sentences() throws Exception {
 		assertThat(rest
 				.exchange(RequestEntity.get(new URI("/sentences")).build(), String.class)
-				.getBody()).isEqualTo("[\"go\",\"home\"][\"come\",\"back\"]");
+				.getBody()).isEqualTo("[[\"go\",\"home\"],[\"come\",\"back\"]]");
 	}
 
 	@Test
@@ -170,7 +213,7 @@ public class RestApplicationTests {
 		assertThat(rest.exchange(
 				RequestEntity.get(new URI("/sentences")).accept(MediaType.ALL).build(),
 				String.class).getBody())
-						.isEqualTo("[\"go\",\"home\"][\"come\",\"back\"]");
+						.isEqualTo("[[\"go\",\"home\"],[\"come\",\"back\"]]");
 	}
 
 	@Test
@@ -182,7 +225,7 @@ public class RestApplicationTests {
 						String.class);
 		assertThat(result.getBody()).isEqualTo("[[\"go\",\"home\"],[\"come\",\"back\"]]");
 		assertThat(result.getHeaders().getContentType())
-				.isEqualTo(MediaType.APPLICATION_JSON);
+				.isGreaterThanOrEqualTo(MediaType.APPLICATION_JSON);
 	}
 
 	@Test
@@ -197,27 +240,46 @@ public class RestApplicationTests {
 	}
 
 	@Test
-	public void uppercase() {
-		assertThat(rest.postForObject("/uppercase", "foo\nbar", String.class))
-				.isEqualTo("[FOO][BAR]");
+	public void uppercase() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/uppercase")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class);
+		assertThat(result.getBody()).isEqualTo("[\"[FOO]\",\"[BAR]\"]");
 	}
 
 	@Test
-	public void bareUppercase() {
-		assertThat(rest.postForObject("/bareUppercase", "foo\nbar", String.class))
-				.isEqualTo("[FOO][BAR]");
+	public void uppercaseFoos() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				// TODO: does not require a content type header, but the plain MVC version
+				// does
+				.post(new URI("/upFoos")).contentType(MediaType.APPLICATION_JSON)
+				.body("[{\"value\":\"foo\"},{\"value\":\"bar\"}]"), String.class);
+		assertThat(result.getBody())
+				.isEqualTo("[{\"value\":\"FOO\"},{\"value\":\"BAR\"}]");
 	}
 
 	@Test
-	public void transform() {
-		assertThat(rest.postForObject("/transform", "foo\nbar", String.class))
-				.isEqualTo("[FOO][BAR]");
+	public void bareUppercase() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/bareUppercase")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class);
+		assertThat(result.getBody()).isEqualTo("[\"[FOO]\",\"[BAR]\"]");
 	}
 
 	@Test
-	public void postMore() {
-		assertThat(rest.postForObject("/post/more", "foo\nbar", String.class))
-				.isEqualTo("[FOO][BAR]");
+	public void transform() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/transform")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class);
+		assertThat(result.getBody()).isEqualTo("[\"[FOO]\",\"[BAR]\"]");
+	}
+
+	@Test
+	public void postMore() throws Exception {
+		ResponseEntity<String> result = rest.exchange(RequestEntity
+				.post(new URI("/post/more")).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class);
+		assertThat(result.getBody()).isEqualTo("[\"[FOO]\",\"[BAR]\"]");
 	}
 
 	@Test
@@ -237,7 +299,8 @@ public class RestApplicationTests {
 
 	@Test
 	public void supplierFirst() {
-		assertThat(rest.getForObject("/not/a/function", String.class)).isEqualTo("hello");
+		assertThat(rest.getForObject("/not/a/function", String.class))
+				.isEqualTo("[\"hello\"]");
 	}
 
 	@Test
@@ -256,26 +319,15 @@ public class RestApplicationTests {
 						// The new line in the middle is optional
 						.body("[{\"value\":\"foo\"},\n{\"value\":\"bar\"}]"),
 				String.class).getBody())
-						.isEqualTo("{\"value\":\"FOO\"}{\"value\":\"BAR\"}");
-	}
-
-	@Test
-	public void uppercaseJsonStream() throws Exception {
-		assertThat(rest
-				.exchange(RequestEntity.post(new URI("/maps"))
-						.contentType(MediaType.APPLICATION_JSON)
-						// TODO: make this work without newline separator
-						.body("{\"value\":\"foo\"}\n{\"value\":\"bar\"}"), String.class)
-				.getBody()).isEqualTo("{\"value\":\"FOO\"}{\"value\":\"BAR\"}");
+						.isEqualTo("[{\"value\":\"FOO\"},{\"value\":\"BAR\"}]");
 	}
 
 	@Test
 	public void uppercaseSSE() throws Exception {
-		assertThat(
-				rest.exchange(
-						RequestEntity.post(new URI("/uppercase")).accept(EVENT_STREAM)
-								.contentType(EVENT_STREAM).body(sse("foo", "bar")),
-						String.class).getBody()).isEqualTo(sse("[FOO]", "[BAR]"));
+		assertThat(rest.exchange(RequestEntity.post(new URI("/uppercase"))
+				.accept(EVENT_STREAM).contentType(MediaType.APPLICATION_JSON)
+				.body("[\"foo\",\"bar\"]"), String.class).getBody())
+						.isEqualTo(sse("[FOO]", "[BAR]"));
 	}
 
 	private String sse(String... values) {
@@ -299,6 +351,12 @@ public class RestApplicationTests {
 			return value -> "[" + value.trim().toUpperCase() + "]";
 		}
 
+		@Bean
+		public Function<Flux<Foo>, Flux<Foo>> upFoos() {
+			return flux -> flux.log()
+					.map(value -> new Foo(value.getValue().trim().toUpperCase()));
+		}
+
 		@Bean
 		public Function<Flux<Integer>, Flux<String>> wrap() {
 			return flux -> flux.log().map(value -> ".." + value + "..");
@@ -320,7 +378,18 @@ public class RestApplicationTests {
 
 		@Bean({ "words", "get/more" })
 		public Supplier<Flux<String>> words() {
-			return () -> Flux.fromArray(new String[] { "foo", "bar" });
+			return () -> Flux.just("foo", "bar");
+		}
+
+		@Bean
+		public Supplier<Flux<Foo>> foos() {
+			return () -> Flux.just(new Foo("foo"), new Foo("bar"));
+		}
+
+		@Bean
+		@Qualifier("foos")
+		public Function<String, Foo> qualifier() {
+			return value -> new Foo("[" + value.trim().toUpperCase() + "]");
 		}
 
 		@Bean
@@ -333,6 +402,11 @@ public class RestApplicationTests {
 			return flux -> flux.subscribe(value -> list.add(value));
 		}
 
+		@Bean
+		public Consumer<Flux<Foo>> addFoos() {
+			return flux -> flux.subscribe(value -> list.add(value.getValue()));
+		}
+
 		@Bean
 		public Consumer<String> bareUpdates() {
 			return value -> list.add(value);
@@ -365,9 +439,9 @@ public class RestApplicationTests {
 
 		@Bean
 		public Supplier<Flux<String>> timeout() {
-			return () -> Flux.create(emitter -> {
+			return () -> Flux.defer(() -> Flux.<String>create(emitter -> {
 				emitter.next("foo");
-			});
+			}).timeout(Duration.ofMillis(100L), Flux.empty()));
 		}
 
 		@Bean
@@ -378,4 +452,23 @@ public class RestApplicationTests {
 
 	}
 
+	public static class Foo {
+		private String value;
+
+		public Foo(String value) {
+			this.value = value;
+		}
+
+		Foo() {
+		}
+
+		public String getValue() {
+			return value;
+		}
+
+		public void setValue(String value) {
+			this.value = value;
+		}
+	}
+
 }

spring-cloud-function-web/src/test/java/org/springframework/cloud/function/web/flux/FluxHttpMessageConverterTests.java

@@ -1,108 +0,0 @@
-/*
- * Copyright 2012-2015 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.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.cloud.function.web.flux;
-
-import org.junit.Test;
-
-import org.springframework.http.MediaType;
-import org.springframework.mock.http.MockHttpInputMessage;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-import reactor.core.publisher.Flux;
-
-/**
- * @author Dave Syer
- *
- */
-public class FluxHttpMessageConverterTests {
-
-	private FluxHttpMessageConverter converter = new FluxHttpMessageConverter();
-
-	private Class<Flux<Object>> type = null;
-
-	@Test
-	public void newlines() throws Exception {
-		MockHttpInputMessage message = new MockHttpInputMessage("foo\nbar".getBytes());
-		assertThat(converter.read(type, message).collectList().block()).contains("foo",
-				"bar");
-	}
-
-	@Test
-	public void sse() throws Exception {
-		MockHttpInputMessage message = new MockHttpInputMessage(
-				"data:foo\n\ndata:bar".getBytes());
-		message.getHeaders().setContentType(MediaType.valueOf("text/event-stream"));
-		assertThat(converter.read(type, message).collectList().block()).contains("foo",
-				"bar");
-	}
-
-	@Test
-	public void jsonStream() throws Exception {
-		MockHttpInputMessage message = new MockHttpInputMessage(
-				"{\"value\":\"foo\"}{\"value\":\"barrier\"}".getBytes());
-		message.getHeaders().setContentType(MediaType.APPLICATION_JSON);
-		assertThat(converter.read(type, message).collectList().block())
-				.contains("{\"value\":\"foo\"}", "{\"value\":\"barrier\"}");
-	}
-
-	@Test
-	public void jsonStreamWhitespace() throws Exception {
-		MockHttpInputMessage message = new MockHttpInputMessage(
-				"{\"value\":\"foo\"} {\"value\":\"barrier\"}  ".getBytes());
-		message.getHeaders().setContentType(MediaType.APPLICATION_JSON);
-		assertThat(converter.read(type, message).collectList().block())
-				.contains("{\"value\":\"foo\"}", "{\"value\":\"barrier\"}");
-	}
-
-	@Test
-	public void jsonStreamNewline() throws Exception {
-		MockHttpInputMessage message = new MockHttpInputMessage(
-				"{\"value\":\"foo\"}\n{\"value\":\"barrier\"}".getBytes());
-		message.getHeaders().setContentType(MediaType.APPLICATION_JSON);
-		assertThat(converter.read(type, message).collectList().block())
-				.contains("{\"value\":\"foo\"}", "{\"value\":\"barrier\"}");
-	}
-
-	@Test
-	public void jsonArray() throws Exception {
-		MockHttpInputMessage message = new MockHttpInputMessage(
-				"[{\"value\":\"foo\"},{\"value\":\"barrier\"}]".getBytes());
-		message.getHeaders().setContentType(MediaType.APPLICATION_JSON);
-		assertThat(converter.read(type, message).collectList().block())
-				.contains("{\"value\":\"foo\"}", "{\"value\":\"barrier\"}");
-	}
-
-	@Test
-	public void jsonArrayWhitespace() throws Exception {
-		MockHttpInputMessage message = new MockHttpInputMessage(
-				"[{\"value\":\"foo\"}, {\"value\":\"barrier\"}]  ".getBytes());
-		message.getHeaders().setContentType(MediaType.APPLICATION_JSON);
-		assertThat(converter.read(type, message).collectList().block())
-				.contains("{\"value\":\"foo\"}", "{\"value\":\"barrier\"}");
-	}
-
-	@Test
-	public void jsonArrayNewline() throws Exception {
-		MockHttpInputMessage message = new MockHttpInputMessage(
-				"[{\"value\":\"foo\"},\n{\"value\":\"barrier\"}]".getBytes());
-		message.getHeaders().setContentType(MediaType.APPLICATION_JSON);
-		assertThat(converter.read(type, message).collectList().block())
-				.contains("{\"value\":\"foo\"}", "{\"value\":\"barrier\"}");
-	}
-
-}