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