/*- * ============LICENSE_START======================================================= * SDC * ================================================================================ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ============LICENSE_END========================================================= */ package org.openecomp.sdc.versioning.impl; import org.mockito.ArgumentCaptor; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.openecomp.sdc.common.errors.CoreException; import org.openecomp.sdc.versioning.ActionVersioningManager; import org.openecomp.sdc.versioning.AsdcItemManager; import org.openecomp.sdc.versioning.ItemManager; import org.openecomp.sdc.versioning.VersionCalculator; import org.openecomp.sdc.versioning.dao.VersionDao; import org.openecomp.sdc.versioning.dao.types.Revision; import org.openecomp.sdc.versioning.dao.types.SynchronizationState; import org.openecomp.sdc.versioning.dao.types.Version; import org.openecomp.sdc.versioning.dao.types.VersionState; import org.openecomp.sdc.versioning.dao.types.VersionStatus; import org.openecomp.sdc.versioning.types.VersionCreationMethod; import org.testng.Assert; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; import java.util.ArrayList; import java.util.List; import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; import static org.mockito.Matchers.any; import static org.mockito.Matchers.eq; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.OutOfSync; import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.UpToDate; import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified; import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft; public class VersioningManagerImplTest { private static final String ITEM_ID = "itemId"; private static final String VERSION_ID = "versionId"; @Mock private VersionDao versionDaoMock; @Mock private VersionCalculator versionCalculatorMock; @Mock private ItemManager asdcItemManager; @InjectMocks private VersioningManagerImpl versioningManager; @BeforeMethod public void setUp() throws Exception { MockitoAnnotations.initMocks(this); } @Test public void testListWhenNone() throws Exception { doReturn(new ArrayList<>()).when(versionDaoMock).list(ITEM_ID); List versions = versioningManager.list(ITEM_ID); Assert.assertTrue(versions.isEmpty()); } @Test public void testList() throws Exception { List returnedVersions = Stream.of(createVersion("1", null, null, false), createVersion("2", null, null, false), createVersion("3", null, null, false)).collect(Collectors.toList()); doReturn(returnedVersions).when(versionDaoMock).list(ITEM_ID); List versions = versioningManager.list(ITEM_ID); Assert.assertEquals(versions, returnedVersions); } @Test(expectedExceptions = Exception.class) public void testGetNonExisting() throws Exception { Version version = new Version(VERSION_ID); doReturn(Optional.empty()).when(versionDaoMock).get(ITEM_ID, version); doThrow(new Exception()).when(versionDaoMock).sync(ITEM_ID, version); versioningManager.get(ITEM_ID, version); } @Test public void testGetNonExistingForUser() throws Exception { Version requestedVersion = new Version(VERSION_ID); Version returnedVersion = createVersion(VERSION_ID, Draft, UpToDate, false); doReturn(Optional.empty()).doReturn(Optional.of(returnedVersion)) .when(versionDaoMock).get(ITEM_ID, requestedVersion); Version version = versioningManager.get(ITEM_ID, requestedVersion); Assert.assertEquals(version, returnedVersion); verify(versionDaoMock, times(2)).get(ITEM_ID, requestedVersion); verify(versionDaoMock).sync(ITEM_ID, requestedVersion); } @Test public void testGetOutOfSyncCertified() throws Exception { Version requestedVersion = new Version(VERSION_ID); Version returnedVersion = createVersion(VERSION_ID, Certified, UpToDate, false); doReturn(Optional.of(createVersion(VERSION_ID, Certified, OutOfSync, false))) .doReturn(Optional.of(returnedVersion)) .when(versionDaoMock).get(ITEM_ID, requestedVersion); Version version = versioningManager.get(ITEM_ID, requestedVersion); Assert.assertEquals(version, returnedVersion); verify(versionDaoMock, times(2)).get(ITEM_ID, requestedVersion); verify(versionDaoMock).forceSync(ITEM_ID, requestedVersion); } @Test public void testGet() throws Exception { Version requestedVersion = new Version(VERSION_ID); Version returnedVersion = createVersion(VERSION_ID, Draft, OutOfSync, true); doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, requestedVersion); Version version = versioningManager.get(ITEM_ID, requestedVersion); Assert.assertEquals(version, returnedVersion); verify(versionDaoMock).get(ITEM_ID, requestedVersion); verify(versionDaoMock, never()).sync(any(), any()); verify(versionDaoMock, never()).forceSync(any(), any()); } @Test public void testCreate() throws Exception { Version requestedVersion = new Version(); String versionName = "versionName"; doReturn(versionName).when(versionCalculatorMock).calculate(null, VersionCreationMethod.major); doReturn(Stream.of(createVersion("1", null, null, false), createVersion("2", null, null, false), createVersion("3", null, null, false)).collect(Collectors.toList())) .when(versionDaoMock).list(ITEM_ID); Version version = versioningManager.create(ITEM_ID, requestedVersion, VersionCreationMethod.major); Assert.assertNotNull(version); Assert.assertEquals(version.getName(), versionName); verify(versionDaoMock).create(ITEM_ID, requestedVersion); verify(asdcItemManager).updateVersionStatus(ITEM_ID, Draft, null); verify(versionDaoMock) .publish(eq(ITEM_ID), eq(requestedVersion), eq("Create version: versionName")); } @Test public void testCreateBasedOn() throws Exception { Version requestedVersion = new Version(); requestedVersion.setBaseId("baseVersionId"); Version baseVersion = createVersion(requestedVersion.getBaseId(), Certified, UpToDate, false); // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(ITEM_ID), any(Version.class)); String versionName = "4.0"; doReturn(versionName) .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major); doReturn(Stream.of(createVersion("1", null, null, false), createVersion("2", null, null, false), createVersion("3", null, null, false)).collect(Collectors.toList())) .when(versionDaoMock).list(ITEM_ID); Version version = versioningManager.create(ITEM_ID, requestedVersion, VersionCreationMethod.major); Assert.assertNotNull(version); Assert.assertEquals(version.getName(), versionName); verify(versionDaoMock).create(ITEM_ID, requestedVersion); verify(asdcItemManager).updateVersionStatus(ITEM_ID, Draft, null); verify(versionDaoMock).publish(eq(ITEM_ID), eq(requestedVersion), eq("Create version: 4.0")); } @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Item itemId: create version failed, a version with the name 2.0 already exist") public void testCreateWithExistingName() throws Exception { Version version = new Version(); version.setBaseId("baseVersionId"); Version baseVersion = createVersion(version.getBaseId(), Certified, UpToDate, false); // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(ITEM_ID), any(Version.class)); String versionName = "2.0"; doReturn(versionName) .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major); doReturn(Stream.of(createVersion("1", null, null, false), createVersion("2", null, null, false), createVersion("3", null, null, false)).collect(Collectors.toList())) .when(versionDaoMock).list(ITEM_ID); versioningManager.create(ITEM_ID, version, VersionCreationMethod.major); } @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Item itemId: submit version failed, version versionId is already Certified") public void testSubmitCertified() throws Exception { Version version = new Version(VERSION_ID); Version returnedVersion = createVersion(VERSION_ID, Certified, UpToDate, false); doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, version); versioningManager.submit(ITEM_ID, version, "Submit message"); } @Test public void testSubmit() throws Exception { Version version = new Version(VERSION_ID); ArgumentCaptor versionArgumentCaptor = ArgumentCaptor.forClass(Version.class); Version returnedVersion = createVersion(VERSION_ID, Draft, UpToDate, false); doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, version); String submitDescription = "Submit message"; versioningManager.submit(ITEM_ID, version, submitDescription); verify(versionDaoMock).update(eq(ITEM_ID), versionArgumentCaptor.capture()); Assert.assertEquals(Certified, versionArgumentCaptor.getValue().getStatus()); verify(versionDaoMock).publish(ITEM_ID, version, submitDescription); verify(asdcItemManager).updateVersionStatus(ITEM_ID, Certified, Draft); } @Test public void testPublish() throws Exception { Version version = new Version(VERSION_ID); String publishDescription = "Publish message"; versioningManager.publish(ITEM_ID, version, publishDescription); verify(versionDaoMock).publish(ITEM_ID, version, publishDescription); } @Test public void testSync() throws Exception { Version version = new Version(VERSION_ID); versioningManager.sync(ITEM_ID, version); verify(versionDaoMock).sync(ITEM_ID, version); } @Test public void testForceSync() throws Exception { Version version = new Version(VERSION_ID); versioningManager.forceSync(ITEM_ID, version); verify(versionDaoMock).forceSync(ITEM_ID, version); } @Test public void testRevert() throws Exception { Version version = new Version(VERSION_ID); String revisionId = "revisionId"; versioningManager.revert(ITEM_ID, version, revisionId); verify(versionDaoMock).revert(ITEM_ID, version, revisionId); } @Test public void testListRevisions() throws Exception { Version version = new Version(VERSION_ID); List returnedRevisions = Stream.of(new Revision(), new Revision()).collect(Collectors.toList()); doReturn(returnedRevisions) .when(versionDaoMock).listRevisions(ITEM_ID, version); List revisions = versioningManager.listRevisions(ITEM_ID, version); Assert.assertEquals(revisions, returnedRevisions); } private Version createVersion(String id, VersionStatus status, SynchronizationState syncState, boolean dirty) { Version version = new Version(id); version.setName(id + ".0"); version.setDescription(id + " desc"); version.setStatus(status); VersionState state = new VersionState(); state.setSynchronizationState(syncState); state.setDirty(dirty); version.setState(state); return version; } /* private static final String USR1 = "usr1"; private static final String USR2 = "usr2"; private static final String TYPE1 = "Type1"; */ /* private static final String TYPE2 = "Type2";*//* private static final String ID1 = "Id1"; */ /* private static final String ID2 = "Id2"; private static final String ID3 = "Id3"; private static final String TYPE1_TABLE_NAME = "vendor_license_model"; private static final String TYPE1_ID_NAME = "vlm_id"; private static final String TYPE1_VERSION_NAME = "version"; private static final String TYPE2_TABLE_NAME = "feature_group"; private static final String TYPE2_ID_NAME = "vlm_id"; private static final String TYPE2_VERSION_NAME = "version";*//* private static final Version VERSION0 = new Version(0, 0); private static final Version VERSION01 = new Version(0, 1); private static final Version VERSION02 = new Version(0, 2); private static final Version VERSION10 = new Version(1, 0); private static final Version VERSION11 = new Version(1, 1); */ /* private static final NoSqlDb noSqlDb = NoSqlDbFactory.getInstance().createInterface(); private static UDTMapper versionMapper = noSqlDb.getMappingManager().udtMapper(Version.class);*//* @Mock private VersionInfoDao versionInfoDaoMock; @Mock private VersionInfoDeletedDao versionInfoDeletedDaoMock; @InjectMocks private VersioningManagerImpl versioningManager; @Captor private ArgumentCaptor versionInfoEntityArg; @BeforeMethod public void setUp() throws Exception { MockitoAnnotations.initMocks(this); } */ /* @BeforeClass private void init() { versionInfoDaoMock.delete(new VersionInfoEntity(TYPE1, ID1)); versionInfoDaoMock.delete(new VersionInfoEntity(TYPE1, ID2)); versionInfoDaoMock.delete(new VersionInfoEntity(TYPE2, ID3)); String deleteFromType1 = String .format("delete from %s where %s=? and %s=?", TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME); noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION01)); noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION02)); noSqlDb.execute(deleteFromType1, ID1, versionMapper.toUDT(VERSION11)); versioningManager.register(TYPE1, new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME)); versioningManager.register(TYPE2, new VersionableEntityMetadata(TYPE2_TABLE_NAME, TYPE2_ID_NAME, TYPE2_VERSION_NAME)); }*//* */ /* @Test public void testRegister() throws Exception { VersionableEntityMetadata entityMetadata = new VersionableEntityMetadata(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME); versioningManager.register(TYPE1, entityMetadata); Map> versionableEntities = versionableEntitiesCapture.capture(); Set type1Entities = versionableEntities.get(TYPE1); Assert.assertNotNull(type1Entities); Assert.assertTrue(type1Entities.contains(entityMetadata)); }*//* @Test(expectedExceptions = CoreException.class) public void testCreateAlreadyExisting() { doReturn(new VersionInfoEntity()).when(versionInfoDaoMock).get(anyObject()); versioningManager.create(TYPE1, ID1, USR1); } @Test public void testCreate() { Version version = versioningManager.create(TYPE1, ID1, USR1); Assert.assertEquals(version, VERSION01); */ /* createVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1, version);*//* verify(versionInfoDaoMock).create(versionInfoEntityArg.capture()); VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue(); assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, new Version(0, 0), VERSION01, USR1, VersionStatus.Locked, new HashSet<>(), null); } @Test(expectedExceptions = CoreException.class) public void testDeleteNonExisting() { versioningManager.delete(TYPE1, ID1, USR1); } @Test(expectedExceptions = CoreException.class) public void testDeleteLocked() { mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0, new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null); versioningManager.delete(TYPE1, ID1, USR1); } @Test public void testDelete() { VersionInfoEntity versionInfoEntity = new VersionInfoEntity(); versionInfoEntity.setStatus(VersionStatus.Draft); doReturn(versionInfoEntity).when(versionInfoDaoMock).get(anyObject()); versioningManager.delete(TYPE1, ID1, USR1); verify(versionInfoDaoMock).delete(versionInfoEntity); ArgumentCaptor versionInfoDeletedEntityArg = ArgumentCaptor.forClass(VersionInfoDeletedEntity.class); verify(versionInfoDeletedDaoMock).create(versionInfoDeletedEntityArg.capture()); } @Test(expectedExceptions = CoreException.class) public void testUndoDeleteNonExisting() { versioningManager.undoDelete(TYPE1, ID1, USR1); } @Test public void testUndoDelete() { VersionInfoDeletedEntity versionInfoDeletedEntity = new VersionInfoDeletedEntity(); versionInfoDeletedEntity.setStatus(VersionStatus.Draft); doReturn(versionInfoDeletedEntity).when(versionInfoDeletedDaoMock).get(anyObject()); versioningManager.undoDelete(TYPE1, ID1, USR1); verify(versionInfoDeletedDaoMock).delete(versionInfoDeletedEntity); verify(versionInfoDaoMock).create(versionInfoEntityArg.capture()); */ /* VersionInfoDeletedEntity versionInfoDeletedEntity = versionInfoDeletedDaoMock.get(new VersionInfoDeletedEntity(TYPE1, ID1)); Assert.assertNotNull(versionInfoDeletedEntity); Map entitiesInfoMap = versioningManager.listDeletedEntitiesVersionInfo(TYPE1, USR2, null); Assert.assertEquals(entitiesInfoMap.size(), 1); VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1)); Assert.assertNull(versionInfoEntity); versioningManager.undoDelete(TYPE1, ID1, USR1); versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1)); Assert.assertNotNull(versionInfoEntity);*//* } @Test(expectedExceptions = CoreException.class) public void testCheckoutNonExisting() { versioningManager.checkout(TYPE1, ID1, USR2); } @Test(expectedExceptions = CoreException.class) public void testCheckoutOnLockedSameUser() { mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0, new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null); versioningManager.checkout(TYPE1, ID1, USR1); } @Test(expectedExceptions = CoreException.class) public void testCheckoutOnLockedOtherUser() { mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0, new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null); versioningManager.checkout(TYPE1, ID1, USR1); } @Test public void testCheckoutOnFinalized() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION10); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions, VERSION10); Version version = versioningManager.checkout(TYPE1, ID1, USR1); Assert.assertEquals(version, VERSION11); VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1)); assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION10, VERSION11, USR1, VersionStatus.Locked, viewableVersions, VERSION10); */ /* ResultSet results = loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1, VERSION11); Assert.assertTrue(results.iterator().hasNext());*//* } @Test public void testCheckout() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions, null); Version version = versioningManager.checkout(TYPE1, ID1, USR1); Assert.assertEquals(version, VERSION02); verify(versionInfoDaoMock).update(versionInfoEntityArg.capture()); VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue(); assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, VERSION02, USR1, VersionStatus.Locked, viewableVersions, null); */ /* ResultSet results = loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1, VERSION02); Assert.assertTrue(results.iterator().hasNext());*//* } @Test(expectedExceptions = CoreException.class) public void testUndoCheckoutNonExisting() { versioningManager.undoCheckout(TYPE1, ID1, USR1); } @Test(expectedExceptions = CoreException.class) public void testUndoCheckoutOnAvailable() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions, null); versioningManager.undoCheckout(TYPE1, ID1, USR1); } @Test(expectedExceptions = CoreException.class) public void testUndoCheckouOnFinalized() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION10); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions, VERSION10); versioningManager.undoCheckout(TYPE1, ID1, USR2); } @Test(expectedExceptions = CoreException.class) public void testUndoCheckoutOnLockedOtherUser() { mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0, new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null); versioningManager.undoCheckout(TYPE1, ID1, USR1); } @Test public void testUndoCheckout() { HashSet viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01, new UserCandidateVersion(USR1, VERSION02), viewableVersions, null); Version version = versioningManager.undoCheckout(TYPE1, ID1, USR1); Assert.assertEquals(version, VERSION01); VersionInfoEntity versionInfoEntity = versionInfoDaoMock.get(new VersionInfoEntity(TYPE1, ID1)); assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null, VersionStatus.Draft, viewableVersions, null); */ /* ResultSet results = loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1, VERSION02); Assert.assertFalse(results.iterator().hasNext());*//* } @Test(expectedExceptions = CoreException.class) public void testCheckinNonExisting() { versioningManager.checkin(TYPE1, ID1, USR1, ""); } @Test(expectedExceptions = CoreException.class) public void testCheckinOnAvailable() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions, null); versioningManager.checkin(TYPE1, ID1, USR1, "fail checkin"); } @Test(expectedExceptions = CoreException.class) public void testCheckinOnFinalized() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION10); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions, VERSION10); versioningManager.checkin(TYPE1, ID1, USR1, "failed checkin"); } @Test(expectedExceptions = CoreException.class) public void testCheckinOnLockedOtherUser() { mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0, new UserCandidateVersion(USR2, VERSION01), Collections.emptySet(), null); versioningManager.checkin(TYPE1, ID1, USR1, ""); } @Test public void testCheckin() { HashSet viewableVersions = new HashSet<>(); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0, new UserCandidateVersion(USR1, VERSION01), viewableVersions, null); Version version = versioningManager.checkin(TYPE1, ID1, USR1, "checkin 0.1"); Assert.assertEquals(version, VERSION01); verify(versionInfoDaoMock).update(versionInfoEntityArg.capture()); VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue(); viewableVersions.add(VERSION01); assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, VERSION01, null, null, VersionStatus.Draft, viewableVersions, null); } @Test(expectedExceptions = CoreException.class) public void testSubmitNonExisting() { versioningManager.submit(TYPE1, ID1, USR2, "failed submit"); } @Test(expectedExceptions = CoreException.class) public void testSubmitOnLocked() { mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION0, new UserCandidateVersion(USR1, VERSION01), Collections.emptySet(), null); versioningManager.submit(TYPE1, ID1, USR2, "failed submit"); } @Test(expectedExceptions = CoreException.class) public void testSubmitOnFinalized() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION10); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Certified, VERSION10, null, viewableVersions, VERSION10); versioningManager.submit(TYPE1, ID1, USR2, "failed submit"); } @Test public void testSubmit() { Version version32 = new Version(3, 2); Version version40 = new Version(4, 0); Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION10); viewableVersions.add(new Version(2, 0)); viewableVersions.add(new Version(3, 0)); viewableVersions.add(new Version(3, 1)); viewableVersions.add(version32); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, version32, null, viewableVersions, new Version(3, 0)); Version version = versioningManager.submit(TYPE1, ID1, USR1, "submit msg"); Assert.assertEquals(version, version40); viewableVersions.remove(new Version(3, 1)); viewableVersions.remove(version32); viewableVersions.add(version40); verify(versionInfoDaoMock).update(versionInfoEntityArg.capture()); VersionInfoEntity versionInfoEntity = versionInfoEntityArg.getValue(); assretVersionInfoEntity(versionInfoEntity, TYPE1, ID1, version40, null, null, VersionStatus.Certified, viewableVersions, version40); */ /* ResultSet results = loadVersionableEntityRecord(TYPE1_TABLE_NAME, TYPE1_ID_NAME, TYPE1_VERSION_NAME, ID1, VERSION10); Assert.assertTrue(results.iterator().hasNext());*//* } @Test(expectedExceptions = CoreException.class) public void testGetVersionInfoOnNonExistingEntity() { versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read); } @Test public void testGetVersionInfoForReadOnAvailable() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions, null); VersionInfo versionInfo = versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read); assertVersionInfo(versionInfo, VERSION01, VersionStatus.Draft, null, viewableVersions, null); } @Test(expectedExceptions = CoreException.class) public void testGetVersionInfoForWriteOnAvailable() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Draft, VERSION01, null, viewableVersions, null); versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write); } @Test public void testGetVersionInfoForReadOnLockedSameUser() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01, new UserCandidateVersion(USR1, VERSION02), viewableVersions, null); VersionInfo versionInfo = versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read); viewableVersions.add(VERSION02); assertVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR1, viewableVersions, null); } @Test public void testGetVersionInfoForReadOnLockedOtherUser() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01, new UserCandidateVersion(USR2, VERSION02), viewableVersions, null); VersionInfo versionInfo = versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Read); Assert.assertEquals(versionInfo.getActiveVersion(), VERSION01); assertVersionInfo(versionInfo, VERSION01, VersionStatus.Locked, USR2, viewableVersions, null); } @Test(expectedExceptions = CoreException.class) public void testGetVersionInfoForWriteOnLockedOtherUser() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01, new UserCandidateVersion(USR2, VERSION02), viewableVersions, null); versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write); } @Test public void testGetVersionInfoForWriteOnLockedSameUser() { Set viewableVersions = new HashSet<>(); viewableVersions.add(VERSION01); mockVersionInfoEntity(TYPE1, ID1, VersionStatus.Locked, VERSION01, new UserCandidateVersion(USR1, VERSION02), viewableVersions, null); VersionInfo versionInfo = versioningManager.getEntityVersionInfo(TYPE1, ID1, USR1, VersionableEntityAction.Write); viewableVersions.add(VERSION02); assertVersionInfo(versionInfo, VERSION02, VersionStatus.Locked, USR1, viewableVersions, null); } */ /* private void createVersionableEntityRecord(String tableName, String idName, String versionName, String id, Version version) { noSqlDb.execute( String.format("insert into %s (%s,%s) values (?,?)", tableName, idName, versionName), id, versionMapper.toUDT(version)); } private ResultSet loadVersionableEntityRecord(String tableName, String idName, String versionName, String id, Version version) { return noSqlDb.execute( String.format("select * from %s where %s=? and %s=?", tableName, idName, versionName), id, versionMapper.toUDT(version)); }*//* private static void assretVersionInfoEntity(VersionInfoEntity actual, String entityType, String entityId, Version activeVersion, Version candidateVersion, String candidateUser, VersionStatus status, Set viewbleVersions, Version latestFinalVersion) { Assert.assertNotNull(actual); Assert.assertEquals(actual.getEntityType(), entityType); Assert.assertEquals(actual.getEntityId(), entityId); Assert.assertEquals(actual.getActiveVersion(), activeVersion); if (candidateVersion != null && candidateUser != null) { Assert.assertEquals(actual.getCandidate().getVersion(), candidateVersion); Assert.assertEquals(actual.getCandidate().getUser(), candidateUser); } else { Assert.assertNull(actual.getCandidate()); } Assert.assertEquals(actual.getStatus(), status); Assert.assertEquals(actual.getViewableVersions().size(), viewbleVersions.size()); Assert.assertEquals(actual.getViewableVersions(), viewbleVersions); Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion); } private static void assertVersionInfo(VersionInfo actual, Version activeVersion, VersionStatus status, String lockingUser, Set viewableVersions, Version latestFinalVersion) { Assert.assertNotNull(actual); Assert.assertEquals(actual.getActiveVersion(), activeVersion); Assert.assertEquals(actual.getStatus(), status); Assert.assertEquals(actual.getLockingUser(), lockingUser); Assert.assertEquals(actual.getViewableVersions().size(), viewableVersions.size()); Assert.assertEquals(actual.getViewableVersions(), viewableVersions); Assert.assertEquals(actual.getLatestFinalVersion(), latestFinalVersion); } private VersionInfoEntity mockVersionInfoEntity(String entityType, String entityId, VersionStatus status, Version activeVersion, UserCandidateVersion candidate, Set viewableVersions, Version latestFinalVersion) { VersionInfoEntity mock = new VersionInfoEntity(); mock.setEntityType(entityType); mock.setEntityId(entityId); mock.setStatus(status); mock.setActiveVersion(activeVersion); mock.setCandidate(candidate); mock.setViewableVersions(viewableVersions); mock.setLatestFinalVersion(latestFinalVersion); doReturn(mock).when(versionInfoDaoMock).get(anyObject()); return mock; } */ }