package org.onap.so.client.sdnc.lcm;
import java.net.URI;
-import java.util.Map;
import java.util.Optional;
-import org.onap.so.client.RestClient;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
import org.onap.logging.filter.base.ONAPComponents;
+import org.onap.so.client.RestClient;
import org.onap.so.client.sdnc.lcm.beans.LcmInput;
import org.onap.so.client.sdnc.lcm.beans.LcmOutput;
import org.onap.so.client.sdnc.lcm.beans.LcmRestRequest;
}
@Override
- protected void initializeHeaderMap(Map<String, String> headerMap) {
- headerMap.put("Authorization", sdncLcmProperties.getBasicAuth());
+ protected void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap) {
+ headerMap.add("ALL", Pair.with("Authorization", sdncLcmProperties.getBasicAuth()));
}
@Override
package org.onap.so.client;
+import static org.apache.commons.lang3.StringUtils.isNotBlank;
import java.net.URL;
-import java.util.Map;
import java.util.Optional;
-import static org.apache.commons.lang3.StringUtils.*;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
import org.onap.logging.filter.base.ONAPComponentsList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- protected void initializeHeaderMap(Map<String, String> headerMap) {}
+ protected void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap) {}
@Override
protected Optional<ResponseExceptionMapper> addResponseExceptionMapper() {
public void addAdditionalHeader(String name, String value) {
try {
if (isNotBlank(name) && isNotBlank(value)) {
- headerMap.put(name, value);
+ headerMap.add("ALL", Pair.with(name, value));
} else {
log.warn("Not adding " + name + " to headers.");
}
import java.time.Duration;
import java.util.ArrayList;
import java.util.Base64;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.function.Predicate;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.GenericType;
import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriBuilder;
+import org.javatuples.Pair;
import org.onap.logging.filter.base.MDCSetup;
import org.onap.logging.filter.base.ONAPComponentsList;
import org.onap.logging.filter.base.PayloadLoggingClientFilter;
private static final int MAX_PAYLOAD_SIZE = 1024 * 1024;
private WebTarget webTarget;
- protected final Map<String, String> headerMap;
+ protected final MultivaluedMap<String, Pair<String, String>> headerMap;
protected final Logger logger = LoggerFactory.getLogger(RestClient.class);
protected URL host;
protected Optional<URI> path;
protected RestClient(RestProperties props, Optional<URI> path) {
- headerMap = new HashMap<>();
+ headerMap = new MultivaluedHashMap<>();
try {
host = props.getEndpoint();
} catch (MalformedURLException e) {
}
protected RestClient(URL host, String contentType) {
- headerMap = new HashMap<>();
+ headerMap = new MultivaluedHashMap<>();
this.path = Optional.empty();
this.host = host;
this.contentType = contentType;
}
protected RestClient(URL host, String acceptType, String contentType) {
- headerMap = new HashMap<>();
+ headerMap = new MultivaluedHashMap<>();
this.path = Optional.empty();
this.host = host;
this.accept = acceptType;
return MAX_PAYLOAD_SIZE;
}
- protected Builder getBuilder() {
+ protected Builder getBuilder(String method) {
if (webTarget == null) {
initializeClient(getClient());
}
Builder builder = webTarget.request();
initializeHeaderMap(headerMap);
- for (Entry<String, String> entry : headerMap.entrySet()) {
- builder.header(entry.getKey(), entry.getValue());
+ if (headerMap.containsKey("ALL")) {
+ for (Pair<String, String> pair : headerMap.get("ALL")) {
+ builder.header(pair.getValue0(), pair.getValue1());
+ }
+ }
+
+ if (headerMap.containsKey(method)) {
+ for (Pair<String, String> pair : headerMap.get(method)) {
+ builder.header(pair.getValue0(), pair.getValue1());
+ }
}
return builder;
}
return this.webTarget;
}
- protected abstract void initializeHeaderMap(Map<String, String> headerMap);
+ protected abstract void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap);
protected Optional<ResponseExceptionMapper> addResponseExceptionMapper() {
return Optional.of(new ResponseExceptionMapperImpl());
try {
byte[] decryptedAuth = CryptoUtils.decrypt(auth, key).getBytes();
String authHeaderValue = "Basic " + Base64.getEncoder().encodeToString(decryptedAuth);
- headerMap.put("Authorization", authHeaderValue);
+ headerMap.add("ALL", Pair.with("Authorization", authHeaderValue));
} catch (GeneralSecurityException e) {
logger.error(e.getMessage(), e);
}
import java.net.MalformedURLException;
import java.net.URL;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
public interface RestProperties {
public default CacheProperties getCacheProperties() {
return new CacheProperties() {};
}
+
+ public default MultivaluedMap<String, Pair<String, String>> additionalHeaders() {
+ return new MultivaluedHashMap<>();
+ }
}
if (clazz.isAssignableFrom(item.getClass())) {
try {
if (forceNewInstance) {
- result = (T) item.getClass().newInstance();
+ return (T) item.getClass().newInstance();
} else {
- result = (T) item;
+ return (T) item;
}
} catch (InstantiationException | IllegalAccessException e) {
/*
public Response get() throws Exception {
final Response response;
if ("GET".equals(method)) {
- response = this.client.getBuilder().accept(this.client.getAccept()).get();
+ response = this.client.getBuilder(method).accept(this.client.getAccept()).get();
} else if ("POST".equals(method)) {
- response = this.client.getBuilder().accept(this.client.getAccept())
+ response = this.client.getBuilder(method).accept(this.client.getAccept())
.post(Entity.entity(entity, this.client.getContentType()));
} else if ("PATCH".equals(method)) {
- response = this.client.getBuilder().header("X-HTTP-Method-Override", "PATCH")
+ response = this.client.getBuilder(method).header("X-HTTP-Method-Override", "PATCH")
.accept(this.client.getAccept()).post(Entity.entity(entity, this.client.getMergeContentType()));
} else if ("DELETE".equals(method)) {
if (entity == null) {
- response = this.client.getBuilder().accept(this.client.getAccept()).delete();
+ response = this.client.getBuilder(method).accept(this.client.getAccept()).delete();
} else {
- response = this.client.getBuilder().accept(this.client.getAccept())
+ response = this.client.getBuilder(method).accept(this.client.getAccept())
.build(HttpMethod.DELETE, Entity.entity(entity, this.client.getContentType())).invoke();
}
} else if ("PUT".equals(method)) {
- response = this.client.getBuilder().accept(this.client.getAccept())
+ response = this.client.getBuilder(method).accept(this.client.getAccept())
.put(Entity.entity(entity, this.client.getContentType()));
} else {
response = Response.serverError().entity(method + " not valid").build();
import java.net.URI;
import java.security.GeneralSecurityException;
-import java.util.Map;
import java.util.Optional;
+import javax.ws.rs.core.MultivaluedMap;
import org.apache.commons.codec.binary.Base64;
+import org.javatuples.Pair;
+import org.onap.logging.filter.base.ONAPComponents;
import org.onap.so.client.RestClient;
import org.onap.so.client.policy.CommonObjectMapperProvider;
import org.onap.so.client.policy.JettisonStyleMapperProvider;
import org.onap.so.utils.CryptoUtils;
-import org.onap.logging.filter.base.ONAPComponents;
public class AdapterRestClient extends RestClient {
}
@Override
- protected void initializeHeaderMap(Map<String, String> headerMap) {
- headerMap.put("Authorization",
- this.getBasicAuth(adapterRestProperties.getAuth(), adapterRestProperties.getKey()));
+ protected void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap) {
+ headerMap.add("ALL", Pair.with("Authorization",
+ this.getBasicAuth(adapterRestProperties.getAuth(), adapterRestProperties.getKey())));
}
@Override
package org.onap.so.client.dmaap.rest;
import java.net.URL;
-import java.util.Map;
import java.util.UUID;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
+import org.onap.logging.filter.base.ONAPComponents;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import org.onap.so.client.RestClient;
import org.onap.logging.filter.base.ONAPComponents;
}
@Override
- protected void initializeHeaderMap(Map<String, String> headerMap) {
+ protected void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap) {
if (auth != null && !auth.isEmpty() && key != null && !key.isEmpty()) {
addBasicAuthHeader(auth, key);
}
String onapRequestId = UUID.randomUUID().toString();
- headerMap.put(ONAPLogConstants.Headers.REQUEST_ID, onapRequestId);
+ headerMap.add("ALL", Pair.with(ONAPLogConstants.Headers.REQUEST_ID, onapRequestId));
if (MDC.get(ONAPLogConstants.MDCs.REQUEST_ID) != null) {
- headerMap.put(ONAPLogConstants.Headers.INVOCATION_ID, MDC.get(ONAPLogConstants.MDCs.REQUEST_ID));
+ headerMap.add("ALL",
+ Pair.with(ONAPLogConstants.Headers.INVOCATION_ID, MDC.get(ONAPLogConstants.MDCs.REQUEST_ID)));
}
}
}
import java.net.URI;
-import java.util.Map;
import java.util.Optional;
-import org.onap.so.client.RestClient;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
import org.onap.logging.filter.base.ONAPComponents;
+import org.onap.so.client.RestClient;
public class GRMRestClient extends RestClient {
}
@Override
- protected void initializeHeaderMap(Map<String, String> headerMap) {
+ protected void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap) {
String auth = properties.getAuth();
String key = properties.getKey();
package org.onap.so.client.policy;
-import java.util.Map;
import java.util.Optional;
+import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.UriBuilder;
+import org.javatuples.Pair;
+import org.onap.logging.filter.base.ONAPComponents;
import org.onap.so.client.RestClient;
import org.onap.so.client.policy.entities.PolicyServiceType;
-import org.onap.logging.filter.base.ONAPComponents;
public class PolicyRestClient extends RestClient {
}
@Override
- protected void initializeHeaderMap(Map<String, String> headerMap) {
- headerMap.put("ClientAuth", properties.getClientAuth());
- headerMap.put("Authorization", properties.getAuth());
- headerMap.put("Environment", properties.getEnvironment());
+ protected void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap) {
+ headerMap.add("ALL", Pair.with("ClientAuth", properties.getClientAuth()));
+ headerMap.add("ALL", Pair.with("Authorization", properties.getAuth()));
+ headerMap.add("ALL", Pair.with("Environment", properties.getEnvironment()));
}
}
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
-import java.util.Map;
import java.util.Optional;
import javax.ws.rs.NotFoundException;
import javax.ws.rs.ProcessingException;
import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriBuilderException;
+import org.javatuples.Pair;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
RestClient client = new RestClient(props, Optional.of(new URI("/chunked/delayed"))) {
@Override
- protected void initializeHeaderMap(Map<String, String> headerMap) {
+ protected void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap) {
// TODO Auto-generated method stub
}
package org.onap.so.client.adapter.rest;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.entry;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.GeneralSecurityException;
-import java.util.HashMap;
-import java.util.Map;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
import org.apache.commons.codec.binary.Base64;
+import org.javatuples.Pair;
import org.junit.Before;
import org.junit.Test;
+import org.onap.logging.filter.base.ONAPComponents;
import org.onap.so.client.policy.JettisonStyleMapperProvider;
import org.onap.so.utils.CryptoUtils;
-import org.onap.logging.filter.base.ONAPComponents;
public class AdapterRestClientTest {
private static final String CRYPTO_KEY = "546573746F736973546573746F736973";
private static final String INVALID_CRYPTO_KEY = "1234";
- private Map<String, String> headerMap;
+ private MultivaluedMap<String, Pair<String, String>> headerMap;
private AdapterRestProperties adapterRestPropertiesMock;
@Before
public void setup() {
- headerMap = new HashMap<>();
+ headerMap = new MultivaluedHashMap<>();
+
adapterRestPropertiesMock = mock(AdapterRestProperties.class);
}
// when
testedObject.initializeHeaderMap(headerMap);
// then
- assertThat(headerMap).containsOnly(entry("Authorization", getExpectedEncodedString(encyptedMessage)));
+ assertThat(headerMap.get("ALL"))
+ .containsOnly(Pair.with("Authorization", getExpectedEncodedString(encyptedMessage)));
}
@Test
// when
testedObject.initializeHeaderMap(headerMap);
// then
- assertThat(headerMap).containsOnly(entry("Authorization", null));
+ assertThat(headerMap.get("ALL")).containsOnly(Pair.with("Authorization", null));
}
@Test
// when
testedObject.initializeHeaderMap(headerMap);
// then
- assertThat(headerMap).containsOnly(entry("Authorization", null));
+ assertThat(headerMap.get("ALL")).containsOnly(Pair.with("Authorization", null));
}
@Test
import static org.junit.Assert.assertNotNull;
import java.net.MalformedURLException;
import java.net.URL;
-import java.util.HashMap;
-import java.util.Map;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
import org.junit.Test;
import org.onap.logging.ref.slf4j.ONAPLogConstants;
import org.slf4j.MDC;
throw new RuntimeException(e);
}
DMaaPRestClient client = new DMaaPRestClient(url, contentType, auth, key);
- Map<String, String> map = new HashMap<>();
+ MultivaluedMap<String, Pair<String, String>> map = new MultivaluedHashMap<>();
client.initializeHeaderMap(map);
- map.put(ONAPLogConstants.MDCs.REQUEST_ID, "1234");
+ map.add("ALL", Pair.with(ONAPLogConstants.MDCs.REQUEST_ID, "1234"));
assertNotNull(map);
- assertEquals("Found expected RequesttId", "1234", map.get(ONAPLogConstants.MDCs.REQUEST_ID));
+ assertEquals("Found expected RequestId", true,
+ map.get("ALL").contains(Pair.with(ONAPLogConstants.MDCs.REQUEST_ID, "1234")));
}
}
MDC.put(ONAPLogConstants.MDCs.REQUEST_ID, "1234");
DMaaPRestClient client = new DMaaPRestClient(url, contentType, auth, key);
- Map<String, String> map = new HashMap<>();
+ MultivaluedMap<String, Pair<String, String>> map = new MultivaluedHashMap<>();
client.initializeHeaderMap(map);
assertNotNull(map);
- assertEquals("Found expected RequestId", "1234", map.get(ONAPLogConstants.Headers.INVOCATION_ID));
+ assertEquals("Found expected RequestId", true,
+ map.get("ALL").contains(Pair.with(ONAPLogConstants.Headers.INVOCATION_ID, "1234")));
}
MDC.put(ONAPLogConstants.MDCs.REQUEST_ID, null);
DMaaPRestClient client = new DMaaPRestClient(url, contentType, auth, key);
- Map<String, String> map = new HashMap<>();
+ MultivaluedMap<String, Pair<String, String>> map = new MultivaluedHashMap<>();
client.initializeHeaderMap(map);
assertNotNull(map);
- assertEquals("header not found as expected", null, map.get(ONAPLogConstants.Headers.INVOCATION_ID));
+ assertEquals("header not found as expected", false,
+ map.get("ALL").contains(Pair.with(ONAPLogConstants.Headers.INVOCATION_ID, "1234")));
}
}
package org.onap.so.client.policy;
import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
-import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.assertj.core.api.Assertions.assertThat;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.onap.so.client.policy.entities.PolicyDecision;
import org.onap.so.client.policy.entities.PolicyDecisionRequest;
import org.onap.so.client.policy.entities.PolicyServiceType;
+import org.onap.so.client.policy.entities.Workstep;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
-import org.onap.so.client.policy.entities.Workstep;
public class PolicyClientImplTest {
@Test
public void successReadProperties() {
PolicyRestClient client = new PolicyRestClient(new PolicyRestPropertiesImpl(), PolicyServiceType.GET_DECISION);
- Map<String, String> map = new HashMap<>();
+ MultivaluedMap<String, Pair<String, String>> map = new MultivaluedHashMap<>();
client.initializeHeaderMap(map);
- assertEquals("Found expected Client Auth", "Basic bTAzNzQzOnBvbGljeVIwY2sk", map.get("ClientAuth"));
- assertEquals("Found expected Authorization", "Basic dGVzdHBkcDphbHBoYTEyMw==", map.get("Authorization"));
- assertEquals("Found expected Environment", "TEST", map.get("Environment"));
+ assertTrue("Found expected Client Auth",
+ map.get("ALL").contains(Pair.with("ClientAuth", "Basic bTAzNzQzOnBvbGljeVIwY2sk")));
+ assertTrue("Found expected Authorization",
+ map.get("ALL").contains(Pair.with("Authorization", "Basic dGVzdHBkcDphbHBoYTEyMw==")));
+ assertTrue("Found expected Environment", map.get("ALL").contains(Pair.with("Environment", "TEST")));
}
@Test
package org.onap.aaiclient.client.aai;
import java.net.URI;
-import java.util.HashMap;
-import java.util.Map;
import javax.ws.rs.NotFoundException;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.UriBuilder;
+import org.javatuples.Pair;
import org.onap.aaiclient.client.graphinventory.GraphInventoryClient;
import org.onap.aaiclient.client.graphinventory.exceptions.GraphInventoryUriComputationException;
import org.onap.so.client.RestClient;
protected AAIVersion version;
protected AAIClient() {
- super(AAIProperties.class, new HashMap<String, String>());
+ super(AAIProperties.class, new MultivaluedHashMap<>());
}
protected AAIClient(AAIVersion version) {
- super(AAIProperties.class, new HashMap<String, String>());
+ super(AAIProperties.class, new MultivaluedHashMap<>());
this.version = version;
}
- protected AAIClient(Map<String, String> additionalHeaders) {
+ protected AAIClient(MultivaluedMap<String, Pair<String, String>> additionalHeaders) {
super(AAIProperties.class, additionalHeaders);
}
- protected AAIClient(AAIVersion version, Map<String, String> additionalHeaders) {
+ protected AAIClient(AAIVersion version, MultivaluedMap<String, Pair<String, String>> additionalHeaders) {
super(AAIProperties.class, additionalHeaders);
this.version = version;
}
package org.onap.aaiclient.client.aai;
+import javax.ws.rs.core.MultivaluedHashMap;
+import org.javatuples.Pair;
import org.onap.aaiclient.client.aai.entities.AAIResultWrapper;
import org.onap.aaiclient.client.aai.entities.uri.AAIFluentTypeReverseLookup;
import org.onap.aaiclient.client.aai.entities.uri.AAIUriFactory;
extends GraphInventoryQueryClient<AAIDSLQueryClient, DSLQuery, AAIResultWrapper, AAIObjectType> {
public AAIDSLQueryClient() {
- super(new AAIClient(ImmutableMap.of("X-DslApiVersion", "V2")));
+ super(new AAIClient(new MultivaluedHashMap<String, Pair<String, String>>(
+ ImmutableMap.of("ALL", Pair.with("X-DslApiVersion", "V2")))));
+
}
public AAIDSLQueryClient(AAIVersion version) {
- super(new AAIClient(version, ImmutableMap.of("X-DslApiVersion", "V2")));
+ super(new AAIClient(version, new MultivaluedHashMap<String, Pair<String, String>>(
+ ImmutableMap.of("ALL", Pair.with("X-DslApiVersion", "V2")))));
}
@Override
package org.onap.aaiclient.client.aai;
import java.net.URI;
-import java.util.Map;
import java.util.Optional;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
import org.onap.aaiclient.client.graphinventory.GraphInventoryPatchConverter;
import org.onap.aaiclient.client.graphinventory.GraphInventoryRestClient;
import org.onap.logging.filter.base.ONAPComponents;
public class AAIRestClient extends GraphInventoryRestClient {
private final AAIProperties aaiProperties;
- private final Map<String, String> additionalHeaders;
+ private final MultivaluedMap<String, Pair<String, String>> additionalHeaders;
- protected AAIRestClient(AAIProperties props, URI uri, Map<String, String> additionalHeaders) {
+ protected AAIRestClient(AAIProperties props, URI uri,
+ MultivaluedMap<String, Pair<String, String>> additionalHeaders) {
super(props, uri);
this.aaiProperties = props;
this.additionalHeaders = additionalHeaders;
}
@Override
- protected void initializeHeaderMap(Map<String, String> headerMap) {
- headerMap.put("X-FromAppId", aaiProperties.getSystemName());
- headerMap.put("X-TransactionId", requestId);
- headerMap.putAll(additionalHeaders);
+ protected void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap) {
+ headerMap.add("ALL", Pair.with("X-FromAppId", aaiProperties.getSystemName()));
+ headerMap.add("ALL", Pair.with("X-TransactionId", requestId));
+ additionalHeaders.forEach((k, v) -> {
+ headerMap.addAll(k, v);
+ });
String auth = aaiProperties.getAuth();
String key = aaiProperties.getKey();
if (auth != null && !auth.isEmpty() && key != null && !key.isEmpty()) {
addBasicAuthHeader(auth, key);
}
+
+ if (!aaiProperties.additionalHeaders().isEmpty()) {
+ aaiProperties.additionalHeaders().forEach((k, v) -> {
+ headerMap.addAll(k, v);
+ });
+ }
}
@Override
package org.onap.aaiclient.client.graphinventory;
import java.net.URI;
-import java.util.Map;
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import org.javatuples.Pair;
import org.onap.aaiclient.client.graphinventory.entities.uri.GraphInventoryUri;
import org.onap.aaiclient.client.graphinventory.entities.uri.HttpAwareUri;
import org.onap.so.client.RestClient;
import org.onap.so.client.RestProperties;
import org.onap.so.client.RestPropertiesLoader;
-import com.google.common.collect.ImmutableMap;
public abstract class GraphInventoryClient {
private RestProperties props;
- protected final Map<String, String> additionalHeaders;
+ protected final MultivaluedMap<String, Pair<String, String>> additionalHeaders;
protected GraphInventoryClient(Class<? extends RestProperties> propertiesClass,
- Map<String, String> additionalHeaders) {
-
+ MultivaluedMap<String, Pair<String, String>> additionalHeaders) {
RestProperties props = RestPropertiesLoader.getInstance().getNewImpl(propertiesClass);
this.props = props;
this.additionalHeaders = additionalHeaders;
public abstract String getGraphDBName();
- public Map<String, String> getAdditionalHeaders() {
- return ImmutableMap.copyOf(this.additionalHeaders);
+ public MultivaluedMap<String, Pair<String, String>> getAdditionalHeaders() {
+ return new MultivaluedHashMap<>(this.additionalHeaders);
}
}
package org.onap.aaiclient.client.graphinventory;
import java.net.URI;
-import java.util.Map;
import java.util.Optional;
import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
+import org.javatuples.Pair;
import org.onap.aaiclient.client.CacheControlFeature;
import org.onap.aaiclient.client.FlushCache;
import org.onap.logging.filter.base.ONAPComponentsList;
public abstract ONAPComponentsList getTargetEntity();
@Override
- protected abstract void initializeHeaderMap(Map<String, String> headerMap);
+ protected abstract void initializeHeaderMap(MultivaluedMap<String, Pair<String, String>> headerMap);
@Override
protected abstract Optional<ResponseExceptionMapper> addResponseExceptionMapper();
package org.onap.aaiclient.client.aai;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import java.net.URISyntaxException;
+import org.javatuples.Pair;
import org.junit.Test;
public class AAIDSLQueryClientTest {
public void verifyHeadersTest() throws URISyntaxException {
AAIDSLQueryClient client = new AAIDSLQueryClient();
- assertEquals("V2", client.getClient().getAdditionalHeaders().get("X-DslApiVersion"));
+ assertTrue(client.getClient().getAdditionalHeaders().get("ALL").contains(Pair.with("X-DslApiVersion", "V2")));
}
}
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
-import java.util.HashMap;
+import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.Response;
+import org.javatuples.Pair;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
@Test
public void failPatchOnComplexObject() throws URISyntaxException {
- AAIRestClient client = new AAIRestClient(props, new URI(""), new HashMap<String, String>());
+ AAIRestClient client = new AAIRestClient(props, new URI(""), new MultivaluedHashMap<>());
this.thrown.expect(GraphInventoryPatchDepthExceededException.class);
this.thrown.expectMessage(containsString("Object exceeds allowed depth for update action"));
client.patch(
@Test
public void verifyPatchValidation() throws URISyntaxException {
- AAIRestClient client = new AAIRestClient(props, new URI(""), new HashMap<String, String>());
+ AAIRestClient client = new AAIRestClient(props, new URI(""), new MultivaluedHashMap<>());
AAIRestClient spy = spy(client);
GraphInventoryPatchConverter patchValidatorMock = mock(GraphInventoryPatchConverter.class);
doReturn(patchValidatorMock).when(spy).getPatchConverter();
@Test
public void verifyAdditionalHeadersTest() throws URISyntaxException {
AAIRestClient client = new AAIRestClient(new DefaultAAIPropertiesImpl(wireMockRule.port()), new URI("/test"),
- ImmutableMap.of("test", "value"));
+ new MultivaluedHashMap<String, Pair<String, String>>(
+ ImmutableMap.of("ALL", Pair.with("test", "value"), "GET", Pair.with("get test", "value"))));
wireMockRule.stubFor(get(urlPathEqualTo("/test")).willReturn(aResponse().withStatus(200)));
client.get();
wireMockRule.verify(getRequestedFor(urlPathEqualTo("/test")).withHeader("X-FromAppId", equalTo("MSO"))
- .withHeader("X-TransactionId", matching(".*")).withHeader("test", equalTo("value")));
+ .withHeader("X-TransactionId", matching(".*")).withHeader("test", equalTo("value"))
+ .withHeader("get test", equalTo("value")));
}
}
};
- RestClient client = new AAIRestClient(props, new URI("/cached"), new HashMap<String, String>());
+ RestClient client = new AAIRestClient(props, new URI("/cached"), new MultivaluedHashMap<>());
Response response = client.get();
};
- RestClient client = new AAIRestClient(props, new URI("/cached/1"), new HashMap<String, String>());
+ RestClient client = new AAIRestClient(props, new URI("/cached/1"), new MultivaluedHashMap<>());
Response response = client.get();
</exclusions>
</dependency>
<dependency>
- <groupId>org.onap.aaf.authz</groupId>
- <artifactId>aaf-auth-client</artifactId>
- <scope>runtime</scope>
+ <groupId>org.onap.aaf.authz</groupId>
+ <artifactId>aaf-auth-client</artifactId>
+ <scope>runtime</scope>
</dependency>
<dependency>
- <groupId>org.onap.aaf.authz</groupId>
- <artifactId>aaf-misc-env</artifactId>
- <scope>runtime</scope>
+ <groupId>org.onap.aaf.authz</groupId>
+ <artifactId>aaf-misc-env</artifactId>
+ <scope>runtime</scope>
</dependency>
<dependency>
- <groupId>org.onap.aaf.authz</groupId>
- <artifactId>aaf-misc-rosetta</artifactId>
- <scope>runtime</scope>
+ <groupId>org.onap.aaf.authz</groupId>
+ <artifactId>aaf-misc-rosetta</artifactId>
+ <scope>runtime</scope>
</dependency>
<dependency>
<groupId>javax.xml.bind</groupId>
<groupId>org.onap.aaf.authz</groupId>
<artifactId>aaf-cadi-client</artifactId>
<version>${aaf.version}</version>
- </dependency>
- <dependency>
- <groupId>org.onap.aaf.authz</groupId>
- <artifactId>aaf-cadi-aaf</artifactId>
- <version>${aaf.version}</version>
- <exclusions>
- <exclusion>
- <groupId>javax.servlet</groupId>
- <artifactId>servlet-api</artifactId>
- </exclusion>
- <exclusion>
- <groupId>log4j</groupId>
- <artifactId>log4j</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
- <dependency>
- <groupId>org.onap.aaf.authz</groupId>
- <artifactId>aaf-auth-client</artifactId>
- <version>${aaf.version}</version>
- <scope>runtime</scope>
- </dependency>
- <dependency>
- <groupId>org.onap.aaf.authz</groupId>
- <artifactId>aaf-misc-env</artifactId>
- <version>${aaf.version}</version>
- <scope>runtime</scope>
- </dependency>
- <dependency>
- <groupId>org.onap.aaf.authz</groupId>
- <artifactId>aaf-misc-rosetta</artifactId>
- <version>${aaf.version}</version>
- <scope>runtime</scope>
- </dependency>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.aaf.authz</groupId>
+ <artifactId>aaf-cadi-aaf</artifactId>
+ <version>${aaf.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>javax.servlet</groupId>
+ <artifactId>servlet-api</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>log4j</groupId>
+ <artifactId>log4j</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.aaf.authz</groupId>
+ <artifactId>aaf-auth-client</artifactId>
+ <version>${aaf.version}</version>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.aaf.authz</groupId>
+ <artifactId>aaf-misc-env</artifactId>
+ <version>${aaf.version}</version>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.aaf.authz</groupId>
+ <artifactId>aaf-misc-rosetta</artifactId>
+ <version>${aaf.version}</version>
+ <scope>runtime</scope>
+ </dependency>
</dependencies>
</dependencyManagement>
<profiles>