openecomp-be/lib/openecomp-sdc-versioning-lib/openecomp-sdc-versioning-core/src/test/java/org/openecomp/sdc/versioning/dao/impl/zusammen/VersionZusammenDaoImplTest.java

   1 package org.openecomp.sdc.versioning.dao.impl.zusammen;
   2
   3 import com.amdocs.zusammen.datatypes.Id;
   4 import com.amdocs.zusammen.datatypes.SessionContext;
   5 import com.amdocs.zusammen.datatypes.item.*;
   6 import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
   7 import org.mockito.ArgumentCaptor;
   8 import org.mockito.InjectMocks;
   9 import org.mockito.Mock;
  10 import org.mockito.MockitoAnnotations;
  11 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
  12 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  13 import org.openecomp.sdc.versioning.dao.types.Revision;
  14 import org.openecomp.sdc.versioning.dao.types.Version;
  15 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
  16 import org.testng.Assert;
  17 import org.testng.annotations.BeforeMethod;
  18 import org.testng.annotations.Test;
  19
  20 import java.util.ArrayList;
  21 import java.util.Date;
  22 import java.util.List;
  23 import java.util.Optional;
  24 import java.util.stream.Collectors;
  25 import java.util.stream.Stream;
  26
  27 import static org.mockito.Matchers.eq;
  28 import static org.mockito.Matchers.isNull;
  29 import static org.mockito.Mockito.doReturn;
  30 import static org.mockito.Mockito.verify;
  31 import static org.openecomp.sdc.versioning.dao.impl.zusammen.TestUtil.createZusammenContext;
  32
  33 public class VersionZusammenDaoImplTest {
  34
  35   private static final String USER = "user1";
  36   private static final String tenant = "dox";
  37   @Mock
  38   private ZusammenAdaptor zusammenAdaptorMock;
  39   @InjectMocks
  40   private VersionZusammenDaoImpl versionDao;
  41
  42   @BeforeMethod
  43   public void setUp() throws Exception {
  44     MockitoAnnotations.initMocks(this);
  45     SessionContextProviderFactory.getInstance().createInterface().create(USER, tenant);
  46   }
  47
  48   @Test
  49   public void testListWhenNone() throws Exception {
  50     String itemId = "itemId";
  51
  52     doReturn(new ArrayList<>()).when(zusammenAdaptorMock)
  53         .listPublicVersions(eq(createZusammenContext(USER)), eq(new Id(itemId)));
  54
  55     List<Version> versions = versionDao.list(itemId);
  56
  57     Assert.assertTrue(versions.isEmpty());
  58   }
  59
  60   @Test
  61   public void testList() throws Exception {
  62     String itemId = "itemId";
  63     Id versionId1 = new Id("v1_id");
  64     Id versionId2 = new Id("v2_id");
  65     Id versionId3 = new Id("v3_id");
  66
  67     List<ItemVersion> zusammenVersions = Stream.of(
  68         createZusammenVersion(versionId1, null, "version desc", "1.0", VersionStatus.Certified),
  69         createZusammenVersion(versionId2, versionId1, "version desc", "2.0",
  70             VersionStatus.Certified),
  71         createZusammenVersion(versionId3, versionId2, "version desc", "3.0", VersionStatus.Draft))
  72         .collect(Collectors.toList());
  73     doReturn(zusammenVersions).when(zusammenAdaptorMock)
  74         .listPublicVersions(eq(createZusammenContext(USER)), eq(new Id(itemId)));
  75
  76     List<Version> versions = versionDao.list(itemId);
  77     Assert.assertEquals(versions.size(), 3);
  78
  79     int zusammenVersionIndex;
  80     for (Version version : versions) {
  81       zusammenVersionIndex = versionId1.getValue().equals(version.getId())
  82           ? 0
  83           : versionId2.getValue().equals(version.getId())
  84               ? 1
  85               : 2;
  86       assetVersionEquals(version, zusammenVersions.get(zusammenVersionIndex), null);
  87     }
  88   }
  89
  90   @Test
  91   public void testCreate() throws Exception {
  92     testCreate(null);
  93   }
  94
  95   @Test
  96   public void testCreateBasedOn() throws Exception {
  97     testCreate("baseId");
  98   }
  99
 100   private void testCreate(String baseId) {
 101     String itemId = "itemId";
 102     Version version = new Version(1, 0);
 103     version.setBaseId(baseId);
 104     version.setName("version name");
 105     version.setDescription("version description");
 106     version.setStatus(VersionStatus.Draft);
 107
 108     ArgumentCaptor<ItemVersionData> capturedZusammenVersion =
 109         ArgumentCaptor.forClass(ItemVersionData.class);
 110
 111     String versionId = "versionId";
 112     doReturn(new Id(versionId)).when(zusammenAdaptorMock)
 113         .createVersion(eq(createZusammenContext(USER)), eq(new Id(itemId)),
 114             baseId == null ? isNull(Id.class) : eq(new Id(baseId)),
 115             capturedZusammenVersion.capture());
 116
 117
 118     versionDao.create(itemId, version);
 119
 120     Assert.assertEquals(version.getId(), versionId);
 121
 122     Info capturedInfo = capturedZusammenVersion.getValue().getInfo();
 123     Assert.assertEquals(capturedInfo.getName(), version.getName());
 124     Assert.assertEquals(capturedInfo.getDescription(), version.getDescription());
 125     Assert.assertEquals(VersionStatus
 126             .valueOf(capturedInfo.getProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS)),
 127         version.getStatus());
 128     Assert.assertEquals(capturedInfo.getProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL),
 129         version.toString());
 130   }
 131
 132   @Test
 133   public void testUpdate() throws Exception {
 134     String itemId = "itemId";
 135     Version version = new Version(1, 0);
 136     version.setId("versionId");
 137     version.setBaseId("baseId");
 138     version.setName("version name");
 139     version.setDescription("version description");
 140     version.setStatus(VersionStatus.Certified);
 141
 142     ArgumentCaptor<ItemVersionData> capturedZusammenVersion =
 143         ArgumentCaptor.forClass(ItemVersionData.class);
 144
 145     versionDao.update(itemId, version);
 146
 147     verify(zusammenAdaptorMock)
 148         .updateVersion(eq(createZusammenContext(USER)), eq(new Id(itemId)),
 149             eq(new Id(version.getId())), capturedZusammenVersion.capture());
 150
 151     Info capturedInfo = capturedZusammenVersion.getValue().getInfo();
 152     Assert.assertEquals(capturedInfo.getName(), version.getName());
 153     Assert.assertEquals(capturedInfo.getDescription(), version.getDescription());
 154     Assert.assertEquals(VersionStatus
 155             .valueOf(capturedInfo.getProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS)),
 156         version.getStatus());
 157     Assert.assertEquals(capturedInfo.getProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL),
 158         version.toString());
 159   }
 160
 161   @Test
 162   public void testGetNonExisting() throws Exception {
 163     Optional<Version> version = versionDao.get("itemId", new Version("versionId"));
 164
 165     Assert.assertEquals(version, Optional.empty());
 166   }
 167
 168   @Test
 169   public void testGetSynced() throws Exception {
 170     String itemId = "itemId";
 171     String versionId = "versionId";
 172
 173     SessionContext zusammenContext = createZusammenContext(USER);
 174     Id itemIdObj = new Id(itemId);
 175     Id versionIdObj = new Id(versionId);
 176
 177     ItemVersion zusammenPrivateVersion =
 178         createZusammenVersion(versionIdObj, new Id("baseId"), "version desc  updated", "2.0",
 179             VersionStatus.Draft);
 180     doReturn(zusammenPrivateVersion).when(zusammenAdaptorMock)
 181         .getVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
 182
 183     ItemVersionStatus zusammenVersionStatus =
 184         new ItemVersionStatus(SynchronizationStatus.UP_TO_DATE, true);
 185     doReturn(zusammenVersionStatus).when(zusammenAdaptorMock)
 186         .getVersionStatus(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
 187
 188     Optional<Version> version = versionDao.get(itemId, new Version(versionId));
 189
 190     Assert.assertTrue(version.isPresent());
 191     assetVersionEquals(version.get(), zusammenPrivateVersion, zusammenVersionStatus);
 192   }
 193
 194   @Test
 195   public void testGetOutOfSync() throws Exception {
 196     String itemId = "itemId";
 197     String versionId = "versionId";
 198
 199     SessionContext zusammenContext = createZusammenContext(USER);
 200     Id itemIdObj = new Id(itemId);
 201     Id versionIdObj = new Id(versionId);
 202
 203     ItemVersion zusammenPrivateVersion =
 204         createZusammenVersion(versionIdObj, new Id("baseId"), "version desc updated", "2.0",
 205             VersionStatus.Draft);
 206     doReturn(zusammenPrivateVersion).when(zusammenAdaptorMock)
 207         .getVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
 208
 209     ItemVersionStatus zusammenVersionStatus =
 210         new ItemVersionStatus(SynchronizationStatus.OUT_OF_SYNC, true);
 211     doReturn(zusammenVersionStatus).when(zusammenAdaptorMock)
 212         .getVersionStatus(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
 213
 214     VersionStatus statusOnPublic = VersionStatus.Certified;
 215     ItemVersion zusammenPublicVersion =
 216         createZusammenVersion(versionIdObj, new Id("baseId"), "version desc", "2.0",
 217             statusOnPublic);
 218     doReturn(zusammenPublicVersion).when(zusammenAdaptorMock)
 219         .getPublicVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
 220
 221     Optional<Version> version = versionDao.get(itemId, new Version(versionId));
 222
 223     Assert.assertTrue(version.isPresent());
 224     zusammenPrivateVersion.getData().getInfo()
 225         .addProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS, statusOnPublic.name());
 226     assetVersionEquals(version.get(), zusammenPrivateVersion, zusammenVersionStatus);
 227   }
 228
 229   @Test
 230   public void testGetMerging() throws Exception {
 231     String itemId = "itemId";
 232     String versionId = "versionId";
 233
 234     SessionContext zusammenContext = createZusammenContext(USER);
 235     Id itemIdObj = new Id(itemId);
 236     Id versionIdObj = new Id(versionId);
 237
 238     ItemVersion zusammenPrivateVersion =
 239         createZusammenVersion(versionIdObj, new Id("baseId"), "version desc", "2.0",
 240             VersionStatus.Draft);
 241     doReturn(zusammenPrivateVersion).when(zusammenAdaptorMock)
 242         .getVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
 243
 244     ItemVersionStatus zusammenVersionStatus =
 245         new ItemVersionStatus(SynchronizationStatus.MERGING, true);
 246     doReturn(zusammenVersionStatus).when(zusammenAdaptorMock)
 247         .getVersionStatus(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
 248
 249     ItemVersion zusammenPublicVersion =
 250         createZusammenVersion(versionIdObj, new Id("baseId"), "version desc", "2.0",
 251             VersionStatus.Draft);
 252     doReturn(zusammenPublicVersion).when(zusammenAdaptorMock)
 253         .getPublicVersion(eq(zusammenContext), eq(itemIdObj), eq(versionIdObj));
 254
 255     Optional<Version> version = versionDao.get(itemId, new Version(versionId));
 256
 257     Assert.assertTrue(version.isPresent());
 258     assetVersionEquals(version.get(), zusammenPrivateVersion, zusammenVersionStatus);
 259   }
 260
 261   @Test
 262   public void testPublish() throws Exception {
 263     String itemId = "itemId";
 264     String versionId = "versionId";
 265     String message = "publish message";
 266
 267     versionDao.publish(itemId, new Version(versionId), message);
 268
 269     verify(zusammenAdaptorMock)
 270         .publishVersion(eq(createZusammenContext(USER)), eq(new Id(itemId)), eq(new Id(versionId)),
 271             eq(message));
 272   }
 273
 274   @Test
 275   public void testSync() throws Exception {
 276     String itemId = "itemId";
 277     String versionId = "versionId";
 278
 279     versionDao.sync(itemId, new Version(versionId));
 280
 281     verify(zusammenAdaptorMock)
 282         .syncVersion(eq(createZusammenContext(USER)), eq(new Id(itemId)), eq(new Id(versionId)));
 283   }
 284
 285   @Test
 286   public void testForceSync() throws Exception {
 287     String itemId = "itemId";
 288     String versionId = "versionId";
 289
 290     versionDao.forceSync(itemId, new Version(versionId));
 291
 292     verify(zusammenAdaptorMock)
 293         .forceSyncVersion(eq(createZusammenContext(USER)), eq(new Id(itemId)),
 294             eq(new Id(versionId)));
 295   }
 296
 297   @Test
 298   public void testRevert() throws Exception {
 299     String itemId = "itemId";
 300     String versionId = "versionId";
 301     String revisionId = "revisionId";
 302
 303     versionDao.revert(itemId, new Version(versionId), revisionId);
 304
 305     verify(zusammenAdaptorMock)
 306         .revert(eq(createZusammenContext(USER)), eq(new Id(itemId)), eq(new Id(versionId)),
 307             eq(new Id(revisionId)));
 308   }
 309
 310   @Test
 311   public void testListRevisionsWhenNone() throws Exception {
 312     String itemId = "itemId";
 313     String versionId = "versionId";
 314
 315     List<Revision> revisions = versionDao.listRevisions(itemId, new Version(versionId));
 316
 317     Assert.assertTrue(revisions.isEmpty());
 318   }
 319
 320   @Test
 321   public void testListRevisions() throws Exception {
 322     String itemId = "itemId";
 323     String versionId = "versionId";
 324
 325     long currentTime = System.currentTimeMillis();
 326     Date rev4time = new Date(currentTime);            // latest
 327     Date rev3time = new Date(currentTime - 1);
 328     Date rev2time = new Date(currentTime - 2);
 329     Date rev1time = new Date(currentTime - 3);  // oldest
 330     List<com.amdocs.zusammen.datatypes.itemversion.Revision> zusammenRevisions = Stream.of(
 331         createZusammenRevision("rev4", "forth rev", "user1", rev4time),
 332         createZusammenRevision("rev1", "first rev", "user2", rev1time),
 333         createZusammenRevision("rev3", "third rev", "user2", rev3time),
 334         createZusammenRevision("rev2", "second rev", "user1", rev2time))
 335         .collect(Collectors.toList());
 336     ItemVersionRevisions toBeReturned = new ItemVersionRevisions();
 337     toBeReturned.setItemVersionRevisions(zusammenRevisions);
 338     doReturn(toBeReturned).when(zusammenAdaptorMock)
 339         .listRevisions(eq(createZusammenContext(USER)), eq(new Id(itemId)), eq(new Id(versionId)));
 340
 341     List<Revision> revisions = versionDao.listRevisions(itemId, new Version(versionId));
 342
 343     Assert.assertEquals(revisions.size(), 4);
 344     assertRevisionEquals(revisions.get(0), zusammenRevisions.get(0)); // rev4 - latest
 345     assertRevisionEquals(revisions.get(1), zusammenRevisions.get(2)); // rev3
 346     assertRevisionEquals(revisions.get(2), zusammenRevisions.get(3)); // rev2
 347     assertRevisionEquals(revisions.get(3), zusammenRevisions.get(1)); // rev1 - oldest
 348   }
 349
 350   private ItemVersion createZusammenVersion(Id id, Id baseId, String description, String label,
 351                                             VersionStatus status) {
 352     ItemVersion version = new ItemVersion();
 353     version.setId(id);
 354     version.setBaseId(baseId);
 355     Info info = new Info();
 356     info.setName(id + "_name");
 357     info.setDescription(description);
 358     info.addProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL, label);
 359     info.addProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS, status.name());
 360     ItemVersionData data = new ItemVersionData();
 361     data.setInfo(info);
 362     version.setData(data);
 363     version.setCreationTime(new Date());
 364     version.setModificationTime(new Date());
 365     return version;
 366   }
 367
 368   private void assetVersionEquals(Version version, ItemVersion zusammenVersion,
 369                                   ItemVersionStatus zusammenVersionStatus) {
 370     Assert.assertEquals(version.getId(), zusammenVersion.getId().getValue());
 371     Assert.assertEquals(version.getBaseId(),
 372         zusammenVersion.getBaseId() == null ? null : zusammenVersion.getBaseId().getValue());
 373     Info info = zusammenVersion.getData().getInfo();
 374     Assert.assertEquals(version.getName(), info.getName());
 375     Assert.assertEquals(version.getDescription(), info.getDescription());
 376     Assert.assertEquals(version.getStatus(),
 377         VersionStatus.valueOf(info.getProperty(VersionZusammenDaoImpl.ZusammenProperty.STATUS)));
 378     String label = info.getProperty(VersionZusammenDaoImpl.ZusammenProperty.LABEL).toString();
 379     Assert
 380         .assertEquals(version.getMajor(), Integer.parseInt(label.substring(0, label.indexOf('.'))));
 381     Assert.assertEquals(version.getMinor(),
 382         Integer.parseInt(label.substring(label.indexOf('.') + 1, label.length())));
 383     Assert.assertEquals(version.getCreationTime(), zusammenVersion.getCreationTime());
 384     Assert.assertEquals(version.getModificationTime(), zusammenVersion.getModificationTime());
 385
 386     if (zusammenVersionStatus != null) {
 387       Assert.assertEquals(version.getState().isDirty(), zusammenVersionStatus.isDirty());
 388       Assert.assertEquals(version.getState().getSynchronizationState().toString(),
 389           zusammenVersionStatus.getSynchronizationStatus().toString());
 390     }
 391   }
 392
 393   private com.amdocs.zusammen.datatypes.itemversion.Revision createZusammenRevision(String id,
 394                                                                                     String message,
 395                                                                                     String user,
 396                                                                                     Date time) {
 397     com.amdocs.zusammen.datatypes.itemversion.Revision revision = new com.amdocs.zusammen
 398         .datatypes.itemversion.Revision();
 399     revision.setRevisionId(new Id(id));
 400     revision.setMessage(message);
 401     revision.setUser(user);
 402     revision.setTime(time);
 403     return revision;
 404   }
 405
 406   private void assertRevisionEquals(
 407       Revision revision,
 408       com.amdocs.zusammen.datatypes.itemversion.Revision zusammenRevision) {
 409     Assert.assertEquals(revision.getId(), zusammenRevision.getRevisionId().getValue());
 410     Assert.assertEquals(revision.getMessage(), zusammenRevision.getMessage());
 411     Assert.assertEquals(revision.getUser(), zusammenRevision.getUser());
 412     Assert.assertEquals(revision.getTime(), zusammenRevision.getTime());
 413   }
 414 }