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

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