package org.onap.vid.aai;
-import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
-import org.onap.vid.aai.util.*;
-import org.onap.vid.utils.Logging;
-import org.springframework.http.HttpMethod;
+import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
+import java.util.UUID;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
-import java.util.UUID;
-
-import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
+import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
+import org.onap.vid.aai.util.AAIRestInterface;
+import org.onap.vid.aai.util.HttpClientMode;
+import org.onap.vid.aai.util.HttpsAuthClient;
+import org.onap.vid.aai.util.ServletRequestHelper;
+import org.onap.vid.aai.util.SystemPropertyHelper;
+import org.onap.vid.utils.Logging;
+import org.springframework.http.HttpMethod;
public class PombaRestInterface extends AAIRestInterface {
private Client client = null;
- public PombaRestInterface (HttpsAuthClient httpsAuthClientFactory, ServletRequestHelper servletRequestHelper, SystemPropertyHelper systemPropertyHelper) {
- super(httpsAuthClientFactory, servletRequestHelper, systemPropertyHelper);
+ public PombaRestInterface (HttpsAuthClient httpsAuthClientFactory,
+ ServletRequestHelper servletRequestHelper,
+ SystemPropertyHelper systemPropertyHelper,
+ Logging loggingService) {
+ super(httpsAuthClientFactory, servletRequestHelper, systemPropertyHelper, loggingService);
}
@Override
try {
initRestClient();
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.POST, url, payload);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.POST, url, payload);
final Response cres = client.target(url)
.request()
.accept(MediaType.APPLICATION_JSON)
.header(FROM_APP_ID_HEADER, fromAppId)
.header(REQUEST_ID_HEADER_KEY, extractOrGenerateRequestId())
.post(Entity.entity(payload, MediaType.APPLICATION_JSON));
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.POST, url, cres);
+ loggingService.logResponse(outgoingRequestsLogger, HttpMethod.POST, url, cres);
if (cres.getStatusInfo().getFamily().equals(Response.Status.Family.SUCCESSFUL)) {
logger.info(EELFLoggerDelegate.errorLogger, getValidResponseLogMessage(methodName));
package org.onap.vid.aai.util;
+import static org.apache.commons.lang3.ObjectUtils.defaultIfNull;
+import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
+
import com.att.eelf.configuration.EELFLogger;
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.net.URLEncoder;
+import java.util.Optional;
+import java.util.UUID;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
-import javax.ws.rs.client.Client;
-import javax.ws.rs.client.Entity;
-import javax.ws.rs.client.Invocation;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-import java.io.UnsupportedEncodingException;
-import java.net.URI;
-import java.net.URLEncoder;
-import java.util.Optional;
-import java.util.UUID;
-
-import static org.apache.commons.lang3.ObjectUtils.defaultIfNull;
-import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
-
/**
* The Class AAIRestInterface.
protected HttpsAuthClient httpsAuthClientFactory;
private final ServletRequestHelper servletRequestHelper;
private final SystemPropertyHelper systemPropertyHelper;
+ protected final Logging loggingService;
protected static final String START_STRING = " start";
protected static final String TRANSACTION_ID_HEADER = "X-TransactionId";
protected static final String SUCCESSFUL_API_MESSAGE = " REST api call was successful!";
protected static final String URL_DECLARATION = ", url=";
- public AAIRestInterface(HttpsAuthClient httpsAuthClientFactory, ServletRequestHelper servletRequestHelper, SystemPropertyHelper systemPropertyHelper) {
+ public AAIRestInterface(HttpsAuthClient httpsAuthClientFactory,
+ ServletRequestHelper servletRequestHelper,
+ SystemPropertyHelper systemPropertyHelper,
+ Logging loggingService) {
this.httpsAuthClientFactory = httpsAuthClientFactory;
this.servletRequestHelper = servletRequestHelper;
this.systemPropertyHelper = systemPropertyHelper;
+ this.loggingService = loggingService;
initRestClient();
}
* For testing purpose
*/
AAIRestInterface(Optional<Client> client,
- HttpsAuthClient httpsAuthClientFactory, ServletRequestHelper servletRequestHelper, SystemPropertyHelper systemPropertyHelper){
+ HttpsAuthClient httpsAuthClientFactory,
+ ServletRequestHelper servletRequestHelper,
+ SystemPropertyHelper systemPropertyHelper,
+ Logging loggingService){
this.httpsAuthClientFactory = httpsAuthClientFactory;
this.servletRequestHelper = servletRequestHelper;
this.systemPropertyHelper = systemPropertyHelper;
+ this.loggingService = loggingService;
if (client != null && client.isPresent()){
this.client = client.get();
}
logger.debug(EELFLoggerDelegate.debugLogger, methodName + START_STRING);
logger.debug(EELFLoggerDelegate.debugLogger, url + " for the get REST API");
- Logging.logRequest(outgoingRequestsLogger, method, url, payload);
+ loggingService.logRequest(outgoingRequestsLogger, method, url, payload);
final Response response;
Invocation.Builder requestBuilder = client.target(url)
requestBuilder.build(method.name(), Entity.entity(payload, MediaType.APPLICATION_JSON));
response = restInvocation.invoke();
- Logging.logResponse(outgoingRequestsLogger, method, url, response);
+ loggingService.logResponse(outgoingRequestsLogger, method, url, response);
if (response.getStatusInfo().getFamily() == Response.Status.Family.SUCCESSFUL) {
logger.debug(EELFLoggerDelegate.debugLogger, methodName + SUCCESSFUL_API_MESSAGE);
try {
initRestClient();
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url);
final Response cres = client.target(url)
.request()
.accept(MediaType.APPLICATION_JSON)
.header(FROM_APP_ID_HEADER, sourceID)
.header(REQUEST_ID_HEADER_KEY, extractOrGenerateRequestId())
.delete();
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.DELETE, url, cres);
+ loggingService.logResponse(outgoingRequestsLogger, HttpMethod.DELETE, url, cres);
if (cres.getStatusInfo().equals(Response.Status.NOT_FOUND)) {
logger.debug(EELFLoggerDelegate.debugLogger, "Resource does not exist...: " + cres.getStatus()
+ ":" + cres.readEntity(String.class));
Response response = null;
try {
initRestClient();
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.POST, url, payload);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.POST, url, payload);
response = authenticateRequest(client.target(url)
.request()
.accept(xml ? MediaType.APPLICATION_XML : MediaType.APPLICATION_JSON)
.header(FROM_APP_ID_HEADER, fromAppId))
.header(REQUEST_ID_HEADER_KEY, extractOrGenerateRequestId())
.post(Entity.entity(payload, MediaType.APPLICATION_JSON));
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.POST, url, response);
+ loggingService.logResponse(outgoingRequestsLogger, HttpMethod.POST, url, response);
if (response.getStatusInfo().getFamily().equals(Response.Status.Family.SUCCESSFUL)) {
logger.info(EELFLoggerDelegate.errorLogger, getValidResponseLogMessage(methodName));
import static org.onap.vid.client.SyncRestClientInterface.HEADERS.X_ECOMP_INSTANCE_ID;
import static org.onap.vid.client.UnirestPatchKt.extractRawAsString;
import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
-import static org.onap.vid.utils.Logging.logRequest;
import com.att.eelf.configuration.EELFLogger;
import com.google.common.collect.ImmutableMap;
private String baseUrl;
private String path;
private String auth;
- private static final EELFLogger LOGGER = Logging.getRequestsLogger("asdc");
+ private static final EELFLogger LOGGER = Logging.getRequestsLogger("sdc");
private SyncRestClientInterface syncRestClient;
+ private Logging loggingService;
- public SdcRestClient(String baseUrl, String auth, SyncRestClientInterface client) {
+ public SdcRestClient(String baseUrl, String auth, SyncRestClientInterface client, Logging loggingService) {
this.syncRestClient = client;
this.auth = auth;
this.baseUrl = baseUrl;
this.path = VidProperties.getPropertyWithDefault(ModelConstants.ASDC_SVC_API_PATH, ModelConstants.DEFAULT_ASDC_SVC_API_PATH);
+ this.loggingService = loggingService;
}
@Override
public Service getService(UUID uuid) throws AsdcCatalogException {
String finalUrl = String.format(METADATA_URL_TEMPLATE, baseUrl, path, uuid);
- logRequest(LOGGER, HttpMethod.GET, finalUrl);
+ loggingService.logRequest(LOGGER, HttpMethod.GET, finalUrl);
return Try
.of(() -> syncRestClient.get(finalUrl, prepareHeaders(auth, APPLICATION_JSON), Collections.emptyMap(), Service.class))
HttpResponseWithRequestInfo<InputStream> responseWithRequestInfo = getServiceInputStream(uuid, false);
if (responseWithRequestInfo.getResponse().getStatus()>399) {
- Logging.logResponse(LOGGER, HttpMethod.GET,
+ loggingService.logRequest(LOGGER, HttpMethod.GET,
responseWithRequestInfo.getRequestUrl(), responseWithRequestInfo.getResponse());
String body = extractRawAsString(responseWithRequestInfo.getResponse());
@Override
public HttpResponseWithRequestInfo<InputStream> getServiceInputStream(UUID serviceUuid, boolean warpException) {
String finalUrl = String.format(TOSCA_MODEL_URL_TEMPLATE, baseUrl, path, serviceUuid);
- logRequest(LOGGER, HttpMethod.GET, finalUrl);
+ loggingService.logRequest(LOGGER, HttpMethod.GET, finalUrl);
try {
HttpResponse<InputStream> httpResponse = syncRestClient.getStream(finalUrl, prepareHeaders(auth, APPLICATION_OCTET_STREAM), Collections.emptyMap());
return new HttpResponseWithRequestInfo<>(httpResponse, finalUrl, HttpMethod.GET);
import static org.apache.commons.lang3.StringUtils.isEmpty;
import static org.onap.vid.client.UnirestPatchKt.patched;
+import com.att.eelf.configuration.EELFLogger;
import io.joshworks.restclient.http.HttpResponse;
import io.joshworks.restclient.http.JsonNode;
import io.joshworks.restclient.http.RestClient;
import java.util.Map;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
+import org.apache.commons.lang3.ObjectUtils;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
import org.onap.portalsdk.core.util.SystemProperties;
import org.onap.vid.properties.VidProperties;
+import org.onap.vid.utils.Logging;
public class SyncRestClient implements SyncRestClientInterface {
private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(SyncRestClient.class);
private static final String[] SUPPORTED_SSL_VERSIONS = {"TLSv1", "TLSv1.2"};
private static final String HTTPS_SCHEMA = "https://";
private static final String HTTP_SCHEMA = "http://";
+ private final Logging loggingService;
+ private final EELFLogger outgoingRequestsLogger;
private RestClient restClient;
- public SyncRestClient() {
- restClient = RestClient.newClient().objectMapper(defaultObjectMapper()).httpClient(defaultHttpClient()).build();
+ public SyncRestClient(Logging loggingService) {
+ this(null, null, loggingService);
}
- public SyncRestClient(ObjectMapper objectMapper) {
- restClient = RestClient.newClient().objectMapper(objectMapper).httpClient(defaultHttpClient()).build();
+ public SyncRestClient(ObjectMapper objectMapper, Logging loggingService) {
+ this(null, objectMapper, loggingService);
}
- public SyncRestClient(CloseableHttpClient httpClient) {
- restClient = RestClient.newClient().objectMapper(defaultObjectMapper()).httpClient(httpClient).build();
+ public SyncRestClient(CloseableHttpClient httpClient, Logging loggingService) {
+ this(httpClient, null, loggingService);
}
- public SyncRestClient(CloseableHttpClient httpClient, ObjectMapper objectMapper) {
- restClient = RestClient.newClient().objectMapper(objectMapper).httpClient(httpClient).build();
+ public SyncRestClient(CloseableHttpClient httpClient, ObjectMapper objectMapper, Logging loggingService) {
+ restClient = RestClient
+ .newClient()
+ .objectMapper(ObjectUtils.defaultIfNull(objectMapper, defaultObjectMapper()))
+ .httpClient(ObjectUtils.defaultIfNull(httpClient , defaultHttpClient()))
+ .build();
+ this.loggingService = loggingService;
+ this.outgoingRequestsLogger = Logging.getRequestsLogger("syncRestClient");
}
@Override
import org.onap.vid.mso.rest.MsoRestClientNew;
import org.onap.vid.services.CloudOwnerService;
import org.onap.vid.services.CloudOwnerServiceImpl;
+import org.onap.vid.utils.Logging;
import org.onap.vid.utils.SystemPropertiesWrapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
}
@Bean
- public MsoRestClientNew msoClient(ObjectMapper unirestObjectMapper, HttpsAuthClient httpsAuthClient, SystemPropertiesWrapper systemPropertiesWrapper){
+ public MsoRestClientNew msoClient(ObjectMapper unirestObjectMapper,
+ HttpsAuthClient httpsAuthClient,
+ SystemPropertiesWrapper systemPropertiesWrapper,
+ Logging loggingService){
// Satisfy both interfaces -- MsoInterface and RestMsoImplementation
- return new MsoRestClientNew(new SyncRestClient(unirestObjectMapper), SystemProperties.getProperty(
- MsoProperties.MSO_SERVER_URL),httpsAuthClient, systemPropertiesWrapper);
+ return new MsoRestClientNew(
+ new SyncRestClient(unirestObjectMapper, loggingService),
+ SystemProperties.getProperty(MsoProperties.MSO_SERVER_URL),
+ httpsAuthClient,
+ systemPropertiesWrapper,
+ loggingService
+ );
}
import org.onap.vid.asdc.parser.VidNotionsBuilder;
import org.onap.vid.asdc.rest.SdcRestClient;
import org.onap.vid.client.SyncRestClient;
-import org.onap.vid.client.SyncRestClientInterface;
import org.onap.vid.properties.AsdcClientConfiguration;
import org.onap.vid.properties.VidProperties;
import org.onap.vid.scheduler.SchedulerService;
import org.onap.vid.services.ChangeManagementService;
import org.onap.vid.services.PombaService;
import org.onap.vid.services.PombaServiceImpl;
+import org.onap.vid.utils.Logging;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
}
@Bean(name = "aaiRestInterface")
- public AAIRestInterface aaiRestInterface(HttpsAuthClient httpsAuthClientFactory, ServletRequestHelper servletRequestHelper, SystemPropertyHelper systemPropertyHelper) {
- return new AAIRestInterface(httpsAuthClientFactory, servletRequestHelper, systemPropertyHelper);
+ public AAIRestInterface aaiRestInterface(HttpsAuthClient httpsAuthClientFactory,
+ ServletRequestHelper servletRequestHelper,
+ SystemPropertyHelper systemPropertyHelper,
+ Logging loggingService) {
+ return new AAIRestInterface(httpsAuthClientFactory, servletRequestHelper, systemPropertyHelper, loggingService);
}
@Bean
- public PombaRestInterface getPombaRestInterface(HttpsAuthClient httpsAuthClientFactory, ServletRequestHelper servletRequestHelper, SystemPropertyHelper systemPropertyHelper) {
- return new PombaRestInterface(httpsAuthClientFactory, servletRequestHelper, systemPropertyHelper);
+ public PombaRestInterface getPombaRestInterface(HttpsAuthClient httpsAuthClientFactory,
+ ServletRequestHelper servletRequestHelper,
+ SystemPropertyHelper systemPropertyHelper,
+ Logging loggingService) {
+ return new PombaRestInterface(httpsAuthClientFactory, servletRequestHelper, systemPropertyHelper, loggingService);
}
@Bean
}
@Bean
- public AsdcClient sdcClient(AsdcClientConfiguration asdcClientConfiguration, SyncRestClientInterface syncRestClient) {
+ public AsdcClient sdcClient(AsdcClientConfiguration asdcClientConfiguration, Logging loggingService) {
String auth = asdcClientConfiguration.getAsdcClientAuth();
String host = asdcClientConfiguration.getAsdcClientHost();
String protocol = asdcClientConfiguration.getAsdcClientProtocol();
int port = asdcClientConfiguration.getAsdcClientPort();
- return new SdcRestClient(protocol + "://" + host + ":" + port + "/", auth, syncRestClient);
- }
-
- @Bean
- public SyncRestClientInterface syncRestClient() {
- return new SyncRestClient();
+ return new SdcRestClient(protocol + "://" + host + ":" + port + "/", auth, new SyncRestClient(loggingService), loggingService);
}
@Bean
}
@Bean
- public AaiOverTLSClientInterface aaiOverTLSClient(ObjectMapper unirestObjectMapper, SystemProperties systemProperties){
- return new AaiOverTLSClient(new SyncRestClient(unirestObjectMapper), new AaiOverTLSPropertySupplier());
+ public AaiOverTLSClientInterface aaiOverTLSClient(ObjectMapper unirestObjectMapper, SystemProperties systemProperties, Logging loggingService){
+ return new AaiOverTLSClient(
+ new SyncRestClient(unirestObjectMapper, loggingService),
+ new AaiOverTLSPropertySupplier());
}
@Bean
package org.onap.vid.mso;
+import static org.onap.vid.utils.Logging.ONAP_REQUEST_ID_HEADER_KEY;
+import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
+import static org.onap.vid.utils.Logging.getMethodCallerName;
+import static org.onap.vid.utils.Logging.getMethodName;
+
import com.att.eelf.configuration.EELFLogger;
import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.Collections;
+import java.util.Optional;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.Response;
import org.apache.commons.codec.binary.Base64;
import org.apache.http.HttpException;
import org.eclipse.jetty.util.security.Password;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
-import javax.ws.rs.client.Client;
-import javax.ws.rs.client.Entity;
-import javax.ws.rs.client.Invocation;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.Response;
-import java.util.Collections;
-import java.util.Optional;
-
-import static org.onap.vid.utils.Logging.*;
-
/**
* Created by pickjonathan on 26/06/2017.
*/
public class RestMsoImplementation implements RestInterface {
+
/**
* The logger.
*/
protected HttpsAuthClient httpsAuthClient;
protected SystemPropertiesWrapper systemProperties;
+ protected final Logging loggingService;
private static final String START_LOG = " start";
private static final String APPLICATION_JSON = "application/json";
*/
@Autowired
- protected RestMsoImplementation(HttpsAuthClient httpsAuthClient, SystemPropertiesWrapper systemProperties){
+ protected RestMsoImplementation(HttpsAuthClient httpsAuthClient, SystemPropertiesWrapper systemProperties, Logging loggingService){
this.httpsAuthClient=httpsAuthClient;
this.systemProperties = systemProperties;
+ this.loggingService = loggingService;
}
@SuppressWarnings("Duplicates")
url = systemProperties.getProperty(MsoProperties.MSO_SERVER_URL) + path;
MultivaluedHashMap<String, Object> commonHeaders = initMsoClient();
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.GET, url);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.GET, url);
final Response cres = client.target(url)
.request()
.accept(APPLICATION_JSON)
.headers(commonHeaders)
.get();
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.GET, url, cres);
+ loggingService.logResponse(outgoingRequestsLogger, HttpMethod.GET, url, cres);
cres.bufferEntity();
status = cres.getStatus();
logger.debug(EELFLoggerDelegate.debugLogger, "<== " + methodName + " sending request to url= " + url);
MultivaluedHashMap<String, Object> commonHeaders = initMsoClient();
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.GET, url);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.GET, url);
final Response cres = client.target(url)
.request()
.accept(APPLICATION_JSON)
.headers(commonHeaders)
.get();
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.GET, url, cres);
+ loggingService.logResponse(outgoingRequestsLogger, HttpMethod.GET, url, cres);
final RestObject<T> restObject = cresToRestObject(cres, clazz);
int status = cres.getStatus();
MultivaluedHashMap<String, Object> commonHeaders = initMsoClient();
url = systemProperties.getProperty(MsoProperties.MSO_SERVER_URL) + path;
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url, r);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url, r);
cres = client.target(url)
.request()
//.entity(r)
.build("DELETE", Entity.entity(r, MediaType.APPLICATION_JSON))
.invoke();
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.DELETE, url, cres);
+ loggingService.logResponse(outgoingRequestsLogger, HttpMethod.DELETE, url, cres);
int status = cres.getStatus();
restObject.setStatusCode (status);
userId.ifPresent(id->commonHeaders.put("X-RequestorID", Collections.singletonList(id)));
url = systemProperties.getProperty(MsoProperties.MSO_SERVER_URL) + path;
- Logging.logRequest(outgoingRequestsLogger, httpMethod, url, payload);
+ loggingService.logRequest(outgoingRequestsLogger, httpMethod, url, payload);
// Change the content length
final Invocation.Builder restBuilder = client.target(url)
.request()
restBuilder.build(httpMethod.name(), Entity.entity(payload, MediaType.APPLICATION_JSON));
final Response cres = restInvocation.invoke();
- Logging.logResponse(outgoingRequestsLogger, httpMethod, url, cres);
+ loggingService.logResponse(outgoingRequestsLogger, httpMethod, url, cres);
return cresToRestObject(cres, tClass);
}
catch (Exception e) {
MultivaluedHashMap<String, Object> commonHeaders = initMsoClient();
url = systemProperties.getProperty(MsoProperties.MSO_SERVER_URL) + path;
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.PUT, url, r);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.PUT, url, r);
// Change the content length
final Response cres = client.target(url)
.request()
//.header("content-length", 201)
.put(Entity.entity(r, MediaType.APPLICATION_JSON));
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.PUT, url, cres);
+ loggingService.logResponse(outgoingRequestsLogger, HttpMethod.PUT, url, cres);
try {
t = (T) cres.readEntity(t.getClass());
*/
EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(MsoRestClientNew.class);
- public MsoRestClientNew(SyncRestClient client, String baseUrl, HttpsAuthClient authClient, SystemPropertiesWrapper systemPropertiesWrapper) {
- super(authClient,systemPropertiesWrapper);
+ public MsoRestClientNew(SyncRestClient client, String baseUrl, HttpsAuthClient authClient, SystemPropertiesWrapper systemPropertiesWrapper, Logging loggingService) {
+ super(authClient,systemPropertiesWrapper, loggingService);
this.client = client;
this.baseUrl = baseUrl;
this.commonHeaders = initCommonHeaders();
package org.onap.vid.scheduler;
+import static org.onap.vid.utils.KotlinUtilsKt.JACKSON_OBJECT_MAPPER;
+import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
+
import com.att.eelf.configuration.EELFLogger;
-import com.fasterxml.jackson.core.type.TypeReference;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
import io.joshworks.restclient.http.HttpResponse;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.Map;
+import java.util.function.Function;
import org.apache.http.HttpException;
import org.eclipse.jetty.util.security.Password;
import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
import org.onap.vid.mso.RestObject;
import org.onap.vid.mso.RestObjectWithRequestInfo;
import org.onap.vid.utils.Logging;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Service;
-import java.util.Base64;
-import java.util.Collections;
-import java.util.Map;
-import java.util.function.Function;
-
-import static org.onap.vid.utils.KotlinUtilsKt.JACKSON_OBJECT_MAPPER;
-import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
-
@Service
public class SchedulerRestInterface implements SchedulerRestInterfaceIfc {
private Function<String, String> propertyGetter;
private Map<String, String> commonHeaders;
- public SchedulerRestInterface() {
- this.propertyGetter = SystemProperties::getProperty;
- }
+ private Logging loggingService;
- public SchedulerRestInterface(Function<String, String> propertyGetter) {
+ public SchedulerRestInterface(Function<String, String> propertyGetter, Logging loggingService) {
+ this.loggingService = loggingService;
this.propertyGetter = propertyGetter;
}
+ @Autowired
+ public SchedulerRestInterface(Logging loggingService) {
+ this.loggingService = loggingService;
+ this.propertyGetter = SystemProperties::getProperty;
+ }
+
public void initRestClient() {
logger.info("Starting to initialize rest client ");
String authStringEnc = calcEncodedAuthString();
commonHeaders = Maps.newHashMap();
commonHeaders.put("Authorization", "Basic " + authStringEnc);
- syncRestClient = new SyncRestClient();
+ syncRestClient = new SyncRestClient(loggingService);
logger.info("\t<== Client Initialized \n");
}
String methodName = "Get";
url = String.format("%s%s", propertyGetter.apply(SchedulerProperties.SCHEDULER_SERVER_URL_VAL), path);
initRestClient();
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.GET, url);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.GET, url);
Map<String, String> requestHeaders = ImmutableMap.<String, String>builder()
.putAll(commonHeaders)
.put(REQUEST_ID_HEADER_KEY, Logging.extractOrGenerateRequestId())
.build();
final HttpResponse<String> response = syncRestClient.get(url, requestHeaders,
Collections.emptyMap(), String.class);
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.GET, url, response);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.GET, url, response);
status = response.getStatus();
restObject.setStatusCode(status);
rawData = response.getBody();
public <T> void Delete(T t, String sourceID, String path, RestObject<T> restObject) {
initRestClient();
String url = String.format("%s%s", propertyGetter.apply(SchedulerProperties.SCHEDULER_SERVER_URL_VAL), path);
- Logging.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url);
Map<String, String> requestHeaders = ImmutableMap.<String, String>builder()
.putAll(commonHeaders)
.put(REQUEST_ID_HEADER_KEY, Logging.extractOrGenerateRequestId()).build();
final HttpResponse<T> response = (HttpResponse<T>) syncRestClient.delete(url, requestHeaders, t.getClass());
- Logging.logResponse(outgoingRequestsLogger, HttpMethod.DELETE, url, response);
+ loggingService.logRequest(outgoingRequestsLogger, HttpMethod.DELETE, url, response);
int status = response.getStatus();
restObject.setStatusCode(status);
package org.onap.vid.utils;
+import static org.apache.commons.lang3.ObjectUtils.defaultIfNull;
+import static org.apache.commons.lang3.exception.ExceptionUtils.getRootCause;
+import static org.apache.commons.lang3.exception.ExceptionUtils.getThrowableList;
+import static org.onap.vid.utils.Streams.not;
+
import com.att.eelf.configuration.EELFLogger;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.google.common.collect.ImmutableList;
import io.joshworks.restclient.http.HttpResponse;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.UUID;
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.core.Response;
import org.apache.commons.lang3.StringUtils;
-import org.onap.vid.exceptions.GenericUncheckedException;
import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
import org.onap.portalsdk.core.util.SystemProperties;
+import org.onap.vid.exceptions.GenericUncheckedException;
import org.springframework.http.HttpMethod;
+import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.ProcessingException;
-import javax.ws.rs.core.Response;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.UUID;
-
-import static org.apache.commons.lang3.ObjectUtils.defaultIfNull;
-import static org.apache.commons.lang3.exception.ExceptionUtils.getRootCause;
-import static org.apache.commons.lang3.exception.ExceptionUtils.getThrowableList;
-import static org.onap.vid.utils.Streams.not;
-
+@Service
public class Logging {
- private Logging() {
- }
-
public static final String HTTP_REQUESTS_OUTGOING = "http.requests.outgoing.";
public static final String REQUEST_ID_HEADER_KEY = SystemProperties.ECOMP_REQUEST_ID;
return EELFLoggerDelegate.getLogger(HTTP_REQUESTS_OUTGOING +serverName);
}
- public static void logRequest(final EELFLogger logger, final HttpMethod method, final String url, final Object body) {
+ public void logRequest(final EELFLogger logger, final HttpMethod method, final String url, final Object body) {
if (!logger.isDebugEnabled()) {
return;
}
}
}
- public static void logRequest(final EELFLogger logger, final HttpMethod method, final String url) {
+ public void logRequest(final EELFLogger logger, final HttpMethod method, final String url) {
logger.debug("Sending {} {}", method.name(), url);
}
- public static <T> void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final Response response, final Class<T> entityClass) {
+ public <T> void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final Response response, final Class<T> entityClass) {
if (!logger.isDebugEnabled()) {
return;
}
}
}
- public static <T> void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final HttpResponse<T> response) {
+ public <T> void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final HttpResponse<T> response) {
try {
logger.debug("Received {} {} Status: {} . Body: {}", method.name(), url, response.getStatus(), response.getBody());
}
}
}
- public static void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final Response response) {
+ public void logResponse(final EELFLogger logger, final HttpMethod method, final String url, final Response response) {
logResponse(logger, method, url, response, String.class);
}
import org.onap.vid.model.probes.HttpRequestMetadata;
import org.onap.vid.model.probes.StatusMetadata;
import org.onap.vid.testUtils.TestUtils;
+import org.onap.vid.utils.Logging;
import org.onap.vid.utils.Unchecked;
import org.springframework.http.HttpMethod;
import org.springframework.test.context.ContextConfiguration;
Response responseMock = mocks.getFakeResponse();
// prepare real AAIRestInterface and AaiClient, and wire mocks
- AAIRestInterface aaiRestInterface = new AAIRestInterface(httpsAuthClientMock, mock(ServletRequestHelper.class), mock(SystemPropertyHelper.class));
+ AAIRestInterface aaiRestInterface = new AAIRestInterface(httpsAuthClientMock,
+ mock(ServletRequestHelper.class),
+ mock(SystemPropertyHelper.class),
+ mock(Logging.class));
final AaiClient aaiClient = new AaiClient(aaiRestInterface, null, null);
when(httpsAuthClientMock.getClient(any())).thenReturn(javaxClientMock);
package org.onap.vid.aai;
+import static org.mockito.Mockito.mock;
+import static org.mockito.MockitoAnnotations.initMocks;
+
import com.fasterxml.jackson.core.JsonProcessingException;
import com.xebialabs.restito.semantics.Action;
import io.joshworks.restclient.http.HttpResponse;
import io.joshworks.restclient.http.mapper.ObjectMapper;
+import java.io.IOException;
import org.assertj.core.api.Assertions;
import org.glassfish.grizzly.http.util.HttpStatus;
+import org.jetbrains.annotations.NotNull;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.mockito.Mock;
import org.onap.vid.client.SyncRestClient;
import org.onap.vid.model.SubscriberList;
import org.onap.vid.testUtils.StubServerUtil;
+import org.onap.vid.utils.Logging;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
-import java.io.IOException;
-
-import static org.mockito.MockitoAnnotations.initMocks;
-
public class AaiOverTLSClientServerTest {
@Mock
@Test
public void shouldSearchNodeTypeByName() throws IOException, ParseException {
- ObjectMapper objectMapper = getFasterXmlObjectMapper();
- AaiOverTLSClient aaiOverTLSClient = new AaiOverTLSClient(new SyncRestClient(objectMapper), propertySupplier, serverUtil.constructTargetUrl("http", ""));
+ AaiOverTLSClient aaiOverTLSClient = createAaiOverTLSClient();
serverUtil.prepareGetCall("/nodes/generic-vnfs", new JSONParser().parse(searchNodesQueryResponsePayload), Action.status(HttpStatus.OK_200));
Assertions.assertThat(aaiNodeQueryResponseHttpResponse).isEqualTo(true);
}
+ @NotNull
+ private AaiOverTLSClient createAaiOverTLSClient() {
+ return new AaiOverTLSClient(
+ new SyncRestClient(getFasterXmlObjectMapper(), mock(Logging.class)),
+ propertySupplier,
+ serverUtil.constructTargetUrl("http", "")
+ );
+ }
+
@Test
public void shouldGetSubscribers() throws ParseException, JsonProcessingException {
ObjectMapper objectMapper = getFasterXmlObjectMapper();
- AaiOverTLSClient aaiOverTLSClient = new AaiOverTLSClient(new SyncRestClient(objectMapper), propertySupplier, serverUtil.constructTargetUrl("http", ""));
+ AaiOverTLSClient aaiOverTLSClient = createAaiOverTLSClient();
serverUtil.prepareGetCall("/business/customers", new JSONParser().parse(subscribersResponsePayload), Action.status(HttpStatus.OK_200));
package org.onap.vid.aai;
-import org.mockito.Mock;
-import org.onap.vid.aai.util.HttpClientMode;
-import org.onap.vid.aai.util.HttpsAuthClient;
-import org.onap.vid.aai.util.ServletRequestHelper;
-import org.onap.vid.aai.util.SystemPropertyHelper;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
-
-import javax.ws.rs.client.Client;
-import javax.ws.rs.client.Entity;
-import javax.ws.rs.client.Invocation;
-import javax.ws.rs.client.WebTarget;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-
-import java.io.IOException;
-import java.security.GeneralSecurityException;
-import java.util.UUID;
-import java.util.regex.Pattern;
-
import static org.assertj.core.api.Assertions.assertThat;
-
-import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.matches;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.verify;
import static org.onap.vid.aai.AaiOverTLSClientInterface.HEADERS.TRANSACTION_ID_HEADER;
import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.util.UUID;
+import java.util.regex.Pattern;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import org.mockito.Mock;
+import org.onap.vid.aai.util.HttpClientMode;
+import org.onap.vid.aai.util.HttpsAuthClient;
+import org.onap.vid.aai.util.ServletRequestHelper;
+import org.onap.vid.aai.util.SystemPropertyHelper;
+import org.onap.vid.utils.Logging;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
public class PombaRestInterfaceTest {
private static final String UUID_REGEX = "[a-f0-9]{8}(-[a-f0-9]{4}){3}-[a-f0-9]{12}";
private static final String SAMPLE_APP_ID = "vid";
@Mock
private Response response;
+ @Mock
+ private Logging loggingService;
+
private PombaRestInterface pombaRestInterface;
@BeforeMethod
when(requestHelper.extractOrGenerateRequestId()).thenReturn(UUID.randomUUID().toString());
when(authClient.getClient(HttpClientMode.WITH_KEYSTORE)).thenReturn(client);
setUpBuilder();
- pombaRestInterface = new PombaRestInterface(authClient, requestHelper, systemPropertyHelper);
+ pombaRestInterface = new PombaRestInterface(authClient, requestHelper, systemPropertyHelper, loggingService);
}
when(builder.post(any(Entity.class))).thenReturn(response);
when(response.getStatusInfo()).thenReturn(Response.Status.OK);
}
-}
\ No newline at end of file
+}
package org.onap.vid.aai.util;
+import static javax.ws.rs.core.Response.Status.BAD_REQUEST;
+import static javax.ws.rs.core.Response.Status.NOT_FOUND;
+import static javax.ws.rs.core.Response.Status.OK;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.util.Optional;
+import java.util.UUID;
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
import org.mockito.Mock;
import org.mockito.Mockito;
-
import org.onap.vid.aai.ExceptionWithRequestInfo;
import org.onap.vid.aai.exceptions.InvalidPropertyException;
import org.onap.vid.exceptions.GenericUncheckedException;
+import org.onap.vid.utils.Logging;
import org.onap.vid.utils.Unchecked;
import org.springframework.http.HttpMethod;
import org.testng.Assert;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.client.Client;
-import javax.ws.rs.client.Entity;
-import javax.ws.rs.client.Invocation;
-import javax.ws.rs.client.WebTarget;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-import java.io.UnsupportedEncodingException;
-import java.net.URI;
-import java.util.Optional;
-import java.util.UUID;
-
-import static com.google.code.beanmatchers.BeanMatchers.hasValidBeanConstructor;
-import static com.google.code.beanmatchers.BeanMatchers.hasValidGettersAndSetters;
-import static javax.ws.rs.core.Response.Status.*;
-import static junit.framework.TestCase.assertSame;
-import static junit.framework.TestCase.fail;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
public class AAIRestInterfaceTest {
private Response response;
@Mock
private SystemPropertyHelper systemPropertyHelper;
+ @Mock
+ private Logging loggingService;
+
private AAIRestInterface testSubject;
}
private AAIRestInterface createTestSubject() {
- return new AAIRestInterface(Optional.of(client), httpsAuthClient, servletRequestHelper, systemPropertyHelper);
+ return new AAIRestInterface(Optional.of(client), httpsAuthClient, servletRequestHelper, systemPropertyHelper, loggingService);
}
@Test
package org.onap.vid.aai.util;
+import static javax.ws.rs.core.Response.Status.NO_CONTENT;
+import static javax.ws.rs.core.Response.Status.OK;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Optional;
+import java.util.UUID;
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Invocation;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.Response;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.onap.vid.aai.exceptions.InvalidPropertyException;
+import org.onap.vid.utils.Logging;
import org.testng.Assert;
-import javax.servlet.http.HttpServletRequest;
-import javax.ws.rs.client.Client;
-import javax.ws.rs.client.Invocation;
-import javax.ws.rs.client.WebTarget;
-import javax.ws.rs.core.Response;
-import java.io.UnsupportedEncodingException;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Optional;
-import java.util.UUID;
-
-import static javax.ws.rs.core.Response.Status.NO_CONTENT;
-import static javax.ws.rs.core.Response.Status.OK;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
@RunWith(Parameterized.class)
public class ParametrizedAAIRestInterfaceTest {
private Response response;
@Mock
private SystemPropertyHelper systemPropertyHelper;
+ @Mock
+ private Logging loggingService;
private AAIRestInterface testSubject;
private Response.Status status;
}
private AAIRestInterface createTestSubject() {
- return new AAIRestInterface(Optional.of(client), httpsAuthClient, servletRequestHelper, systemPropertyHelper);
+ return new AAIRestInterface(Optional.of(client), httpsAuthClient, servletRequestHelper, systemPropertyHelper, loggingService);
}
@Test
- public void testRestDeleteWithValidResponse() throws Exception {
- // given
- String methodName = "Delete";
+ public void testRestDeleteWithValidResponse() {
// when
when(builder.delete()).thenReturn(response);
import static org.hamcrest.Matchers.matchesPattern;
import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
import static org.onap.vid.client.SyncRestClientInterface.HEADERS.X_ECOMP_INSTANCE_ID;
import static org.onap.vid.utils.Logging.REQUEST_ID_HEADER_KEY;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.xebialabs.restito.semantics.Call;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import org.onap.vid.asdc.beans.Service;
import org.onap.vid.client.SyncRestClient;
import org.onap.vid.testUtils.StubServerUtil;
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.xebialabs.restito.semantics.Call;
+import org.onap.vid.utils.Logging;
public class SdcRestClientITTest {
public static void setUpClass() throws GeneralSecurityException {
stubServer = new StubServerUtil();
stubServer.runSecuredServer();
- SyncRestClient syncRestClient = new SyncRestClient(createNaiveHttpClient());
+ SyncRestClient syncRestClient = new SyncRestClient(createNaiveHttpClient(), mock(Logging.class));
String serverUrl = stubServer.constructTargetUrl("https", "");
- sdcRestClient = new SdcRestClient(serverUrl, "", syncRestClient);
+ sdcRestClient = new SdcRestClient(serverUrl, "", syncRestClient, mock(Logging.class));
}
@AfterClass
import org.onap.vid.asdc.AsdcClient;
import org.onap.vid.asdc.beans.Service;
import org.onap.vid.client.SyncRestClient;
+import org.onap.vid.utils.Logging;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
@Mock
private InputStream inputStream;
+ @Mock
+ private Logging loggingService;
+
private UUID randomId;
private Service sampleService;
MockitoAnnotations.initMocks(this);
randomId = UUID.randomUUID();
sampleService = createTestService();
- restClient = new SdcRestClient(SAMPLE_BASE_URL, SAMPLE_AUTH, mockedSyncRestClient);
+ restClient = new SdcRestClient(SAMPLE_BASE_URL, SAMPLE_AUTH, mockedSyncRestClient, loggingService);
}
setupMocks.accept(syncRestClient);
try {
- new SdcRestClient(SAMPLE_BASE_URL, SAMPLE_AUTH, syncRestClient).getServiceToscaModel(UUID.randomUUID());
+ new SdcRestClient(SAMPLE_BASE_URL, SAMPLE_AUTH, syncRestClient, loggingService).getServiceToscaModel(UUID.randomUUID());
} catch (Exception e) {
assertThat("root cause incorrect for " + ExceptionUtils.getStackTrace(e), ExceptionUtils.getRootCause(e), instanceOf(expectedType));
return; //OK
setupMocks.accept(mockResponse);
try {
- new SdcRestClient(SAMPLE_BASE_URL, SAMPLE_AUTH, syncRestClient).getServiceToscaModel(UUID.randomUUID());
+ new SdcRestClient(SAMPLE_BASE_URL, SAMPLE_AUTH, syncRestClient, loggingService).getServiceToscaModel(UUID.randomUUID());
} catch (AsdcCatalogException e) {
assertThat(e.getMessage(), containsString(String.valueOf(mockResponse.getStatus())));
assertThat(e.getMessage(), containsString(exceptedBody));
package org.onap.vid.client;
+import static com.xebialabs.restito.builder.stub.StubHttp.whenHttp;
+import static com.xebialabs.restito.builder.verify.VerifyHttp.verifyHttp;
+import static com.xebialabs.restito.semantics.Action.contentType;
+import static com.xebialabs.restito.semantics.Action.ok;
+import static com.xebialabs.restito.semantics.Action.status;
+import static com.xebialabs.restito.semantics.Action.stringContent;
+import static org.mockito.Mockito.mock;
+import static org.testng.Assert.assertEquals;
+
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.ImmutableMap;
+import com.xebialabs.restito.semantics.Action;
import com.xebialabs.restito.semantics.Condition;
import com.xebialabs.restito.server.StubServer;
import io.joshworks.restclient.http.HttpResponse;
import io.joshworks.restclient.http.JsonNode;
+import java.util.Collections;
+import java.util.Map;
+import org.glassfish.grizzly.http.Method;
import org.glassfish.grizzly.http.util.HttpStatus;
-import com.xebialabs.restito.semantics.Action;
-import org.testng.annotations.BeforeMethod;
+import org.onap.vid.utils.Logging;
import org.testng.annotations.AfterMethod;
-import org.glassfish.grizzly.http.Method;
+import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
-import java.util.Collections;
-import java.util.Map;
-
-import static com.xebialabs.restito.builder.verify.VerifyHttp.verifyHttp;
-import static com.xebialabs.restito.builder.stub.StubHttp.whenHttp;
-import static com.xebialabs.restito.semantics.Action.stringContent;
-import static com.xebialabs.restito.semantics.Action.contentType;
-import static com.xebialabs.restito.semantics.Action.status;
-import static com.xebialabs.restito.semantics.Action.ok;
-import static org.testng.Assert.assertEquals;
-
public class SyncRestClientForHttpServerTest {
private static final SyncRestClientModel.TestModel testObject = new SyncRestClientModel.TestModel(1, "test");
private StubServer stubServer;
private ObjectMapper objectMapper = new ObjectMapper();
private SyncRestClient syncRestClient;
+ private Logging mockLoggingService;
@BeforeMethod
public void setUp() {
stubServer = new StubServer();
stubServer.run();
- syncRestClient = new SyncRestClient();
+ mockLoggingService = mock(Logging.class);
+ syncRestClient = new SyncRestClient(mockLoggingService);
}
@AfterMethod
package org.onap.vid.client;
+import static com.xebialabs.restito.builder.stub.StubHttp.whenHttp;
+import static com.xebialabs.restito.builder.verify.VerifyHttp.verifyHttp;
+import static com.xebialabs.restito.semantics.Action.contentType;
+import static com.xebialabs.restito.semantics.Action.ok;
+import static com.xebialabs.restito.semantics.Action.stringContent;
+import static org.apache.http.client.config.RequestConfig.custom;
+import static org.mockito.Mockito.mock;
+import static org.testng.Assert.assertEquals;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.xebialabs.restito.semantics.Action;
+import com.xebialabs.restito.semantics.Condition;
+import com.xebialabs.restito.server.StubServer;
import io.joshworks.restclient.http.HttpResponse;
import io.joshworks.restclient.http.JsonNode;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
+import java.security.GeneralSecurityException;
+import java.util.Collections;
+import javax.net.ssl.SSLContext;
+import org.apache.http.config.Registry;
+import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
-import com.fasterxml.jackson.core.JsonProcessingException;
+import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
-import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
-import org.apache.http.conn.ssl.SSLContextBuilder;
-import com.xebialabs.restito.semantics.Condition;
-import com.xebialabs.restito.server.StubServer;
-import com.xebialabs.restito.semantics.Action;
-import org.apache.http.config.RegistryBuilder;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.AfterMethod;
+import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.glassfish.grizzly.http.Method;
-import org.apache.http.client.HttpClient;
-import org.apache.http.config.Registry;
+import org.onap.vid.utils.Logging;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
-import java.security.GeneralSecurityException;
-import javax.net.ssl.SSLContext;
-import java.util.Collections;
-
-import static com.xebialabs.restito.builder.verify.VerifyHttp.verifyHttp;
-import static com.xebialabs.restito.builder.stub.StubHttp.whenHttp;
-import static com.xebialabs.restito.semantics.Action.stringContent;
-import static com.xebialabs.restito.semantics.Action.contentType;
-import static org.apache.http.client.config.RequestConfig.custom;
-import static com.xebialabs.restito.semantics.Action.ok;
-import static org.testng.Assert.assertEquals;
-
public class SyncRestClientForHttpsServerTest {
private static final SyncRestClientModel.TestModel testObject = new SyncRestClientModel.TestModel(1, "test");
private ObjectMapper objectMapper = new ObjectMapper();
private SyncRestClient syncRestClient;
+ private Logging mockLoggingService;
@BeforeMethod
public void setUp() throws GeneralSecurityException {
stubServer = new StubServer();
stubServer.secured().run();
- syncRestClient = new SyncRestClient(createNaiveHttpClient());
+ mockLoggingService = mock(Logging.class);
+ syncRestClient = new SyncRestClient(createNaiveHttpClient(), mockLoggingService);
}
@AfterMethod
import javax.servlet.ServletContext;
import org.onap.vid.aai.AaiClient;
import org.onap.vid.aai.AaiClientInterface;
-import org.onap.vid.aai.AaiOverTLSClientInterface;
import org.onap.vid.aai.AaiResponseTranslator;
import org.onap.vid.aai.model.PortDetailsTranslator;
import org.onap.vid.aai.util.AAIRestInterface;
import org.onap.vid.services.AaiServiceImpl;
import org.onap.vid.services.VidService;
import org.onap.vid.services.VidServiceImpl;
+import org.onap.vid.utils.Logging;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
}
@Bean(name = "aaiRestInterface")
- public AAIRestInterface aaiRestInterface(HttpsAuthClient httpsAuthClientFactory, ServletRequestHelper servletRequestHelper, SystemPropertyHelper systemPropertyHelper) {
- return new AAIRestInterface(httpsAuthClientFactory, servletRequestHelper, systemPropertyHelper);
+ public AAIRestInterface aaiRestInterface(HttpsAuthClient httpsAuthClientFactory,
+ ServletRequestHelper servletRequestHelper,
+ SystemPropertyHelper systemPropertyHelper,
+ Logging loggingService) {
+ return new AAIRestInterface(httpsAuthClientFactory, servletRequestHelper, systemPropertyHelper, loggingService);
}
@Bean
* VID
* ================================================================================
* Copyright (C) 2019 Nokia Intellectual Property. All rights reserved.
+ * Modifications Copyright (C) 2017 - 2019 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.
package org.onap.vid.mso;
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
+
import io.joshworks.restclient.request.HttpRequest;
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.util.Optional;
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
import org.glassfish.jersey.client.JerseyInvocation;
import org.mockito.InjectMocks;
import org.mockito.Mock;
+import org.onap.vid.aai.util.HttpClientMode;
import org.onap.vid.aai.util.HttpsAuthClient;
import org.onap.vid.changeManagement.RequestDetailsWrapper;
import org.onap.vid.exceptions.GenericUncheckedException;
import org.onap.vid.mso.rest.RequestDetails;
+import org.onap.vid.utils.Logging;
import org.onap.vid.utils.SystemPropertiesWrapper;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
-import javax.ws.rs.client.Client;
-import javax.ws.rs.client.Entity;
-import javax.ws.rs.client.WebTarget;
-import javax.ws.rs.core.MultivaluedHashMap;
-import javax.ws.rs.core.MultivaluedMap;
-import javax.ws.rs.core.Response;
-
-import java.util.Optional;
-
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
public class RestMsoImplementationTest {
@Mock
@Mock
private SystemPropertiesWrapper systemProperties;
+ @Mock
+ private Logging loggingService;
+
@InjectMocks
- private RestMsoImplementation restMsoImplementation = new RestMsoImplementation(mockHttpsAuthClient, systemProperties);
+ private RestMsoImplementation restMsoImplementation;
private String path = "/test_path/";
private String rawData = "test-row-data";
@BeforeClass
- public void setUp(){
+ public void setUp() throws GeneralSecurityException, IOException {
initMocks(this);
+ when(mockHttpsAuthClient.getClient(any(HttpClientMode.class))).thenReturn(mockClient);
when(systemProperties.getProperty(MsoProperties.MSO_PASSWORD)).thenReturn("OBF:1ghz1kfx1j1w1m7w1i271e8q1eas1hzj1m4i1iyy1kch1gdz");
}
import org.onap.vid.mso.MsoResponseWrapper;
import org.onap.vid.mso.MsoResponseWrapperInterface;
import org.onap.vid.mso.RestObject;
+import org.onap.vid.utils.Logging;
import org.onap.vid.utils.SystemPropertiesWrapper;
import org.springframework.test.context.ContextConfiguration;
String sourceId = "";
String endpoint = "";
final SyncRestClient client = mock(SyncRestClient.class);
- MsoRestClientNew testSubject = new MsoRestClientNew(client, "", null, new SystemPropertiesWrapper());
+ MsoRestClientNew testSubject = new MsoRestClientNew(client, "", null, new SystemPropertiesWrapper(), mock(Logging.class));
// setup
final HttpResponse<String> response = mock(HttpResponse.class);
private MsoRestClientNew msoRestClient() {
final WebConfig webConfig = new WebConfig();
- return new MsoRestClientNew(new SyncRestClient(webConfig.unirestFasterxmlObjectMapper(new ObjectMapper())), baseUrl(), null, new SystemPropertiesWrapper());
+ return new MsoRestClientNew(new SyncRestClient(webConfig.unirestFasterxmlObjectMapper(new ObjectMapper()), mock(Logging.class)),
+ baseUrl(), null, new SystemPropertiesWrapper(), mock(Logging.class));
}
private MsoRestClientNew createTestSubject() {
- return new MsoRestClientNew(null, "", null, new SystemPropertiesWrapper());
+ return new MsoRestClientNew(null, "", null, new SystemPropertiesWrapper(), mock(Logging.class));
}
}
import org.onap.vid.mso.MsoUtil;
import org.onap.vid.mso.RestObject;
import org.onap.vid.mso.model.RequestReferences;
+import org.onap.vid.utils.Logging;
import org.onap.vid.utils.SystemPropertiesWrapper;
import org.springframework.http.HttpMethod;
import org.springframework.test.context.ContextConfiguration;
@Mock
private SystemPropertiesWrapper systemProperties;
+ @Mock
+ private Logging loggingService;
+
private MsoRestClientNew restClient;
initMocks(this);
when(systemProperties.getProperty(MsoProperties.MSO_PASSWORD)).thenReturn("OBF:1ghz1kfx1j1w1m7w1i271e8q1eas1hzj1m4i1iyy1kch1gdz");
when(systemProperties.getProperty("app_display_name")).thenReturn("vid");
- restClient = new MsoRestClientNew(client,baseUrl,null,systemProperties);
+ restClient = new MsoRestClientNew(client,baseUrl,null,systemProperties,loggingService);
}
@Test
import org.onap.vid.aai.util.SystemPropertyHelper;
import org.onap.vid.controller.filter.PromiseEcompRequestIdFilter;
import org.onap.vid.testUtils.TestUtils;
+import org.onap.vid.utils.Logging;
import org.onap.vid.utils.Unchecked;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.web.context.request.RequestContextHolder;
@Mock
private ServletRequestHelper servletRequestHelper;
+ @Mock
+ private Logging loggingService;
+
@InjectMocks
private AAIRestInterface aaiRestInterface;
package org.onap.vid.scheduler;
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.mockito.Mockito.mock;
+
import com.fasterxml.jackson.core.JsonProcessingException;
import com.xebialabs.restito.semantics.Action;
+import java.util.HashMap;
+import java.util.Map;
import org.glassfish.grizzly.http.util.HttpStatus;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.mockito.junit.MockitoJUnitRunner;
import org.onap.vid.mso.RestObject;
import org.onap.vid.testUtils.StubServerUtil;
+import org.onap.vid.utils.Logging;
import org.testng.annotations.AfterMethod;
-import java.util.HashMap;
-import java.util.Map;
-
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
-
@RunWith(MockitoJUnitRunner.class)
public class SchedulerRestInterfaceTest {
put(SchedulerProperties.SCHEDULER_SERVER_URL_VAL, SAMPLE_SCHEDULER_SERVER_URL);
}};
private static StubServerUtil serverUtil;
- private static SchedulerRestInterface schedulerInterface = new SchedulerRestInterface((key) -> DUMMY_SYSTEM_PROPERTIES.get(key));
+ private static SchedulerRestInterface schedulerInterface = new SchedulerRestInterface((key) -> DUMMY_SYSTEM_PROPERTIES.get(key), mock(Logging.class));
@BeforeClass
public static void setUpClass() {
Code Review / vid.git / commitdiff