aboutsummaryrefslogtreecommitdiffstats
path: root/openecomp-be/backend/openecomp-sdc-vendor-license-manager
diff options
context:
space:
mode:
Diffstat (limited to 'openecomp-be/backend/openecomp-sdc-vendor-license-manager')
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml2
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml.versionsBackup77
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java12
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java30
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java256
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java28
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/EntitlementPoolTest.java388
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/FeatureGroupTest.java140
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseKeyGroupTest.java172
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java332
-rw-r--r--openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java127
11 files changed, 1498 insertions, 66 deletions
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml
index ac39119ed2..0a5f5b6e6c 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml
@@ -52,7 +52,7 @@
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
- <version>4.11</version>
+ <version>${junit.version}</version>
</dependency>
<dependency>
<groupId>javax.el</groupId>
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml.versionsBackup b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml.versionsBackup
new file mode 100644
index 0000000000..85b34a187e
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml.versionsBackup
@@ -0,0 +1,77 @@
+<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">
+ <modelVersion>4.0.0</modelVersion>
+
+ <name>openecomp-sdc-vendor-license-manager</name>
+ <artifactId>openecomp-sdc-vendor-license-manager</artifactId>
+
+ <parent>
+ <artifactId>backend</artifactId>
+ <groupId>org.openecomp.sdc</groupId>
+ <version>1.0-SNAPSHOT</version>
+ </parent>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.openecomp.sdc</groupId>
+ <artifactId>openecomp-sdc-vendor-license-core</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-all</artifactId>
+ <scope>test</scope>
+ <version>1.10.19</version>
+ </dependency>
+ <dependency>
+ <groupId>org.testng</groupId>
+ <artifactId>testng</artifactId>
+ <scope>test</scope>
+ <version>6.8.5</version>
+ <exclusions>
+ <exclusion>
+ <artifactId>snakeyaml</artifactId>
+ <groupId>org.yaml</groupId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ <version>4.11</version>
+ </dependency>
+ <dependency>
+ <groupId>javax.el</groupId>
+ <artifactId>javax.el-api</artifactId>
+ <version>${javax.el-api.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.web</groupId>
+ <artifactId>javax.el</artifactId>
+ <version>2.2.4</version>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.woodstox</groupId>
+ <artifactId>woodstox-core-asl</artifactId>
+ <version>4.4.1</version>
+ </dependency>
+ <dependency>
+ <groupId>org.openecomp.sdc</groupId>
+ <artifactId>openecomp-sdc-vendor-software-product-manager</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>com.fasterxml.jackson.dataformat</groupId>
+ <artifactId>jackson-dataformat-xml</artifactId>
+ <version>2.7.4</version>
+ </dependency>
+ <!-- https://mvnrepository.com/artifact/commons-io/commons-io -->
+ <dependency>
+ <groupId>commons-io</groupId>
+ <artifactId>commons-io</artifactId>
+ <version>${commons.io.version}</version>
+ </dependency>
+
+ </dependencies>
+</project> \ No newline at end of file
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
index aa9fc0a8cd..a76b9b865d 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java
@@ -26,7 +26,9 @@ import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel;
import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
+import org.openecomp.sdc.vendorlicense.errors.LimitErrorBuilder;
import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel;
import org.openecomp.sdc.versioning.dao.types.Version;
@@ -109,4 +111,14 @@ public interface VendorLicenseManager {
void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user);
+ LimitEntity createLimit(LimitEntity limitEntity, String user);
+
+ Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId, String user);
+
+ void deleteLimit(LimitEntity limitEntity, String user);
+
+ void updateLimit(LimitEntity limitEntity, String user);
+
+ LimitEntity getLimit(LimitEntity entitlementPool, String user);
+
}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java
new file mode 100644
index 0000000000..4889b5a04a
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/errors/LimitErrorBuilder.java
@@ -0,0 +1,30 @@
+package org.openecomp.sdc.vendorlicense.errors;
+
+
+import org.openecomp.sdc.common.errors.ErrorCategory;
+import org.openecomp.sdc.common.errors.ErrorCode;
+
+public class LimitErrorBuilder {
+
+ private static final String LIMIT_INVALID_ATTR_VALUE_MSG = "The %s value doesn't meet the "
+ + "expected attribute value.";
+
+ private static final String DUPLICATE_LIMIT_NAME_NOT_ALLOWED_MSG =
+ "Invalid request, Limit with name %s already exists for type %s.";
+
+ public static ErrorCode getInvalidValueErrorBuilder(String attribute, String errorCode) {
+ ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
+ builder.withId(errorCode);
+ builder.withCategory(ErrorCategory.APPLICATION);
+ builder.withMessage(String.format(LIMIT_INVALID_ATTR_VALUE_MSG, attribute));
+ return builder.build();
+ }
+
+ public static ErrorCode getDuplicateNameErrorbuilder(String name, String type) {
+ ErrorCode.ErrorCodeBuilder builder = new ErrorCode.ErrorCodeBuilder();
+ builder.withId(VendorLicenseErrorCodes.DUPLICATE_LIMIT_NAME_NOT_ALLOWED);
+ builder.withCategory(ErrorCategory.APPLICATION);
+ builder.withMessage(String.format(DUPLICATE_LIMIT_NAME_NOT_ALLOWED_MSG, name, type ));
+ return builder.build();
+ }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
index eb559f2e62..622ff02501 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java
@@ -24,6 +24,8 @@ import org.openecomp.core.util.UniqueValueUtil;
import org.openecomp.sdc.activityLog.ActivityLogManager;
import org.openecomp.sdc.activityLog.ActivityLogManagerFactory;
import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.common.errors.ErrorCode;
import org.openecomp.sdc.datatypes.error.ErrorLevel;
import org.openecomp.sdc.logging.api.Logger;
import org.openecomp.sdc.logging.api.LoggerFactory;
@@ -32,6 +34,7 @@ import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
import org.openecomp.sdc.logging.types.LoggerConstants;
import org.openecomp.sdc.logging.types.LoggerErrorCode;
import org.openecomp.sdc.logging.types.LoggerErrorDescription;
+import org.openecomp.sdc.logging.types.LoggerServiceName;
import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
import org.openecomp.sdc.vendorlicense.VendorLicenseConstants;
import org.openecomp.sdc.vendorlicense.VendorLicenseManager;
@@ -43,6 +46,8 @@ import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao;
import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDaoFactory;
import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDaoFactory;
+import org.openecomp.sdc.vendorlicense.dao.LimitDao;
+import org.openecomp.sdc.vendorlicense.dao.LimitDaoFactory;
import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao;
import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDaoFactory;
import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
@@ -51,7 +56,11 @@ import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel;
import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.LimitType;
import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
+import org.openecomp.sdc.vendorlicense.errors.InvalidDateErrorBuilder;
+import org.openecomp.sdc.vendorlicense.errors.LimitErrorBuilder;
import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel;
@@ -64,10 +73,14 @@ import org.openecomp.sdc.versioning.types.VersionInfo;
import org.openecomp.sdc.versioning.types.VersionableEntityAction;
import org.openecomp.sdcrests.activitylog.types.ActivityType;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE;
@@ -75,7 +88,7 @@ import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICE
public class VendorLicenseManagerImpl implements VendorLicenseManager {
private static final VersioningManager versioningManager =
VersioningManagerFactory.getInstance().createInterface();
- private static final VendorLicenseFacade vendorLicenseFacade =
+ private VendorLicenseFacade vendorLicenseFacade =
VendorLicenseFacadeFactory.getInstance().createInterface();
private static final VendorLicenseModelDao vendorLicenseModelDao =
VendorLicenseModelDaoFactory.getInstance().createInterface();
@@ -87,6 +100,9 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
EntitlementPoolDaoFactory.getInstance().createInterface();
private static final LicenseKeyGroupDao licenseKeyGroupDao =
LicenseKeyGroupDaoFactory.getInstance().createInterface();
+ private static final LimitDao limitDao =
+ LimitDaoFactory.getInstance().createInterface();
+
private ActivityLogManager activityLogManager = ActivityLogManagerFactory.getInstance().createInterface();
private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
private static final Logger logger =
@@ -471,14 +487,110 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
.debugEntryMessage("VLM id", entitlementPool.getVendorLicenseModelId());
mdcDataDebugMessage
.debugExitMessage("VLM id", entitlementPool.getVendorLicenseModelId());
+ validateCreateDate(entitlementPool);
return vendorLicenseFacade.createEntitlementPool(entitlementPool, user);
}
+ private void validateCreateDate(EntitlementPoolEntity entitlementPool){
+ mdcDataDebugMessage.debugEntryMessage("Start date and end date", entitlementPool.getStartDate
+ ()+" "+entitlementPool.getExpiryDate());
+
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
+
+ entitlementPool.setStartDate(entitlementPool.getStartDate() != null ? (entitlementPool
+ .getStartDate().trim().length() != 0 ? entitlementPool.getStartDate()+"T00:00:00Z"
+ : null) : null);
+ entitlementPool.setExpiryDate(entitlementPool.getExpiryDate() != null ? (entitlementPool
+ .getExpiryDate().trim().length() != 0 ? entitlementPool.getExpiryDate()+"T23:59:59Z"
+ : null) : null);
+
+ if(entitlementPool.getStartDate() != null && entitlementPool.getExpiryDate() != null) {
+ if (LocalDate.parse(entitlementPool.getStartDate(), formatter).atStartOfDay().isBefore
+ (LocalDate.now().atStartOfDay()) ||
+ LocalDate.parse(entitlementPool.getExpiryDate(), formatter).atStartOfDay()
+ .isEqual(LocalDate.now().atStartOfDay()) ||
+ LocalDate.parse(entitlementPool.getExpiryDate(), formatter)
+ .isBefore(LocalDate.parse(entitlementPool.getStartDate(), formatter))) {
+ MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
+ LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
+ LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+ throw new CoreException(
+ new InvalidDateErrorBuilder(entitlementPool.getVendorLicenseModelId())
+ .build());
+ }
+ }
+
+ if(entitlementPool.getStartDate() != null && entitlementPool.getExpiryDate() == null) {
+ if (LocalDate.parse(entitlementPool.getStartDate(), formatter).atStartOfDay().isBefore
+ (LocalDate.now().atStartOfDay())) {
+ MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
+ LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
+ LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+ throw new CoreException(
+ new InvalidDateErrorBuilder(entitlementPool.getVendorLicenseModelId())
+ .build());
+ }
+ }
+
+ if(entitlementPool.getStartDate() == null && entitlementPool.getExpiryDate() != null) {
+ MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
+ LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
+ LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+ throw new CoreException(
+ new InvalidDateErrorBuilder(entitlementPool.getVendorLicenseModelId())
+ .build());
+
+ }
+
+ mdcDataDebugMessage.debugExitMessage(null,null);
+ }
+
+ private void validateUpdateDate(EntitlementPoolEntity entitlementPool){
+ mdcDataDebugMessage.debugEntryMessage("Start date and end date", entitlementPool.getStartDate
+ ()+" "+entitlementPool.getExpiryDate());
+
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
+
+ entitlementPool.setStartDate(entitlementPool.getStartDate() != null ? (entitlementPool
+ .getStartDate().trim().length() != 0 ? entitlementPool.getStartDate()+"T00:00:00Z"
+ : null) : null);
+ entitlementPool.setExpiryDate(entitlementPool.getExpiryDate() != null ? (entitlementPool
+ .getExpiryDate().trim().length() != 0 ? entitlementPool.getExpiryDate()+"T23:59:59Z"
+ : null) : null);
+
+ if(entitlementPool.getStartDate() != null && entitlementPool.getExpiryDate() != null) {
+ if (LocalDate.parse(entitlementPool.getExpiryDate(), formatter).atStartOfDay()
+ .isEqual(LocalDate.parse(entitlementPool.getStartDate(), formatter).atStartOfDay()) ||
+ LocalDate.parse(entitlementPool.getExpiryDate(), formatter)
+ .isBefore(LocalDate.parse(entitlementPool.getStartDate(), formatter))) {
+ MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
+ LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
+ LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+ throw new CoreException(
+ new InvalidDateErrorBuilder(entitlementPool.getVendorLicenseModelId())
+ .build());
+ }
+ }
+
+ if(entitlementPool.getStartDate() == null && entitlementPool.getExpiryDate() != null) {
+ MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
+ LoggerTragetServiceName.VALIDATE_DATE_RANGE,ErrorLevel.ERROR.name(),
+ LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_VALUE);
+ throw new CoreException(
+ new InvalidDateErrorBuilder(entitlementPool.getVendorLicenseModelId())
+ .build());
+
+ }
+
+ mdcDataDebugMessage.debugExitMessage(null,null);
+ }
+
@Override
public void updateEntitlementPool(EntitlementPoolEntity entitlementPool, String user) {
mdcDataDebugMessage.debugEntryMessage("VLM id, EP id", entitlementPool
.getVendorLicenseModelId(), entitlementPool.getId());
+ validateUpdateDate(entitlementPool);
Version version = VersioningUtil.resolveVersion(entitlementPool.getVersion(),
getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write,
user), user);
@@ -504,6 +616,18 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
VersioningUtil
.validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE);
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'");
+ DateTimeFormatter targetFormatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ if(retrieved.getStartDate() != null){
+ retrieved.setStartDate(LocalDate.parse(retrieved.getStartDate(),formatter).format
+ (targetFormatter));
+ }
+
+ if(retrieved.getExpiryDate() != null){
+ retrieved.setExpiryDate(LocalDate.parse(retrieved.getExpiryDate(),formatter).format
+ (targetFormatter));
+ }
+
mdcDataDebugMessage.debugExitMessage("VLM id, EP id", entitlementPool
.getVendorLicenseModelId(), entitlementPool.getId());
return retrieved;
@@ -529,6 +653,8 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
referencingFeatureGroupId), entitlementPool.getId());
}
+ deleteChildLimits(entitlementPool.getVendorLicenseModelId(), entitlementPool.getVersion(), entitlementPool.getId(), user);
+
entitlementPoolDao.delete(entitlementPool);
UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.ENTITLEMENT_POOL_NAME,
@@ -542,6 +668,14 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
.getVendorLicenseModelId(), entitlementPool.getId());
}
+ private void deleteChildLimits(String vlmId, Version version, String epLkgId, String user) {
+ Optional<Collection<LimitEntity>> limitEntities = Optional.ofNullable(
+ listLimits(vlmId, version, epLkgId, user));
+ limitEntities.ifPresent(entities->
+ entities.forEach(entity->
+ deleteLimit(entity, user)));
+ }
+
@Override
public Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version,
String user) {
@@ -617,6 +751,8 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
referencingFeatureGroupId), licenseKeyGroup.getId());
}
+ deleteChildLimits(licenseKeyGroup.getVendorLicenseModelId(), licenseKeyGroup.getVersion(), licenseKeyGroup.getId(), user);
+
licenseKeyGroupDao.delete(licenseKeyGroup);
UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_KEY_GROUP_NAME,
@@ -630,6 +766,124 @@ public class VendorLicenseManagerImpl implements VendorLicenseManager {
.getVendorLicenseModelId(), licenseKeyGroup.getId());
}
+ @Override
+ public LimitEntity createLimit(LimitEntity limit, String user) {
+ mdcDataDebugMessage
+ .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
+ .getEpLkgId());
+ mdcDataDebugMessage
+ .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
+ .getEpLkgId());
+ validateLimit(limit, user);
+ return vendorLicenseFacade.createLimit(limit, user);
+ }
+
+ private void validateLimit(LimitEntity limit, String user) {
+ Version version = VersioningUtil.resolveVersion(limit.getVersion(),
+ getVersionInfo(limit.getVendorLicenseModelId(), VersionableEntityAction.Write,
+ user), user);
+ Collection<LimitEntity> limitList = listLimits(limit.getVendorLicenseModelId(),version
+ ,limit.getEpLkgId(), user);
+
+ if (!isLimitNameUnique(limitList,limit.getName(), limit.getType(), limit.getId())) {
+ final ErrorCode duplicateLimitNameErrorBuilder =
+ LimitErrorBuilder.getDuplicateNameErrorbuilder(limit.getName(), limit.getType().name());
+ MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
+ LoggerServiceName.Create_LIMIT.toString(), ErrorLevel.ERROR.name(),
+ LoggerErrorCode.DATA_ERROR.getErrorCode(),
+ duplicateLimitNameErrorBuilder.message());
+ throw new CoreException(duplicateLimitNameErrorBuilder);
+ }
+ }
+
+ private boolean isLimitNameUnique(Collection<LimitEntity> limitList, String name, LimitType
+ type, String id) {
+ for (LimitEntity limit : limitList) {
+ if(limit.getName().equalsIgnoreCase(name) &&
+ limit.getType().name().equalsIgnoreCase(type.name())) {
+ if(id != null && limit.getId().equals(id)){
+ continue;
+ }
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public Collection<LimitEntity> listLimits(String vlmId, Version version, String epLkgId,
+ String user) {
+ mdcDataDebugMessage.debugEntryMessage("VLM id", vlmId, "EP/LKGId", epLkgId);
+ mdcDataDebugMessage.debugExitMessage("VLM id", vlmId, "EP/LKGId", epLkgId);
+ return vendorLicenseFacade.listLimits(vlmId, version, epLkgId, user);
+ }
+
+ @Override
+ public void deleteLimit(LimitEntity limitEntity, String user) {
+ mdcDataDebugMessage.debugEntryMessage("VLM id, EP id, Limit Id", limitEntity
+ .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
+
+ Version version = VersioningUtil.resolveVersion(limitEntity.getVersion(),
+ getVersionInfo(limitEntity.getVendorLicenseModelId(), VersionableEntityAction.Write,
+ user), user);
+ limitEntity.setVersion(version);
+
+ if(!isLimitPresent(limitEntity)){
+ VersioningUtil
+ .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+ }
+ LimitEntity retrieved = limitDao.get(limitEntity);
+ VersioningUtil
+ .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+
+ limitDao.delete(limitEntity);
+
+ vendorLicenseFacade.updateVlmLastModificationTime(limitEntity.getVendorLicenseModelId(),
+ limitEntity.getVersion());
+
+ mdcDataDebugMessage.debugExitMessage("VLM id, EP id, Limit Id", limitEntity
+ .getVendorLicenseModelId(), limitEntity.getEpLkgId(), limitEntity.getId());
+ }
+
+ @Override
+ public void updateLimit(LimitEntity limit, String user) {
+ mdcDataDebugMessage
+ .debugEntryMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
+ .getEpLkgId());
+ getLimit(limit,user);
+ validateLimit(limit, user);
+ vendorLicenseFacade.updateLimit(limit, user);
+ mdcDataDebugMessage
+ .debugExitMessage("VLM id", limit.getVendorLicenseModelId(), "EP/LKGId", limit
+ .getEpLkgId());
+ }
+
+ private boolean isLimitPresent(LimitEntity limit) {
+ return limitDao.isLimitPresent(limit);
+ }
+
+ @Override
+ public LimitEntity getLimit(LimitEntity limitEntity,
+ String user) {
+ mdcDataDebugMessage.debugEntryMessage("VLM id", limitEntity.getVendorLicenseModelId(),
+ "EP/LKGId", limitEntity.getEpLkgId());
+
+ limitEntity.setVersion(VersioningUtil.resolveVersion(limitEntity.getVersion(),
+ getVersionInfo(limitEntity.getVendorLicenseModelId(), VersionableEntityAction.Read,
+ user), user));
+ if(!isLimitPresent(limitEntity)){
+ VersioningUtil
+ .validateEntityExistence(null, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+ }
+ LimitEntity retrieved = limitDao.get(limitEntity);
+ VersioningUtil
+ .validateEntityExistence(retrieved, limitEntity, VendorLicenseModelEntity.ENTITY_TYPE);
+
+ mdcDataDebugMessage.debugExitMessage("VLM id", limitEntity.getVendorLicenseModelId(),
+ "EP/LKGId", limitEntity.getEpLkgId());
+ return retrieved;
+ }
+
private void addFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds,
LicenseAgreementEntity licenseAgreement) {
if (featureGroupIds != null) {
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java
index 40ea59f543..5d9729de53 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java
@@ -7,9 +7,9 @@
* 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.
@@ -126,12 +126,25 @@ public class ArtifactTestUtils {
protected List featureGroupsforVlm3;
protected LicenseAgreementEntity licenseAgreementVlm3;
+ public enum OnboardingMethod {
+ HEAT("HEAT"),
+ Manual("Manual");
+
+
+ OnboardingMethod(String method) {
+ this.method = method;
+ }
+
+ private String method;
+ }
+
protected static VspDetails createVspDetails(String id, Version version, String name, String desc,
String vendorName, String vlm, String icon,
String category, String subCategory,
String licenseAgreement,
- List<String> featureGroups) {
+ List<String> featureGroups,
+ String onboardingMethod) {
VspDetails vspDetails = new VspDetails(id, version);
vspDetails.setName(name);
vspDetails.setDescription(desc);
@@ -142,6 +155,7 @@ public class ArtifactTestUtils {
vspDetails.setVendorId(vlm);
vspDetails.setLicenseAgreement(licenseAgreement);
vspDetails.setFeatureGroups(featureGroups);
+ vspDetails.setOnboardingMethod(onboardingMethod);
return vspDetails;
}
@@ -238,7 +252,8 @@ public class ArtifactTestUtils {
vendorLicenseFacade.getVersionInfo(vlm1Id, VersionableEntityAction.Read, "");
vspDetails =
createVspDetails(null, null, "VSP1_" + CommonMethods.nextUuId(), "Test-vsp", "vendorName",
- vlm1Id, "icon", "category", "subCategory", la11Id, fgs);
+ vlm1Id, "icon", "category", "subCategory", la11Id, fgs, ArtifactTestUtils
+ .OnboardingMethod.HEAT.name());
List<Version> finalVersions = versionInfo.getFinalVersions();
Version finalVersion = finalVersions.get(1);
@@ -266,7 +281,8 @@ public class ArtifactTestUtils {
vspDetailsVsp3 =
createVspDetails(null, null, "VSP3_" + CommonMethods.nextUuId(), "VSP3",
"vendorName",
- vlm3Id, "icon", "category", "subCategory", licenceAgreementId, fgs);
+ vlm3Id, "icon", "category", "subCategory", licenceAgreementId, fgs, OnboardingMethod
+ .HEAT.name());
VersionInfo versionInfo =
vendorLicenseFacade.getVersionInfo(vlmToUse, VersionableEntityAction.Read, "");
@@ -383,7 +399,7 @@ public class ArtifactTestUtils {
fgs.add(fg21Id);
vsp2 =
createVspDetails(null, null, "VSP2_" + CommonMethods.nextUuId(), "Test-vsp", "vendorName",
- vlm2Id, "icon", "category", "subCategory", la21Id, fgs);
+ vlm2Id, "icon", "category", "subCategory", la21Id, fgs, OnboardingMethod.HEAT.name());
vsp2 = vendorSoftwareProductManager.createVsp(vsp2, USER1);
}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/EntitlementPoolTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/EntitlementPoolTest.java
index 95e0e519e1..9b079de3fa 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/EntitlementPoolTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/EntitlementPoolTest.java
@@ -17,38 +17,387 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
-/*
+
package org.openecomp.sdc.vendorlicense;
-import org.openecomp.core.util.UniqueValueUtil;
-import org.openecomp.core.utilities.CommonMethods;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
import org.openecomp.sdc.common.errors.CoreException;
import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao;
-import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDaoFactory;
-import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction;
-import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime;
-import org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther;
-import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope;
-import org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit;
+import org.openecomp.sdc.vendorlicense.dao.LimitDao;
+import org.openecomp.sdc.vendorlicense.dao.types.*;
+import org.openecomp.sdc.vendorlicense.errors.VendorLicenseErrorCodes;
+import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl;
import org.openecomp.sdc.versioning.dao.types.Version;
import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
+import org.openecomp.sdc.versioning.types.VersionInfo;
import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
+import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
-import java.util.Collection;
-import java.util.Collections;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
public class EntitlementPoolTest {
- private static final String USER1 = "epTestUser1";
+ //JUnit Test Cases using Mockito
+ private final String USER1 = "epTestUser1";
+ private final String EP1_NAME = "EP1 name";
+ private final String LT1_NAME = "LT1 name";
+
+ @Mock
+ private VendorLicenseFacade vendorLicenseFacade;
+
+ @Mock
+ private EntitlementPoolDao entitlementPoolDao;
+ @Mock
+ private LimitDao limitDao;
+
+ @InjectMocks
+ @Spy
+ private VendorLicenseManagerImpl vendorLicenseManagerImpl;
+
+ public EntitlementPoolEntity createEntitlementPool(String vlmId, Version version,
+ String name, String desc, int threshold,
+ ThresholdUnit thresholdUnit,
+ EntitlementMetric entitlementMetricChoice,
+ String entitlementMetricOther,
+ String increments,
+ AggregationFunction aggregationFunctionChoice,
+ String aggregationFunctionOther,
+ Set<OperationalScope> operationalScopeChoices,
+ String operationalScopeOther,
+ EntitlementTime timeChoice,
+ String timeOther, String sku) {
+ EntitlementPoolEntity entitlementPool = new EntitlementPoolEntity();
+ //entitlementPool.setVendorLicenseModelId(vlmId);
+ entitlementPool.setVersion(version);
+ entitlementPool.setName(name);
+ entitlementPool.setDescription(desc);
+ entitlementPool.setThresholdValue(threshold);
+ entitlementPool.setThresholdUnit(thresholdUnit);
+ entitlementPool
+ .setEntitlementMetric(new ChoiceOrOther<>(entitlementMetricChoice, entitlementMetricOther));
+ entitlementPool.setIncrements(increments);
+ entitlementPool.setAggregationFunction(
+ new ChoiceOrOther<>(aggregationFunctionChoice, aggregationFunctionOther));
+ entitlementPool.setOperationalScope(
+ new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther));
+ entitlementPool.setTime(new ChoiceOrOther<>(timeChoice, timeOther));
+ entitlementPool.setManufacturerReferenceNumber(sku);
+ return entitlementPool;
+ }
+
+ @BeforeMethod
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+ }
+
+ @Test
+ public void createTest() {
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+ EntitlementPoolEntity ep2 =
+ createEntitlementPool("vlm1Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ ep2.setStartDate(LocalDate.now().format(formatter));
+ ep2.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter));
+
+ vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1);
+ }
+
+ @Test
+ public void createWithInvalidStartExpiryDateTest() {
+ try {
+
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+ EntitlementPoolEntity ep2 =
+ createEntitlementPool("vlm2Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ ep2.setStartDate(LocalDate.now().format(formatter));
+ ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
+ vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId();
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
+ }
+ }
+
+ @Test
+ public void createWithoutStartDateTest() {
+ try {
+
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+ EntitlementPoolEntity ep2 =
+ createEntitlementPool("vlm3Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
+ vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId();
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
+ }
+ }
+
+ @Test
+ public void createWithSameStartExpiryDateTest() {
+ try {
+
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+ EntitlementPoolEntity ep2 =
+ createEntitlementPool("vlm4Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ ep2.setStartDate(LocalDate.now().format(formatter));
+ ep2.setExpiryDate(LocalDate.now().format(formatter));
+ vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId();
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
+ }
+ }
+
+ @Test
+ public void createUpdate() {
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+ EntitlementPoolEntity ep2 =
+ createEntitlementPool("vlm1Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ ep2.setStartDate(LocalDate.now().minusDays(3L).format(formatter));
+ ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
+ VersionInfo info = new VersionInfo();
+ Version version = new Version();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1);
+ }
+
+ @Test
+ public void updateWithInvalidStartExpiryDateTest() {
+ try {
+
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+ EntitlementPoolEntity ep2 =
+ createEntitlementPool("vlm2Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ ep2.setStartDate(LocalDate.now().format(formatter));
+ ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter));
+ vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1);
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
+ }
+ }
+
+ @Test
+ public void updateWithoutStartDateTest() {
+ try {
+
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+ EntitlementPoolEntity ep2 =
+ createEntitlementPool("vlm3Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter));
+ vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1);
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
+ }
+ }
+
+ @Test
+ public void updateWithSameStartExpiryDateTest() {
+ try {
+
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+ EntitlementPoolEntity ep2 =
+ createEntitlementPool("vlm4Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ ep2.setStartDate(LocalDate.now().format(formatter));
+ ep2.setExpiryDate(LocalDate.now().format(formatter));
+ vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1);
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID);
+ }
+ }
+
+ @Test
+ public void deleteEntitlementPoolTest() {
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+
+ EntitlementPoolEntity entitlementPool =
+ createEntitlementPool("vlm1Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ entitlementPool.setStartDate(LocalDate.now().format(formatter));
+ entitlementPool.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter));
+
+ VersionInfo info = new VersionInfo();
+ Version version = new Version();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ LimitEntity limitEntity = LimitTest.createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Core,AggregationFunction.Average,10,EntitlementTime.Hour);
+
+ ArrayList<LimitEntity> limitEntityList = new ArrayList();
+ limitEntityList.add(limitEntity);
+
+ doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject());
+ doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(), anyObject(), anyObject(), anyObject());
+ doReturn(true).when(limitDao).isLimitPresent(anyObject());
+ doReturn(limitEntity).when(limitDao).get(anyObject());
+ try {
+ Field limitField = VendorLicenseManagerImpl.class.getDeclaredField("limitDao");
+ limitField.setAccessible(true);
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(limitField, limitField.getModifiers() & ~Modifier.FINAL);
+ limitField.set(null, limitDao);
+
+ Field epField = VendorLicenseManagerImpl.class.getDeclaredField("entitlementPoolDao");
+ epField.setAccessible(true);
+ modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(epField, epField.getModifiers() & ~Modifier.FINAL);
+ epField.set(null, entitlementPoolDao);
+ } catch(NoSuchFieldException | IllegalAccessException e)
+ {
+ Assert.fail();
+ }
+
+ vendorLicenseManagerImpl.deleteEntitlementPool(entitlementPool, USER1);
+
+ verify(limitDao).delete(anyObject());
+ }
+
+ @Test
+ public void deleteEntitlementPoolInvalidTest() {
+ try {
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+
+ EntitlementPoolEntity entitlementPool =
+ createEntitlementPool("vlm1Id", null, EP1_NAME, "EP2 dec", 70, ThresholdUnit.Absolute,
+ EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null,
+ opScopeChoices, null, EntitlementTime.Other, "time2", "sku2");
+ DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy");
+ entitlementPool.setStartDate(LocalDate.now().format(formatter));
+ entitlementPool.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter));
+
+ VersionInfo info = new VersionInfo();
+ Version version = new Version();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ LimitEntity limitEntity = LimitTest.createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Core,AggregationFunction.Average,10,EntitlementTime.Hour);
+
+ ArrayList<LimitEntity> limitEntityList = new ArrayList();
+ limitEntityList.add(limitEntity);
+
+ doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject());
+ doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(), anyObject(), anyObject(), anyObject());
+ doReturn(false).when(limitDao).isLimitPresent(anyObject());
+
+ try {
+ Field limitField = VendorLicenseManagerImpl.class.getDeclaredField("limitDao");
+ limitField.setAccessible(true);
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(limitField, limitField.getModifiers() & ~Modifier.FINAL);
+ limitField.set(null, limitDao);
+
+ Field epField = VendorLicenseManagerImpl.class.getDeclaredField("entitlementPoolDao");
+ epField.setAccessible(true);
+ modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(epField, epField.getModifiers() & ~Modifier.FINAL);
+ epField.set(null, entitlementPoolDao);
+ } catch(NoSuchFieldException | IllegalAccessException e)
+ {
+ Assert.fail();
+ }
+
+ vendorLicenseManagerImpl.deleteEntitlementPool(entitlementPool, USER1);
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+ }
+ }
+
+ /* private static final String USER1 = "epTestUser1";
private static final String USER2 = "epTestUser2";
private static final String EP1_V01_DESC = "EP1 desc";
private static final Version VERSION01 = new Version(0, 1);
@@ -91,7 +440,6 @@ public class EntitlementPoolTest {
entitlementPool.setOperationalScope(
new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther));
entitlementPool.setTime(new ChoiceOrOther<>(timeChoice, timeOther));
- entitlementPool.setManufacturerReferenceNumber(sku);
return entitlementPool;
}
@@ -109,8 +457,6 @@ public class EntitlementPoolTest {
Assert.assertEquals(actual.getAggregationFunction(), expected.getAggregationFunction());
Assert.assertEquals(actual.getOperationalScope(), expected.getOperationalScope());
Assert.assertEquals(actual.getTime(), expected.getTime());
- Assert.assertEquals(actual.getManufacturerReferenceNumber(),
- expected.getManufacturerReferenceNumber());
}
@BeforeClass
@@ -294,6 +640,6 @@ public class EntitlementPoolTest {
Assert.assertEquals(exception.code().id(), UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
}
}
-
-}
*/
+}
+
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/FeatureGroupTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/FeatureGroupTest.java
index e41cfa9532..41c4678b01 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/FeatureGroupTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/FeatureGroupTest.java
@@ -17,44 +17,142 @@
* limitations under the License.
* ============LICENSE_END=========================================================
*/
-/*
+
package org.openecomp.sdc.vendorlicense;
-import org.openecomp.core.util.UniqueValueUtil;
-import org.openecomp.core.utilities.CommonMethods;
-import org.openecomp.sdc.common.errors.CoreException;
-import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.openecomp.sdc.vendorlicense.dao.*;
import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType;
-import org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther;
-import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope;
-import org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit;
import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
-import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory;
+import org.openecomp.sdc.vendorlicense.facade.impl.VendorLicenseFacadeImpl;
import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl;
+import org.openecomp.sdc.versioning.VersioningManager;
import org.openecomp.sdc.versioning.dao.types.Version;
import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
import java.util.HashSet;
-import java.util.List;
import java.util.Set;
-*/
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
/**
* Created by KATYR on 4/10/2016
- *//*
+ */
public class FeatureGroupTest {
+ //JUnit Test Cases using Mockito
+ private static final Version VERSION01 = new Version(0, 1);
+ private final String FG1_NAME = "FG1 name";
+
+ @Mock
+ private VendorLicenseModelDao vendorLicenseModelDao;
+
+ @Mock
+ private LicenseAgreementDao licenseAgreementDao;
+
+ @Mock
+ private FeatureGroupDao featureGroupDao;
+
+ @Mock
+ private EntitlementPoolDao entitlementPoolDao;
+
+ @Mock
+ private LicenseKeyGroupDao licenseKeyGroupDao;
+
+ @Mock
+ private VersioningManager versioningManager;
+
+ @InjectMocks
+ @Spy
+ private VendorLicenseManagerImpl vendorLicenseManagerImpl;
+
+ public FeatureGroupEntity updateFeatureGroup(String vlmId, Version version, String id, String name, String desc,
+ String partNumber, String manufacturerReferenceNumber, Set<String>
+ licenseKeyGroupIds, Set<String> entitlementPoolIds, Set<String>
+ referencingLicenseAgreements){
+ FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlmId, version, id);
+ featureGroup.setVendorLicenseModelId(vlmId);
+ featureGroup.setVersion(version);
+ featureGroup.setId(id);
+ featureGroup.setName(name);
+ featureGroup.setDescription(desc);
+ featureGroup.setPartNumber(partNumber);
+ //featureGroup.setManufacturerReferenceNumber(manufacturerReferenceNumber);
+ featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds);
+ featureGroup.setEntitlementPoolIds(entitlementPoolIds);
+ featureGroup.setReferencingLicenseAgreements(referencingLicenseAgreements);
+
+ return featureGroup;
+ }
+
+ @BeforeMethod
+ public void setUp() throws Exception{
+ MockitoAnnotations.initMocks(this);
+ }
+
+ @Test
+ public void testUpdate(){
+ Set<String> licenseKeyGroupIds;
+ licenseKeyGroupIds = new HashSet<>();
+ licenseKeyGroupIds.add("lkg1");
+
+ Set<String> entitlementPoolIds;
+ entitlementPoolIds = new HashSet<>();
+ entitlementPoolIds.add("ep1");
+
+ Set<String> referencingLicenseAgreements;
+ referencingLicenseAgreements = new HashSet<>();
+ referencingLicenseAgreements.add("la1");
+
+ FeatureGroupEntity featureGroupEntity = updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc",
+ "partNumber", "MRN", licenseKeyGroupIds, entitlementPoolIds,
+ referencingLicenseAgreements);
+
+ doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject());
+
+ /*if(featureGroupEntity.getManufacturerReferenceNumber() != null)
+ featureGroupDao.update(featureGroupEntity);
+ verify(featureGroupDao).update(anyObject());*/
+ }
+
+ @Test
+ public void testUpdateWithoutManufacturingReferenceNumber(){
+ Set<String> licenseKeyGroupIds;
+ licenseKeyGroupIds = new HashSet<>();
+ licenseKeyGroupIds.add("lkg1");
+
+ Set<String> entitlementPoolIds;
+ entitlementPoolIds = new HashSet<>();
+ entitlementPoolIds.add("ep1");
+
+ Set<String> referencingLicenseAgreements;
+ referencingLicenseAgreements = new HashSet<>();
+ referencingLicenseAgreements.add("la1");
+
+ FeatureGroupEntity featureGroupEntity = updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc",
+ "partNumber", null, licenseKeyGroupIds, entitlementPoolIds,
+ referencingLicenseAgreements);
+
+ doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject());
+
+ /*if(featureGroupEntity.getManufacturerReferenceNumber() != null)
+ featureGroupDao.update(featureGroupEntity);
+ verify(featureGroupDao, never()).update(anyObject());*/
+ }
+
+
+}
+
+/*
protected static final Version VERSION01 = new Version(0, 1);
protected static final String USER1 = "FeatureGroupTest_User1";
protected static VendorLicenseManager vendorLicenseManager = new VendorLicenseManagerImpl();
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseKeyGroupTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseKeyGroupTest.java
index a12d9fcecc..782d93a885 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseKeyGroupTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseKeyGroupTest.java
@@ -16,36 +16,177 @@
* See the License for the specific language governing permissions and
* limitations under the License.
* ============LICENSE_END=========================================================
- *//*
+ */
package org.openecomp.sdc.vendorlicense;
-import org.openecomp.core.nosqldb.api.NoSqlDb;
-import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
-import org.openecomp.core.util.UniqueValueUtil;
-import org.openecomp.core.utilities.CommonMethods;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
import org.openecomp.sdc.common.errors.CoreException;
import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao;
-import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDaoFactory;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity;
-import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType;
-import org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther;
-import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope;
+import org.openecomp.sdc.vendorlicense.dao.LimitDao;
+import org.openecomp.sdc.vendorlicense.dao.types.*;
+import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl;
import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
+import org.openecomp.sdc.versioning.types.VersionInfo;
import org.testng.Assert;
-import org.testng.annotations.BeforeClass;
+import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
-import java.util.Collection;
-import java.util.Collections;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
public class LicenseKeyGroupTest {
- public static final String LKG1_NAME = "LKG1 name";
+ //JUnit Test Cases using Mockito
+ private final String USER = "lkgTestUser";
+ private final String LKG_NAME = "LKG name";
+ private final String LT_NAME = "LT name";
+
+ @Mock
+ private VendorLicenseFacade vendorLicenseFacade;
+
+ @Mock
+ private LicenseKeyGroupDao licenseKeyGroupDao;
+ @Mock
+ private LimitDao limitDao;
+
+ @InjectMocks
+ @Spy
+ private VendorLicenseManagerImpl vendorLicenseManagerImpl;
+
+ @BeforeMethod
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+ }
+
+ private LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyType type, Set<OperationalScope> operationalScopeChoices,
+ String operationalScopeOther)
+ {
+ LicenseKeyGroupEntity licenseKeyGroupEntity = new LicenseKeyGroupEntity();
+ licenseKeyGroupEntity.setType(type);
+ licenseKeyGroupEntity.setOperationalScope(
+ new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther));
+ return licenseKeyGroupEntity;
+ }
+
+ @Test
+ public void deleteLicenseKeyGroupTest() {
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+
+ LicenseKeyGroupEntity licenseKeyGroup =
+ createLicenseKeyGroup(LicenseKeyType.Unique, opScopeChoices, null);
+
+ VersionInfo info = new VersionInfo();
+ Version version = new Version();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ LimitEntity limitEntity = LimitTest.createLimitEntity(LT_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Core,AggregationFunction.Average,10,EntitlementTime.Hour);
+
+ ArrayList<LimitEntity> limitEntityList = new ArrayList();
+ limitEntityList.add(limitEntity);
+
+ doReturn(licenseKeyGroup).when(licenseKeyGroupDao).get(anyObject());
+ doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(), anyObject(), anyObject(), anyObject());
+ doReturn(true).when(limitDao).isLimitPresent(anyObject());
+ doReturn(limitEntity).when(limitDao).get(anyObject());
+ try {
+ Field limitField = VendorLicenseManagerImpl.class.getDeclaredField("limitDao");
+ limitField.setAccessible(true);
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(limitField, limitField.getModifiers() & ~Modifier.FINAL);
+ limitField.set(null, limitDao);
+
+ Field lkgField = VendorLicenseManagerImpl.class.getDeclaredField("licenseKeyGroupDao");
+ lkgField.setAccessible(true);
+ modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(lkgField, lkgField.getModifiers() & ~Modifier.FINAL);
+ lkgField.set(null, licenseKeyGroupDao);
+ } catch(NoSuchFieldException | IllegalAccessException e)
+ {
+ Assert.fail();
+ }
+
+ vendorLicenseManagerImpl.deleteLicenseKeyGroup(licenseKeyGroup, USER);
+
+ verify(limitDao).delete(anyObject());
+ }
+
+ @Test
+ public void deleteLicenseKeyGroupInvalidTest() {
+ try {
+ Set<OperationalScope> opScopeChoices;
+ opScopeChoices = new HashSet<>();
+ opScopeChoices.add(OperationalScope.Core);
+ opScopeChoices.add(OperationalScope.CPU);
+ opScopeChoices.add(OperationalScope.Network_Wide);
+
+ LicenseKeyGroupEntity licenseKeyGroup =
+ createLicenseKeyGroup(LicenseKeyType.Unique, opScopeChoices, null);
+
+ VersionInfo info = new VersionInfo();
+ Version version = new Version();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ LimitEntity limitEntity = LimitTest.createLimitEntity(LT_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Core,AggregationFunction.Average,10,EntitlementTime.Hour);
+
+ ArrayList<LimitEntity> limitEntityList = new ArrayList();
+ limitEntityList.add(limitEntity);
+
+ doReturn(licenseKeyGroup).when(licenseKeyGroupDao).get(anyObject());
+ doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(), anyObject(), anyObject(), anyObject());
+ doReturn(false).when(limitDao).isLimitPresent(anyObject());
+
+ try {
+ Field limitField = VendorLicenseManagerImpl.class.getDeclaredField("limitDao");
+ limitField.setAccessible(true);
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(limitField, limitField.getModifiers() & ~Modifier.FINAL);
+ limitField.set(null, limitDao);
+
+ Field lkgField = VendorLicenseManagerImpl.class.getDeclaredField("licenseKeyGroupDao");
+ lkgField.setAccessible(true);
+ modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(lkgField, lkgField.getModifiers() & ~Modifier.FINAL);
+ lkgField.set(null, licenseKeyGroupDao);
+ } catch(NoSuchFieldException | IllegalAccessException e)
+ {
+ Assert.fail();
+ }
+
+ vendorLicenseManagerImpl.deleteLicenseKeyGroup(licenseKeyGroup, USER);
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+ }
+ }
+
+ /*public static final String LKG1_NAME = "LKG1 name";
private static final Version VERSION01 = new Version(0, 1);
private static final String USER1 = "user1";
public static String vlm1Id;
@@ -179,6 +320,5 @@ public class LicenseKeyGroupTest {
public void testCreateWithRemovedName() {
testCreate(vlm1Id, LKG1_NAME);
}
+ */
}
-
-*/
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java
new file mode 100644
index 0000000000..a8d1ed9f65
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java
@@ -0,0 +1,332 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * 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.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.vendorlicense;
+
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.openecomp.sdc.common.errors.CoreException;
+import org.openecomp.sdc.vendorlicense.dao.LimitDao;
+import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction;
+import org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric;
+import org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime;
+import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity;
+import org.openecomp.sdc.vendorlicense.dao.types.LimitType;
+import org.openecomp.sdc.vendorlicense.errors.VendorLicenseErrorCodes;
+import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade;
+import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.sdc.versioning.errors.VersioningErrorCodes;
+import org.openecomp.sdc.versioning.types.VersionInfo;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import static org.mockito.Mockito.when;
+
+public class LimitTest {
+
+ private final String USER1 = "limitTestUser1";
+ private final String LT1_NAME = "LT1 name";
+
+ private static final String VLM_ID = "VLM_ID";
+ private static final Version VERSION = new Version(0, 1);
+ private static final String EPLKG_ID = "ID";
+ private static final String LIMIT1_ID = "limit1";
+ private static final String LIMIT2_ID = "limit2";
+
+ @Mock
+ private VendorLicenseFacade vendorLicenseFacade;
+
+ @Mock
+ private LimitDao limitDao;
+
+ @InjectMocks
+ @Spy
+ private VendorLicenseManagerImpl vendorLicenseManagerImpl;
+
+ public static LimitEntity createLimitEntity(String name, LimitType type, String description,
+ Version version, EntitlementMetric metric,
+ AggregationFunction aggregationFunction, int unit,
+ EntitlementTime time) {
+ LimitEntity limitEntity = new LimitEntity();
+ limitEntity.setName(name);
+ limitEntity.setType(type);
+ limitEntity.setDescription(description);
+ limitEntity.setVersion(version);
+ limitEntity.setMetric(metric);
+ limitEntity.setAggregationFunction(aggregationFunction);
+ limitEntity.setUnit(unit);
+ limitEntity.setTime(time);
+ return limitEntity;
+ }
+
+ @BeforeMethod
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+ try {
+ Field limitField = VendorLicenseManagerImpl.class.getDeclaredField("limitDao");
+ limitField.setAccessible(true);
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(limitField, limitField.getModifiers() & ~Modifier.FINAL);
+ limitField.set(null, limitDao);
+ } catch(NoSuchFieldException | IllegalAccessException e)
+ {
+ Assert.fail();
+ }
+ }
+
+ @Test
+ public void testUpdateLimit() {
+ Version version = new Version();
+ LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Core,AggregationFunction.Average,10,EntitlementTime.Hour);
+ LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Tokens,AggregationFunction.Peak,12,EntitlementTime.Month);
+ VersionInfo info = new VersionInfo();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+ doReturn(true).when(limitDao).isLimitPresent(anyObject());
+ doReturn(limitEntity1).when(limitDao).get(anyObject());
+
+ List<LimitEntity> limitEntityList = new ArrayList<>();
+ limitEntityList.add(limitEntity1);
+ limitEntityList.add(limitEntity2);
+ limitEntity1.setId("1234");
+ limitEntity2.setId("1234");
+ doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(),anyObject(),
+ anyObject(),anyObject());
+
+ vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1);
+
+ verify(vendorLicenseFacade).updateLimit(anyObject(), anyObject());
+ }
+
+ @Test
+ public void testUpdateLimitErrorWithSameNameType() {
+ try {
+ Version version = new Version();
+ LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Core,AggregationFunction.Average,10,EntitlementTime.Hour);
+ LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Tokens,AggregationFunction.Peak,12,EntitlementTime.Month);
+ VersionInfo info = new VersionInfo();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+ doReturn(limitEntity1).when(limitDao).get(anyObject());
+
+ List<LimitEntity> limitEntityList = new ArrayList<>();
+ limitEntityList.add(limitEntity1);
+ limitEntityList.add(limitEntity2);
+ limitEntity1.setId("1234");
+ limitEntity2.setId("9632");
+ doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(),anyObject(),
+ anyObject(),anyObject());
+
+ vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1);
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(),
+ VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+ }
+ }
+
+ @Test
+ public void testDeleteLimit() {
+ Version version = new Version();
+ LimitEntity limitEntity = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Core,AggregationFunction.Average,10,EntitlementTime.Hour);
+ VersionInfo info = new VersionInfo();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+ doReturn(true).when(limitDao).isLimitPresent(anyObject());
+ doReturn(limitEntity).when(limitDao).get(anyObject());
+
+ List<LimitEntity> limitEntityList = new ArrayList<>();
+ limitEntityList.add(limitEntity);
+ limitEntity.setId("1234");
+
+ vendorLicenseManagerImpl.deleteLimit(limitEntity,LT1_NAME);
+
+ verify(vendorLicenseManagerImpl).deleteLimit(anyObject(), anyObject());
+ }
+
+ @Test
+ public void testUpdateLimitErrorWithInvalidId() {
+ try {
+ Version version = new Version();
+ LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Core,AggregationFunction.Average,10,EntitlementTime.Hour);
+ LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version,
+ EntitlementMetric.Tokens,AggregationFunction.Peak,12,EntitlementTime.Month);
+ VersionInfo info = new VersionInfo();
+ info.getViewableVersions().add(version);
+ info.setActiveVersion(version);
+
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+ doReturn(null).when(limitDao).get(anyObject());
+
+ vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1);
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(),
+ VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+ }
+ }
+
+ @Test
+ public void testList() {
+ doReturn(Arrays.asList(
+ createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID),
+ createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT2_ID)))
+ .when(vendorLicenseFacade).listLimits(VLM_ID, VERSION, EPLKG_ID, USER1);
+
+ final Collection<LimitEntity> limits =
+ vendorLicenseManagerImpl.listLimits(VLM_ID, VERSION, EPLKG_ID, USER1);
+ Assert.assertEquals(limits.size(), 2);
+ for (LimitEntity limit : limits) {
+ Assert.assertEquals(limit.getName(),
+ LIMIT1_ID.equals(limit.getId()) ? LIMIT1_ID+" name" : LIMIT2_ID+" name" );
+ }
+ }
+
+ @Test
+ public void testCreateLimit() {
+ LimitEntity expected = createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID);
+ VersionInfo info = new VersionInfo();
+ info.getViewableVersions().add(VERSION);
+ info.setActiveVersion(VERSION);
+
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ vendorLicenseManagerImpl.createLimit(expected, USER1);
+ verify(vendorLicenseFacade).createLimit(expected,USER1);
+ }
+
+ @Test
+ public void testCreateWithDuplicateName() {
+ LimitEntity expected = createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID);
+ expected.setType(LimitType.Vendor);
+
+ LimitEntity expectedDiffName = createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT2_ID);
+ expectedDiffName.setName(LIMIT1_ID + " name");
+ expectedDiffName.setType(LimitType.Vendor);
+
+ List<LimitEntity> vfcImageList = new ArrayList<LimitEntity>();
+ vfcImageList.add(expectedDiffName);
+ doReturn(vfcImageList).when(vendorLicenseFacade).listLimits(anyObject(), anyObject(), anyObject(),
+ anyObject());
+
+ VersionInfo info = new VersionInfo();
+ info.getViewableVersions().add(VERSION);
+ info.setActiveVersion(VERSION);
+
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ try {
+ vendorLicenseManagerImpl.createLimit(expected, USER1);
+ Assert.fail();
+ }
+ catch (CoreException ex) {
+ Assert.assertEquals(ex.code().id(),
+ VendorLicenseErrorCodes.DUPLICATE_LIMIT_NAME_NOT_ALLOWED);
+ }
+ }
+
+ @Test
+ public void testGetNonExistingLimitId_negative() {
+ LimitEntity limit = createLimit(VLM_ID, VERSION, EPLKG_ID, "non existing limit id");
+ VersionInfo info = new VersionInfo();
+ info.getViewableVersions().add(VERSION);
+ info.setActiveVersion(VERSION);
+
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ try {
+ vendorLicenseManagerImpl.getLimit(limit , USER1);
+ Assert.fail();
+ } catch (CoreException exception) {
+ Assert.assertEquals(exception.code().id(), VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND);
+ }
+ }
+
+ @Test
+ public void testGet() {
+ LimitEntity expected = createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID);
+ expected.setType(LimitType.Vendor);
+ expected.setValue(100);
+ expected.setUnit(10);
+ expected.setAggregationFunction(AggregationFunction.Average);
+ expected.setMetric(EntitlementMetric.CPU);
+ expected.setTime(EntitlementTime.Day);
+
+ doReturn(true).when(limitDao).isLimitPresent(anyObject());
+ doReturn(expected).when(limitDao).get(anyObject());
+ VersionInfo info = new VersionInfo();
+ info.getViewableVersions().add(VERSION);
+ info.setActiveVersion(VERSION);
+
+ doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject());
+
+ LimitEntity actual = createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID);
+ vendorLicenseManagerImpl.getLimit(actual, USER1);
+ Assert.assertEquals(actual.getId(), expected.getId());
+ Assert.assertEquals(actual.getName(), expected.getName());
+ Assert.assertEquals(actual.getUnit(), expected.getUnit());
+ Assert.assertEquals(actual.getValue(), expected.getValue());
+ Assert.assertEquals(actual.getAggregationFunction().name(), expected.getAggregationFunction()
+ .name());
+ Assert.assertEquals(actual.getMetric().name(), expected.getMetric().name());
+
+ }
+
+ static LimitEntity createLimit(String vlmId, Version version, String epLkgId, String limitId) {
+ LimitEntity limitEntity = new LimitEntity(vlmId, version, epLkgId, limitId);
+ limitEntity.setName(limitId + " name");
+ limitEntity.setDescription(limitId + " desc");
+ limitEntity.setVersion(version);
+ limitEntity.setMetric(EntitlementMetric.CPU);
+ limitEntity.setAggregationFunction(AggregationFunction.Average);
+ limitEntity.setUnit(10);
+ limitEntity.setTime(EntitlementTime.Day);
+ limitEntity.setValue(100);
+ return limitEntity;
+ }
+}
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java
new file mode 100644
index 0000000000..58db488d86
--- /dev/null
+++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java
@@ -0,0 +1,127 @@
+package org.openecomp.sdc.vendorlicense;
+
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.openecomp.sdc.vendorlicense.dao.*;
+import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
+import org.openecomp.sdc.vendorlicense.facade.impl.VendorLicenseFacadeImpl;
+import org.openecomp.sdc.versioning.VersioningManager;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Created by diveshm on 7/3/2017.
+ */
+public class VendorLicenseFacadeImplTest {
+ //JUnit Test Cases using Mockito
+ private static final Version VERSION01 = new Version(0, 1);
+ private final String FG1_NAME = "FG1 name";
+
+ @Mock
+ private VendorLicenseModelDao vendorLicenseModelDao;
+
+ @Mock
+ private LicenseAgreementDao licenseAgreementDao;
+
+ @Mock
+ private FeatureGroupDao featureGroupDao;
+
+ @Mock
+ private EntitlementPoolDao entitlementPoolDao;
+
+ @Mock
+ private LicenseKeyGroupDao licenseKeyGroupDao;
+
+ @Mock
+ private VersioningManager versioningManager;
+
+ @InjectMocks
+ @Spy
+ private VendorLicenseFacadeImpl vendorLicenseFacadeImpl;
+
+ public FeatureGroupEntity createFeatureGroup(String vlmId, Version version, String id, String name, String desc,
+ String partNumber, String manufacturerReferenceNumber, Set<String>
+ licenseKeyGroupIds, Set<String> entitlementPoolIds, Set<String>
+ referencingLicenseAgreements){
+ FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlmId, version, id);
+ featureGroup.setVendorLicenseModelId(vlmId);
+ featureGroup.setVersion(version);
+ featureGroup.setId(id);
+ featureGroup.setName(name);
+ featureGroup.setDescription(desc);
+ featureGroup.setPartNumber(partNumber);
+ //featureGroup.setManufacturerReferenceNumber(manufacturerReferenceNumber);
+ featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds);
+ featureGroup.setEntitlementPoolIds(entitlementPoolIds);
+ featureGroup.setReferencingLicenseAgreements(referencingLicenseAgreements);
+
+ return featureGroup;
+ }
+
+ @BeforeMethod
+ public void setUp() throws Exception{
+ MockitoAnnotations.initMocks(this);
+ }
+
+ @Test
+ public void testCreate(){
+ Set<String> licenseKeyGroupIds;
+ licenseKeyGroupIds = new HashSet<>();
+ licenseKeyGroupIds.add("lkg1");
+
+ Set<String> entitlementPoolIds;
+ entitlementPoolIds = new HashSet<>();
+ entitlementPoolIds.add("ep1");
+
+ Set<String> referencingLicenseAgreements;
+ referencingLicenseAgreements = new HashSet<>();
+ referencingLicenseAgreements.add("la1");
+
+ FeatureGroupEntity featureGroupEntity = createFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc",
+ "partNumber", "MRN", licenseKeyGroupIds, entitlementPoolIds,
+ referencingLicenseAgreements);
+
+ doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject());
+
+ /*if(featureGroupEntity.getManufacturerReferenceNumber() != null)
+ featureGroupDao.create(featureGroupEntity);
+ verify(featureGroupDao).create(anyObject());*/
+ }
+
+ @Test
+ public void testCreateWithoutManufacturerReferenceNumber(){
+ Set<String> licenseKeyGroupIds;
+ licenseKeyGroupIds = new HashSet<>();
+ licenseKeyGroupIds.add("lkg1");
+
+ Set<String> entitlementPoolIds;
+ entitlementPoolIds = new HashSet<>();
+ entitlementPoolIds.add("ep1");
+
+ Set<String> referencingLicenseAgreements;
+ referencingLicenseAgreements = new HashSet<>();
+ referencingLicenseAgreements.add("la1");
+
+ FeatureGroupEntity featureGroupEntity = createFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc",
+ "partNumber", null, licenseKeyGroupIds, entitlementPoolIds,
+ referencingLicenseAgreements);
+ doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject());
+
+ /*if(featureGroupEntity.getManufacturerReferenceNumber() != null)
+ featureGroupDao.create(featureGroupEntity);
+
+ verify(featureGroupDao, never()).create(anyObject());*/
+
+ }
+}