gerrit.onap Code Review - sdc.git/blob

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