More tests for async flow.

Author: Thanh Nguyen

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/FeignClientOverrideDefaultsTests.java

@@ -224,7 +224,7 @@ interface FooAsyncClient {
 
 	}
 
-	@FeignClient(name = "barAsync", url = "https://barAsync",
+	@FeignClient(name = "barAsync", url = "https://barAsync", decode404 = true,
 			configuration = BarAsyncConfiguration.class, asynchronous = true)
 	interface BarAsyncClient {
 

spring-cloud-openfeign-core/src/test/java/org/springframework/cloud/openfeign/FeignClientUsingPropertiesTests.java

@@ -28,6 +28,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -76,6 +77,7 @@
  * @author Eko Kurniawan Khannedy
  * @author Olga Maciaszek-Sharma
  * @author Ilia Ilinykh
+ * @author Nguyen Ky Thanh
  */
 @SuppressWarnings("FieldMayBeFinal")
 @RunWith(SpringJUnit4ClassRunner.class)
@@ -142,62 +144,124 @@ public FooClient fooClient() {
 				"http://localhost:" + port);
 	}
 
+	public FooAsyncClient fooAsyncClient() {
+		fooFactoryBean.setApplicationContext(applicationContext);
+		return (FooAsyncClient) fooFactoryBean.asyncFeign(context)
+				.target(FooAsyncClient.class, "http://localhost:" + port);
+	}
+
 	public BarClient barClient() {
 		barFactoryBean.setApplicationContext(applicationContext);
 		return barFactoryBean.feign(context).target(BarClient.class,
 				"http://localhost:" + port);
 	}
 
+	public BarAsyncClient barAsyncClient() {
+		barFactoryBean.setApplicationContext(applicationContext);
+		return (BarAsyncClient) barFactoryBean.asyncFeign(context)
+				.target(BarAsyncClient.class, "http://localhost:" + port);
+	}
+
 	public UnwrapClient unwrapClient() {
 		unwrapFactoryBean.setApplicationContext(applicationContext);
 		return unwrapFactoryBean.feign(context).target(UnwrapClient.class,
 				"http://localhost:" + port);
 	}
 
+	public UnwrapAsyncClient unwrapAsyncClient() {
+		unwrapFactoryBean.setApplicationContext(applicationContext);
+		return (UnwrapAsyncClient) unwrapFactoryBean.asyncFeign(context)
+				.target(UnwrapAsyncClient.class, "http://localhost:" + port);
+	}
+
 	public FormClient formClient() {
 		formFactoryBean.setApplicationContext(applicationContext);
 		return formFactoryBean.feign(context).target(FormClient.class,
 				"http://localhost:" + port);
 	}
 
+	public FormAsyncClient formAsyncClient() {
+		formFactoryBean.setApplicationContext(applicationContext);
+		return (FormAsyncClient) formFactoryBean.asyncFeign(context)
+				.target(FormAsyncClient.class, "http://localhost:" + port);
+	}
+
 	@Test
 	public void testFoo() {
 		String response = fooClient().foo();
 		assertThat(response).isEqualTo("OK");
 	}
 
+	@Test
+	public void testFooAsync() {
+		String response = fooAsyncClient().foo();
+		assertThat(response).isEqualTo("OK");
+	}
+
 	@Test(expected = RetryableException.class)
 	public void testBar() {
 		barClient().bar();
 		fail("it should timeout");
 	}
 
+	@Test(expected = CompletionException.class)
+	public void testBarAsync() {
+		barAsyncClient().bar();
+		fail("it should timeout");
+	}
+
 	@Test(expected = SocketTimeoutException.class)
 	public void testUnwrap() throws Exception {
 		unwrapClient().unwrap();
 		fail("it should timeout");
 	}
 
+	@Test(expected = CompletionException.class)
+	public void testUnwrapAsync() throws Exception {
+		unwrapAsyncClient().unwrap();
+		fail("it should timeout");
+	}
+
 	@Test
 	public void testForm() {
 		Map<String, String> request = Collections.singletonMap("form", "Data");
 		String response = formClient().form(request);
 		assertThat(response).isEqualTo("Data");
 	}
 
+	@Test
+	public void testAsyncForm() {
+		Map<String, String> request = Collections.singletonMap("form", "Data");
+		String response = formAsyncClient().form(request);
+		assertThat(response).isEqualTo("Data");
+	}
+
 	@Test
 	public void testSingleValue() {
 		List<String> response = singleValueClient().singleValue();
 		assertThat(response).isEqualTo(Arrays.asList("header", "parameter"));
 	}
 
+	@Test
+	public void testSingleValueAsync() {
+		List<String> response = singleValueAsyncClient().singleValue();
+		assertThat(response).isEqualTo(Arrays.asList("header", "parameter"));
+	}
+
 	@Test
 	public void testMultipleValue() {
 		List<String> response = multipleValueClient().multipleValue();
 		assertThat(response).isEqualTo(
 				Arrays.asList("header1", "header2", "parameter1", "parameter2"));
 	}
 
+	@Test
+	public void testMultipleValueAsync() {
+		List<String> response = multipleValueAsyncClient().multipleValue();
+		assertThat(response).isEqualTo(
+				Arrays.asList("header1", "header2", "parameter1", "parameter2"));
+	}
+
 	public SingleValueClient singleValueClient() {
 		this.defaultHeadersAndQuerySingleParamsFeignClientFactoryBean
 				.setApplicationContext(this.applicationContext);
@@ -206,6 +270,14 @@ public SingleValueClient singleValueClient() {
 				.target(SingleValueClient.class, "http://localhost:" + this.port);
 	}
 
+	public SingleValueAsyncClient singleValueAsyncClient() {
+		this.defaultHeadersAndQuerySingleParamsFeignClientFactoryBean
+				.setApplicationContext(this.applicationContext);
+		return (SingleValueAsyncClient) this.defaultHeadersAndQuerySingleParamsFeignClientFactoryBean
+				.asyncFeign(this.context)
+				.target(SingleValueAsyncClient.class, "http://localhost:" + this.port);
+	}
+
 	public MultipleValueClient multipleValueClient() {
 		this.defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean
 				.setApplicationContext(this.applicationContext);
@@ -214,6 +286,14 @@ public MultipleValueClient multipleValueClient() {
 				.target(MultipleValueClient.class, "http://localhost:" + this.port);
 	}
 
+	public MultipleValueAsyncClient multipleValueAsyncClient() {
+		this.defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean
+				.setApplicationContext(this.applicationContext);
+		return (MultipleValueAsyncClient) this.defaultHeadersAndQueryMultipleParamsFeignClientFactoryBean
+				.asyncFeign(this.context)
+				.target(MultipleValueAsyncClient.class, "http://localhost:" + this.port);
+	}
+
 	@Test
 	public void readTimeoutShouldWorkWhenConnectTimeoutNotSet() {
 		FeignClientFactoryBean readTimeoutFactoryBean = new FeignClientFactoryBean();
@@ -230,6 +310,23 @@ public void readTimeoutShouldWorkWhenConnectTimeoutNotSet() {
 		assertThat(options.connectTimeoutMillis()).isEqualTo(5000);
 	}
 
+	@Test
+	public void readTimeoutAsyncShouldWorkWhenConnectTimeoutNotSet() {
+		FeignClientFactoryBean readTimeoutFactoryBean = new FeignClientFactoryBean();
+		readTimeoutFactoryBean.setContextId("readTimeout");
+		readTimeoutFactoryBean.setType(FeignClientFactoryBean.class);
+		readTimeoutFactoryBean.setApplicationContext(applicationContext);
+
+		TimeoutAsyncClient client = (TimeoutAsyncClient) readTimeoutFactoryBean
+				.asyncFeign(context)
+				.target(TimeoutAsyncClient.class, "http://localhost:" + port);
+
+		Request.Options options = getAsyncRequestOptions((Proxy) client);
+
+		assertThat(options.readTimeoutMillis()).isEqualTo(1000);
+		assertThat(options.connectTimeoutMillis()).isEqualTo(5000);
+	}
+
 	@Test
 	public void connectTimeoutShouldWorkWhenReadTimeoutNotSet() {
 		FeignClientFactoryBean readTimeoutFactoryBean = new FeignClientFactoryBean();
@@ -246,6 +343,23 @@ public void connectTimeoutShouldWorkWhenReadTimeoutNotSet() {
 		assertThat(options.readTimeoutMillis()).isEqualTo(5000);
 	}
 
+	@Test
+	public void connectTimeoutAsyncShouldWorkWhenReadTimeoutNotSet() {
+		FeignClientFactoryBean readTimeoutFactoryBean = new FeignClientFactoryBean();
+		readTimeoutFactoryBean.setContextId("connectTimeout");
+		readTimeoutFactoryBean.setType(FeignClientFactoryBean.class);
+		readTimeoutFactoryBean.setApplicationContext(applicationContext);
+
+		TimeoutAsyncClient client = (TimeoutAsyncClient) readTimeoutFactoryBean
+				.asyncFeign(context)
+				.target(TimeoutAsyncClient.class, "http://localhost:" + port);
+
+		Request.Options options = getAsyncRequestOptions((Proxy) client);
+
+		assertThat(options.connectTimeoutMillis()).isEqualTo(1000);
+		assertThat(options.readTimeoutMillis()).isEqualTo(5000);
+	}
+
 	@Test
 	public void shouldSetFollowRedirects() {
 		FeignClientFactoryBean testFactoryBean = new FeignClientFactoryBean();
@@ -261,6 +375,22 @@ public void shouldSetFollowRedirects() {
 		assertThat(options.isFollowRedirects()).isFalse();
 	}
 
+	@Test
+	public void shouldSetFollowRedirectsAsync() {
+		FeignClientFactoryBean testFactoryBean = new FeignClientFactoryBean();
+		testFactoryBean.setContextId("test");
+		testFactoryBean.setType(FeignClientFactoryBean.class);
+		testFactoryBean.setApplicationContext(applicationContext);
+
+		TimeoutAsyncClient client = (TimeoutAsyncClient) testFactoryBean
+				.asyncFeign(context)
+				.target(TimeoutAsyncClient.class, "http://localhost:" + port);
+
+		Request.Options options = getAsyncRequestOptions((Proxy) client);
+
+		assertThat(options.isFollowRedirects()).isFalse();
+	}
+
 	private Request.Options getRequestOptions(Proxy client) {
 		Object invocationHandler = ReflectionTestUtils.getField(client, "h");
 		Map<Method, InvocationHandlerFactory.MethodHandler> dispatch = (Map<Method, InvocationHandlerFactory.MethodHandler>) ReflectionTestUtils
@@ -270,27 +400,60 @@ private Request.Options getRequestOptions(Proxy client) {
 				"options");
 	}
 
+	private Request.Options getAsyncRequestOptions(Proxy client) {
+		Object asyncInvocationHandler = ReflectionTestUtils.getField(client, "h");
+		Object instance = ReflectionTestUtils.getField(asyncInvocationHandler,
+				"instance");
+		Object invocationHandler = ReflectionTestUtils.getField(instance, "h");
+		Map<Method, InvocationHandlerFactory.MethodHandler> dispatch = (Map<Method, InvocationHandlerFactory.MethodHandler>) ReflectionTestUtils
+				.getField(Objects.requireNonNull(invocationHandler), "dispatch");
+		Method key = new ArrayList<>(dispatch.keySet()).get(0);
+		return (Request.Options) ReflectionTestUtils.getField(dispatch.get(key),
+				"options");
+	}
+
 	protected interface FooClient {
 
 		@GetMapping(path = "/foo")
 		String foo();
 
 	}
 
+	protected interface FooAsyncClient {
+
+		@GetMapping(path = "/foo")
+		String foo();
+
+	}
+
 	protected interface BarClient {
 
 		@GetMapping(path = "/bar")
 		String bar();
 
 	}
 
+	protected interface BarAsyncClient {
+
+		@GetMapping(path = "/bar")
+		String bar();
+
+	}
+
 	protected interface UnwrapClient {
 
 		@GetMapping(path = "/bar") // intentionally /bar
 		String unwrap() throws IOException;
 
 	}
 
+	protected interface UnwrapAsyncClient {
+
+		@GetMapping(path = "/bar") // intentionally /bar
+		String unwrap() throws IOException;
+
+	}
+
 	protected interface FormClient {
 
 		@RequestMapping(value = "/form", method = RequestMethod.POST,
@@ -299,27 +462,56 @@ protected interface FormClient {
 
 	}
 
+	protected interface FormAsyncClient {
+
+		@RequestMapping(value = "/form", method = RequestMethod.POST,
+				consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE)
+		String form(Map<String, String> form);
+
+	}
+
 	protected interface SingleValueClient {
 
 		@GetMapping(path = "/singleValue")
 		List<String> singleValue();
 
 	}
 
+	protected interface SingleValueAsyncClient {
+
+		@GetMapping(path = "/singleValue")
+		List<String> singleValue();
+
+	}
+
 	protected interface MultipleValueClient {
 
 		@GetMapping(path = "/multipleValue")
 		List<String> multipleValue();
 
 	}
 
+	protected interface MultipleValueAsyncClient {
+
+		@GetMapping(path = "/multipleValue")
+		List<String> multipleValue();
+
+	}
+
 	protected interface TimeoutClient {
 
 		@GetMapping("/timeouts")
 		String timeouts();
 
 	}
 
+	protected interface TimeoutAsyncClient {
+
+		@GetMapping("/timeouts")
+		String timeouts();
+
+	}
+
 	@Configuration(proxyBeanMethods = false)
 	@EnableAutoConfiguration
 	@RestController