update so to use 1.6.3 snapshot from the logging

Updated snapshot to 1.6.3 and began fixing failing tests
Update SOAPLoggingInInterceptor to use new InvocationID value
Changed client and server keys to InvocationID
BPRestCallback to use ServerInvocationId
Removed logging MDC checking from unit tests
Began switching bprestcallback to use resttemplate
Removed changes to logback replacing invocationIds
Updated logic where requestEntity is created on null message
Added unit tests for BPRestCallback
Set InvocationID in MDC in SOAPLoggingInInterceptor
Send in URI to prevent encoding of URI causing % to change to %25
Updated restTemplate to fix issue with interceptors

Issue-ID: SO-2571
Signed-off-by: Benjamin, Max (mb388a) <mb388a@att.com>
Change-Id: I7e0d80eae9036c993414ae96ebd571c89cb9dfa9

4 files changed, 215 insertions, 75 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/sdncrest/BPRestCallback.java b/adapters/mso-sdnc-adapter/src/main/java/org/onap/so/adapters/sdnc/sdncrest/BPRestCallback.java
index 8a1a7559b5..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.BusinessProcessError.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.BusinessProcessError.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.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/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