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