gerrit.onap Code Review - sdc.git/blob

   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 package org.openecomp.sdc.versioning.impl;
  22
  23
  24 import static org.mockito.Matchers.anyObject;
  25 import static org.mockito.Mockito.doReturn;
  26 import static org.mockito.Mockito.verify;
  27
  28 import org.mockito.ArgumentCaptor;
  29 import org.mockito.Captor;
  30 import org.mockito.InjectMocks;
  31 import org.mockito.Mock;
  32 import org.mockito.MockitoAnnotations;
  33 import org.openecomp.sdc.common.errors.CoreException;
  34 import org.openecomp.sdc.versioning.dao.VersionInfoDao;
  35 import org.openecomp.sdc.versioning.dao.VersionInfoDeletedDao;
  36 import org.openecomp.sdc.versioning.dao.types.UserCandidateVersion;
  37 import org.openecomp.sdc.versioning.dao.types.Version;
  38 import org.openecomp.sdc.versioning.dao.types.VersionInfoDeletedEntity;
  39 import org.openecomp.sdc.versioning.dao.types.VersionInfoEntity;
  40 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  41 import org.openecomp.sdc.versioning.types.VersionInfo;
  42 import org.openecomp.sdc.versioning.types.VersionableEntityAction;
  43 import org.testng.Assert;
  44 import org.testng.annotations.BeforeMethod;
  45 import org.testng.annotations.Test;
  46
  47 import java.util.Collections;
  48 import java.util.HashSet;
  49 import java.util.Set;
  50
  51 public class VersioningManagerImplTest {
  52   private static final String USR1 = "usr1";
  53   private static final String USR2 = "usr2";
  54   private static final String TYPE1 = "Type1";
  55 /*  private static final String TYPE2 = "Type2";*/
  56   private static final String ID1 = "Id1";
  57 /*  private static final String ID2 = "Id2";
  58   private static final String ID3 = "Id3";
  59   private static final String TYPE1_TABLE_NAME = "vendor_license_model";
  60   private static final String TYPE1_ID_NAME = "vlm_id";
  61   private static final String TYPE1_VERSION_NAME = "version";
  62   private static final String TYPE2_TABLE_NAME = "feature_group";
  63   private static final String TYPE2_ID_NAME = "vlm_id";
  64   private static final String TYPE2_VERSION_NAME = "version";*/
  65   private static final Version VERSION0 = new Version(0, 0);
  66   private static final Version VERSION01 = new Version(0, 1);
  67   private static final Version VERSION02 = new Version(0, 2);
  68   private static final Version VERSION10 = new Version(1, 0);
  69   private static final Version VERSION11 = new Version(1, 1);
  70
  71   /*  private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
  72
  73     private static UDTMapper<Version> versionMapper =
  74         noSqlDb.getMappingManager().udtMapper(Version.class);*/
  75   @Mock
  76   private VersionInfoDao versionInfoDaoMock;
  77   @Mock
  78   private VersionInfoDeletedDao versionInfoDeletedDaoMock;
  79   @InjectMocks
  80   private VersioningManagerImpl versioningManager;
  81
  82   @Captor
  83   private ArgumentCaptor<VersionInfoEntity> versionInfoEntityArg;
  84
  85   @BeforeMethod
  86   public void setUp() throws Exception {
  87     MockitoAnnotations.initMocks(this);
  88   }
  89
  90   /*  @BeforeClass
  91     private void init() {
  92       versionInfoDaoMock.delete(new VersionInfoEntity(TYPE1, ID1));
  93       versionInfoDaoMock.delete(new VersionInfoEntity(TYPE1, ID2));
  94       versionInfoDaoMock.delete(new VersionInfoEntity(TYPE2, ID3));
  95       String deleteFromType1 = String
  96           .format("delete from %s where %s=? and %s=?", TYPE1_TABLE_NAME, TYPE1_ID_NAME,
  97               TYPE1_VERSION_NAME);
  98       noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION01));
  99       noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION02));
 100       noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION11));
 101
 102       versioningManager.register(TYPE1,
 103           new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME));
 104       versioningManager.register(TYPE2,
 105           new VersionableEntityMetadata(TYPE2_TABLE_NAME, TYPE2_ID_NAME, TYPE2_VERSION_NAME));
 106     }*/
 107
 108 /*  @Test
 109   public void testRegister() throws Exception {
 110     VersionableEntityMetadata entityMetadata =
 111         new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME);
 112     versioningManager.register(TYPE1, entityMetadata);
 113
 114     Map<String, Set<VersionableEntityMetadata>> versionableEntities =
 115         versionableEntitiesCapture.capture();
 116     Set<VersionableEntityMetadata> type1Entities = versionableEntities.get(TYPE1);
 117     Assert.assertNotNull(type1Entities);
 118     Assert.assertTrue(type1Entities.contains(entityMetadata));
 119   }*/
 120
 121   @Test(expectedExceptions = CoreException.class)
 122   public void testCreateAlreadyExisting() {
 123     doReturn(new VersionInfoEntity()).when(versionInfoDaoMock).get(anyObject());
 124     versioningManager.create(TYPE1, ID1, USR1);
 125   }
 126
 127   @Test
 128   public void testCreate() {
 129     Version version = versioningManager.create(TYPE1, ID1, USR1);
 130     Assert.assertEquals(version, VERSION01);
 131
 132 /*    createVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 133         version);*/
 134     verify(versionInfoDaoMock).create(versionInfoEntityArg.capture());
 135     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 136     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(0, 0), VERSION01, USR1,
 137         VersionStatus.Locked, new HashSet<>(), null);
 138   }
 139
 140   @Test(expectedExceptions = CoreException.class)
 141   public void testDeleteNonExisting() {
 142     versioningManager.delete(TYPE1, ID1, USR1);
 143   }
 144
 145   @Test(expectedExceptions = CoreException.class)
 146   public void testDeleteLocked() {
 147     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 148         new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null);
 149     versioningManager.delete(TYPE1, ID1, USR1);
 150   }
 151
 152   @Test
 153   public void testDelete() {
 154     VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
 155     versionInfoEntity.setStatus(VersionStatus.Available);
 156     doReturn(versionInfoEntity).when(versionInfoDaoMock).get(anyObject());
 157
 158     versioningManager.delete(TYPE1, ID1, USR1);
 159
 160     verify(versionInfoDaoMock).delete(versionInfoEntity);
 161     ArgumentCaptor<VersionInfoDeletedEntity> versionInfoDeletedEntityArg =
 162         ArgumentCaptor.forClass(VersionInfoDeletedEntity.class);
 163     verify(versionInfoDeletedDaoMock).create(versionInfoDeletedEntityArg.capture());
 164   }
 165
 166   @Test(expectedExceptions = CoreException.class)
 167   public void testUndoDeleteNonExisting() {
 168     versioningManager.undoDelete(TYPE1, ID1, USR1);
 169   }
 170
 171   @Test
 172   public void testUndoDelete() {
 173     VersionInfoDeletedEntity versionInfoDeletedEntity = new VersionInfoDeletedEntity();
 174     versionInfoDeletedEntity.setStatus(VersionStatus.Available);
 175     doReturn(versionInfoDeletedEntity).when(versionInfoDeletedDaoMock).get(anyObject());
 176
 177     versioningManager.undoDelete(TYPE1, ID1, USR1);
 178
 179     verify(versionInfoDeletedDaoMock).delete(versionInfoDeletedEntity);
 180     verify(versionInfoDaoMock).create(versionInfoEntityArg.capture());
 181 /*
 182     VersionInfoDeletedEntity versionInfoDeletedEntity =
 183         versionInfoDeletedDaoMock.get(new VersionInfoDeletedEntity(TYPE1, ID1));
 184     Assert.assertNotNull(versionInfoDeletedEntity);
 185
 186     Map<String, VersionInfo> entitiesInfoMap =
 187         versioningManager.listDeletedEntitiesVersionInfo(TYPE1, USR2, null);
 188     Assert.assertEquals(entitiesInfoMap.size(), 1);
 189     VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
 190     Assert.assertNull(versionInfoEntity);
 191     versioningManager.undoDelete(TYPE1, ID1, USR1);
 192     versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
 193     Assert.assertNotNull(versionInfoEntity);*/
 194   }
 195
 196   @Test(expectedExceptions = CoreException.class)
 197   public void testCheckoutNonExisting() {
 198     versioningManager.checkout(TYPE1, ID1, USR2);
 199   }
 200
 201   @Test(expectedExceptions = CoreException.class)
 202   public void testCheckoutOnLockedSameUser() {
 203     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 204         new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null);
 205     versioningManager.checkout(TYPE1, ID1, USR1);
 206   }
 207
 208   @Test(expectedExceptions = CoreException.class)
 209   public void testCheckoutOnLockedOtherUser() {
 210     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 211         new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null);
 212     versioningManager.checkout(TYPE1, ID1, USR1);
 213   }
 214
 215   @Test
 216   public void testCheckoutOnFinalized() {
 217     Set<Version> viewableVersions = new HashSet<>();
 218     viewableVersions.add(VERSION10);
 219     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Final, VERSION10, null, viewableVersions,
 220         VERSION10);
 221
 222     Version version = versioningManager.checkout(TYPE1, ID1, USR1);
 223     Assert.assertEquals(version, VERSION11);
 224
 225     VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
 226     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, VERSION11, USR1,
 227         VersionStatus.Locked, viewableVersions, VERSION10);
 228 /*
 229     ResultSet results =
 230         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 231             VERSION11);
 232     Assert.assertTrue(results.iterator().hasNext());*/
 233   }
 234
 235   @Test
 236   public void testCheckout() {
 237     Set<Version> viewableVersions = new HashSet<>();
 238     viewableVersions.add(VERSION01);
 239     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
 240         null);
 241
 242     Version version = versioningManager.checkout(TYPE1, ID1, USR1);
 243     Assert.assertEquals(version, VERSION02);
 244
 245     verify(versionInfoDaoMock).update(versionInfoEntityArg.capture());
 246     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 247
 248     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, VERSION02, USR1,
 249         VersionStatus.Locked, viewableVersions, null);
 250
 251 /*    ResultSet results =
 252         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 253             VERSION02);
 254     Assert.assertTrue(results.iterator().hasNext());*/
 255   }
 256
 257   @Test(expectedExceptions = CoreException.class)
 258   public void testUndoCheckoutNonExisting() {
 259     versioningManager.undoCheckout(TYPE1, ID1, USR1);
 260   }
 261
 262   @Test(expectedExceptions = CoreException.class)
 263   public void testUndoCheckoutOnAvailable() {
 264     Set<Version> viewableVersions = new HashSet<>();
 265     viewableVersions.add(VERSION01);
 266     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
 267         null);
 268
 269     versioningManager.undoCheckout(TYPE1, ID1, USR1);
 270   }
 271
 272   @Test(expectedExceptions = CoreException.class)
 273   public void testUndoCheckouOnFinalized() {
 274     Set<Version> viewableVersions = new HashSet<>();
 275     viewableVersions.add(VERSION10);
 276     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Final, VERSION10, null, viewableVersions,
 277         VERSION10);
 278     versioningManager.undoCheckout(TYPE1, ID1, USR2);
 279   }
 280
 281   @Test(expectedExceptions = CoreException.class)
 282   public void testUndoCheckoutOnLockedOtherUser() {
 283     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 284         new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null);
 285
 286     versioningManager.undoCheckout(TYPE1, ID1, USR1);
 287   }
 288
 289   @Test
 290   public void testUndoCheckout() {
 291     HashSet<Version> viewableVersions = new HashSet<>();
 292     viewableVersions.add(VERSION01);
 293     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 294         new UserCandidateVersion(USR1, VERSION02), viewableVersions, null);
 295
 296     Version version = versioningManager.undoCheckout(TYPE1, ID1, USR1);
 297     Assert.assertEquals(version, VERSION01);
 298
 299     VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
 300     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
 301         VersionStatus.Available, viewableVersions, null);
 302
 303 /*    ResultSet results =
 304         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 305             VERSION02);
 306     Assert.assertFalse(results.iterator().hasNext());*/
 307   }
 308
 309   @Test(expectedExceptions = CoreException.class)
 310   public void testCheckinNonExisting() {
 311     versioningManager.checkin(TYPE1, ID1, USR1, "");
 312   }
 313
 314   @Test(expectedExceptions = CoreException.class)
 315   public void testCheckinOnAvailable() {
 316     Set<Version> viewableVersions = new HashSet<>();
 317     viewableVersions.add(VERSION01);
 318     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
 319         null);
 320
 321     versioningManager.checkin(TYPE1, ID1, USR1, "fail checkin");
 322   }
 323
 324
 325   @Test(expectedExceptions = CoreException.class)
 326   public void testCheckinOnFinalized() {
 327     Set<Version> viewableVersions = new HashSet<>();
 328     viewableVersions.add(VERSION10);
 329     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Final, VERSION10, null, viewableVersions,
 330         VERSION10);
 331
 332     versioningManager.checkin(TYPE1, ID1, USR1, "failed checkin");
 333   }
 334
 335   @Test(expectedExceptions = CoreException.class)
 336   public void testCheckinOnLockedOtherUser() {
 337     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 338         new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null);
 339
 340     versioningManager.checkin(TYPE1, ID1, USR1, "");
 341   }
 342
 343   @Test
 344   public void testCheckin() {
 345     HashSet<Version> viewableVersions = new HashSet<>();
 346     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 347         new UserCandidateVersion(USR1, VERSION01), viewableVersions, null);
 348
 349     Version version = versioningManager.checkin(TYPE1, ID1, USR1, "checkin 0.1");
 350     Assert.assertEquals(version, VERSION01);
 351
 352     verify(versionInfoDaoMock).update(versionInfoEntityArg.capture());
 353     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 354
 355     viewableVersions.add(VERSION01);
 356     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
 357         VersionStatus.Available, viewableVersions, null);
 358   }
 359
 360   @Test(expectedExceptions = CoreException.class)
 361   public void testSubmitNonExisting() {
 362     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
 363   }
 364
 365   @Test(expectedExceptions = CoreException.class)
 366   public void testSubmitOnLocked() {
 367     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 368         new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null);
 369     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
 370   }
 371
 372
 373   @Test(expectedExceptions = CoreException.class)
 374   public void testSubmitOnFinalized() {
 375     Set<Version> viewableVersions = new HashSet<>();
 376     viewableVersions.add(VERSION10);
 377     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Final, VERSION10, null, viewableVersions,
 378         VERSION10);
 379     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
 380   }
 381
 382   @Test
 383   public void testSubmit() {
 384     Version version32 = new Version(3, 2);
 385     Version version40 = new Version(4, 0);
 386
 387     Set<Version> viewableVersions = new HashSet<>();
 388     viewableVersions.add(VERSION10);
 389     viewableVersions.add(new Version(2, 0));
 390     viewableVersions.add(new Version(3, 0));
 391     viewableVersions.add(new Version(3, 1));
 392     viewableVersions.add(version32);
 393     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, version32, null, viewableVersions,
 394         new Version(3, 0));
 395
 396     Version version = versioningManager.submit(TYPE1, ID1, USR1, "submit msg");
 397     Assert.assertEquals(version, version40);
 398     viewableVersions.remove(new Version(3, 1));
 399     viewableVersions.remove(version32);
 400     viewableVersions.add(version40);
 401
 402     verify(versionInfoDaoMock).update(versionInfoEntityArg.capture());
 403     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 404
 405     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, version40, null, null,
 406         VersionStatus.Final, viewableVersions, version40);
 407
 408 /*    ResultSet results =
 409         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 410             VERSION10);
 411     Assert.assertTrue(results.iterator().hasNext());*/
 412   }
 413
 414   @Test(expectedExceptions = CoreException.class)
 415   public void testGetVersionInfoOnNonExistingEntity() {
 416     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 417   }
 418
 419   @Test
 420   public void testGetVersionInfoForReadOnAvailable() {
 421     Set<Version> viewableVersions = new HashSet<>();
 422     viewableVersions.add(VERSION01);
 423     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
 424         null);
 425
 426     VersionInfo versionInfo =
 427         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 428     assertVersionInfo(versionInfo, VERSION01, VersionStatus.Available, null,
 429         viewableVersions, null);
 430   }
 431
 432   @Test(expectedExceptions = CoreException.class)
 433   public void testGetVersionInfoForWriteOnAvailable() {
 434     Set<Version> viewableVersions = new HashSet<>();
 435     viewableVersions.add(VERSION01);
 436     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Available, VERSION01, null, viewableVersions,
 437         null);
 438
 439     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write);
 440   }
 441
 442   @Test
 443   public void testGetVersionInfoForReadOnLockedSameUser() {
 444     Set<Version> viewableVersions = new HashSet<>();
 445     viewableVersions.add(VERSION01);
 446     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 447         new UserCandidateVersion(USR1, VERSION02), viewableVersions, null);
 448
 449     VersionInfo versionInfo =
 450         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 451     viewableVersions.add(VERSION02);
 452     assertVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR1, viewableVersions, null);
 453   }
 454
 455   @Test
 456   public void testGetVersionInfoForReadOnLockedOtherUser() {
 457     Set<Version> viewableVersions = new HashSet<>();
 458     viewableVersions.add(VERSION01);
 459     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 460         new UserCandidateVersion(USR2, VERSION02), viewableVersions, null);
 461
 462     VersionInfo versionInfo =
 463         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 464     Assert.assertEquals(versionInfo.getActiveVersion(), VERSION01);
 465     assertVersionInfo(versionInfo, VERSION01, VersionStatus.Locked, USR2, viewableVersions, null);
 466   }
 467
 468   @Test(expectedExceptions = CoreException.class)
 469   public void testGetVersionInfoForWriteOnLockedOtherUser() {
 470     Set<Version> viewableVersions = new HashSet<>();
 471     viewableVersions.add(VERSION01);
 472     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 473         new UserCandidateVersion(USR2, VERSION02), viewableVersions, null);
 474
 475     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write);
 476   }
 477
 478   @Test
 479   public void testGetVersionInfoForWriteOnLockedSameUser() {
 480     Set<Version> viewableVersions = new HashSet<>();
 481     viewableVersions.add(VERSION01);
 482     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 483         new UserCandidateVersion(USR1, VERSION02), viewableVersions, null);
 484
 485     VersionInfo versionInfo =
 486         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write);
 487     viewableVersions.add(VERSION02);
 488     assertVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR1, viewableVersions, null);
 489   }
 490
 491 /*  private void createVersionableEntityRecord(String tableName, String idName, String versionName,
 492                                              String id, Version version) {
 493     noSqlDb.execute(
 494         String.format("insert into %s (%s,%s) values (?,?)", tableName, idName, versionName), id,
 495         versionMapper.toUDT(version));
 496   }
 497
 498   private ResultSet loadVersionableEntityRecord(String tableName, String idName, String versionName,
 499                                                 String id, Version version) {
 500     return noSqlDb.execute(
 501         String.format("select * from %s where %s=? and %s=?", tableName, idName, versionName), id,
 502         versionMapper.toUDT(version));
 503   }*/
 504
 505
 506   private static void assretVersionInfoEntity(VersionInfoEntity actual, String entityType,
 507                                               String entityId, Version activeVersion,
 508                                               Version candidateVersion, String candidateUser,
 509                                               VersionStatus status, Set<Version> viewbleVersions,
 510                                               Version latestFinalVersion) {
 511     Assert.assertNotNull(actual);
 512     Assert.assertEquals(actual.getEntityType(), entityType);
 513     Assert.assertEquals(actual.getEntityId(), entityId);
 514     Assert.assertEquals(actual.getActiveVersion(), activeVersion);
 515     if (candidateVersion != null && candidateUser != null) {
 516       Assert.assertEquals(actual.getCandidate().getVersion(), candidateVersion);
 517       Assert.assertEquals(actual.getCandidate().getUser(), candidateUser);
 518     } else {
 519       Assert.assertNull(actual.getCandidate());
 520     }
 521     Assert.assertEquals(actual.getStatus(), status);
 522     Assert.assertEquals(actual.getViewableVersions().size(), viewbleVersions.size());
 523     Assert.assertEquals(actual.getViewableVersions(), viewbleVersions);
 524     Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
 525   }
 526
 527   private static void assertVersionInfo(VersionInfo actual, Version activeVersion,
 528                                         VersionStatus status, String lockingUser,
 529                                         Set<Version> viewableVersions, Version latestFinalVersion) {
 530     Assert.assertNotNull(actual);
 531     Assert.assertEquals(actual.getActiveVersion(), activeVersion);
 532     Assert.assertEquals(actual.getStatus(), status);
 533     Assert.assertEquals(actual.getLockingUser(), lockingUser);
 534     Assert.assertEquals(actual.getViewableVersions().size(), viewableVersions.size());
 535     Assert.assertEquals(actual.getViewableVersions(), viewableVersions);
 536     Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
 537   }
 538
 539   private VersionInfoEntity mockVersionInfoEntity(String entityType, String entityId,
 540                                                   VersionStatus status, Version activeVersion,
 541                                                   UserCandidateVersion candidate,
 542                                                   Set<Version> viewableVersions,
 543                                                   Version latestFinalVersion) {
 544     VersionInfoEntity mock = new VersionInfoEntity();
 545     mock.setEntityType(entityType);
 546     mock.setEntityId(entityId);
 547     mock.setStatus(status);
 548     mock.setActiveVersion(activeVersion);
 549     mock.setCandidate(candidate);
 550     mock.setViewableVersions(viewableVersions);
 551     mock.setLatestFinalVersion(latestFinalVersion);
 552
 553     doReturn(mock).when(versionInfoDaoMock).get(anyObject());
 554     return mock;
 555   }
 556 }