Merge "Improve coverage of cadi-client"

2 files changed, 340 insertions, 25 deletions

diff --git a/cadi/client/src/main/java/org/onap/aaf/cadi/http/HClient.java b/cadi/client/src/main/java/org/onap/aaf/cadi/http/HClient.java
index 46099887..456184c3 100644
--- a/cadi/client/src/main/java/org/onap/aaf/cadi/http/HClient.java
+++ b/cadi/client/src/main/java/org/onap/aaf/cadi/http/HClient.java
@@ -28,6 +28,7 @@ import java.io.OutputStream;
 import java.io.Reader;
 import java.net.HttpURLConnection;
 import java.net.URI;
+import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.ArrayList;
 
@@ -121,18 +122,11 @@ public class HClient implements EClient<HttpURLConnection> {
 				}
 				pi.append(pathinfo);
 			}
-			URL url = new URI(
-					uri.getScheme(), 
-					uri.getUserInfo(),
-					uri.getHost(), 
-					uri.getPort(), 
-					pi==null?uri.getPath():pi.toString(), 
-					query,
-					fragment).toURL();
 			pathinfo=null;
 			query=null;
 			fragment=null;
-			huc = (HttpURLConnection) url.openConnection();
+			//huc = (HttpURLConnection) url.openConnection();
+			huc = getConnection(uri, pi);
 			huc.setRequestMethod(meth);
 			if(ss!=null) {
 				ss.setSecurity(huc); 
@@ -169,10 +163,21 @@ public class HClient implements EClient<HttpURLConnection> {
 		return connectTimeout;
 	}
 	
-	public abstract class HFuture<T> extends Future<T> {
+	protected HttpURLConnection getConnection(URI uri, StringBuilder pi) throws IOException, URISyntaxException {
+		URL url = new URI(
+				uri.getScheme(), 
+				uri.getUserInfo(),
+				uri.getHost(), 
+				uri.getPort(), 
+				pi==null?uri.getPath():pi.toString(), 
+				query,
+				fragment).toURL();
+		return (HttpURLConnection) url.openConnection();
+	}
+	
+ 	public abstract class HFuture<T> extends Future<T> {
 		protected HttpURLConnection huc;
 		protected int respCode;
-		protected String respMessage;
 		protected IOException exception;
 		protected StringBuilder errContent;
 	
@@ -258,10 +263,6 @@ public class HClient implements EClient<HttpURLConnection> {
 			return exception;
 		}
 	
-		public String respMessage() {
-			return respMessage;
-		}
-	
 		@Override
 		public String header(String tag) {
 			return huc.getHeaderField(tag);
@@ -285,9 +286,6 @@ public class HClient implements EClient<HttpURLConnection> {
 			public String body() {
 				if (errContent != null) {
 					return errContent.toString();
-	
-				} else if (respMessage != null) {
-					return respMessage;
 				}
 				return "";
 			}
@@ -314,8 +312,6 @@ public class HClient implements EClient<HttpURLConnection> {
 					return value;
 				} else if (errContent != null) {
 					return errContent.toString();
-				} else if (respMessage != null) {
-					return respMessage;
 				}
 				return "";
 			}
@@ -346,8 +342,6 @@ public class HClient implements EClient<HttpURLConnection> {
 					}
 				} else if (errContent != null) {
 					return errContent.toString();
-				} else if (respMessage != null) {
-					return respMessage;
 				}
 				return "";
 			}
@@ -369,8 +363,6 @@ public class HClient implements EClient<HttpURLConnection> {
 			public String body() {
 				if (errContent != null) {
 					return errContent.toString();
-				} else if (respMessage != null) {
-					return respMessage;
 				}
 				return Integer.toString(respCode);
 			}
@@ -419,7 +411,7 @@ public class HClient implements EClient<HttpURLConnection> {
 
 			@Override
 			public String body() {
-				return errContent==null?respMessage:errContent.toString();
+				return errContent==null?null:errContent.toString();
 			}
 		};
 	}
diff --git a/cadi/client/src/test/java/org/onap/aaf/cadi/http/test/JU_HClient.java b/cadi/client/src/test/java/org/onap/aaf/cadi/http/test/JU_HClient.java
new file mode 100644
index 00000000..0b4b8e78
--- /dev/null
+++ b/cadi/client/src/test/java/org/onap/aaf/cadi/http/test/JU_HClient.java
@@ -0,0 +1,323 @@
+/**
+ * ============LICENSE_START====================================================
+ * org.onap.aaf
+ * ===========================================================================
+ * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
+ * ===========================================================================
+ * 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.
+ * ============LICENSE_END====================================================
+ *
+ */
+
+package org.onap.aaf.cadi.http.test;
+
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.lang.reflect.Field;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletResponse;
+
+import static org.hamcrest.CoreMatchers.*;
+import org.junit.*;
+import org.mockito.*;
+import org.onap.aaf.cadi.CadiException;
+import org.onap.aaf.cadi.LocatorException;
+import org.onap.aaf.cadi.SecuritySetter;
+import org.onap.aaf.cadi.client.EClient.Transfer;
+import org.onap.aaf.cadi.client.Future;
+import org.onap.aaf.cadi.http.HClient;
+import org.onap.aaf.cadi.http.HClient.HFuture;
+import org.onap.aaf.misc.env.APIException;
+import org.onap.aaf.misc.rosetta.env.RosettaDF;
+import org.onap.aaf.misc.rosetta.env.RosettaData;
+
+public class JU_HClient {
+
+	@Mock private SecuritySetter<HttpURLConnection> ssMock;
+	@Mock private Transfer transferMock;
+	@Mock private HttpURLConnection hucMock;
+	@Mock private HttpServletResponse respMock;
+	@Mock private RosettaDF<HttpURLConnection> dfMock;
+	@Mock private RosettaData<HttpURLConnection> dataMock;
+
+	private static final String uriString = "http://example.com:8080/path/to/a/file.txt";
+	private static final String fragment = "fragment";
+	private static final String method = "method";
+	private static final String pathinfo = "pathinfo";
+	private static final String queryParams = "queryParams";
+
+	private static final String errorString = "error string";
+	private static final String successString = "success string";
+
+	private static final String tag1 = "tag1";
+	private static final String tag2 = "tag2";
+	private static final String value1 = "value1";
+	private static final String value2 = "value2";
+
+	private URI uri;
+
+	@Before
+	public void setup() throws URISyntaxException {
+		MockitoAnnotations.initMocks(this);
+
+		uri = new URI(uriString);
+	}
+
+	@Test
+	public void accessorsMutatorsTest() throws LocatorException {
+		HClient client = new HClient(ssMock, uri, 0);
+		client.setFragment(fragment);
+		client.setMethod(method);
+		client.setPathInfo(pathinfo);
+		client.setPayload(transferMock);
+		client.setQueryParams(queryParams);
+		assertThat(client.getURI(), is(uri));
+		assertThat(client.timeout(), is(0));
+		assertThat(client.toString(), is("HttpURLConnection Client configured to " + uri.toString()));
+	}
+
+	@Test
+	public void sendTest() throws LocatorException, APIException, URISyntaxException {
+		HClientStub client;
+		client = new HClientStub(ssMock, uri, 0, null);
+		client.send();
+		
+		client.setPathInfo("/pathinfo");
+		client.send();
+
+		client.setPathInfo("pathinfo");
+		client.send();
+
+		client = new HClientStub(null, uri, 0, null);
+		client.send();
+
+		client.addHeader(tag1, value1);
+		client.addHeader(tag2, value2);
+		client.send();
+
+		client.setPayload(transferMock);
+		client.send();
+	}
+	
+	@Test(expected = APIException.class)
+	public void sendThrows1Test() throws APIException, LocatorException, URISyntaxException {
+		HClientStub client = new HClientStub(ssMock, new URI("mailto:me@domain.com"), 0, null);
+		client.send();
+	}
+
+	@Test(expected = APIException.class)
+	public void sendThrows2Test() throws APIException, LocatorException, URISyntaxException {
+		HClientStub client = new HClientStub(ssMock, new URI("mailto:me@domain.com"), 0, null);
+		client.addHeader(tag1, value1);
+		client.addHeader(tag2, value2);
+		client.send();
+	}
+
+	@Test
+	public void futureCreateTest() throws LocatorException, CadiException, IOException {
+		HClient client = new HClientStub(ssMock, uri, 0, hucMock);
+		HFuture<HttpURLConnection> future = (HFuture<HttpURLConnection>) client.futureCreate(HttpURLConnection.class);
+
+		// Test a bad response code (default 0) without output
+		assertThat(future.get(0), is(false));
+		assertThat(future.body().length(), is(0));
+
+		// Test a bad response code (default 0) with output
+		ByteArrayInputStream bais = new ByteArrayInputStream(errorString.getBytes());
+		when(hucMock.getInputStream()).thenReturn(bais);
+		assertThat(future.get(0), is(false));
+		assertThat(future.body(), is(errorString));
+
+		// Test a good response code
+		when(hucMock.getResponseCode()).thenReturn(201);
+		assertThat(future.get(0), is(true));
+	}
+
+	@Test
+	public void futureReadStringTest() throws LocatorException, CadiException, IOException {
+		HClient client = new HClientStub(ssMock, uri, 0, hucMock);
+		Future<String> future = client.futureReadString();
+
+		// Test a bad response code (default 0) without output
+		assertThat(future.get(0), is(false));
+		assertThat(future.body().length(), is(0));
+
+		// Test a bad response code (default 0) with output
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(errorString.getBytes()));
+		assertThat(future.get(0), is(false));
+		assertThat(future.body(), is(errorString));
+
+		// Test a good response code
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(successString.getBytes()));
+		when(hucMock.getResponseCode()).thenReturn(200);
+		assertThat(future.get(0), is(true));
+		assertThat(future.body(), is(successString));
+	}
+
+	@Test
+	public void futureReadTest() throws LocatorException, CadiException, IOException, APIException {
+		HClient client = new HClientStub(ssMock, uri, 0, hucMock);
+		Future<HttpURLConnection> future = client.futureRead(dfMock, null);
+
+		// Test a bad response code (default 0) without output
+		assertThat(future.get(0), is(false));
+		assertThat(future.body().length(), is(0));
+
+		// Test a bad response code (default 0) with output
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(errorString.getBytes()));
+		assertThat(future.get(0), is(false));
+		assertThat(future.body(), is(errorString));
+
+		// Test a good response code
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(successString.getBytes()));
+		when(dfMock.newData()).thenReturn(dataMock);
+		when(dataMock.in(null)).thenReturn(dataMock);
+		when(dataMock.load((InputStream)any())).thenReturn(dataMock);
+		when(dataMock.asObject()).thenReturn(hucMock);
+		when(dataMock.asString()).thenReturn(successString);
+		when(hucMock.getResponseCode()).thenReturn(200);
+		assertThat(future.get(0), is(true));
+		assertThat(future.body(), is(successString));
+	}
+
+	@Test
+	public void future1Test() throws LocatorException, CadiException, IOException, APIException {
+		HClient client = new HClientStub(ssMock, uri, 0, hucMock);
+		Future<HttpURLConnection> future = client.future(hucMock);
+
+		// Test a good response code
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(successString.getBytes()));
+		when(hucMock.getResponseCode()).thenReturn(200);
+		assertThat(future.get(0), is(true));
+		assertThat(future.body(), is("200"));
+
+		// Test a bad response code
+		when(hucMock.getResponseCode()).thenReturn(0);
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(errorString.getBytes()));
+		assertThat(future.get(0), is(false));
+		assertThat(future.body(), is(errorString));
+	}
+
+	@Test
+	public void future2Test() throws LocatorException, CadiException, IOException, APIException {
+		HClient client = new HClientStub(ssMock, uri, 0, hucMock);
+		Future<Void> future = client.future(respMock, 200);
+
+		ServletOutputStream sos = new ServletOutputStream() {
+			@Override public void write(int arg0) throws IOException { }
+		};
+		when(respMock.getOutputStream()).thenReturn(sos);
+
+		// Test a good response code
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(successString.getBytes()));
+		when(hucMock.getResponseCode()).thenReturn(200);
+		assertThat(future.get(0), is(true));
+		assertThat(future.body(), is(nullValue()));
+
+		// Test a bad response code
+		when(hucMock.getResponseCode()).thenReturn(0);
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(errorString.getBytes()));
+		assertThat(future.get(0), is(false));
+		assertThat(future.body(), is(""));
+	}
+
+	@Test
+	public void hfutureTest() throws CadiException, IOException, LocatorException {
+		HClient client = new HClientStub(ssMock, uri, 0, hucMock);
+		HFutureStub future = new HFutureStub(client, hucMock);
+		assertThat(future.get(0), is(false));
+
+		// Test a bad response code (default 0) with output
+		when(hucMock.getInputStream()).thenReturn(new ByteArrayInputStream(errorString.getBytes()));
+		assertThat(future.get(0), is(false));
+
+		assertThat(future.get(0), is(false));
+
+		when(hucMock.getResponseCode()).thenReturn(200);
+		assertThat(future.get(0), is(true));
+
+		StringBuilder sb = future.inputStreamToString(new ByteArrayInputStream(errorString.getBytes()));
+		assertThat(sb.toString(), is(errorString));
+
+		assertThat(future.code(), is(200));
+		assertThat(future.huc(), is(hucMock));
+
+		assertThat(future.exception(), is(nullValue()));
+		assertThat(future.header("string"), is(nullValue()));
+
+		// coverage...
+		future.setHuc(null);
+		future.close();
+	}
+
+	@Test
+	public void headerTest() throws LocatorException {
+		HClient client = new HClientStub(ssMock, uri, 0, hucMock);
+		String tag1 = "tag1";
+		String tag2 = "tag2";
+		String value1 = "value1";
+		String value2 = "value2";
+		client.addHeader(tag1, value1);
+		client.addHeader(tag2, value2);
+	}
+
+	@Test(expected = LocatorException.class)
+	public void throws1Test() throws LocatorException {
+		@SuppressWarnings("unused")
+		HClient client = new HClient(ssMock, null, 0);
+	}
+
+	private class HClientStub extends HClient {
+		public HClientStub(SecuritySetter<HttpURLConnection> ss, URI uri, int connectTimeout, HttpURLConnection huc) throws LocatorException {
+			super(ss, uri, connectTimeout);
+			setHuc(huc);
+		}
+		public void setHuc(HttpURLConnection huc) {
+			Field field;
+			try {
+				field = HClient.class.getDeclaredField("huc");
+				field.setAccessible(true);
+				field.set(this, huc);
+				field.setAccessible(false);
+			} catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
+				e.printStackTrace();
+				fail("Caught an exception: " + e.getMessage());
+			}
+		}
+		@Override
+		public HttpURLConnection getConnection(URI uri, StringBuilder pi) throws IOException {
+			return hucMock;
+		}
+	}
+
+	private class HFutureStub extends HFuture<HttpURLConnection> {
+		public HFutureStub(HClient hClient, HttpURLConnection huc) {
+			hClient.super(huc);
+		}
+
+		@Override public String body() { return null; }
+		public void setHuc(HttpURLConnection huc) { this.huc = huc; }
+	}
+
+}