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 import static org.mockito.Matchers.any;
  24 import static org.mockito.Matchers.eq;
  25 import static org.mockito.Mockito.doReturn;
  26 import static org.mockito.Mockito.doThrow;
  27 import static org.mockito.Mockito.never;
  28 import static org.mockito.Mockito.times;
  29 import static org.mockito.Mockito.verify;
  30 import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.OutOfSync;
  31 import static org.openecomp.sdc.versioning.dao.types.SynchronizationState.UpToDate;
  32 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified;
  33 import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Draft;
  34
  35 import java.util.ArrayList;
  36 import java.util.List;
  37 import java.util.Optional;
  38 import java.util.stream.Collectors;
  39 import java.util.stream.Stream;
  40 import org.junit.Assert;
  41 import org.junit.Before;
  42 import org.junit.Rule;
  43 import org.junit.Test;
  44 import org.junit.rules.ExpectedException;
  45 import org.mockito.ArgumentCaptor;
  46 import org.mockito.InjectMocks;
  47 import org.mockito.Mock;
  48 import org.mockito.MockitoAnnotations;
  49 import org.openecomp.sdc.common.errors.CoreException;
  50 import org.openecomp.sdc.versioning.ItemManager;
  51 import org.openecomp.sdc.versioning.VersionCalculator;
  52 import org.openecomp.sdc.versioning.dao.VersionDao;
  53 import org.openecomp.sdc.versioning.dao.types.Revision;
  54 import org.openecomp.sdc.versioning.dao.types.SynchronizationState;
  55 import org.openecomp.sdc.versioning.dao.types.Version;
  56 import org.openecomp.sdc.versioning.dao.types.VersionState;
  57 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  58 import org.openecomp.sdc.versioning.types.VersionCreationMethod;
  59
  60 public class VersioningManagerImplTest {
  61   private static final String ITEM_ID = "itemId";
  62   private static final String VERSION_ID = "versionId";
  63
  64   @Rule
  65   public ExpectedException expectedException = ExpectedException.none();
  66
  67   @Mock
  68   private VersionDao versionDaoMock;
  69   @Mock
  70   private VersionCalculator versionCalculatorMock;
  71   @Mock
  72   private ItemManager asdcItemManager;
  73   @InjectMocks
  74   private VersioningManagerImpl versioningManager;
  75
  76   @Before
  77   public void setUp() throws Exception {
  78     MockitoAnnotations.initMocks(this);
  79   }
  80
  81   @Test
  82   public void testListWhenNone() {
  83     doReturn(new ArrayList<>()).when(versionDaoMock).list(ITEM_ID);
  84
  85     List<Version> versions = versioningManager.list(ITEM_ID);
  86
  87     Assert.assertTrue(versions.isEmpty());
  88   }
  89
  90   @Test
  91   public void testList() {
  92     List<Version> returnedVersions = Stream.of(createVersion("1", null, null, false),
  93         createVersion("2", null, null, false),
  94         createVersion("3", null, null, false)).collect(Collectors.toList());
  95     doReturn(returnedVersions).when(versionDaoMock).list(ITEM_ID);
  96
  97     List<Version> versions = versioningManager.list(ITEM_ID);
  98     Assert.assertEquals(versions, returnedVersions);
  99   }
 100
 101   @Test(expected = Exception.class)
 102   public void testGetNonExisting() throws Exception {
 103     Version version = new Version(VERSION_ID);
 104
 105     doReturn(Optional.empty()).when(versionDaoMock).get(ITEM_ID, version);
 106     doThrow(new Exception()).when(versionDaoMock).sync(ITEM_ID, version);
 107
 108     versioningManager.get(ITEM_ID, version);
 109   }
 110
 111   @Test
 112   public void testGetNonExistingForUser() {
 113     Version requestedVersion = new Version(VERSION_ID);
 114
 115     Version returnedVersion = createVersion(VERSION_ID, Draft, UpToDate, false);
 116     doReturn(Optional.empty()).doReturn(Optional.of(returnedVersion))
 117         .when(versionDaoMock).get(ITEM_ID, requestedVersion);
 118
 119     Version version = versioningManager.get(ITEM_ID, requestedVersion);
 120     Assert.assertEquals(version, returnedVersion);
 121
 122     verify(versionDaoMock, times(2)).get(ITEM_ID, requestedVersion);
 123     verify(versionDaoMock).sync(ITEM_ID, requestedVersion);
 124   }
 125
 126   @Test
 127   public void testGetOutOfSyncCertified() {
 128     Version requestedVersion = new Version(VERSION_ID);
 129
 130     Version returnedVersion = createVersion(VERSION_ID, Certified, UpToDate, false);
 131     doReturn(Optional.of(createVersion(VERSION_ID, Certified, OutOfSync, false)))
 132         .doReturn(Optional.of(returnedVersion))
 133         .when(versionDaoMock).get(ITEM_ID, requestedVersion);
 134
 135     Version version = versioningManager.get(ITEM_ID, requestedVersion);
 136     Assert.assertEquals(version, returnedVersion);
 137
 138     verify(versionDaoMock, times(2)).get(ITEM_ID, requestedVersion);
 139     verify(versionDaoMock).forceSync(ITEM_ID, requestedVersion);
 140   }
 141
 142   @Test
 143   public void testGet() {
 144     Version requestedVersion = new Version(VERSION_ID);
 145
 146     Version returnedVersion = createVersion(VERSION_ID, Draft, OutOfSync, true);
 147     doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, requestedVersion);
 148
 149     Version version = versioningManager.get(ITEM_ID, requestedVersion);
 150     Assert.assertEquals(version, returnedVersion);
 151
 152     verify(versionDaoMock).get(ITEM_ID, requestedVersion);
 153     verify(versionDaoMock, never()).sync(any(), any());
 154     verify(versionDaoMock, never()).forceSync(any(), any());
 155   }
 156
 157   @Test
 158   public void testCreate() {
 159     Version requestedVersion = new Version();
 160
 161     String versionName = "versionName";
 162     doReturn(versionName).when(versionCalculatorMock).calculate(null, VersionCreationMethod.major);
 163
 164     doReturn(Stream.of(createVersion("1", null, null, false),
 165         createVersion("2", null, null, false),
 166         createVersion("3", null, null, false)).collect(Collectors.toList()))
 167         .when(versionDaoMock).list(ITEM_ID);
 168
 169     Version version =
 170         versioningManager.create(ITEM_ID, requestedVersion, VersionCreationMethod.major);
 171     Assert.assertNotNull(version);
 172     Assert.assertEquals(version.getName(), versionName);
 173
 174     verify(versionDaoMock).create(ITEM_ID, requestedVersion);
 175     verify(asdcItemManager).updateVersionStatus(ITEM_ID, Draft, null);
 176     verify(versionDaoMock)
 177         .publish(eq(ITEM_ID), eq(requestedVersion), eq("Create version: versionName"));
 178   }
 179
 180   @Test
 181   public void testCreateBasedOn() {
 182     Version requestedVersion = new Version();
 183     requestedVersion.setBaseId("baseVersionId");
 184
 185     Version baseVersion = createVersion(requestedVersion.getBaseId(), Certified, UpToDate, false);
 186     // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed
 187     doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(ITEM_ID), any(Version.class));
 188
 189     String versionName = "4.0";
 190     doReturn(versionName)
 191         .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major);
 192
 193     doReturn(Stream.of(createVersion("1", null, null, false),
 194         createVersion("2", null, null, false),
 195         createVersion("3", null, null, false)).collect(Collectors.toList()))
 196         .when(versionDaoMock).list(ITEM_ID);
 197
 198     Version version =
 199         versioningManager.create(ITEM_ID, requestedVersion, VersionCreationMethod.major);
 200     Assert.assertNotNull(version);
 201     Assert.assertEquals(version.getName(), versionName);
 202
 203     verify(versionDaoMock).create(ITEM_ID, requestedVersion);
 204     verify(asdcItemManager).updateVersionStatus(ITEM_ID, Draft, null);
 205     verify(versionDaoMock).publish(eq(ITEM_ID), eq(requestedVersion), eq("Create version: 4.0"));
 206   }
 207
 208   @Test
 209   public void testCreateWithExistingName() {
 210
 211     expectedException.expect(CoreException.class);
 212     expectedException.expectMessage("Item itemId: create version failed, a version with the name 2.0 already exist");
 213
 214     Version version = new Version();
 215     version.setBaseId("baseVersionId");
 216
 217     Version baseVersion = createVersion(version.getBaseId(), Certified, UpToDate, false);
 218     // TODO: 12/13/2017 fix to eq(new Version("baseVersionId")) when version.equals will be fixed
 219     doReturn(Optional.of(baseVersion)).when(versionDaoMock).get(eq(ITEM_ID), any(Version.class));
 220
 221     String versionName = "2.0";
 222     doReturn(versionName)
 223         .when(versionCalculatorMock).calculate(baseVersion.getName(), VersionCreationMethod.major);
 224
 225     doReturn(Stream.of(createVersion("1", null, null, false),
 226         createVersion("2", null, null, false),
 227         createVersion("3", null, null, false)).collect(Collectors.toList()))
 228         .when(versionDaoMock).list(ITEM_ID);
 229
 230     versioningManager.create(ITEM_ID, version, VersionCreationMethod.major);
 231   }
 232
 233   @Test
 234   public void testSubmitCertified() {
 235
 236     expectedException.expect(CoreException.class);
 237     expectedException.expectMessage("Item itemId: submit version failed, version versionId is already Certified");
 238
 239     Version version = new Version(VERSION_ID);
 240
 241     Version returnedVersion = createVersion(VERSION_ID, Certified, UpToDate, false);
 242     doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, version);
 243
 244     versioningManager.submit(ITEM_ID, version, "Submit message");
 245   }
 246
 247   @Test
 248   public void testSubmit() {
 249     Version version = new Version(VERSION_ID);
 250
 251     ArgumentCaptor<Version> versionArgumentCaptor = ArgumentCaptor.forClass(Version.class);
 252
 253     Version returnedVersion = createVersion(VERSION_ID, Draft, UpToDate, false);
 254     doReturn(Optional.of(returnedVersion)).when(versionDaoMock).get(ITEM_ID, version);
 255
 256     String submitDescription = "Submit message";
 257     versioningManager.submit(ITEM_ID, version, submitDescription);
 258
 259     verify(versionDaoMock).update(eq(ITEM_ID), versionArgumentCaptor.capture());
 260     Assert.assertEquals(Certified, versionArgumentCaptor.getValue().getStatus());
 261     verify(versionDaoMock).publish(ITEM_ID, version, submitDescription);
 262     verify(asdcItemManager).updateVersionStatus(ITEM_ID, Certified, Draft);
 263   }
 264
 265   @Test
 266   public void testPublish() {
 267     Version version = new Version(VERSION_ID);
 268     String publishDescription = "Publish message";
 269
 270     versioningManager.publish(ITEM_ID, version, publishDescription);
 271
 272     verify(versionDaoMock).publish(ITEM_ID, version, publishDescription);
 273   }
 274
 275   @Test
 276   public void testSync() {
 277     Version version = new Version(VERSION_ID);
 278
 279     versioningManager.sync(ITEM_ID, version);
 280
 281     verify(versionDaoMock).sync(ITEM_ID, version);
 282   }
 283
 284   @Test
 285   public void testForceSync() {
 286     Version version = new Version(VERSION_ID);
 287
 288     versioningManager.forceSync(ITEM_ID, version);
 289
 290     verify(versionDaoMock).forceSync(ITEM_ID, version);
 291   }
 292
 293   @Test
 294   public void testRevert() {
 295     Version version = new Version(VERSION_ID);
 296     String revisionId = "revisionId";
 297
 298     versioningManager.revert(ITEM_ID, version, revisionId);
 299
 300     verify(versionDaoMock).revert(ITEM_ID, version, revisionId);
 301   }
 302
 303   @Test
 304   public void testListRevisions() {
 305     Version version = new Version(VERSION_ID);
 306
 307     List<Revision> returnedRevisions =
 308         Stream.of(new Revision(), new Revision()).collect(Collectors.toList());
 309     doReturn(returnedRevisions)
 310         .when(versionDaoMock).listRevisions(ITEM_ID, version);
 311
 312     List<Revision> revisions = versioningManager.listRevisions(ITEM_ID, version);
 313     Assert.assertEquals(revisions, returnedRevisions);
 314   }
 315
 316   private Version createVersion(String id, VersionStatus status,
 317                                 SynchronizationState syncState, boolean dirty) {
 318     Version version = new Version(id);
 319     version.setName(id + ".0");
 320     version.setDescription(id + " desc");
 321     version.setStatus(status);
 322
 323     VersionState state = new VersionState();
 324     state.setSynchronizationState(syncState);
 325     state.setDirty(dirty);
 326     version.setState(state);
 327     return version;
 328   }
 329 }