# the IP address of the message bus
messageBusIp=127.0.0.1
# the URL of the CBAM catalog service
-cbamCatalogUrl=https://127.0.0.1:443/api/catalog/adapter
+cbamCatalogUrl=https://127.0.0.1:443/api/catalog/adapter/
# the URL of the CBAM LCN service
-cbamLcnUrl=https://127.0.0.1:443/vnfm/lcn/v3
+cbamLcnUrl=https://127.0.0.1:443/vnfm/lcn/v3/
# the URL of the CBAM authentication service
-cbamKeyCloakBaseUrl=https://127.0.0.1:443/auth
+cbamKeyCloakBaseUrl=https://127.0.0.1:443/auth/
# the username to be used for requesing a token on CBAM authorization interface
cbamUsername=kukuUser
# the password to be used for requesing a token on CBAM authorization interface
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
- <version>1.5.10.RELEASE</version>
+ <version>${spring.boot.version}</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
- <version>1.5.10.RELEASE</version>
+ <version>${spring.boot.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<artifactId>snakeyaml</artifactId>
<version>1.19</version>
</dependency>
+ <!-- this version must be in sync with the dependency comming from spring boot -->
<dependency>
- <!-- this does not have a compile time dependency, but is required to be able to deserialize the date to joda time -->
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-yaml</artifactId>
- <!-- this version must be in sync with the dependency comming from spring boot -->
- <version>2.8.10</version>
+ <version>2.9.3</version>
</dependency>
<!-- access MSB during registration -->
<dependency>
<version>9.4.8.v20171121</version>
<scope>test</scope>
</dependency>
+<!--
<dependency>
<groupId>org.jetbrains</groupId>
<artifactId>annotations</artifactId>
- <version>RELEASE</version>
+ <version>16.0.1</version>
</dependency>
+-->
<dependency>
<groupId>org.onap.aai.aai-common</groupId>
<artifactId>aai-schema</artifactId>
<artifactId>rest-client</artifactId>
<version>1.2.0</version>
</dependency>
- </dependencies>
+
+ </dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.5</version>
+ <version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia;
-import org.apache.log4j.Logger;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.JobManager;
+import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.stereotype.Component;
+import static org.slf4j.LoggerFactory.getLogger;
+
/**
* Represents the spring boot application
*/
@SpringBootApplication
public class NokiaSvnfmApplication {
- private static Logger logger = Logger.getLogger(NokiaSvnfmApplication.class);
+ private static Logger logger = getLogger(NokiaSvnfmApplication.class);
/**
* Entry point for the Spring boot application
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core;
-import com.nokia.cbam.lcn.v32.ApiException;
import com.nokia.cbam.lcn.v32.api.SubscriptionsApi;
import com.nokia.cbam.lcn.v32.model.*;
import org.onap.msb.sdk.discovery.common.RouteException;
SubscriptionsApi lcnApi = cbamRestApiProvider.getCbamLcnApi(vnfmId);
try {
String callbackUrl = getDriverVnfmUrl() + DriverProperties.LCN_URL;
- for (Subscription subscription : lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)) {
+ for (Subscription subscription : lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION).blockingFirst()) {
if (subscription.getCallbackUrl().equals(callbackUrl)) {
lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
}
}
- } catch (ApiException e) {
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to delete CBAM LCN subscription", e);
}
}
logger.info("Subscribing to CBAM LCN {} with callback to {}", driverProperties.getCbamLcnUrl(), callbackUrl);
SubscriptionsApi lcnApi = cbamRestApiProvider.getCbamLcnApi(vnfmId);
try {
- for (Subscription subscription : lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)) {
+ for (Subscription subscription : lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION).blockingFirst()) {
if (subscription.getCallbackUrl().equals(callbackUrl)) {
return;
}
subscriptionAuthentication.setType(NONE);
request.setAuthentication(subscriptionAuthentication);
lcnApi.subscriptionsPost(request, NOKIA_LCN_API_VERSION);
- } catch (ApiException e) {
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to subscribe to CBAM LCN", e);
}
}
for (ReportedAffectedCp affectedCp : affectedConnectionPoints.get().getPost()) {
if (!isEmpty(affectedCp.getServerProviderId())) {
lInterfaceManager.update(receivedNotification.getVnfInstanceId(), vimId, affectedCp, inMaintenance);
- }
- else{
+ } else {
logger.warn("The changed {} connection point is not linked to any server", affectedCp.getCpId());
}
}
- }
- else{
+ } else {
logger.warn("The changed connection points are not present in VNF with {} identifier", receivedNotification.getVnfInstanceId());
}
}
*/
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.model.VnfInfo;
import org.onap.aai.domain.yang.v11.GenericVnf;
import org.onap.aai.domain.yang.v11.Relationship;
private void updateFields(GenericVnf vnf, String vnfId, boolean inMaintenance) {
try {
- VnfInfo vnfInfo = cbamRestApiProvider.getCbamLcmApi(driverProperties.getVnfmId()).vnfsVnfInstanceIdGet(vnfId, CbamRestApiProvider.NOKIA_LCM_API_VERSION);
+ VnfInfo vnfInfo = cbamRestApiProvider.getCbamLcmApi(driverProperties.getVnfmId()).vnfsVnfInstanceIdGet(vnfId, CbamRestApiProvider.NOKIA_LCM_API_VERSION).blockingFirst();
vnf.setVnfName(vnfInfo.getName());
- } catch (ApiException e) {
+ } catch (RuntimeException e) {
throw buildFatalFailure(logger, "Unable to query VNF with " + vnfId + " identifier from CBAM", e);
}
vnf.setVnfId(vnfId);
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification;
import com.google.common.base.Splitter;
-import com.nokia.cbam.lcm.v32.model.AffectedVnfc;
import org.onap.aai.domain.yang.v11.RelationshipList;
import org.onap.aai.domain.yang.v11.Vnfc;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.AAIRestApiProvider;
return format("/vnfcs/vnfc/%s", buildId(vnfId, cbamVnfcId));
}
- public static String getCbamVnfcId(String vnfcId){
+ public static String getCbamVnfcId(String vnfcId) {
String vnfId = Splitter.on(CbamUtils.SEPARATOR).split(vnfcId).iterator().next();
return vnfcId.replaceFirst(vnfId + SEPARATOR, "");
}
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.GenericExternalSystemInfoProvider;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions;
-import org.onap.vnfmdriver.ApiException;
import org.onap.vnfmdriver.model.VimInfo;
import org.onap.vnfmdriver.model.VnfmInfo;
import org.slf4j.Logger;
@Override
public VnfmInfo queryVnfmInfoFromSource(String vnfmId) {
try {
- return vfcRestApiProvider.getNsLcmApi().queryVnfmInfo(vnfmId);
- } catch (ApiException e) {
+ return vfcRestApiProvider.getNsLcmApi().queryVnfmInfo(vnfmId).execute().body();
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to query VNFM from VF-C with " + vnfmId + " identifier", e);
}
}
@Override
public VimInfo getVimInfo(String vimId) {
try {
- return vfcRestApiProvider.getNsLcmApi().queryVIMInfo(vimId);
- } catch (org.onap.vnfmdriver.ApiException e) {
+ return vfcRestApiProvider.getNsLcmApi().queryVIMInfo(vimId).execute().body();
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to query VIM from VF-C with " + vimId + " identifier", e);
}
}
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.model.VnfInfo;
import com.nokia.cbam.lcm.v32.model.VnfcResourceInfo;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.IGrantManager;
@Override
public void requestGrantForScale(String vnfmId, String vnfId, String vimId, String onapCsarId, VnfScaleRequest request, String jobId) {
+ String cbamVnfdId;
try {
- OperationType operationType = ScaleDirection.IN.equals(request.getType()) ? OperationType.SCALEIN : OperationType.SCALEOUT;
- GrantVNFRequest grantRequest = buildGrantRequest(vnfmId, vimId, onapCsarId, jobId, operationType);
- com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
- String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, vnf.getVnfdId());
- Set<ResourceChange> resourceChanges = calculateResourceChangeDuringScaling(vnfdContent, request.getAspectId(), Integer.parseInt(request.getNumberOfSteps()));
- if (request.getType() == ScaleDirection.IN) {
- grantRequest.getRemoveResource().addAll(resourceChanges);
-
- } else {
- grantRequest.getAddResource().addAll(resourceChanges);
- }
- grantRequest.setVnfInstanceId(vnfId);
- requestGrant(grantRequest);
- } catch (ApiException e) {
+ com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
+ cbamVnfdId = vnf.getVnfdId();
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to query VNF " + vnfId, e);
}
+ OperationType operationType = ScaleDirection.IN.equals(request.getType()) ? OperationType.SCALEIN : OperationType.SCALEOUT;
+ GrantVNFRequest grantRequest = buildGrantRequest(vnfmId, vimId, onapCsarId, jobId, operationType);
+ String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, cbamVnfdId);
+ Set<ResourceChange> resourceChanges = calculateResourceChangeDuringScaling(vnfdContent, request.getAspectId(), Integer.parseInt(request.getNumberOfSteps()));
+ if (request.getType() == ScaleDirection.IN) {
+ grantRequest.getRemoveResource().addAll(resourceChanges);
+
+ } else {
+ grantRequest.getAddResource().addAll(resourceChanges);
+ }
+ grantRequest.setVnfInstanceId(vnfId);
+ requestGrant(grantRequest);
}
@Override
private GrantVNFResponseVim requestGrant(GrantVNFRequest grantRequest) {
try {
- return vfcRestApiProvider.getNsLcmApi().grantvnf(grantRequest).getVim();
- } catch (org.onap.vnfmdriver.ApiException e) {
+ return vfcRestApiProvider.getNsLcmApi().grantvnf(grantRequest).execute().body().getVim();
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to request grant", e);
}
}
@Override
public String getCbamVnfdId(String csarId) {
+ VnfPkgDetailInfo vnfPackageDetails;
try {
- VnfpackageApi onapCatalogApi = restApiProvider.getOnapCatalogApi();
- VnfPkgDetailInfo vnfPackageDetails = onapCatalogApi.queryVnfPackage(csarId);
- JsonElement vnfdModel = new JsonParser().parse(vnfPackageDetails.getPackageInfo().getVnfdModel());
- return vnfdModel.getAsJsonObject().get("metadata").getAsJsonObject().get("resourceVendorModelNumber").getAsString();
+ VnfpackageApi onapCatalogApi = restApiProvider.getVfcCatalogApi();
+ vnfPackageDetails = onapCatalogApi.queryVnfPackage(csarId).execute().body();
} catch (Exception e) {
throw buildFatalFailure(logger, "Unable to query VNF package with " + csarId, e);
}
+ JsonElement vnfdModel = new JsonParser().parse(vnfPackageDetails.getPackageInfo().getVnfdModel());
+ return vnfdModel.getAsJsonObject().get("metadata").getAsJsonObject().get("resourceVendorModelNumber").getAsString();
}
@Override
public byte[] getPackage(String csarId) {
String downloadUrl;
try {
- VnfpackageApi onapCatalogApi = restApiProvider.getOnapCatalogApi();
- VnfPkgDetailInfo vnfPackageDetails = onapCatalogApi.queryVnfPackage(csarId);
+ VnfpackageApi onapCatalogApi = restApiProvider.getVfcCatalogApi();
+ VnfPkgDetailInfo vnfPackageDetails = onapCatalogApi.queryVnfPackage(csarId).execute().body();
String urlFromVfc = vnfPackageDetails.getPackageInfo().getDownloadUrl();
String host = new URL(urlFromVfc).getHost();
downloadUrl = urlFromVfc.replaceFirst("://" + host, "://" + ipMappingProvider.mapPrivateIpToPublicIp(host));
*/
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc;
+import com.google.common.annotations.VisibleForTesting;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.MsbApiProvider;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.Conditions;
import org.onap.vfccatalog.api.VnfpackageApi;
+import org.onap.vnfmdriver.ApiClient;
import org.onap.vnfmdriver.api.NslcmApi;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Conditional;
* @return API to access VF-C for granting & LCN API
*/
public NslcmApi getNsLcmApi() {
- org.onap.vnfmdriver.ApiClient apiClient = new org.onap.vnfmdriver.ApiClient();
+ return buildNslcmApiClient().createService(NslcmApi.class);
+ }
+
+ @VisibleForTesting
+ ApiClient buildNslcmApiClient() {
+ ApiClient apiClient = new ApiClient();
String correctedUrl = fixIncorrectUrl();
- apiClient.setBasePath(correctedUrl);
- return new NslcmApi(apiClient);
+ if (!correctedUrl.endsWith("/")) {
+ correctedUrl = correctedUrl + "/";
+ }
+ apiClient.setAdapterBuilder(apiClient.getAdapterBuilder().baseUrl(correctedUrl));
+ return apiClient;
}
/**
* @return API to access VF-C catalog API
*/
- public VnfpackageApi getOnapCatalogApi() {
+ public VnfpackageApi getVfcCatalogApi() {
+ return buildCatalogApiClient().createService(VnfpackageApi.class);
+ }
+
+ @VisibleForTesting
+ org.onap.vfccatalog.ApiClient buildCatalogApiClient() {
org.onap.vfccatalog.ApiClient vfcApiClient = new org.onap.vfccatalog.ApiClient();
- vfcApiClient.setBasePath(msbApiProvider.getMicroServiceUrl(NSCATALOG_SERVICE_NAME, NSCATALOG_API_VERSION));
- return new VnfpackageApi(vfcApiClient);
+ String microServiceUrl = msbApiProvider.getMicroServiceUrl(NSCATALOG_SERVICE_NAME, NSCATALOG_API_VERSION);
+ if (!microServiceUrl.endsWith("/")) {
+ microServiceUrl = microServiceUrl + "/";
+ }
+ vfcApiClient.setAdapterBuilder(vfcApiClient.getAdapterBuilder().baseUrl(microServiceUrl));
+ return vfcApiClient;
}
/**
import javax.servlet.http.HttpServletResponse;
-import java.util.Optional;
-
import static java.util.Optional.empty;
import static org.apache.http.HttpStatus.SC_CREATED;
import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties.BASE_URL;
*/
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring;
-import com.nokia.cbam.lcm.v32.ApiClient;
import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
-import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.GsonHttpMessageConverter;
*
* @return the message converter
*/
- @Bean
+ //FIXME? @Bean
public HttpMessageConverters customConverters() {
Collection<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
GsonHttpMessageConverter gsonHttpMessageConverter = new GsonHttpMessageConverter();
- gsonHttpMessageConverter.setGson(new ApiClient().getJSON().getGson());
+ //FIXME gsonHttpMessageConverter.setGson(new ApiClient().getAdapterBuilder().build()..getJSON().getGson());
messageConverters.add(gsonHttpMessageConverter);
return new HttpMessageConverters(true, messageConverters);
}
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
import com.google.common.io.ByteStreams;
-import com.nokia.cbam.catalog.v1.ApiException;
import com.nokia.cbam.catalog.v1.api.DefaultApi;
import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.IPackageProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
-import java.io.*;
-import java.nio.file.Path;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
import java.util.HashSet;
import java.util.NoSuchElementException;
import java.util.Set;
import static com.google.common.base.Splitter.on;
import static com.google.common.collect.Iterables.filter;
-import static java.nio.file.Files.createTempFile;
-import static java.nio.file.Files.write;
+import static javax.ws.rs.core.MediaType.APPLICATION_OCTET_STREAM;
+import static okhttp3.MediaType.parse;
+import static okhttp3.RequestBody.create;
import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.buildFatalFailure;
import static org.slf4j.LoggerFactory.getLogger;
DefaultApi cbamCatalogApi = cbamRestApiProvider.getCbamCatalogApi(vnfmId);
if (!isPackageReplicated(cbamVnfdId, cbamCatalogApi)) {
try {
- Path tempFile = createTempFile("cbam", "zip");
ByteArrayOutputStream cbamPackage = getFileInZip(new ByteArrayInputStream(packageProvider.getPackage(csarId)), CBAM_PACKAGE_NAME_IN_ZIP);
- write(tempFile, cbamPackage.toByteArray());
- //FIXME delete file
- return cbamCatalogApi.create(tempFile.toFile());
+ return cbamCatalogApi.create(create(parse(APPLICATION_OCTET_STREAM), cbamPackage.toByteArray())).execute().body();
} catch (Exception e) {
logger.debug("Probably concurrent package uploads", e);
//retest if the VNF package exists in CBAM. It might happen that an other operation
*/
public String getCbamVnfdContent(String vnfmId, String vnfdId) {
try {
- File content = cbamRestApiProvider.getCbamCatalogApi(vnfmId).content(vnfdId);
- String vnfdPath = getVnfdLocation(new FileInputStream(content));
- return new String(getFileInZip(new FileInputStream(content), vnfdPath).toByteArray());
+ byte[] vnfdContent = cbamRestApiProvider.getCbamCatalogApi(vnfmId).content(vnfdId).execute().body().bytes();
+ String vnfdPath = getVnfdLocation(new ByteArrayInputStream(vnfdContent));
+ return new String(getFileInZip(new ByteArrayInputStream(vnfdContent), vnfdPath).toByteArray());
} catch (Exception e) {
throw buildFatalFailure(logger, "Unable to get package with (" + vnfdId + ")", e);
}
private CatalogAdapterVnfpackage queryPackageFromCBAM(String cbamVnfdId, DefaultApi cbamCatalogApi) {
try {
- return cbamCatalogApi.getById(cbamVnfdId);
- } catch (ApiException e) {
+ return cbamCatalogApi.getById(cbamVnfdId).execute().body();
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to query VNF package with " + cbamVnfdId + " from CBAM", e);
}
}
- private boolean isPackageReplicatedToCbam(String cbamVnfdId, DefaultApi cbamCatalogApi) throws ApiException {
- for (CatalogAdapterVnfpackage vnfPackage : cbamCatalogApi.list()) {
+ private boolean isPackageReplicatedToCbam(String cbamVnfdId, DefaultApi cbamCatalogApi) throws IOException {
+ for (CatalogAdapterVnfpackage vnfPackage : cbamCatalogApi.list().execute().body()) {
if (vnfPackage.getVnfdId().equals(cbamVnfdId)) {
return true;
}
*/
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
-import com.google.common.io.BaseEncoding;
+import com.google.common.annotations.VisibleForTesting;
import com.nokia.cbam.catalog.v1.api.DefaultApi;
import com.nokia.cbam.lcm.v32.ApiClient;
import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
-import java.io.ByteArrayInputStream;
-
/**
* Responsible for providing client to access CBAM REST API
*/
public class CbamRestApiProvider {
public static final String NOKIA_LCN_API_VERSION = "3.2";
public static final String NOKIA_LCM_API_VERSION = "3.2";
+ public static final String AUTH_NAME = "test";
private final DriverProperties driverProperties;
private final CbamTokenProvider tokenProvider;
private final VnfmInfoProvider vnfmInfoProvider;
-
- @Value("${trustedCertificates}")
- private String trustedCertificates;
- @Value("${skipCertificateVerification}")
- private boolean skipCertificateVerification;
+ private final CbamSecurityProvider cbamSecurityProvider;
+ @Value("${cbamKeyCloakBaseUrl}")
+ private String cbamKeyCloakBaseUrl;
+ @Value("${cbamUsername}")
+ private String username;
+ @Value("${cbamPassword}")
+ private String password;
@Autowired
- public CbamRestApiProvider(DriverProperties driverProperties, CbamTokenProvider cbamTokenProvider, VnfmInfoProvider vnfmInfoProvider) {
+ public CbamRestApiProvider(DriverProperties driverProperties, CbamTokenProvider cbamTokenProvider, VnfmInfoProvider vnfmInfoProvider, CbamSecurityProvider cbamSecurityProvider) {
this.driverProperties = driverProperties;
this.tokenProvider = cbamTokenProvider;
this.vnfmInfoProvider = vnfmInfoProvider;
+ this.cbamSecurityProvider = cbamSecurityProvider;
}
/**
* @return API to access CBAM LCM API
*/
public VnfsApi getCbamLcmApi(String vnfmId) {
- return new VnfsApi(getLcmApiClient(vnfmId));
+ return buildLcmApiClient(vnfmId).createService(VnfsApi.class);
}
/**
* @return API to access the operation executions
*/
public OperationExecutionsApi getCbamOperationExecutionApi(String vnfmId) {
- return new OperationExecutionsApi(getLcmApiClient(vnfmId));
+ return buildLcmApiClient(vnfmId).createService(OperationExecutionsApi.class);
}
/**
* @return API to access CBAM LCN subscription API
*/
public SubscriptionsApi getCbamLcnApi(String vnfmId) {
- com.nokia.cbam.lcn.v32.ApiClient apiClient = new com.nokia.cbam.lcn.v32.ApiClient();
- if (!skipCertificateVerification) {
- apiClient.setSslCaCert(new ByteArrayInputStream(BaseEncoding.base64().decode(trustedCertificates)));
- } else {
- apiClient.setVerifyingSsl(false);
- }
- apiClient.setBasePath(driverProperties.getCbamLcnUrl());
- apiClient.setAccessToken(tokenProvider.getToken(vnfmId));
- return new SubscriptionsApi(apiClient);
+ return buildLcnApiClient(vnfmId).createService(SubscriptionsApi.class);
}
/**
* @return API to access CBAM catalog API
*/
public DefaultApi getCbamCatalogApi(String vnfmId) {
+ return buildCatalogApiClient(vnfmId).createService(DefaultApi.class);
+ }
+
+ @VisibleForTesting
+ com.nokia.cbam.lcn.v32.ApiClient buildLcnApiClient(String vnfmId) {
+ com.nokia.cbam.lcn.v32.ApiClient apiClient = new com.nokia.cbam.lcn.v32.ApiClient();
+ apiClient.getOkBuilder().sslSocketFactory(cbamSecurityProvider.buildSSLSocketFactory(), cbamSecurityProvider.buildTrustManager());
+ apiClient.getOkBuilder().hostnameVerifier(cbamSecurityProvider.buildHostnameVerifier());
+ apiClient.addAuthorization(AUTH_NAME, tokenProvider.getToken(vnfmId));
+ apiClient.setAdapterBuilder(apiClient.getAdapterBuilder().baseUrl(driverProperties.getCbamLcnUrl()));
+ return apiClient;
+ }
+
+ @VisibleForTesting
+ com.nokia.cbam.catalog.v1.ApiClient buildCatalogApiClient(String vnfmId) {
com.nokia.cbam.catalog.v1.ApiClient apiClient = new com.nokia.cbam.catalog.v1.ApiClient();
- if (!skipCertificateVerification) {
- apiClient.setSslCaCert(new ByteArrayInputStream(BaseEncoding.base64().decode(trustedCertificates)));
- } else {
- apiClient.setVerifyingSsl(false);
- }
- apiClient.setBasePath(driverProperties.getCbamCatalogUrl());
- apiClient.setAccessToken(tokenProvider.getToken(vnfmId));
- return new DefaultApi(apiClient);
+ apiClient.getOkBuilder().sslSocketFactory(cbamSecurityProvider.buildSSLSocketFactory(), cbamSecurityProvider.buildTrustManager());
+ apiClient.getOkBuilder().hostnameVerifier(cbamSecurityProvider.buildHostnameVerifier());
+ apiClient.addAuthorization(AUTH_NAME, tokenProvider.getToken(vnfmId));
+ apiClient.setAdapterBuilder(apiClient.getAdapterBuilder().baseUrl(driverProperties.getCbamCatalogUrl()));
+ return apiClient;
}
- private ApiClient getLcmApiClient(String vnfmId) {
+ @VisibleForTesting
+ ApiClient buildLcmApiClient(String vnfmId) {
VnfmInfo vnfmInfo = vnfmInfoProvider.getVnfmInfo(vnfmId);
ApiClient apiClient = new ApiClient();
- if (!skipCertificateVerification) {
- apiClient.setSslCaCert(new ByteArrayInputStream(BaseEncoding.base64().decode(trustedCertificates)));
- } else {
- apiClient.setVerifyingSsl(false);
- }
- apiClient.setAccessToken(tokenProvider.getToken(vnfmId));
- apiClient.setBasePath(vnfmInfo.getUrl());
+ apiClient.getOkBuilder().sslSocketFactory(cbamSecurityProvider.buildSSLSocketFactory(), cbamSecurityProvider.buildTrustManager());
+ apiClient.getOkBuilder().hostnameVerifier(cbamSecurityProvider.buildHostnameVerifier());
+ apiClient.addAuthorization(AUTH_NAME, tokenProvider.getToken(vnfmId));
+ apiClient.setAdapterBuilder(apiClient.getAdapterBuilder().baseUrl(vnfmInfo.getUrl()));
return apiClient;
}
}
--- /dev/null
+/*
+ * Copyright 2016-2017, Nokia Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
+
+import com.google.common.base.Joiner;
+import com.google.common.io.BaseEncoding;
+import org.apache.http.conn.ssl.DefaultHostnameVerifier;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
+import org.slf4j.Logger;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import javax.net.ssl.*;
+import java.nio.charset.StandardCharsets;
+import java.security.KeyStore;
+import java.security.SecureRandom;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.Set;
+
+import static java.util.UUID.randomUUID;
+import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.buildFatalFailure;
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Responsible for providing a token to access CBAM APIs
+ */
+@Component
+public class CbamSecurityProvider {
+ private static Logger logger = getLogger(CbamSecurityProvider.class);
+ @Value("${trustedCertificates}")
+ private String trustedCertificates;
+ @Value("${skipCertificateVerification}")
+ private boolean skipCertificateVerification;
+ @Value("${skipHostnameVerification}")
+ private boolean skipHostnameVerification;
+
+ protected HostnameVerifier buildHostnameVerifier() {
+ if (skipHostnameVerification) {
+ return (hostname, session) -> true;
+ } else {
+ return new DefaultHostnameVerifier();
+ }
+ }
+
+ protected SSLSocketFactory buildSSLSocketFactory() {
+ try {
+ TrustManager[] trustManagers = new X509TrustManager[]{buildTrustManager()};
+ SSLContext sslContext = SSLContext.getInstance("TLS");
+ sslContext.init(null, trustManagers, new SecureRandom());
+ return sslContext.getSocketFactory();
+ } catch (Exception e) {
+ throw buildFatalFailure(logger, "Unable to create SSL socket factory", e);
+ }
+ }
+
+ protected X509TrustManager buildTrustManager() {
+ if (skipCertificateVerification) {
+ return new AllTrustedTrustManager();
+ } else {
+ if (StringUtils.isEmpty(trustedCertificates)) {
+ throw buildFatalFailure(logger, "If the skipCertificateVerification is set to false (default) the trustedCertificates can not be empty");
+ }
+ Set<String> trustedPems;
+ String content;
+ try {
+ content = new String(BaseEncoding.base64().decode(trustedCertificates), StandardCharsets.UTF_8);
+ trustedPems = StoreLoader.getCertifacates(content);
+ } catch (Exception e) {
+ throw buildFatalFailure(logger, "The trustedCertificates must be a base64 encoded collection of PEM certificates", e);
+ }
+ if (trustedPems.size() == 0) {
+ throw buildFatalFailure(logger, "No certificate can be extracted from " + content);
+ }
+ try {
+ KeyStore keyStore = StoreLoader.loadStore(Joiner.on("\n").join(trustedPems), randomUUID().toString(), randomUUID().toString());
+ TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+ trustManagerFactory.init(keyStore);
+ return (X509TrustManager) trustManagerFactory.getTrustManagers()[0];
+ } catch (Exception e) {
+ throw buildFatalFailure(logger, "Unable to create keystore", e);
+ }
+ }
+ }
+
+ private static class AllTrustedTrustManager implements X509TrustManager {
+ @Override
+ public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+ //no need to check certificates if everything is trusted
+ }
+
+ @Override
+ public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+ //no need to check certificates if everything is trusted
+ }
+
+ @Override
+ public X509Certificate[] getAcceptedIssuers() {
+ return new X509Certificate[0];
+ }
+ }
+
+}
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Joiner;
-import com.google.common.io.BaseEncoding;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import okhttp3.*;
-import org.apache.http.conn.ssl.DefaultHostnameVerifier;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VnfmInfoProvider;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.UserVisibleError;
import org.onap.vnfmdriver.model.VnfmInfo;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
-import org.springframework.util.StringUtils;
-import javax.net.ssl.*;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.security.*;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-import java.util.Set;
-import static java.util.UUID.randomUUID;
import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.buildFatalFailure;
import static org.slf4j.LoggerFactory.getLogger;
import static org.springframework.http.HttpHeaders.CONTENT_TYPE;
//even if the value for grant type an user password is the same they do not mean the same thing
//the duplication of this is intentional
@SuppressWarnings("squid:S1192")
-public class CbamTokenProvider {
+public class CbamTokenProvider extends CbamSecurityProvider {
public static final int MAX_RETRY_COUNT = 5;
public static final String GRANT_TYPE = "password";
public static final String CLIENT_SECRET = "password";
- private static final String CBAM_TOKEN_URL = "/realms/cbam/protocol/openid-connect/token";
+ private static final String CBAM_TOKEN_URL = "realms/cbam/protocol/openid-connect/token";
private static Logger logger = getLogger(CbamTokenProvider.class);
private final VnfmInfoProvider vnfmInfoProvider;
@Value("${cbamKeyCloakBaseUrl}")
private String username;
@Value("${cbamPassword}")
private String password;
- @Value("${trustedCertificates}")
- private String trustedCertificates;
- @Value("${skipCertificateVerification}")
- private boolean skipCertificateVerification;
- @Value("${skipHostnameVerification}")
- private boolean skipHostnameVerification;
private volatile CurrentToken token;
@Autowired
/**
* @return the token to access CBAM APIs (ex. 123456)
*/
- public String getToken(String vnfmId) {
+ public Interceptor getToken(String vnfmId) {
VnfmInfo vnfmInfo = vnfmInfoProvider.getVnfmInfo(vnfmId);
- return getToken(vnfmInfo.getUserName(), vnfmInfo.getPassword());
+ return new OauthInterceptor(getToken(vnfmInfo.getUserName(), vnfmInfo.getPassword()));
}
private String getToken(String clientId, String clientSecret) {
return SystemFunctions.systemFunctions().currentTimeMillis() + token.expiresIn * (1000 / 2);
}
- private HostnameVerifier buildHostnameVerifier() {
- if (skipHostnameVerification) {
- return (hostname, session) -> true;
- } else {
- return new DefaultHostnameVerifier();
- }
- }
+ private static class OauthInterceptor implements Interceptor {
+ private final String token;
- @VisibleForTesting
- SSLSocketFactory buildSSLSocketFactory() {
- try {
- TrustManager[] trustManagers = buildTrustManager();
- SSLContext sslContext = SSLContext.getInstance("TLS");
- sslContext.init(null, trustManagers, new SecureRandom());
- return sslContext.getSocketFactory();
- } catch (GeneralSecurityException e) {
- throw buildFatalFailure(logger, "Unable to create SSL socket factory", e);
+ OauthInterceptor(String token) {
+ this.token = token;
}
- }
-
- @VisibleForTesting
- TrustManager[] buildTrustManager() throws KeyStoreException, NoSuchAlgorithmException {
- if (skipCertificateVerification) {
- return new TrustManager[]{new AllTrustedTrustManager()};
- } else {
- if (StringUtils.isEmpty(trustedCertificates)) {
- throw new IllegalArgumentException("If the skipCertificateVerification is set to false (default) the trustedCertificates can not be empty");
- }
- Set<String> trustedPems;
- try {
- trustedPems = StoreLoader.getCertifacates(new String(BaseEncoding.base64().decode(trustedCertificates), StandardCharsets.UTF_8));
- } catch (Exception e) {
- throw new UserVisibleError("The trustedCertificates must be a base64 encoded collection of PEM certificates", e);
- }
- KeyStore keyStore = StoreLoader.loadStore(Joiner.on("\n").join(trustedPems), randomUUID().toString(), randomUUID().toString());
- TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
- trustManagerFactory.init(keyStore);
- return trustManagerFactory.getTrustManagers();
+ @Override
+ public Response intercept(Chain chain) throws IOException {
+ Request request = chain.request();
+ Request.Builder builder = request.newBuilder();
+ builder.addHeader("Authorization", "Bearer " + token);
+ Request request1 = builder.build();
+ return chain.proceed(request1);
}
}
}
}
- static class AllTrustedTrustManager implements X509TrustManager {
- @Override
- public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
- //no need to check certificates if everything is trusted
- }
-
- @Override
- public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
- //no need to check certificates if everything is trusted
- }
-
- @Override
- public X509Certificate[] getAcceptedIssuers() {
- return new X509Certificate[0];
- }
- }
-
/**
* Represents the token received from CBAM
*/
import com.google.common.collect.Sets;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi;
import com.nokia.cbam.lcm.v32.api.VnfsApi;
import com.nokia.cbam.lcm.v32.model.OperationExecution;
}
private boolean isCurrentOperationTriggeredByJob(String jobId, OperationExecutionsApi cbamOperationExecutionApi, OperationExecution operationExecution) {
+
try {
- Object operationParams = cbamOperationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operationExecution.getId(), NOKIA_LCM_API_VERSION);
+ Object operationParams = cbamOperationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operationExecution.getId(), NOKIA_LCM_API_VERSION).blockingFirst();
if (extractOnapJobId(operationParams).equals(jobId)) {
return true;
}
- } catch (ApiException e) {
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to retrieve operation parameters", e);
}
return false;
//test if the VNF exists (required to be able to distingush between failed request )
VnfsApi cbamLcmApi = cbamRestApiProvider.getCbamLcmApi(vnfmId);
logger.debug("Listing VNFs");
- List<VnfInfo> vnfs = cbamLcmApi.vnfsGet(NOKIA_LCM_API_VERSION);
+ List<VnfInfo> vnfs = cbamLcmApi.vnfsGet(NOKIA_LCM_API_VERSION).blockingSingle();
com.google.common.base.Optional<VnfInfo> vnf = tryFind(vnfs, vnfInfo -> vnfId.equals(vnfInfo.getId()));
if (!vnf.isPresent()) {
logger.debug("VNF with {} identifier is missing", vnfId);
} else {
logger.debug("VNF with {} identifier still exists", vnfId);
//query the VNF again to get operation execution result
- return of(cbamLcmApi.vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION));
+ return of(cbamLcmApi.vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst());
}
- } catch (ApiException e) {
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to retrieve VNF", e);
}
}
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.model.*;
import com.nokia.cbam.lcm.v32.model.ScaleDirection;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.IGrantManager;
* <li>terminate & delete VNF if error occurs after instantiation</li>
* </ul>
*
- * @param vnfmId the identifier of the VNFM
- * @param csarId the identifier of the VNF package
- * @param vnfName the name of the VNF
- * @param description the description of the VNF
+ * @param vnfmId the identifier of the VNFM
+ * @param csarId the identifier of the VNF package
+ * @param vnfName the name of the VNF
+ * @param description the description of the VNF
* @return the VNF creation result
*/
public VnfCreationResult create(String vnfmId, String csarId, String vnfName, String description) {
vnfCreateRequest.setVnfdId(cbamPackage.getVnfdId());
vnfCreateRequest.setName(vnfName);
vnfCreateRequest.setDescription(description);
- com.nokia.cbam.lcm.v32.model.VnfInfo vnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsPost(vnfCreateRequest, NOKIA_LCM_API_VERSION);
+ com.nokia.cbam.lcm.v32.model.VnfInfo vnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsPost(vnfCreateRequest, NOKIA_LCM_API_VERSION).blockingFirst();
addVnfdIdToVnfModifyableAttributeExtensions(vnfmId, vnfInfo.getId(), csarId);
return new VnfCreationResult(vnfInfo, cbamPackage.getVnfdId());
} catch (Exception e) {
return instantiate(vnfmId, request, httpResponse, additionalParameters, creationResult.vnfInfo.getId(), creationResult.vnfdId);
}
- private void instantiateVnf(String vnfmId, VnfInstantiateRequest request, AdditionalParameters additionalParameters, String vnfdId, String vnfId, String vimId, JobInfo jobInfo) throws ApiException {
+ private void instantiateVnf(String vnfmId, VnfInstantiateRequest request, AdditionalParameters additionalParameters, String vnfdId, String vnfId, String vimId, JobInfo jobInfo) {
String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, vnfdId);
GrantVNFResponseVim vim = grantManager.requestGrantForInstantiate(vnfmId, vnfId, vimId, request.getVnfPackageId(), additionalParameters.getInstantiationLevel(), vnfdContent, jobInfo.getJobId());
if (vim.getVimId() == null) {
logger.warn("No additional parameters were specified for the operation");
}
instantiationRequest.setAdditionalParams(root);
- OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdInstantiatePost(vnfId, instantiationRequest, NOKIA_LCM_API_VERSION);
+ OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdInstantiatePost(vnfId, instantiationRequest, NOKIA_LCM_API_VERSION).blockingFirst();
waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
}
return childElement(deploymentFlavorProperties, "flavour_id").getAsString();
}
- private Set<String> getAcceptableOperationParameters(String vnfdContent, String categroryOfOperation, String operationName) {
+ private Set<Map.Entry<String, JsonElement>> getAcceptableOperationParameters(String vnfdContent, String categroryOfOperation, String operationName) {
JsonObject root = new Gson().toJsonTree(new Yaml().load(vnfdContent)).getAsJsonObject();
JsonObject interfaces = child(child(child(root, "topology_template"), "substitution_mappings"), "interfaces");
JsonObject additionalParameters = child(child(child(child(interfaces, categroryOfOperation), operationName), "inputs"), "additional_parameters");
- return additionalParameters.keySet();
+ return additionalParameters.entrySet();
}
private void addExternalLinksToRequest(List<ExtVirtualLinkInfo> extVirtualLinks, AdditionalParameters additionalParameters, InstantiateVnfRequest instantiationRequest, String vimId) {
request.getExtensions().add(externalVnfmIdProperty);
request.setVnfConfigurableProperties(null);
try {
- OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdPatch(vnfId, request, NOKIA_LCM_API_VERSION);
+ OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdPatch(vnfId, request, NOKIA_LCM_API_VERSION).blockingFirst();
waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
- } catch (ApiException e) {
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to set the " + ONAP_CSAR_ID + " property on the VNF", e);
}
}
logOperationInput(vnfId, "termination", request);
return scheduleExecution(vnfId, httpResponse, "terminate", jobInfo -> {
TerminateVnfRequest cbamRequest = new TerminateVnfRequest();
- cbamRequest.setAdditionalParams(jobInfo);
+ //cbamRequest.setAdditionalParams(jobInfo);
if (request.getTerminationType() == null) {
cbamRequest.setTerminationType(TerminationType.FORCEFUL);
} else {
cbamRequest.setTerminationType(TerminationType.FORCEFUL);
}
}
- com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
+ com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
if (vnf.getInstantiationState() == INSTANTIATED) {
terminateVnf(vnfmId, vnfId, jobInfo, cbamRequest, vnf);
} else {
});
}
- private void terminateVnf(String vnfmId, String vnfId, JobInfo jobInfo, TerminateVnfRequest cbamRequest, com.nokia.cbam.lcm.v32.model.VnfInfo vnf) throws ApiException {
+ private void terminateVnf(String vnfmId, String vnfId, JobInfo jobInfo, TerminateVnfRequest cbamRequest, com.nokia.cbam.lcm.v32.model.VnfInfo vnf) {
String vimId = getVimIdFromInstantiationRequest(vnfmId, vnf);
grantManager.requestGrantForTerminate(vnfmId, vnfId, vimId, getVnfdIdFromModifyableAttributes(vnf), vnf, jobInfo.getJobId());
- OperationExecution terminationOperation = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdTerminatePost(vnfId, cbamRequest, NOKIA_LCM_API_VERSION);
+ OperationExecution terminationOperation = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdTerminatePost(vnfId, cbamRequest, NOKIA_LCM_API_VERSION).blockingFirst();
OperationExecution finishedOperation = waitForOperationToFinish(vnfmId, vnfId, terminationOperation.getId());
if (finishedOperation.getStatus() == FINISHED) {
notificationManager.waitForTerminationToBeProcessed(finishedOperation.getId());
}
}
- private String getVimIdFromInstantiationRequest(String vnfmId, com.nokia.cbam.lcm.v32.model.VnfInfo vnf) throws ApiException {
+ private String getVimIdFromInstantiationRequest(String vnfmId, com.nokia.cbam.lcm.v32.model.VnfInfo vnf) {
OperationExecution lastInstantiation = findLastInstantiation(vnf.getOperationExecutions());
- Object operationParameters = cbamRestApiProvider.getCbamOperationExecutionApi(vnfmId).operationExecutionsOperationExecutionIdOperationParamsGet(lastInstantiation.getId(), NOKIA_LCM_API_VERSION);
+ Object operationParameters = cbamRestApiProvider.getCbamOperationExecutionApi(vnfmId).operationExecutionsOperationExecutionIdOperationParamsGet(lastInstantiation.getId(), NOKIA_LCM_API_VERSION).blockingFirst();
JsonObject root = new Gson().toJsonTree(operationParameters).getAsJsonObject();
return childElement(childElement(root, "vims").getAsJsonArray().get(0).getAsJsonObject(), "id").getAsString();
}
*/
public VnfInfo queryVnf(String vnfmId, String vnfId) {
try {
- com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
+ com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
VnfInfo vnfInfo = new VnfInfo();
vnfInfo.setVersion(cbamVnfInfo.getVnfSoftwareVersion());
vnfInfo.setVnfInstanceId(vnfId);
vnfInfo.setVnfStatus("ACTIVE");
vnfInfo.setVnfType("Kuku");
return vnfInfo;
- } catch (ApiException e) {
+ } catch (Exception e) {
throw buildFatalFailure(logger, "Unable to query VNF (" + vnfId + ")", e);
}
}
*/
public JobInfo scaleVnf(String vnfmId, String vnfId, VnfScaleRequest request, HttpServletResponse httpResponse) {
logOperationInput(vnfId, SCALE_OPERATION_NAME, request);
- return scheduleExecution(vnfId, httpResponse, SCALE_OPERATION_NAME, jobInfo -> {
- ScaleVnfRequest cbamRequest = new ScaleVnfRequest();
- cbamRequest.setAspectId(request.getAspectId());
- cbamRequest.setNumberOfSteps(Integer.valueOf(request.getNumberOfSteps()));
- cbamRequest.setType(convert(request.getType()));
- com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
- JsonObject root = new Gson().toJsonTree(jobInfo).getAsJsonObject();
- com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
- String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, cbamVnfInfo.getVnfdId());
- Set<String> acceptableOperationParameters = getAcceptableOperationParameters(vnfdContent, "Basic", SCALE_OPERATION_NAME);
- buildAdditionalParameters(request, root, acceptableOperationParameters);
- cbamRequest.setAdditionalParams(root);
- grantManager.requestGrantForScale(vnfmId, vnfId, getVimIdFromInstantiationRequest(vnfmId, vnf), getVnfdIdFromModifyableAttributes(vnf), request, jobInfo.getJobId());
- OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdScalePost(vnfId, cbamRequest, NOKIA_LCM_API_VERSION);
- waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
+ return scheduleExecution(vnfId, httpResponse, SCALE_OPERATION_NAME, new AsynchronousExecution() {
+ @Override
+ public void execute(JobInfo jobInfo) {
+ ScaleVnfRequest cbamRequest = new ScaleVnfRequest();
+ cbamRequest.setAspectId(request.getAspectId());
+ cbamRequest.setNumberOfSteps(Integer.valueOf(request.getNumberOfSteps()));
+ cbamRequest.setType(convert(request.getType()));
+ com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
+ JsonObject root = new Gson().toJsonTree(jobInfo).getAsJsonObject();
+ com.nokia.cbam.lcm.v32.model.VnfInfo cbamVnfInfo = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
+ String vnfdContent = catalogManager.getCbamVnfdContent(vnfmId, cbamVnfInfo.getVnfdId());
+ Set<Map.Entry<String, JsonElement>> acceptableOperationParameters = getAcceptableOperationParameters(vnfdContent, "Basic", SCALE_OPERATION_NAME);
+ buildAdditionalParameters(request, root, acceptableOperationParameters);
+ cbamRequest.setAdditionalParams(root);
+ grantManager.requestGrantForScale(vnfmId, vnfId, getVimIdFromInstantiationRequest(vnfmId, vnf), getVnfdIdFromModifyableAttributes(vnf), request, jobInfo.getJobId());
+ OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdScalePost(vnfId, cbamRequest, NOKIA_LCM_API_VERSION).blockingFirst();
+ waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
+ }
});
}
- private void buildAdditionalParameters(VnfScaleRequest request, JsonObject root, Set<String> acceptableOperationParameters) {
+ private void buildAdditionalParameters(VnfScaleRequest request, JsonObject root, Set<Map.Entry<String, JsonElement>> acceptableOperationParameters) {
if (request.getAdditionalParam() != null) {
for (Map.Entry<String, JsonElement> item : new Gson().toJsonTree(request.getAdditionalParam()).getAsJsonObject().entrySet()) {
- if (acceptableOperationParameters.contains(item.getKey())) {
+ boolean found = false;
+ for (Map.Entry<String, JsonElement> acceptableOperationParameter : acceptableOperationParameters) {
+ if (acceptableOperationParameter.getKey().equals(item.getKey())) {
+ found = true;
+ }
+ }
+ if (found) {
root.add(item.getKey(), item.getValue());
}
}
* @param vnfId the identifier of the VNF
* @param request the heal request
* @param httpResponse the HTTP response
- * @param vnfcId the identifer of thr VNFC to be healed
+ * @param vnfcId the identifer of thr VNFC to be healed
* @return the job for tracking the heal
*/
public JobInfo healVnf(String vnfmId, String vnfId, VnfHealRequest request, Optional<String> vnfcId, HttpServletResponse httpResponse) {
additionalParams.put("jobId", job.getJobId());
additionalParams.put("vnfcId", vnfcId.orElse("unknown"));
cbamHealRequest.setAdditionalParams(additionalParams);
- com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION);
+ com.nokia.cbam.lcm.v32.model.VnfInfo vnf = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst();
String vimId = getVimIdFromInstantiationRequest(vnfmId, vnf);
grantManager.requestGrantForHeal(vnfmId, vnfId, vimId, getVnfdIdFromModifyableAttributes(vnf), request, job.getJobId());
- OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdHealPost(vnfId, cbamHealRequest, NOKIA_LCM_API_VERSION);
+ OperationExecution operationExecution = cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdHealPost(vnfId, cbamHealRequest, NOKIA_LCM_API_VERSION).blockingFirst();
waitForOperationToFinish(vnfmId, vnfId, operationExecution.getId());
});
}
private OperationExecution waitForOperationToFinish(String vnfmId, String vnfId, String operationExecutionId) {
while (true) {
try {
- OperationExecution operationExecution = find(cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdOperationExecutionsGet(vnfId, NOKIA_LCM_API_VERSION), opEx -> operationExecutionId.equals(opEx.getId()));
+ OperationExecution operationExecution = find(cbamRestApiProvider.getCbamLcmApi(vnfmId).vnfsVnfInstanceIdOperationExecutionsGet(vnfId, NOKIA_LCM_API_VERSION).blockingFirst(), opEx -> operationExecutionId.equals(opEx.getId()));
if (hasOperationFinished(operationExecution)) {
logger.debug("Operation finished with " + operationExecution.getId());
return operationExecution;
@FunctionalInterface
private interface AsynchronousExecution {
- void execute(JobInfo job) throws ApiException;
-
+ void execute(JobInfo job);
}
+
public static class VnfCreationResult {
private final com.nokia.cbam.lcm.v32.model.VnfInfo vnfInfo;
private final String vnfdId;
+
VnfCreationResult(com.nokia.cbam.lcm.v32.model.VnfInfo vnfInfo, String vnfdId) {
this.vnfInfo = vnfInfo;
this.vnfdId = vnfdId;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi;
import com.nokia.cbam.lcm.v32.api.VnfsApi;
import com.nokia.cbam.lcm.v32.model.*;
}
VnfsApi cbamLcmApi = restApiProvider.getCbamLcmApi(driverProperties.getVnfmId());
try {
- List<VnfInfo> vnfs = cbamLcmApi.vnfsGet(NOKIA_LCM_API_VERSION);
+ List<VnfInfo> vnfs = cbamLcmApi.vnfsGet(NOKIA_LCM_API_VERSION).blockingFirst();
com.google.common.base.Optional<VnfInfo> currentVnf = tryFind(vnfs, vnf -> vnf.getId().equals(receivedNotification.getVnfInstanceId()));
String vnfHeader = "The VNF with " + receivedNotification.getVnfInstanceId() + " identifier";
if (!currentVnf.isPresent()) {
//swallow LCN
return;
} else {
- VnfInfo vnf = cbamLcmApi.vnfsVnfInstanceIdGet(receivedNotification.getVnfInstanceId(), NOKIA_LCN_API_VERSION);
+ VnfInfo vnf = cbamLcmApi.vnfsVnfInstanceIdGet(receivedNotification.getVnfInstanceId(), NOKIA_LCN_API_VERSION).blockingFirst();
com.google.common.base.Optional<VnfProperty> externalVnfmId = tryFind(vnf.getExtensions(), prop -> prop.getName().equals(LifecycleManager.EXTERNAL_VNFM_ID));
if (!externalVnfmId.isPresent()) {
logger.warn(vnfHeader + " is not a managed VNF");
throw buildFatalFailure(logger, "Unable to list VNFs / query VNF", e);
}
OperationExecutionsApi cbamOperationExecutionApi = restApiProvider.getCbamOperationExecutionApi(driverProperties.getVnfmId());
+ List<OperationExecution> operationExecutions;
try {
- List<OperationExecution> operationExecutions = cbamLcmApi.vnfsVnfInstanceIdOperationExecutionsGet(receivedNotification.getVnfInstanceId(), NOKIA_LCM_API_VERSION);
- OperationExecution operationExecution = cbamOperationExecutionApi.operationExecutionsOperationExecutionIdGet(receivedNotification.getLifecycleOperationOccurrenceId(), NOKIA_LCM_API_VERSION);
- OperationExecution closestInstantiationToOperation = findLastInstantiationBefore(operationExecutions, operationExecution);
- String vimId = getVimId(cbamOperationExecutionApi, closestInstantiationToOperation);
- notificationSender.processNotification(receivedNotification, operationExecution, buildAffectedCps(operationExecution), vimId);
- if (isTerminationFinished(receivedNotification)) {
- //signal LifecycleManager to continue the deletion of the VNF
- processedNotifications.add(new ProcessedNotification(receivedNotification.getLifecycleOperationOccurrenceId(), receivedNotification.getStatus()));
- }
- } catch (ApiException e) {
- throw buildFatalFailure(logger, "Unable to retrieve the current VNF " + receivedNotification.getVnfInstanceId(), e);
+ operationExecutions = cbamLcmApi.vnfsVnfInstanceIdOperationExecutionsGet(receivedNotification.getVnfInstanceId(), NOKIA_LCM_API_VERSION).blockingFirst();
+ } catch (Exception e) {
+ throw buildFatalFailure(logger, "Unable to retrieve the operation executions for the VNF " + receivedNotification.getVnfInstanceId(), e);
+ }
+ OperationExecution operationExecution;
+ try {
+ operationExecution = cbamOperationExecutionApi.operationExecutionsOperationExecutionIdGet(receivedNotification.getLifecycleOperationOccurrenceId(), NOKIA_LCM_API_VERSION).blockingFirst();
+ } catch (Exception e) {
+ throw buildFatalFailure(logger, "Unable to retrieve the operation execution with " + receivedNotification.getLifecycleOperationOccurrenceId() + " identifier", e);
+ }
+ OperationExecution closestInstantiationToOperation = findLastInstantiationBefore(operationExecutions, operationExecution);
+ String vimId = getVimId(cbamOperationExecutionApi, closestInstantiationToOperation);
+ notificationSender.processNotification(receivedNotification, operationExecution, buildAffectedCps(operationExecution), vimId);
+ if (isTerminationFinished(receivedNotification)) {
+ //signal LifecycleManager to continue the deletion of the VNF
+ processedNotifications.add(new ProcessedNotification(receivedNotification.getLifecycleOperationOccurrenceId(), receivedNotification.getStatus()));
}
}
private String getVimId(OperationExecutionsApi cbamOperationExecutionApi, OperationExecution closestInstantiationToOperation) {
try {
- Object operationParams = cbamOperationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(closestInstantiationToOperation.getId(), NOKIA_LCM_API_VERSION);
+ Object operationParams = cbamOperationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(closestInstantiationToOperation.getId(), NOKIA_LCM_API_VERSION).blockingFirst();
return getVimId(operationParams);
} catch (Exception e) {
throw buildFatalFailure(logger, "Unable to detect last instantiation operation", e);
--- /dev/null
+/*
+ * Copyright 2016-2017, Nokia Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package okhttp3;
+
+import javax.net.ssl.HostnameVerifier;
+
+public class OakExtractor {
+ /**
+ * Cheat access control durting tests
+ */
+ public static HostnameVerifier extract(OkHttpClient.Builder okBuilder) {
+ return okBuilder.hostnameVerifier;
+ }
+}
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestCbamRestApiProvider;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestGenericExternalSystemInfoProvider;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestIpMappingProvider;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestMsbApiProvider;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.TestAAIExternalSystemInfoProvider;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.TestAAIRestApiProvider;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.TestGrantlessGrantManager;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.TestSdcPackageProvider;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification.*;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.*;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.TestCbamVnfPackageBuilder;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.TestCbamVnfdBuilder;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.TestReportedAffectedConnectionPoints;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.TestReportedAffectedCp;
+//import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestCbamRestApiProvider;
+
@RunWith(Suite.class)
@Suite.SuiteClasses({
-
- TestCbamRestApiProvider.class,
TestGenericExternalSystemInfoProvider.class,
TestIpMappingProvider.class,
TestMsbApiProvider.class,
+ TestAAINotificationProcessor.class,
+ TestAbstractManager.class,
+ TestGenericVnfManager.class,
+ TestL3NetworkManager.class,
+ TestLInterfaceManager.class,
+ TestVnfcManager.class,
+ TestVserverManager.class,
+
+ TestAAIExternalSystemInfoProvider.class,
+ TestAAIRestApiProvider.class,
+ TestGrantlessGrantManager.class,
+ TestSdcPackageProvider.class,
+
TestVfcExternalSystemInfoProvider.class,
TestVfcGrantManager.class,
TestVfcPackageProvider.class,
TestAdditionalParams.class,
TestCbamCatalogManager.class,
+ TestCbamRestApiProvider.class,
+ TestCbamSecurityProvider.class,
TestCbamTokenProvider.class,
TestDriverProperties.class,
TestJobManager.class,
-
-
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia;
import junit.framework.TestCase;
-import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.Test;
import org.mockito.*;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.JobManager;
+import org.slf4j.Logger;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.ContextClosedEvent;
import org.springframework.test.util.ReflectionTestUtils;
+++ /dev/null
-/*
- * Copyright 2016-2017, Nokia Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core;
-
-import com.nokia.cbam.catalog.v1.api.DefaultApi;
-import com.nokia.cbam.lcm.v32.ApiClient;
-import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi;
-import com.nokia.cbam.lcm.v32.api.VnfsApi;
-import com.nokia.cbam.lcn.v32.api.SubscriptionsApi;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.onap.msb.sdk.discovery.entity.MicroServiceFullInfo;
-import org.onap.msb.sdk.discovery.entity.NodeInfo;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamTokenProvider;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
-import org.onap.vnfmdriver.model.VnfmInfo;
-import org.springframework.core.env.Environment;
-
-import java.util.Base64;
-import java.util.HashSet;
-import java.util.Set;
-
-import static junit.framework.TestCase.*;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
-import static org.springframework.test.util.ReflectionTestUtils.setField;
-
-public class TestCbamRestApiProvider extends TestBase {
- @Mock
- private Environment environment;
- @Mock
- private CbamTokenProvider cbamTokenProvider;
- private MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
- private Set<NodeInfo> nodes = new HashSet<>();
-
- private CbamRestApiProvider cbamRestApiProvider;
-
- @Before
- public void init() {
- microServiceInfo.setNodes(nodes);
- CbamRestApiProvider real = new CbamRestApiProvider(driverProperties, cbamTokenProvider, vnfmInfoProvider);
- setField(real, "trustedCertificates", "mytrustedCertificates");
- setField(real, "skipCertificateVerification", true);
- cbamRestApiProvider = spy(real);
- when(environment.getProperty(IpMappingProvider.IP_MAP, String.class, "")).thenReturn("");
- when(environment.getProperty(GenericExternalSystemInfoProvider.VNFM_INFO_CACHE_EVICTION_IN_MS, Long.class, Long.valueOf(10 * 60 * 1000))).thenReturn(10 * 60 * 1000L);
- }
-
- /**
- * test CBAM LCM API retrieval without SSL verification
- */
- @Test
- public void testCbamLcmApi() throws Exception {
- VnfmInfo expectedVnfmInfo = new VnfmInfo();
- when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- expectedVnfmInfo.setUrl("https://cbamUrl:123/d");
- when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken");
- //when
- VnfsApi cbamLcmApi = cbamRestApiProvider.getCbamLcmApi(VNFM_ID);
- //verify
- ApiClient apiClient = cbamLcmApi.getApiClient();
- assertEquals("https://cbamUrl:123/d", apiClient.getBasePath());
- assertNull(apiClient.getSslCaCert());
- assertEquals("myToken", ((com.nokia.cbam.lcm.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken());
- assertEquals(2, cbamLcmApi.getApiClient().getAuthentications().size());
- assertTrue(!cbamLcmApi.getApiClient().isVerifyingSsl());
- }
-
- /**
- * test CBAM LCM API retrieval with SSL verification
- */
- @Test
- public void testCbamLcmApiWithSslVerfy() throws Exception {
- VnfmInfo expectedVnfmInfo = new VnfmInfo();
- when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- expectedVnfmInfo.setUrl("https://cbamUrl:123/d");
- when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken");
- setField(cbamRestApiProvider, "skipCertificateVerification", false);
- setField(cbamRestApiProvider, "trustedCertificates", Base64.getEncoder().encodeToString(TestUtil.loadFile("unittests/sample.cert.pem")));
- //when
- VnfsApi cbamLcmApi = cbamRestApiProvider.getCbamLcmApi(VNFM_ID);
- //verify
- ApiClient apiClient = cbamLcmApi.getApiClient();
- assertEquals("https://cbamUrl:123/d", apiClient.getBasePath());
- assertNotNull(apiClient.getSslCaCert());
- assertEquals("myToken", ((com.nokia.cbam.lcm.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken());
- assertEquals(2, cbamLcmApi.getApiClient().getAuthentications().size());
- assertTrue(cbamLcmApi.getApiClient().isVerifyingSsl());
- }
-
- /**
- * test CBAM Catalog API retrieval without SSL verification
- */
- @Test
- public void testCbamCatalogApi() throws Exception {
- VnfmInfo expectedVnfmInfo = new VnfmInfo();
- when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken");
- when(driverProperties.getCbamCatalogUrl()).thenReturn("https://1.2.3.4/path");
- //when
- DefaultApi cbamCatalogApi = cbamRestApiProvider.getCbamCatalogApi(VNFM_ID);
- //verify
- com.nokia.cbam.catalog.v1.ApiClient apiClient = cbamCatalogApi.getApiClient();
- assertEquals("https://1.2.3.4/path", apiClient.getBasePath());
- assertNull(apiClient.getSslCaCert());
- assertEquals("myToken", ((com.nokia.cbam.catalog.v1.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken());
- assertEquals(2, cbamCatalogApi.getApiClient().getAuthentications().size());
- assertTrue(!cbamCatalogApi.getApiClient().isVerifyingSsl());
- }
-
- /**
- * test CBAM Catalog API retrieval with SSL verification
- */
- @Test
- public void testCbamCatalogApiWithSslVerfy() throws Exception {
- VnfmInfo expectedVnfmInfo = new VnfmInfo();
- when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken");
- when(driverProperties.getCbamCatalogUrl()).thenReturn("https://1.2.3.4/path");
- setField(cbamRestApiProvider, "skipCertificateVerification", false);
- setField(cbamRestApiProvider, "trustedCertificates", Base64.getEncoder().encodeToString(TestUtil.loadFile("unittests/sample.cert.pem")));
- //when
- DefaultApi cbamLcmApi = cbamRestApiProvider.getCbamCatalogApi(VNFM_ID);
- //verify
- com.nokia.cbam.catalog.v1.ApiClient apiClient = cbamLcmApi.getApiClient();
- assertEquals("https://1.2.3.4/path", apiClient.getBasePath());
- assertNotNull(apiClient.getSslCaCert());
- assertEquals("myToken", ((com.nokia.cbam.catalog.v1.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken());
- assertEquals(2, cbamLcmApi.getApiClient().getAuthentications().size());
- assertTrue(cbamLcmApi.getApiClient().isVerifyingSsl());
- }
-
- /**
- * test CBAM Lcn API retrieval without SSL verification
- */
- @Test
- public void testCbamLcnApi() throws Exception {
- VnfmInfo expectedVnfmInfo = new VnfmInfo();
- when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken");
- when(driverProperties.getCbamLcnUrl()).thenReturn("https://1.2.3.4/path");
- //when
- SubscriptionsApi cbamLcnApi = cbamRestApiProvider.getCbamLcnApi(VNFM_ID);
- //verify
- com.nokia.cbam.lcn.v32.ApiClient apiClient = cbamLcnApi.getApiClient();
- assertEquals("https://1.2.3.4/path", apiClient.getBasePath());
- assertNull(apiClient.getSslCaCert());
- assertEquals("myToken", ((com.nokia.cbam.lcn.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken());
- assertEquals(2, cbamLcnApi.getApiClient().getAuthentications().size());
- assertTrue(!cbamLcnApi.getApiClient().isVerifyingSsl());
- }
-
- /**
- * test CBAM Lcn API retrieval with SSL verification
- */
- @Test
- public void testCbamLcnApiWithSslVerfy() throws Exception {
- VnfmInfo expectedVnfmInfo = new VnfmInfo();
- when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken");
- when(driverProperties.getCbamLcnUrl()).thenReturn("https://1.2.3.4/path");
- setField(cbamRestApiProvider, "skipCertificateVerification", false);
- setField(cbamRestApiProvider, "trustedCertificates", Base64.getEncoder().encodeToString(TestUtil.loadFile("unittests/sample.cert.pem")));
- //when
- SubscriptionsApi cbamLcnApi = cbamRestApiProvider.getCbamLcnApi(VNFM_ID);
- //verify
- com.nokia.cbam.lcn.v32.ApiClient apiClient = cbamLcnApi.getApiClient();
- assertEquals("https://1.2.3.4/path", apiClient.getBasePath());
- assertNotNull(apiClient.getSslCaCert());
- assertEquals("myToken", ((com.nokia.cbam.lcn.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken());
- assertEquals(2, cbamLcnApi.getApiClient().getAuthentications().size());
- assertTrue(cbamLcnApi.getApiClient().isVerifyingSsl());
- }
-
- /**
- * test CBAM operation exeution API retrieval without SSL verification
- */
- @Test
- public void testCbamOpexApi() throws Exception {
- VnfmInfo expectedVnfmInfo = new VnfmInfo();
- when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken");
- when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- expectedVnfmInfo.setUrl("https://cbamUrl:123/d");
- //when
- OperationExecutionsApi cbamLcnApi = cbamRestApiProvider.getCbamOperationExecutionApi(VNFM_ID);
- //verify
- ApiClient apiClient = cbamLcnApi.getApiClient();
- assertEquals("https://cbamUrl:123/d", apiClient.getBasePath());
- assertNull(apiClient.getSslCaCert());
- assertEquals("myToken", ((com.nokia.cbam.lcm.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken());
- assertEquals(2, cbamLcnApi.getApiClient().getAuthentications().size());
- assertTrue(!cbamLcnApi.getApiClient().isVerifyingSsl());
- }
-
- /**
- * test CBAM operation execution API retrieval with SSL verification
- */
- @Test
- public void testCbamOpexApiWithSslVerfy() throws Exception {
- when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken");
- setField(cbamRestApiProvider, "skipCertificateVerification", false);
- setField(cbamRestApiProvider, "trustedCertificates", Base64.getEncoder().encodeToString(TestUtil.loadFile("unittests/sample.cert.pem")));
- VnfmInfo expectedVnfmInfo = new VnfmInfo();
- when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- expectedVnfmInfo.setUrl("https://cbamUrl:123/d");
- when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
- //when
- OperationExecutionsApi cbamLcnApi = cbamRestApiProvider.getCbamOperationExecutionApi(VNFM_ID);
- //verify
- ApiClient apiClient = cbamLcnApi.getApiClient();
- assertEquals("https://cbamUrl:123/d", apiClient.getBasePath());
- assertNotNull(apiClient.getSslCaCert());
- assertEquals("myToken", ((com.nokia.cbam.lcm.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken());
- assertEquals(2, cbamLcnApi.getApiClient().getAuthentications().size());
- assertTrue(cbamLcnApi.getApiClient().isVerifyingSsl());
- }
-}
import com.google.gson.JsonObject;
import com.nokia.cbam.lcm.v32.model.*;
-import org.jetbrains.annotations.NotNull;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InOrder;
}
-
/**
* if changes connection points are not present a warning is logged
*/
verify(logger).warn("The changed connection points are not present in VNF with {} identifier", VNF_ID);
}
- @NotNull
private ReportedAffectedCp buildCp() {
ReportedAffectedCp cp = new ReportedAffectedCp();
cp.setServerProviderId(UUID.randomUUID().toString());
*/
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.direct.notification;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.model.VnfInfo;
import org.junit.Before;
import org.junit.Test;
}
return vnfs.iterator().next();
});
- when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), payload.capture(), eq(Void.class))).thenAnswer(invocation -> {
vnfs.add(vnfInAaai);
return null;
GenericVnf vnfInAaai = OBJECT_FACTORY.createGenericVnf();
vnfInAaai.setResourceVersion("v1");
when(aaiRestApiProvider.get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class)).thenReturn(vnfInAaai);
- when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), payload.capture(), eq(Void.class))).thenReturn(null);
vnfInfo.setName("vnfName");
//when
GenericVnf vnfInAaai = OBJECT_FACTORY.createGenericVnf();
vnfInAaai.setResourceVersion("v1");
when(aaiRestApiProvider.get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class)).thenReturn(vnfInAaai);
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), payload.capture(), eq(Void.class))).thenAnswer(invocation -> {
vnfInAaai.setResourceVersion("v2");
}
throw new NoSuchElementException();
});
- when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID).vnfsVnfInstanceIdGet(VNF_ID, CbamRestApiProvider.NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
RuntimeException runtimeException = new RuntimeException();
when(aaiRestApiProvider.put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), payload.capture(), eq(Void.class))).thenAnswer(invocation -> {
GenericVnf vnfSentToAAi = (GenericVnf) invocation.getArguments()[3];
assertEquals("v3", vnfSentToAai.getResourceVersion());
verify(systemFunctions, times(10)).sleep(3000);
verify(aaiRestApiProvider, times(11)).get(logger, NETWORK, "/generic-vnfs/generic-vnf/" + VNF_ID, GenericVnf.class);
- verify(aaiRestApiProvider, times(2)).put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), anyString(), eq(Void.class));
+ verify(aaiRestApiProvider, times(2)).put(eq(logger), eq(NETWORK), eq("/generic-vnfs/generic-vnf/" + VNF_ID), any(), eq(Void.class));
verify(logger).warn(eq("The VNF with myVnfId identifier did not appear in time"), any(NoSuchElementException.class));
verify(logger).warn("The VNF with myVnfId identifier has been created since after the maximal wait for VNF to appear timeout", runtimeException);
}
assertRelation(payload.getValue().getRelationshipList(), "tenant", buildRelationshipData("cloud-region.cloud-owner", getCloudOwner(VIM_ID)), buildRelationshipData("cloud-region.cloud-region-id", getRegionName(VIM_ID)), buildRelationshipData("tenant.tenant-id", "myTenantId"));
assertRelation(payload.getValue().getRelationshipList(), "generic-vnf", buildRelationshipData("generic-vnf.vnf-id", VNF_ID));
}
+
/**
* test L3 network deletion
*/
import org.junit.Before;
import org.junit.Test;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
-import org.onap.vnfmdriver.ApiException;
import org.onap.vnfmdriver.model.VimInfo;
import org.onap.vnfmdriver.model.VnfmInfo;
import org.springframework.test.util.ReflectionTestUtils;
+import retrofit2.Call;
import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.fail;
@Test
public void testVimRetrieval() throws Exception {
VimInfo expectedVimInfo = new VimInfo();
- when(nsLcmApi.queryVIMInfo(VIM_ID)).thenReturn(expectedVimInfo);
+ Call<VimInfo> vimInfoCall = buildCall(expectedVimInfo);
+ when(nsLcmApi.queryVIMInfo(VIM_ID)).thenReturn(vimInfoCall);
//when
VimInfo vimInfo = vfcExternalSystemInfoProvider.getVimInfo(VIM_ID);
//verify
*/
@Test
public void testUnableToQueryVim() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(nsLcmApi.queryVIMInfo(VIM_ID)).thenThrow(expectedException);
//when
try {
@Test
public void testVnfmRetrieval() throws Exception {
VnfmInfo expectedVimInfo = new VnfmInfo();
- when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenReturn(expectedVimInfo);
+ Call<VnfmInfo> vnfmInfoCall = buildCall(expectedVimInfo);
+ when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenReturn(vnfmInfoCall);
//when
VnfmInfo vimInfo = vfcExternalSystemInfoProvider.queryVnfmInfoFromSource(VNFM_ID);
//verify
*/
@Test
public void testUnableToQueryVnfm() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenThrow(expectedException);
//when
try {
import com.google.gson.JsonObject;
import com.nokia.cbam.lcm.v32.model.*;
import com.nokia.cbam.lcm.v32.model.VnfInfo;
+import io.reactivex.Observable;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CatalogManager;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
-import org.onap.vnfmdriver.ApiException;
import org.onap.vnfmdriver.model.*;
import org.onap.vnfmdriver.model.ScaleDirection;
+import retrofit2.Call;
import java.nio.file.Paths;
import java.util.ArrayList;
@Before
public void initMocks() throws Exception {
setField(VfcGrantManager.class, "logger", logger);
- when(nsLcmApi.grantvnf(grantRequest.capture())).thenReturn(grantResponse);
+ Call<GrantVNFResponse> grantVNFResponseCall = buildCall(grantResponse);
+ when(nsLcmApi.grantvnf(grantRequest.capture())).thenReturn(grantVNFResponseCall);
grantResponse.setVim(vim);
}
@Test
public void testFailureDuringGrantRequest() throws Exception {
String cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.instantiation.yaml").toURI())));
- ApiException expectedException = new ApiException("a");
+ RuntimeException expectedException = new RuntimeException("a");
when(nsLcmApi.grantvnf(Mockito.any())).thenThrow(expectedException);
//when
try {
prop.setValue(ONAP_CSAR_ID);
vnf.setVnfConfigurableProperties(new ArrayList<>());
vnf.getVnfConfigurableProperties().add(prop);
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(nsLcmApi.grantvnf(Mockito.any())).thenThrow(expectedException);
//when
try {
scaleRequest.setType(ScaleDirection.OUT);
scaleRequest.setAspectId("aspect1");
scaleRequest.setNumberOfSteps("2");
- com.nokia.cbam.lcm.v32.ApiException expectedException = new com.nokia.cbam.lcm.v32.ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
//when
try {
scaleRequest.setAspectId("aspect1");
scaleRequest.setNumberOfSteps("2");
VnfInfo vnf = new VnfInfo();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnf);
+ Observable<VnfInfo> vnfInfoObservable = buildObservable(vnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfoObservable);
vnf.setVnfdId(CBAM_VNFD_ID);
when(cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
//when
scaleRequest.setAspectId("aspectWithOutVdu");
scaleRequest.setNumberOfSteps("2");
VnfInfo vnf = new VnfInfo();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnf);
+ Observable<VnfInfo> vnfInfoObservable = buildObservable(vnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfoObservable);
vnf.setVnfdId(CBAM_VNFD_ID);
when(cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
//when
scaleRequest.setAspectId("emptyAspect");
scaleRequest.setNumberOfSteps("2");
VnfInfo vnf = new VnfInfo();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnf));
vnf.setVnfdId(CBAM_VNFD_ID);
when(cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
//when
scaleRequest.setAspectId("aspect1");
scaleRequest.setNumberOfSteps("2");
VnfInfo vnf = new VnfInfo();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnf));
vnf.setVnfdId(CBAM_VNFD_ID);
when(cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
//when
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedConnectionPoints;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp;
-import org.onap.vnfmdriver.ApiException;
import org.onap.vnfmdriver.model.*;
import org.threeten.bp.OffsetDateTime;
public void init() throws Exception {
vfcNotificationSender = new VfcNotificationSender(driverProperties, vfcRestApiProvider);
setField(VfcNotificationSender.class, "logger", logger);
- Mockito.doNothing().when(nsLcmApi).vNFLCMNotification(eq(VNFM_ID), eq(VNF_ID), sentLcnToVfc.capture());
+ when(nsLcmApi.vNFLCMNotification(eq(VNFM_ID), eq(VNF_ID), sentLcnToVfc.capture())).thenReturn(VOID_CALL);
instantiationOperation.setId("instantiationOperationExecutionId");
instantiationOperation.setStartTime(OffsetDateTime.now());
instantiationOperation.setOperationType(OperationType.INSTANTIATE);
healOperation.setId("healOperaitonExecutionId");
healOperation.setOperationType(OperationType.HEAL);
healOperation.setStartTime(OffsetDateTime.now().plusDays(1));
- when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(operationExecutions);
+ when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
prepOperation(instantiationOperation);
prepOperation(scaleOperation);
prepOperation(healOperation);
recievedLcn.setVnfInstanceId(VNF_ID);
}
- private void prepOperation(OperationExecution operationExecution) throws com.nokia.cbam.lcm.v32.ApiException {
+ private void prepOperation(OperationExecution operationExecution) {
addEmptyModifiedConnectionPoints(operationExecution);
JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}");
operationExecution.setOperationParams(root);
case TERMINATE:
root.getAsJsonObject().addProperty("terminationType", "GRACEFULL");
}
- when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationExecution);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecution));
operationExecutions.add(operationExecution);
}
*/
@Test
public void testUnableToSendNotificationToVfc() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
doThrow(expectedException).when(nsLcmApi).vNFLCMNotification(any(), any(), any());
recievedLcn.setStatus(OperationStatus.STARTED);
recievedLcn.setOperation(OperationType.INSTANTIATE);
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.IpMappingProvider;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
-import org.onap.vfccatalog.ApiException;
import org.onap.vfccatalog.model.VnfPkgDetailInfo;
import org.onap.vfccatalog.model.VnfPkgInfo;
+import retrofit2.Call;
import java.io.ByteArrayInputStream;
import java.io.IOException;
vnfPackageDetails.setPackageInfo(new VnfPkgInfo());
vnfPackageDetails.getPackageInfo().setVnfdModel("{ \"metadata\" : { \"resourceVendorModelNumber\" : \"" + CBAM_VNFD_ID + "\" }}");
vnfPackageDetails.getPackageInfo().setDownloadUrl("http://127.0.0.1/a.csar");
- when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPackageDetails);
+ Call<VnfPkgDetailInfo> vnfPkgDetailInfoCall = buildCall(vnfPackageDetails);
+ when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPkgDetailInfoCall);
//when
String cbamVnfdId = vfcPackageProvider.getCbamVnfdId(CSAR_ID);
//verify
vnfPackageDetails.setPackageInfo(new VnfPkgInfo());
vnfPackageDetails.getPackageInfo().setVnfdModel("{ \"metadata\" : { \"resourceVendorModelNumber\" : \"" + CBAM_VNFD_ID + "\" }}");
vnfPackageDetails.getPackageInfo().setDownloadUrl("http://127.0.0.1/a.csar");
- when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPackageDetails);
+ Call<VnfPkgDetailInfo> vnfPkgDetailInfoCall = buildCall(vnfPackageDetails);
+ when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPkgDetailInfoCall);
byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar");
when(ipMappingProvider.mapPrivateIpToPublicIp("127.0.0.1")).thenReturn("1.2.3.4");
when(entity.getContent()).thenReturn(new ByteArrayInputStream(onapPackageContent));
*/
@Test
public void unableToGetCbamVnfdFromCatalog() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenThrow(expectedException);
//when
try {
vnfPackageDetails.setPackageInfo(new VnfPkgInfo());
vnfPackageDetails.getPackageInfo().setVnfdModel("{ \"metadata\" : { \"resourceVendorModelNumber\" : \"" + CBAM_VNFD_ID + "\" }}");
vnfPackageDetails.getPackageInfo().setDownloadUrl("http://127.0.0.1/a.csar");
- when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPackageDetails);
+ Call<VnfPkgDetailInfo> vnfPkgDetailInfoCall = buildCall(vnfPackageDetails);
+ when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPkgDetailInfoCall);
byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar");
when(ipMappingProvider.mapPrivateIpToPublicIp("127.0.0.1")).thenReturn("1.2.3.4");
IOException expectedException = new IOException();
*/
@Test
public void unableToQueryPackageForDownloadFromCatalog() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenThrow(expectedException);
//when
try {
import org.junit.Before;
import org.junit.Test;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
+import org.onap.vfccatalog.ApiClient;
import org.onap.vfccatalog.api.VnfpackageApi;
-import org.onap.vnfmdriver.api.NslcmApi;
import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertNull;
+import static junit.framework.TestCase.assertNotNull;
import static org.mockito.Mockito.when;
public class TestVfcRestApiProvider extends TestBase {
}
/**
- * test VF-C NSLCM API retrieval
+ * the base URL of the LCM API is set
*/
@Test
public void testNsLcmApi() throws Exception {
- when(msbApiProvider.getMicroServiceUrl(VfcRestApiProvider.NSLCM_API_SERVICE_NAME, VfcRestApiProvider.NSLCM_API_VERION)).thenReturn("http://1.2.3.4:1234/nslcm/v1/lead");
+ when(msbApiProvider.getMicroServiceUrl(VfcRestApiProvider.NSLCM_API_SERVICE_NAME, VfcRestApiProvider.NSLCM_API_VERION)).thenReturn("http://1.2.3.4:1234/nslcm/v1/lead/");
//when
- NslcmApi nsLcmApi = vfcRestApiProvider.getNsLcmApi();
+ org.onap.vnfmdriver.ApiClient apiClient = vfcRestApiProvider.buildNslcmApiClient();
//verify
- assertEquals("http://1.2.3.4:1234/lead", nsLcmApi.getApiClient().getBasePath());
- assertNull(nsLcmApi.getApiClient().getSslCaCert());
- assertEquals(0, nsLcmApi.getApiClient().getAuthentications().size());
+ assertEquals("http://1.2.3.4:1234/lead/", apiClient.getAdapterBuilder().build().baseUrl().toString());
}
/**
- * test VF-C catalog API retrieval
+ * the base URL of the Catalog API is set
*/
@Test
public void testNsCatalogApi() throws Exception {
- when(msbApiProvider.getMicroServiceUrl(VfcRestApiProvider.NSCATALOG_SERVICE_NAME, VfcRestApiProvider.NSCATALOG_API_VERSION)).thenReturn("http://1.2.3.4:1234/lead");
+ when(msbApiProvider.getMicroServiceUrl(VfcRestApiProvider.NSCATALOG_SERVICE_NAME, VfcRestApiProvider.NSCATALOG_API_VERSION)).thenReturn("http://1.2.3.4:1234/lead/");
//when
- VnfpackageApi nsCatalogApi = vfcRestApiProvider.getOnapCatalogApi();
+ ApiClient apiClient = vfcRestApiProvider.buildCatalogApiClient();
//verify
- assertEquals("http://1.2.3.4:1234/lead", nsCatalogApi.getApiClient().getBasePath());
- assertNull(nsCatalogApi.getApiClient().getSslCaCert());
- assertEquals(0, nsCatalogApi.getApiClient().getAuthentications().size());
+ assertEquals("http://1.2.3.4:1234/lead/", apiClient.getAdapterBuilder().build().baseUrl().toString());
+ }
+
+ @Test
+ public void testNsLcm() {
+ when(msbApiProvider.getMicroServiceUrl(VfcRestApiProvider.NSLCM_API_SERVICE_NAME, VfcRestApiProvider.NSLCM_API_VERION)).thenReturn("http://1.2.3.4:1234/nslcm/v1/lead/");
+ //when
+ //verify
+ assertNotNull(vfcRestApiProvider.getNsLcmApi());
+ }
+
+ @Test
+ public void testNsCatalog() {
+ when(msbApiProvider.getMicroServiceUrl(VfcRestApiProvider.NSCATALOG_SERVICE_NAME, VfcRestApiProvider.NSCATALOG_API_VERSION)).thenReturn("http://1.2.3.4:1234/lead/");
+ //when
+ VnfpackageApi catalogApi = vfcRestApiProvider.getVfcCatalogApi();
+ //verify
+ assertNotNull(catalogApi);
}
}
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Sets;
+import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import junit.framework.TestCase;
import java.lang.reflect.Method;
import java.util.HashSet;
+import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;
JsonObject root = new JsonParser().parse(new String(loadFile("self.swagger.json"))).getAsJsonObject();
String basePath = root.get("basePath").getAsString();
HashMultimap<String, RequestMethod> expectedPaths = HashMultimap.create();
- for (String pathName : child(root, "paths").keySet()) {
- JsonObject path = child(child(root, "paths"), pathName);
- for (String method : path.keySet()) {
- locate(basePath + pathName);
- expectedPaths.put(basePath + pathName, RequestMethod.valueOf(method.toUpperCase()));
+ for (Map.Entry<String, JsonElement> pathName : child(root, "paths").entrySet()) {
+ JsonObject path = child(child(root, "paths"), pathName.getKey());
+ for (Map.Entry<String, JsonElement> method : path.entrySet()) {
+ locate(basePath + pathName.getKey());
+ expectedPaths.put(basePath + pathName.getKey(), RequestMethod.valueOf(method.getKey().toUpperCase()));
}
}
RequestMethod restMethod = methodMapping.method()[0];
Set<RequestMethod> currentMethods = expectedPaths.get(fPath);
if (!currentMethods.contains(restMethod)) {
- TestCase.fail("Not documented REST API" + fPath + " " + restMethod + " current " + currentMethods);
+ TestCase.fail("Not documented REST API " + fPath + " " + restMethod + " current " + currentMethods);
}
}
}
* use class in a static way
*/
@Test
- public void useStaticway(){
+ public void useStaticway() {
TestUtil.coveragePrivateConstructorForClassesWithStaticMethodsOnly(Conditions.class);
}
--- /dev/null
+/*
+ * Copyright 2016-2017, Nokia Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
+
+import com.google.common.io.ByteStreams;
+import org.eclipse.jetty.server.NetworkTrafficServerConnector;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.handler.AbstractHandler;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+
+import javax.servlet.ServletException;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+public class HttpTestServer {
+ public Server _server;
+ public volatile List<String> requests = new ArrayList<>();
+ public volatile List<Integer> codes = new ArrayList<>();
+ public volatile List<String> respones = new ArrayList<>();
+ ExecutorService executorService = Executors.newCachedThreadPool();
+
+ public void start() throws Exception {
+ configureServer();
+ startServer();
+ }
+
+ private void startServer() throws Exception {
+ requests.clear();
+ codes.clear();
+ _server.start();
+ Future<?> serverStarted = executorService.submit(() -> {
+ while (true) {
+ try {
+ Thread.sleep(10);
+ if (_server.isStarted()) {
+ return;
+ }
+ } catch (InterruptedException e) {
+ }
+ }
+ });
+ serverStarted.get(30, TimeUnit.SECONDS);
+ }
+
+ protected void configureServer() throws Exception {
+ Path jksPath = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.jks").toURI());
+ String path = jksPath.normalize().toAbsolutePath().toUri().toString();
+ _server = new Server();
+ SslContextFactory factory = new SslContextFactory(path);
+ factory.setKeyStorePassword("changeit");
+ NetworkTrafficServerConnector connector = new NetworkTrafficServerConnector(_server, factory);
+ connector.setHost("127.0.0.1");
+ _server.addConnector(connector);
+ _server.setHandler(new AbstractHandler() {
+ @Override
+ public void handle(String target, org.eclipse.jetty.server.Request request, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws IOException, ServletException {
+ requests.add(new String(ByteStreams.toByteArray(request.getInputStream())));
+ httpServletResponse.getWriter().write(respones.remove(0));
+ httpServletResponse.setStatus(codes.remove(0));
+ request.setHandled(true);
+ }
+ });
+ }
+
+ public void stop() throws Exception {
+ _server.stop();
+ }
+}
import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi;
import com.nokia.cbam.lcm.v32.api.VnfsApi;
import com.nokia.cbam.lcn.v32.api.SubscriptionsApi;
+import io.reactivex.Observable;
+import okhttp3.RequestBody;
+import okio.Buffer;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.junit.Before;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
+import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.onap.msb.sdk.httpclient.msb.MSBServiceClient;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.INotificationSender;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.test.util.ReflectionTestUtils;
+import retrofit2.Call;
+import retrofit2.Response;
import javax.servlet.http.HttpServletResponse;
import java.io.ByteArrayInputStream;
public static final String VIM_ID = "myCloudOwnerId_myRegionName";
public static final String JOB_ID = "myJobId";
public static final String CBAM_VNFD_ID = "cbamVnfdId";
+ protected static Call<Void> VOID_CALL = buildCall(null);
@Mock
protected CbamRestApiProvider cbamRestApiProvider;
@Mock
@Mock
protected Environment environment;
+ protected static <T> Call<T> buildCall(T response) {
+ Call<T> call = Mockito.mock(Call.class);
+ try {
+ when(call.execute()).thenReturn(Response.success(response));
+ } catch (Exception e) {
+ throw new RuntimeException();
+ }
+ return call;
+ }
+
+ protected static <T> Observable<T> buildObservable(T response) {
+ return Observable.just(response);
+ }
+
@Before
public void genericSetup() throws Exception {
MockitoAnnotations.initMocks(this);
when(cbamRestApiProvider.getCbamCatalogApi(VNFM_ID)).thenReturn(cbamCatalogApi);
when(msbApiProvider.getMsbClient()).thenReturn(msbClient);
when(vfcRestApiProvider.getNsLcmApi()).thenReturn(nsLcmApi);
- when(vfcRestApiProvider.getOnapCatalogApi()).thenReturn(vfcCatalogApi);
+ when(vfcRestApiProvider.getVfcCatalogApi()).thenReturn(vfcCatalogApi);
when(systemFunctions.getHttpClient()).thenReturn(httpClient);
when(httpClient.execute(request.capture())).thenReturn(response);
when(response.getEntity()).thenReturn(entity);
assertEquals(build(expected), build(actual));
}
+ byte[] getContent(RequestBody requestBody) {
+ try {
+ Buffer buffer = new Buffer();
+ requestBody.writeTo(buffer);
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ buffer.copyTo(byteArrayOutputStream);
+ return byteArrayOutputStream.toByteArray();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
private Map<String, List<Byte>> build(byte[] zip) throws Exception {
Map<String, List<Byte>> files = new HashMap<>();
ZipInputStream zipInputStream = new ZipInputStream(new ByteArrayInputStream(zip));
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
+import okhttp3.Headers;
+import okhttp3.RequestBody;
+import okhttp3.ResponseBody;
+import okhttp3.internal.http.RealResponseBody;
+import okio.Buffer;
+import okio.BufferedSource;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.stubbing.Answer;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.IPackageProvider;
import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil;
+import retrofit2.Call;
import java.io.ByteArrayInputStream;
-import java.io.File;
-import java.nio.file.Files;
-import java.nio.file.Path;
+import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import java.util.UUID;
import static junit.framework.TestCase.*;
import static org.junit.Assert.assertArrayEquals;
private IPackageProvider packageProvider;
private List<CatalogAdapterVnfpackage> existingVnfPackages = new ArrayList<>();
- private ArgumentCaptor<File> uploadedFile = ArgumentCaptor.forClass(File.class);
+ private ArgumentCaptor<RequestBody> uploadedFile = ArgumentCaptor.forClass(RequestBody.class);
@Before
public void initMocks() throws Exception {
setField(CatalogManager.class, "logger", logger);
- when(cbamCatalogApi.list()).thenReturn(existingVnfPackages);
+ Call<List<CatalogAdapterVnfpackage>> value = buildCall(existingVnfPackages);
+ when(cbamCatalogApi.list()).thenReturn(value);
cbamCatalogManager = new CatalogManager(cbamRestApiProvider, packageProvider);
}
existingVnfPackages.add(existingPackage);
CatalogAdapterVnfpackage createdPackage = new CatalogAdapterVnfpackage();
createdPackage.setVnfdId(CBAM_VNFD_ID);
- when(cbamCatalogApi.create(uploadedFile.capture())).thenAnswer(new Answer<CatalogAdapterVnfpackage>() {
- @Override
- public CatalogAdapterVnfpackage answer(InvocationOnMock invocationOnMock) throws Throwable {
- return createdPackage;
- }
- });
+ Call<CatalogAdapterVnfpackage> catalogAdapterVnfpackageCall = buildCall(createdPackage);
+ when(cbamCatalogApi.create(uploadedFile.capture())).thenReturn(catalogAdapterVnfpackageCall);
byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar");
when(packageProvider.getPackage(CSAR_ID)).thenReturn(onapPackageContent);
when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID);
//when
CatalogAdapterVnfpackage cbamPackage = cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID);
//verify
- byte[] a2 = Files.readAllBytes(uploadedFile.getValue().toPath());
+ byte[] a2 = getContent(uploadedFile.getValue());
assertArrayEquals(getFileInZip(new ByteArrayInputStream(onapPackageContent), "Artifacts/Deployment/OTHER/cbam.package.zip").toByteArray(), a2);
assertEquals(createdPackage, cbamPackage);
}
public CatalogAdapterVnfpackage answer(InvocationOnMock invocationOnMock) throws Throwable {
//this is done by an other thread
existingVnfPackages.add(createdPackage);
- when(cbamCatalogApi.getById(CBAM_VNFD_ID)).thenReturn(createdPackage);
+ Call<CatalogAdapterVnfpackage> catalogAdapterVnfpackageCall = buildCall(createdPackage);
+ when(cbamCatalogApi.getById(CBAM_VNFD_ID)).thenReturn(catalogAdapterVnfpackageCall);
throw can_not_upload_package;
}
});
//verify
//the correct portion of the package is extracted and uploaded to CBAM
byte[] expectedContentToUpload = getFileInZip(new ByteArrayInputStream(onapPackageContent), "Artifacts/Deployment/OTHER/cbam.package.zip").toByteArray();
- assertTrue(Arrays.equals(expectedContentToUpload, Files.readAllBytes(uploadedFile.getValue().toPath())));
+ assertTrue(Arrays.equals(expectedContentToUpload, getContent(uploadedFile.getValue())));
assertEquals(createdPackage, cbamPackage);
verify(logger).debug("Probably concurrent package uploads", can_not_upload_package);
}
CatalogAdapterVnfpackage existingPackage = new CatalogAdapterVnfpackage();
existingPackage.setVnfdId(CBAM_VNFD_ID);
existingVnfPackages.add(existingPackage);
- when(cbamCatalogApi.getById(CBAM_VNFD_ID)).thenReturn(existingPackage);
+ Call<CatalogAdapterVnfpackage> catalogAdapterVnfpackageCall = buildCall(existingPackage);
+ when(cbamCatalogApi.getById(CBAM_VNFD_ID)).thenReturn(catalogAdapterVnfpackageCall);
//when
CatalogAdapterVnfpackage cbamPackage = cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID);
//verify
@Test
public void testFailureToListVnfPackagesInCbam() throws Exception {
when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID);
- com.nokia.cbam.catalog.v1.ApiException expectedException = new com.nokia.cbam.catalog.v1.ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(cbamCatalogApi.list()).thenThrow(expectedException);
//when
try {
CatalogAdapterVnfpackage existingPackage = new CatalogAdapterVnfpackage();
existingPackage.setVnfdId(CBAM_VNFD_ID);
existingVnfPackages.add(existingPackage);
- com.nokia.cbam.catalog.v1.ApiException expectedException = new com.nokia.cbam.catalog.v1.ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(cbamCatalogApi.getById(CBAM_VNFD_ID)).thenThrow(expectedException);
//when
try {
when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID);
byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar");
when(packageProvider.getPackage(CSAR_ID)).thenReturn(onapPackageContent);
- com.nokia.cbam.catalog.v1.ApiException expectedException = new com.nokia.cbam.catalog.v1.ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(cbamCatalogApi.create(Mockito.any())).thenThrow(expectedException);
try {
cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID);
*/
@Test
public void testExtractVnfdFromPackage() throws Exception {
- Path csar = Files.createTempFile(UUID.randomUUID().toString(), "csar");
- Files.write(csar, TestUtil.loadFile("unittests/cbam.package.zip"));
- when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(csar.toFile());
+ Call<ResponseBody> responseBodyCall = buildCall(buildResponse(TestUtil.loadFile("unittests/cbam.package.zip")));
+ when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(responseBodyCall);
//when
String content = cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID);
//verify
*/
@Test
public void testEmptyCbamPackage() throws Exception {
- Path csar = Files.createTempFile(UUID.randomUUID().toString(), "csar");
- Files.write(csar, TestUtil.loadFile("unittests/empty.zip"));
- when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(csar.toFile());
+ Call<ResponseBody> responseBodyCall = buildCall(buildResponse(TestUtil.loadFile("unittests/empty.zip")));
+ when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(responseBodyCall);
//when
try {
cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID);
*/
@Test
public void testMissingVnfdCbamPackage() throws Exception {
- Path csar = Files.createTempFile(UUID.randomUUID().toString(), "csar");
- Files.write(csar, TestUtil.loadFile("unittests/missing.vnfd.zip"));
- when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(csar.toFile());
+ byte[] bytes = TestUtil.loadFile("unittests/missing.vnfd.zip");
+ Call<ResponseBody> response = buildCall(buildResponse(bytes));
+ when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(response);
//when
try {
cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID);
);
}
}
+
+ private ResponseBody buildResponse(byte[] content) throws IOException {
+ Headers headers = new Headers.Builder().build();
+ Buffer buffer = new Buffer();
+ buffer.write(content);
+ BufferedSource response = buffer;
+ return new RealResponseBody(headers, response);
+ }
}
--- /dev/null
+/*
+ * Copyright 2016-2017, Nokia Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
+
+import com.nokia.cbam.catalog.v1.api.DefaultApi;
+import com.nokia.cbam.lcm.v32.ApiClient;
+import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi;
+import com.nokia.cbam.lcm.v32.api.VnfsApi;
+import com.nokia.cbam.lcn.v32.api.SubscriptionsApi;
+import okhttp3.Interceptor;
+import okhttp3.OakExtractor;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.onap.msb.sdk.discovery.entity.MicroServiceFullInfo;
+import org.onap.msb.sdk.discovery.entity.NodeInfo;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.GenericExternalSystemInfoProvider;
+import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.IpMappingProvider;
+import org.onap.vnfmdriver.model.VnfmInfo;
+import org.springframework.core.env.Environment;
+
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSocketFactory;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertNotNull;
+import static org.mockito.Mockito.*;
+import static org.springframework.test.util.ReflectionTestUtils.setField;
+
+class ResultCaptor<T> implements Answer {
+ private T result = null;
+
+ public T getResult() {
+ return result;
+ }
+
+ @Override
+ public T answer(InvocationOnMock invocationOnMock) throws Throwable {
+ result = (T) invocationOnMock.callRealMethod();
+ return result;
+ }
+}
+
+public class TestCbamRestApiProvider extends TestBase {
+ @Mock
+ private Environment environment;
+ @Mock
+ private CbamTokenProvider cbamTokenProvider;
+ @Mock
+ private MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo();
+ @Mock
+ private Interceptor interceptor;
+ @Mock
+ private HostnameVerifier hostnameVerifier;
+ private Set<NodeInfo> nodes = new HashSet<>();
+
+ private CbamRestApiProvider cbamRestApiProvider;
+ private CbamSecurityProvider cbamSecurityProvider = spy(new CbamSecurityProvider());
+
+ @Before
+ public void init() {
+ microServiceInfo.setNodes(nodes);
+ setField(cbamSecurityProvider, "skipCertificateVerification", true);
+ setField(cbamSecurityProvider, "skipHostnameVerification", true);
+ cbamRestApiProvider = new CbamRestApiProvider(driverProperties, cbamTokenProvider, vnfmInfoProvider, cbamSecurityProvider);
+ when(environment.getProperty(IpMappingProvider.IP_MAP, String.class, "")).thenReturn("");
+ when(environment.getProperty(GenericExternalSystemInfoProvider.VNFM_INFO_CACHE_EVICTION_IN_MS, Long.class, Long.valueOf(10 * 60 * 1000))).thenReturn(10 * 60 * 1000L);
+ }
+
+ /**
+ * test CBAM LCM API
+ */
+ @Test
+ public void testCbamLcmApi() throws Exception {
+ VnfmInfo expectedVnfmInfo = new VnfmInfo();
+ when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo);
+ expectedVnfmInfo.setUrl("https://cbamurl:123/d/");
+ ResultCaptor<SSLSocketFactory> sslSocketFactoryResultCaptor = new ResultCaptor<>();
+ doAnswer(sslSocketFactoryResultCaptor).when(cbamSecurityProvider).buildSSLSocketFactory();
+ when(cbamSecurityProvider.buildHostnameVerifier()).thenReturn(hostnameVerifier);
+ when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn(interceptor);
+ //when
+ ApiClient cbamLcmApi = cbamRestApiProvider.buildLcmApiClient(VNFM_ID);
+ //verify
+ String actual = cbamLcmApi.getAdapterBuilder().build().baseUrl().toString();
+ assertEquals("https://cbamurl:123/d/", actual);
+ assertEquals(sslSocketFactoryResultCaptor.getResult(), cbamLcmApi.getOkBuilder().build().sslSocketFactory());
+ Map<String, Interceptor> apiAuthorizations = cbamLcmApi.getApiAuthorizations();
+ assertEquals(1, apiAuthorizations.size());
+ assertEquals(interceptor, apiAuthorizations.values().iterator().next());
+ assertEquals(hostnameVerifier, OakExtractor.extract(cbamLcmApi.getOkBuilder()));
+ }
+
+ /**
+ * test CBAM catalog API
+ */
+ @Test
+ public void testCbamCatalogApi() throws Exception {
+ ResultCaptor<SSLSocketFactory> sslSocketFactoryResultCaptor = new ResultCaptor<>();
+ doAnswer(sslSocketFactoryResultCaptor).when(cbamSecurityProvider).buildSSLSocketFactory();
+ when(cbamSecurityProvider.buildHostnameVerifier()).thenReturn(hostnameVerifier);
+ when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn(interceptor);
+ when(driverProperties.getCbamCatalogUrl()).thenReturn("https://cbamurl:123/d/");
+ //when
+ com.nokia.cbam.catalog.v1.ApiClient cbamLcmApi = cbamRestApiProvider.buildCatalogApiClient(VNFM_ID);
+ //verify
+ String actual = cbamLcmApi.getAdapterBuilder().build().baseUrl().toString();
+ assertEquals("https://cbamurl:123/d/", actual);
+ assertEquals(sslSocketFactoryResultCaptor.getResult(), cbamLcmApi.getOkBuilder().build().sslSocketFactory());
+ Map<String, Interceptor> apiAuthorizations = cbamLcmApi.getApiAuthorizations();
+ assertEquals(1, apiAuthorizations.size());
+ assertEquals(interceptor, apiAuthorizations.values().iterator().next());
+ assertEquals(hostnameVerifier, OakExtractor.extract(cbamLcmApi.getOkBuilder()));
+ }
+
+ /**
+ * test CBAM LCN API
+ */
+ @Test
+ public void testCbamLcnApi() throws Exception {
+ ResultCaptor<SSLSocketFactory> sslSocketFactoryResultCaptor = new ResultCaptor<>();
+ doAnswer(sslSocketFactoryResultCaptor).when(cbamSecurityProvider).buildSSLSocketFactory();
+ when(cbamSecurityProvider.buildHostnameVerifier()).thenReturn(hostnameVerifier);
+ when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn(interceptor);
+ when(driverProperties.getCbamLcnUrl()).thenReturn("https://cbamurl:123/d/");
+ //when
+ com.nokia.cbam.lcn.v32.ApiClient cbamLcmApi = cbamRestApiProvider.buildLcnApiClient(VNFM_ID);
+ //verify
+ String actual = cbamLcmApi.getAdapterBuilder().build().baseUrl().toString();
+ assertEquals("https://cbamurl:123/d/", actual);
+ assertEquals(sslSocketFactoryResultCaptor.getResult(), cbamLcmApi.getOkBuilder().build().sslSocketFactory());
+ Map<String, Interceptor> apiAuthorizations = cbamLcmApi.getApiAuthorizations();
+ assertEquals(1, apiAuthorizations.size());
+ assertEquals(interceptor, apiAuthorizations.values().iterator().next());
+ assertEquals(hostnameVerifier, OakExtractor.extract(cbamLcmApi.getOkBuilder()));
+ }
+
+ /**
+ * Test API wrapping for Catalog
+ * (questionable benefit [ this is more less ensured by Java type safety) ]
+ */
+ @Test
+ public void testCatalogAPiWrapping() {
+ com.nokia.cbam.catalog.v1.ApiClient c = Mockito.mock(com.nokia.cbam.catalog.v1.ApiClient.class);
+ class TestClasss extends CbamRestApiProvider {
+ public TestClasss() {
+ super(driverProperties, cbamTokenProvider, vnfmInfoProvider, cbamSecurityProvider);
+ }
+
+ @Override
+ com.nokia.cbam.catalog.v1.ApiClient buildCatalogApiClient(String vnfmId) {
+ return c;
+ }
+ }
+ DefaultApi defaultApi = Mockito.mock(DefaultApi.class);
+ when(c.createService(DefaultApi.class)).thenReturn(defaultApi);
+ //verify
+ TestClasss testInstnace = new TestClasss();
+ assertNotNull(testInstnace.getCbamCatalogApi(VNFM_ID));
+ assertEquals(defaultApi, testInstnace.getCbamCatalogApi(VNFM_ID));
+ }
+
+ /**
+ * Test API wrapping for LCN
+ * (questionable benefit [ this is more less ensured by Java type safety) ]
+ */
+ @Test
+ public void testLcmAPiWrapping() {
+ com.nokia.cbam.lcn.v32.ApiClient c = Mockito.mock(com.nokia.cbam.lcn.v32.ApiClient.class);
+ class TestClasss extends CbamRestApiProvider {
+ public TestClasss() {
+ super(driverProperties, cbamTokenProvider, vnfmInfoProvider, cbamSecurityProvider);
+ }
+
+ @Override
+ com.nokia.cbam.lcn.v32.ApiClient buildLcnApiClient(String vnfmId) {
+ return c;
+ }
+ }
+ SubscriptionsApi defaultApi = Mockito.mock(SubscriptionsApi.class);
+ when(c.createService(SubscriptionsApi.class)).thenReturn(defaultApi);
+ //verify
+ TestClasss testInstnace = new TestClasss();
+ assertNotNull(testInstnace.getCbamLcnApi(VNFM_ID));
+ assertEquals(defaultApi, testInstnace.getCbamLcnApi(VNFM_ID));
+ }
+
+ /**
+ * Test API wrapping for LCM
+ * (questionable benefit [ this is more less ensured by Java type safety) ]
+ */
+ @Test
+ public void testLcnAPiWrapping() {
+ com.nokia.cbam.lcm.v32.ApiClient c = Mockito.mock(com.nokia.cbam.lcm.v32.ApiClient.class);
+ class TestClasss extends CbamRestApiProvider {
+ public TestClasss() {
+ super(driverProperties, cbamTokenProvider, vnfmInfoProvider, cbamSecurityProvider);
+ }
+
+ @Override
+ ApiClient buildLcmApiClient(String vnfmId) {
+ return c;
+ }
+ }
+ VnfsApi defaultApi = Mockito.mock(VnfsApi.class);
+ when(c.createService(VnfsApi.class)).thenReturn(defaultApi);
+ //verify
+ TestClasss testInstnace = new TestClasss();
+ assertNotNull(testInstnace.getCbamLcmApi(VNFM_ID));
+ assertEquals(defaultApi, testInstnace.getCbamLcmApi(VNFM_ID));
+ }
+
+ /**
+ * Test API wrapping for LCM
+ * (questionable benefit [ this is more less ensured by Java type safety) ]
+ */
+ @Test
+ public void testOperationExecutionsApiAPiWrapping() {
+ com.nokia.cbam.lcm.v32.ApiClient c = Mockito.mock(com.nokia.cbam.lcm.v32.ApiClient.class);
+ class TestClasss extends CbamRestApiProvider {
+ public TestClasss() {
+ super(driverProperties, cbamTokenProvider, vnfmInfoProvider, cbamSecurityProvider);
+ }
+
+ @Override
+ ApiClient buildLcmApiClient(String vnfmId) {
+ return c;
+ }
+ }
+ OperationExecutionsApi defaultApi = Mockito.mock(OperationExecutionsApi.class);
+ when(c.createService(OperationExecutionsApi.class)).thenReturn(defaultApi);
+ //verify
+ TestClasss testInstnace = new TestClasss();
+ assertNotNull(testInstnace.getCbamOperationExecutionApi(VNFM_ID));
+ assertEquals(defaultApi, testInstnace.getCbamOperationExecutionApi(VNFM_ID));
+ }
+}
--- /dev/null
+/*
+ * Copyright 2016-2017, Nokia Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonParseException;
+import com.google.gson.annotations.SerializedName;
+import com.nokia.cbam.lcn.v32.JSON;
+import io.reactivex.Observable;
+import okhttp3.OkHttpClient;
+import okhttp3.RequestBody;
+import okhttp3.ResponseBody;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import retrofit2.Converter;
+import retrofit2.Retrofit;
+import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
+import retrofit2.converter.gson.GsonConverterFactory;
+import retrofit2.http.GET;
+import retrofit2.http.Headers;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Base64;
+
+import static junit.framework.TestCase.*;
+import static org.springframework.test.util.ReflectionTestUtils.setField;
+
+interface TestService {
+ @Headers({
+ "Content-Type:application/json"
+ })
+ @GET("subscriptions")
+ Observable<TestResource> subscriptionsGet();
+}
+
+@XmlRootElement(name = "Subscription")
+@XmlAccessorType(XmlAccessType.FIELD)
+class TestResource {
+ @XmlElement(name = "id")
+ @SerializedName("id")
+ public String id = null;
+}
+
+class GsonCustomConverterFactory extends Converter.Factory {
+ private final Gson gson;
+ private final GsonConverterFactory gsonConverterFactory;
+
+ private GsonCustomConverterFactory(Gson gson) {
+ if (gson == null)
+ throw new NullPointerException("gson == null");
+ this.gson = gson;
+ this.gsonConverterFactory = GsonConverterFactory.create(gson);
+ }
+
+ public static GsonCustomConverterFactory create(Gson gson) {
+ return new GsonCustomConverterFactory(gson);
+ }
+
+ @Override
+ public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
+ if (type.equals(String.class))
+ return new GsonResponseBodyConverterToString<Object>(gson, type);
+ else
+ return gsonConverterFactory.responseBodyConverter(type, annotations, retrofit);
+ }
+
+ @Override
+ public Converter<?, RequestBody> requestBodyConverter(Type type, Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
+ return gsonConverterFactory.requestBodyConverter(type, parameterAnnotations, methodAnnotations, retrofit);
+ }
+}
+
+class GsonResponseBodyConverterToString<T> implements Converter<ResponseBody, T> {
+ private final Gson gson;
+ private final Type type;
+
+ GsonResponseBodyConverterToString(Gson gson, Type type) {
+ this.gson = gson;
+ this.type = type;
+ }
+
+ @Override
+ public T convert(ResponseBody value) throws IOException {
+ String returned = value.string();
+ try {
+ return gson.fromJson(returned, type);
+ } catch (JsonParseException e) {
+ return (T) returned;
+ }
+ }
+}
+
+public class TestCbamSecurityProvider extends TestBase {
+ CbamSecurityProvider securityProvider = new CbamSecurityProvider() {
+ };
+
+ HttpTestServer testServer = new HttpTestServer();
+ String url;
+
+ @Before
+ public void init() throws Exception {
+ setField(securityProvider, "skipCertificateVerification", true);
+ setField(securityProvider, "skipHostnameVerification", true);
+ testServer = new HttpTestServer();
+ testServer.start();
+ url = testServer._server.getURI().toString();
+ }
+
+ @After
+ public void testServer() throws Exception {
+ testServer.stop();
+ }
+
+ /**
+ * test skipping certificate and skipping hostname verification
+ */
+ @Test
+ public void testSkipHostAndSkipCertifiacateVerification() throws Exception {
+ setField(securityProvider, "skipCertificateVerification", true);
+ setField(securityProvider, "skipHostnameVerification", true);
+ //when
+ TestResource testResource = fireRequest();
+ //verify
+ assertEquals("1234", testResource.id);
+ //when
+ securityProvider.buildTrustManager().checkClientTrusted(null, null);
+ //verify
+ //no security exception is thrown
+ }
+
+ /**
+ * test skipping certificate and doing hostname verification
+ */
+ @Test
+ public void testHostAndSkipCertifiacateVerification() throws Exception {
+ setField(securityProvider, "skipCertificateVerification", true);
+ setField(securityProvider, "skipHostnameVerification", false);
+ url = url.replace("127.0.0.1", "localhost");
+ TestResource testResource = fireRequest();
+ assertEquals("1234", testResource.id);
+ }
+
+ /**
+ * test skipping certificate and doing hostname verification
+ * (if hostname is invalid exception is propagated)
+ */
+ @Test
+ public void testHostAndSkipCertifiacateVerificationNegativeCase() throws Exception {
+ setField(securityProvider, "skipCertificateVerification", true);
+ setField(securityProvider, "skipHostnameVerification", false);
+ //url = url.replace("127.0.0.1", "localhost");
+ try {
+ fireRequest();
+ fail();
+ } catch (Exception e) {
+ assertEquals(javax.net.ssl.SSLPeerUnverifiedException.class, e.getCause().getClass());
+ assertTrue(e.getCause().getMessage().contains("Hostname 127.0.0.1 not verified"));
+ }
+ }
+
+ /**
+ * test certificate and hostname verification
+ */
+ @Test
+ public void testHostAndCertifiacateVerification() throws Exception {
+ Path jksPath = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.cert.pem").toURI());
+ String cert = Base64.getEncoder().encodeToString(Files.readAllBytes(jksPath));
+ setField(securityProvider, "trustedCertificates", cert);
+ setField(securityProvider, "skipCertificateVerification", false);
+ setField(securityProvider, "skipHostnameVerification", false);
+ url = url.replace("127.0.0.1", "localhost");
+ TestResource testResource = fireRequest();
+ assertEquals("1234", testResource.id);
+ }
+
+ /**
+ * test certificate and hostname verification
+ * (not trusted certificate)
+ */
+ @Test
+ public void testHostAndCertifiacateVerificationNegative() throws Exception {
+ Path jksPath = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/sample.cert.pem").toURI());
+ String cert = Base64.getEncoder().encodeToString(Files.readAllBytes(jksPath));
+ setField(securityProvider, "trustedCertificates", cert);
+ setField(securityProvider, "skipCertificateVerification", false);
+ setField(securityProvider, "skipHostnameVerification", false);
+ url = url.replace("127.0.0.1", "localhost");
+ try {
+ fireRequest();
+ fail();
+ } catch (Exception e) {
+ assertEquals(javax.net.ssl.SSLHandshakeException.class, e.getCause().getClass());
+ assertTrue(e.getCause().getMessage().contains("unable to find valid certification path to requested target"));
+ }
+ }
+
+ /**
+ * test certificate and hostname verification
+ */
+ @Test
+ public void testSkipHostAndCertifiacateVerification() throws Exception {
+ Path jksPath = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.cert.pem").toURI());
+ String cert = Base64.getEncoder().encodeToString(Files.readAllBytes(jksPath));
+ setField(securityProvider, "trustedCertificates", cert);
+ setField(securityProvider, "skipCertificateVerification", false);
+ setField(securityProvider, "skipHostnameVerification", true);
+ //url = url.replace("127.0.0.1", "localhost");
+ TestResource testResource = fireRequest();
+ assertEquals("1234", testResource.id);
+ }
+
+ /**
+ * empty trusted pem results in error if verification is required
+ */
+ @Test
+ public void testEmptyTrustStoreWhenCheckingIsRequired() throws Exception {
+ setField(securityProvider, "trustedCertificates", "");
+ setField(securityProvider, "skipCertificateVerification", false);
+ try {
+ securityProvider.buildTrustManager();
+ fail();
+ } catch (Exception e) {
+ assertEquals("If the skipCertificateVerification is set to false (default) the trustedCertificates can not be empty", e.getMessage());
+ }
+ }
+
+ /**
+ * invalid PEM results in fast fail error
+ */
+ @Test
+ public void testInvalidPem() throws Exception {
+ setField(securityProvider, "trustedCertificates", "______");
+ setField(securityProvider, "skipCertificateVerification", false);
+ try {
+ securityProvider.buildTrustManager();
+ fail();
+ } catch (Exception e) {
+ assertEquals("The trustedCertificates must be a base64 encoded collection of PEM certificates", e.getMessage());
+ }
+ }
+
+ /**
+ * invalid PEM results in fast fail error
+ */
+ @Test
+ public void testEmptyInvalidPem() throws Exception {
+ setField(securityProvider, "trustedCertificates", "a3VrdQo=");
+ setField(securityProvider, "skipCertificateVerification", false);
+ try {
+ securityProvider.buildTrustManager();
+ fail();
+ } catch (Exception e) {
+ assertEquals("No certificate can be extracted from kuku\n", e.getMessage());
+ }
+ }
+
+ /**
+ * bad certificate content results in fast fail error
+ */
+ @Test
+ public void testEmptyInvalidPemContent() throws Exception {
+ String badCert = "-----BEGIN CERTIFICATE-----\nXXXXXX\n-----END CERTIFICATE-----";
+ setField(securityProvider, "trustedCertificates", Base64.getEncoder().encodeToString(badCert.getBytes()));
+ setField(securityProvider, "skipCertificateVerification", false);
+ try {
+ securityProvider.buildTrustManager();
+ fail();
+ } catch (Exception e) {
+ assertEquals("Unable to create keystore", e.getMessage());
+ }
+ }
+
+ /**
+ * bad certificate content results in fast fail error for SSL socket factory
+ */
+ @Test
+ public void testEmptyInvalidPemContentSSl() throws Exception {
+ String badCert = "-----BEGIN CERTIFICATE-----\nXXXXXX\n-----END CERTIFICATE-----";
+ setField(securityProvider, "trustedCertificates", Base64.getEncoder().encodeToString(badCert.getBytes()));
+ setField(securityProvider, "skipCertificateVerification", false);
+ try {
+ securityProvider.buildSSLSocketFactory();
+ fail();
+ } catch (Exception e) {
+ assertEquals("Unable to create SSL socket factory", e.getMessage());
+ }
+ }
+
+ private TestResource fireRequest() {
+ OkHttpClient client =
+ new OkHttpClient.Builder()
+ .sslSocketFactory(securityProvider.buildSSLSocketFactory(), securityProvider.buildTrustManager())
+ .hostnameVerifier(securityProvider.buildHostnameVerifier()).build();
+ TestService test1 = new Retrofit.Builder().baseUrl(url).client(client)
+ .addConverterFactory(GsonCustomConverterFactory.create(new JSON().getGson()))
+ .addCallAdapterFactory(RxJava2CallAdapterFactory.create()).build().create(TestService.class);
+ testServer.respones.add("{ \"id\" : \"1234\" } ");
+ testServer.codes.add(200);
+ TestService test = test1;
+ return test.subscriptionsGet().blockingFirst();
+ }
+
+}
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
-import com.google.common.io.ByteStreams;
-import org.eclipse.jetty.server.NetworkTrafficServerConnector;
-import org.eclipse.jetty.server.Server;
-import org.eclipse.jetty.server.handler.AbstractHandler;
-import org.eclipse.jetty.util.ssl.SslContextFactory;
+import okhttp3.Interceptor;
+import okhttp3.Request;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
-import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VnfmInfoProvider;
import org.onap.vnfmdriver.model.VnfmInfo;
import org.springframework.http.HttpStatus;
-import javax.net.ssl.*;
-import javax.servlet.ServletException;
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URI;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.security.GeneralSecurityException;
-import java.security.KeyStoreException;
-import java.util.ArrayList;
-import java.util.Base64;
-import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
import static junit.framework.TestCase.*;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.when;
import static org.springframework.test.util.ReflectionTestUtils.setField;
-class HttpTestServer {
- Server _server;
- volatile List<String> requests = new ArrayList<>();
- volatile List<Integer> codes = new ArrayList<>();
- volatile List<String> respones = new ArrayList<>();
- ExecutorService executorService = Executors.newCachedThreadPool();
- public void start() throws Exception {
- configureServer();
- startServer();
- }
-
- private void startServer() throws Exception {
- requests.clear();
- codes.clear();
- _server.start();
- Future<?> serverStarted = executorService.submit(() -> {
- while(true){
- try {
- Thread.sleep(10);
- if(_server.isStarted()){
- return;
- }
- } catch (InterruptedException e) {
- }
- }
- });
- serverStarted.get(30, TimeUnit.SECONDS);
- }
-
- protected void configureServer() throws Exception {
- Path jksPath = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.jks").toURI());
- String path = jksPath.normalize().toAbsolutePath().toUri().toString();
- _server = new Server();
- SslContextFactory factory = new SslContextFactory(path);
- factory.setKeyStorePassword("changeit");
- NetworkTrafficServerConnector connector = new NetworkTrafficServerConnector(_server, factory);
- connector.setHost("127.0.0.1");
- _server.addConnector(connector);
- _server.setHandler(new AbstractHandler() {
- @Override
- public void handle(String target, org.eclipse.jetty.server.Request request, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws IOException, ServletException {
- requests.add(new String(ByteStreams.toByteArray(request.getInputStream())));
- httpServletResponse.getWriter().write(respones.remove(0));
- httpServletResponse.setStatus(codes.remove(0));
- request.setHandled(true);
- }
- });
- }
-
- public void stop() throws Exception {
- _server.stop();
- }
-}
-
public class TestCbamTokenProvider extends TestBase {
private static String GOOD_RESPONSE = "{ \"access_token\" : \"myToken\", \"expires_in\" : 1000 }";
@InjectMocks
private CbamTokenProvider cbamTokenProvider;
private VnfmInfo vnfmInfo = new VnfmInfo();
- private ArgumentCaptor<SSLSocketFactory> sslSocketFactory = ArgumentCaptor.forClass(SSLSocketFactory.class);
- private ArgumentCaptor<HostnameVerifier> hostnameVerifier = ArgumentCaptor.forClass(HostnameVerifier.class);
private HttpTestServer testServer;
+ public static String extractToken(Interceptor token) throws IOException {
+ Interceptor.Chain chain = Mockito.mock(Interceptor.Chain.class);
+ Request request = new Request.Builder().url("http://127.0.0.0/").build();
+ when(chain.request()).thenReturn(request);
+ ArgumentCaptor<Request> re = ArgumentCaptor.forClass(Request.class);
+ when(chain.proceed(re.capture())).thenReturn(null);
+ token.intercept(chain);
+ return re.getValue().header("Authorization").replaceFirst("Bearer ", "");
+ }
+
@Before
public void initMocks() throws Exception {
setField(CbamTokenProvider.class, "logger", logger);
testServer.start();
URI uri = testServer._server.getURI();
setField(cbamTokenProvider, "cbamKeyCloakBaseUrl", uri.toString());
-
-
}
private void addGoodTokenResponse() {
//given
addGoodTokenResponse();
//when
- String token = cbamTokenProvider.getToken(VNFM_ID);
+ String token = extractToken(cbamTokenProvider.getToken(VNFM_ID));
//verify
assertEquals(1, testServer.requests.size());
assertTokenRequest(testServer.requests.get(0));
public void testTokenIsRequestedIfPreviousExpired() throws Exception {
//given
addGoodTokenResponse();
- String firstToken = cbamTokenProvider.getToken(VNFM_ID);
+ String firstToken = extractToken(cbamTokenProvider.getToken(VNFM_ID));
testServer.respones.add("{ \"access_token\" : \"myToken2\", \"expires_in\" : 2000 }");
testServer.codes.add(HttpStatus.OK.value());
when(systemFunctions.currentTimeMillis()).thenReturn(500L * 1000 + 1L);
//when
- String token = cbamTokenProvider.getToken(VNFM_ID);
+ String token = extractToken(cbamTokenProvider.getToken(VNFM_ID));
//verify
assertEquals(2, testServer.requests.size());
assertTokenRequest(testServer.requests.get(0));
public void testTokenIsNotRequestedIfPreviousHasNotExpired() throws Exception {
//given
addGoodTokenResponse();
- String firstToken = cbamTokenProvider.getToken(VNFM_ID);
+ String firstToken = extractToken(cbamTokenProvider.getToken(VNFM_ID));
testServer.respones.add("{ \"access_token\" : \"myToken2\", \"expires_in\" : 2000 }");
testServer.codes.add(HttpStatus.OK.value());
when(systemFunctions.currentTimeMillis()).thenReturn(500L * 1000);
//when
- String token = cbamTokenProvider.getToken(VNFM_ID);
+ String token = extractToken(cbamTokenProvider.getToken(VNFM_ID));
//verify
assertEquals(1, testServer.requests.size());
assertTokenRequest(testServer.requests.get(0));
addGoodTokenResponse();
//cbamTokenProvider.failOnRequestNumber = 5;
//when
- String token = cbamTokenProvider.getToken(VNFM_ID);
+ String token = extractToken(cbamTokenProvider.getToken(VNFM_ID));
//verify
assertEquals(5, testServer.requests.size());
assertTokenRequest(testServer.requests.get(0));
testServer.respones.add(new String());
}
- /**
- * the SSL connection is established without certificate & hostname verification
- */
- @Test
- public void noSslVerification() throws Exception {
- //given
- //the default settings is no SSL & hostname check
- addGoodTokenResponse();
- //when
- cbamTokenProvider.getToken(VNFM_ID);
- //verify
- //no exception is thrown
- }
-
- /**
- * if SSL is verified the certificates must be defined
- */
- @Test
- public void testInvalidCombinationOfSettings() throws Exception {
- //given
- setField(cbamTokenProvider, "skipCertificateVerification", false);
- //when
- try {
- cbamTokenProvider.getToken(VNFM_ID);
- //verify
- fail();
- } catch (RuntimeException e) {
- assertEquals("If the skipCertificateVerification is set to false (default) the trustedCertificates can not be empty", e.getMessage());
- }
- }
-
- /**
- * if SSL is verified the certificates must be defined
- */
- @Test
- public void testInvalidCombinationOfSettings2() throws Exception {
- //given
- setField(cbamTokenProvider, "skipCertificateVerification", false);
- setField(cbamTokenProvider, "trustedCertificates", "xx\nxx");
- //when
- try {
- cbamTokenProvider.getToken(VNFM_ID);
- //verify
- fail();
- } catch (RuntimeException e) {
- assertEquals("The trustedCertificates must be a base64 encoded collection of PEM certificates", e.getMessage());
- assertNotNull(e.getCause());
- }
- }
-
- /**
- * the SSL connection is established without certificate & hostname verification
- */
- @Test
- public void testNotTrustedSslConnection() throws Exception {
- //given
- setField(cbamTokenProvider, "skipCertificateVerification", false);
- Path caPem = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/sample.cert.pem").toURI());
- setField(cbamTokenProvider, "trustedCertificates", Base64.getEncoder().encodeToString(Files.readAllBytes(caPem)));
- addGoodTokenResponse();
- //when
- try {
- cbamTokenProvider.getToken(VNFM_ID);
- //verify
- fail();
- } catch (RuntimeException e) {
- assertTrue(e.getCause().getCause().getMessage().contains("unable to find valid certification path"));
- assertTrue(e.getCause() instanceof SSLHandshakeException);
- }
- }
-
- /**
- * the SSL connection is established with certificate & hostname verification
- */
- @Test
- public void testHostnameVerificationSucceeds() throws Exception {
- //given
- setField(cbamTokenProvider, "skipCertificateVerification", false);
- Path caPem = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.cert.pem").toURI());
- setField(cbamTokenProvider, "trustedCertificates", Base64.getEncoder().encodeToString(Files.readAllBytes(caPem)));
- setField(cbamTokenProvider, "cbamKeyCloakBaseUrl", testServer._server.getURI().toString().replace("127.0.0.1", "localhost"));
- setField(cbamTokenProvider, "skipHostnameVerification", false);
- addGoodTokenResponse();
- //when
- cbamTokenProvider.getToken(VNFM_ID);
- //verify
- //no seception is thrown
- }
-
- /**
- * the SSL connection is dropped with certificate & hostname verification due to invalid hostname
- */
- @Test
- public void testHostnameverifcationfail() throws Exception {
- //given
- setField(cbamTokenProvider, "skipCertificateVerification", false);
- Path caPem = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.cert.pem").toURI());
- setField(cbamTokenProvider, "trustedCertificates", Base64.getEncoder().encodeToString(Files.readAllBytes(caPem)));
- setField(cbamTokenProvider, "skipHostnameVerification", false);
- addGoodTokenResponse();
- //when
- try {
- cbamTokenProvider.getToken(VNFM_ID);
- //verify
- fail();
- } catch (RuntimeException e) {
- assertTrue(e.getCause().getMessage().contains("Hostname 127.0.0.1 not verified"));
- assertTrue(e.getCause() instanceof SSLPeerUnverifiedException);
- }
- }
-
- /**
- * invalid certificate content
- */
- @Test
- public void testInvalidCerificateContent() throws Exception {
- //given
- setField(cbamTokenProvider, "skipCertificateVerification", false);
- setField(cbamTokenProvider, "trustedCertificates", Base64.getEncoder().encodeToString("-----BEGIN CERTIFICATE-----\nkuku\n-----END CERTIFICATE-----\n".getBytes()));
- setField(cbamTokenProvider, "skipHostnameVerification", false);
- addGoodTokenResponse();
- //when
- try {
- cbamTokenProvider.getToken(VNFM_ID);
- //verify
- fail();
- } catch (RuntimeException e) {
- assertEquals("Unable to load certificates", e.getMessage());
- assertTrue(e.getCause() instanceof GeneralSecurityException);
- }
- }
-
- /**
- * Verify client certificates are not verified
- * \
- */
- @Test
- public void testClientCertificates() throws Exception {
- //when
- new CbamTokenProvider.AllTrustedTrustManager().checkClientTrusted(null, null);
- //verify
- //no security exception is thrown
- }
-
- /**
- * Exception during keystore creation is logged (semi-useless)
- */
- @Test
- public void testKeystoreCreationFailure() {
- KeyStoreException expectedException = new KeyStoreException();
- class X extends CbamTokenProvider {
- X(VnfmInfoProvider vnfmInfoProvider) {
- super(vnfmInfoProvider);
- }
-
- @Override
- TrustManager[] buildTrustManager() throws KeyStoreException {
- throw expectedException;
- }
- }
- try {
- new X(null).buildSSLSocketFactory();
- fail();
- } catch (RuntimeException e) {
- assertEquals(expectedException, e.getCause());
- verify(logger).error("Unable to create SSL socket factory", expectedException);
- }
- }
private void assertTokenRequest(String body) {
assertContains(body, "grant_type", "password");
import com.google.common.collect.Lists;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.model.*;
+import io.reactivex.Observable;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
@Before
public void initMocks() throws Exception {
ReflectionTestUtils.setField(JobManager.class, "logger", logger);
- when(vnfApi.vnfsGet(NOKIA_LCM_API_VERSION)).thenReturn(vnfs);
+ when(vnfApi.vnfsGet(NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfs));
when(selfRegistrationManager.isReady()).thenReturn(true);
}
vnfs.add(vnf);
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(detailedVnf));
JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId);
//verify
assertResult(jobId, job, STARTED, "50", "Operation started");
vnfs.add(vnf);
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(detailedVnf));
jobManager.jobFinished(jobId);
JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId);
//verify
vnfs.add(vnf);
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(detailedVnf));
OperationExecution operation = new OperationExecution();
operation.setId(UUID.randomUUID().toString());
operation.setStartTime(OffsetDateTime.now());
detailedVnf.setOperationExecutions(new ArrayList<>());
detailedVnf.getOperationExecutions().add(operation);
JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationParams));
JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId);
//verify
assertResult(jobId, job, STARTED, "50", "Operation started");
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
List<Integer> vnfQueryCallCounter = new ArrayList<>();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<VnfInfo>() {
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<VnfInfo>>() {
@Override
- public VnfInfo answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<VnfInfo> answer(InvocationOnMock invocation) throws Throwable {
vnfs.clear();
- return detailedVnf;
+ return buildObservable(detailedVnf);
}
});
detailedVnf.getOperationExecutions().add(operation);
JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationParams));
//when
JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId);
//verify
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
List<Integer> vnfCounter = new ArrayList<>();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(detailedVnf));
OperationExecution operation = new OperationExecution();
operation.setId(UUID.randomUUID().toString());
operation.setStartTime(OffsetDateTime.now());
detailedVnf.setOperationExecutions(new ArrayList<>());
detailedVnf.getOperationExecutions().add(operation);
JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationParams));
//when
JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId);
//verify
vnfs.add(vnf);
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(detailedVnf));
OperationExecution operation = new OperationExecution();
operation.setId(UUID.randomUUID().toString());
operation.setStartTime(OffsetDateTime.now());
detailedVnf.setOperationExecutions(new ArrayList<>());
detailedVnf.getOperationExecutions().add(operation);
JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationParams));
JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId);
//verify
assertResult(jobId, job, JobStatus.FINISHED, "100", "Operation finished");
vnfs.add(vnf);
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(detailedVnf));
OperationExecution operation = new OperationExecution();
operation.setId(UUID.randomUUID().toString());
operation.setStartTime(OffsetDateTime.now());
detailedVnf.setOperationExecutions(new ArrayList<>());
detailedVnf.getOperationExecutions().add(operation);
JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationParams));
JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId);
//verify
assertResult(jobId, job, STARTED, "50", "Operation started");
vnfs.add(vnf);
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(detailedVnf));
OperationExecution operation = new OperationExecution();
operation.setId(UUID.randomUUID().toString());
detailedVnf.setOperationExecutions(new ArrayList<>());
detailedVnf.getOperationExecutions().add(operation);
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
//verify
try {
VnfInfo vnf = new VnfInfo();
vnf.setId(VNF_ID);
vnfs.add(vnf);
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
//verify
try {
vnfs.add(vnf);
VnfInfo detailedVnf = new VnfInfo();
detailedVnf.setId(VNF_ID);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(detailedVnf));
OperationExecution olderOperation = new OperationExecution();
olderOperation.setId(UUID.randomUUID().toString());
olderOperation.setStartTime(OffsetDateTime.now());
JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}");
List<String> queriedOperaionsInOrder = new ArrayList<>();
when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(Mockito.anyString(), Mockito.eq(NOKIA_LCM_API_VERSION)))
- .then(new Answer<Object>() {
+ .then(new Answer<Observable<Object>>() {
@Override
- public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
+ public Observable<Object> answer(InvocationOnMock invocationOnMock) throws Throwable {
queriedOperaionsInOrder.add(invocationOnMock.getArguments()[0].toString());
if (invocationOnMock.getArguments()[0].equals(olderOperation.getId())) {
- return new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}");
+ return buildObservable(new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}"));
} else {
- return new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + "nonMatching" + "\"}}");
+ return buildObservable(new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + "nonMatching" + "\"}}"));
}
}
});
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.model.*;
import com.nokia.cbam.lcm.v32.model.OperationType;
import com.nokia.cbam.lcm.v32.model.VimInfo;
import com.nokia.cbam.lcm.v32.model.VnfInfo;
+import io.reactivex.Observable;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
instantiationOperationExecution.setStartTime(OffsetDateTime.now());
- when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(operationExecutions);
+ when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
operationExecutions.add(modifyPropertyoperationExecution);
modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
scaleOperationExecution.setId(UUID.randomUUID().toString());
healOperationExecution.setId(UUID.randomUUID().toString());
- when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(modifyPropertyoperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
return null;
}
}).when(jobManager).jobFinished(JOB_ID);
- when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+ when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
@Override
- public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
operationExecutions.add(scaleOperationExecution);
- return scaleOperationExecution;
+ return buildObservable(scaleOperationExecution);
}
});
- when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+ when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
@Override
- public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
operationExecutions.add(healOperationExecution);
- return healOperationExecution;
+ return buildObservable(healOperationExecution);
}
});
}
//given
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
accessInfo.setTenant(TENANT);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
public void testInstantiationWithInvalidVimType() throws Exception {
//given
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
when(logger.isInfoEnabled()).thenReturn(false);
//when
try {
public void testInstantiationV2WithSsl() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
vimInfo.setSslCacert(caCert);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
JsonObject vnfs = child(child(inputs, "vnfs"), ONAP_CSAR_ID);
vnfs.remove("additionalParams");
public void testInstantiationV2WithoutSsl() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
vimInfo.setSslInsecure(null);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
public void testInstantiationV3() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
accessInfo.setTenant(TENANT);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
public void testInstantiationV3WithSsl() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
vimInfo.setSslCacert(caCert);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
vimInfo.setSslInsecure(null);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
public void testInstantiationVcloud() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
accessInfo.setTenant(TENANT);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
public void testInstantiationVcloudWithSsl() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
vimInfo.setSslCacert(caCert);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
vimInfo.setSslInsecure(null);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
@Test
public void testFailureInTheInstantiationRequest() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
accessInfo.setTenant(TENANT);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
//when
public void testVfcFailsToSendVimId() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
//grantResponse.setVimId(VIM_ID);
vimInfo.setSslCacert(caCert);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
//when
VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
waitForJobToFinishInJobManager(finished);
@Test
public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
accessInfo.setTenant(TENANT);
grantResponse.setAccessInfo(accessInfo);
ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
- ApiException expectedException = new ApiException();
- List<ApiException> polling = new ArrayList<>();
- when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution);
- when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<List<OperationExecution>>() {
+ List<RuntimeException> polling = new ArrayList<>();
+ when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
+ when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
@Override
- public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
if (polling.size() > 2) {
- return operationExecutions;
+ return buildObservable(operationExecutions);
}
- ApiException apiException = new ApiException();
- polling.add(apiException);
- throw apiException;
+ RuntimeException runtimeException = new RuntimeException();
+ polling.add(runtimeException);
+ throw runtimeException;
}
});
//when
assertEquals(VNF_ID, response.getVnfInstanceId());
assertEquals(JOB_ID, response.getJobId());
assertEquals(3, polling.size());
- for (ApiException e : polling) {
+ for (RuntimeException e : polling) {
verify(logger).warn("Unable to retrieve operations details", e);
}
verify(systemFunctions, Mockito.times(3)).sleep(5000);
//given
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
//when
try {
//given
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- ApiException expectedException = new ApiException();
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ RuntimeException expectedException = new RuntimeException();
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
//when
@Test
public void testFailureInQueryVimInfo() throws Exception {
VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
- when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo);
+ when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
grantResponse.setVimId(VIM_ID);
GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
public void testTermination() throws Exception {
//given
VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
vnfInfo.setOperationExecutions(operationExecutions);
VnfProperty vnfdId = new VnfProperty();
vnfdId.setValue(ONAP_CSAR_ID);
vnfInfo.getExtensions().add(vnfdId);
ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+ when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
@Override
- public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
OperationExecution terminationOperation = new OperationExecution();
terminationOperation.setId("terminationId");
operationExecutions.add(terminationOperation);
terminationOperation.setStatus(OperationStatus.FINISHED);
- return terminationOperation;
+ return buildObservable(terminationOperation);
}
});
JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
//when
JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
//verify
public void testTerminationOfNonInstantiated() throws Exception {
//given
VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
vnfInfo.setOperationExecutions(operationExecutions);
VnfProperty vnfdId = new VnfProperty();
vnfdId.setValue(ONAP_CSAR_ID);
vnfInfo.getExtensions().add(vnfdId);
JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
//when
JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
//verify
public void testTerminationOperationIsOutwaited() throws Exception {
//given
VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
vnfInfo.setOperationExecutions(operationExecutions);
VnfProperty vnfdId = new VnfProperty();
vnfInfo.getExtensions().add(vnfdId);
ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
OperationExecution terminationOperation = new OperationExecution();
- when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
- @Override
- public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
- terminationOperation.setId("terminationId");
- operationExecutions.add(terminationOperation);
- terminationOperation.setStatus(OperationStatus.STARTED);
- return terminationOperation;
- }
+ when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
+ terminationOperation.setId("terminationId");
+ operationExecutions.add(terminationOperation);
+ terminationOperation.setStatus(OperationStatus.STARTED);
+ return buildObservable(terminationOperation);
});
JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
Set<Integer> calls = new HashSet<>();
- when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
- @Override
- public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
- if (calls.size() == 1000) {
- terminationOperation.setStatus(OperationStatus.FINISHED);
- }
- calls.add(calls.size());
- return operationExecutions;
+ when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
+ if (calls.size() == 1000) {
+ terminationOperation.setStatus(OperationStatus.FINISHED);
}
+ calls.add(calls.size());
+ return buildObservable(operationExecutions);
});
//when
JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
//given
VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
vnfInfo.setOperationExecutions(operationExecutions);
VnfProperty vnfdId = new VnfProperty();
vnfInfo.getExtensions().add(vnfdId);
ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
OperationExecution terminationOperation = new OperationExecution();
- when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+ when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
@Override
- public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
terminationOperation.setId("terminationId");
operationExecutions.add(terminationOperation);
terminationOperation.setStatus(OperationStatus.STARTED);
- return terminationOperation;
+ return buildObservable(terminationOperation);
}
});
JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
Set<Integer> calls = new HashSet<>();
- List<ApiException> expectedExceptions = new ArrayList<>();
- when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
+ List<RuntimeException> expectedExceptions = new ArrayList<>();
+ when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
@Override
- public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
if (calls.size() >= 100) {
terminationOperation.setStatus(OperationStatus.FINISHED);
- return operationExecutions;
+ return buildObservable(operationExecutions);
}
calls.add(calls.size());
- ApiException apiException = new ApiException();
- expectedExceptions.add(apiException);
- throw apiException;
+ RuntimeException RuntimeException = new RuntimeException();
+ expectedExceptions.add(RuntimeException);
+ throw RuntimeException;
}
});
//when
waitForJobToFinishInJobManager(finished);
verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
verify(systemFunctions, times(100)).sleep(5000);
- for (ApiException expectedException : expectedExceptions) {
+ for (RuntimeException expectedException : expectedExceptions) {
verify(logger).warn("Unable to retrieve operations details", expectedException);
}
}
public void testGracefullTermination() throws Exception {
//given
VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
terminationRequest.setGracefulTerminationTimeout("1234");
vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
vnfdId.setValue(ONAP_CSAR_ID);
vnfInfo.getExtensions().add(vnfdId);
ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+ when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
@Override
- public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
OperationExecution terminationOperation = new OperationExecution();
terminationOperation.setId("terminationId");
operationExecutions.add(terminationOperation);
terminationOperation.setStatus(OperationStatus.FINISHED);
- return terminationOperation;
+ return buildObservable(terminationOperation);
}
});
doAnswer(invocation -> {
return null;
}).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
//when
JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
//verify
public void testExplicitForcefulTermination() throws Exception {
//given
VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
terminationRequest.setGracefulTerminationTimeout("1234");
vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
vnfdId.setValue(ONAP_CSAR_ID);
vnfInfo.getExtensions().add(vnfdId);
ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
- @Override
- public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
- OperationExecution terminationOperation = new OperationExecution();
- terminationOperation.setId("terminationId");
- operationExecutions.add(terminationOperation);
- terminationOperation.setStatus(OperationStatus.FINISHED);
- return terminationOperation;
- }
+ when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
+ OperationExecution terminationOperation = new OperationExecution();
+ terminationOperation.setId("terminationId");
+ operationExecutions.add(terminationOperation);
+ terminationOperation.setStatus(OperationStatus.FINISHED);
+ return buildObservable(terminationOperation);
});
doAnswer(invocation -> {
verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
return null;
}).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
//when
JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
//verify
public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
//given
VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
terminationRequest.setGracefulTerminationTimeout("1234");
vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
return terminationOperation;
}
});
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
//when
JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
//verify
public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
//given
VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
vnfInfo.setOperationExecutions(operationExecutions);
VnfProperty vnfdId = new VnfProperty();
vnfdId.setValue(ONAP_CSAR_ID);
vnfInfo.getExtensions().add(vnfdId);
ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
- when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
+ when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
@Override
- public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
OperationExecution terminationOperation = new OperationExecution();
terminationOperation.setId("terminationId");
operationExecutions.add(terminationOperation);
terminationOperation.setStatus(OperationStatus.FAILED);
- return terminationOperation;
+ return buildObservable(terminationOperation);
}
});
JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
//when
JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
//verify
vnfInfo.setName("myName");
vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
vnfInfo.setVnfProvider("myProvider");
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
VnfProperty prop = new VnfProperty();
prop.setName(LifecycleManager.ONAP_CSAR_ID);
prop.setValue(ONAP_CSAR_ID);
@Test
public void testQueryForNonExistingVnf() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
//when
try {
scaleRequest.setType(ScaleDirection.IN);
scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
scaleOperationExecution.setStatus(OperationStatus.FINISHED);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
VnfProperty prop = new VnfProperty();
prop.setValue(ONAP_CSAR_ID);
prop.setName(LifecycleManager.ONAP_CSAR_ID);
vnfInfo.getExtensions().add(prop);
vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
//when
JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
//verify
scaleRequest.setType(ScaleDirection.IN);
scaleRequest.setAdditionalParam(null);
scaleOperationExecution.setStatus(OperationStatus.FINISHED);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
VnfProperty prop = new VnfProperty();
prop.setValue(ONAP_CSAR_ID);
prop.setName(LifecycleManager.ONAP_CSAR_ID);
vnfInfo.getExtensions().add(prop);
vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
//when
JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
//verify
scaleRequest.setType(ScaleDirection.OUT);
scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
scaleOperationExecution.setStatus(OperationStatus.FINISHED);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
VnfProperty prop = new VnfProperty();
prop.setValue(ONAP_CSAR_ID);
prop.setName(LifecycleManager.ONAP_CSAR_ID);
vnfInfo.getExtensions().add(prop);
vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
//when
JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
//verify
scaleRequest.setType(ScaleDirection.IN);
scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
scaleOperationExecution.setStatus(OperationStatus.STARTED);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
VnfProperty prop = new VnfProperty();
prop.setValue(ONAP_CSAR_ID);
prop.setName(LifecycleManager.ONAP_CSAR_ID);
vnfInfo.getExtensions().add(prop);
vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
- List<ApiException> expectedExceptions = new ArrayList<>();
- when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<List<OperationExecution>>) invocation -> {
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
+ List<RuntimeException> expectedExceptions = new ArrayList<>();
+ when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
if (expectedExceptions.size() >= 100) {
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
scaleOperationExecution.setStatus(OperationStatus.FINISHED);
- return operationExecutions;
+ return buildObservable(operationExecutions);
}
- ApiException apiException = new ApiException();
- expectedExceptions.add(apiException);
- // when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(scaleOperationExecution);
- throw apiException;
+ RuntimeException RuntimeException = new RuntimeException();
+ expectedExceptions.add(RuntimeException);
+ throw RuntimeException;
});
//when
//verify
waitForJobToFinishInJobManager(finished);
assertEquals(100, expectedExceptions.size());
- for (ApiException expectedException : expectedExceptions) {
+ for (RuntimeException expectedException : expectedExceptions) {
verify(logger).warn("Unable to retrieve operations details", expectedException);
}
verify(systemFunctions, times(100)).sleep(5000);
*/
@Test
public void testScaleFailurePropagation() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
VnfScaleRequest scaleRequest = new VnfScaleRequest();
scaleRequest.setNumberOfSteps("2");
scaleRequest.setAspectId("myAspect");
affectedVm.setVmname("vmName");
healRequest.setAffectedvm(affectedVm);
healOperationExecution.setStatus(OperationStatus.FINISHED);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
VnfProperty prop = new VnfProperty();
prop.setValue(ONAP_CSAR_ID);
prop.setName(LifecycleManager.ONAP_CSAR_ID);
vnfInfo.getExtensions().add(prop);
vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
//when
JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
//verify
affectedVm.setVmname("vmName");
healRequest.setAffectedvm(affectedVm);
healOperationExecution.setStatus(OperationStatus.FINISHED);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
VnfProperty prop = new VnfProperty();
prop.setValue(ONAP_CSAR_ID);
prop.setName(LifecycleManager.ONAP_CSAR_ID);
vnfInfo.getExtensions().add(prop);
vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams));
- List<ApiException> expectedExceptions = new ArrayList<>();
- when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() {
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
+ List<RuntimeException> expectedExceptions = new ArrayList<>();
+ when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
@Override
- public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
+ public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
if (expectedExceptions.size() >= 100) {
scaleOperationExecution.setStatus(OperationStatus.FINISHED);
- return operationExecutions;
+ return buildObservable(operationExecutions);
}
- ApiException apiException = new ApiException();
- expectedExceptions.add(apiException);
- throw apiException;
+ RuntimeException RuntimeException = new RuntimeException();
+ expectedExceptions.add(RuntimeException);
+ throw RuntimeException;
}
});
//when
- JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
+ JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
//verify
waitForJobToFinishInJobManager(finished);
assertEquals(100, expectedExceptions.size());
- for (ApiException expectedException : expectedExceptions) {
+ for (RuntimeException expectedException : expectedExceptions) {
verify(logger).warn("Unable to retrieve operations details", expectedException);
}
verify(systemFunctions, times(100)).sleep(5000);
*/
@Test
public void testHealFailurePropagation() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
VnfHealRequest healRequest = new VnfHealRequest();
healRequest.setAction("myAction");
VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
healRequest.setAffectedvm(affectedVm);
when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
//when
- JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
+ JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
//verify
waitForJobToFinishInJobManager(finished);
verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
import com.google.common.collect.Lists;
-import com.nokia.cbam.lcn.v32.ApiException;
import com.nokia.cbam.lcn.v32.model.CreateSubscriptionRequest;
import com.nokia.cbam.lcn.v32.model.Subscription;
import com.nokia.cbam.lcn.v32.model.SubscriptionAuthentication;
@Before
public void initMocks() throws Exception {
setField(SelfRegistrationManager.class, "logger", logger);
- when(lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)).thenReturn(subscriptions);
+ when(lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)).thenReturn(buildObservable(subscriptions));
when(driverProperties.getVnfmId()).thenReturn(VNFM_ID);
setField(selfRegistrationManager, "driverMsbExternalIp", "1.2.3.4");
setField(selfRegistrationManager, "driverVnfmExternalIp", "5.6.7.8");
public void testRegistration() throws Exception {
//given
Subscription subscription = new Subscription();
- when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenReturn(subscription);
+ when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenReturn(buildObservable(subscription));
MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
when(msbClient.registerMicroServiceInfo(registeredMicroservice.capture())).thenReturn(returnedMicroService);
//when
@Test
public void testFailedLcnSubscription() throws Exception {
//given
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(lcnApi.subscriptionsPost(any(), any())).thenThrow(expectedException);
//when
try {
public void testFailedMsbPublish() throws Exception {
//given
Subscription subscription = new Subscription();
- when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenAnswer(new Answer<Subscription>() {
- @Override
- public Subscription answer(InvocationOnMock invocationOnMock) throws Throwable {
- subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
- subscription.setId(UUID.randomUUID().toString());
- subscriptions.add(subscription);
- return subscription;
- }
+ when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenAnswer(invocationOnMock -> {
+ subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
+ subscription.setId(UUID.randomUUID().toString());
+ subscriptions.add(subscription);
+ return buildObservable(subscription);
});
MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
RouteException expectedException = new RouteException();
subscription.setId(UUID.randomUUID().toString());
subscriptions.add(subscription);
when(jobManager.hasOngoingJobs()).thenReturn(false);
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
doThrow(expectedException).when(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
//when
try {
package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification;
import com.google.gson.*;
-import com.nokia.cbam.lcm.v32.ApiException;
import com.nokia.cbam.lcm.v32.model.*;
-import org.joda.time.DateTime;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
public class TestLifecycleChangeNotificationManager extends TestBase {
- public static final String OPERATION_EXECUTION_ID = "myOperationExecutionId";
-
@InjectMocks
private LifecycleChangeNotificationManager lifecycleChangeNotificationManager;
private VnfLifecycleChangeNotification recievedLcn = new VnfLifecycleChangeNotification();
recievedLcn.setLifecycleOperationOccurrenceId("instantiationOperationExecutionId");
healOperation.setStartTime(OffsetDateTime.now().plusDays(1));
recievedLcn.setVnfInstanceId(VNF_ID);
- when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(operationExecutions);
+ when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
prepOperation(instantiationOperation);
prepOperation(scaleOperation);
prepOperation(healOperation);
VimInfo vimInfo = new VimInfo();
vimInfo.setId(VIM_ID);
instantiateVnfRequest.getVims().add(vimInfo);
- when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new Gson().toJsonTree(instantiateVnfRequest));
- when(vnfApi.vnfsGet(NOKIA_LCM_API_VERSION)).thenReturn(vnfs);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new Gson().toJsonTree(instantiateVnfRequest)));
+ when(vnfApi.vnfsGet(NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfs));
vnfs.add(vnf);
vnf.setId(VNF_ID);
VnfProperty prop = new VnfProperty();
prop.setValue(VNFM_ID);
vnf.setExtensions(new ArrayList<>());
vnf.getExtensions().add(prop);
- when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnf);
+ when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnf));
}
- private void prepOperation(OperationExecution operationExecution) throws ApiException {
+ private void prepOperation(OperationExecution operationExecution) {
addEmptyModifiedConnectionPoints(operationExecution);
JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}");
operationExecution.setOperationParams(root);
case TERMINATE:
root.getAsJsonObject().addProperty("terminationType", "GRACEFULL");
}
- when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationExecution);
+ when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecution));
operationExecutions.add(operationExecution);
}
*/
@Test
public void testInstantiationSufficesTheLastInstantiation() {
- DateTime baseTime = DateTime.now();
+ OffsetDateTime baseTime = OffsetDateTime.now();
List<OperationExecution> operations = new ArrayList<>();
OperationExecution operation = buildOperation(OffsetDateTime.now(), INSTANTIATE);
*/
@Test
public void testNoInstantiation() {
- DateTime baseTime = DateTime.now();
+ OffsetDateTime baseTime = OffsetDateTime.now();
List<OperationExecution> operations = new ArrayList<>();
OperationExecution operation = buildOperation(OffsetDateTime.now(), TERMINATE);
*/
@Test
public void testUnableToListVnfs() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsGet(NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
//when
try {
*/
@Test
public void testUnableToQueryVnf() throws Exception {
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
//when
try {
public void testUnableToQueryCurrentOperation() throws Exception {
recievedLcn.setOperation(OperationType.TERMINATE);
recievedLcn.setStatus(OperationStatus.FINISHED);
- ApiException expectedException = new ApiException();
+ RuntimeException expectedException = new RuntimeException();
when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
//when
try {
} catch (Exception e) {
//verify
assertEquals(expectedException, e.getCause());
- verify(logger).error("Unable to retrieve the current VNF myVnfId", e.getCause());
+ verify(logger).error("Unable to retrieve the operation executions for the VNF myVnfId", e.getCause());
}
}
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
- <version>1.5.10.RELEASE</version>
+ <version>${spring.boot.version}</version>
</dependency>
</dependencies>
<build>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
+ <version>3.2.0</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
<archive>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
- <version>1.5.10.RELEASE</version>
+ <version>${spring.boot.version}</version>
<configuration>
<mainClass>org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.NokiaSvnfmApplication</mainClass>
<layout>ZIP</layout>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
- <version>3.5</version>
+ <version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<version>1.1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>vfc/nfvo/driver/vnfm/svnfm/nokiav2/generatedapis</name>
+ <properties>
+ <gson-fire-version>1.8.2</gson-fire-version>
+ <retrofit-version>2.3.0</retrofit-version>
+ <rxjava-version>2.0.0</rxjava-version>
+ <threetenbp-version>1.3.5</threetenbp-version>
+ <oltu-version>1.0.1</oltu-version>
+ <swagger-core-version>1.5.15</swagger-core-version>
+ </properties>
<build>
<plugins>
<plugin>
<configuration>
<inputSpec>${basedir}/src/main/resources/nokia.vnfm.api.v3.lcm.json</inputSpec>
<language>java</language>
+ <library>retrofit2</library>
<output>${project.build.directory}/generated-sources/cbam</output>
<apiPackage>com.nokia.cbam.lcm.v32.api</apiPackage>
<modelPackage>com.nokia.cbam.lcm.v32.model</modelPackage>
<configuration>
<inputSpec>${basedir}/src/main/resources/nokia.vnfm.api.v3.lcn.subscription.json</inputSpec>
<language>java</language>
+ <library>retrofit2</library>
<output>${project.build.directory}/generated-sources/cbam</output>
<apiPackage>com.nokia.cbam.lcn.v32.api</apiPackage>
<modelPackage>com.nokia.cbam.lcn.v32.model</modelPackage>
<configOptions>
<generateSupportingFiles>false</generateSupportingFiles>
<sourceFolder>src/gen/java/main</sourceFolder>
+ <withXml>true</withXml>
+ <useRxJava2>true</useRxJava2>
</configOptions>
</configuration>
</execution>
<configuration>
<inputSpec>${basedir}/src/main/resources/nokia.catalog.json</inputSpec>
<language>java</language>
+ <library>retrofit2</library>
<output>${project.build.directory}/generated-sources/cbam</output>
<apiPackage>com.nokia.cbam.catalog.v1.api</apiPackage>
<modelPackage>com.nokia.cbam.catalog.v1.model</modelPackage>
<configuration>
<inputSpec>${basedir}/src/main/resources/vfc.catalog.swagger.json</inputSpec>
<language>java</language>
+ <library>retrofit2</library>
<output>${project.build.directory}/generated-sources/vfccatalog</output>
<apiPackage>org.onap.vfccatalog.api</apiPackage>
<modelPackage>org.onap.vfccatalog.model</modelPackage>
<configuration>
<inputSpec>${basedir}/src/main/resources/vfc.vnfdriver.swagger.json</inputSpec>
<language>java</language>
+ <library>retrofit2</library>
<output>${project.build.directory}/generated-sources/vnfmdriver</output>
<apiPackage>org.onap.vnfmdriver.api</apiPackage>
<modelPackage>org.onap.vnfmdriver.model</modelPackage>
</configOptions>
</configuration>
</execution>
+<!--
+ <execution>
+ <id>soadapter</id>
+ <goals>
+ <goal>generate</goal>
+ </goals>
+ <configuration>
+ <inputSpec>${basedir}/src/main/resources/so.vnfm.json</inputSpec>
+ <language>java</language>
+ <library>retrofit2</library>
+ <output>${project.build.directory}/generated-sources/soadapter</output>
+ <apiPackage>org.onap.soadapter.api</apiPackage>
+ <modelPackage>org.onap.soadapter.model</modelPackage>
+ <configOptions>
+ <generateSupportingFiles>false</generateSupportingFiles>
+ <sourceFolder>src/gen/java/main</sourceFolder>
+ </configOptions>
+ </configuration>
+ </execution>
+-->
</executions>
</plugin>
<plugin>
</plugins>
</build>
<dependencies>
- <dependency>
- <groupId>com.google.code.gson</groupId>
- <artifactId>gson</artifactId>
- <version>2.8.2</version>
- </dependency>
<dependency>
<groupId>io.swagger</groupId>
<artifactId>swagger-annotations</artifactId>
- <version>1.5.16</version>
+ <version>${swagger-core-version}</version>
</dependency>
<dependency>
- <groupId>joda-time</groupId>
- <artifactId>joda-time</artifactId>
- <version>2.9.9</version>
+ <groupId>com.squareup.retrofit2</groupId>
+ <artifactId>converter-gson</artifactId>
+ <version>${retrofit-version}</version>
</dependency>
<dependency>
- <!-- this does not have a compile time dependency, but is required to be able to deserialize the date to joda time -->
- <groupId>com.fasterxml.jackson.datatype</groupId>
- <artifactId>jackson-datatype-joda</artifactId>
- <!-- this version must be in sync with the dependency comming from spring boot -->
- <version>2.8.10</version>
+ <groupId>com.squareup.retrofit2</groupId>
+ <artifactId>retrofit</artifactId>
+ <version>${retrofit-version}</version>
</dependency>
<dependency>
- <groupId>com.squareup.okhttp</groupId>
- <artifactId>okhttp</artifactId>
- <version>2.7.5</version>
+ <groupId>com.squareup.retrofit2</groupId>
+ <artifactId>converter-scalars</artifactId>
+ <version>${retrofit-version}</version>
</dependency>
<dependency>
- <groupId>com.squareup.okhttp</groupId>
- <artifactId>logging-interceptor</artifactId>
- <version>2.7.5</version>
+ <groupId>org.apache.oltu.oauth2</groupId>
+ <artifactId>org.apache.oltu.oauth2.client</artifactId>
+ <version>${oltu-version}</version>
+ </dependency>
+ <dependency>
+ <groupId>io.gsonfire</groupId>
+ <artifactId>gson-fire</artifactId>
+ <version>${gson-fire-version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.threeten</groupId>
+ <artifactId>threetenbp</artifactId>
+ <version>${threetenbp-version}</version>
+ </dependency>
+ <dependency>
+ <groupId>io.reactivex.rxjava2</groupId>
+ <artifactId>rxjava</artifactId>
+ <version>${rxjava-version}</version>
+ </dependency>
+ <dependency>
+ <groupId>com.squareup.retrofit2</groupId>
+ <artifactId>adapter-rxjava2</artifactId>
+ <version>${retrofit-version}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<scope>provided</scope>
</dependency>
<dependency>
- <groupId>io.gsonfire</groupId>
- <artifactId>gson-fire</artifactId>
- <version>1.8.2</version>
- </dependency>
- <dependency>
- <groupId>org.threeten</groupId>
- <artifactId>threetenbp</artifactId>
- <version>1.3.6</version>
+ <groupId>com.google.guava</groupId>
+ <artifactId>guava</artifactId>
+ <version>24.0-jre</version>
+ <scope>test</scope>
</dependency>
</dependencies>
</project>
import com.nokia.cbam.lcm.v32.ApiClient;
import com.nokia.cbam.lcm.v32.model.*;
+import okhttp3.Headers;
+import okhttp3.RequestBody;
+import okhttp3.ResponseBody;
+import okhttp3.internal.http.RealResponseBody;
+import okio.Buffer;
+import okio.BufferedSource;
import org.junit.Test;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+
import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertNull;
import static junit.framework.TestCase.assertTrue;
public class TestInhertence {
* test OpenStack v2 inheritence handling in serialization and deserialization
*/
@Test
- public void testOpenStackV2(){
+ public void testOpenStackV2() throws IOException{
InstantiateVnfRequest req = new InstantiateVnfRequest();
OPENSTACKV2INFO vim = new OPENSTACKV2INFO();
req.getVims().add(vim);
OpenStackAccessInfoV2 accessInfo = new OpenStackAccessInfoV2();
accessInfo.setPassword("myPassword");
vim.setAccessInfo(accessInfo);
- String serialize = new ApiClient().getJSON().serialize(req);
- assertTrue(serialize.contains("myPassword"));
- InstantiateVnfRequest deserialize = new ApiClient().getJSON().deserialize(serialize, InstantiateVnfRequest.class);
+ Annotation[] x = new Annotation[0];
+ RequestBody requestBody = new ApiClient().getAdapterBuilder().build().requestBodyConverter(InstantiateVnfRequest.class, x, new Annotation[0]).convert(req);
+ assertTrue(getContent(requestBody).contains("myPassword"));
+ ResponseBody responseBody = toResponse(requestBody);
+ InstantiateVnfRequest deserialize = (InstantiateVnfRequest) new ApiClient().getAdapterBuilder().build().responseBodyConverter(InstantiateVnfRequest.class, new Annotation[0]).convert(responseBody);
assertEquals(1, deserialize.getVims().size());
OPENSTACKV2INFO deserializedVim = (OPENSTACKV2INFO) deserialize.getVims().get(0);
assertEquals("myPassword", deserializedVim.getAccessInfo().getPassword());
}
- /**
- * test OpenStack v3 inheritence handling in serialization and deserialization
- */
- @Test
- public void testOpenStackV3(){
- InstantiateVnfRequest req = new InstantiateVnfRequest();
- OPENSTACKV3INFO vim = new OPENSTACKV3INFO();
- req.getVims().add(vim);
- vim.setVimInfoType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
- OpenStackAccessInfoV3 accessInfo = new OpenStackAccessInfoV3();
- accessInfo.setPassword("myPassword");
- vim.setAccessInfo(accessInfo);
- String serialize = new ApiClient().getJSON().serialize(req);
- assertTrue(serialize.contains("myPassword"));
- InstantiateVnfRequest deserialize = new ApiClient().getJSON().deserialize(serialize, InstantiateVnfRequest.class);
- assertEquals(1, deserialize.getVims().size());
- OPENSTACKV3INFO deserializedVim = (OPENSTACKV3INFO) deserialize.getVims().get(0);
- assertEquals("myPassword", deserializedVim.getAccessInfo().getPassword());
- }
-
- /**
- * test vCloud inheritence handling in serialization and deserialization
- */
- @Test
- public void testVCloud(){
- InstantiateVnfRequest req = new InstantiateVnfRequest();
- VMWAREVCLOUDINFO vim = new VMWAREVCLOUDINFO();
- req.getVims().add(vim);
- vim.setVimInfoType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
- VCloudAccessInfo accessInfo = new VCloudAccessInfo();
- accessInfo.setPassword("myPassword");
- vim.setAccessInfo(accessInfo);
- String serialize = new ApiClient().getJSON().serialize(req);
- assertTrue(serialize.contains("myPassword"));
- InstantiateVnfRequest deserialize = new ApiClient().getJSON().deserialize(serialize, InstantiateVnfRequest.class);
- assertEquals(1, deserialize.getVims().size());
- VMWAREVCLOUDINFO deserializedVim = (VMWAREVCLOUDINFO) deserialize.getVims().get(0);
- assertEquals("myPassword", deserializedVim.getAccessInfo().getPassword());
+ private ResponseBody toResponse(RequestBody convert) throws IOException {
+ Headers headers = new Headers.Builder().build();
+ Buffer buffer = new Buffer();
+ convert.writeTo(buffer);
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ buffer.copyTo(byteArrayOutputStream);
+ BufferedSource response = buffer;
+ return new RealResponseBody(headers, response);
}
- /**
- * test LCN serialization and deserialization
- */
- @Test
- public void testLcn() throws Exception{
- VnfLifecycleChangeNotification vnfLifecycleChangeNotification = new VnfLifecycleChangeNotification();
- vnfLifecycleChangeNotification.setNotificationType(VnfNotificationType.VNFLIFECYCLECHANGENOTIFICATION);
- vnfLifecycleChangeNotification.setVnfInstanceId("myId");
- String serialize = new ApiClient().getJSON().serialize(vnfLifecycleChangeNotification);
- VnfLifecycleChangeNotification deserialize = new ApiClient().getJSON().deserialize(serialize, VnfLifecycleChangeNotification.class);
- assertEquals("myId", deserialize.getVnfInstanceId());
+ private String getContent(RequestBody requestBody) throws IOException {
+ Buffer buffer = new Buffer();
+ requestBody.writeTo(buffer);
+ ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+ buffer.copyTo(byteArrayOutputStream);
+ return new String(byteArrayOutputStream.toByteArray());
}
- /**
- * test arrays are not initialized to empty arrays
- */
- @Test
- public void testArrayBehaviour() throws Exception{
- VnfLifecycleChangeNotification vnfLifecycleChangeNotification = new VnfLifecycleChangeNotification();
- vnfLifecycleChangeNotification.setNotificationType(VnfNotificationType.VNFLIFECYCLECHANGENOTIFICATION);
- vnfLifecycleChangeNotification.setVnfInstanceId("myId");
- String serialize = new ApiClient().getJSON().serialize(vnfLifecycleChangeNotification);
- VnfLifecycleChangeNotification deserialize = new ApiClient().getJSON().deserialize(serialize, VnfLifecycleChangeNotification.class);
- assertNull(deserialize.getAffectedVirtualLinks());
- }
-
}
-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
- <!--<groupId>org.onap.oparent</groupId>
- <artifactId>oparent</artifactId>
- <version>0.1.1</version>
- -->
-<!-- FIXME this artifact is not available in nexus-->
- <groupId>org.onap.vfc.nfvo.driver.vnfm.svnfm</groupId>
- <artifactId>vfc-nfvo-driver-vnfm-svnfm</artifactId>
- <version>1.1.0-SNAPSHOT</version>
+ <groupId>org.onap.vfc.nfvo.driver.vnfm.svnfm</groupId>
+ <artifactId>vfc-nfvo-driver-vnfm-svnfm</artifactId>
+ <version>1.1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.onap.vfc.nfvo.driver.vnfm.svnfm.nokiav2</groupId>
<name>vfc-nfvo-driver-vnfm-svnfm-nokiav2</name>
<properties>
<jacoco.version>0.8.0</jacoco.version>
- </properties>
-<modules>
+ <spring.boot.version>1.5.10.RELEASE</spring.boot.version>
+<!-- <spring.boot.version>2.0.0.RELEASE</spring.boot.version> -->
+ </properties>
+ <!--
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-enforcer-plugin</artifactId>
+ <version>1.4.1</version>
+ <executions>
+ <execution>
+ <id>enforce</id>
+ <configuration>
+ <rules>
+ <DependencyConvergence/>
+ </rules>
+ </configuration>
+ <goals>
+ <goal>enforce</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ -->
+ <modules>
<module>generatedapis</module>
<module>driver</module>
<module>driverwar</module>
<parent>
<groupId>org.onap.oparent</groupId>
<artifactId>oparent</artifactId>
- <version>0.1.1</version>
+ <version>1.1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>org.onap.vfc.nfvo.driver.vnfm.svnfm</groupId>
Code Review / vfc / nfvo / driver / vnfm / svnfm.git / commitdiff