openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/impl/VersioningManagerImplTest.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 package org.openecomp.sdc.versioning.impl;
  22
  23
  24 import org.mockito.ArgumentCaptor;
  25 import org.mockito.InjectMocks;
  26 import org.mockito.Mock;
  27 import org.mockito.MockitoAnnotations;
  28 import org.openecomp.sdc.common.errors.CoreException;
  29 import org.openecomp.sdc.versioning.ItemManager;
  30 import org.openecomp.sdc.versioning.VersionCalculator;
  31 import org.openecomp.sdc.versioning.dao.VersionDao;
  32 import org.openecomp.sdc.versioning.dao.types.Revision;
  33 import org.openecomp.sdc.versioning.dao.types.SynchronizationState;
  34 import org.openecomp.sdc.versioning.dao.types.Version;
  35 import org.openecomp.sdc.versioning.dao.types.VersionState;
  36 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  37 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  38 import org.testng.Assert;
  39 import org.testng.annotations.BeforeMethod;
  40 import org.testng.annotations.Test;
  41
  42 import java.util.List;
  43 import java.util.Optional;
  44 import java.util.stream.Collectors;
  45 import java.util.stream.Stream;
  46
  47 import static org.mockito.Matchers.any;
  48 import static org.mockito.Matchers.anyString;
  49 import static org.mockito.Matchers.eq;
  50 import static org.mockito.Mockito.doReturn;
  51 import static org.mockito.Mockito.doThrow;
  52 import static org.mockito.Mockito.never;
  53 import static org.mockito.Mockito.times;
  54 import static org.mockito.Mockito.verify;
  55 import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.OutOfSync;
  56 import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.UpToDate;
  57 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
  58 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
  59
  60 public class VersioningManagerImplTest {
  61   @Mock
  62   private VersionDao versionDaoMock;
  63   @Mock
  64   private VersionCalculator versionCalculatorMock;
  65   @Mock
  66   private ItemManager itemManagerMock;
  67   @InjectMocks
  68   private VersioningManagerImpl versioningManager;
  69
  70   @BeforeMethod
  71   public void setUp() throws Exception {
  72     MockitoAnnotations.initMocks(this);
  73   }
  74
  75   @Test
  76   public void testList() throws Exception {
  77     String itemId = "itemId";
  78
  79     List<Version> returnedVersions = Stream.of(createVersion("1", null, null, false),
  80         createVersion("2", null, null, false),
  81         createVersion("3", null, null, false)).collect(Collectors.toList());
  82     doReturn(returnedVersions).when(versionDaoMock).list(itemId);
  83
  84     List<Version> versions = versioningManager.list(itemId);
  85     Assert.assertEquals(versions, returnedVersions);
  86   }
  87
  88   @Test(expectedExceptions = Exception.class)
  89   public void testGetNonExisting() throws Exception {
  90     String itemId = "itemId";
  91     String versionId = "versionId";
  92     Version version = new Version(versionId);
  93
  94     doReturn(Optional.empty()).when(versionDaoMock).get(itemId, version);
  95     doThrow(new Exception()).when(versionDaoMock).sync(itemId, version);
  96
  97     versioningManager.get(itemId, version);
  98   }
  99
 100   @Test
 101   public void testGetNonExistingForUser() throws Exception {
 102     String itemId = "itemId";
 103     String versionId = "versionId";
 104     Version requestedVersion = new Version(versionId);
 105
 106     Version returnedVersion = createVersion(versionId, Draft, UpToDate, false);
 107     doReturn(Optional.empty()).doReturn(Optional.of(returnedVersion))
 108         .when(versionDaoMock).get(itemId, requestedVersion);
 109
 110     Version version = versioningManager.get(itemId, requestedVersion);
 111     Assert.assertEquals(version, returnedVersion);
 112
 113     verify(versionDaoMock, times(2)).get(itemId, requestedVersion);
 114     verify(versionDaoMock).sync(itemId, requestedVersion);
 115   }
 116
 117   @Test
 118   public void testGetOutOfSyncCertified() throws Exception {
 119     String itemId = "itemId";
 120     String versionId = "versionId";
 121     Version requestedVersion = new Version(versionId);
 122
 123     Version returnedVersion = createVersion(versionId, Certified, UpToDate, false);
 124     doReturn(Optional.of(createVersion(versionId, Certified, OutOfSync, false)))
 125         .doReturn(Optional.of(returnedVersion))
 126         .when(versionDaoMock).get(itemId, requestedVersion);
 127
 128     Version version = versioningManager.get(itemId, requestedVersion);
 129     Assert.assertEquals(version, returnedVersion);
 130
 131     verify(versionDaoMock, times(2)).get(itemId, requestedVersion);
 132     verify(versionDaoMock).forceSync(itemId, requestedVersion);
 133   }
 134
 135   @Test
 136   public void testGet() throws Exception {
 137     String itemId = "itemId";
 138     String versionId = "versionId";
 139     Version requestedVersion = new Version(versionId);
 140
 141     Version returnedVersion = createVersion(versionId, Draft, OutOfSync, true);
 142     doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(itemId, requestedVersion);
 143
 144     Version version = versioningManager.get(itemId, requestedVersion);
 145     Assert.assertEquals(version, returnedVersion);
 146
 147     verify(versionDaoMock).get(itemId, requestedVersion);
 148     verify(versionDaoMock, never()).sync(any(), any());
 149     verify(versionDaoMock, never()).forceSync(any(), any());
 150   }
 151
 152   @Test
 153   public void testCreate() throws Exception {
 154     String itemId = "itemId";
 155     Version requestedVersion = new Version();
 156
 157     String versionName = "versionName";
 158     doReturn(versionName).when(versionCalculatorMock).calculate(null, VersionCreationMethod.major);
 159
 160     doReturn(Stream.of(createVersion("1", null, null, false),
 161         createVersion("2", null, null, false),
 162         createVersion("3", null, null, false)).collect(Collectors.toList()))
 163         .when(versionDaoMock).list(itemId);
 164
 165     Version version =
 166         versioningManager.create(itemId, requestedVersion, VersionCreationMethod.major);
 167     Assert.assertNotNull(version);
 168     Assert.assertEquals(version.getName(), versionName);
 169
 170     verify(versionDaoMock).create(itemId, requestedVersion);
 171     verify(itemManagerMock).updateVersionStatus(itemId, Draft, null);
 172     verify(versionDaoMock).publish(eq(itemId), eq(requestedVersion), anyString());
 173   }
 174
 175   @Test
 176   public void testCreateBasedOn() throws Exception {
 177     String itemId = "itemId";
 178     Version requestedVersion = new Version();
 179     requestedVersion.setBaseId("baseVersionId");
 180
 181     Version baseVersion = createVersion(requestedVersion.getBaseId(), Certified, UpToDate, false);
 182     // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed
 183     doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(itemId), any(Version.class));
 184
 185     String versionName = "4.0";
 186     doReturn(versionName)
 187         .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major);
 188
 189     doReturn(Stream.of(createVersion("1", null, null, false),
 190         createVersion("2", null, null, false),
 191         createVersion("3", null, null, false)).collect(Collectors.toList()))
 192         .when(versionDaoMock).list(itemId);
 193
 194     Version version =
 195         versioningManager.create(itemId, requestedVersion, VersionCreationMethod.major);
 196     Assert.assertNotNull(version);
 197     Assert.assertEquals(version.getName(), versionName);
 198
 199     verify(versionDaoMock).create(itemId, requestedVersion);
 200     verify(itemManagerMock).updateVersionStatus(itemId, Draft, null);
 201     verify(versionDaoMock).publish(eq(itemId), eq(requestedVersion), anyString());
 202   }
 203
 204   @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp =
 205       "Item itemId: create version failed, a version with the name 2.0 already exist")
 206   public void testCreateWithExistingName() throws Exception {
 207     String itemId = "itemId";
 208     Version version = new Version();
 209     version.setBaseId("baseVersionId");
 210
 211     Version baseVersion = createVersion(version.getBaseId(), Certified, UpToDate, false);
 212     // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed
 213     doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(itemId), any(Version.class));
 214
 215     String versionName = "2.0";
 216     doReturn(versionName)
 217         .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major);
 218
 219     doReturn(Stream.of(createVersion("1", null, null, false),
 220         createVersion("2", null, null, false),
 221         createVersion("3", null, null, false)).collect(Collectors.toList()))
 222         .when(versionDaoMock).list(itemId);
 223
 224     versioningManager.create(itemId, version, VersionCreationMethod.major);
 225   }
 226
 227   @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp =
 228       "Item itemId: submit version failed, version versionId is already Certified")
 229   public void testSubmitCertified() throws Exception {
 230     String itemId = "itemId";
 231     String versionId = "versionId";
 232     Version version = new Version(versionId);
 233
 234     Version returnedVersion = createVersion(versionId, Certified, UpToDate, false);
 235     doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(itemId, version);
 236
 237     versioningManager.submit(itemId, version, "Submit message");
 238   }
 239
 240   @Test
 241   public void testSubmit() throws Exception {
 242     String itemId = "itemId";
 243     String versionId = "versionId";
 244     Version version = new Version(versionId);
 245
 246     ArgumentCaptor<Version> versionArgumentCaptor = ArgumentCaptor.forClass(Version.class);
 247
 248     Version returnedVersion = createVersion(versionId, Draft, UpToDate, false);
 249     doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(itemId, version);
 250
 251     String submitDescription = "Submit message";
 252     versioningManager.submit(itemId, version, submitDescription);
 253
 254     verify(versionDaoMock).update(eq(itemId), versionArgumentCaptor.capture());
 255     Assert.assertEquals(Certified, versionArgumentCaptor.getValue().getStatus());
 256     verify(versionDaoMock).publish(itemId, version, submitDescription);
 257     verify(itemManagerMock).updateVersionStatus(itemId, Certified, Draft);
 258   }
 259
 260   @Test
 261   public void testPublish() throws Exception {
 262     String itemId = "itemId";
 263     String versionId = "versionId";
 264     Version version = new Version(versionId);
 265     String publishDescription = "Publish message";
 266
 267     versioningManager.publish(itemId, version, publishDescription);
 268
 269     verify(versionDaoMock).publish(itemId, version, publishDescription);
 270   }
 271
 272   @Test
 273   public void testSync() throws Exception {
 274     String itemId = "itemId";
 275     String versionId = "versionId";
 276     Version version = new Version(versionId);
 277
 278     versioningManager.sync(itemId, version);
 279
 280     verify(versionDaoMock).sync(itemId, version);
 281   }
 282
 283   @Test
 284   public void testForceSync() throws Exception {
 285     String itemId = "itemId";
 286     String versionId = "versionId";
 287     Version version = new Version(versionId);
 288
 289     versioningManager.forceSync(itemId, version);
 290
 291     verify(versionDaoMock).forceSync(itemId, version);
 292   }
 293
 294   @Test
 295   public void testRevert() throws Exception {
 296     String itemId = "itemId";
 297     String versionId = "versionId";
 298     Version version = new Version(versionId);
 299     String revisionId = "revisionId";
 300
 301     versioningManager.revert(itemId, version, revisionId);
 302
 303     verify(versionDaoMock).revert(itemId, version, revisionId);
 304   }
 305
 306   @Test
 307   public void testListRevisions() throws Exception {
 308     String itemId = "itemId";
 309     String versionId = "versionId";
 310     Version version = new Version(versionId);
 311
 312     List<Revision> returnedRevisions =
 313         Stream.of(new Revision(), new Revision()).collect(Collectors.toList());
 314     doReturn(returnedRevisions)
 315         .when(versionDaoMock).listRevisions(itemId, version);
 316
 317     List<Revision> revisions = versioningManager.listRevisions(itemId, version);
 318     Assert.assertEquals(revisions, returnedRevisions);
 319   }
 320
 321   private Version createVersion(String id, VersionStatus status,
 322                                 SynchronizationState syncState, boolean dirty) {
 323     Version version = new Version(id);
 324     version.setName(id + ".0");
 325     version.setDescription(id + " desc");
 326     version.setStatus(status);
 327
 328     VersionState state = new VersionState();
 329     state.setSynchronizationState(syncState);
 330     state.setDirty(dirty);
 331     version.setState(state);
 332     return version;
 333   }
 334
 335 /*
 336   private static final String USR1 = "usr1";
 337   private static final String USR2 = "usr2";
 338   private static final String TYPE1 = "Type1";
 339 */
 340 /*  private static final String TYPE2 = "Type2";*//*
 341
 342   private static final String ID1 = "Id1";
 343 */
 344 /*  private static final String ID2 = "Id2";
 345   private static final String ID3 = "Id3";
 346   private static final String TYPE1_TABLE_NAME = "vendor_license_model";
 347   private static final String TYPE1_ID_NAME = "vlm_id";
 348   private static final String TYPE1_VERSION_NAME = "version";
 349   private static final String TYPE2_TABLE_NAME = "feature_group";
 350   private static final String TYPE2_ID_NAME = "vlm_id";
 351   private static final String TYPE2_VERSION_NAME = "version";*//*
 352
 353   private static final Version VERSION0 = new Version(0, 0);
 354   private static final Version VERSION01 = new Version(0, 1);
 355   private static final Version VERSION02 = new Version(0, 2);
 356   private static final Version VERSION10 = new Version(1, 0);
 357   private static final Version VERSION11 = new Version(1, 1);
 358
 359   */
 360 /*  private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface();
 361
 362     private static UDTMapper<Version> versionMapper =
 363         noSqlDb.getMappingManager().udtMapper(Version.class);*//*
 364
 365   @Mock
 366   private VersionInfoDao versionInfoDaoMock;
 367   @Mock
 368   private VersionInfoDeletedDao versionInfoDeletedDaoMock;
 369   @InjectMocks
 370   private VersioningManagerImpl versioningManager;
 371
 372   @Captor
 373   private ArgumentCaptor<VersionInfoEntity> versionInfoEntityArg;
 374
 375   @BeforeMethod
 376   public void setUp() throws Exception {
 377     MockitoAnnotations.initMocks(this);
 378   }
 379
 380   */
 381 /*  @BeforeClass
 382     private void init() {
 383       versionInfoDaoMock.delete(new VersionInfoEntity(TYPE1, ID1));
 384       versionInfoDaoMock.delete(new VersionInfoEntity(TYPE1, ID2));
 385       versionInfoDaoMock.delete(new VersionInfoEntity(TYPE2, ID3));
 386       String deleteFromType1 = String
 387           .format("delete from %s where %s=? and %s=?", TYPE1_TABLE_NAME, TYPE1_ID_NAME,
 388               TYPE1_VERSION_NAME);
 389       noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION01));
 390       noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION02));
 391       noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION11));
 392
 393       versioningManager.register(TYPE1,
 394           new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME));
 395       versioningManager.register(TYPE2,
 396           new VersionableEntityMetadata(TYPE2_TABLE_NAME, TYPE2_ID_NAME, TYPE2_VERSION_NAME));
 397     }*//*
 398
 399
 400 */
 401 /*  @Test
 402   public void testRegister() throws Exception {
 403     VersionableEntityMetadata entityMetadata =
 404         new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME);
 405     versioningManager.register(TYPE1, entityMetadata);
 406
 407     Map<String, Set<VersionableEntityMetadata>> versionableEntities =
 408         versionableEntitiesCapture.capture();
 409     Set<VersionableEntityMetadata> type1Entities = versionableEntities.get(TYPE1);
 410     Assert.assertNotNull(type1Entities);
 411     Assert.assertTrue(type1Entities.contains(entityMetadata));
 412   }*//*
 413
 414
 415   @Test(expectedExceptions = CoreException.class)
 416   public void testCreateAlreadyExisting() {
 417     doReturn(new VersionInfoEntity()).when(versionInfoDaoMock).get(anyObject());
 418     versioningManager.create(TYPE1, ID1, USR1);
 419   }
 420
 421   @Test
 422   public void testCreate() {
 423     Version version = versioningManager.create(TYPE1, ID1, USR1);
 424     Assert.assertEquals(version, VERSION01);
 425
 426 */
 427 /*    createVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 428         version);*//*
 429
 430     verify(versionInfoDaoMock).create(versionInfoEntityArg.capture());
 431     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 432     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(0, 0), VERSION01, USR1,
 433         VersionStatus.Locked, new HashSet<>(), null);
 434   }
 435
 436   @Test(expectedExceptions = CoreException.class)
 437   public void testDeleteNonExisting() {
 438     versioningManager.delete(TYPE1, ID1, USR1);
 439   }
 440
 441   @Test(expectedExceptions = CoreException.class)
 442   public void testDeleteLocked() {
 443     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 444         new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null);
 445     versioningManager.delete(TYPE1, ID1, USR1);
 446   }
 447
 448   @Test
 449   public void testDelete() {
 450     VersionInfoEntity versionInfoEntity = new VersionInfoEntity();
 451     versionInfoEntity.setStatus(VersionStatus.Draft);
 452     doReturn(versionInfoEntity).when(versionInfoDaoMock).get(anyObject());
 453
 454     versioningManager.delete(TYPE1, ID1, USR1);
 455
 456     verify(versionInfoDaoMock).delete(versionInfoEntity);
 457     ArgumentCaptor<VersionInfoDeletedEntity> versionInfoDeletedEntityArg =
 458         ArgumentCaptor.forClass(VersionInfoDeletedEntity.class);
 459     verify(versionInfoDeletedDaoMock).create(versionInfoDeletedEntityArg.capture());
 460   }
 461
 462   @Test(expectedExceptions = CoreException.class)
 463   public void testUndoDeleteNonExisting() {
 464     versioningManager.undoDelete(TYPE1, ID1, USR1);
 465   }
 466
 467   @Test
 468   public void testUndoDelete() {
 469     VersionInfoDeletedEntity versionInfoDeletedEntity = new VersionInfoDeletedEntity();
 470     versionInfoDeletedEntity.setStatus(VersionStatus.Draft);
 471     doReturn(versionInfoDeletedEntity).when(versionInfoDeletedDaoMock).get(anyObject());
 472
 473     versioningManager.undoDelete(TYPE1, ID1, USR1);
 474
 475     verify(versionInfoDeletedDaoMock).delete(versionInfoDeletedEntity);
 476     verify(versionInfoDaoMock).create(versionInfoEntityArg.capture());
 477 */
 478 /*
 479     VersionInfoDeletedEntity versionInfoDeletedEntity =
 480         versionInfoDeletedDaoMock.get(new VersionInfoDeletedEntity(TYPE1, ID1));
 481     Assert.assertNotNull(versionInfoDeletedEntity);
 482
 483     Map<String, VersionInfo> entitiesInfoMap =
 484         versioningManager.listDeletedEntitiesVersionInfo(TYPE1, USR2, null);
 485     Assert.assertEquals(entitiesInfoMap.size(), 1);
 486     VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
 487     Assert.assertNull(versionInfoEntity);
 488     versioningManager.undoDelete(TYPE1, ID1, USR1);
 489     versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
 490     Assert.assertNotNull(versionInfoEntity);*//*
 491
 492   }
 493
 494   @Test(expectedExceptions = CoreException.class)
 495   public void testCheckoutNonExisting() {
 496     versioningManager.checkout(TYPE1, ID1, USR2);
 497   }
 498
 499   @Test(expectedExceptions = CoreException.class)
 500   public void testCheckoutOnLockedSameUser() {
 501     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 502         new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null);
 503     versioningManager.checkout(TYPE1, ID1, USR1);
 504   }
 505
 506   @Test(expectedExceptions = CoreException.class)
 507   public void testCheckoutOnLockedOtherUser() {
 508     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 509         new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null);
 510     versioningManager.checkout(TYPE1, ID1, USR1);
 511   }
 512
 513   @Test
 514   public void testCheckoutOnFinalized() {
 515     Set<Version> viewableVersions = new HashSet<>();
 516     viewableVersions.add(VERSION10);
 517     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions,
 518         VERSION10);
 519
 520     Version version = versioningManager.checkout(TYPE1, ID1, USR1);
 521     Assert.assertEquals(version, VERSION11);
 522
 523     VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
 524     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, VERSION11, USR1,
 525         VersionStatus.Locked, viewableVersions, VERSION10);
 526 */
 527 /*
 528     ResultSet results =
 529         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 530             VERSION11);
 531     Assert.assertTrue(results.iterator().hasNext());*//*
 532
 533   }
 534
 535   @Test
 536   public void testCheckout() {
 537     Set<Version> viewableVersions = new HashSet<>();
 538     viewableVersions.add(VERSION01);
 539     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
 540         null);
 541
 542     Version version = versioningManager.checkout(TYPE1, ID1, USR1);
 543     Assert.assertEquals(version, VERSION02);
 544
 545     verify(versionInfoDaoMock).update(versionInfoEntityArg.capture());
 546     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 547
 548     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, VERSION02, USR1,
 549         VersionStatus.Locked, viewableVersions, null);
 550
 551 */
 552 /*    ResultSet results =
 553         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 554             VERSION02);
 555     Assert.assertTrue(results.iterator().hasNext());*//*
 556
 557   }
 558
 559   @Test(expectedExceptions = CoreException.class)
 560   public void testUndoCheckoutNonExisting() {
 561     versioningManager.undoCheckout(TYPE1, ID1, USR1);
 562   }
 563
 564   @Test(expectedExceptions = CoreException.class)
 565   public void testUndoCheckoutOnAvailable() {
 566     Set<Version> viewableVersions = new HashSet<>();
 567     viewableVersions.add(VERSION01);
 568     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
 569         null);
 570
 571     versioningManager.undoCheckout(TYPE1, ID1, USR1);
 572   }
 573
 574   @Test(expectedExceptions = CoreException.class)
 575   public void testUndoCheckouOnFinalized() {
 576     Set<Version> viewableVersions = new HashSet<>();
 577     viewableVersions.add(VERSION10);
 578     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions,
 579         VERSION10);
 580     versioningManager.undoCheckout(TYPE1, ID1, USR2);
 581   }
 582
 583   @Test(expectedExceptions = CoreException.class)
 584   public void testUndoCheckoutOnLockedOtherUser() {
 585     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 586         new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null);
 587
 588     versioningManager.undoCheckout(TYPE1, ID1, USR1);
 589   }
 590
 591   @Test
 592   public void testUndoCheckout() {
 593     HashSet<Version> viewableVersions = new HashSet<>();
 594     viewableVersions.add(VERSION01);
 595     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 596         new UserCandidateVersion(USR1, VERSION02), viewableVersions, null);
 597
 598     Version version = versioningManager.undoCheckout(TYPE1, ID1, USR1);
 599     Assert.assertEquals(version, VERSION01);
 600
 601     VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1));
 602     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
 603         VersionStatus.Draft, viewableVersions, null);
 604
 605 */
 606 /*    ResultSet results =
 607         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 608             VERSION02);
 609     Assert.assertFalse(results.iterator().hasNext());*//*
 610
 611   }
 612
 613   @Test(expectedExceptions = CoreException.class)
 614   public void testCheckinNonExisting() {
 615     versioningManager.checkin(TYPE1, ID1, USR1, "");
 616   }
 617
 618   @Test(expectedExceptions = CoreException.class)
 619   public void testCheckinOnAvailable() {
 620     Set<Version> viewableVersions = new HashSet<>();
 621     viewableVersions.add(VERSION01);
 622     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
 623         null);
 624
 625     versioningManager.checkin(TYPE1, ID1, USR1, "fail checkin");
 626   }
 627
 628
 629   @Test(expectedExceptions = CoreException.class)
 630   public void testCheckinOnFinalized() {
 631     Set<Version> viewableVersions = new HashSet<>();
 632     viewableVersions.add(VERSION10);
 633     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions,
 634         VERSION10);
 635
 636     versioningManager.checkin(TYPE1, ID1, USR1, "failed checkin");
 637   }
 638
 639   @Test(expectedExceptions = CoreException.class)
 640   public void testCheckinOnLockedOtherUser() {
 641     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 642         new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null);
 643
 644     versioningManager.checkin(TYPE1, ID1, USR1, "");
 645   }
 646
 647   @Test
 648   public void testCheckin() {
 649     HashSet<Version> viewableVersions = new HashSet<>();
 650     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 651         new UserCandidateVersion(USR1, VERSION01), viewableVersions, null);
 652
 653     Version version = versioningManager.checkin(TYPE1, ID1, USR1, "checkin 0.1");
 654     Assert.assertEquals(version, VERSION01);
 655
 656     verify(versionInfoDaoMock).update(versionInfoEntityArg.capture());
 657     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 658
 659     viewableVersions.add(VERSION01);
 660     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null,
 661         VersionStatus.Draft, viewableVersions, null);
 662   }
 663
 664   @Test(expectedExceptions = CoreException.class)
 665   public void testSubmitNonExisting() {
 666     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
 667   }
 668
 669   @Test(expectedExceptions = CoreException.class)
 670   public void testSubmitOnLocked() {
 671     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0,
 672         new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null);
 673     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
 674   }
 675
 676
 677   @Test(expectedExceptions = CoreException.class)
 678   public void testSubmitOnFinalized() {
 679     Set<Version> viewableVersions = new HashSet<>();
 680     viewableVersions.add(VERSION10);
 681     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions,
 682         VERSION10);
 683     versioningManager.submit(TYPE1, ID1, USR2, "failed submit");
 684   }
 685
 686   @Test
 687   public void testSubmit() {
 688     Version version32 = new Version(3, 2);
 689     Version version40 = new Version(4, 0);
 690
 691     Set<Version> viewableVersions = new HashSet<>();
 692     viewableVersions.add(VERSION10);
 693     viewableVersions.add(new Version(2, 0));
 694     viewableVersions.add(new Version(3, 0));
 695     viewableVersions.add(new Version(3, 1));
 696     viewableVersions.add(version32);
 697     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, version32, null, viewableVersions,
 698         new Version(3, 0));
 699
 700     Version version = versioningManager.submit(TYPE1, ID1, USR1, "submit msg");
 701     Assert.assertEquals(version, version40);
 702     viewableVersions.remove(new Version(3, 1));
 703     viewableVersions.remove(version32);
 704     viewableVersions.add(version40);
 705
 706     verify(versionInfoDaoMock).update(versionInfoEntityArg.capture());
 707     VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue();
 708
 709     assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, version40, null, null,
 710         VersionStatus.Certified, viewableVersions, version40);
 711
 712 */
 713 /*    ResultSet results =
 714         loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1,
 715             VERSION10);
 716     Assert.assertTrue(results.iterator().hasNext());*//*
 717
 718   }
 719
 720   @Test(expectedExceptions = CoreException.class)
 721   public void testGetVersionInfoOnNonExistingEntity() {
 722     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 723   }
 724
 725   @Test
 726   public void testGetVersionInfoForReadOnAvailable() {
 727     Set<Version> viewableVersions = new HashSet<>();
 728     viewableVersions.add(VERSION01);
 729     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
 730         null);
 731
 732     VersionInfo versionInfo =
 733         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 734     assertVersionInfo(versionInfo, VERSION01, VersionStatus.Draft, null,
 735         viewableVersions, null);
 736   }
 737
 738   @Test(expectedExceptions = CoreException.class)
 739   public void testGetVersionInfoForWriteOnAvailable() {
 740     Set<Version> viewableVersions = new HashSet<>();
 741     viewableVersions.add(VERSION01);
 742     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions,
 743         null);
 744
 745     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write);
 746   }
 747
 748   @Test
 749   public void testGetVersionInfoForReadOnLockedSameUser() {
 750     Set<Version> viewableVersions = new HashSet<>();
 751     viewableVersions.add(VERSION01);
 752     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 753         new UserCandidateVersion(USR1, VERSION02), viewableVersions, null);
 754
 755     VersionInfo versionInfo =
 756         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 757     viewableVersions.add(VERSION02);
 758     assertVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR1, viewableVersions, null);
 759   }
 760
 761   @Test
 762   public void testGetVersionInfoForReadOnLockedOtherUser() {
 763     Set<Version> viewableVersions = new HashSet<>();
 764     viewableVersions.add(VERSION01);
 765     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 766         new UserCandidateVersion(USR2, VERSION02), viewableVersions, null);
 767
 768     VersionInfo versionInfo =
 769         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read);
 770     Assert.assertEquals(versionInfo.getActiveVersion(), VERSION01);
 771     assertVersionInfo(versionInfo, VERSION01, VersionStatus.Locked, USR2, viewableVersions, null);
 772   }
 773
 774   @Test(expectedExceptions = CoreException.class)
 775   public void testGetVersionInfoForWriteOnLockedOtherUser() {
 776     Set<Version> viewableVersions = new HashSet<>();
 777     viewableVersions.add(VERSION01);
 778     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 779         new UserCandidateVersion(USR2, VERSION02), viewableVersions, null);
 780
 781     versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write);
 782   }
 783
 784   @Test
 785   public void testGetVersionInfoForWriteOnLockedSameUser() {
 786     Set<Version> viewableVersions = new HashSet<>();
 787     viewableVersions.add(VERSION01);
 788     mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01,
 789         new UserCandidateVersion(USR1, VERSION02), viewableVersions, null);
 790
 791     VersionInfo versionInfo =
 792         versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write);
 793     viewableVersions.add(VERSION02);
 794     assertVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR1, viewableVersions, null);
 795   }
 796
 797 */
 798 /*  private void createVersionableEntityRecord(String tableName, String idName, String versionName,
 799                                              String id, Version version) {
 800     noSqlDb.execute(
 801         String.format("insert into %s (%s,%s) values (?,?)", tableName, idName, versionName), id,
 802         versionMapper.toUDT(version));
 803   }
 804
 805   private ResultSet loadVersionableEntityRecord(String tableName, String idName, String versionName,
 806                                                 String id, Version version) {
 807     return noSqlDb.execute(
 808         String.format("select * from %s where %s=? and %s=?", tableName, idName, versionName), id,
 809         versionMapper.toUDT(version));
 810   }*//*
 811
 812
 813
 814   private static void assretVersionInfoEntity(VersionInfoEntity actual, String entityType,
 815                                               String entityId, Version activeVersion,
 816                                               Version candidateVersion, String candidateUser,
 817                                               VersionStatus status, Set<Version> viewbleVersions,
 818                                               Version latestFinalVersion) {
 819     Assert.assertNotNull(actual);
 820     Assert.assertEquals(actual.getEntityType(), entityType);
 821     Assert.assertEquals(actual.getEntityId(), entityId);
 822     Assert.assertEquals(actual.getActiveVersion(), activeVersion);
 823     if (candidateVersion != null && candidateUser != null) {
 824       Assert.assertEquals(actual.getCandidate().getVersion(), candidateVersion);
 825       Assert.assertEquals(actual.getCandidate().getUser(), candidateUser);
 826     } else {
 827       Assert.assertNull(actual.getCandidate());
 828     }
 829     Assert.assertEquals(actual.getStatus(), status);
 830     Assert.assertEquals(actual.getViewableVersions().size(), viewbleVersions.size());
 831     Assert.assertEquals(actual.getViewableVersions(), viewbleVersions);
 832     Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
 833   }
 834
 835   private static void assertVersionInfo(VersionInfo actual, Version activeVersion,
 836                                         VersionStatus status, String lockingUser,
 837                                         Set<Version> viewableVersions, Version latestFinalVersion) {
 838     Assert.assertNotNull(actual);
 839     Assert.assertEquals(actual.getActiveVersion(), activeVersion);
 840     Assert.assertEquals(actual.getStatus(), status);
 841     Assert.assertEquals(actual.getLockingUser(), lockingUser);
 842     Assert.assertEquals(actual.getViewableVersions().size(), viewableVersions.size());
 843     Assert.assertEquals(actual.getViewableVersions(), viewableVersions);
 844     Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion);
 845   }
 846
 847   private VersionInfoEntity mockVersionInfoEntity(String entityType, String entityId,
 848                                                   VersionStatus status, Version activeVersion,
 849                                                   UserCandidateVersion candidate,
 850                                                   Set<Version> viewableVersions,
 851                                                   Version latestFinalVersion) {
 852     VersionInfoEntity mock = new VersionInfoEntity();
 853     mock.setEntityType(entityType);
 854     mock.setEntityId(entityId);
 855     mock.setStatus(status);
 856     mock.setActiveVersion(activeVersion);
 857     mock.setCandidate(candidate);
 858     mock.setViewableVersions(viewableVersions);
 859     mock.setLatestFinalVersion(latestFinalVersion);
 860
 861     doReturn(mock).when(versionInfoDaoMock).get(anyObject());
 862     return mock;
 863   }
 864 */
 865 }