diff options
Diffstat (limited to 'openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp')
9 files changed, 694 insertions, 1085 deletions
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java index 5d9729de53..c005e9696f 100644 --- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/ArtifactTestUtils.java @@ -20,41 +20,6 @@ package org.openecomp.sdc.vendorlicense; -import org.openecomp.core.utilities.CommonMethods; -import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction; -import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther; -import org.openecomp.sdc.vendorlicense.dao.types.EntitlementMetric; -import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity; -import org.openecomp.sdc.vendorlicense.dao.types.EntitlementTime; -import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyType; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm; -import org.openecomp.sdc.vendorlicense.dao.types.MultiChoiceOrOther; -import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope; -import org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit; -import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade; -import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacadeFactory; -import org.openecomp.sdc.vendorlicense.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.VersioningManagerFactory; -import org.openecomp.sdc.versioning.dao.types.Version; -import org.openecomp.sdc.versioning.types.VersionInfo; -import org.openecomp.sdc.versioning.types.VersionableEntityAction; -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; - /** * Created by Katyr on 29-May-16 */ diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java index 07fdeeeee8..0197dd9d28 100644 --- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/LimitTest.java @@ -20,17 +20,11 @@ package org.openecomp.sdc.vendorlicense; -import static org.mockito.Matchers.anyObject; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.verify; - import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.mockito.Spy; import org.openecomp.sdc.common.errors.CoreException; -import org.openecomp.sdc.logging.api.Logger; -import org.openecomp.sdc.logging.api.LoggerFactory; import org.openecomp.sdc.vendorlicense.dao.LimitDao; import org.openecomp.sdc.vendorlicense.dao.types.AggregationFunction; import org.openecomp.sdc.vendorlicense.dao.types.LimitEntity; @@ -45,19 +39,19 @@ import org.testng.Assert; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; -import java.lang.reflect.Field; -import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.List; -public class LimitTest { +import static org.mockito.Matchers.anyObject; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.verify; - private final Logger log = (Logger) LoggerFactory.getLogger(this.getClass().getName()); +public class LimitTest { - private final String USER1 = "limitTestUser1"; - private final String LT1_NAME = "LT1 name"; + private final String USER1 = "limitTestUser1"; + private final String LT1_NAME = "LT1 name"; private static final String VLM_ID = "VLM_ID"; private static final Version VERSION = new Version(0, 1); @@ -76,8 +70,8 @@ public class LimitTest { private VendorLicenseManagerImpl vendorLicenseManagerImpl; public static LimitEntity createLimitEntity(String name, LimitType type, String description, - Version version, String metric, - AggregationFunction aggregationFunction, int unit, + Version version, String metric, + AggregationFunction aggregationFunction, int unit, String time) { LimitEntity limitEntity = new LimitEntity(); limitEntity.setName(name); @@ -92,22 +86,22 @@ public class LimitTest { } @BeforeMethod - public void setUp() { + public void setUp() throws Exception { MockitoAnnotations.initMocks(this); } @Test public void testUpdateLimit() { Version version = new Version(); - LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version, - "Core",AggregationFunction.Average,10,"Hour"); - LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version, - "Tokens",AggregationFunction.Peak,12,"Month"); + LimitEntity limitEntity1 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version, + "Core", AggregationFunction.Average, 10, "Hour"); + LimitEntity limitEntity2 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version, + "Tokens", AggregationFunction.Peak, 12, "Month"); VersionInfo info = new VersionInfo(); info.getViewableVersions().add(version); info.setActiveVersion(version); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); + /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/ doReturn(true).when(limitDao).isLimitPresent(anyObject()); doReturn(limitEntity1).when(limitDao).get(anyObject()); @@ -116,27 +110,28 @@ public class LimitTest { limitEntityList.add(limitEntity2); limitEntity1.setId("1234"); limitEntity2.setId("1234"); - doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(),anyObject(), - anyObject(),anyObject()); + doReturn(limitEntityList).when(vendorLicenseFacade) + .listLimits(anyObject(), anyObject(), anyObject()); - vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1); + vendorLicenseManagerImpl.updateLimit(limitEntity2); - verify(vendorLicenseFacade).updateLimit(anyObject(), anyObject()); + verify(vendorLicenseFacade).updateLimit(anyObject()); } @Test public void testUpdateLimitErrorWithSameNameType() { try { Version version = new Version(); - LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version, - "Core",AggregationFunction.Average,10,"Hour"); - LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version, - "Tokens",AggregationFunction.Peak,12,"Month"); + LimitEntity limitEntity1 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version, + "Core", AggregationFunction.Average, 10, "Hour"); + LimitEntity limitEntity2 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version, + "Tokens", AggregationFunction.Peak, 12, "Month"); VersionInfo info = new VersionInfo(); info.getViewableVersions().add(version); info.setActiveVersion(version); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); +/* doReturn(info).when(vendorLicenseFacade) + .getVersionInfo(anyObject(), anyObject(), anyObject());*/ doReturn(limitEntity1).when(limitDao).get(anyObject()); List<LimitEntity> limitEntityList = new ArrayList<>(); @@ -144,13 +139,12 @@ public class LimitTest { limitEntityList.add(limitEntity2); limitEntity1.setId("1234"); limitEntity2.setId("9632"); - doReturn(limitEntityList).when(vendorLicenseFacade).listLimits(anyObject(),anyObject(), - anyObject(),anyObject()); + doReturn(limitEntityList).when(vendorLicenseFacade) + .listLimits(anyObject(), anyObject(), anyObject()); - vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1); + vendorLicenseManagerImpl.updateLimit(limitEntity2); Assert.fail(); } catch (CoreException exception) { - log.debug("",exception); Assert.assertEquals(exception.code().id(), VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND); } @@ -159,13 +153,13 @@ public class LimitTest { @Test public void testDeleteLimit() { Version version = new Version(); - LimitEntity limitEntity = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version, - "Core",AggregationFunction.Average,10,"Hour"); + LimitEntity limitEntity = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version, + "Core", AggregationFunction.Average, 10, "Hour"); VersionInfo info = new VersionInfo(); info.getViewableVersions().add(version); info.setActiveVersion(version); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); + /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/ doReturn(true).when(limitDao).isLimitPresent(anyObject()); doReturn(limitEntity).when(limitDao).get(anyObject()); @@ -173,27 +167,28 @@ public class LimitTest { limitEntityList.add(limitEntity); limitEntity.setId("1234"); - vendorLicenseManagerImpl.deleteLimit(limitEntity,LT1_NAME); + vendorLicenseManagerImpl.deleteLimit(limitEntity); - verify(vendorLicenseManagerImpl).deleteLimit(anyObject(), anyObject()); + verify(vendorLicenseManagerImpl).deleteLimit(anyObject()); } @Test public void testUpdateLimitErrorWithInvalidId() { try { Version version = new Version(); - LimitEntity limitEntity1 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version, - "Core",AggregationFunction.Average,10,"Hour"); - LimitEntity limitEntity2 = createLimitEntity(LT1_NAME,LimitType.Vendor,"string",version, - "Tokens",AggregationFunction.Peak,12,"Month"); + LimitEntity limitEntity1 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version, + "Core", AggregationFunction.Average, 10, "Hour"); + LimitEntity limitEntity2 = createLimitEntity(LT1_NAME, LimitType.Vendor, "string", version, + "Tokens", AggregationFunction.Peak, 12, "Month"); VersionInfo info = new VersionInfo(); info.getViewableVersions().add(version); info.setActiveVersion(version); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); +/* doReturn(info).when(vendorLicenseFacade) + .getVersionInfo(anyObject(), anyObject(), anyObject());*/ doReturn(null).when(limitDao).get(anyObject()); - vendorLicenseManagerImpl.updateLimit(limitEntity2,USER1); + vendorLicenseManagerImpl.updateLimit(limitEntity2); Assert.fail(); } catch (CoreException exception) { Assert.assertEquals(exception.code().id(), @@ -206,14 +201,14 @@ public class LimitTest { doReturn(Arrays.asList( createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID), createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT2_ID))) - .when(vendorLicenseFacade).listLimits(VLM_ID, VERSION, EPLKG_ID, USER1); + .when(vendorLicenseFacade).listLimits(VLM_ID, VERSION, EPLKG_ID); final Collection<LimitEntity> limits = - vendorLicenseManagerImpl.listLimits(VLM_ID, VERSION, EPLKG_ID, USER1); + vendorLicenseManagerImpl.listLimits(VLM_ID, VERSION, EPLKG_ID); Assert.assertEquals(limits.size(), 2); for (LimitEntity limit : limits) { Assert.assertEquals(limit.getName(), - LIMIT1_ID.equals(limit.getId()) ? LIMIT1_ID+" name" : LIMIT2_ID+" name" ); + LIMIT1_ID.equals(limit.getId()) ? LIMIT1_ID + " name" : LIMIT2_ID + " name"); } } @@ -224,10 +219,10 @@ public class LimitTest { info.getViewableVersions().add(VERSION); info.setActiveVersion(VERSION); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); + /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/ - vendorLicenseManagerImpl.createLimit(expected, USER1); - verify(vendorLicenseFacade).createLimit(expected,USER1); + vendorLicenseManagerImpl.createLimit(expected); + verify(vendorLicenseFacade).createLimit(expected); } @Test @@ -241,20 +236,19 @@ public class LimitTest { List<LimitEntity> vfcImageList = new ArrayList<LimitEntity>(); vfcImageList.add(expectedDiffName); - doReturn(vfcImageList).when(vendorLicenseFacade).listLimits(anyObject(), anyObject(), anyObject(), - anyObject()); + doReturn(vfcImageList).when(vendorLicenseFacade) + .listLimits(anyObject(), anyObject(), anyObject()); VersionInfo info = new VersionInfo(); info.getViewableVersions().add(VERSION); info.setActiveVersion(VERSION); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); +/* doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/ try { - vendorLicenseManagerImpl.createLimit(expected, USER1); + vendorLicenseManagerImpl.createLimit(expected); Assert.fail(); - } - catch (CoreException ex) { + } catch (CoreException ex) { Assert.assertEquals(ex.code().id(), VendorLicenseErrorCodes.DUPLICATE_LIMIT_NAME_NOT_ALLOWED); } @@ -267,13 +261,14 @@ public class LimitTest { info.getViewableVersions().add(VERSION); info.setActiveVersion(VERSION); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); + /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/ try { - vendorLicenseManagerImpl.getLimit(limit , USER1); + vendorLicenseManagerImpl.getLimit(limit); Assert.fail(); } catch (CoreException exception) { - Assert.assertEquals(exception.code().id(), VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND); + Assert.assertEquals(exception.code().id(), + VersioningErrorCodes.VERSIONABLE_SUB_ENTITY_NOT_FOUND); } } @@ -293,10 +288,10 @@ public class LimitTest { info.getViewableVersions().add(VERSION); info.setActiveVersion(VERSION); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); + /*doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(), anyObject(), anyObject());*/ LimitEntity actual = createLimit(VLM_ID, VERSION, EPLKG_ID, LIMIT1_ID); - vendorLicenseManagerImpl.getLimit(actual, USER1); + vendorLicenseManagerImpl.getLimit(actual); Assert.assertEquals(actual.getId(), expected.getId()); Assert.assertEquals(actual.getName(), expected.getName()); Assert.assertEquals(actual.getUnit(), expected.getUnit()); diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java index ab6262d8ca..e3719ab515 100644 --- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseFacadeImplTest.java @@ -1,39 +1,5 @@ package org.openecomp.sdc.vendorlicense; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.mockito.Spy; -import org.openecomp.sdc.common.errors.CoreException; -import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao; -import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao; -import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao; -import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao; -import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao; -import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity; -import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity; -import org.openecomp.sdc.vendorlicense.facade.impl.VendorLicenseFacadeImpl; -import org.openecomp.sdc.versioning.VersioningManager; -import org.openecomp.sdc.versioning.dao.types.Version; -import org.openecomp.sdc.versioning.types.VersionInfo; -import org.testng.Assert; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.Test; - -import java.lang.reflect.Field; -import java.lang.reflect.Modifier; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - -import static org.mockito.Matchers.anyObject; -import static org.mockito.Mockito.doReturn; -import static org.openecomp.sdc.vendorlicense.errors.UncompletedVendorLicenseModelErrorType.SUBMIT_UNCOMPLETED_VLM_MSG_FG_MISSING_EP; -import static org.openecomp.sdc.vendorlicense.errors.UncompletedVendorLicenseModelErrorType.SUBMIT_UNCOMPLETED_VLM_MSG_LA_MISSING_FG; - /** * This test just verifies Feature Group Get and List APIs. */ diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/EntitlementPoolTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/EntitlementPoolTest.java index 178d05e6c8..57d22544ad 100644 --- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/EntitlementPoolTest.java +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/EntitlementPoolTest.java @@ -28,12 +28,16 @@ import org.mockito.Spy; import org.openecomp.sdc.common.errors.CoreException; import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao; import org.openecomp.sdc.vendorlicense.dao.LimitDao; -import org.openecomp.sdc.vendorlicense.dao.types.*; +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.MultiChoiceOrOther; +import org.openecomp.sdc.vendorlicense.dao.types.OperationalScope; +import org.openecomp.sdc.vendorlicense.dao.types.ThresholdUnit; import org.openecomp.sdc.vendorlicense.errors.VendorLicenseErrorCodes; import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade; import org.openecomp.sdc.versioning.dao.types.Version; -import org.openecomp.sdc.versioning.types.VersionInfo; -import org.openecomp.sdc.versioning.types.VersionableEntityAction; import org.testng.Assert; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; @@ -41,7 +45,6 @@ import org.testng.annotations.Test; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; -import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashSet; @@ -54,353 +57,323 @@ import static org.mockito.Mockito.verify; public class EntitlementPoolTest { - //JUnit Test Cases using Mockito - private final String USER1 = "epTestUser1"; - private final String EP1_NAME = "EP1 name"; - private final String EP2_NAME = "EP2 name"; - private final String LT1_NAME = "LT1 name"; - private static String vlm1_id = "vlm1_id"; - private static String ep1_id = "ep1_id"; - private static String ep2_id = "ep2_id"; - public static final Version VERSION01 = new Version(0, 1); - - @Mock - private VendorLicenseFacade vendorLicenseFacade; - - @Mock - private EntitlementPoolDao entitlementPoolDao; - @Mock - private LimitDao limitDao; - - @InjectMocks - @Spy - private VendorLicenseManagerImpl vendorLicenseManagerImpl; - - public EntitlementPoolEntity createEntitlementPool(String vlmId, Version version,String id, - String name, String desc, int threshold, - ThresholdUnit thresholdUnit, - EntitlementMetric entitlementMetricChoice, - String entitlementMetricOther, - String increments, - AggregationFunction aggregationFunctionChoice, - String aggregationFunctionOther, - Set<OperationalScope> operationalScopeChoices, - String operationalScopeOther, - EntitlementTime timeChoice, - String timeOther, String sku) { - EntitlementPoolEntity entitlementPool = new EntitlementPoolEntity(); - entitlementPool.setVendorLicenseModelId(vlmId); - entitlementPool.setId(id); - entitlementPool.setVersion(version); - entitlementPool.setName(name); - entitlementPool.setDescription(desc); - entitlementPool.setThresholdValue(threshold); - entitlementPool.setThresholdUnit(thresholdUnit); - entitlementPool.setIncrements(increments); - entitlementPool.setOperationalScope( - new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther)); - return entitlementPool; - } - - @BeforeMethod - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - } + //JUnit Test Cases using Mockito + private final String USER1 = "epTestUser1"; + private final String EP1_NAME = "EP1 name"; + private final String EP2_NAME = "EP2 name"; + private final String LT1_NAME = "LT1 name"; + private static String vlm1_id = "vlm1_id"; + private static String ep1_id = "ep1_id"; + private static String ep2_id = "ep2_id"; + public static final Version VERSION01 = new Version(0, 1); + + @Mock + private VendorLicenseFacade vendorLicenseFacade; + + @Mock + private EntitlementPoolDao entitlementPoolDao; + @Mock + private LimitDao limitDao; + + @InjectMocks + @Spy + private VendorLicenseManagerImpl vendorLicenseManagerImpl; + + public EntitlementPoolEntity createEntitlementPool(String vlmId, Version version, String id, + String name, String desc, int threshold, + ThresholdUnit thresholdUnit, + EntitlementMetric entitlementMetricChoice, + String entitlementMetricOther, + String increments, + AggregationFunction aggregationFunctionChoice, + String aggregationFunctionOther, + Set<OperationalScope> operationalScopeChoices, + String operationalScopeOther, + EntitlementTime timeChoice, + String timeOther, String sku) { + EntitlementPoolEntity entitlementPool = new EntitlementPoolEntity(); + entitlementPool.setVendorLicenseModelId(vlmId); + entitlementPool.setId(id); + entitlementPool.setVersion(version); + entitlementPool.setName(name); + entitlementPool.setDescription(desc); + entitlementPool.setThresholdValue(threshold); + entitlementPool.setThresholdUnit(thresholdUnit); + entitlementPool.setIncrements(increments); + entitlementPool.setOperationalScope( + new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther)); + return entitlementPool; + } - @Test - public void createTest() { - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity ep2 = - createEntitlementPool("vlm1Id", null, ep1_id,EP1_NAME, "EP2 dec", 70, ThresholdUnit - .Absolute, - EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - ep2.setStartDate(LocalDate.now().format(formatter)); - ep2.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter)); + @BeforeMethod + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + } - vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1); - verify(vendorLicenseFacade).createEntitlementPool(ep2,USER1); + @Test + public void createTest() { + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool("vlm1Id", null, ep1_id, EP1_NAME, "EP2 dec", 70, ThresholdUnit + .Absolute, + EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + ep2.setStartDate(LocalDate.now().format(formatter)); + ep2.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter)); - } + vendorLicenseManagerImpl.createEntitlementPool(ep2); + verify(vendorLicenseFacade).createEntitlementPool(ep2); - @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " + - "license model with id vlm1_id has invalid date range.") - public void createWithInvalidStartExpiryDateTest() { + } - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity ep2 = - createEntitlementPool("vlm2Id", null, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit.Absolute, - EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - ep2.setStartDate(LocalDate.now().format(formatter)); - ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); - ep2.setVendorLicenseModelId(vlm1_id); - vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId(); - Assert.fail(); + @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " + + "license model with id vlm1_id has invalid date range.") + public void createWithInvalidStartExpiryDateTest() { - } + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool("vlm2Id", null, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, + EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + ep2.setStartDate(LocalDate.now().format(formatter)); + ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); + ep2.setVendorLicenseModelId(vlm1_id); + vendorLicenseManagerImpl.createEntitlementPool(ep2).getId(); + Assert.fail(); - @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " + - "license model with id vlm1_id has invalid date range.") - public void createWithoutStartDateTest() { + } - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity ep2 = - createEntitlementPool("vlm3Id", null, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit.Absolute, - EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter)); - ep2.setVendorLicenseModelId(vlm1_id); - vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId(); - Assert.fail(); + @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " + + "license model with id vlm1_id has invalid date range.") + public void createWithoutStartDateTest() { - } + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool("vlm3Id", null, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, + EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter)); + ep2.setVendorLicenseModelId(vlm1_id); + vendorLicenseManagerImpl.createEntitlementPool(ep2).getId(); + Assert.fail(); - @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " + - "license model with id vlm1_id has invalid date range.") - public void createWithSameStartExpiryDateTest() { + } - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity ep2 = - createEntitlementPool("vlm4Id", null, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit.Absolute, - EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - ep2.setStartDate(LocalDate.now().format(formatter)); - ep2.setExpiryDate(LocalDate.now().format(formatter)); - ep2.setVendorLicenseModelId(vlm1_id); - vendorLicenseManagerImpl.createEntitlementPool(ep2, USER1).getId(); - Assert.fail(); - } + @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " + + "license model with id vlm1_id has invalid date range.") + public void createWithSameStartExpiryDateTest() { - @Test - public void testUpdate() { - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity ep2 = - createEntitlementPool(vlm1_id, VERSION01, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit - .Absolute, - EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - ep2.setStartDate(LocalDate.now().minusDays(3L).format(formatter)); - ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool("vlm4Id", null, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, + EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + ep2.setStartDate(LocalDate.now().format(formatter)); + ep2.setExpiryDate(LocalDate.now().format(formatter)); + ep2.setVendorLicenseModelId(vlm1_id); + vendorLicenseManagerImpl.createEntitlementPool(ep2).getId(); + Assert.fail(); + } - VersionInfo info = new VersionInfo(); - info.getViewableVersions().add(VERSION01); - info.setActiveVersion(VERSION01); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); + @Test + public void testUpdate() { + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool(vlm1_id, VERSION01, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit + .Absolute, + EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + ep2.setStartDate(LocalDate.now().minusDays(3L).format(formatter)); + ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); - vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1); - verify(vendorLicenseFacade).updateEntitlementPool(ep2,USER1); - verify(vendorLicenseFacade).updateVlmLastModificationTime(vlm1_id,VERSION01); - } + vendorLicenseManagerImpl.updateEntitlementPool(ep2); + } - @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " + - "license model with id vlm1_id has invalid date range.") - public void updateWithInvalidStartExpiryDateTest() { + @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Vendor " + + "license model with id vlm1_id has invalid date range.") + public void updateWithInvalidStartExpiryDateTest() { - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity ep2 = - createEntitlementPool("vlm2Id", null, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit.Absolute, - EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - ep2.setStartDate(LocalDate.now().format(formatter)); - ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); - ep2.setVendorLicenseModelId(vlm1_id); - vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1); - Assert.fail(); + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool("vlm2Id", null, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, + EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + ep2.setStartDate(LocalDate.now().format(formatter)); + ep2.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); + ep2.setVendorLicenseModelId(vlm1_id); + vendorLicenseManagerImpl.updateEntitlementPool(ep2); + Assert.fail(); - } + } - @Test - public void updateWithoutStartDateTest() { - try { + @Test + public void updateWithoutStartDateTest() { + try { - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity ep2 = - createEntitlementPool("vlm3Id", null, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit.Absolute, - EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter)); - vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1); - Assert.fail(); - } catch (CoreException exception) { - Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); - } + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool("vlm3Id", null, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, + EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, + null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + ep2.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter)); + vendorLicenseManagerImpl.updateEntitlementPool(ep2); + Assert.fail(); + } catch (CoreException exception) { + Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); } + } - @Test - public void updateWithSameStartExpiryDateTest() { - try { + @Test + public void updateWithSameStartExpiryDateTest() { + try { - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity ep2 = - createEntitlementPool("vlm4Id", null, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit.Absolute, - EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - ep2.setStartDate(LocalDate.now().format(formatter)); - ep2.setExpiryDate(LocalDate.now().format(formatter)); - vendorLicenseManagerImpl.updateEntitlementPool(ep2, USER1); - Assert.fail(); - } catch (CoreException exception) { - Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); - } + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); + EntitlementPoolEntity ep2 = + createEntitlementPool("vlm4Id", null, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, + EntitlementMetric.Other, "exception metric2", "inc2", AggregationFunction.Average, + null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + ep2.setStartDate(LocalDate.now().format(formatter)); + ep2.setExpiryDate(LocalDate.now().format(formatter)); + vendorLicenseManagerImpl.updateEntitlementPool(ep2); + Assert.fail(); + } catch (CoreException exception) { + Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); } + } - @Test - public void deleteEntitlementPoolTest() { - - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - versionInfo.setLockingUser(USER1); - ArrayList<Version> viewable = new ArrayList<Version>(); - viewable.add(VERSION01); - versionInfo.setViewableVersions(viewable); - - doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id, - VersionableEntityAction.Write, USER1); - - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); - - EntitlementPoolEntity entitlementPool = - createEntitlementPool(vlm1_id,VERSION01, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit.Absolute,EntitlementMetric.Other, "exception metric2", "inc2", - AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); - entitlementPool.setStartDate(LocalDate.now().format(formatter)); - entitlementPool.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter)); - - doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject()); - - doNothing().when(vendorLicenseManagerImpl).deleteChildLimits(vlm1_id,VERSION01,ep1_id,USER1); - - doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(anyObject(),anyObject(), - anyObject(),anyObject()); + @Test + public void deleteEntitlementPoolTest() { + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); - vendorLicenseManagerImpl.deleteEntitlementPool(entitlementPool, USER1); + EntitlementPoolEntity entitlementPool = + createEntitlementPool(vlm1_id, VERSION01, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, EntitlementMetric.Other, "exception metric2", "inc2", + AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); + entitlementPool.setStartDate(LocalDate.now().format(formatter)); + entitlementPool.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter)); - verify(entitlementPoolDao).delete(entitlementPool); - verify(vendorLicenseFacade).updateVlmLastModificationTime(vlm1_id,VERSION01); + doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject()); - } + doNothing().when(vendorLicenseManagerImpl).deleteChildLimits(vlm1_id, VERSION01, ep1_id); - @Test - public void testGetEntitlementPool(){ + doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(anyObject(), anyObject(), + anyObject(), anyObject()); - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - versionInfo.setLockingUser(USER1); - ArrayList<Version> viewable = new ArrayList<Version>(); - viewable.add(VERSION01); - versionInfo.setViewableVersions(viewable); - versionInfo.setActiveVersion(VERSION01); + vendorLicenseManagerImpl.deleteEntitlementPool(entitlementPool); - doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id, - VersionableEntityAction.Read, USER1); + verify(entitlementPoolDao).delete(entitlementPool); + } - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); + @Test + public void testGetEntitlementPool() { + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); - EntitlementPoolEntity entitlementPool = - createEntitlementPool(vlm1_id,VERSION01, ep1_id,EP1_NAME, "EP2 dec", 70, - ThresholdUnit.Absolute,EntitlementMetric.Other, "exception metric2", "inc2", - AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'"); + EntitlementPoolEntity entitlementPool = + createEntitlementPool(vlm1_id, VERSION01, ep1_id, EP1_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, EntitlementMetric.Other, "exception metric2", "inc2", + AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy'T'HH:mm:ss'Z'"); - entitlementPool.setStartDate(LocalDateTime.now().format(formatter)); - entitlementPool.setExpiryDate(LocalDateTime.now().plusDays(1L).format(formatter)); + entitlementPool.setStartDate(LocalDateTime.now().format(formatter)); + entitlementPool.setExpiryDate(LocalDateTime.now().plusDays(1L).format(formatter)); - doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject()); + doReturn(entitlementPool).when(entitlementPoolDao).get(anyObject()); - EntitlementPoolEntity retrived = vendorLicenseManagerImpl.getEntitlementPool - (entitlementPool,USER1); + EntitlementPoolEntity retrived = vendorLicenseManagerImpl.getEntitlementPool(entitlementPool); - Assert.assertEquals(retrived.getId(),entitlementPool.getId()); - Assert.assertEquals(retrived.getVendorLicenseModelId(),entitlementPool.getVendorLicenseModelId()); - Assert.assertEquals(retrived.getVersion(),entitlementPool.getVersion()); - } + Assert.assertEquals(retrived.getId(), entitlementPool.getId()); + Assert.assertEquals(retrived.getVendorLicenseModelId(), + entitlementPool.getVendorLicenseModelId()); + Assert.assertEquals(retrived.getVersion(), entitlementPool.getVersion()); + } - @Test - public void testListEntitlmentPool(){ + @Test + public void testListEntitlmentPool() { - Set<OperationalScope> opScopeChoices; - opScopeChoices = new HashSet<>(); - opScopeChoices.add(OperationalScope.Core); - opScopeChoices.add(OperationalScope.CPU); - opScopeChoices.add(OperationalScope.Network_Wide); + Set<OperationalScope> opScopeChoices; + opScopeChoices = new HashSet<>(); + opScopeChoices.add(OperationalScope.Core); + opScopeChoices.add(OperationalScope.CPU); + opScopeChoices.add(OperationalScope.Network_Wide); - doReturn(Arrays.asList( - createEntitlementPool(vlm1_id,VERSION01, ep1_id, EP1_NAME,"EP1 dec", 70, - ThresholdUnit.Absolute,EntitlementMetric.Other, "exception metric1", - "inc1", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time1", "sku1"), - createEntitlementPool(vlm1_id,VERSION01, ep2_id, EP2_NAME,"EP2 dec", 70, - ThresholdUnit.Absolute,EntitlementMetric.Other, "exception metric2", - "inc2", AggregationFunction.Average, null, - opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"))) - .when(vendorLicenseFacade).listEntitlementPools(vlm1_id, VERSION01, USER1); - - Collection<EntitlementPoolEntity> EPs = - vendorLicenseManagerImpl.listEntitlementPools(vlm1_id, VERSION01, USER1); - - verify(vendorLicenseFacade).listEntitlementPools(vlm1_id, VERSION01, USER1); - Assert.assertEquals(EPs.size(), 2); - EPs.forEach(ep -> Assert.assertTrue(ep.getId().matches(ep1_id + "|" + ep2_id))); - } + doReturn(Arrays.asList( + createEntitlementPool(vlm1_id, VERSION01, ep1_id, EP1_NAME, "EP1 dec", 70, + ThresholdUnit.Absolute, EntitlementMetric.Other, "exception metric1", + "inc1", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time1", "sku1"), + createEntitlementPool(vlm1_id, VERSION01, ep2_id, EP2_NAME, "EP2 dec", 70, + ThresholdUnit.Absolute, EntitlementMetric.Other, "exception metric2", + "inc2", AggregationFunction.Average, null, + opScopeChoices, null, EntitlementTime.Other, "time2", "sku2"))) + .when(vendorLicenseFacade).listEntitlementPools(vlm1_id, VERSION01); + + Collection<EntitlementPoolEntity> EPs = + vendorLicenseManagerImpl.listEntitlementPools(vlm1_id, VERSION01); + + verify(vendorLicenseFacade).listEntitlementPools(vlm1_id, VERSION01); + Assert.assertEquals(EPs.size(), 2); + EPs.forEach(ep -> Assert.assertTrue(ep.getId().matches(ep1_id + "|" + ep2_id))); + } /* @Test diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/FeatureGroupTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/FeatureGroupTest.java index dd3560615e..b9eacc3e6f 100644 --- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/FeatureGroupTest.java +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/FeatureGroupTest.java @@ -21,35 +21,27 @@ package org.openecomp.sdc.vendorlicense.impl; -import static org.mockito.Matchers.anyObject; -import static org.mockito.Mockito.doReturn; - import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.mockito.Spy; -import org.openecomp.sdc.activityLog.ActivityLogManager; import org.openecomp.sdc.vendorlicense.VendorLicenseConstants; -import org.openecomp.sdc.vendorlicense.dao.*; -import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther; +import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao; +import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao; +import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao; +import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao; +import org.openecomp.sdc.vendorlicense.dao.LimitDao; +import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao; import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity; import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity; import org.openecomp.sdc.vendorlicense.dao.types.LicenseKeyGroupEntity; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm; import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade; -import org.openecomp.sdc.vendorlicense.facade.impl.VendorLicenseFacadeImpl; -import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl; import org.openecomp.sdc.versioning.VersioningManager; import org.openecomp.sdc.versioning.dao.types.Version; -import org.openecomp.sdc.versioning.types.VersionInfo; -import org.openecomp.sdc.versioning.types.VersionableEntityAction; import org.testng.Assert; -import org.testng.AssertJUnit.*; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; -import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashSet; @@ -58,7 +50,6 @@ import java.util.Set; import static org.mockito.Matchers.anyObject; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; /** @@ -66,272 +57,254 @@ import static org.mockito.Mockito.verify; */ public class FeatureGroupTest { - //JUnit Test Cases using Mockito - private static final Version VERSION01 = new Version(0, 1); - private static final Version VERSION10 = new Version(1, 0); - private final String FG1_NAME = "FG1 name"; - private static final String USER1 = "TestUser1"; - private static final String USER2 = "TestUser2"; - - private static String vlm1_id = "vlm1_id"; - private static String vlm2_id = "vlm2_id"; - private static String lkg1_id = "lkg1_id"; - private static String lkg2_id = "lkg2_id"; - private static String fg1_id = "fg1_id"; - private static String fg2_id = "fg2_id"; - private static String ep1_id = "ep1_id"; - private static String ep2_id = "ep2_id"; - - @Mock - private VendorLicenseFacade vendorLicenseFacadeMcok; - - @Mock - private LimitDao limitDaoMcok; - @Mock - private ActivityLogManager activityLogManagerMcok; - - @Mock - private VendorLicenseModelDao vendorLicenseModelDao; - - @Mock - private LicenseAgreementDao licenseAgreementDao; - - @Mock - private FeatureGroupDao featureGroupDao; - - @Mock - private EntitlementPoolDao entitlementPoolDao; - - @Mock - private LicenseKeyGroupDao licenseKeyGroupDao; - - @Mock - private VersioningManager versioningManager; - - @InjectMocks - @Spy - private VendorLicenseManagerImpl vendorLicenseManagerImpl; - - public FeatureGroupEntity updateFeatureGroup(String vlmId, Version version, String id, String name, String desc, - String partNumber, String manufacturerReferenceNumber, Set<String> - licenseKeyGroupIds, Set<String> entitlementPoolIds, Set<String> - referencingLicenseAgreements){ - FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlmId, version, id); - featureGroup.setVendorLicenseModelId(vlmId); - featureGroup.setVersion(version); - featureGroup.setId(id); - featureGroup.setName(name); - featureGroup.setDescription(desc); - featureGroup.setPartNumber(partNumber); - //featureGroup.setManufacturerReferenceNumber(manufacturerReferenceNumber); - featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds); - featureGroup.setEntitlementPoolIds(entitlementPoolIds); - featureGroup.setReferencingLicenseAgreements(referencingLicenseAgreements); - - return featureGroup; - } - - @BeforeMethod - public void setUp() { - MockitoAnnotations.initMocks(this); - } - - @Test - public void testUpdate(){ - Set<String> licenseKeyGroupIds; - licenseKeyGroupIds = new HashSet<>(); - licenseKeyGroupIds.add("lkg1"); - - Set<String> entitlementPoolIds; - entitlementPoolIds = new HashSet<>(); - entitlementPoolIds.add("ep1"); - - Set<String> referencingLicenseAgreements; - referencingLicenseAgreements = new HashSet<>(); - referencingLicenseAgreements.add("la1"); - - FeatureGroupEntity featureGroupEntity = updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc", + //JUnit Test Cases using Mockito + private static final Version VERSION01 = new Version(0, 1); + private static final Version VERSION10 = new Version(1, 0); + private final String FG1_NAME = "FG1 name"; + private static final String USER1 = "TestUser1"; + private static final String USER2 = "TestUser2"; + + private static String vlm1_id = "vlm1_id"; + private static String vlm2_id = "vlm2_id"; + private static String lkg1_id = "lkg1_id"; + private static String lkg2_id = "lkg2_id"; + private static String fg1_id = "fg1_id"; + private static String fg2_id = "fg2_id"; + private static String ep1_id = "ep1_id"; + private static String ep2_id = "ep2_id"; + + @Mock + private VendorLicenseFacade vendorLicenseFacadeMcok; + + @Mock + private LimitDao limitDaoMcok; + + @Mock + private VendorLicenseModelDao vendorLicenseModelDao; + + @Mock + private LicenseAgreementDao licenseAgreementDao; + + @Mock + private FeatureGroupDao featureGroupDao; + + @Mock + private EntitlementPoolDao entitlementPoolDao; + + @Mock + private LicenseKeyGroupDao licenseKeyGroupDao; + + @Mock + private VersioningManager versioningManager; + + @InjectMocks + @Spy + private VendorLicenseManagerImpl vendorLicenseManagerImpl; + + public FeatureGroupEntity updateFeatureGroup(String vlmId, Version version, String id, + String name, String desc, + String partNumber, + String manufacturerReferenceNumber, Set<String> + licenseKeyGroupIds, + Set<String> entitlementPoolIds, Set<String> + referencingLicenseAgreements) { + FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlmId, version, id); + featureGroup.setVendorLicenseModelId(vlmId); + featureGroup.setVersion(version); + featureGroup.setId(id); + featureGroup.setName(name); + featureGroup.setDescription(desc); + featureGroup.setPartNumber(partNumber); + //featureGroup.setManufacturerReferenceNumber(manufacturerReferenceNumber); + featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds); + featureGroup.setEntitlementPoolIds(entitlementPoolIds); + featureGroup.setReferencingLicenseAgreements(referencingLicenseAgreements); + + return featureGroup; + } + + @BeforeMethod + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + } + + @Test + public void testUpdate() { + Set<String> licenseKeyGroupIds; + licenseKeyGroupIds = new HashSet<>(); + licenseKeyGroupIds.add("lkg1"); + + Set<String> entitlementPoolIds; + entitlementPoolIds = new HashSet<>(); + entitlementPoolIds.add("ep1"); + + Set<String> referencingLicenseAgreements; + referencingLicenseAgreements = new HashSet<>(); + referencingLicenseAgreements.add("la1"); + + FeatureGroupEntity featureGroupEntity = + updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc", "partNumber", "MRN", licenseKeyGroupIds, entitlementPoolIds, referencingLicenseAgreements); - doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject()); + doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject()); /*if(featureGroupEntity.getManufacturerReferenceNumber() != null) featureGroupDao.update(featureGroupEntity); verify(featureGroupDao).update(anyObject());*/ - } + } - @Test - public void testUpdateWithoutManufacturingReferenceNumber(){ - Set<String> licenseKeyGroupIds; - licenseKeyGroupIds = new HashSet<>(); - licenseKeyGroupIds.add("lkg1"); + @Test + public void testUpdateWithoutManufacturingReferenceNumber() { + Set<String> licenseKeyGroupIds; + licenseKeyGroupIds = new HashSet<>(); + licenseKeyGroupIds.add("lkg1"); - Set<String> entitlementPoolIds; - entitlementPoolIds = new HashSet<>(); - entitlementPoolIds.add("ep1"); + Set<String> entitlementPoolIds; + entitlementPoolIds = new HashSet<>(); + entitlementPoolIds.add("ep1"); - Set<String> referencingLicenseAgreements; - referencingLicenseAgreements = new HashSet<>(); - referencingLicenseAgreements.add("la1"); + Set<String> referencingLicenseAgreements; + referencingLicenseAgreements = new HashSet<>(); + referencingLicenseAgreements.add("la1"); - FeatureGroupEntity featureGroupEntity = updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc", + FeatureGroupEntity featureGroupEntity = + updateFeatureGroup("vlmId", VERSION01, "fgId", FG1_NAME, "fg1 desc", "partNumber", null, licenseKeyGroupIds, entitlementPoolIds, referencingLicenseAgreements); - doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject()); + doReturn(featureGroupEntity).when(featureGroupDao).get(anyObject()); /*if(featureGroupEntity.getManufacturerReferenceNumber() != null) featureGroupDao.update(featureGroupEntity); verify(featureGroupDao, never()).update(anyObject());*/ - } - - @Test - public void testListFeatureGroups() { - doReturn(Arrays.asList( - createFeatureGroup(vlm1_id, VERSION01, fg1_id, "FG1", "FG1 desc", new HashSet<String>(), - new HashSet<String>()), - createFeatureGroup(vlm1_id, VERSION01, fg2_id, "FG2", "FG2 desc", new HashSet<String>(), - new HashSet<String>()))) - .when(vendorLicenseFacadeMcok).listFeatureGroups(vlm1_id, VERSION01, USER1); - - Collection<FeatureGroupEntity> FGs = - vendorLicenseManagerImpl.listFeatureGroups(vlm1_id, VERSION01, USER1); - - verify(vendorLicenseFacadeMcok).listFeatureGroups(vlm1_id, VERSION01, USER1); - Assert.assertEquals(FGs.size(), 2); - FGs.forEach(fg -> Assert.assertTrue(fg.getId().matches(fg1_id + "|" + fg2_id))); - } - - @Test - public void testCreateFeatureGroup() { - FeatureGroupEntity featureGroupEntity = new FeatureGroupEntity(vlm1_id,VERSION01, - fg1_id); - - doReturn(featureGroupEntity).when(vendorLicenseFacadeMcok).createFeatureGroup - (featureGroupEntity,USER1); + } + + @Test + public void testListFeatureGroups() { + doReturn(Arrays.asList( + createFeatureGroup(vlm1_id, VERSION01, fg1_id, "FG1", "FG1 desc", new HashSet<String>(), + new HashSet<String>()), + createFeatureGroup(vlm1_id, VERSION01, fg2_id, "FG2", "FG2 desc", new HashSet<String>(), + new HashSet<String>()))) + .when(vendorLicenseFacadeMcok).listFeatureGroups(vlm1_id, VERSION01); + + Collection<FeatureGroupEntity> FGs = + vendorLicenseManagerImpl.listFeatureGroups(vlm1_id, VERSION01); + + verify(vendorLicenseFacadeMcok).listFeatureGroups(vlm1_id, VERSION01); + Assert.assertEquals(FGs.size(), 2); + FGs.forEach(fg -> Assert.assertTrue(fg.getId().matches(fg1_id + "|" + fg2_id))); + } - vendorLicenseManagerImpl.createFeatureGroup(featureGroupEntity,USER1); - - verify(vendorLicenseFacadeMcok).createFeatureGroup(featureGroupEntity,USER1); - } - - - @Test - public void testUpdateFeatureGroup(){ - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - versionInfo.setLockingUser(USER1); - ArrayList<Version> viewable = new ArrayList<Version>(); - viewable.add(VERSION01); - versionInfo.setViewableVersions(viewable); - - doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id, - VersionableEntityAction.Write, USER1); - FeatureGroupEntity existingFG = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id); - - existingFG.setEntitlementPoolIds(new HashSet<String>()); - existingFG.setLicenseKeyGroupIds(new HashSet<String>()); - - doReturn(existingFG).when(featureGroupDao).get(existingFG); - - Set<String> removedEPs = new HashSet<>(); - Set<String> addedEPs = new HashSet<>(); - - addedEPs.add(ep1_id); - addedEPs.add(ep2_id); - EntitlementPoolEntity ep1 = new EntitlementPoolEntity(vlm1_id, VERSION01, ep1_id); - EntitlementPoolEntity ep2 = new EntitlementPoolEntity(vlm1_id, VERSION01, ep2_id); - doReturn(ep1).when(entitlementPoolDao).get(ep1); - doReturn(ep2).when(entitlementPoolDao).get(ep2); - - Set<String> removedLKGs = new HashSet<>(); - Set<String> addedLKGs = new HashSet<>(); - - addedLKGs.add(lkg1_id); - addedLKGs.add(lkg2_id); - LicenseKeyGroupEntity lkg1 = new LicenseKeyGroupEntity(vlm1_id, VERSION01, lkg1_id); - LicenseKeyGroupEntity lkg2 = new LicenseKeyGroupEntity(vlm1_id, VERSION01, lkg2_id); - doReturn(lkg1).when(licenseKeyGroupDao).get(lkg1); - doReturn(lkg2).when(licenseKeyGroupDao).get(lkg2); - - doNothing().when(vendorLicenseManagerImpl).updateUniqueName(anyObject(), anyObject(), - anyObject(),anyObject(), anyObject()); - - vendorLicenseManagerImpl.updateFeatureGroup(existingFG,addedLKGs,removedLKGs, addedEPs, - removedEPs, USER1); - - verify(vendorLicenseManagerImpl).addLicenseKeyGroupsToFeatureGroupsRef(addedLKGs, - existingFG); - verify(vendorLicenseManagerImpl).removeLicenseKeyGroupsToFeatureGroupsRef(removedLKGs, - existingFG); - verify(vendorLicenseManagerImpl).addEntitlementPoolsToFeatureGroupsRef(addedEPs,existingFG); - verify(vendorLicenseManagerImpl).removeEntitlementPoolsToFeatureGroupsRef(removedEPs, - existingFG); - - verify(featureGroupDao) - .updateFeatureGroup(existingFG,addedEPs,removedEPs, addedLKGs, removedLKGs); - verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id,VERSION01); - } - - - @Test - public void testGetFeatureGroup(){ - FeatureGroupEntity featureGroupEntity = new FeatureGroupEntity(vlm1_id,VERSION01,fg1_id); - vendorLicenseManagerImpl.getFeatureGroupModel(featureGroupEntity,USER1); - verify(vendorLicenseFacadeMcok).getFeatureGroupModel(featureGroupEntity,USER1); - } - - @Test - public void deleteFeatureGroupTest() { - - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - versionInfo.setLockingUser(USER1); - ArrayList<Version> viewable = new ArrayList<Version>(); - viewable.add(VERSION01); - versionInfo.setViewableVersions(viewable); - - doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id, - VersionableEntityAction.Write, USER1); - - FeatureGroupEntity existingFG = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id); - existingFG.setName("FG_name"); - existingFG.setLicenseKeyGroupIds(new HashSet<String>()); - existingFG.setEntitlementPoolIds(new HashSet<String>()); - existingFG.setLicenseKeyGroupIds(new HashSet<String>()); - - doReturn(existingFG).when(featureGroupDao).get(anyObject()); - - doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(VendorLicenseConstants - .UniqueValues.FEATURE_GROUP_NAME,vlm1_id,VERSION01.toString(),existingFG.getName()); - - vendorLicenseManagerImpl.deleteFeatureGroup(existingFG, USER1); - - verify(featureGroupDao).delete(existingFG); - verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id,VERSION01); - - verify(vendorLicenseManagerImpl).removeLicenseKeyGroupsToFeatureGroupsRef(existingFG - .getLicenseKeyGroupIds(),existingFG); - verify(vendorLicenseManagerImpl).removeEntitlementPoolsToFeatureGroupsRef(existingFG - .getEntitlementPoolIds(),existingFG); - verify(vendorLicenseManagerImpl).deleteUniqueName(VendorLicenseConstants - .UniqueValues.FEATURE_GROUP_NAME,vlm1_id,VERSION01.toString(),existingFG.getName()); - } - - private FeatureGroupEntity createFeatureGroup(String vendorId, Version version, String id, - String name, String description, - Set<String> entitlementPoolIds, - Set<String> licenseKeyGroupIds) { - FeatureGroupEntity featureGroup = new FeatureGroupEntity(); - featureGroup.setVendorLicenseModelId(vendorId); - featureGroup.setVersion(version); - featureGroup.setId(id); - featureGroup.setName(name); - featureGroup.setDescription(description); - featureGroup.setEntitlementPoolIds(entitlementPoolIds); - featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds); - return featureGroup; - } + @Test + public void testCreateFeatureGroup() { + FeatureGroupEntity featureGroupEntity = new FeatureGroupEntity(vlm1_id, VERSION01, + fg1_id); + + doReturn(featureGroupEntity).when(vendorLicenseFacadeMcok).createFeatureGroup + (featureGroupEntity); + + vendorLicenseManagerImpl.createFeatureGroup(featureGroupEntity); + + verify(vendorLicenseFacadeMcok).createFeatureGroup(featureGroupEntity); + } + + + @Test + public void testUpdateFeatureGroup() { + FeatureGroupEntity existingFG = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id); + + existingFG.setEntitlementPoolIds(new HashSet<String>()); + existingFG.setLicenseKeyGroupIds(new HashSet<String>()); + + doReturn(existingFG).when(featureGroupDao).get(existingFG); + + Set<String> removedEPs = new HashSet<>(); + Set<String> addedEPs = new HashSet<>(); + + addedEPs.add(ep1_id); + addedEPs.add(ep2_id); + EntitlementPoolEntity ep1 = new EntitlementPoolEntity(vlm1_id, VERSION01, ep1_id); + EntitlementPoolEntity ep2 = new EntitlementPoolEntity(vlm1_id, VERSION01, ep2_id); + doReturn(ep1).when(entitlementPoolDao).get(ep1); + doReturn(ep2).when(entitlementPoolDao).get(ep2); + + Set<String> removedLKGs = new HashSet<>(); + Set<String> addedLKGs = new HashSet<>(); + + addedLKGs.add(lkg1_id); + addedLKGs.add(lkg2_id); + LicenseKeyGroupEntity lkg1 = new LicenseKeyGroupEntity(vlm1_id, VERSION01, lkg1_id); + LicenseKeyGroupEntity lkg2 = new LicenseKeyGroupEntity(vlm1_id, VERSION01, lkg2_id); + doReturn(lkg1).when(licenseKeyGroupDao).get(lkg1); + doReturn(lkg2).when(licenseKeyGroupDao).get(lkg2); + + doNothing().when(vendorLicenseManagerImpl).updateUniqueName(anyObject(), anyObject(), + anyObject(), anyObject(), anyObject()); + + vendorLicenseManagerImpl.updateFeatureGroup(existingFG, addedLKGs, removedLKGs, addedEPs, + removedEPs); + + verify(vendorLicenseManagerImpl).addLicenseKeyGroupsToFeatureGroupsRef(addedLKGs, + existingFG); + verify(vendorLicenseManagerImpl).removeLicenseKeyGroupsToFeatureGroupsRef(removedLKGs, + existingFG); + verify(vendorLicenseManagerImpl).addEntitlementPoolsToFeatureGroupsRef(addedEPs, existingFG); + verify(vendorLicenseManagerImpl).removeEntitlementPoolsToFeatureGroupsRef(removedEPs, + existingFG); + + verify(featureGroupDao) + .updateFeatureGroup(existingFG, addedEPs, removedEPs, addedLKGs, removedLKGs); + } + + + @Test + public void testGetFeatureGroup() { + FeatureGroupEntity featureGroupEntity = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id); + vendorLicenseManagerImpl.getFeatureGroupModel(featureGroupEntity); + verify(vendorLicenseFacadeMcok).getFeatureGroupModel(featureGroupEntity); + } + + @Test + public void deleteFeatureGroupTest() { + + FeatureGroupEntity existingFG = new FeatureGroupEntity(vlm1_id, VERSION01, fg1_id); + existingFG.setName("FG_name"); + existingFG.setLicenseKeyGroupIds(new HashSet<String>()); + existingFG.setEntitlementPoolIds(new HashSet<String>()); + existingFG.setLicenseKeyGroupIds(new HashSet<String>()); + + doReturn(existingFG).when(featureGroupDao).get(anyObject()); + + doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(VendorLicenseConstants + .UniqueValues.FEATURE_GROUP_NAME, vlm1_id, VERSION01.toString(), existingFG.getName()); + + vendorLicenseManagerImpl.deleteFeatureGroup(existingFG); + + verify(featureGroupDao).delete(existingFG); + + verify(vendorLicenseManagerImpl).removeLicenseKeyGroupsToFeatureGroupsRef(existingFG + .getLicenseKeyGroupIds(), existingFG); + verify(vendorLicenseManagerImpl).removeEntitlementPoolsToFeatureGroupsRef(existingFG + .getEntitlementPoolIds(), existingFG); + verify(vendorLicenseManagerImpl).deleteUniqueName(VendorLicenseConstants + .UniqueValues.FEATURE_GROUP_NAME, vlm1_id, VERSION01.toString(), existingFG.getName()); + } + + private FeatureGroupEntity createFeatureGroup(String vendorId, Version version, String id, + String name, String description, + Set<String> entitlementPoolIds, + Set<String> licenseKeyGroupIds) { + FeatureGroupEntity featureGroup = new FeatureGroupEntity(); + featureGroup.setVendorLicenseModelId(vendorId); + featureGroup.setVersion(version); + featureGroup.setId(id); + featureGroup.setName(name); + featureGroup.setDescription(description); + featureGroup.setEntitlementPoolIds(entitlementPoolIds); + featureGroup.setLicenseKeyGroupIds(licenseKeyGroupIds); + return featureGroup; + } } diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseAgreementTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseAgreementTest.java index b0b5953a53..91435e85fd 100644 --- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseAgreementTest.java +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseAgreementTest.java @@ -26,17 +26,11 @@ import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.mockito.Spy; -import org.openecomp.core.util.UniqueValueUtil; -import org.openecomp.core.utilities.CommonMethods; -import org.openecomp.sdc.activityLog.ActivityLogManager; import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity; -import org.openecomp.sdc.common.errors.CoreException; import org.openecomp.sdc.vendorlicense.VendorLicenseConstants; import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao; import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao; -import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDaoFactory; import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao; -import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDaoFactory; import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao; import org.openecomp.sdc.vendorlicense.dao.LimitDao; import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao; @@ -44,36 +38,24 @@ import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther; import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity; import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity; import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm; -import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity; import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade; -import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl; -import org.openecomp.sdc.vendorsoftwareproduct.dao.type.ProcessEntity; 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.types.VersionInfo; -import org.openecomp.sdc.versioning.types.VersionableEntityAction; import org.testng.Assert; -import org.testng.annotations.BeforeClass; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyObject; -import static org.mockito.Matchers.eq; -import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.verify; -import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE; -import static org.testng.AssertJUnit.assertEquals; - import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashSet; import java.util.Set; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.verify; + public class LicenseAgreementTest { private static final String USER1 = "TestUser1"; @@ -104,8 +86,6 @@ public class LicenseAgreementTest { private LicenseKeyGroupDao licenseKeyGroupDaoMcok; @Mock private LimitDao limitDaoMcok; - @Mock - private ActivityLogManager activityLogManagerMcok; @Spy @@ -160,12 +140,12 @@ public class LicenseAgreementTest { @Test public void listLicenseAgreementsTest() { - LicenseAgreementEntity la = new LicenseAgreementEntity(vlm1_id,VERSION01,USER1); - doReturn(la).when(vendorLicenseManager).createLicenseAgreementForList(vlm1_id,VERSION01, USER1); + LicenseAgreementEntity la = + new LicenseAgreementEntity(vlm1_id, VERSION01, null); // TODO: 8/13/2017 doReturn(Arrays.asList( createLicenseAgreement(vlm1_id, VERSION01, la1_id, "LA1", "LA1 " + - "desc","RequirementsAndConstrains2", new ChoiceOrOther<>(LicenseTerm.Unlimited, null), + "desc", "RequirementsAndConstrains2", new ChoiceOrOther<>(LicenseTerm.Unlimited, null), "fg1"), createLicenseAgreement(vlm1_id, VERSION01, la2_id, "LA2", "LA2 desc", "RequirementsAndConstrains2", new ChoiceOrOther<>(LicenseTerm.Unlimited, null), @@ -173,23 +153,23 @@ public class LicenseAgreementTest { .when(licenseAgreementDaoMcok).list(la); Collection<LicenseAgreementEntity> LAs = - vendorLicenseManager.listLicenseAgreements(vlm1_id, VERSION01, USER1); + vendorLicenseManager.listLicenseAgreements(vlm1_id, VERSION01); Assert.assertEquals(LAs.size(), 2); - LAs.forEach(licseAgreement-> Assert.assertTrue(licseAgreement.getId().matches(la1_id + "|" + la2_id))); + LAs.forEach( + licseAgreement -> Assert.assertTrue(licseAgreement.getId().matches(la1_id + "|" + la2_id))); } @Test public void testListLicenseAgreementsWhenNone() { - LicenseAgreementEntity la = new LicenseAgreementEntity(vlm1_id,VERSION01,USER1); - doReturn(la).when(vendorLicenseManager).createLicenseAgreementForList(vlm1_id,VERSION01, - USER1); + LicenseAgreementEntity la = + new LicenseAgreementEntity(vlm1_id, VERSION01, null); // TODO: 8/13/2017 doReturn(new ArrayList<LicenseAgreementEntity>()) .when(licenseAgreementDaoMcok).list(la); Collection<LicenseAgreementEntity> LAs = - vendorLicenseManager.listLicenseAgreements(vlm1_id, VERSION01, USER1); + vendorLicenseManager.listLicenseAgreements(vlm1_id, VERSION01); verify(licenseAgreementDaoMcok).list(la); Assert.assertEquals(LAs.size(), 0); @@ -199,29 +179,19 @@ public class LicenseAgreementTest { @Test public void testCreateLicenseAgreement() { - LicenseAgreementEntity licenseAgreementEntity = new LicenseAgreementEntity(vlm1_id,VERSION01, + LicenseAgreementEntity licenseAgreementEntity = new LicenseAgreementEntity(vlm1_id, VERSION01, la2_id); doReturn(licenseAgreementEntity).when(vendorLicenseFacadeMcok).createLicenseAgreement - (licenseAgreementEntity,USER1); + (licenseAgreementEntity); - vendorLicenseManager.createLicenseAgreement(licenseAgreementEntity,USER1); + vendorLicenseManager.createLicenseAgreement(licenseAgreementEntity); - verify(vendorLicenseFacadeMcok).createLicenseAgreement(licenseAgreementEntity,USER1); + verify(vendorLicenseFacadeMcok).createLicenseAgreement(licenseAgreementEntity); } @Test public void testUpdateLicenseAgreement() { - - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - versionInfo.setLockingUser(USER1); - ArrayList<Version> viewable = new ArrayList<Version>(); - viewable.add(VERSION01); - versionInfo.setViewableVersions(viewable); - - doReturn(versionInfo).when(vendorLicenseManager).getVersionInfo(vlm1_id, - VersionableEntityAction.Write, USER1); LicenseAgreementEntity existingLA = new LicenseAgreementEntity(vlm1_id, VERSION01, la1_id); existingLA.setFeatureGroupIds(new HashSet<String>()); @@ -236,34 +206,20 @@ public class LicenseAgreementTest { FeatureGroupEntity fg2 = new FeatureGroupEntity(vlm1_id, VERSION01, fg2_id); doReturn(fg1).when(featureGroupDaoMcok).get(fg1); doReturn(fg2).when(featureGroupDaoMcok).get(fg2); - doReturn(existingLA).when(vendorLicenseManager).createLicenseAgreementForList(vlm1_id,VERSION01, - USER1); doNothing().when(vendorLicenseManager).updateUniqueName(anyObject(), anyObject(), anyObject(), anyObject(), anyObject()); - vendorLicenseManager.updateLicenseAgreement(existingLA, addedFGs, removedFGs, USER1); + vendorLicenseManager.updateLicenseAgreement(existingLA, addedFGs, removedFGs); verify(licenseAgreementDaoMcok) .updateColumnsAndDeltaFeatureGroupIds(existingLA, addedFGs, removedFGs); - verify(vendorLicenseManager).addFeatureGroupsToLicenseAgreementRef(addedFGs,existingLA); - verify(vendorLicenseManager).removeFeatureGroupsToLicenseAgreementRef(removedFGs,existingLA); - verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id,VERSION01); + verify(vendorLicenseManager).addFeatureGroupsToLicenseAgreementRef(addedFGs, existingLA); + verify(vendorLicenseManager).removeFeatureGroupsToLicenseAgreementRef(removedFGs, existingLA); } @Test public void deleteLicenseAgreementsTest() { - - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - versionInfo.setLockingUser(USER1); - ArrayList<Version> viewable = new ArrayList<Version>(); - viewable.add(VERSION01); - versionInfo.setViewableVersions(viewable); - - doReturn(versionInfo).when(vendorLicenseManager).getVersionInfo(vlm1_id, - VersionableEntityAction.Write, USER1); - LicenseAgreementEntity existingLA = new LicenseAgreementEntity(vlm1_id, VERSION01, la1_id); existingLA.setName("LA"); existingLA.setFeatureGroupIds(new HashSet<>()); @@ -271,20 +227,19 @@ public class LicenseAgreementTest { doReturn(existingLA).when(licenseAgreementDaoMcok).get(anyObject()); doNothing().when(vendorLicenseManager).deleteUniqueName(VendorLicenseConstants.UniqueValues - .LICENSE_AGREEMENT_NAME,vlm1_id,VERSION01.toString(),existingLA.getName()); + .LICENSE_AGREEMENT_NAME, vlm1_id, VERSION01.toString(), existingLA.getName()); - vendorLicenseManager.deleteLicenseAgreement(vlm1_id, VERSION01, la1_id, USER1); + vendorLicenseManager.deleteLicenseAgreement(vlm1_id, VERSION01, la1_id); verify(licenseAgreementDaoMcok).delete(existingLA); - verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id,VERSION01); verify(vendorLicenseManager).removeFeatureGroupsToLicenseAgreementRef(existingLA - .getFeatureGroupIds(),existingLA); + .getFeatureGroupIds(), existingLA); } @Test - public void testGetLicenseAgreement(){ - vendorLicenseManager.getLicenseAgreementModel(vlm1_id,VERSION01,la1_id,USER1); - verify(vendorLicenseFacadeMcok).getLicenseAgreementModel(vlm1_id,VERSION01,la1_id,USER1); + public void testGetLicenseAgreement() { + vendorLicenseManager.getLicenseAgreementModel(vlm1_id, VERSION01, la1_id); + verify(vendorLicenseFacadeMcok).getLicenseAgreementModel(vlm1_id, VERSION01, la1_id); } /* @@ -300,7 +255,7 @@ public class LicenseAgreementTest { featureGroupDao.create(created); featureGroupDao.addReferencingLicenseAgreement(created, licenseAgreement.getId()); - vendorLicenseManager.deleteFeatureGroup(created, USER1); + vendorLicenseManager.deleteFeatureGroup(created); LicenseAgreementEntity afterDeletingFG = licenseAgreementDao.get(licenseAgreement); Assert.assertEquals(afterDeletingFG.getFeatureGroupIds().size(), 1); Assert.assertTrue(afterDeletingFG.getFeatureGroupIds().contains("fg2")); diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseKeyGroupTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseKeyGroupTest.java index f0dd383a1f..dc376ee5b6 100644 --- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseKeyGroupTest.java +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/LicenseKeyGroupTest.java @@ -26,21 +26,19 @@ import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.mockito.Spy; import org.openecomp.sdc.common.errors.CoreException; -import org.openecomp.sdc.logging.api.Logger; -import org.openecomp.sdc.logging.api.LoggerFactory; import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao; import org.openecomp.sdc.vendorlicense.dao.LimitDao; -import org.openecomp.sdc.vendorlicense.dao.types.*; +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.errors.VendorLicenseErrorCodes; import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade; import org.openecomp.sdc.versioning.dao.types.Version; -import org.openecomp.sdc.versioning.types.VersionInfo; -import org.openecomp.sdc.versioning.types.VersionableEntityAction; import org.testng.Assert; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; -import java.util.ArrayList; import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.util.Arrays; @@ -56,10 +54,10 @@ import static org.mockito.Mockito.verify; public class LicenseKeyGroupTest { //JUnit Test Cases using Mockito - private final String USER = "lkgTestUser"; - private final String LKG_NAME = "LKG name"; - private final String LKG2_NAME = "LKG2 name"; - private final String LT_NAME = "LT name"; + private final String USER = "lkgTestUser"; + private final String LKG_NAME = "LKG name"; + private final String LKG2_NAME = "LKG2 name"; + private final String LT_NAME = "LT name"; private final String LKG1_NAME = "LKG1 name"; private final String USER1 = "user1"; private static String lkg1_id = "lkg1_id"; @@ -85,15 +83,16 @@ public class LicenseKeyGroupTest { MockitoAnnotations.initMocks(this); } - private LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyType type, Set<OperationalScope> operationalScopeChoices, - String operationalScopeOther) - { + private LicenseKeyGroupEntity createLicenseKeyGroup(LicenseKeyType type, + Set<OperationalScope> operationalScopeChoices, + String operationalScopeOther) { LicenseKeyGroupEntity licenseKeyGroupEntity = new LicenseKeyGroupEntity(); licenseKeyGroupEntity.setType(type); licenseKeyGroupEntity.setOperationalScope( new MultiChoiceOrOther<>(operationalScopeChoices, operationalScopeOther)); return licenseKeyGroupEntity; } + /* @Test public void deleteLicenseKeyGroupTest() { @@ -207,14 +206,14 @@ public class LicenseKeyGroupTest { opScopeChoices.add(OperationalScope.CPU); opScopeChoices.add(OperationalScope.Network_Wide); LicenseKeyGroupEntity lkg = - createLicenseKeyGroup("vlm1Id", null,lkg1_id, LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique, + createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec", LicenseKeyType.Unique, new MultiChoiceOrOther<>(opScopeChoices, null)); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); lkg.setStartDate(LocalDate.now().format(formatter)); lkg.setExpiryDate(LocalDate.now().plusDays(1L).format(formatter)); - vendorLicenseManagerImpl.createLicenseKeyGroup(lkg, USER1); - verify(vendorLicenseFacade).createLicenseKeyGroup(lkg,USER1); + vendorLicenseManagerImpl.createLicenseKeyGroup(lkg); + verify(vendorLicenseFacade).createLicenseKeyGroup(lkg); } @Test @@ -227,12 +226,13 @@ public class LicenseKeyGroupTest { opScopeChoices.add(OperationalScope.CPU); opScopeChoices.add(OperationalScope.Network_Wide); LicenseKeyGroupEntity lkg = - createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique, + createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec", + LicenseKeyType.Unique, new MultiChoiceOrOther<>(opScopeChoices, null)); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); lkg.setStartDate(LocalDate.now().format(formatter)); lkg.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); - vendorLicenseManagerImpl.createLicenseKeyGroup(lkg, USER1); + vendorLicenseManagerImpl.createLicenseKeyGroup(lkg); Assert.fail(); } catch (CoreException exception) { Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); @@ -249,11 +249,12 @@ public class LicenseKeyGroupTest { opScopeChoices.add(OperationalScope.CPU); opScopeChoices.add(OperationalScope.Network_Wide); LicenseKeyGroupEntity lkg = - createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique, + createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec", + LicenseKeyType.Unique, new MultiChoiceOrOther<>(opScopeChoices, null)); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); lkg.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter)); - vendorLicenseManagerImpl.createLicenseKeyGroup(lkg, USER1).getId(); + vendorLicenseManagerImpl.createLicenseKeyGroup(lkg).getId(); Assert.fail(); } catch (CoreException exception) { Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); @@ -270,12 +271,13 @@ public class LicenseKeyGroupTest { opScopeChoices.add(OperationalScope.CPU); opScopeChoices.add(OperationalScope.Network_Wide); LicenseKeyGroupEntity lkg = - createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique, + createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec", + LicenseKeyType.Unique, new MultiChoiceOrOther<>(opScopeChoices, null)); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); lkg.setStartDate(LocalDate.now().plusDays(2L).format(formatter)); lkg.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter)); - vendorLicenseManagerImpl.createLicenseKeyGroup(lkg, USER1).getId(); + vendorLicenseManagerImpl.createLicenseKeyGroup(lkg).getId(); Assert.fail(); } catch (CoreException exception) { Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); @@ -290,19 +292,14 @@ public class LicenseKeyGroupTest { opScopeChoices.add(OperationalScope.CPU); opScopeChoices.add(OperationalScope.Network_Wide); LicenseKeyGroupEntity lkg = - createLicenseKeyGroup(vlm1_id, null,lkg1_id, LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique, + createLicenseKeyGroup(vlm1_id, null, lkg1_id, LKG1_NAME, "LKG1 dec", LicenseKeyType.Unique, new MultiChoiceOrOther<>(opScopeChoices, null)); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); lkg.setStartDate(LocalDate.now().minusDays(3L).format(formatter)); lkg.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); - VersionInfo info = new VersionInfo(); - info.getViewableVersions().add(VERSION01); - info.setActiveVersion(VERSION01); - doReturn(info).when(vendorLicenseFacade).getVersionInfo(anyObject(),anyObject(),anyObject()); - - vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg, USER1); - verify(vendorLicenseFacade).updateLicenseKeyGroup(lkg,USER1); - verify(vendorLicenseFacade).updateVlmLastModificationTime(vlm1_id,VERSION01); + + vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg); + verify(vendorLicenseFacade).updateLicenseKeyGroup(lkg); } @Test @@ -315,12 +312,13 @@ public class LicenseKeyGroupTest { opScopeChoices.add(OperationalScope.CPU); opScopeChoices.add(OperationalScope.Network_Wide); LicenseKeyGroupEntity lkg = - createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique, + createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec", + LicenseKeyType.Unique, new MultiChoiceOrOther<>(opScopeChoices, null)); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); lkg.setStartDate(LocalDate.now().format(formatter)); lkg.setExpiryDate(LocalDate.now().minusDays(2L).format(formatter)); - vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg, USER1); + vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg); Assert.fail(); } catch (CoreException exception) { Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); @@ -337,11 +335,12 @@ public class LicenseKeyGroupTest { opScopeChoices.add(OperationalScope.CPU); opScopeChoices.add(OperationalScope.Network_Wide); LicenseKeyGroupEntity lkg = - createLicenseKeyGroup("vlm1Id", null, lkg1_id,LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique, + createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec", + LicenseKeyType.Unique, new MultiChoiceOrOther<>(opScopeChoices, null)); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); lkg.setExpiryDate(LocalDate.now().plusDays(2L).format(formatter)); - vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg, USER1); + vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg); Assert.fail(); } catch (CoreException exception) { Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); @@ -358,12 +357,13 @@ public class LicenseKeyGroupTest { opScopeChoices.add(OperationalScope.CPU); opScopeChoices.add(OperationalScope.Network_Wide); LicenseKeyGroupEntity lkg = - createLicenseKeyGroup("vlm1Id", null,lkg1_id, LKG1_NAME, "LKG1 dec",LicenseKeyType.Unique, + createLicenseKeyGroup("vlm1Id", null, lkg1_id, LKG1_NAME, "LKG1 dec", + LicenseKeyType.Unique, new MultiChoiceOrOther<>(opScopeChoices, null)); DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM/dd/yyyy"); lkg.setStartDate(LocalDate.now().format(formatter)); lkg.setExpiryDate(LocalDate.now().format(formatter)); - vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg, USER1); + vendorLicenseManagerImpl.updateLicenseKeyGroup(lkg); Assert.fail(); } catch (CoreException exception) { Assert.assertEquals(exception.code().id(), VendorLicenseErrorCodes.DATE_RANGE_INVALID); @@ -371,9 +371,10 @@ public class LicenseKeyGroupTest { } @Test - public void testListlistLicenseKeyGroups(){ + public void testListlistLicenseKeyGroups() { - MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = new MultiChoiceOrOther<OperationalScope>(); + MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = + new MultiChoiceOrOther<OperationalScope>(); Set<OperationalScope> opScopeChoices = new HashSet<>(); opScopeChoices.add(OperationalScope.Core); opScopeChoices.add(OperationalScope.CPU); @@ -382,34 +383,25 @@ public class LicenseKeyGroupTest { multiChoiceOrOther.setOther("Other"); doReturn(Arrays.asList( - createLicenseKeyGroup(vlm1_id,VERSION01, lkg1_id, LKG1_NAME,"LKG1 dec", LicenseKeyType.Universal, + createLicenseKeyGroup(vlm1_id, VERSION01, lkg1_id, LKG1_NAME, "LKG1 dec", + LicenseKeyType.Universal, multiChoiceOrOther), - createLicenseKeyGroup(vlm1_id,VERSION01, lkg2_id, LKG2_NAME,"LKG2 dec", LicenseKeyType + createLicenseKeyGroup(vlm1_id, VERSION01, lkg2_id, LKG2_NAME, "LKG2 dec", LicenseKeyType .Universal, multiChoiceOrOther))) - .when(vendorLicenseFacade).listLicenseKeyGroups(vlm1_id, VERSION01, USER1); + .when(vendorLicenseFacade).listLicenseKeyGroups(vlm1_id, VERSION01); Collection<LicenseKeyGroupEntity> LKGs = - vendorLicenseManagerImpl.listLicenseKeyGroups(vlm1_id, VERSION01, USER1); + vendorLicenseManagerImpl.listLicenseKeyGroups(vlm1_id, VERSION01); - verify(vendorLicenseFacade).listLicenseKeyGroups(vlm1_id, VERSION01, USER1); + verify(vendorLicenseFacade).listLicenseKeyGroups(vlm1_id, VERSION01); Assert.assertEquals(LKGs.size(), 2); LKGs.forEach(lkg -> Assert.assertTrue(lkg.getId().matches(lkg1_id + "|" + lkg2_id))); } @Test - public void testGetLicenseKeyGroup(){ - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - versionInfo.setLockingUser(USER1); - ArrayList<Version> viewable = new ArrayList<Version>(); - viewable.add(VERSION01); - versionInfo.setViewableVersions(viewable); - versionInfo.setActiveVersion(VERSION01); - - doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id, - VersionableEntityAction.Read, USER1); - - MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = new MultiChoiceOrOther<OperationalScope>(); + public void testGetLicenseKeyGroup() { + MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = + new MultiChoiceOrOther<OperationalScope>(); Set<OperationalScope> opScopeChoices = new HashSet<>(); opScopeChoices.add(OperationalScope.Core); opScopeChoices.add(OperationalScope.CPU); @@ -417,35 +409,24 @@ public class LicenseKeyGroupTest { multiChoiceOrOther.setChoices(opScopeChoices); multiChoiceOrOther.setOther("Other"); - LicenseKeyGroupEntity lkg = createLicenseKeyGroup(vlm1_id,VERSION01, lkg1_id, LKG1_NAME, + LicenseKeyGroupEntity lkg = createLicenseKeyGroup(vlm1_id, VERSION01, lkg1_id, LKG1_NAME, "LKG1 dec", LicenseKeyType.Universal, multiChoiceOrOther); doReturn(lkg).when(licenseKeyGroupDao).get(anyObject()); - LicenseKeyGroupEntity lkgRetrived = vendorLicenseManagerImpl.getLicenseKeyGroup(lkg,USER1); + LicenseKeyGroupEntity lkgRetrived = vendorLicenseManagerImpl.getLicenseKeyGroup(lkg); verify(licenseKeyGroupDao).get(lkg); - Assert.assertEquals(lkgRetrived.getId(),lkg.getId()); - Assert.assertEquals(lkgRetrived.getVendorLicenseModelId(),lkg.getVendorLicenseModelId()); - Assert.assertEquals(lkgRetrived.getVersion(),lkg.getVersion()); + Assert.assertEquals(lkgRetrived.getId(), lkg.getId()); + Assert.assertEquals(lkgRetrived.getVendorLicenseModelId(), lkg.getVendorLicenseModelId()); + Assert.assertEquals(lkgRetrived.getVersion(), lkg.getVersion()); } @Test public void testDeleteLicenseKeyGroup() { - - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - versionInfo.setLockingUser(USER1); - ArrayList<Version> viewable = new ArrayList<Version>(); - viewable.add(VERSION01); - versionInfo.setViewableVersions(viewable); - - doReturn(versionInfo).when(vendorLicenseManagerImpl).getVersionInfo(vlm1_id, - VersionableEntityAction.Write, USER1); - - - MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = new MultiChoiceOrOther<OperationalScope>(); + MultiChoiceOrOther<OperationalScope> multiChoiceOrOther = + new MultiChoiceOrOther<OperationalScope>(); Set<OperationalScope> opScopeChoices = new HashSet<>(); opScopeChoices.add(OperationalScope.Core); opScopeChoices.add(OperationalScope.CPU); @@ -453,26 +434,26 @@ public class LicenseKeyGroupTest { multiChoiceOrOther.setChoices(opScopeChoices); multiChoiceOrOther.setOther("Other"); - LicenseKeyGroupEntity lkg = createLicenseKeyGroup(vlm1_id,VERSION01, lkg1_id, LKG1_NAME, + LicenseKeyGroupEntity lkg = createLicenseKeyGroup(vlm1_id, VERSION01, lkg1_id, LKG1_NAME, "LKG1 dec", LicenseKeyType.Universal, multiChoiceOrOther); lkg.setReferencingFeatureGroups(new HashSet<>()); doReturn(lkg).when(licenseKeyGroupDao).get(anyObject()); - doNothing().when(vendorLicenseManagerImpl).deleteChildLimits(vlm1_id,VERSION01,lkg1_id,USER1); + doNothing().when(vendorLicenseManagerImpl).deleteChildLimits(vlm1_id, VERSION01, lkg1_id); - doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(anyObject(),anyObject(), - anyObject(),anyObject()); + doNothing().when(vendorLicenseManagerImpl).deleteUniqueName(anyObject(), anyObject(), + anyObject(), anyObject()); - vendorLicenseManagerImpl.deleteLicenseKeyGroup(lkg, USER1); + vendorLicenseManagerImpl.deleteLicenseKeyGroup(lkg); verify(licenseKeyGroupDao).delete(lkg); - verify(vendorLicenseFacade).updateVlmLastModificationTime(vlm1_id,VERSION01); } - public static LicenseKeyGroupEntity createLicenseKeyGroup(String vlmId, Version version,String id, + public static LicenseKeyGroupEntity createLicenseKeyGroup(String vlmId, Version version, + String id, String name, String desc, LicenseKeyType type, MultiChoiceOrOther<OperationalScope> operationalScope) { @@ -525,7 +506,7 @@ public class LicenseKeyGroupTest { vlm1Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest .createVendorLicenseModel("vendor1 name " + CommonMethods.nextUuId(), "vlm1Id dec", - "icon1"), USER1).getId(); + "icon1")1).getId(); vlm2Id = vendorLicenseManager.createVendorLicenseModel(VendorLicenseModelTest .createVendorLicenseModel("vendor2 name " + CommonMethods.nextUuId(), "vlm2 dec", "icon2"), USER1).getId(); @@ -545,7 +526,7 @@ public class LicenseKeyGroupTest { LicenseKeyGroupEntity lkg1 = createLicenseKeyGroup(vlmId, VERSION01, name, "LKG1 dec", LicenseKeyType.One_Time, new MultiChoiceOrOther<>(opScopeChoices, null)); - String lkg1Id = vendorLicenseManager.createLicenseKeyGroup(lkg1, USER1).getId(); + String lkg1Id = vendorLicenseManager.createLicenseKeyGroup(lkg11).getId(); lkg1.setId(lkg1Id); LicenseKeyGroupEntity loadedLkg1 = licenseKeyGroupDao.get(lkg1); @@ -560,7 +541,7 @@ public class LicenseKeyGroupTest { createLicenseKeyGroup(vlm1Id, VERSION01, LKG1_NAME, "LKG1 dec", LicenseKeyType.One_Time, new MultiChoiceOrOther<>(Collections.singleton(OperationalScope.Other), "other op scope")); - vendorLicenseManager.createLicenseKeyGroup(lkg1, USER1).getId(); + vendorLicenseManager.createLicenseKeyGroup(lkg11).getId(); Assert.fail(); } catch (CoreException exception) { Assert.assertEquals(exception.code().id(), UniqueValueUtil.UNIQUE_VALUE_VIOLATION); @@ -581,9 +562,9 @@ public class LicenseKeyGroupTest { lkg1.setOperationalScope(new MultiChoiceOrOther<>(opScopeChoices, "op scope1 updated")); lkg1.setDescription("LKG1 dec updated"); - vendorLicenseManager.updateLicenseKeyGroup(lkg1, USER1); + vendorLicenseManager.updateLicenseKeyGroup(lkg11); - LicenseKeyGroupEntity loadedLkg1 = vendorLicenseManager.getLicenseKeyGroup(lkg1, USER1); + LicenseKeyGroupEntity loadedLkg1 = vendorLicenseManager.getLicenseKeyGroup(lkg11); Assert.assertTrue(loadedLkg1.equals(lkg1)); } @@ -595,11 +576,11 @@ public class LicenseKeyGroupTest { LicenseKeyGroupEntity lkg2 = createLicenseKeyGroup(vlm1Id, VERSION01, "LKG2", "LKG2 dec", LicenseKeyType.Universal, new MultiChoiceOrOther<>(opScopeChoices, null)); - lkg2Id = vendorLicenseManager.createLicenseKeyGroup(lkg2, USER1).getId(); + lkg2Id = vendorLicenseManager.createLicenseKeyGroup(lkg21).getId(); lkg2.setId(lkg2Id); Collection<LicenseKeyGroupEntity> loadedLkgs = - vendorLicenseManager.listLicenseKeyGroups(vlm1Id, null, USER1); + vendorLicenseManager.listLicenseKeyGroups(vlm1Id, null1); Assert.assertEquals(loadedLkgs.size(), 2); for (LicenseKeyGroupEntity loadedLkg : loadedLkgs) { if (lkg2Id.equals(loadedLkg.getId())) { @@ -611,7 +592,7 @@ public class LicenseKeyGroupTest { @Test(dependsOnMethods = {"listTest"}) public void deleteTest() { vendorLicenseManager - .deleteLicenseKeyGroup(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id), USER1); + .deleteLicenseKeyGroup(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id)1); LicenseKeyGroupEntity loadedLkg1 = licenseKeyGroupDao.get(new LicenseKeyGroupEntity(vlm1Id, VERSION01, lkg1Id)); diff --git a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseModelTest.java b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseModelTest.java index 195fa5d4da..d1df147a60 100644 --- a/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseModelTest.java +++ b/openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/impl/VendorLicenseModelTest.java @@ -1,12 +1,12 @@ package org.openecomp.sdc.vendorlicense.impl; -import org.junit.rules.ExpectedException; -import org.openecomp.core.util.UniqueValueUtil; -import org.openecomp.sdc.activityLog.ActivityLogManager; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.mockito.Spy; import org.openecomp.sdc.activitylog.dao.type.ActivityLogEntity; -import org.openecomp.sdc.common.errors.CoreException; -import org.openecomp.sdc.common.errors.ErrorCategory; -import org.openecomp.sdc.common.errors.ErrorCode; import org.openecomp.sdc.vendorlicense.VendorLicenseConstants; import org.openecomp.sdc.vendorlicense.dao.EntitlementPoolDao; import org.openecomp.sdc.vendorlicense.dao.FeatureGroupDao; @@ -14,50 +14,17 @@ import org.openecomp.sdc.vendorlicense.dao.LicenseAgreementDao; import org.openecomp.sdc.vendorlicense.dao.LicenseKeyGroupDao; import org.openecomp.sdc.vendorlicense.dao.LimitDao; import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao; -import org.openecomp.sdc.vendorlicense.dao.types.ChoiceOrOther; -import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity; -import org.openecomp.sdc.vendorlicense.dao.types.LicenseTerm; import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity; import org.openecomp.sdc.vendorlicense.facade.VendorLicenseFacade; -import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel; -import org.openecomp.sdc.vendorsoftwareproduct.VendorSoftwareProductConstants; -import org.openecomp.sdc.vendorsoftwareproduct.dao.type.VspDetails; -import org.openecomp.sdc.vendorsoftwareproduct.types.VersionedVendorSoftwareProductInfo; 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 org.testng.annotations.BeforeMethod; -import org.mockito.ArgumentCaptor; -import org.mockito.Captor; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.mockito.Spy; -import org.testng.Assert; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; - import static org.mockito.Matchers.any; -import static org.mockito.Matchers.anyObject; -import static org.mockito.Matchers.eq; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doReturn; -import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.verify; -import static org.openecomp.sdc.vendorlicense.VendorLicenseConstants.VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE; /** @@ -93,9 +60,6 @@ public class VendorLicenseModelTest { private LicenseKeyGroupDao licenseKeyGroupDaoMcok; @Mock private LimitDao limitDaoMcok; - @Mock - private ActivityLogManager activityLogManagerMcok; - @Spy @InjectMocks @@ -112,159 +76,19 @@ public class VendorLicenseModelTest { } @Test - public void testCheckout() { - - doReturn(VERSION01).when(versioningManagerMcok) - .checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1_id, USER1); - - vendorLicenseManager.checkout(vlm1_id, USER1); - - Assert.assertEquals(VERSION01.getStatus(), VersionStatus.Locked); - verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id, VERSION01); - - verify(versioningManagerMcok) - .checkout(VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1_id, USER1); - - verify(activityLogManagerMcok).addActionLog(activityLogEntityArg.capture(), eq(USER1)); - ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue(); - Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION01.getMajor() + 1)); - Assert.assertTrue(activityLogEntity.isSuccess()); - } - - @Test - public void testUndoCheckout() { - Version existingVersion = new Version(0, 2); - doReturn(existingVersion).when(versioningManagerMcok).undoCheckout( - VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, vlm1_id, USER1); - - vendorLicenseManager.undoCheckout(vlm1_id, USER1); - - verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id, existingVersion); - } - - @Test - public void testCheckin() { - - doReturn(VERSION10).when(vendorLicenseFacadeMcok).checkin(vlm1_id, USER1); - - vendorLicenseManager.checkin(vlm1_id, USER1); - verify(activityLogManagerMcok).addActionLog(activityLogEntityArg.capture(), eq(USER1)); - ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue(); - Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION10.getMajor() + 1)); - verify(vendorLicenseFacadeMcok).checkin(vlm1_id, USER1); - - } - - @Test - public void testSubmit() { - - doReturn(VERSION10).when(vendorLicenseFacadeMcok).submit(vlm1_id, USER1); - - vendorLicenseManager.submit(vlm1_id, USER1); - verify(activityLogManagerMcok).addActionLog(activityLogEntityArg.capture(), eq(USER1)); - ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue(); - Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION10.getMajor())); - verify(vendorLicenseFacadeMcok).submit(vlm1_id, USER1); - - } - - @Test - public void testListWhenNone() { - doReturn(new HashMap<>()).when(versioningManagerMcok).listEntitiesVersionInfo - (VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, USER1, VersionableEntityAction.Read); - Collection<VersionedVendorLicenseModel> vlms = vendorLicenseManager.listVendorLicenseModels - (null, USER1); - Assert.assertEquals(vlms.size(), 0); - } - - @Test - public void testList() { - - Map<String, VersionInfo> vlmsTobeReturned = new HashMap<>(); - - VersionInfo versionInfo1 = new VersionInfo(); - versionInfo1.setActiveVersion(VERSION01); - vlmsTobeReturned.put(vlm1_id, versionInfo1); - - VersionInfo versionInfo2 = new VersionInfo(); - versionInfo2.setActiveVersion(VERSION10); - vlmsTobeReturned.put(vlm2_id, versionInfo2); - - doReturn(vlmsTobeReturned).when(versioningManagerMcok).listEntitiesVersionInfo - (VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, USER1, VersionableEntityAction.Read); - - VendorLicenseModelEntity vlm1 = new VendorLicenseModelEntity(vlm1_id, VERSION01); - vlm1.setWritetimeMicroSeconds(8L); - doReturn(vlm1).when(vendorLicenseModelDaoMcok).get(any(VendorLicenseModelEntity.class)); - - Collection<VersionedVendorLicenseModel> vlms = vendorLicenseManager.listVendorLicenseModels - (null, USER1); - Assert.assertEquals(vlms.size(), 2); - } - - @Test - public void testListFinalsWhenNone() { - - Map<String, VersionInfo> vspsTobeReturned = new HashMap<>(); - - VersionInfo versionInfo1 = new VersionInfo(); - versionInfo1.setActiveVersion(VERSION01); - vspsTobeReturned.put(vlm1_id, versionInfo1); - - VersionInfo versionInfo2 = new VersionInfo(); - versionInfo2.setActiveVersion(VERSION10); - vspsTobeReturned.put(vlm2_id, versionInfo2); - - doReturn(vspsTobeReturned).when(versioningManagerMcok).listEntitiesVersionInfo - (VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, USER1, VersionableEntityAction.Read); - - Collection<VersionedVendorLicenseModel> vlms = vendorLicenseManager.listVendorLicenseModels - (VersionStatus.Final.name(), USER1); - Assert.assertEquals(vlms.size(), 0); - } - - @Test - public void testListFinals() { - Map<String, VersionInfo> vlmsTobeReturned = new HashMap<>(); - - VersionInfo versionInfo1 = new VersionInfo(); - versionInfo1.setActiveVersion(VERSION01); - vlmsTobeReturned.put(vlm1_id, versionInfo1); - - VersionInfo versionInfo2 = new VersionInfo(); - - versionInfo2.setActiveVersion(new Version(1, 3)); - versionInfo2.setLatestFinalVersion(VERSION10); - vlmsTobeReturned.put(vlm2_id, versionInfo2); - - doReturn(vlmsTobeReturned).when(versioningManagerMcok).listEntitiesVersionInfo - (VENDOR_LICENSE_MODEL_VERSIONABLE_TYPE, USER1, VersionableEntityAction.Read); - - VendorLicenseModelEntity vlm1 = new VendorLicenseModelEntity(vlm1_id, VERSION01); - vlm1.setWritetimeMicroSeconds(8L); - doReturn(vlm1).when(vendorLicenseModelDaoMcok).get(any(VendorLicenseModelEntity.class)); - - Collection<VersionedVendorLicenseModel> vlms = vendorLicenseManager.listVendorLicenseModels - (VersionStatus.Final.name(), USER1); - - Assert.assertEquals(vlms.size(), 1); + public void testValidate() { + // TODO: 8/13/2017 + vendorLicenseManager.validate(vlm1_id, null); + verify(vendorLicenseFacadeMcok).validate(vlm1_id, null); } @Test public void testCreate() { - VendorLicenseModelEntity vlmEntity = new VendorLicenseModelEntity(vlm1_id, VERSION01); - doReturn(vlmEntity).when(vendorLicenseFacadeMcok).createVendorLicenseModel(vlmEntity, USER1); - - vendorLicenseManager.createVendorLicenseModel(vlmEntity, USER1); - - verify(vendorLicenseFacadeMcok).createVendorLicenseModel(vlmEntity, USER1); - verify(activityLogManagerMcok).addActionLog(activityLogEntityArg.capture(), eq(USER1)); - ActivityLogEntity activityLogEntity = activityLogEntityArg.getValue(); - Assert.assertEquals(activityLogEntity.getVersionId(), String.valueOf(VERSION01.getMajor() + 1)); - Assert.assertTrue(activityLogEntity.isSuccess()); + vendorLicenseManager.createVendorLicenseModel(vlmEntity); + verify(vendorLicenseModelDaoMcok).create(vlmEntity); } @Test @@ -277,14 +101,6 @@ public class VendorLicenseModelTest { existingVlm.setVendorName("VLM1"); existingVlm.setDescription("decription"); - VersionInfo versionInfo = new VersionInfo(); - versionInfo.setActiveVersion(VERSION01); - - doReturn(versionInfo).when(vendorLicenseManager).getVersionInfo(existingVlm.getId(), - VersionableEntityAction.Write, USER1); - - doReturn(VERSION01).when(vendorLicenseManager).resloveVersion(vlm1_id,null, versionInfo, USER1); - doReturn("VLM1").when(vendorLicenseModelDaoMcok).get(existingVlm); VendorLicenseModelEntity updatedVlm = new VendorLicenseModelEntity(); @@ -302,21 +118,20 @@ public class VendorLicenseModelTest { doReturn(existingVlm).when(vendorLicenseModelDaoMcok).get(any(VendorLicenseModelEntity.class)); - vendorLicenseManager.updateVendorLicenseModel(updatedVlm, USER1); + vendorLicenseManager.updateVendorLicenseModel(updatedVlm); verify(vendorLicenseModelDaoMcok).update(updatedVlm); - verify(vendorLicenseFacadeMcok).updateVlmLastModificationTime(vlm1_id, VERSION01); } @Test - public void testGetVendorLicenseModel(){ - vendorLicenseManager.getVendorLicenseModel(vlm1_id,VERSION01,USER1); - verify(vendorLicenseFacadeMcok).getVendorLicenseModel(vlm1_id,VERSION01,USER1); + public void testGetVendorLicenseModel() { + vendorLicenseManager.getVendorLicenseModel(vlm1_id, VERSION01); + verify(vendorLicenseFacadeMcok).getVendorLicenseModel(vlm1_id, VERSION01); } @Test(expectedExceptions = UnsupportedOperationException.class) public void testDeleteVLMUnsupportedOperation() { - vendorLicenseManager.deleteVendorLicenseModel(vlm1_id, USER1); + vendorLicenseManager.deleteVendorLicenseModel(vlm1_id, null); // TODO: 8/13/2017 } @@ -324,7 +139,7 @@ public class VendorLicenseModelTest { // public void testGetNonExistingVersion_negative() { // Version notExistversion = new Version(43, 8); // doReturn(null).when(vspInfoDaoMock).get(any(VspDetails.class)); -// vendorSoftwareProductManager.getVsp(VSP_ID, notExistversion, USER1); +// vendorSoftwareProductManager.getVsp(VSP_ID, notExistversion); // } }
\ No newline at end of file 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 index ec50c96f74..c20d96ac36 100644 --- 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 @@ -20,22 +20,8 @@ package org.openecomp.sdc.vendorlicense.licenseartifacts.impl; -import org.apache.commons.io.IOUtils; -import org.apache.commons.lang3.StringUtils; import org.openecomp.core.utilities.file.FileContentHandler; import org.openecomp.sdc.vendorlicense.ArtifactTestUtils; -import org.openecomp.sdc.vendorlicense.VendorLicenseConstants; -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.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 { |