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

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