Address NullPointerException with apih healthcheck endpoint

Facing NullPointerException with apih healthcheck endpoint
with elalto branch. Brittany has addressed this issue
with master branch and this change brings in those
changes with elalto branch
This is a squashed commit cherry picked commits from master
commit 4e79baed423434b42d75f0d5c26757cd6792ce79
commit b341d9cd027b0f7bec125d51b8298c3e31d7f685
commit 02b85383a1f2a7c9677db2929b30fc283ad9a00c
commit 8e3e32d4c7a10ddd8ee97576e030185e273bd2c0
commit 8a1bade3296510df340d11f7c22353994cbdfa83
commit ef6d7e225d8601489f8559483e1414dc62a62e8b
commit 84a201f889f635c9405ea737d814fc43d274afd7

Issue-ID: SO-3046
Signed-off-by: Ramesh Parthasarathy(rp6768)<ramesh.parthasarathy@att.com>
Change-Id: Ic7579f84746dad4002a5291edd54237eaaa602cf

7 files changed, 222 insertions, 82 deletions

diff --git a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/SDNCAdapterApplication.java b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/SDNCAdapterApplication.java
index fc6d0a6fc9..55a05436f0 100644
--- a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/SDNCAdapterApplication.java
+++ b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/SDNCAdapterApplication.java
@@ -23,7 +23,9 @@
 package org.onap.so.adapters.sdnc;
 
 import java.util.concurrent.Executor;
+import org.onap.logging.filter.base.Constants;
 import org.onap.logging.filter.spring.MDCTaskDecorator;
+import org.onap.so.utils.Components;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
@@ -52,6 +54,7 @@ public class SDNCAdapterApplication {
     }
 
     public static void main(String[] args) {
+        System.setProperty(Constants.Property.PARTNER_NAME, Components.SDNC_ADAPTER.toString());
         SpringApplication.run(SDNCAdapterApplication.class, args);
         System.getProperties().setProperty("server.name", "Springboot");
         setLogsDir();
diff --git a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/impl/SDNCRestClient.java b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/impl/SDNCRestClient.java
index 012a19f1a9..a8418ea901 100644
--- a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/impl/SDNCRestClient.java
+++ b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/impl/SDNCRestClient.java
@@ -178,7 +178,7 @@ public class SDNCRestClient {
             return (sdncResp);
         } catch (Exception e) {
             logger.error(LoggingAnchor.FOUR, MessageEnum.RA_EXCEPTION_COMMUNICATE_SDNC.toString(), "SDNC",
-                    ErrorCode.BusinessProcesssError.getValue(), "Exception processing request to SDNC", e);
+                    ErrorCode.BusinessProcessError.getValue(), "Exception processing request to SDNC", e);
             // default
             sdncResp.setRespCode(HttpURLConnection.HTTP_INTERNAL_ERROR);
             String respMsg = "Error processing request to SDNC. ";
@@ -246,7 +246,7 @@ public class SDNCRestClient {
                     } // is != null
                 } catch (Exception e1) {
                     logger.error(LoggingAnchor.FOUR, MessageEnum.RA_ERROR_GET_RESPONSE_SDNC.toString(), "SDNC",
-                            ErrorCode.BusinessProcesssError.getValue(), "Exception while get SDNC response", e1);
+                            ErrorCode.BusinessProcessError.getValue(), "Exception while get SDNC response", e1);
                 }
             } // con != null
 
@@ -312,7 +312,7 @@ public class SDNCRestClient {
                 headers.put("Authorization", Collections.singletonList(basicAuth));
             } catch (Exception e2) {
                 logger.error(LoggingAnchor.FOUR, MessageEnum.RA_SET_CALLBACK_AUTH_EXC.toString(), CAMUNDA,
-                        ErrorCode.BusinessProcesssError.getValue(),
+                        ErrorCode.BusinessProcessError.getValue(),
                         "Exception - Unable to set authorization in callback request", e2);
 
             }
@@ -322,7 +322,7 @@ public class SDNCRestClient {
 
         } catch (Exception e) {
             error = "Error sending BpelCallback request" + e.getMessage();
-            logger.error("Error {} - {} - {}", ErrorCode.BusinessProcesssError.getValue(),
+            logger.error("Error {} - {} - {}", ErrorCode.BusinessProcessError.getValue(),
                     MessageEnum.RA_CALLBACK_BPEL_EXC.toString(), error, e);
         }
         logger.info(MessageEnum.RA_CALLBACK_BPEL_COMPLETE.name(), CAMUNDA);
diff --git a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/impl/Utils.java b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/impl/Utils.java
index 1c47a2d6b0..f710988886 100644
--- a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/impl/Utils.java
+++ b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/impl/Utils.java
@@ -99,7 +99,7 @@ public class Utils {
 
         } catch (Exception e) {
             logger.error(LoggingAnchor.FOUR, MessageEnum.RA_ERROR_CREATE_SDNC_REQUEST.toString(), "SDNC",
-                    ErrorCode.BusinessProcesssError.getValue(), "Exception in genSdncReq", e);
+                    ErrorCode.BusinessProcessError.getValue(), "Exception in genSdncReq", e);
         }
         return null;
     }
diff --git a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/BPRestCallback.java b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/BPRestCallback.java
index b50662a832..631be2f9ff 100644
--- a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/BPRestCallback.java
+++ b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/BPRestCallback.java
@@ -24,27 +24,30 @@
 
 package org.onap.so.adapters.sdnc.sdncrest;
 
+import java.net.URI;
 import javax.xml.bind.DatatypeConverter;
-import org.onap.so.logger.LoggingAnchor;
-import org.apache.http.HttpResponse;
-import org.apache.http.client.HttpClient;
-import org.apache.http.client.config.RequestConfig;
-import org.apache.http.client.methods.HttpPost;
-import org.apache.http.entity.ContentType;
-import org.apache.http.entity.StringEntity;
-import org.apache.http.impl.client.HttpClientBuilder;
-import org.apache.http.util.EntityUtils;
-import org.onap.logging.ref.slf4j.ONAPLogConstants;
+import org.onap.logging.filter.spring.SpringClientPayloadFilter;
 import org.onap.so.adapters.sdnc.impl.Constants;
 import org.onap.so.logger.ErrorCode;
+import org.onap.so.logger.LoggingAnchor;
 import org.onap.so.logger.MessageEnum;
+import org.onap.so.logging.jaxrs.filter.SOSpringClientFilter;
+import org.onap.so.utils.CryptoUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-import org.onap.so.utils.CryptoUtils;
-import org.slf4j.MDC;
 import org.springframework.core.env.Environment;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.http.client.BufferingClientHttpRequestFactory;
+import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.HttpStatusCodeException;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.util.UriComponentsBuilder;
 
 /**
  * Sends asynchronous messages to the BPMN WorkflowMessage service.
@@ -95,81 +98,72 @@ public class BPRestCallback {
 
         logger.info(LoggingAnchor.THREE, MessageEnum.RA_CALLBACK_BPEL.toString(),
                 message == null ? "[no content]" : message, CAMUNDA);
-
-        HttpPost method = null;
-        HttpResponse httpResponse = null;
-
         try {
             int timeout = 60 * 1000;
+            RestTemplate restTemplate = setRestTemplate(timeout);
 
-            RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(timeout).setConnectTimeout(timeout)
-                    .setConnectionRequestTimeout(timeout).build();
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
 
-            HttpClient client = HttpClientBuilder.create().build();
-            method = new HttpPost(url);
-            method.setConfig(requestConfig);
-
-            if (message != null) {
-                method.setEntity(new StringEntity(message, ContentType.APPLICATION_JSON));
-            }
-
-            boolean error = false;
-
-            try {
-                String userCredentials = CryptoUtils.decrypt(env.getProperty(Constants.BPEL_AUTH_PROP),
-                        env.getProperty(Constants.ENCRYPTION_KEY_PROP));
-                String authorization = "Basic " + DatatypeConverter.printBase64Binary(userCredentials.getBytes());
-                method.setHeader("Authorization", authorization);
-                method.setHeader(ONAPLogConstants.Headers.REQUEST_ID, MDC.get(ONAPLogConstants.MDCs.REQUEST_ID));
-                method.setHeader(ONAPLogConstants.Headers.INVOCATION_ID, MDC.get(ONAPLogConstants.MDCs.INVOCATION_ID));
-                method.setHeader(ONAPLogConstants.Headers.PARTNER_NAME, "SO-SDNCAdapter");
-            } catch (Exception e) {
-                logger.error(LoggingAnchor.FOUR, MessageEnum.RA_SET_CALLBACK_AUTH_EXC.toString(), CAMUNDA,
-                        ErrorCode.BusinessProcesssError.getValue(), "Unable to set authorization in callback request",
-                        e);
-                error = true;
-            }
+            boolean error = setAuthorizationHeader(headers);
 
+            HttpEntity<String> requestEntity = new HttpEntity<>(message, headers);
             if (!error) {
-                httpResponse = client.execute(method);
-
-                @SuppressWarnings("unused")
-                String responseContent = null;
-
-                if (httpResponse.getEntity() != null) {
-                    responseContent = EntityUtils.toString(httpResponse.getEntity(), "UTF-8");
-                }
-
-                if (httpResponse.getStatusLine().getStatusCode() >= 300) {
-                    String msg = "Received error response to callback request: " + httpResponse.getStatusLine();
-                    logger.error(LoggingAnchor.FOUR, MessageEnum.RA_CALLBACK_BPEL_EXC.toString(), CAMUNDA,
-                            ErrorCode.BusinessProcesssError.getValue(), msg);
-
-                }
+                postRequest(restTemplate, url, requestEntity);
             }
+            logger.info(LoggingAnchor.TWO, MessageEnum.RA_CALLBACK_BPEL_COMPLETE.toString(), CAMUNDA);
             return true;
         } catch (Exception e) {
             logger.error(LoggingAnchor.FOUR, MessageEnum.RA_CALLBACK_BPEL_EXC.toString(), CAMUNDA,
-                    ErrorCode.BusinessProcesssError.getValue(), "Error sending callback request", e);
+                    ErrorCode.BusinessProcessError.getValue(), "Error sending callback request", e);
             return false;
-        } finally {
-            if (httpResponse != null) {
-                try {
-                    EntityUtils.consume(httpResponse.getEntity());
-                    httpResponse = null;
-                } catch (Exception e) {
-                    logger.debug("Exception:", e);
-                }
-            }
+        }
+    }
 
-            if (method != null) {
-                try {
-                    method.reset();
-                } catch (Exception e) {
-                    logger.debug("Exception:", e);
-                }
-            }
-            logger.info(LoggingAnchor.TWO, MessageEnum.RA_CALLBACK_BPEL_COMPLETE.toString(), CAMUNDA);
+    protected boolean setAuthorizationHeader(HttpHeaders headers) {
+        boolean error = false;
+        try {
+            String userCredentials = CryptoUtils.decrypt(env.getProperty(Constants.BPEL_AUTH_PROP),
+                    env.getProperty(Constants.ENCRYPTION_KEY_PROP));
+            String authorization = "Basic " + DatatypeConverter.printBase64Binary(userCredentials.getBytes());
+            headers.set("Authorization", authorization);
+        } catch (Exception e) {
+            logger.error(LoggingAnchor.FOUR, MessageEnum.RA_SET_CALLBACK_AUTH_EXC.toString(), CAMUNDA,
+                    ErrorCode.BusinessProcessError.getValue(), "Unable to set authorization in callback request", e);
+            error = true;
+        }
+        return error;
+    }
+
+    private void postRequest(RestTemplate restTemplate, String url, HttpEntity<String> requestEntity) {
+        ResponseEntity<String> response = null;
+        try {
+            UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(url);
+            URI uri = builder.build(true).toUri();
+            response = restTemplate.postForEntity(uri, requestEntity, String.class);
+        } catch (HttpStatusCodeException e) {
+            logResponseError(e.getStatusCode());
+        }
+        if (response != null && response.getStatusCode().is3xxRedirection()) {
+            logResponseError(response.getStatusCode());
         }
     }
+
+    private void logResponseError(HttpStatus statusCode) {
+        String msg = "Received error response to callback request: " + statusCode;
+        logger.error(LoggingAnchor.FOUR, MessageEnum.RA_CALLBACK_BPEL_EXC.toString(), CAMUNDA,
+                ErrorCode.BusinessProcessError.getValue(), msg);
+    }
+
+    protected RestTemplate setRestTemplate(int timeout) {
+        RestTemplate restTemplate = new RestTemplate();
+        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
+        factory.setConnectionRequestTimeout(timeout);
+        factory.setReadTimeout(timeout);
+        factory.setConnectTimeout(timeout);
+        restTemplate.setRequestFactory(new BufferingClientHttpRequestFactory(factory));
+        restTemplate.getInterceptors().add(new SOSpringClientFilter());
+        restTemplate.getInterceptors().add((new SpringClientPayloadFilter()));
+        return restTemplate;
+    }
 }
diff --git a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/SDNCServiceRequestTask.java b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/SDNCServiceRequestTask.java
index 5697ed56a5..50c8a089df 100644
--- a/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/SDNCServiceRequestTask.java
+++ b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/SDNCServiceRequestTask.java
@@ -185,7 +185,7 @@ public class SDNCServiceRequestTask {
             addTextChild(agnosticServiceInformation, "anydata", anydata);
         } catch (Exception e) {
             logger.error(LoggingAnchor.FOUR, MessageEnum.RA_ERROR_CREATE_SDNC_REQUEST.toString(), "SDNC",
-                    ErrorCode.BusinessProcesssError.getValue(), "Exception in genSdncReq", e);
+                    ErrorCode.BusinessProcessError.getValue(), "Exception in genSdncReq", e);
             return null;
         }
 
diff --git a/adapters/mso-sdnc-adapter/src/test/java/org/onap/so/adapters/sdnc/sdncrest/BPRestCallbackUnitTest.java b/adapters/mso-sdnc-adapter/src/test/java/org/onap/so/adapters/sdnc/sdncrest/BPRestCallbackUnitTest.java
new file mode 100644
index 0000000000..09089890ab
--- /dev/null
+++ b/adapters/mso-sdnc-adapter/src/test/java/org/onap/so/adapters/sdnc/sdncrest/BPRestCallbackUnitTest.java
@@ -0,0 +1,142 @@
+package org.onap.so.adapters.sdnc.sdncrest;
+
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.onap.so.adapters.sdnc.impl.Constants;
+import org.springframework.core.env.Environment;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.HttpServerErrorException;
+import org.springframework.web.client.ResourceAccessException;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.util.UriComponentsBuilder;
+
+@RunWith(MockitoJUnitRunner.class)
+public class BPRestCallbackUnitTest {
+    @Mock
+    private Environment env;
+
+    @Mock
+    private RestTemplate restTemplate;
+
+    @Spy
+    @InjectMocks
+    private BPRestCallback bpRestCallback;
+
+    private HttpEntity<String> requestEntity;
+    private String message;
+    private HttpHeaders headers;
+    private URI uri;
+
+    @Before
+    public void setUp() throws IOException {
+        headers = new HttpHeaders();
+        headers.setContentType(MediaType.APPLICATION_JSON);
+        message = input("BPRestCallbackRequest.json");
+        requestEntity = new HttpEntity<>(message, headers);
+        UriComponentsBuilder builder = UriComponentsBuilder.fromUriString("http://localhost:8000/sdnc");
+        uri = builder.build(true).toUri();
+    }
+
+    public String input(String JsonInput) throws IOException {
+        JsonInput = "src/test/resources/" + JsonInput;
+        return new String(Files.readAllBytes(Paths.get(JsonInput)));
+    }
+
+    @Test
+    public void sendTest() throws IOException {
+        ResponseEntity<String> postResponse = new ResponseEntity<String>("response", HttpStatus.OK);
+        doReturn(restTemplate).when(bpRestCallback).setRestTemplate(60000);
+        doReturn(false).when(bpRestCallback).setAuthorizationHeader(headers);
+        when(restTemplate.postForEntity(uri, requestEntity, String.class)).thenReturn(postResponse);
+        boolean response = bpRestCallback.send("http://localhost:8000/sdnc", message);
+        assertTrue(response);
+    }
+
+    @Test
+    public void sendNoAuthHeaderTest() throws IOException {
+        doReturn(true).when(bpRestCallback).setAuthorizationHeader(headers);
+        doReturn(restTemplate).when(bpRestCallback).setRestTemplate(60000);
+        boolean response = bpRestCallback.send("http://localhost:8000/sdnc", message);
+        assertTrue(response);
+    }
+
+    @Test
+    public void sendErrorTest() throws IOException {
+        doReturn(false).when(bpRestCallback).setAuthorizationHeader(headers);
+        doReturn(restTemplate).when(bpRestCallback).setRestTemplate(60000);
+        when(restTemplate.postForEntity(uri, requestEntity, String.class))
+                .thenThrow(new HttpServerErrorException(HttpStatus.INTERNAL_SERVER_ERROR, null, null, null));
+        boolean response = bpRestCallback.send("http://localhost:8000/sdnc", message);
+        assertTrue(response);
+    }
+
+    @Test
+    public void sendResponse3xxTest() throws IOException {
+        ResponseEntity<String> postResponse = new ResponseEntity<String>("response", HttpStatus.MULTIPLE_CHOICES);
+        doReturn(false).when(bpRestCallback).setAuthorizationHeader(headers);
+        doReturn(restTemplate).when(bpRestCallback).setRestTemplate(60000);
+        when(restTemplate.postForEntity(uri, requestEntity, String.class)).thenReturn(postResponse);
+        boolean response = bpRestCallback.send("http://localhost:8000/sdnc", message);
+        assertTrue(response);
+    }
+
+    @Test
+    public void sendResponseNullMessageTest() throws IOException {
+        HttpHeaders httpHeaders = new HttpHeaders();
+        httpHeaders.setContentType(MediaType.APPLICATION_JSON);
+        HttpEntity<String> requestEntityNoMessage = new HttpEntity<>(null, httpHeaders);
+        ResponseEntity<String> postResponse = new ResponseEntity<String>("response", HttpStatus.OK);
+        doReturn(false).when(bpRestCallback).setAuthorizationHeader(httpHeaders);
+        doReturn(restTemplate).when(bpRestCallback).setRestTemplate(60000);
+        when(restTemplate.postForEntity(uri, requestEntityNoMessage, String.class)).thenReturn(postResponse);
+        boolean response = bpRestCallback.send("http://localhost:8000/sdnc", null);
+        assertTrue(response);
+    }
+
+    @Test
+    public void postThrowsExceptionTest() throws IOException {
+        doReturn(false).when(bpRestCallback).setAuthorizationHeader(headers);
+        doReturn(restTemplate).when(bpRestCallback).setRestTemplate(60000);
+        when(restTemplate.postForEntity(uri, requestEntity, String.class))
+                .thenThrow(new ResourceAccessException("ResourceAccessException"));
+        boolean response = bpRestCallback.send("http://localhost:8000/sdnc", message);
+        assertFalse(response);
+    }
+
+    @Test
+    public void setAuthorizationHeaderTest() {
+        HttpHeaders authHeaders = new HttpHeaders();
+        when(env.getProperty(Constants.BPEL_AUTH_PROP))
+                .thenReturn("5E12ACACBD552A415E081E29F2C4772F9835792A51C766CCFDD7433DB5220B59969CB2798C");
+        when(env.getProperty(Constants.ENCRYPTION_KEY_PROP)).thenReturn("07a7159d3bf51a0e53be7a8f89699be7");
+        boolean result = bpRestCallback.setAuthorizationHeader(authHeaders);
+        assertFalse(result);
+    }
+
+    @Test
+    public void setAuthorizationHeaderErrorTest() {
+        HttpHeaders authHeaders = new HttpHeaders();
+        when(env.getProperty(Constants.BPEL_AUTH_PROP)).thenReturn("test");
+        when(env.getProperty(Constants.ENCRYPTION_KEY_PROP)).thenReturn("test");
+        boolean result = bpRestCallback.setAuthorizationHeader(authHeaders);
+        assertTrue(result);
+    }
+}
diff --git a/adapters/mso-sdnc-adapter/src/test/resources/BPRestCallbackRequest.json b/adapters/mso-sdnc-adapter/src/test/resources/BPRestCallbackRequest.json
new file mode 100644
index 0000000000..21f3dab7e0
--- /dev/null
+++ b/adapters/mso-sdnc-adapter/src/test/resources/BPRestCallbackRequest.json
@@ -0,0 +1 @@
+{"SDNCServiceResponse":{"sdncRequestId":"b5b763aa-0d8a-4438-b900-83af45d21d10","responseCode":"200","ackFinalIndicator":"N"}}
\ No newline at end of file