openecomp-be/backend/openecomp-sdc-vendor-license-manager/src/test/java/org/openecomp/sdc/vendorlicense/VendorLicenseModelTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  *//*
  20
  21
  22 package org.openecomp.sdc.vendorlicense;
  23
  24 import org.openecomp.core.util.UniqueValueUtil;
  25 import org.openecomp.sdc.common.errors.CoreException;
  26 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDao;
  27 import org.openecomp.sdc.vendorlicense.dao.VendorLicenseModelDaoFactory;
  28 import org.openecomp.sdc.vendorlicense.dao.types.EntitlementPoolEntity;
  29 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupEntity;
  30 import org.openecomp.sdc.vendorlicense.dao.types.FeatureGroupModel;
  31 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementEntity;
  32 import org.openecomp.sdc.vendorlicense.dao.types.LicenseAgreementModel;
  33 import org.openecomp.sdc.vendorlicense.dao.types.VendorLicenseModelEntity;
  34 import org.openecomp.sdc.vendorlicense.impl.VendorLicenseManagerImpl;
  35 import org.openecomp.sdc.vendorlicense.types.VersionedVendorLicenseModel;
  36 import org.openecomp.sdc.versioning.dao.types.Version;
  37 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  38 import org.testng.Assert;
  39 import org.testng.annotations.BeforeTest;
  40 import org.testng.annotations.Test;
  41
  42 import java.util.Collection;
  43 import java.util.HashSet;
  44 import java.util.List;
  45 import java.util.Set;
  46
  47 public class VendorLicenseModelTest {
  48   private static final Version VERSION01 = new Version(0, 1);
  49   private static final Version VERSION02 = new Version(0, 2);
  50   private static final String USER1 = "vlmTestUser1";
  51   private static final String USER2 = "vlmTestUser2";
  52   private static final String USER3 = "vlmTestUser3";
  53   private static final String VLM1_NAME = "Vlm1 name";
  54   private static VendorLicenseManager vendorLicenseManager = new VendorLicenseManagerImpl();
  55   private static VendorLicenseModelDao vendorLicenseModelDao =
  56       VendorLicenseModelDaoFactory.getInstance().createInterface();
  57
  58   private static String vlm1Id;
  59   private static String vlm2Id;
  60   private static String vlm3Id;
  61   private static String vlm4Id;
  62   private static String laId;
  63   private static String fg1Id;
  64   private static String fg2Id;
  65
  66   private static String testCreate() {
  67     VendorLicenseModelEntity vlm1 = createVendorLicenseModel(VLM1_NAME, "VLM1 dec", "icon1");
  68     String vlmId = vendorLicenseManager.createVendorLicenseModel(vlm1, USER1).getId();
  69
  70     vlm1.setVersion(VERSION01);
  71     VendorLicenseModelEntity loadedVlm1 = vendorLicenseModelDao.get(vlm1);
  72     Assert.assertTrue(loadedVlm1.equals(vlm1));
  73     return vlmId;
  74   }
  75
  76   public static VendorLicenseModelEntity createVendorLicenseModel(String name, String desc,
  77                                                                   String icon) {
  78     VendorLicenseModelEntity vendorLicenseModel = new VendorLicenseModelEntity();
  79     vendorLicenseModel.setVendorName(name);
  80     vendorLicenseModel.setDescription(desc);
  81     vendorLicenseModel.setIconRef(icon);
  82     return vendorLicenseModel;
  83   }
  84
  85   @BeforeTest
  86   private void init() {
  87     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, VLM1_NAME);
  88     UniqueValueUtil
  89         .deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "VLM1 updated");
  90     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "VLM2");
  91     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "test_vlm1");
  92     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "test_vlm2");
  93     UniqueValueUtil.deleteUniqueValue(VendorLicenseConstants.UniqueValues.VENDOR_NAME, "test_vlm3");
  94   }
  95
  96   @Test
  97   public void createTest() {
  98     vlm1Id = testCreate();
  99     //TODO: add verification of 'ActivityLogManager.addActionLog' func call
 100   }
 101
 102   @Test(dependsOnMethods = {"createTest"})
 103   public void testCreateWithExistingVendorName_negative() {
 104     try {
 105       vendorLicenseManager
 106           .createVendorLicenseModel(createVendorLicenseModel(VLM1_NAME, "VLM1 dec", "icon1"),
 107               USER1);
 108       Assert.fail();
 109     } catch (CoreException exception) {
 110       Assert.assertEquals(exception.code().id(), UniqueValueUtil.UNIQUE_VALUE_VIOLATION);
 111     }
 112     //TODO: add verification of none 'ActivityLogManager.addActionLog' func call
 113   }
 114
 115   @Test(dependsOnMethods = {"testCreateWithExistingVendorName_negative"})
 116   public void updateTest() {
 117     VendorLicenseModelEntity expectedVlm1 = new VendorLicenseModelEntity(vlm1Id, VERSION01);
 118     expectedVlm1.setVendorName("VLM1 updated");
 119     expectedVlm1.setDescription("VLM1 dec updated");
 120     expectedVlm1.setIconRef("icon1 updated");
 121     vendorLicenseManager.updateVendorLicenseModel(expectedVlm1, USER1);
 122
 123     VendorLicenseModelEntity actualVlm1 =
 124         vendorLicenseModelDao.get(new VendorLicenseModelEntity(vlm1Id, VERSION01));
 125     Assert.assertTrue(actualVlm1.equals(expectedVlm1));
 126   }
 127
 128   @Test(dependsOnMethods = {"updateTest"})
 129   public void testUpdateWithSimilarVendorName() {
 130     VendorLicenseModelEntity expectedVlm1 = new VendorLicenseModelEntity(vlm1Id, VERSION01);
 131     expectedVlm1.setVendorName("vlm1 UPDATED");
 132     vendorLicenseManager.updateVendorLicenseModel(expectedVlm1, USER1);
 133
 134     VendorLicenseModelEntity actualVlm1 =
 135         vendorLicenseModelDao.get(new VendorLicenseModelEntity(vlm1Id, VERSION01));
 136     Assert.assertTrue(actualVlm1.equals(expectedVlm1));
 137   }
 138
 139   @Test(dependsOnMethods = {"updateTest"})
 140   public void testCreateWithRemovedVendorName() {
 141     testCreate();
 142   }
 143
 144   @Test(dependsOnMethods = {"updateTest"})
 145   public void getTest() {
 146     VendorLicenseModelEntity expectedVlm1 =
 147         vendorLicenseModelDao.get(new VendorLicenseModelEntity(vlm1Id, VERSION01));
 148     VersionedVendorLicenseModel actualVlm1 =
 149         vendorLicenseManager.getVendorLicenseModel(vlm1Id, null, USER1);
 150
 151     Assert.assertTrue(actualVlm1.getVendorLicenseModel().equals(expectedVlm1));
 152     Assert.assertEquals(actualVlm1.getVersionInfo().getActiveVersion(), VERSION01);
 153     Assert.assertEquals(actualVlm1.getVersionInfo().getStatus(), VersionStatus.Locked);
 154     Assert.assertEquals(actualVlm1.getVersionInfo().getLockingUser(), USER1);
 155   }
 156
 157   @Test(dependsOnMethods = {"getTest"})
 158   public void listTest() {
 159     VendorLicenseModelEntity vlm2 = createVendorLicenseModel("VLM2", "VLM2 dec", "icon2");
 160     vlm2Id = vendorLicenseManager.createVendorLicenseModel(vlm2, USER1).getId();
 161     vlm2.setId(vlm2Id);
 162
 163     Collection<VersionedVendorLicenseModel> loadedVlms =
 164         vendorLicenseManager.listVendorLicenseModels(null, USER1);
 165     boolean vlm1Exists = false;
 166     boolean vlm2Exists = false;
 167     for (VersionedVendorLicenseModel loadedVlm : loadedVlms) {
 168       if (vlm1Id.equals(loadedVlm.getVendorLicenseModel().getId())) {
 169         vlm1Exists = true;
 170         continue;
 171       }
 172       if (vlm2Id.equals(loadedVlm.getVendorLicenseModel().getId())) {
 173         Assert.assertTrue(loadedVlm.getVendorLicenseModel().equals(vlm2));
 174
 175         vlm2Exists = true;
 176       }
 177     }
 178
 179     Assert.assertTrue(vlm1Exists);
 180     Assert.assertTrue(vlm2Exists);
 181   }
 182
 183   @Test(dependsOnMethods = {"listTest"})
 184   public void listFinalVersionWhenNoneTest() {
 185     Collection<VersionedVendorLicenseModel> loadedVlms =
 186         vendorLicenseManager.listVendorLicenseModels(VersionStatus.Final.name(), USER1);
 187     boolean vlm1Exists = false;
 188     boolean vlm2Exists = false;
 189     for (VersionedVendorLicenseModel loadedVlm : loadedVlms) {
 190       if (vlm1Id.equals(loadedVlm.getVendorLicenseModel().getId())) {
 191         vlm1Exists = true;
 192         continue;
 193       }
 194       if (vlm2Id.equals(loadedVlm.getVendorLicenseModel().getId())) {
 195         vlm2Exists = true;
 196       }
 197     }
 198
 199     Assert.assertFalse(vlm1Exists);
 200     Assert.assertFalse(vlm2Exists);
 201   }
 202
 203   @Test(dependsOnMethods = {"listFinalVersionWhenNoneTest"})
 204
 205   // Unsupported operation for 1607 release.
 206 */
 207 /*    public void deleteTest() {
 208         vendorLicenseManager.deleteVendorLicenseModel(vlm1Id, USER1);
 209
 210         VendorLicenseModelEntity loadedVlm1 = vendorLicenseModelDao.get(new VendorLicenseModelEntity(vlm1Id, VERSION01));
 211         Assert.assertEquals(loadedVlm1, null);
 212
 213         Collection<VendorLicenseModelEntity> loadedVlms = vendorLicenseModelDao.list(null);
 214         Assert.assertTrue(loadedVlms.size() > 1);
 215         boolean vlm1Exists = false;
 216         boolean vlm2Exists = false;
 217         for (VendorLicenseModelEntity loadedVlm : loadedVlms) {
 218             if (vlm1Id.equals(loadedVlm.getId())) {
 219                 vlm1Exists = true;
 220             }
 221             if (vlm2Id.equals(loadedVlm.getId())) {
 222                 vlm2Exists = true;
 223             }
 224         }
 225         Assert.assertFalse(vlm1Exists);
 226         Assert.assertTrue(vlm2Exists);
 227     }
 228
 229     @Test(dependsOnMethods = {"deleteTest"})*//*
 230
 231   public void checkinTest() {
 232     vendorLicenseManager.checkin(vlm2Id, USER1);
 233
 234     VersionedVendorLicenseModel versionedVlm2 =
 235         vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER1);
 236     Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), VERSION01);
 237     Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), VersionStatus.Available);
 238     Assert.assertNull(versionedVlm2.getVersionInfo().getLockingUser());
 239
 240     //TODO: add verification of 'ActivityLogManager.addActionLog' func call
 241   }
 242
 243   @Test(dependsOnMethods = {"checkinTest"})
 244   public void checkoutTest() {
 245     vendorLicenseManager.checkout(vlm2Id, USER2);
 246
 247     VersionedVendorLicenseModel versionedVlm2 =
 248         vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER2);
 249     Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), VERSION02);
 250     Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), VersionStatus.Locked);
 251     Assert.assertEquals(versionedVlm2.getVersionInfo().getLockingUser(), USER2);
 252
 253     versionedVlm2 = vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER1);
 254     Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), VERSION01);
 255     Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), VersionStatus.Locked);
 256     Assert.assertEquals(versionedVlm2.getVersionInfo().getLockingUser(), USER2);
 257
 258     //TODO: add verification of 'ActivityLogManager.addActionLog' func call
 259   }
 260
 261   @Test(dependsOnMethods = {"checkoutTest"})
 262   public void undoCheckoutTest() {
 263     vendorLicenseManager.undoCheckout(vlm2Id, USER2);
 264
 265     VersionedVendorLicenseModel versionedVlm2 =
 266         vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER2);
 267     Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), VERSION01);
 268     Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), VersionStatus.Available);
 269     Assert.assertNull(versionedVlm2.getVersionInfo().getLockingUser());
 270   }
 271
 272   @Test(dependsOnMethods = {"undoCheckoutTest"}, expectedExceptions = CoreException.class)
 273   public void submitUncompletedVlmNegativeTest() {
 274     vendorLicenseManager.submit(vlm2Id, USER2);
 275
 276     //TODO: add verification of none 'ActivityLogManager.addActionLog' func call
 277   }
 278
 279   @Test(dependsOnMethods = {"submitUncompletedVlmNegativeTest"},
 280       expectedExceptions = CoreException.class)
 281   public void submitUncompletedVlmMissingFGNegativeTest() {
 282     vendorLicenseManager.checkout(vlm2Id, USER2);
 283     LicenseAgreementEntity licenseAgreement = new LicenseAgreementEntity(vlm2Id, null, null);
 284     LicenseAgreementEntity licenseAgreementEntity =
 285         vendorLicenseManager.createLicenseAgreement(licenseAgreement, USER2);
 286     laId = licenseAgreementEntity.getId();
 287     vendorLicenseManager.checkin(vlm2Id, USER2);
 288     vendorLicenseManager.submit(vlm2Id, USER2);
 289   }
 290
 291   @Test(dependsOnMethods = {"submitUncompletedVlmMissingFGNegativeTest"},
 292       expectedExceptions = CoreException.class)
 293   public void submitUncompletedVlmMissingEPNegativeTest() {
 294     vendorLicenseManager.checkout(vlm2Id, USER2);
 295     FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlm2Id, null, null);
 296     featureGroup = vendorLicenseManager.createFeatureGroup(featureGroup, USER2);
 297     fg1Id = featureGroup.getId();
 298
 299     LicenseAgreementModel
 300         licenseAgreementModel =
 301         vendorLicenseManager.getLicenseAgreementModel(vlm2Id, null, laId, USER2);
 302     Set<String> fgIdSet = new HashSet<>();
 303     fgIdSet.add(fg1Id);
 304     vendorLicenseManager
 305         .updateLicenseAgreement(licenseAgreementModel.getLicenseAgreement(), fgIdSet, null, USER2);
 306     vendorLicenseManager.checkin(vlm2Id, USER2);
 307     vendorLicenseManager.submit(vlm2Id, USER2);
 308   }
 309
 310   @Test(dependsOnMethods = {"submitUncompletedVlmMissingEPNegativeTest"},
 311       expectedExceptions = CoreException.class)
 312   public void submitUncompletedVlmMissingEPInOneFGNegativeTest() {
 313     vendorLicenseManager.checkout(vlm2Id, USER2);
 314     FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlm2Id, null, null);
 315     EntitlementPoolEntity entitlementPool = vendorLicenseManager
 316         .createEntitlementPool(new EntitlementPoolEntity(vlm2Id, null, null), USER2);
 317     featureGroup.getEntitlementPoolIds().add(entitlementPool.getId());
 318     featureGroup = vendorLicenseManager.createFeatureGroup(featureGroup, USER2);
 319     fg2Id = featureGroup.getId();
 320     LicenseAgreementModel licenseAgreementModel =
 321         vendorLicenseManager.getLicenseAgreementModel(vlm2Id, null, laId, USER2);
 322     Set<String> fgIdSet = new HashSet<>();
 323     fgIdSet.add(fg2Id);
 324     vendorLicenseManager
 325         .updateLicenseAgreement(licenseAgreementModel.getLicenseAgreement(), fgIdSet, null, USER2);
 326
 327     vendorLicenseManager.checkin(vlm2Id, USER2);
 328     vendorLicenseManager.submit(vlm2Id, USER2);
 329   }
 330
 331   @Test(dependsOnMethods = {"submitUncompletedVlmMissingEPInOneFGNegativeTest"})
 332   public void submitTest() {
 333     vendorLicenseManager.checkout(vlm2Id, USER2);
 334
 335     EntitlementPoolEntity entitlementPool = vendorLicenseManager
 336         .createEntitlementPool(new EntitlementPoolEntity(vlm2Id, null, null), USER2);
 337     Set<String> epSetId = new HashSet<>();
 338     epSetId.add(entitlementPool.getId());
 339
 340     FeatureGroupEntity featureGroup = new FeatureGroupEntity(vlm2Id, null, fg1Id);
 341     featureGroup.getEntitlementPoolIds().add(entitlementPool.getId());
 342     FeatureGroupModel
 343         featureGroupModel = vendorLicenseManager.getFeatureGroupModel(featureGroup, USER2);
 344
 345     vendorLicenseManager
 346         .updateFeatureGroup(featureGroupModel.getFeatureGroup(), null, null, epSetId, null, USER2);
 347     vendorLicenseManager.checkin(vlm2Id, USER2);
 348     vendorLicenseManager.submit(vlm2Id, USER2);
 349
 350     VersionedVendorLicenseModel versionedVlm2 =
 351         vendorLicenseManager.getVendorLicenseModel(vlm2Id, null, USER1);
 352     Assert.assertEquals(versionedVlm2.getVersionInfo().getActiveVersion(), new Version(1, 0));
 353     Assert.assertEquals(versionedVlm2.getVersionInfo().getStatus(), VersionStatus.Final);
 354     Assert.assertNull(versionedVlm2.getVersionInfo().getLockingUser());
 355
 356     //TODO: add verification of 'ActivityLogManager.addActionLog' func call
 357   }
 358
 359   @Test(dependsOnMethods = {"submitTest"})
 360   public void listFinalVersionWhenOneTest() {
 361     Collection<VersionedVendorLicenseModel> loadedVlms =
 362         vendorLicenseManager.listVendorLicenseModels(VersionStatus.Final.name(), USER1);
 363     boolean vlm2Exists = false;
 364     for (VersionedVendorLicenseModel loadedVlm : loadedVlms) {
 365       if (vlm2Id.equals(loadedVlm.getVendorLicenseModel().getId())) {
 366         vlm2Exists = true;
 367         Assert.assertEquals(loadedVlm.getVersionInfo().getActiveVersion(), new Version(1, 0));
 368         Assert.assertEquals(loadedVlm.getVersionInfo().getStatus(), VersionStatus.Final);
 369         Assert.assertNull(loadedVlm.getVersionInfo().getLockingUser());
 370         break;
 371       }
 372     }
 373
 374     Assert.assertTrue(vlm2Exists);
 375   }
 376
 377   @Test(dependsOnMethods = {"listFinalVersionWhenOneTest"})
 378   public void testVLMListWithModificationTimeDescOrder() {
 379     VendorLicenseModelEntity vlm1 = createVendorLicenseModel("test_vlm1", "desc", "icon");
 380     vlm3Id = vendorLicenseManager.createVendorLicenseModel(vlm1, USER3).getId();
 381
 382     VendorLicenseModelEntity vlm2 = createVendorLicenseModel("test_vlm2", "desc", "icon");
 383     vlm4Id = vendorLicenseManager.createVendorLicenseModel(vlm2, USER3).getId();
 384
 385     assertVLMInWantedLocationInVSPList(vlm4Id, 0, USER3);
 386     assertVLMInWantedLocationInVSPList(vlm3Id, 1, USER3);
 387   }
 388
 389   @Test(dependsOnMethods = {"testVLMListWithModificationTimeDescOrder"})
 390   public void testOldVLMAfterChangeShouldBeInBeginningOfList() {
 391     EntitlementPoolEntity ep = vendorLicenseManager
 392         .createEntitlementPool(new EntitlementPoolEntity(vlm3Id, null, null), USER3);
 393
 394     assertVLMInWantedLocationInVSPList(vlm3Id, 0, USER3);
 395   }
 396
 397   @Test(dependsOnMethods = {"testOldVLMAfterChangeShouldBeInBeginningOfList"})
 398   public void testAddNewVLMShouldBeInBeginningOfList() {
 399     VendorLicenseModelEntity vlm = createVendorLicenseModel("test_vlm3", "desc", "icon");
 400     String vlm5Id = vendorLicenseManager.createVendorLicenseModel(vlm, USER3).getId();
 401
 402     assertVLMInWantedLocationInVSPList(vlm5Id, 0, USER3);
 403   }
 404
 405   @Test(dependsOnMethods = {"testAddNewVLMShouldBeInBeginningOfList"})
 406   public void testVLMInBeginningOfListAfterCheckin() {
 407     vendorLicenseManager.checkin(vlm4Id, USER3);
 408     assertVLMInWantedLocationInVSPList(vlm4Id, 0, USER3);
 409   }
 410
 411   @Test(dependsOnMethods = {"testVLMInBeginningOfListAfterCheckin"})
 412   public void testVLMInBeginningOfListAfterCheckout() {
 413     vendorLicenseManager.checkin(vlm3Id, USER3);
 414     assertVLMInWantedLocationInVSPList(vlm3Id, 0, USER3);
 415
 416     vendorLicenseManager.checkout(vlm4Id, USER3);
 417     assertVLMInWantedLocationInVSPList(vlm4Id, 0, USER3);
 418   }
 419
 420   @Test(dependsOnMethods = {"testVLMInBeginningOfListAfterCheckout"})
 421   public void testVLMInBeginningOfListAfterUndoCheckout() {
 422     vendorLicenseManager.checkout(vlm3Id, USER3);
 423     vendorLicenseManager.undoCheckout(vlm3Id, USER3);
 424     assertVLMInWantedLocationInVSPList(vlm3Id, 0, USER3);
 425   }
 426
 427   private void assertVLMInWantedLocationInVSPList(String vlmId, int location, String user) {
 428     List<VersionedVendorLicenseModel> vlmList =
 429         (List<VersionedVendorLicenseModel>) vendorLicenseManager
 430             .listVendorLicenseModels(null, user);
 431     Assert.assertEquals(vlmList.get(location).getVendorLicenseModel().getId(), vlmId);
 432   }
 433
 434
 435 }
 436 */