diff options
Diffstat (limited to 'openecomp-be/backend/openecomp-sdc-vendor-license-manager')
10 files changed, 2428 insertions, 0 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 new file mode 100644 index 0000000000..a8c8e9a9f1 --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/pom.xml @@ -0,0 +1,103 @@ +<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> + + + <parent> + <artifactId>backend</artifactId> + <groupId>org.openecomp.sdc</groupId> + <version>1.0.0-SNAPSHOT</version> + </parent> + + <artifactId>openecomp-sdc-vendor-license-manager</artifactId> + <name>openecomp-sdc-vendor-license-manager</name> + + <dependencies> + <dependency> + <groupId>com.google.code.gson</groupId> + <artifactId>gson</artifactId> + <version>2.3.1</version> + <scope>test</scope> + </dependency> + <dependency> + <groupId>org.yaml</groupId> + <artifactId>snakeyaml</artifactId> + <version>1.14</version> + <scope>test</scope> + </dependency> + <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>RELEASE</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>${project.version}</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> + + <build> + <plugins> + <plugin> + <groupId>org.apache.maven.plugins</groupId> + <artifactId>maven-surefire-plugin</artifactId> + <version>2.19.1</version> + <configuration> + <skipTests>true</skipTests> + </configuration> + </plugin> + </plugins> + </build> +</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 new file mode 100644 index 0000000000..dbe786a44b --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/VendorLicenseManager.java @@ -0,0 +1,115 @@ +/*- + * ============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 org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity; +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.VendorLicenseModelEntity; +import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel; +import org.openecomp.sdc.versioning.dao.types.Version; + +import java.util.Collection; +import java.util.Set; + +public interface VendorLicenseManager { + + void checkout(String vendorLicenseModelId, String user); + + void undoCheckout(String vendorLicenseModelId, String user); + + void checkin(String vendorLicenseModelId, String user); + + void submit(String vendorLicenseModelId, String user); + + Collection<VersionedVendorLicenseModel> listVendorLicenseModels(String versionFilter, + String user); + + VendorLicenseModelEntity createVendorLicenseModel(VendorLicenseModelEntity licenseModel, + String user); + + void updateVendorLicenseModel(VendorLicenseModelEntity licenseModel, String user); + + VersionedVendorLicenseModel getVendorLicenseModel(String vlmId, Version version, String user); + + void deleteVendorLicenseModel(String vlmId, String user); + + + Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version, + String user); + + LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement, + String user); + + void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement, + Set<String> addedFeatureGroupIds, Set<String> removedFeatureGroupIds, + String user); + + LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version, + String licenseAgreementId, String user); + + void deleteLicenseAgreement(String vlmId, String licenseAgreementId, String user); + + + Collection<org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity> listFeatureGroups( + String vlmId, Version version, String user); + + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity createFeatureGroup( + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity fg, String user); + + void updateFeatureGroup(org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup, + Set<String> addedLicenseKeyGroups, Set<String> removedLicenseKeyGroups, + Set<String> addedEntitlementPools, Set<String> removedEntitlementPools, + String user); + + FeatureGroupModel getFeatureGroupModel( + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup, String user); + + void deleteFeatureGroup(org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup, + String user); + + + Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version, + String user); + + EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool, String user); + + void updateEntitlementPool(EntitlementPoolEntity entitlementPool, String user); + + EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool, String user); + + void deleteEntitlementPool(EntitlementPoolEntity entitlementPool, String user); + + + Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version, + String user); + + LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user); + + void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user); + + LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user); + + void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user); + +} 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 new file mode 100644 index 0000000000..b0b088c774 --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/main/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseManagerImpl.java @@ -0,0 +1,558 @@ +/*- + * ============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.impl; + +import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants + .VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE; + +import org.openecomp.core.util.UniqueValueUtil; +import org.openecomp.sdc.vendorlicense.VendorLicenseConstants; +import org.openecomp.sdc.vendorlicense.VendorLicenseManager; +import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao; +import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDaoFactory; +import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao; +import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDaoFactory; +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.VendorLicenseModelDao; +import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDaoFactory; +import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity; +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.VendorLicenseModelEntity; +import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade; +import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory; +import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel; +import org.openecomp.sdc.versioning.VersioningManager; +import org.openecomp.sdc.versioning.VersioningUtil; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.sdc.versioning.dao.types.VersionStatus; +import org.openecomp.sdc.versioning.types.VersionInfo; +import org.openecomp.sdc.versioning.types.VersionableEntityAction; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class VendorLicenseManagerImpl implements VendorLicenseManager { + + private static final VersioningManager versioningManager = + org.openecomp.sdc.versioning.VersioningManagerFactory.getInstance().createInterface(); + private static final VendorLicenseFacade vendorLicenseFacade = + VendorLicenseFacadeFactory.getInstance().createInterface(); + + private static final VendorLicenseModelDao + vendorLicenseModelDao = VendorLicenseModelDaoFactory.getInstance().createInterface(); + private static final org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao + licenseAgreementDao = LicenseAgreementDaoFactory.getInstance().createInterface(); + private static final FeatureGroupDao featureGroupDao = + FeatureGroupDaoFactory.getInstance().createInterface(); + private static final EntitlementPoolDao + entitlementPoolDao = EntitlementPoolDaoFactory.getInstance().createInterface(); + private static final LicenseKeyGroupDao + licenseKeyGroupDao = LicenseKeyGroupDaoFactory.getInstance().createInterface(); + + private static void sortVlmListByModificationTimeDescOrder( + List<VersionedVendorLicenseModel> vendorLicenseModels) { + Collections.sort(vendorLicenseModels, new Comparator<VersionedVendorLicenseModel>() { + @Override + public int compare(VersionedVendorLicenseModel o1, VersionedVendorLicenseModel o2) { + return o2.getVendorLicenseModel().getWritetimeMicroSeconds() + .compareTo(o1.getVendorLicenseModel().getWritetimeMicroSeconds()); + } + }); + } + + @Override + public void checkout(String vendorLicenseModelId, String user) { + Version newVersion = versioningManager + .checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vendorLicenseModelId, user); + vendorLicenseFacade.updateVlmLastModificationTime(vendorLicenseModelId, newVersion); + } + + @Override + public void undoCheckout(String vendorLicenseModelId, String user) { + Version newVersion = versioningManager + .undoCheckout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vendorLicenseModelId, user); + vendorLicenseFacade.updateVlmLastModificationTime(vendorLicenseModelId, newVersion); + } + + @Override + public void checkin(String vendorLicenseModelId, String user) { + vendorLicenseFacade.checkin(vendorLicenseModelId, user); + } + + @Override + public void submit(String vendorLicenseModelId, String user) { + vendorLicenseFacade.submit(vendorLicenseModelId, user); + } + + @Override + public Collection<VersionedVendorLicenseModel> listVendorLicenseModels(String versionFilter, + String user) { + Map<String, VersionInfo> idToVersionsInfo = versioningManager + .listEntitiesVersionInfo(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, user, + VersionableEntityAction.Read); + + List<VersionedVendorLicenseModel> vendorLicenseModels = new ArrayList<>(); + for (Map.Entry<String, VersionInfo> entry : idToVersionsInfo.entrySet()) { + VersionInfo versionInfo = entry.getValue(); + if (versionFilter != null && versionFilter.equals(VersionStatus.Final.name())) { + if (versionInfo.getLatestFinalVersion() == null) { + continue; + } + versionInfo.setActiveVersion(versionInfo.getLatestFinalVersion()); + versionInfo.setStatus(VersionStatus.Final); + versionInfo.setLockingUser(null); + } + + VendorLicenseModelEntity + vlm = vendorLicenseModelDao + .get(new VendorLicenseModelEntity(entry.getKey(), versionInfo.getActiveVersion())); + if (vlm != null) { + VersionedVendorLicenseModel versionedVlm = new VersionedVendorLicenseModel(); + versionedVlm.setVendorLicenseModel(vlm); + versionedVlm.setVersionInfo(versionInfo); + vendorLicenseModels.add(versionedVlm); + } + } + + sortVlmListByModificationTimeDescOrder(vendorLicenseModels); + + return vendorLicenseModels; + } + + @Override + public VendorLicenseModelEntity createVendorLicenseModel( + VendorLicenseModelEntity vendorLicenseModelEntity, String user) { + return vendorLicenseFacade.createVendorLicenseModel(vendorLicenseModelEntity, user); + } + + @Override + public void updateVendorLicenseModel(VendorLicenseModelEntity vendorLicenseModelEntity, + String user) { + Version activeVersion = + getVersionInfo(vendorLicenseModelEntity.getId(), VersionableEntityAction.Write, user) + .getActiveVersion(); + vendorLicenseModelEntity.setVersion(activeVersion); + + String existingVendorName = vendorLicenseModelDao.get(vendorLicenseModelEntity).getVendorName(); + UniqueValueUtil + .updateUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, existingVendorName, + vendorLicenseModelEntity.getVendorName()); + vendorLicenseModelDao.update(vendorLicenseModelEntity); + + vendorLicenseFacade + .updateVlmLastModificationTime(vendorLicenseModelEntity.getId(), activeVersion); + } + + @Override + public VersionedVendorLicenseModel getVendorLicenseModel(String vlmId, Version version, + String user) { + return vendorLicenseFacade.getVendorLicenseModel(vlmId, version, user); + } + + @Override + public void deleteVendorLicenseModel(String vlmId, String user) { + throw new UnsupportedOperationException("Unsupported operation for 1607 release."); + + /* Version activeVersion = getVersionInfo(vlmId, VersionableEntityAction.Write, user) + .getActiveVersion(); + + vendorLicenseModelDao.delete(new VendorLicenseModelEntity(vlmId, activeVersion)); + licenseAgreementDao.deleteAll(new LicenseAgreementEntity(vlmId, activeVersion, null)); + featureGroupDao.deleteAll(new FeatureGroupEntity(vlmId, activeVersion, null)); + licenseKeyGroupDao.deleteAll(new LicenseKeyGroupEntity(vlmId, activeVersion, null)); + entitlementPoolDao.deleteAll(new EntitlementPoolEntity(vlmId, activeVersion, null));*/ + } + + @Override + public Collection<LicenseAgreementEntity> listLicenseAgreements(String vlmId, Version version, + String user) { + return licenseAgreementDao.list(new LicenseAgreementEntity(vlmId, VersioningUtil + .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Read, user)), null)); + } + + @Override + public LicenseAgreementEntity createLicenseAgreement(LicenseAgreementEntity licenseAgreement, + String user) { + return vendorLicenseFacade.createLicenseAgreement(licenseAgreement, user); + } + + @Override + public void updateLicenseAgreement(LicenseAgreementEntity licenseAgreement, + Set<String> addedFeatureGroupIds, + Set<String> removedFeatureGroupIds, String user) { + Version activeVersion = + getVersionInfo(licenseAgreement.getVendorLicenseModelId(), VersionableEntityAction.Write, + user).getActiveVersion(); + licenseAgreement.setVersion(activeVersion); + LicenseAgreementEntity retrieved = licenseAgreementDao.get(licenseAgreement); + VersioningUtil + .validateEntityExistence(retrieved, licenseAgreement, VendorLicenseModelEntity.ENTITY_TYPE); + VersioningUtil.validateContainedEntitiesExistence( + new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity().getEntityType(), + removedFeatureGroupIds, retrieved, retrieved.getFeatureGroupIds()); + VersioningUtil.validateEntitiesExistence(addedFeatureGroupIds, + new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity( + licenseAgreement.getVendorLicenseModelId(), activeVersion, null), + featureGroupDao, VendorLicenseModelEntity.ENTITY_TYPE); + + UniqueValueUtil.updateUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME, + retrieved.getName(), licenseAgreement.getName(), licenseAgreement.getVendorLicenseModelId(), + licenseAgreement.getVersion().toString()); + licenseAgreementDao.updateColumnsAndDeltaFeatureGroupIds(licenseAgreement, addedFeatureGroupIds, + removedFeatureGroupIds); + + addFeatureGroupsToLicenseAgreementRef(addedFeatureGroupIds, licenseAgreement); + removeFeatureGroupsToLicenseAgreementRef(removedFeatureGroupIds, licenseAgreement); + + vendorLicenseFacade + .updateVlmLastModificationTime(licenseAgreement.getVendorLicenseModelId(), activeVersion); + } + + @Override + public LicenseAgreementModel getLicenseAgreementModel(String vlmId, Version version, + String licenseAgreementId, String user) { + return vendorLicenseFacade.getLicenseAgreementModel(vlmId, version, licenseAgreementId, user); + } + + @Override + public void deleteLicenseAgreement(String vlmId, String licenseAgreementId, String user) { + Version activeVersion = + getVersionInfo(vlmId, VersionableEntityAction.Write, user).getActiveVersion(); + LicenseAgreementEntity input = + new LicenseAgreementEntity(vlmId, activeVersion, licenseAgreementId); + LicenseAgreementEntity retrieved = licenseAgreementDao.get(input); + VersioningUtil.validateEntityExistence(retrieved, input, VendorLicenseModelEntity.ENTITY_TYPE); + + removeFeatureGroupsToLicenseAgreementRef(retrieved.getFeatureGroupIds(), retrieved); + + licenseAgreementDao.delete(input); + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_AGREEMENT_NAME, + retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(), + retrieved.getName()); + + vendorLicenseFacade + .updateVlmLastModificationTime(input.getVendorLicenseModelId(), input.getVersion()); + } + + @Override + public Collection<org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity> listFeatureGroups( + String vlmId, Version version, + String user) { + return featureGroupDao + .list(new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity(vlmId, VersioningUtil + .resolveVersion(version, getVersionInfo(vlmId, VersionableEntityAction.Read, user)), + null)); + } + + @Override + public org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity createFeatureGroup( + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup, String user) { + return vendorLicenseFacade.createFeatureGroup(featureGroup, user); + } + + @Override + public void updateFeatureGroup( + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup, + Set<String> addedLicenseKeyGroups, + Set<String> removedLicenseKeyGroups, + Set<String> addedEntitlementPools, + Set<String> removedEntitlementPools, + String user) { + Version activeVersion = + getVersionInfo(featureGroup.getVendorLicenseModelId(), VersionableEntityAction.Write, user) + .getActiveVersion(); + featureGroup.setVersion(activeVersion); + + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity retrieved = + featureGroupDao.get(featureGroup); + VersioningUtil + .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE); + + VersioningUtil.validateContainedEntitiesExistence(new LicenseKeyGroupEntity().getEntityType(), + removedLicenseKeyGroups, retrieved, retrieved.getLicenseKeyGroupIds()); + VersioningUtil.validateContainedEntitiesExistence(new EntitlementPoolEntity().getEntityType(), + removedEntitlementPools, retrieved, retrieved.getEntitlementPoolIds()); + + VersioningUtil.validateEntitiesExistence(addedLicenseKeyGroups, + new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), activeVersion, null), + licenseKeyGroupDao, VendorLicenseModelEntity.ENTITY_TYPE); + VersioningUtil.validateEntitiesExistence(addedEntitlementPools, + new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), activeVersion, null), + entitlementPoolDao, VendorLicenseModelEntity.ENTITY_TYPE); + UniqueValueUtil.updateUniqueValue(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME, + retrieved.getName(), featureGroup.getName(), featureGroup.getVendorLicenseModelId(), + featureGroup.getVersion().toString()); + + addLicenseKeyGroupsToFeatureGroupsRef(addedLicenseKeyGroups, featureGroup); + removeLicenseKeyGroupsToFeatureGroupsRef(removedLicenseKeyGroups, featureGroup); + addEntitlementPoolsToFeatureGroupsRef(addedEntitlementPools, featureGroup); + removeEntitlementPoolsToFeatureGroupsRef(removedEntitlementPools, featureGroup); + + featureGroupDao.updateFeatureGroup(featureGroup, addedEntitlementPools, removedEntitlementPools, + addedLicenseKeyGroups, removedLicenseKeyGroups); + + vendorLicenseFacade + .updateVlmLastModificationTime(featureGroup.getVendorLicenseModelId(), activeVersion); + } + + @Override + public FeatureGroupModel getFeatureGroupModel( + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup, String user) { + return vendorLicenseFacade.getFeatureGroupModel(featureGroup, user); + } + + @Override + public void deleteFeatureGroup( + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup, String user) { + Version activeVersion = + getVersionInfo(featureGroup.getVendorLicenseModelId(), VersionableEntityAction.Write, user) + .getActiveVersion(); + featureGroup.setVersion(activeVersion); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity retrieved = + featureGroupDao.get(featureGroup); + VersioningUtil + .validateEntityExistence(retrieved, featureGroup, VendorLicenseModelEntity.ENTITY_TYPE); + + removeLicenseKeyGroupsToFeatureGroupsRef(retrieved.getLicenseKeyGroupIds(), featureGroup); + removeEntitlementPoolsToFeatureGroupsRef(retrieved.getEntitlementPoolIds(), featureGroup); + + for (String licenceAgreementId : retrieved.getReferencingLicenseAgreements()) { + licenseAgreementDao.removeFeatureGroup( + new LicenseAgreementEntity(featureGroup.getVendorLicenseModelId(), activeVersion, + licenceAgreementId), featureGroup.getId()); + } + + featureGroupDao.delete(featureGroup); + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.FEATURE_GROUP_NAME, + retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(), + retrieved.getName()); + + vendorLicenseFacade.updateVlmLastModificationTime(featureGroup.getVendorLicenseModelId(), + featureGroup.getVersion()); + } + + @Override + public Collection<EntitlementPoolEntity> listEntitlementPools(String vlmId, Version version, + String user) { + return vendorLicenseFacade.listEntitlementPools(vlmId, version, user); + } + + @Override + public EntitlementPoolEntity createEntitlementPool(EntitlementPoolEntity entitlementPool, + String user) { + return vendorLicenseFacade.createEntitlementPool(entitlementPool, user); + } + + @Override + public void updateEntitlementPool(EntitlementPoolEntity entitlementPool, String user) { + Version activeVersion = + getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write, + user).getActiveVersion(); + vendorLicenseFacade + .updateVlmLastModificationTime(entitlementPool.getVendorLicenseModelId(), activeVersion); + vendorLicenseFacade.updateEntitlementPool(entitlementPool, user); + } + + @Override + public EntitlementPoolEntity getEntitlementPool(EntitlementPoolEntity entitlementPool, + String user) { + entitlementPool.setVersion(VersioningUtil.resolveVersion(entitlementPool.getVersion(), + getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Read, + user))); + + EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool); + VersioningUtil + .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE); + return retrieved; + } + + @Override + public void deleteEntitlementPool(EntitlementPoolEntity entitlementPool, String user) { + Version activeVersion = + getVersionInfo(entitlementPool.getVendorLicenseModelId(), VersionableEntityAction.Write, + user).getActiveVersion(); + entitlementPool.setVersion(activeVersion); + + EntitlementPoolEntity retrieved = entitlementPoolDao.get(entitlementPool); + VersioningUtil + .validateEntityExistence(retrieved, entitlementPool, VendorLicenseModelEntity.ENTITY_TYPE); + + for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) { + featureGroupDao.removeEntitlementPool( + new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity( + entitlementPool.getVendorLicenseModelId(), activeVersion, + referencingFeatureGroupId), entitlementPool.getId()); + } + + entitlementPoolDao.delete(entitlementPool); + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.ENTITLEMENT_POOL_NAME, + retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(), + retrieved.getName()); + + vendorLicenseFacade.updateVlmLastModificationTime(entitlementPool.getVendorLicenseModelId(), + entitlementPool.getVersion()); + } + + @Override + public Collection<LicenseKeyGroupEntity> listLicenseKeyGroups(String vlmId, Version version, + String user) { + return vendorLicenseFacade.listLicenseKeyGroups(vlmId, version, user); + } + + @Override + public LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, + String user) { + return vendorLicenseFacade.createLicenseKeyGroup(licenseKeyGroup, user); + } + + @Override + public void updateLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user) { + Version activeVersion = + getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Write, + user).getActiveVersion(); + vendorLicenseFacade + .updateVlmLastModificationTime(licenseKeyGroup.getVendorLicenseModelId(), activeVersion); + + vendorLicenseFacade.updateLicenseKeyGroup(licenseKeyGroup, user); + } + + @Override + public LicenseKeyGroupEntity getLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, + String user) { + licenseKeyGroup.setVersion(VersioningUtil.resolveVersion(licenseKeyGroup.getVersion(), + getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Read, + user))); + + LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup); + VersioningUtil + .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE); + return retrieved; + } + + @Override + public void deleteLicenseKeyGroup(LicenseKeyGroupEntity licenseKeyGroup, String user) { + Version activeVersion = + getVersionInfo(licenseKeyGroup.getVendorLicenseModelId(), VersionableEntityAction.Write, + user).getActiveVersion(); + licenseKeyGroup.setVersion(activeVersion); + + LicenseKeyGroupEntity retrieved = licenseKeyGroupDao.get(licenseKeyGroup); + VersioningUtil + .validateEntityExistence(retrieved, licenseKeyGroup, VendorLicenseModelEntity.ENTITY_TYPE); + + licenseKeyGroupDao.delete(licenseKeyGroup); + for (String referencingFeatureGroupId : retrieved.getReferencingFeatureGroups()) { + featureGroupDao.removeLicenseKeyGroup( + new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity( + licenseKeyGroup.getVendorLicenseModelId(), activeVersion, + referencingFeatureGroupId), licenseKeyGroup.getId()); + } + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.LICENSE_KEY_GROUP_NAME, + retrieved.getVendorLicenseModelId(), retrieved.getVersion().toString(), + retrieved.getName()); + + vendorLicenseFacade.updateVlmLastModificationTime(licenseKeyGroup.getVendorLicenseModelId(), + licenseKeyGroup.getVersion()); + } + + private void addFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds, + LicenseAgreementEntity licenseAgreement) { + if (featureGroupIds != null) { + for (String featureGroupId : featureGroupIds) { + featureGroupDao.addReferencingLicenseAgreement( + new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity( + licenseAgreement.getVendorLicenseModelId(), + licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId()); + } + } + } + + private void removeFeatureGroupsToLicenseAgreementRef(Set<String> featureGroupIds, + LicenseAgreementEntity licenseAgreement) { + if (featureGroupIds != null) { + for (String featureGroupId : featureGroupIds) { + featureGroupDao.removeReferencingLicenseAgreement( + new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity( + licenseAgreement.getVendorLicenseModelId(), + licenseAgreement.getVersion(), featureGroupId), licenseAgreement.getId()); + } + } + } + + private void addLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds, + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup) { + if (licenseKeyGroupIds != null) { + for (String licenseKeyGroupId : licenseKeyGroupIds) { + licenseKeyGroupDao.addReferencingFeatureGroup( + new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), + featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId()); + } + } + } + + private void removeLicenseKeyGroupsToFeatureGroupsRef(Set<String> licenseKeyGroupIds, + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup) { + if (licenseKeyGroupIds != null) { + for (String licenseKeyGroupId : licenseKeyGroupIds) { + licenseKeyGroupDao.removeReferencingFeatureGroup( + new LicenseKeyGroupEntity(featureGroup.getVendorLicenseModelId(), + featureGroup.getVersion(), licenseKeyGroupId), featureGroup.getId()); + } + } + } + + private void addEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds, + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup) { + if (entitlementPoolIds != null) { + for (String entitlementPoolId : entitlementPoolIds) { + entitlementPoolDao.addReferencingFeatureGroup( + new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), + featureGroup.getVersion(), entitlementPoolId), featureGroup.getId()); + } + } + } + + private void removeEntitlementPoolsToFeatureGroupsRef(Set<String> entitlementPoolIds, + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroup) { + if (entitlementPoolIds != null) { + for (String entitlementPoolId : entitlementPoolIds) { + entitlementPoolDao.removeReferencingFeatureGroup( + new EntitlementPoolEntity(featureGroup.getVendorLicenseModelId(), + featureGroup.getVersion(), entitlementPoolId), featureGroup.getId()); + } + } + } + + private VersionInfo getVersionInfo(String vendorLicenseModelId, VersionableEntityAction action, + String user) { + return vendorLicenseFacade.getVersionInfo(vendorLicenseModelId, action, user); + } +} 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 new file mode 100644 index 0000000000..60fe06a23e --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java @@ -0,0 +1,252 @@ +package org.openecomp.sdc.vendorlicense; + +import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade; +import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory; +import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl; +import org.openecomp.sdc.vendorlicense.licenseartifacts.VendorLicenseArtifactsService; +import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductManager; +import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails; +import org.openecomp.sdc.vendorsoftwareproduct.impl.VendorSoftwareProductManagerImpl; +import org.openecomp.sdc.versioning.VersioningManager; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.sdc.versioning.types.VersionInfo; +import org.openecomp.sdc.versioning.types.VersionableEntityAction; +import org.openecomp.core.utilities.CommonMethods; +import org.testng.annotations.BeforeMethod; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE; + +public class ArtifactTestUtils { + + protected static final Version VERSION01 = new Version(0, 1); + protected static final String USER1 = "baseTest_TestUser1"; + protected static VendorLicenseManager vendorLicenseManager = new VendorLicenseManagerImpl(); + protected static VendorSoftwareProductManager vendorSoftwareProductManager = new VendorSoftwareProductManagerImpl(); + protected static VendorLicenseFacade vendorLicenseFacade = VendorLicenseFacadeFactory.getInstance().createInterface(); + private static final VersioningManager versioningManager = org.openecomp.sdc.versioning.VersioningManagerFactory + .getInstance().createInterface(); + protected static VendorLicenseArtifactsService vendorLicenseArtifactsService = VendorLicenseArtifactServiceFactory + .getInstance().createInterface(); + + protected static Version currVersion; + + protected String vlm1Id; + protected String vlm2Id; + + protected String ep11Id; + protected String ep12Id; + protected String lkg11Id; + protected String lkg12Id; + protected String lkg13Id; + protected String fg11Id; + protected String fg12Id; + protected String la11Id; + + protected String ep21Id; + protected String ep22Id; + protected String lkg21Id; + protected String lkg22Id; + protected String fg21Id; + protected String fg22Id; + protected String la21Id; + protected String la22Id; + + protected org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity fg11; + protected org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity fg12; + protected org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity ep11; + protected org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity ep12; + protected org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity lkg11; + protected org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity lkg12; + protected org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity lkg13; + + protected org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity fg21; + protected org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity fg22; + protected org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity ep21; + protected org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity ep22; + protected org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity lkg21; + protected org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity lkg22; + + protected VspDetails vspDetails; + protected VspDetails vsp2; + + + @BeforeMethod + public void setUp() { + vlm1Id = vendorLicenseFacade.createVendorLicenseModel(VendorLicenseModelTest.createVendorLicenseModel("vlm1 name" + CommonMethods.nextUuId(), "vlm1Id desc", "icon1"), USER1).getId(); + vlm2Id = vendorLicenseFacade.createVendorLicenseModel(VendorLicenseModelTest.createVendorLicenseModel("vlm2 name" + CommonMethods.nextUuId(), "vlm2Id desc", "icon2"), USER1).getId(); + + + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Other); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Network_Wide); + + ep11 = EntitlementPoolTest.createEntitlementPool(vlm1Id, VERSION01, "EP1_" + CommonMethods.nextUuId(), "EP1 dec", 80, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Absolute, org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric.Core, null, "inc1", org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction.Other, "agg func1", opScopeChoices, null, org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime.Hour, null, "sku1"); + ep11Id = vendorLicenseManager.createEntitlementPool(ep11, USER1).getId(); + ep12 = EntitlementPoolTest.createEntitlementPool(vlm1Id, VERSION01, "EP2_" + CommonMethods.nextUuId(), "EP2 dec", 70, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Absolute, org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric.Other, "e metric2", "inc2", org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction.Average, null, opScopeChoices, "op scope2", org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime.Other, "time2", "sku2"); + ep12Id = vendorLicenseManager.createEntitlementPool(ep12, USER1).getId(); + + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoicesLKG = new HashSet<>(); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.CPU); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.VM); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Availability_Zone); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + + lkg11 = LicenseKeyGroupTest.createLicenseKeyGroup(vlm1Id, VERSION01, "LKG1", "LKG1 dec", org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType.One_Time, new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(opScopeChoicesLKG, null)); + lkg11Id = vendorLicenseManager.createLicenseKeyGroup(lkg11, USER1).getId(); + lkg11.setId(lkg11Id); + + lkg12 = LicenseKeyGroupTest.createLicenseKeyGroup(vlm1Id, VERSION01, "LKG2", "LKG2 dec", org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType.Unique, new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(opScopeChoicesLKG, null)); + lkg12Id = vendorLicenseManager.createLicenseKeyGroup(lkg12, USER1).getId(); + lkg12.setId(lkg11Id); + + lkg13 = LicenseKeyGroupTest.createLicenseKeyGroup(vlm1Id, VERSION01, "LKG3", "LKG3 dec", org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType.Universal, new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(opScopeChoicesLKG, null)); + lkg13Id = vendorLicenseManager.createLicenseKeyGroup(lkg13, USER1).getId(); + lkg13.setId(lkg13Id); + + fg11 = LicenseAgreementTest.createFeatureGroup(vlm1Id, VERSION01, "fg11", "FG1", "FG1 desc", CommonMethods.toSingleElementSet(ep11Id), CommonMethods.toSingleElementSet(lkg11Id)); + fg11Id = vendorLicenseManager.createFeatureGroup(fg11, USER1).getId(); + + fg12 = LicenseAgreementTest.createFeatureGroup(vlm1Id, VERSION01, "fg2", "FG2", "FG2 desc", CommonMethods.toSingleElementSet(ep12Id), CommonMethods.toSingleElementSet(lkg12Id)); + fg12Id = vendorLicenseManager.createFeatureGroup(fg12, USER1).getId(); + + + String requirementsAndConstrains1 = "Requirements And Constraints1"; + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity + la1 = LicenseAgreementTest.createLicenseAgreement(vlm1Id, VERSION01, null, "LA1", "LA1 desc", requirementsAndConstrains1, new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>( + org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm.Unlimited, null), fg11Id); + la11Id = vendorLicenseManager.createLicenseAgreement(la1, USER1).getId(); + + List<String> fgs = new ArrayList<>(); + fgs.add(fg11Id); + createTwoFinalVersionsForVLM(vlm1Id); + VersionInfo versionInfo = vendorLicenseFacade.getVersionInfo(vlm1Id, VersionableEntityAction.Read, ""); + vspDetails = createVspDetails(null, null, "VSP1_" + CommonMethods.nextUuId(), "Test-vsp", "vendorName", vlm1Id, "icon", "category", "subCategory", la11Id, fgs); + + List<Version> finalVersions = versionInfo.getFinalVersions(); + Version finalVersion = finalVersions.get(1); + + vspDetails.setVlmVersion(finalVersion); + + vspDetails = vendorSoftwareProductManager.createNewVsp(vspDetails, USER1); + + } + + private void createTwoFinalVersionsForVLM(String vlm1Id) { + versioningManager.checkin(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1Id, USER1, "desc1"); + versioningManager.checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1Id, USER1); + versioningManager.checkin(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1Id, USER1, "desc1"); + vendorLicenseFacade.submit(vlm1Id, USER1); + versioningManager.checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1Id, USER1); + versioningManager.checkin(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1Id, USER1, "desc2"); + vendorLicenseFacade.submit(vlm1Id, USER1); + + } + + protected void createThirdFinalVersionForVLMChangeEpLKGInSome(String vlm1Id, org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity ep, org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity lkg) { + versioningManager.checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1Id, USER1); + vendorLicenseManager.updateEntitlementPool(ep, USER1); + vendorLicenseManager.updateLicenseKeyGroup(lkg, USER1); + versioningManager.checkin(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1Id, USER1, "desc1"); + vendorLicenseFacade.submit(vlm1Id, USER1); + + } + + + protected void setVlm2FirstVersion() { + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Other); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Network_Wide); + + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoicesLKG = new HashSet<>(); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.CPU); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.VM); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Availability_Zone); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + + ep21 = EntitlementPoolTest.createEntitlementPool(vlm2Id, VERSION01, "EP21", "EP21 dec", 80, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Absolute, org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric.Core, null, "inc21", org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction.Other, "agg func21", opScopeChoices, null, org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime.Hour, null, "sku21"); + ep21Id = vendorLicenseManager.createEntitlementPool(ep21, USER1).getId(); + + lkg21 = LicenseKeyGroupTest.createLicenseKeyGroup(vlm2Id, VERSION01, "LKG21", "LKG21 dec", org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType.One_Time, new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(opScopeChoicesLKG, null)); + lkg21Id = vendorLicenseManager.createLicenseKeyGroup(lkg21, USER1).getId(); + lkg21.setId(lkg21Id); + + fg21 = LicenseAgreementTest.createFeatureGroup(vlm2Id, VERSION01, "fg21", "FG21", "FG21 desc", CommonMethods.toSingleElementSet(ep21Id), CommonMethods.toSingleElementSet(lkg21Id)); + fg21Id = vendorLicenseManager.createFeatureGroup(fg21, USER1).getId(); + + String requirementsAndConstrains1 = "Requirements And Constraints21"; + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity + la2 = LicenseAgreementTest.createLicenseAgreement(vlm2Id, VERSION01, null, "LA21", "LA21 desc", requirementsAndConstrains1, new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>( + org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm.Unlimited, null), fg21Id); + la21Id = vendorLicenseManager.createLicenseAgreement(la2, USER1).getId(); + +// setValuesForVlm(VERSION01, ep21, ep21Id, lkg21, lkg21Id, fg21, fg21Id, la21Id, 1); + + vendorLicenseManager.checkin(vlm2Id, USER1); + currVersion = versioningManager.submit(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm2Id, USER1, null); + + List<String> fgs = new ArrayList<>(); + fgs.add(fg21Id); + vsp2 = createVspDetails(null, null, "VSP2_" + CommonMethods.nextUuId(), "Test-vsp", "vendorName", vlm2Id, "icon", "category", "subCategory", la21Id, fgs); + vsp2 = vendorSoftwareProductManager.createNewVsp(vsp2, USER1); + } + + protected void setVlm2SecondVersion() { + vendorLicenseManager.checkout(vlm2Id, USER1); + + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Other); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Network_Wide); + + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoicesLKG = new HashSet<>(); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.CPU); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.VM); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Availability_Zone); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + + ep22 = EntitlementPoolTest.createEntitlementPool(vlm2Id, currVersion, "EP22", "EP22 dec", 80, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Absolute, org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric.Core, null, "inc22", org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction.Other, "agg func22", opScopeChoices, null, org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime.Hour, null, "sku22"); + ep22Id = vendorLicenseManager.createEntitlementPool(ep22, USER1).getId(); + + lkg22 = LicenseKeyGroupTest.createLicenseKeyGroup(vlm2Id, currVersion, "LKG22", "LKG22 dec", org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType.One_Time, new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(opScopeChoicesLKG, null)); + lkg22Id = vendorLicenseManager.createLicenseKeyGroup(lkg22, USER1).getId(); + lkg22.setId(lkg22Id); + + fg22 = LicenseAgreementTest.createFeatureGroup(vlm2Id, currVersion, "fg22", "FG22", "FG22 desc", CommonMethods.toSingleElementSet(ep22Id), CommonMethods.toSingleElementSet(lkg22Id)); + fg22Id = vendorLicenseManager.createFeatureGroup(fg22, USER1).getId(); + + String requirementsAndConstrains1 = "Requirements And Constraints22"; + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity + la2 = LicenseAgreementTest.createLicenseAgreement(vlm2Id, currVersion, null, "LA22", "LA22 desc", requirementsAndConstrains1, new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>( + org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm.Unlimited, null), fg22Id); + la22Id = vendorLicenseManager.createLicenseAgreement(la2, USER1).getId(); + +// setValuesForVlm(currVersion, ep22, ep22Id, lkg22, lkg22Id, fg22, fg22Id, la22Id, 2); + + vendorLicenseManager.checkin(vlm2Id, USER1); + currVersion = versioningManager.submit(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm2Id, USER1, null); + } + + 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) { + VspDetails vspDetails = new VspDetails(id, version); + vspDetails.setName(name); + vspDetails.setDescription(desc); + vspDetails.setIcon(icon); + vspDetails.setCategory(category); + vspDetails.setSubCategory(subCategory); + vspDetails.setVendorName(vendorName); + vspDetails.setVendorId(vlm); + vspDetails.setLicenseAgreement(licenseAgreement); + vspDetails.setFeatureGroups(featureGroups); + return vspDetails; + } + + +} + 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 new file mode 100644 index 0000000000..0c05fee10d --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/EntitlementPoolTest.java @@ -0,0 +1,275 @@ +package org.openecomp.sdc.vendorlicense; + +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.impl.VendorLicenseManagerImpl; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.sdc.versioning.errors.VersioningErrorCodes; +import org.openecomp.core.util.UniqueValueUtil; +import org.openecomp.core.utilities.CommonMethods; + +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.openecomp.sdc.vendorlicense.dao.types.OperationalScope; +import org.testng.Assert; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +public class EntitlementPoolTest { + + 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); + private static final Version VERSION03 = new Version(0, 3); + private static final String EP1_NAME = "EP1 name"; + private static final String EP2_NAME = "EP2 name"; + + private static VendorLicenseManager vendorLicenseManager = new VendorLicenseManagerImpl(); + private static EntitlementPoolDao entitlementPoolDao; + + private static String vlm1Id; + private static String vlm2Id; + private static String ep1Id; + private static String ep2Id; + + public static EntitlementPoolEntity createEntitlementPool(String vlmId, Version version, + String name, String desc, int threshold, + org.openecomp.sdc.vendorlicense.dao.types.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 org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>(entitlementMetricChoice, entitlementMetricOther)); + entitlementPool.setIncrements(increments); + entitlementPool.setAggregationFunction( + new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>(aggregationFunctionChoice, aggregationFunctionOther)); + entitlementPool.setOperationalScope( + new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther)); + entitlementPool.setTime(new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>(timeChoice, timeOther)); + entitlementPool.setManufacturerReferenceNumber(sku); + return entitlementPool; + } + + private static void assertEntitlementPoolsEquals(EntitlementPoolEntity actual, + EntitlementPoolEntity expected) { + Assert.assertEquals(actual.getVendorLicenseModelId(), expected.getVendorLicenseModelId()); + Assert.assertEquals(actual.getVersion(), expected.getVersion()); + Assert.assertEquals(actual.getId(), expected.getId()); + Assert.assertEquals(actual.getName(), expected.getName()); + Assert.assertEquals(actual.getDescription(), expected.getDescription()); + Assert.assertEquals(actual.getThresholdValue(), expected.getThresholdValue()); + Assert.assertEquals(actual.getThresholdUnit(), expected.getThresholdUnit()); + Assert.assertEquals(actual.getEntitlementMetric(), expected.getEntitlementMetric()); + Assert.assertEquals(actual.getIncrements(), expected.getIncrements()); + 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 + private void init() { + entitlementPoolDao = EntitlementPoolDaoFactory.getInstance().createInterface(); + vlm1Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest + .createVendorLicenseModel("vendor1 name " + CommonMethods.nextUuId(), "vlm1 dec", "icon1"), + USER1).getId(); + vlm2Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest + .createVendorLicenseModel("vendor2 name " + CommonMethods.nextUuId(), "vlm2 dec", "icon2"), + USER1).getId(); + } + + @Test + public void emptyListTest() { + Collection<EntitlementPoolEntity> entitlementPools = + vendorLicenseManager.listEntitlementPools(vlm1Id, null, USER1); + Assert.assertEquals(entitlementPools.size(), 0); + } + + @Test(dependsOnMethods = "emptyListTest") + public void createTest() { + ep1Id = testCreate(vlm1Id, EP1_NAME); + + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool(vlm1Id, null, EP2_NAME, "EP2 dec", 70, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Absolute, + EntitlementMetric.Other, "e metric2", "inc2", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + ep2Id = vendorLicenseManager.createEntitlementPool(ep2, USER1).getId(); + ep2.setId(ep2Id); + } + + private String testCreate(String vlmId, String name) { + Set<OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Other); + EntitlementPoolEntity ep1 = + createEntitlementPool(vlmId, null, name, EP1_V01_DESC, 80, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Percentage, + EntitlementMetric.Core, null, "inc1", AggregationFunction.Other, "agg func1", + opScopeChoices, "op scope1", EntitlementTime.Other, "time1", "sku1"); + String ep1Id = vendorLicenseManager.createEntitlementPool(ep1, USER1).getId(); + ep1.setId(ep1Id); + + EntitlementPoolEntity loadedEp1 = entitlementPoolDao.get(ep1); + Assert.assertTrue(loadedEp1.equals(ep1)); + return ep1Id; + } + + @Test(dependsOnMethods = {"createTest"}) + public void testCreateWithExistingName_negative() { + testCreateWithExistingName_negative(vlm1Id, EP1_NAME); + } + + @Test(dependsOnMethods = {"createTest"}) + public void testCreateWithExistingNameUnderOtherVlm() { + testCreate(vlm2Id, EP1_NAME); + } + + @Test(dependsOnMethods = {"testCreateWithExistingName_negative"}) + public void updateAndGetTest() { + EntitlementPoolEntity emptyEp1 = new EntitlementPoolEntity(vlm1Id, VERSION01, ep1Id); + + EntitlementPoolEntity ep1 = entitlementPoolDao.get(emptyEp1); + ep1.setEntitlementMetric(new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>(EntitlementMetric.Other, "e metric1 updated")); + ep1.setAggregationFunction(new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>(AggregationFunction.Other, "agg func1 updated")); + + vendorLicenseManager.updateEntitlementPool(ep1, USER1); + + EntitlementPoolEntity loadedEp1 = vendorLicenseManager.getEntitlementPool(emptyEp1, USER1); + assertEntitlementPoolsEquals(loadedEp1, ep1); + } + + @Test(dependsOnMethods = {"updateAndGetTest"}) + public void testGetNonExistingVersion_negative() { + try { + vendorLicenseManager + .getEntitlementPool(new EntitlementPoolEntity(vlm1Id, new Version(48, 83), ep1Id), USER1); + Assert.assertTrue(false); + } catch (CoreException e) { + Assert.assertEquals(e.code().id(), VersioningErrorCodes.REQUESTED_VERSION_INVALID); + } + } + + @Test(dependsOnMethods = {"updateAndGetTest"}) + public void testGetOtherUserCandidateVersion_negative() { + vendorLicenseManager.checkin(vlm1Id, USER1); + vendorLicenseManager.checkout(vlm1Id, USER2); + try { + vendorLicenseManager + .getEntitlementPool(new EntitlementPoolEntity(vlm1Id, new Version(0, 2), ep1Id), USER1); + Assert.assertTrue(false); + } catch (CoreException e) { + Assert.assertEquals(e.code().id(), VersioningErrorCodes.REQUESTED_VERSION_INVALID); + } + } + + @Test(dependsOnMethods = {"testGetOtherUserCandidateVersion_negative"}) + public void testGetCandidateVersion() { + EntitlementPoolEntity ep = new EntitlementPoolEntity(vlm1Id, new Version(0, 2), ep1Id); + ep.setDescription("updated!"); + vendorLicenseManager.updateEntitlementPool(ep, USER2); + + EntitlementPoolEntity actualEp = vendorLicenseManager.getEntitlementPool(ep, USER2); + EntitlementPoolEntity expectedEp = entitlementPoolDao.get(ep); + + Assert.assertEquals(actualEp.getDescription(), ep.getDescription()); + assertEntitlementPoolsEquals(actualEp, expectedEp); + } + + @Test(dependsOnMethods = {"testGetCandidateVersion"}) + public void testGetOldVersion() { + vendorLicenseManager.checkin(vlm1Id, USER2); + EntitlementPoolEntity actualEp = vendorLicenseManager + .getEntitlementPool(new EntitlementPoolEntity(vlm1Id, new Version(0, 1), ep1Id), USER2); + Assert.assertEquals(actualEp.getDescription(), EP1_V01_DESC); + } + + @Test(dependsOnMethods = {"testGetOldVersion"}) + public void listTest() { + Collection<EntitlementPoolEntity> loadedEps = + vendorLicenseManager.listEntitlementPools(vlm1Id, null, USER1); + Assert.assertEquals(loadedEps.size(), 2); + + int existingCounter = 0; + for (EntitlementPoolEntity loadedEp : loadedEps) { + if (ep2Id.equals(loadedEp.getId()) || ep1Id.equals(loadedEp.getId())) { + existingCounter++; + } + } + + Assert.assertEquals(existingCounter, 2); + } + + @Test(dependsOnMethods = {"listTest"}) + public void deleteTest() { + vendorLicenseManager.checkout(vlm1Id, USER1); + EntitlementPoolEntity emptyEp1 = new EntitlementPoolEntity(vlm1Id, null, ep1Id); + vendorLicenseManager.deleteEntitlementPool(emptyEp1, USER1); + + emptyEp1.setVersion(VERSION03); + EntitlementPoolEntity loadedEp1 = entitlementPoolDao.get(emptyEp1); + Assert.assertEquals(loadedEp1, null); + + Collection<EntitlementPoolEntity> loadedEps = + entitlementPoolDao.list(new EntitlementPoolEntity(vlm1Id, VERSION03, null)); + Assert.assertEquals(loadedEps.size(), 1); + Assert.assertEquals(loadedEps.iterator().next().getId(), ep2Id); + } + + @Test(dependsOnMethods = "deleteTest") + public void listOldVersionTest() { + Collection<EntitlementPoolEntity> loadedEps = + vendorLicenseManager.listEntitlementPools(vlm1Id, VERSION01, USER1); + Assert.assertEquals(loadedEps.size(), 2); + } + + @Test(dependsOnMethods = "deleteTest") + public void testCreateWithRemovedName() { + testCreate(vlm1Id, EP1_NAME); + } + + @Test(dependsOnMethods = "deleteTest") + public void testCreateWithExistingNameAfterCheckout_negative() { + testCreateWithExistingName_negative(vlm1Id, EP2_NAME); + } + + private void testCreateWithExistingName_negative(String vlmId, String epName) { + try { + EntitlementPoolEntity ep1 = + createEntitlementPool(vlmId, null, epName, EP1_V01_DESC, 80, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Percentage, + EntitlementMetric.Core, null, "inc1", AggregationFunction.Other, "agg func1", + Collections.singleton(OperationalScope.Other), "op scope1", EntitlementTime.Other, + "time1", "sku1"); + vendorLicenseManager.createEntitlementPool(ep1, USER1).getId(); + Assert.fail(); + } catch (CoreException e) { + Assert.assertEquals(e.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 new file mode 100644 index 0000000000..c2381dd2f3 --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/FeatureGroupTest.java @@ -0,0 +1,202 @@ +package org.openecomp.sdc.vendorlicense; + +import org.openecomp.sdc.common.errors.CoreException; +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.core.util.UniqueValueUtil; +import org.openecomp.core.utilities.CommonMethods; +import org.testng.Assert; +import org.testng.annotations.Test; + +import java.util.*; + +public class FeatureGroupTest { + protected static final Version VERSION01 = new Version(0, 1); + protected static final String USER1 = "FeatureGroupTest_User1"; + protected static VendorLicenseManager vendorLicenseManager = new VendorLicenseManagerImpl(); + protected static VendorLicenseFacade vendorLicenseFacade = org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory + .getInstance().createInterface(); + + + @Test + public void testListFeatureGroups() throws Exception { + String vlmId = vendorLicenseFacade.createVendorLicenseModel(VendorLicenseModelTest.createVendorLicenseModel("vlmId_" + CommonMethods.nextUuId(), "vlm2Id desc", "icon2"), USER1).getId(); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + fg22 = LicenseAgreementTest.createFeatureGroup(vlmId, VERSION01, "fg2", "FG2", "FG2 desc", null, null); + String fg22Id = vendorLicenseManager.createFeatureGroup(fg22, USER1).getId(); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + fg33 = LicenseAgreementTest.createFeatureGroup(vlmId, VERSION01, "fg3", "FG3", "FG3 desc", null, null); + String fg33Id = vendorLicenseManager.createFeatureGroup(fg33, USER1).getId(); + + Collection<org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity> featureGroupEntities = vendorLicenseManager.listFeatureGroups(vlmId, null, USER1); + + Assert.assertEquals(featureGroupEntities.size(), 2); + Set<String> actualIds = new HashSet<>(); + for (org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity featureGroupEntity : featureGroupEntities) { + actualIds.add(featureGroupEntity.getId()); + } + + Set<String> expectedIds = new HashSet<>(); + expectedIds.add(fg22Id); + expectedIds.add(fg33Id); + for (String id : actualIds) { + Assert.assertTrue(expectedIds.contains(id)); + } + + } + + @Test + public void testCreateFeatureGroup() throws Exception { + String testName = "testCreateFeatureGroup"; + String vlmId = vendorLicenseFacade.createVendorLicenseModel(VendorLicenseModelTest.createVendorLicenseModel(testName + CommonMethods.nextUuId(), testName, "icon1"), USER1).getId(); + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Other); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Network_Wide); + org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity + ep = EntitlementPoolTest.createEntitlementPool(vlmId, VERSION01, "EP1" + CommonMethods.nextUuId(), "EP1 dec", 80, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Absolute, org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric.Core, null, "inc1", org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction.Other, "agg func1", opScopeChoices, null, org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime.Hour, null, "sku1"); + String epId = vendorLicenseManager.createEntitlementPool(ep, USER1).getId(); + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoicesLKG = new HashSet<>(); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.CPU); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.VM); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Availability_Zone); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + + org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity + lkg = LicenseKeyGroupTest.createLicenseKeyGroup(vlmId, VERSION01, "LKG1", "LKG1 dec", org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType.One_Time, new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(opScopeChoicesLKG, null)); + String lkgId = vendorLicenseManager.createLicenseKeyGroup(lkg, USER1).getId(); + lkg.setId(lkgId); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + fg1 = createFGForTest(vlmId, "created" + CommonMethods.nextUuId(), Collections.singleton(epId), Collections.singleton(lkgId)); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + fg1FromDB = vendorLicenseManager.getFeatureGroupModel(fg1, USER1).getFeatureGroup(); + Assert.assertTrue(fg1FromDB.equals(fg1)); + } + + + @Test + public void testCreateWithExistingName_negative() { + String testName = "createExistingName"; + String vlmId = vendorLicenseFacade.createVendorLicenseModel(VendorLicenseModelTest.createVendorLicenseModel(testName + CommonMethods.nextUuId(), testName, "icon1"), USER1).getId(); + createFGForTest(vlmId, "created", Collections.emptySet(), Collections.emptySet()); + try { + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + created = LicenseAgreementTest.createFeatureGroup(vlmId, null, "created", "created", "created desc", Collections.emptySet(), Collections.emptySet()); + vendorLicenseManager.createFeatureGroup(created, USER1); + Assert.fail(); + } catch (CoreException e) { + Assert.assertEquals(e.code().id(), UniqueValueUtil.UNIQUE_VALUE_VIOLATION); + } + } + + private org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity createFGForTest(String vlmId, String fgName, Set<String> epIds, Set<String> lkgIds) { + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + created = LicenseAgreementTest.createFeatureGroup(vlmId, null, null, fgName, "created desc", epIds, lkgIds); + return vendorLicenseManager.createFeatureGroup(created, USER1); + } + + @Test + public void testUpdateFeatureGroup_addEP_andGET() throws Exception { + String testName = "testUpdateFeatureGroup_addEP_andGET"; + String vlmId = vendorLicenseFacade.createVendorLicenseModel(VendorLicenseModelTest.createVendorLicenseModel(testName + CommonMethods.nextUuId(), testName, "icon1"), USER1).getId(); + + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + fg5 = LicenseAgreementTest.createFeatureGroup(vlmId, VERSION01, "id" + CommonMethods.nextUuId(), "created" + CommonMethods.nextUuId(), "created desc", null, null); + vendorLicenseManager.createFeatureGroup(fg5, USER1).getId(); + + + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Other); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + + org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity + epToAdd = EntitlementPoolTest.createEntitlementPool(vlmId, VERSION01, "epToAdd", "epToAdd dec", 80, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Absolute, org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric.Core, null, "inc1", org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction.Other, "agg func1", opScopeChoices, null, org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime.Hour, null, "sku1"); + String epToAddId = vendorLicenseManager.createEntitlementPool(epToAdd, USER1).getId(); + + vendorLicenseManager.updateFeatureGroup(fg5, null, null, CommonMethods.toSingleElementSet(epToAddId), null, USER1); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel + updatedFG = vendorLicenseManager.getFeatureGroupModel(fg5, USER1); + Set<org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity> updatedEPs = updatedFG.getEntitlementPools(); + + epToAdd.setReferencingFeatureGroups(CommonMethods.toSingleElementSet(fg5.getId())); + + Assert.assertEquals(updatedEPs.size(), 1); + for (org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity updatedEP : updatedEPs) { + Assert.assertTrue(updatedEP.getReferencingFeatureGroups().contains(fg5.getId())); + Assert.assertEquals(updatedEP.getId(), epToAddId); + } + } + + @Test + public void testUpdateFeatureGroup_removeLKG_andGET() throws Exception { + String testName = "testUpdateFeatureGroup_removeLKG_andGET"; + String vlmId = vendorLicenseFacade.createVendorLicenseModel(VendorLicenseModelTest.createVendorLicenseModel(testName + CommonMethods.nextUuId(), testName, "icon1"), USER1).getId(); + + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoicesLKG = new HashSet<>(); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.CPU); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.VM); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Availability_Zone); + opScopeChoicesLKG.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity + lkg = LicenseKeyGroupTest.createLicenseKeyGroup(vlmId, VERSION01, "lkg" + CommonMethods.nextUuId(), "lkg desc", org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType.Unique, new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(opScopeChoicesLKG, null)); + String lkgId = vendorLicenseManager.createLicenseKeyGroup(lkg, USER1).getId(); + lkg.setId(lkgId); + + org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity + lkg_1 = LicenseKeyGroupTest.createLicenseKeyGroup(vlmId, VERSION01, "lkg" + CommonMethods.nextUuId(), "lkg_1 desc", org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType.Unique, new org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther<>(opScopeChoicesLKG, null)); + String lkgId_1 = vendorLicenseManager.createLicenseKeyGroup(lkg_1, USER1).getId(); + lkg.setId(lkgId); + + Set<org.openecomp.sdc.vendorlicense.dao.types.OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Other); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Data_Center); + opScopeChoices.add(org.openecomp.sdc.vendorlicense.dao.types.OperationalScope.Network_Wide); + org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity + ep = EntitlementPoolTest.createEntitlementPool(vlmId, VERSION01, "EP1" + CommonMethods.nextUuId(), "EP1 dec", 80, org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit.Absolute, org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric.Core, null, "inc1", org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction.Other, "agg func1", opScopeChoices, null, org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime.Hour, null, "sku1"); + String epId = vendorLicenseManager.createEntitlementPool(ep, USER1).getId(); + + Set<String> lkgs = new HashSet<>(); + lkgs.add(lkgId); + lkgs.add(lkgId_1); + + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + fg = LicenseAgreementTest.createFeatureGroup(vlmId, VERSION01, "fg11" + CommonMethods.nextUuId(), "FG1", "FG1 desc", CommonMethods.toSingleElementSet(epId), lkgs); + String fgId = vendorLicenseManager.createFeatureGroup(fg, USER1).getId(); + vendorLicenseManager.updateFeatureGroup(fg, null, CommonMethods.toSingleElementSet(lkgId), null, null, USER1); + + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel + featureGroup = vendorLicenseManager.getFeatureGroupModel(fg, USER1); + Set<org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity> licenseKeyGroups = featureGroup.getLicenseKeyGroups(); + Assert.assertEquals(licenseKeyGroups.size(), 1); + List<String> lkgIds = new ArrayList<>(); + for (org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity licenseKeyGroup : licenseKeyGroups) { + lkgIds.add(licenseKeyGroup.getId()); + } + + Assert.assertTrue(lkgIds.contains(lkgId_1)); + Assert.assertFalse(lkgIds.contains(lkgId)); + + } + + + @Test + public void testDeleteFeatureGroup() throws Exception { + String testName = "testDeleteFeatureGroup"; + String vlmId = vendorLicenseFacade.createVendorLicenseModel(VendorLicenseModelTest.createVendorLicenseModel(testName + CommonMethods.nextUuId(), testName, "icon1"), USER1).getId(); + + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + fg1 = createFGForTest(vlmId, "new", Collections.emptySet(), Collections.emptySet()); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + fg2 = createFGForTest(vlmId, "newer", Collections.emptySet(), Collections.emptySet()); + Collection<org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity> featureGroupEntities = vendorLicenseManager.listFeatureGroups(vlmId, null, USER1); + Assert.assertEquals(featureGroupEntities.size(), 2); //precondition + + vendorLicenseManager.deleteFeatureGroup(fg1, USER1); + Assert.assertEquals(vendorLicenseManager.listFeatureGroups(vlmId, null, USER1).size(), 1); + + + } + + +}
\ No newline at end of file diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseAgreementTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseAgreementTest.java new file mode 100644 index 0000000000..f68f84ec0a --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseAgreementTest.java @@ -0,0 +1,218 @@ +package org.openecomp.sdc.vendorlicense; + +import org.openecomp.sdc.common.errors.CoreException; +import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDaoFactory; +import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm; +import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.core.util.UniqueValueUtil; +import org.openecomp.core.utilities.CommonMethods; +import org.testng.Assert; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; + +public class LicenseAgreementTest { + private static final Version VERSION01 = new Version(0, 1); + private static final String USER1 = "user1"; + private static final String LA1_NAME = "LA1 Name"; + + private static VendorLicenseManager vendorLicenseManager = new VendorLicenseManagerImpl(); + private static org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao featureGroupDao; + private static org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao licenseAgreementDao; + + private static String vlm1Id; + private static String vlm2Id; + private static String la1Id; + private static String la2Id; + + public static org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity createLicenseAgreement(String vlmId, Version version, + String id, String name, String desc, + String requirementsAndConstrains, + org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<LicenseTerm> term, + String... fgIds) { + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity + la = new org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity(); + la.setVendorLicenseModelId(vlmId); + la.setVersion(version); + la.setId(id); + la.setName(name); + la.setDescription(desc); + la.setLicenseTerm(term); + la.setRequirementsAndConstrains(requirementsAndConstrains); + for (String fgId : fgIds) { + la.getFeatureGroupIds().add(fgId); + } + return la; + } + + public static org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity createFeatureGroup(String vendorId, Version version, String id, + String name, String description, + Set<String> entitlementPoolIds, + Set<String> licenseKeyGroupIds) { + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + featureGroup = new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity(); + featureGroup.setVendorLicenseModelId(vendorId); + featureGroup.setVersion(version); + featureGroup.setId(id); + featureGroup.setName(name); + featureGroup.setDescription(description); + featureGroup.setEntitlementPoolIds(entitlementPoolIds); + featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds); + return featureGroup; + } + + @BeforeClass + private void init() { + licenseAgreementDao = org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDaoFactory.getInstance().createInterface(); + featureGroupDao = FeatureGroupDaoFactory.getInstance().createInterface(); + vlm1Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest + .createVendorLicenseModel("vendor1 name " + CommonMethods.nextUuId(), "vlm1 dec", "icon1"), + USER1).getId(); + vlm2Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest + .createVendorLicenseModel("vendor2 name " + CommonMethods.nextUuId(), "vlm2 dec", "icon2"), + USER1).getId(); + } + + @Test + public void createLicenseAgreementTest() { + la1Id = testCreate(vlm1Id, LA1_NAME); + } + + private String testCreate(String vlmId, String name) { + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity fg1 = + createFeatureGroup(vlmId, VERSION01, "fg11", "FG1", "FG1 desc", null, null); + featureGroupDao.create(fg1); + + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity + la1 = createLicenseAgreement(vlmId, VERSION01, null, name, "LA1 desc", + "RequirementsAndConstrains1", new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>( + org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm.Unlimited, null), "fg11"); + la1 = vendorLicenseManager.createLicenseAgreement(la1, USER1); + String la1Id = la1.getId(); + + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity loadedLa1 = licenseAgreementDao.get(la1); + Assert.assertTrue(loadedLa1.equals(la1)); + return la1Id; + } + + @Test(dependsOnMethods = {"createLicenseAgreementTest"}) + public void testCreateWithExistingName_negative() { + try { + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity la1 = + createLicenseAgreement(vlm1Id, VERSION01, null, LA1_NAME, "LA1 desc", + "RequirementsAndConstrains1", new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>( + org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm.Unlimited, null), + "fg11"); + vendorLicenseManager.createLicenseAgreement(la1, USER1); + Assert.fail(); + } catch (CoreException e) { + Assert.assertEquals(e.code().id(), UniqueValueUtil.UNIQUE_VALUE_VIOLATION); + } + } + + @Test(dependsOnMethods = {"createLicenseAgreementTest"}) + public void testCreateWithExistingNameUnderOtherVlm() { + testCreate(vlm2Id, LA1_NAME); + } + + @Test(dependsOnMethods = {"testCreateWithExistingName_negative"}) + public void updateLicenseAgreementTest() { + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity fg2 = + createFeatureGroup(vlm1Id, VERSION01, "fg2", "FG2", "FG2 desc", null, null); + featureGroupDao.create(fg2); + + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity fg3 = + createFeatureGroup(vlm1Id, VERSION01, "fg3", "FG3", "FG3 desc", null, null); + featureGroupDao.create(fg3); + + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity la1 = + licenseAgreementDao.get(new org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity(vlm1Id, VERSION01, la1Id)); + la1.setDescription("LA1 desc updated"); + la1.setLicenseTerm(new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>( + org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm.Other, "bla bla term")); + la1.getFeatureGroupIds().add("fg2"); + la1.getFeatureGroupIds().add("fg3"); + la1.getFeatureGroupIds().remove("fg11"); + + Set<String> addedFeatureGroupIds = new HashSet<>(); + addedFeatureGroupIds.add("fg2"); + addedFeatureGroupIds.add("fg3"); + + Set<String> removedFeatureGroupIds = new HashSet<>(); + removedFeatureGroupIds.add("fg11"); + + vendorLicenseManager + .updateLicenseAgreement(la1, addedFeatureGroupIds, removedFeatureGroupIds, USER1); + + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity loadedLa1 = + licenseAgreementDao.get(new org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity(vlm1Id, VERSION01, la1Id)); + Assert.assertTrue(loadedLa1.equals(la1)); + + } + + @Test(dependsOnMethods = {"updateLicenseAgreementTest"}) + public void listLicenseAgreementsTest() { + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity + la2 = createLicenseAgreement(vlm1Id, VERSION01, null, "LA2", "LA2 desc", + "RequirementsAndConstrains2", new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>( + org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm.Unlimited, null), "fg2"); + la2 = vendorLicenseManager.createLicenseAgreement(la2, USER1); + la2Id = la2.getId(); + + Collection<org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity> loadedLas = + vendorLicenseManager.listLicenseAgreements(vlm1Id, null, USER1); + Assert.assertEquals(loadedLas.size(), 2); + boolean la2Exists = false; + for (org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity loadedLa : loadedLas) { + if (la2Id.equals(loadedLa.getId())) { + Assert.assertTrue(loadedLa.equals(la2)); + la2Exists = true; + } + } + + Assert.assertTrue(la2Exists); + } + + @Test(dependsOnMethods = {"listLicenseAgreementsTest"}) + public void featureGroupDeletedLicenseAgreementUpdated() { + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity licenseAgreement = + createLicenseAgreement(vlm1Id, VERSION01, "laId", "LA2", "LA2 desc", + "RequirementsAndConstrains2", new org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther<>( + org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm.Unlimited, null), "fg2"); + licenseAgreementDao.create(licenseAgreement); + String featureGroupId = "FeatureGroupId"; + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity created = + createFeatureGroup(vlm1Id, VERSION01, "fg11", "FG1", "FG1 desc", null, null); + featureGroupDao.create(created); + featureGroupDao.addReferencingLicenseAgreement(created, licenseAgreement.getId()); + + vendorLicenseManager.deleteFeatureGroup(created, USER1); + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity afterDeletingFG = licenseAgreementDao.get(licenseAgreement); + Assert.assertEquals(afterDeletingFG.getFeatureGroupIds().size(), 1); + Assert.assertTrue(afterDeletingFG.getFeatureGroupIds().contains("fg2")); + } + + @Test(dependsOnMethods = {"listLicenseAgreementsTest"}) + public void deleteLicenseAgreementsTest() { + vendorLicenseManager.deleteLicenseAgreement(vlm1Id, la1Id, USER1); + + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity loadedLa1 = + licenseAgreementDao.get(new org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity(vlm1Id, VERSION01, la1Id)); + Assert.assertEquals(loadedLa1, null); + + Collection<org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity> loadedLas = + licenseAgreementDao.list(new org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity(vlm1Id, VERSION01, null)); + Assert.assertEquals(loadedLas.size(), 1); + Assert.assertEquals(loadedLas.iterator().next().getId(), la2Id); + } + + @Test(dependsOnMethods = "deleteLicenseAgreementsTest") + public void testCreateWithRemovedName() { + testCreate(vlm1Id, LA1_NAME); + } +} + 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 new file mode 100644 index 0000000000..15b179b9c6 --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LicenseKeyGroupTest.java @@ -0,0 +1,162 @@ +package org.openecomp.sdc.vendorlicense; + +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.impl.VendorLicenseManagerImpl; +import org.openecomp.sdc.versioning.dao.types.Version; +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.testng.Assert; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +public class LicenseKeyGroupTest { + + 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; + public static String vlm2Id; + private static VendorLicenseManager vendorLicenseManager = new VendorLicenseManagerImpl(); + private static LicenseKeyGroupDao licenseKeyGroupDao; + private static NoSqlDb noSqlDb; + private static String lkg1Id; + private static String lkg2Id; + + public static LicenseKeyGroupEntity createLicenseKeyGroup(String vlmId, Version version, + String name, String desc, + LicenseKeyType type, + MultiChoiceOrOther<OperationalScope> operationalScope) { + LicenseKeyGroupEntity licenseKeyGroup = new LicenseKeyGroupEntity(); + licenseKeyGroup.setVendorLicenseModelId(vlmId); + licenseKeyGroup.setVersion(version); + licenseKeyGroup.setName(name); + licenseKeyGroup.setDescription(desc); + licenseKeyGroup.setType(type); + licenseKeyGroup.setOperationalScope(operationalScope); + return licenseKeyGroup; + } + + @BeforeClass + private void init() { + licenseKeyGroupDao = LicenseKeyGroupDaoFactory.getInstance().createInterface(); + noSqlDb = NoSqlDbFactory.getInstance().createInterface(); + + vlm1Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest + .createVendorLicenseModel("vendor1 name " + CommonMethods.nextUuId(), "vlm1Id dec", + "icon1"), USER1).getId(); + vlm2Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest + .createVendorLicenseModel("vendor2 name " + CommonMethods.nextUuId(), "vlm2 dec", "icon2"), + USER1).getId(); + } + + @Test + public void createTest() { + lkg1Id = testCreate(vlm1Id, LKG1_NAME); + } + + private String testCreate(String vlmId, String name) { + Set<OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.VM); + opScopeChoices.add(OperationalScope.Tenant); + opScopeChoices.add(OperationalScope.Data_Center); + LicenseKeyGroupEntity lkg1 = + createLicenseKeyGroup(vlmId, VERSION01, name, "LKG1 dec", LicenseKeyType.One_Time, + new MultiChoiceOrOther<>(opScopeChoices, null)); + String lkg1Id = vendorLicenseManager.createLicenseKeyGroup(lkg1, USER1).getId(); + lkg1.setId(lkg1Id); + + LicenseKeyGroupEntity loadedLkg1 = licenseKeyGroupDao.get(lkg1); + Assert.assertTrue(loadedLkg1.equals(lkg1)); + return lkg1Id; + } + + @Test(dependsOnMethods = {"createTest"}) + public void testCreateWithExistingName_negative() { + try { + LicenseKeyGroupEntity lkg1 = + createLicenseKeyGroup(vlm1Id, VERSION01, LKG1_NAME, "LKG1 dec", LicenseKeyType.One_Time, + new MultiChoiceOrOther<>(Collections.singleton(OperationalScope.Other), + "other op scope")); + vendorLicenseManager.createLicenseKeyGroup(lkg1, USER1).getId(); + Assert.fail(); + } catch (CoreException e) { + Assert.assertEquals(e.code().id(), UniqueValueUtil.UNIQUE_VALUE_VIOLATION); + } + } + + @Test(dependsOnMethods = {"createTest"}) + public void testCreateWithExistingNameUnderOtherVlm() { + testCreate(vlm2Id, LKG1_NAME); + } + + @Test(dependsOnMethods = {"testCreateWithExistingName_negative"}) + public void updateAndGetTest() { + LicenseKeyGroupEntity lkg1 = + licenseKeyGroupDao.get(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id)); + Set<OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Other); + lkg1.setOperationalScope(new MultiChoiceOrOther<>(opScopeChoices, "op scope1 updated")); + lkg1.setDescription("LKG1 dec updated"); + + vendorLicenseManager.updateLicenseKeyGroup(lkg1, USER1); + + LicenseKeyGroupEntity loadedLkg1 = vendorLicenseManager.getLicenseKeyGroup(lkg1, USER1); + Assert.assertTrue(loadedLkg1.equals(lkg1)); + + } + + @Test(dependsOnMethods = {"updateAndGetTest"}) + public void listTest() { + Set<OperationalScope> opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Network_Wide); + LicenseKeyGroupEntity lkg2 = + createLicenseKeyGroup(vlm1Id, VERSION01, "LKG2", "LKG2 dec", LicenseKeyType.Universal, + new MultiChoiceOrOther<>(opScopeChoices, null)); + lkg2Id = vendorLicenseManager.createLicenseKeyGroup(lkg2, USER1).getId(); + lkg2.setId(lkg2Id); + + Collection<LicenseKeyGroupEntity> loadedLkgs = + vendorLicenseManager.listLicenseKeyGroups(vlm1Id, null, USER1); + Assert.assertEquals(loadedLkgs.size(), 2); + for (LicenseKeyGroupEntity loadedLkg : loadedLkgs) { + if (lkg2Id.equals(loadedLkg.getId())) { + Assert.assertTrue(loadedLkg.equals(lkg2)); + } + } + } + + @Test(dependsOnMethods = {"listTest"}) + public void deleteTest() { + vendorLicenseManager + .deleteLicenseKeyGroup(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id), USER1); + + LicenseKeyGroupEntity loadedLkg1 = + licenseKeyGroupDao.get(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id)); + Assert.assertEquals(loadedLkg1, null); + + Collection<LicenseKeyGroupEntity> loadedLkgs = + licenseKeyGroupDao.list(new LicenseKeyGroupEntity(vlm1Id, VERSION01, null)); + Assert.assertEquals(loadedLkgs.size(), 1); + Assert.assertEquals(loadedLkgs.iterator().next().getId(), lkg2Id); + } + + @Test(dependsOnMethods = "deleteTest") + 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/VendorLicenseModelTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseModelTest.java new file mode 100644 index 0000000000..c2a8d14c01 --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseModelTest.java @@ -0,0 +1,402 @@ +package org.openecomp.sdc.vendorlicense; + +import org.openecomp.sdc.common.errors.CoreException; +import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl; +import org.openecomp.core.util.UniqueValueUtil; + +import org.testng.Assert; +import org.testng.annotations.BeforeTest; +import org.testng.annotations.Test; + +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +public class VendorLicenseModelTest { + private static final org.openecomp.sdc.versioning.dao.types.Version + VERSION01 = new org.openecomp.sdc.versioning.dao.types.Version(0, 1); + private static final org.openecomp.sdc.versioning.dao.types.Version + VERSION02 = new org.openecomp.sdc.versioning.dao.types.Version(0, 2); + private static final String USER1 = "vlmTestUser1"; + private static final String USER2 = "vlmTestUser2"; + private static final String USER3 = "vlmTestUser3"; + private static final String VLM1_NAME = "Vlm1 name"; + private static VendorLicenseManager vendorLicenseManager = new VendorLicenseManagerImpl(); + private static org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao vendorLicenseModelDao = + org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDaoFactory.getInstance().createInterface(); + + private static String vlm1Id; + private static String vlm2Id; + private static String vlm3Id; + private static String vlm4Id; + private static String laId; + private static String fg1Id; + private static String fg2Id; + + private static String testCreate() { + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity vlm1 = createVendorLicenseModel(VLM1_NAME, "VLM1 dec", "icon1"); + String vlmId = vendorLicenseManager.createVendorLicenseModel(vlm1, USER1).getId(); + + vlm1.setVersion(VERSION01); + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity loadedVlm1 = vendorLicenseModelDao.get(vlm1); + Assert.assertTrue(loadedVlm1.equals(vlm1)); + return vlmId; + } + + public static org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity createVendorLicenseModel(String name, String desc, + String icon) { + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity + vendorLicenseModel = new org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity(); + vendorLicenseModel.setVendorName(name); + vendorLicenseModel.setDescription(desc); + vendorLicenseModel.setIconRef(icon); + return vendorLicenseModel; + } + + @BeforeTest + private void init() { + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, VLM1_NAME); + UniqueValueUtil + .deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "VLM1 updated"); + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "VLM2"); + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "test_vlm1"); + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "test_vlm2"); + UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "test_vlm3"); + } + + @Test + public void createTest() { + vlm1Id = testCreate(); + } + + @Test(dependsOnMethods = {"createTest"}) + public void testCreateWithExistingVendorName_negative() { + try { + vendorLicenseManager + .createVendorLicenseModel(createVendorLicenseModel(VLM1_NAME, "VLM1 dec", "icon1"), + USER1); + Assert.fail(); + } catch (CoreException e) { + Assert.assertEquals(e.code().id(), UniqueValueUtil.UNIQUE_VALUE_VIOLATION); + } + } + + @Test(dependsOnMethods = {"testCreateWithExistingVendorName_negative"}) + public void updateTest() { + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity + expectedVlm1 = new org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity(vlm1Id, VERSION01); + expectedVlm1.setVendorName("VLM1 updated"); + expectedVlm1.setDescription("VLM1 dec updated"); + expectedVlm1.setIconRef("icon1 updated"); + vendorLicenseManager.updateVendorLicenseModel(expectedVlm1, USER1); + + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity actualVlm1 = + vendorLicenseModelDao.get(new org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity(vlm1Id, VERSION01)); + Assert.assertTrue(actualVlm1.equals(expectedVlm1)); + } + + @Test(dependsOnMethods = {"updateTest"}) + public void testUpdateWithSimilarVendorName() { + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity + expectedVlm1 = new org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity(vlm1Id, VERSION01); + expectedVlm1.setVendorName("vlm1 UPDATED"); + vendorLicenseManager.updateVendorLicenseModel(expectedVlm1, USER1); + + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity actualVlm1 = + vendorLicenseModelDao.get(new org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity(vlm1Id, VERSION01)); + Assert.assertTrue(actualVlm1.equals(expectedVlm1)); + } + + @Test(dependsOnMethods = {"updateTest"}) + public void testCreateWithRemovedVendorName() { + testCreate(); + } + + @Test(dependsOnMethods = {"updateTest"}) + public void getTest() { + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity expectedVlm1 = + vendorLicenseModelDao.get(new org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity(vlm1Id, VERSION01)); + org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel actualVlm1 = + vendorLicenseManager.getVendorLicenseModel(vlm1Id, null, USER1); + + Assert.assertTrue(actualVlm1.getVendorLicenseModel().equals(expectedVlm1)); + Assert.assertEquals(actualVlm1.getVersionInfo().getActiveVersion(), VERSION01); + Assert.assertEquals(actualVlm1.getVersionInfo().getStatus(), org.openecomp.sdc.versioning.dao.types.VersionStatus.Locked); + Assert.assertEquals(actualVlm1.getVersionInfo().getLockingUser(), USER1); + } + + @Test(dependsOnMethods = {"getTest"}) + public void listTest() { + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity vlm2 = createVendorLicenseModel("VLM2", "VLM2 dec", "icon2"); + vlm2Id = vendorLicenseManager.createVendorLicenseModel(vlm2, USER1).getId(); + vlm2.setId(vlm2Id); + + Collection<org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel> loadedVlms = + vendorLicenseManager.listVendorLicenseModels(null, USER1); + boolean vlm1Exists = false; + boolean vlm2Exists = false; + for (org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel loadedVlm : loadedVlms) { + if (vlm1Id.equals(loadedVlm.getVendorLicenseModel().getId())) { + vlm1Exists = true; + continue; + } + if (vlm2Id.equals(loadedVlm.getVendorLicenseModel().getId())) { + Assert.assertTrue(loadedVlm.getVendorLicenseModel().equals(vlm2)); + + vlm2Exists = true; + } + } + + Assert.assertTrue(vlm1Exists); + Assert.assertTrue(vlm2Exists); + } + + @Test(dependsOnMethods = {"listTest"}) + public void listFinalVersionWhenNoneTest() { + Collection<org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel> loadedVlms = + vendorLicenseManager.listVendorLicenseModels( + org.openecomp.sdc.versioning.dao.types.VersionStatus.Final.name(), USER1); + boolean vlm1Exists = false; + boolean vlm2Exists = false; + for (org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel loadedVlm : loadedVlms) { + if (vlm1Id.equals(loadedVlm.getVendorLicenseModel().getId())) { + vlm1Exists = true; + continue; + } + if (vlm2Id.equals(loadedVlm.getVendorLicenseModel().getId())) { + vlm2Exists = true; + } + } + + Assert.assertFalse(vlm1Exists); + Assert.assertFalse(vlm2Exists); + } + + @Test(dependsOnMethods = {"listFinalVersionWhenNoneTest"}) + + // Unsupported operation for 1607 release. +/* public void deleteTest() { + vendorLicenseManager.deleteVendorLicenseModel(vlm1Id, USER1); + + VendorLicenseModelEntity loadedVlm1 = vendorLicenseModelDao.get(new VendorLicenseModelEntity(vlm1Id, VERSION01)); + Assert.assertEquals(loadedVlm1, null); + + Collection<VendorLicenseModelEntity> loadedVlms = vendorLicenseModelDao.list(null); + Assert.assertTrue(loadedVlms.size() > 1); + boolean vlm1Exists = false; + boolean vlm2Exists = false; + for (VendorLicenseModelEntity loadedVlm : loadedVlms) { + if (vlm1Id.equals(loadedVlm.getId())) { + vlm1Exists = true; + } + if (vlm2Id.equals(loadedVlm.getId())) { + vlm2Exists = true; + } + } + Assert.assertFalse(vlm1Exists); + Assert.assertTrue(vlm2Exists); + } + + @Test(dependsOnMethods = {"deleteTest"})*/ + public void checkinTest() { + vendorLicenseManager.checkin(vlm2Id, USER1); + + org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel versionedVlm2 = + vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER1); + Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), VERSION01); + Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), org.openecomp.sdc.versioning.dao.types.VersionStatus.Available); + Assert.assertNull(versionedVlm2.getVersionInfo().getLockingUser()); + } + + @Test(dependsOnMethods = {"checkinTest"}) + public void checkoutTest() { + vendorLicenseManager.checkout(vlm2Id, USER2); + + org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel versionedVlm2 = + vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER2); + Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), VERSION02); + Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), org.openecomp.sdc.versioning.dao.types.VersionStatus.Locked); + Assert.assertEquals(versionedVlm2.getVersionInfo().getLockingUser(), USER2); + + versionedVlm2 = vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER1); + Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), VERSION01); + Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), org.openecomp.sdc.versioning.dao.types.VersionStatus.Locked); + Assert.assertEquals(versionedVlm2.getVersionInfo().getLockingUser(), USER2); + } + + @Test(dependsOnMethods = {"checkoutTest"}) + public void undoCheckoutTest() { + vendorLicenseManager.undoCheckout(vlm2Id, USER2); + + org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel versionedVlm2 = + vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER2); + Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), VERSION01); + Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), org.openecomp.sdc.versioning.dao.types.VersionStatus.Available); + Assert.assertNull(versionedVlm2.getVersionInfo().getLockingUser()); + } + + @Test(dependsOnMethods = {"undoCheckoutTest"}, expectedExceptions = CoreException.class) + public void submitUncompletedVlmNegativeTest() { + vendorLicenseManager.submit(vlm2Id, USER2); + } + + @Test(dependsOnMethods = {"submitUncompletedVlmNegativeTest"}, + expectedExceptions = CoreException.class) + public void submitUncompletedVlmMissingFGNegativeTest() { + vendorLicenseManager.checkout(vlm2Id, USER2); + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity + licenseAgreement = new org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity(vlm2Id, null, null); + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity licenseAgreementEntity = + vendorLicenseManager.createLicenseAgreement(licenseAgreement, USER2); + laId = licenseAgreementEntity.getId(); + vendorLicenseManager.checkin(vlm2Id, USER2); + vendorLicenseManager.submit(vlm2Id, USER2); + } + + @Test(dependsOnMethods = {"submitUncompletedVlmMissingFGNegativeTest"}, + expectedExceptions = CoreException.class) + public void submitUncompletedVlmMissingEPNegativeTest() { + vendorLicenseManager.checkout(vlm2Id, USER2); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + featureGroup = new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity(vlm2Id, null, null); + featureGroup = vendorLicenseManager.createFeatureGroup(featureGroup, USER2); + fg1Id = featureGroup.getId(); + + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel licenseAgreementModel = + vendorLicenseManager.getLicenseAgreementModel(vlm2Id, null, laId, USER2); + Set<String> fgIdSet = new HashSet<>(); + fgIdSet.add(fg1Id); + vendorLicenseManager + .updateLicenseAgreement(licenseAgreementModel.getLicenseAgreement(), fgIdSet, null, USER2); + vendorLicenseManager.checkin(vlm2Id, USER2); + vendorLicenseManager.submit(vlm2Id, USER2); + } + + @Test(dependsOnMethods = {"submitUncompletedVlmMissingEPNegativeTest"}, + expectedExceptions = CoreException.class) + public void submitUncompletedVlmMissingEPInOneFGNegativeTest() { + vendorLicenseManager.checkout(vlm2Id, USER2); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + featureGroup = new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity(vlm2Id, null, null); + org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity entitlementPool = vendorLicenseManager + .createEntitlementPool(new org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity(vlm2Id, null, null), USER2); + featureGroup.getEntitlementPoolIds().add(entitlementPool.getId()); + featureGroup = vendorLicenseManager.createFeatureGroup(featureGroup, USER2); + fg2Id = featureGroup.getId(); + org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel licenseAgreementModel = + vendorLicenseManager.getLicenseAgreementModel(vlm2Id, null, laId, USER2); + Set<String> fgIdSet = new HashSet<>(); + fgIdSet.add(fg2Id); + vendorLicenseManager + .updateLicenseAgreement(licenseAgreementModel.getLicenseAgreement(), fgIdSet, null, USER2); + + vendorLicenseManager.checkin(vlm2Id, USER2); + vendorLicenseManager.submit(vlm2Id, USER2); + } + + @Test(dependsOnMethods = {"submitUncompletedVlmMissingEPInOneFGNegativeTest"}) + public void submitTest() { + vendorLicenseManager.checkout(vlm2Id, USER2); + + org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity entitlementPool = vendorLicenseManager + .createEntitlementPool(new org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity(vlm2Id, null, null), USER2); + Set<String> epSetId = new HashSet<>(); + epSetId.add(entitlementPool.getId()); + + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity + featureGroup = new org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity(vlm2Id, null, fg1Id); + featureGroup.getEntitlementPoolIds().add(entitlementPool.getId()); + org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel featureGroupModel = + vendorLicenseManager.getFeatureGroupModel(featureGroup, USER2); + + vendorLicenseManager + .updateFeatureGroup(featureGroupModel.getFeatureGroup(), null, null, epSetId, null, USER2); + vendorLicenseManager.checkin(vlm2Id, USER2); + vendorLicenseManager.submit(vlm2Id, USER2); + + org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel versionedVlm2 = + vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER1); + Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), new org.openecomp.sdc.versioning.dao.types.Version(1, 0)); + Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), org.openecomp.sdc.versioning.dao.types.VersionStatus.Final); + Assert.assertNull(versionedVlm2.getVersionInfo().getLockingUser()); + } + + @Test(dependsOnMethods = {"submitTest"}) + public void listFinalVersionWhenOneTest() { + Collection<org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel> loadedVlms = + vendorLicenseManager.listVendorLicenseModels( + org.openecomp.sdc.versioning.dao.types.VersionStatus.Final.name(), USER1); + boolean vlm2Exists = false; + for (org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel loadedVlm : loadedVlms) { + if (vlm2Id.equals(loadedVlm.getVendorLicenseModel().getId())) { + vlm2Exists = true; + Assert.assertEquals(loadedVlm.getVersionInfo().getActiveVersion(), new org.openecomp.sdc.versioning.dao.types.Version(1, 0)); + Assert.assertEquals(loadedVlm.getVersionInfo().getStatus(), org.openecomp.sdc.versioning.dao.types.VersionStatus.Final); + Assert.assertNull(loadedVlm.getVersionInfo().getLockingUser()); + break; + } + } + + Assert.assertTrue(vlm2Exists); + } + + @Test(dependsOnMethods = {"listFinalVersionWhenOneTest"}) + public void testVLMListWithModificationTimeDescOrder() { + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity vlm1 = createVendorLicenseModel("test_vlm1", "desc", "icon"); + vlm3Id = vendorLicenseManager.createVendorLicenseModel(vlm1, USER3).getId(); + + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity vlm2 = createVendorLicenseModel("test_vlm2", "desc", "icon"); + vlm4Id = vendorLicenseManager.createVendorLicenseModel(vlm2, USER3).getId(); + + assertVLMInWantedLocationInVSPList(vlm4Id, 0, USER3); + assertVLMInWantedLocationInVSPList(vlm3Id, 1, USER3); + } + + @Test(dependsOnMethods = {"testVLMListWithModificationTimeDescOrder"}) + public void testOldVLMAfterChangeShouldBeInBeginningOfList() { + org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity ep = vendorLicenseManager + .createEntitlementPool(new org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity(vlm3Id, null, null), USER3); + + assertVLMInWantedLocationInVSPList(vlm3Id, 0, USER3); + } + + @Test(dependsOnMethods = {"testOldVLMAfterChangeShouldBeInBeginningOfList"}) + public void testAddNewVLMShouldBeInBeginningOfList() { + org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity vlm = createVendorLicenseModel("test_vlm3", "desc", "icon"); + String vlm5Id = vendorLicenseManager.createVendorLicenseModel(vlm, USER3).getId(); + + assertVLMInWantedLocationInVSPList(vlm5Id, 0, USER3); + } + + @Test(dependsOnMethods = {"testAddNewVLMShouldBeInBeginningOfList"}) + public void testVLMInBeginningOfListAfterCheckin() { + vendorLicenseManager.checkin(vlm4Id, USER3); + assertVLMInWantedLocationInVSPList(vlm4Id, 0, USER3); + } + + @Test(dependsOnMethods = {"testVLMInBeginningOfListAfterCheckin"}) + public void testVLMInBeginningOfListAfterCheckout() { + vendorLicenseManager.checkin(vlm3Id, USER3); + assertVLMInWantedLocationInVSPList(vlm3Id, 0, USER3); + + vendorLicenseManager.checkout(vlm4Id, USER3); + assertVLMInWantedLocationInVSPList(vlm4Id, 0, USER3); + } + + @Test(dependsOnMethods = {"testVLMInBeginningOfListAfterCheckout"}) + public void testVLMInBeginningOfListAfterUndoCheckout() { + vendorLicenseManager.checkout(vlm3Id, USER3); + vendorLicenseManager.undoCheckout(vlm3Id, USER3); + assertVLMInWantedLocationInVSPList(vlm3Id, 0, USER3); + } + + private void assertVLMInWantedLocationInVSPList(String vlmId, int location, String user) { + List<org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel> vlmList = + (List<org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel>) vendorLicenseManager + .listVendorLicenseModels(null, user); + Assert.assertEquals(vlmList.get(location).getVendorLicenseModel().getId(), vlmId); + } + + +} diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/licenseartifacts/impl/VendorLicenseArtifactsServiceTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/licenseartifacts/impl/VendorLicenseArtifactsServiceTest.java new file mode 100644 index 0000000000..778caf3756 --- /dev/null +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/licenseartifacts/impl/VendorLicenseArtifactsServiceTest.java @@ -0,0 +1,141 @@ +package org.openecomp.sdc.vendorlicense.licenseartifacts.impl; + +import org.apache.commons.io.IOUtils; +import org.apache.commons.lang3.StringUtils; +import org.openecomp.sdc.vendorlicense.ArtifactTestUtils; +import org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric; +import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity; +import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity; +import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.core.utilities.file.FileContentHandler; +import org.testng.Assert; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; + +import java.io.IOException; +import java.nio.charset.StandardCharsets; + +public class VendorLicenseArtifactsServiceTest extends ArtifactTestUtils { + private FileContentHandler licenseArtifacts; + + + @Test + public void createVNFArtifact() throws Exception { + Version vlmVersion = vspDetails.getVlmVersion(); + licenseArtifacts = vendorLicenseArtifactsService.createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion, vspDetails.getFeatureGroups(), USER1); + String actual = IOUtils.toString(licenseArtifacts.getFileContent( + org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VNF_ARTIFACT_NAME_WITH_PATH), StandardCharsets.UTF_8); +// System.out.println("createVnfArtifact = " + actual); + + Assert.assertTrue(actual.contains("type")); + Assert.assertFalse(actual.contains(lkg13Id)); + Assert.assertTrue(actual.contains(OperationalScope.Availability_Zone.toString())); + Assert.assertTrue(actual.contains("vf-id")); + Assert.assertFalse(actual.contains(org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_ARTIFACT_REGEX_REMOVE)); + Assert.assertFalse(actual.contains("80.0")); + Assert.assertTrue(actual.contains("80")); + + } + + @Test + public void createVendorLicenseArtifact() throws Exception { + Version vlmVersion = vspDetails.getVlmVersion(); + + licenseArtifacts = vendorLicenseArtifactsService.createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion, vspDetails.getFeatureGroups(), USER1); + String actual = IOUtils.toString(licenseArtifacts.getFileContent( + org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_ARTIFACT_NAME_WITH_PATH), StandardCharsets.UTF_8); + +// System.out.println("createVendorLicenseArtifact = " + actual); + Assert.assertFalse(actual.contains(lkg11Id)); + Assert.assertFalse(actual.contains(ep11Id)); + Assert.assertTrue(actual.contains("type")); + Assert.assertTrue(actual.contains(EntitlementMetric.Core.toString())); + Assert.assertTrue(actual.contains("entitlement-pool-list")); + Assert.assertFalse(actual.contains(org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_ARTIFACT_REGEX_REMOVE)); + + Assert.assertTrue(actual.contains("vendor-license-model")); + Assert.assertFalse(actual.contains("80.0")); + Assert.assertTrue(actual.contains("80")); + } + + @Test + public void vNFArtifactContainsCurrentVLMVersion() throws IOException { + super.setVlm2FirstVersion(); + licenseArtifacts = vendorLicenseArtifactsService.createLicenseArtifacts(vsp2.getId(), vsp2.getVendorId(), vsp2.getVlmVersion(), vsp2.getFeatureGroups(), USER1); + String actual = IOUtils.toString(licenseArtifacts.getFileContent( + org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VNF_ARTIFACT_NAME_WITH_PATH), StandardCharsets.UTF_8); + + Assert.assertTrue(actual.contains(ep21.getVersionUuId())); + } + + @Test + public void vnfArtifactContainsSameIdAsVLMArtifact() throws IOException { + Version vlmVersion = vspDetails.getVlmVersion(); + licenseArtifacts = vendorLicenseArtifactsService.createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion, vspDetails.getFeatureGroups(), USER1); + String actualVnfArtifact = IOUtils.toString(licenseArtifacts.getFileContent( + org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VNF_ARTIFACT_NAME_WITH_PATH), StandardCharsets.UTF_8); + String actualVendorLicenseArtifact = IOUtils.toString(licenseArtifacts.getFileContent( + org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_ARTIFACT_NAME_WITH_PATH), StandardCharsets.UTF_8); + + String firstLKGUUID = actualVnfArtifact.substring(actualVnfArtifact.indexOf("<license-key-group-uuid>") + 24, actualVnfArtifact.indexOf("<license-key-group-uuid>") + 60); + Assert.assertTrue(actualVendorLicenseArtifact.contains(firstLKGUUID)); + + String firstEPUUID = actualVnfArtifact.substring(actualVnfArtifact.indexOf("<<entitlement-pool-uuid>>") + 23, actualVnfArtifact.indexOf("<<entitlement-pool-uuid>>") + 60); + Assert.assertTrue(actualVendorLicenseArtifact.contains(firstEPUUID)); + } + + + @Test + public void vNFArtifactContainsPreviousVLMVersionAndNotLatest() throws IOException { + super.setVlm2SecondVersion(); + licenseArtifacts = vendorLicenseArtifactsService.createLicenseArtifacts(vsp2.getId(), vsp2.getVendorId(), vsp2.getVlmVersion(), vsp2.getFeatureGroups(), USER1); + String actual = IOUtils.toString(licenseArtifacts.getFileContent( + org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VNF_ARTIFACT_NAME_WITH_PATH), StandardCharsets.UTF_8); + + Assert.assertTrue(actual.contains(lkg21.getVersionUuId())); + Assert.assertTrue(actual.contains(ep21.getVersionUuId())); + Assert.assertFalse(actual.contains(lkg22Id)); + Assert.assertFalse(actual.contains(ep22Id)); + + + Assert.assertTrue(actual.contains("80")); + } + + + @Test + public void onlyAddChangedEntitiesToVendorArtifact() throws IOException { + Version vlmVersion = vspDetails.getVlmVersion(); + + EntitlementPoolEntity updatedEP = ep11; + String updatedNameEP = "updatedNameEP"; + updatedEP.setName(updatedNameEP); + LicenseKeyGroupEntity updatedLKG = new LicenseKeyGroupEntity(); + updatedLKG.setId(lkg11Id); + updatedLKG.setVendorLicenseModelId(lkg11.getVendorLicenseModelId()); + String updateDescLKG = "UpdateDescLKG"; + updatedLKG.setName(lkg11.getName()); + updatedLKG.setDescription(updateDescLKG); + + createThirdFinalVersionForVLMChangeEpLKGInSome(ep11.getVendorLicenseModelId(), updatedEP, updatedLKG); + licenseArtifacts = vendorLicenseArtifactsService.createLicenseArtifacts(vspDetails.getId(), vspDetails.getVendorId(), vlmVersion, vspDetails.getFeatureGroups(), USER1); + String actual = IOUtils.toString(licenseArtifacts.getFileContent( + org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_ARTIFACT_NAME_WITH_PATH), StandardCharsets.UTF_8); +// System.out.println("onlyAddChangedEntitiesToVendorArtifact = " + actual); + + int countUpdatedLKG = StringUtils.countMatches(actual, updateDescLKG); + Assert.assertEquals(countUpdatedLKG, 1); + + int countUpdatedEp = StringUtils.countMatches(actual, updatedNameEP); + Assert.assertEquals(countUpdatedEp, 1); + + int epOccurrences = StringUtils.countMatches(actual, "<entitlement-pool>"); + Assert.assertEquals(epOccurrences, 3); + } + + @BeforeClass + public void setUp() { + super.setUp(); + } +} + |