openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/VersioningManagerTest.java

   1 package org.openecomp.sdc.versioning;
   2
   3
   4 import org.openecomp.sdc.common.errors.CoreException;
   5 import org.openecomp.sdc.versioning.dao.VersionInfoDao;
   6 import org.openecomp.sdc.versioning.dao.VersionInfoDaoFactory;
   7 import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
   8 import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDaoFactory;
   9 import org.openecomp.sdc.versioning.dao.types.Version;
  10 import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
  11 import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
  12 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  13 import org.openecomp.sdc.versioning.types.VersionInfo;
  14 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
  15 import org.openecomp.sdc.versioning.types.VersionableEntityMetadata;
  16 import org.openecomp.core.nosqldb.api.NoSqlDb;
  17 import org.openecomp.core.nosqldb.factory.NoSqlDbFactory;
  18 import com.datastax.driver.core.ResultSet;
  19 import com.datastax.driver.mapping.UDTMapper;
  20
  21 import org.testng.Assert;
  22 import org.testng.annotations.BeforeClass;
  23 import org.testng.annotations.Test;
  24
  25 import java.util.HashSet;
  26 import java.util.Map;
  27 import java.util.Set;
  28
  29 public class VersioningManagerTest {
  30   private static final VersioningManager versioningManager =
  31       VersioningManagerFactory.getInstance().createInterface();
  32   private static final VersionInfoDao versionInfoDao =
  33       VersionInfoDaoFactory.getInstance().createInterface();
  34   private static final VersionInfoDeletedDao versionInfoDeletedDao =
  35       VersionInfoDeletedDaoFactory.getInstance().createInterface();
  36   private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
  37   private static final String USR1 = "usr1";
  38   private static final String USR2 = "usr2";
  39   private static final String USR3 = "usr3";
  40   private static final String TYPE1 = "Type1";
  41   private static final String TYPE2 = "Type2";
  42   private static final String ID1 = "Id1";
  43   private static final String ID2 = "Id2";
  44   private static final String ID3 = "Id3";
  45   private static final String TYPE1_TABLE_NAME = "vendor_license_model";
  46   private static final String TYPE1_ID_NAME = "vlm_id";
  47   private static final String TYPE1_VERSION_NAME = "version";
  48   private static final String TYPE2_TABLE_NAME = "feature_group";
  49   private static final String TYPE2_ID_NAME = "vlm_id";
  50   private static final String TYPE2_VERSION_NAME = "version";
  51   private static final Version VERSION01 = new Version(0, 1);
  52   private static final Version VERSION02 = new Version(0, 2);
  53   private static final Version VERSION10 = new Version(1, 0);
  54   private static final Version VERSION11 = new Version(1, 1);
  55   private static UDTMapper<Version> versionMapper =
  56       noSqlDb.getMappingManager().udtMapper(Version.class);
  57   private static Set<Version> expectedViewableVersionsType1Id1 = new HashSet<>();
  58
  59   private static void assretVersionInfoEntity(VersionInfoEntity actual, String entityType,
  60                                               String entityId, Version activeVersion,
  61                                               Version candidateVersion, String candidateUser,
  62                                               VersionStatus status, Set<Version> viewbleVersions,
  63                                               Version latestFinalVersion) {
  64     Assert.assertNotNull(actual);
  65     Assert.assertEquals(actual.getEntityType(), entityType);
  66     Assert.assertEquals(actual.getEntityId(), entityId);
  67     Assert.assertEquals(actual.getActiveVersion(), activeVersion);
  68     if (candidateVersion != null && candidateUser != null) {
  69       Assert.assertEquals(actual.getCandidate().getVersion(), candidateVersion);
  70       Assert.assertEquals(actual.getCandidate().getUser(), candidateUser);
  71     } else {
  72       Assert.assertNull(actual.getCandidate());
  73     }
  74     Assert.assertEquals(actual.getStatus(), status);
  75     Assert.assertEquals(actual.getViewableVersions().size(), viewbleVersions.size());
  76     Assert.assertEquals(actual.getViewableVersions(), viewbleVersions);
  77     Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
  78   }
  79
  80   private static void assretVersionInfo(VersionInfo actual, Version activeVersion,
  81                                         VersionStatus status, String lockingUser,
  82                                         Set<Version> viewableVersions, Version latestFinalVersion) {
  83     Assert.assertNotNull(actual);
  84     Assert.assertEquals(actual.getActiveVersion(), activeVersion);
  85     Assert.assertEquals(actual.getStatus(), status);
  86     Assert.assertEquals(actual.getLockingUser(), lockingUser);
  87     Assert.assertEquals(actual.getViewableVersions().size(), viewableVersions.size());
  88     Assert.assertEquals(actual.getViewableVersions(), viewableVersions);
  89     Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
  90   }
  91
  92 //  @BeforeClass
  93   private void init() {
  94     versionInfoDao.delete(new VersionInfoEntity(TYPE1, ID1));
  95     versionInfoDao.delete(new VersionInfoEntity(TYPE1, ID2));
  96     versionInfoDao.delete(new VersionInfoEntity(TYPE2, ID3));
  97     String deleteFromType1 = String
  98         .format("delete from %s where %s=? and %s=?", TYPE1_TABLE_NAME, TYPE1_ID_NAME,
  99             TYPE1_VERSION_NAME);
 100     noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION01));
 101     noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION02));
 102     noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION11));
 103
 104     versioningManager.register(TYPE1,
 105         new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME));
 106     versioningManager.register(TYPE2,
 107         new VersionableEntityMetadata(TYPE2_TABLE_NAME, TYPE2_ID_NAME, TYPE2_VERSION_NAME));
 108   }
 109
 110 //  @Test
 111   public void createTest() {
 112     Version version = versioningManager.create(TYPE1, ID1, USR1);
 113     createVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 114         version);
 115
 116     VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 117     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(0, 0), VERSION01, USR1,
 118         VersionStatus.Locked, expectedViewableVersionsType1Id1, null);
 119   }
 120
 121 //  @Test(dependsOnMethods = "createTest")
 122   public void checkinTest() {
 123     Version version = versioningManager.checkin(TYPE1, ID1, USR1, "checkin 0.1");
 124     Assert.assertEquals(version, VERSION01);
 125
 126     VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 127     expectedViewableVersionsType1Id1.add(VERSION01);
 128     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
 129         VersionStatus.Available, expectedViewableVersionsType1Id1, null);
 130   }
 131
 132 //  @Test(dependsOnMethods = "checkinTest")
 133   public void getVersionInfoForReadOnAvailableTest() {
 134     VersionInfo versionInfo =
 135         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Read);
 136     assretVersionInfo(versionInfo, VERSION01, VersionStatus.Available, null,
 137         expectedViewableVersionsType1Id1, null);
 138   }
 139
 140 //  @Test(dependsOnMethods = "getVersionInfoForReadOnAvailableTest",
 141 //      expectedExceptions = CoreException.class)
 142   public void getVersionInfoForWriteOnAvailableTest() {
 143     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Write);
 144   }
 145
 146 //  @Test(dependsOnMethods = "getVersionInfoForWriteOnAvailableTest",
 147 //      expectedExceptions = CoreException.class)
 148   public void checkinOnAvailableTest() {
 149     versioningManager.checkin(TYPE1, ID1, USR1, "fail checkin");
 150   }
 151
 152 //  @Test(dependsOnMethods = "checkinOnAvailableTest", expectedExceptions = CoreException.class)
 153   public void undoCheckoutOnAvailableTest() {
 154     versioningManager.undoCheckout(TYPE1, ID1, USR1);
 155   }
 156
 157 //  @Test(dependsOnMethods = "undoCheckoutOnAvailableTest")
 158   public void checkoutTest() {
 159     Version version = versioningManager.checkout(TYPE1, ID1, USR2);
 160     Assert.assertEquals(version, VERSION02);
 161
 162     VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 163     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, VERSION02, USR2,
 164         VersionStatus.Locked, expectedViewableVersionsType1Id1, null);
 165
 166     ResultSet results =
 167         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 168             VERSION02);
 169     Assert.assertTrue(results.iterator().hasNext());
 170   }
 171
 172 //  @Test(dependsOnMethods = "checkoutTest")
 173   public void getVersionInfoForReadOnLockedSameUserTest() {
 174     VersionInfo versionInfo =
 175         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Read);
 176     Set<Version> expectedViewableVersions = new HashSet<>();
 177     expectedViewableVersions.addAll(expectedViewableVersionsType1Id1);
 178     expectedViewableVersions.add(VERSION02);
 179     assretVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR2, expectedViewableVersions,
 180         null);
 181   }
 182
 183 //  @Test(dependsOnMethods = "getVersionInfoForReadOnLockedSameUserTest")
 184   public void getVersionInfoForReadOnLockedOtherUserTest() {
 185     VersionInfo entityVersionInfo =
 186         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 187     Assert.assertEquals(entityVersionInfo.getActiveVersion(), VERSION01);
 188   }
 189
 190 //  @Test(dependsOnMethods = "getVersionInfoForReadOnLockedOtherUserTest",
 191 //      expectedExceptions = CoreException.class)
 192   public void getVersionInfoForWriteOnLockedOtherUserTest() {
 193     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write)
 194         .getActiveVersion();
 195   }
 196
 197 //  @Test(dependsOnMethods = "getVersionInfoForWriteOnLockedOtherUserTest")
 198   public void getVersionInfoForWriteOnLockedSameUserTest() {
 199     Version activeVersion =
 200         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR2, VersionableEntityAction.Write)
 201             .getActiveVersion();
 202     Assert.assertEquals(activeVersion, VERSION02);
 203   }
 204
 205 //  @Test(dependsOnMethods = "getVersionInfoForWriteOnLockedSameUserTest",
 206 //      expectedExceptions = CoreException.class)
 207   public void checkoutOnLockedSameUserTest() {
 208     versioningManager.checkout(TYPE1, ID1, USR2);
 209   }
 210
 211 //  @Test(dependsOnMethods = "checkoutOnLockedSameUserTest", expectedExceptions = CoreException.class)
 212   public void checkoutOnLockedOtherUserTest() {
 213     versioningManager.checkout(TYPE1, ID1, USR1);
 214   }
 215
 216 //  @Test(dependsOnMethods = "checkoutOnLockedSameUserTest", expectedExceptions = CoreException.class)
 217   public void undoCheckoutOnLockedOtherUserTest() {
 218     versioningManager.undoCheckout(TYPE1, ID1, USR1);
 219   }
 220
 221 //  @Test(dependsOnMethods = "undoCheckoutOnLockedOtherUserTest",
 222 //      expectedExceptions = CoreException.class)
 223   public void submitOnLockedTest() {
 224     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
 225   }
 226
 227 //  @Test(dependsOnMethods = "submitOnLockedTest")
 228   public void undoCheckoutTest() {
 229     Version version = versioningManager.undoCheckout(TYPE1, ID1, USR2);
 230     Assert.assertEquals(version, VERSION01);
 231
 232     VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 233     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
 234         VersionStatus.Available, expectedViewableVersionsType1Id1, null);
 235
 236     ResultSet results =
 237         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 238             VERSION02);
 239     Assert.assertFalse(results.iterator().hasNext());
 240   }
 241
 242 //  @Test(dependsOnMethods = "undoCheckoutTest")
 243   public void submitTest() {
 244     Version version = versioningManager.submit(TYPE1, ID1, USR3, "submit msg");
 245     Assert.assertEquals(version, VERSION10);
 246     expectedViewableVersionsType1Id1 = new HashSet<>();
 247     expectedViewableVersionsType1Id1.add(version);
 248
 249     VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 250     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, null, null,
 251         VersionStatus.Final, expectedViewableVersionsType1Id1, VERSION10);
 252
 253     ResultSet results =
 254         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 255             VERSION10);
 256     Assert.assertTrue(results.iterator().hasNext());
 257   }
 258
 259 //  @Test(dependsOnMethods = "submitTest", expectedExceptions = CoreException.class)
 260   public void checkinOnFinalizedTest() {
 261     versioningManager.checkin(TYPE1, ID1, USR2, "failed checkin");
 262   }
 263
 264 //  @Test(dependsOnMethods = "checkinOnFinalizedTest", expectedExceptions = CoreException.class)
 265   public void undoCheckouOnFinalizedTest() {
 266     versioningManager.undoCheckout(TYPE1, ID1, USR2);
 267   }
 268
 269 //  @Test(dependsOnMethods = "undoCheckouOnFinalizedTest", expectedExceptions = CoreException.class)
 270   public void submitOnFinalizedTest() {
 271     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
 272   }
 273
 274 //  @Test(dependsOnMethods = "submitOnFinalizedTest")
 275   public void checkoutOnFinalizedTest() {
 276     Version version = versioningManager.checkout(TYPE1, ID1, USR3);
 277     Assert.assertEquals(version, VERSION11);
 278
 279     VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 280     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, VERSION11, USR3,
 281         VersionStatus.Locked, expectedViewableVersionsType1Id1, VERSION10);
 282
 283     ResultSet results =
 284         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 285             VERSION11);
 286     Assert.assertTrue(results.iterator().hasNext());
 287   }
 288
 289 //  @Test(dependsOnMethods = "checkoutOnFinalizedTest")
 290   public void viewableVersionsTest() {
 291     versioningManager.checkin(TYPE1, ID1, USR3, "check in 1.1");
 292     versioningManager.checkout(TYPE1, ID1, USR3);
 293     versioningManager.checkin(TYPE1, ID1, USR3, "check in 1.2");
 294     versioningManager.submit(TYPE1, ID1, USR3, "submit in 2.0");
 295     versioningManager.checkout(TYPE1, ID1, USR3);
 296     versioningManager.checkin(TYPE1, ID1, USR3, "check in 2.1");
 297     versioningManager.submit(TYPE1, ID1, USR3, "submit in 3.0");
 298     versioningManager.checkout(TYPE1, ID1, USR3);
 299     versioningManager.checkin(TYPE1, ID1, USR3, "check in 3.1");
 300     versioningManager.checkout(TYPE1, ID1, USR3);
 301     versioningManager.checkin(TYPE1, ID1, USR3, "check in 3.2");
 302     versioningManager.checkout(TYPE1, ID1, USR2);
 303
 304     VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 305     HashSet<Version> expectedViewableVersions = new HashSet<>();
 306     expectedViewableVersions.add(VERSION10);
 307     expectedViewableVersions.add(new Version(2, 0));
 308     expectedViewableVersions.add(new Version(3, 0));
 309     expectedViewableVersions.add(new Version(3, 1));
 310     expectedViewableVersions.add(new Version(3, 2));
 311     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(3, 2), new Version(3, 3),
 312         USR2, VersionStatus.Locked, expectedViewableVersions, new Version(3, 0));
 313   }
 314
 315 //  @Test(dependsOnMethods = "viewableVersionsTest")
 316   public void listActiveVersionsTest() {
 317     versioningManager.create(TYPE1, ID2, USR3);
 318     versioningManager.checkin(TYPE1, ID2, USR3, "check in 0.1");
 319
 320     versioningManager.create(TYPE2, ID3, USR3);
 321     versioningManager.checkin(TYPE2, ID3, USR3, "check in 0.1");
 322
 323     Map<String, VersionInfo> idToVersionInfo =
 324         versioningManager.listEntitiesVersionInfo(TYPE1, USR2, VersionableEntityAction.Read);
 325     Assert.assertEquals(idToVersionInfo.size(), 2);
 326     Assert.assertEquals(idToVersionInfo.get(ID1).getActiveVersion(), new Version(3, 3));
 327     Assert.assertEquals(idToVersionInfo.get(ID2).getActiveVersion(), VERSION01);
 328   }
 329
 330 //  @Test(dependsOnMethods = "listActiveVersionsTest")
 331   public void deleteTest() {
 332     versioningManager.checkin(TYPE1, ID1, USR2, "check in for delete");
 333     versioningManager.delete(TYPE1, ID1, USR1);
 334
 335     VersionInfoDeletedEntity versionInfoDeletedEntity =
 336         versionInfoDeletedDao.get(new VersionInfoDeletedEntity(TYPE1, ID1));
 337     Assert.assertNotNull(versionInfoDeletedEntity);
 338
 339     Map<String, VersionInfo> entitiesInfoMap =
 340         versioningManager.listDeletedEntitiesVersionInfo(TYPE1, USR2, null);
 341     Assert.assertEquals(entitiesInfoMap.size(), 1);
 342     VersionInfoEntity versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 343     Assert.assertNull(versionInfoEntity);
 344     versioningManager.undoDelete(TYPE1, ID1, USR1);
 345     versionInfoEntity = versionInfoDao.get(new VersionInfoEntity(TYPE1, ID1));
 346     Assert.assertNotNull(versionInfoEntity);
 347
 348
 349   }
 350
 351   private void createVersionableEntityRecord(String tableName, String idName, String versionName,
 352                                              String id, Version version) {
 353     noSqlDb.execute(
 354         String.format("insert into %s (%s,%s) values (?,?)", tableName, idName, versionName), id,
 355         versionMapper.toUDT(version));
 356   }
 357
 358   private ResultSet loadVersionableEntityRecord(String tableName, String idName, String versionName,
 359                                                 String id, Version version) {
 360     return noSqlDb.execute(
 361         String.format("select * from %s where %s=? and %s=?", tableName, idName, versionName), id,
 362         versionMapper.toUDT(version));
 363   }
 364 }