Merge "update so to use 1.6.3 snapshot from the logging"

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