gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.core.zusammen.plugin.collaboration;
   2
   3 public class VersionCollaborationStoreTest {/*
   4   private static final String TENANT = "test";
   5   private static final String USER = "ItemStateStoreTest_user";
   6   private static final SessionContext context =
   7       TestUtils.createSessionContext(new UserInfo(USER), TENANT);
   8
   9   @Mock
  10   private VersionDao versionDaoMock;
  11   @Mock
  12   private ElementStore elementCollaborationStore;
  13   @Spy
  14   @InjectMocks
  15   private VersionStore versionCollaborationStore;
  16
  17   @BeforeMethod
  18   public void setUp() throws Exception {
  19     MockitoAnnotations.initMocks(this);
  20     when(versionCollaborationStore.getVersionDao(anyObject())).thenReturn(versionDaoMock);
  21   }
  22 *//*
  23   @Test
  24   public void testListPrivateItemVersions() throws Exception {
  25     testListItemVersions(Space.PRIVATE, USER);
  26   }
  27
  28   @Test
  29   public void testListPublicItemVersions() throws Exception {
  30     testListItemVersions(Space.PUBLIC, ZusammenPluginConstants.PUBLIC_SPACE);
  31   }
  32
  33   @Test
  34   public void testIsPrivateItemVersionExist() throws Exception {
  35     testIsItemVersionExist(Space.PRIVATE, USER);
  36   }
  37
  38   @Test
  39   public void testIsPublicItemVersionExist() throws Exception {
  40     testIsItemVersionExist(Space.PUBLIC, ZusammenPluginConstants.PUBLIC_SPACE);
  41   }
  42
  43   @Test
  44   public void testIsItemVersionExistWhenNot() throws Exception {
  45     Id itemId = new Id();
  46     Id versionId = new Id();
  47     doReturn(Optional.empty()).when(versionDaoMock).get(context, USER, itemId, versionId);
  48
  49     boolean itemExist =
  50         versionCollaborationStore.isItemVersionExist(context, Space.PRIVATE, itemId, versionId);
  51     Assert.assertFalse(itemExist);
  52   }
  53
  54   @Test
  55   public void testGetPrivateItemVersion() throws Exception {
  56     testGetItemVersion(Space.PRIVATE, USER);
  57   }
  58
  59   @Test
  60   public void testGetPublicItemVersion() throws Exception {
  61     testGetItemVersion(Space.PUBLIC, ZusammenPluginConstants.PUBLIC_SPACE);
  62   }
  63
  64
  65   @Test
  66   public void testGetNonExistingItemVersion() throws Exception {
  67     Id itemId = new Id();
  68     Id versionId = new Id();
  69     doReturn(Optional.empty()).when(versionDaoMock).get(context, USER, itemId, versionId);
  70
  71     ItemVersion itemVersion =
  72         versionCollaborationStore.getItemVersion(context, Space.PRIVATE, itemId, versionId);
  73     Assert.assertNull(itemVersion);
  74   }*//*
  75
  76   @Test
  77   public void testCreatePrivateItemVersion() throws Exception {
  78     testCreateItemVersion(Space.PRIVATE, USER, null);
  79   }
  80
  81   @Test
  82   public void testCreatePrivateItemVersionBasedOn() throws Exception {
  83     testCreateItemVersion(Space.PRIVATE, USER, new Id());
  84   }
  85
  86   @Test
  87   public void testCreatePublicItemVersion() throws Exception {
  88     testCreateItemVersion(Space.PUBLIC, ZusammenPluginConstants.PUBLIC_SPACE, null);
  89   }
  90
  91   @Test
  92   public void testCreatePublicItemVersionBasedOn() throws Exception {
  93     testCreateItemVersion(Space.PUBLIC, ZusammenPluginConstants.PUBLIC_SPACE, new Id());
  94   }
  95
  96   @Test
  97   public void testUpdatePrivateItemVersion() throws Exception {
  98     testUpdateItemVersion(Space.PRIVATE, USER);
  99   }
 100
 101   @Test
 102   public void testUpdatePublicItemVersion() throws Exception {
 103     testUpdateItemVersion(Space.PUBLIC, ZusammenPluginConstants.PUBLIC_SPACE);
 104   }
 105
 106   @Test
 107   public void testDeletePrivateItemVersion() throws Exception {
 108     testDeleteItemVersion(Space.PRIVATE, USER);
 109   }
 110
 111   @Test
 112   public void testDeletePublicItemVersion() throws Exception {
 113     testDeleteItemVersion(Space.PUBLIC, ZusammenPluginConstants.PUBLIC_SPACE);
 114   }
 115
 116   @Test
 117   public void testPublishItemVersionWhenNotDirty() throws Exception {
 118     Id itemId = new Id();
 119     ItemVersion version = TestUtils.createItemVersion(new Id(), null, "v1", false);
 120     doReturn(Optional.of(version)).when(versionDaoMock).get(context, USER, itemId, version.getId());
 121
 122     versionCollaborationStore.publishItemVersion(context, itemId, version.getId(), "message");
 123
 124   }
 125 *//*
 126   private void testIsItemVersionExist(Space space, String spaceName) {
 127     Id itemId = new Id();
 128     ItemVersion retrievedVersion = TestUtils.createItemVersion(new Id(), null, "v1");
 129     doReturn(Optional.of(retrievedVersion)).when(versionDaoMock)
 130         .get(context, spaceName, itemId, retrievedVersion.getId());
 131
 132     boolean itemExist =
 133         versionCollaborationStore
 134             .isItemVersionExist(context, space, itemId, retrievedVersion.getId());
 135     Assert.assertTrue(itemExist);
 136   }
 137
 138   private void testGetItemVersion(Space space, String spaceName) throws Exception {
 139     Id itemId = new Id();
 140     ItemVersion retrievedVersion = TestUtils.createItemVersion(new Id(), null, "v1");
 141     doReturn(Optional.of(retrievedVersion)).when(versionDaoMock)
 142         .get(context, spaceName, itemId, retrievedVersion.getId());
 143
 144     ItemVersion itemVersion =
 145         versionCollaborationStore.getItemVersion(context, space, itemId, retrievedVersion.getId());
 146     Assert.assertEquals(itemVersion, retrievedVersion);
 147   }
 148
 149   private void testListItemVersions(Space space, String spaceName) {
 150     Id itemId = new Id();
 151     ItemVersion v1 = TestUtils.createItemVersion(new Id(), null, "v1");
 152     ItemVersion v2 = TestUtils.createItemVersion(new Id(), v1.getId(), "v2");
 153     ItemVersion v3 = TestUtils.createItemVersion(new Id(), v2.getId(), "v3");
 154     List<ItemVersion> retrievedVersions = Arrays.asList(v1, v2, v3);
 155     doReturn(retrievedVersions).when(versionDaoMock).list(context, spaceName, itemId);
 156
 157     Collection<ItemVersion> itemVersions =
 158         versionCollaborationStore.listItemVersions(context, space, itemId);
 159     Assert.assertEquals(itemVersions, retrievedVersions);
 160   }*//*
 161
 162   private void testCreateItemVersion(Space space, String spaceName, Id baseId) {
 163     Id itemId = new Id();
 164     ItemVersion v1 = TestUtils.createItemVersion(new Id(), baseId, "v1", false);
 165     List<ElementEntity> baseVersionElements = mockVersionElements(spaceName, itemId, baseId);
 166
 167     ArgumentCaptor<ItemVersion> versionCaptor = ArgumentCaptor.forClass(ItemVersion.class);
 168
 169     Date creationTime = new Date();
 170     versionCollaborationStore
 171         .createItemVersion(context, space, itemId, baseId, v1.getId(), v1.getData(), creationTime);
 172
 173     verify(versionDaoMock).create(eq(context), eq(spaceName), eq(itemId), versionCaptor.capture());
 174     //baseId, v1.getId(),v1.getData(), creationTime);
 175
 176     ItemVersion capturedVersion = versionCaptor.getValue();
 177     Assert.assertEquals(baseId, capturedVersion.getBaseId());
 178     Assert.assertEquals(v1.getId(), capturedVersion.getId());
 179     Assert.assertEquals(v1.getData(), capturedVersion.getData());
 180     Assert.assertEquals(creationTime, capturedVersion.getCreationTime());
 181 *//*    verify(versionDaoMock)
 182         .create(anyObject(), anyObject(), anyObject(), anyObject(), anyObject(), anyObject(),
 183             anyObject());*//*
 184
 185 *//*    if (baseId != null) {
 186       baseVersionElements.forEach(element ->
 187           verify(elementCollaborationStore).create(eq(context),
 188               eq(new ElementEntityContext(spaceName, itemId, v1.getId())),
 189               eq(element)));
 190     } else {
 191       verifyZeroInteractions(elementCollaborationStore);
 192     }*//*
 193   }
 194
 195   private void testUpdateItemVersion(Space space, String spaceName) {
 196     Id itemId = new Id();
 197     ItemVersion retrievedVersion = TestUtils.createItemVersion(new Id(), null, "v1", false);
 198     doReturn(Optional.of(retrievedVersion)).when(versionDaoMock)
 199         .get(context, spaceName, itemId, retrievedVersion.getId());
 200
 201     ItemVersionData updatedData = new ItemVersionData();
 202     updatedData.setInfo(TestUtils.createInfo("v1 updated"));
 203     updatedData.setRelations(
 204         Arrays.asList(new Relation(), new Relation(), new Relation(), new Relation()));
 205     versionCollaborationStore.updateItemVersion(
 206         context, space, itemId, retrievedVersion.getId(), updatedData, new Date());
 207
 208     *//*verify(versionDaoMock)
 209         .update(context, spaceName, itemId, retrievedVersion.getId(), updatedData, modificationTime);*//*
 210     verify(versionDaoMock)
 211         .update(anyObject(), anyObject(), anyObject(), anyObject());
 212
 213   }
 214
 215   private void testDeleteItemVersion(Space space, String spaceName) {
 216     Id itemId = new Id();
 217     Id versionId = new Id();
 218
 219     List<ElementEntity> versionElements = mockVersionElements(spaceName, itemId, versionId);
 220     versionCollaborationStore.deleteItemVersion(context, space, itemId, versionId);
 221
 222 *//*    versionElements.forEach(element ->
 223         verify(elementCollaborationStore).delete(eq(context),
 224             eq(new ElementEntityContext(spaceName, itemId, versionId)),
 225             eq(element)));*//*
 226     verify(versionDaoMock).delete(context, spaceName, itemId, versionId);
 227   }
 228
 229   private List<ElementEntity> mockVersionElements(String spaceName, Id itemId, Id versionId) {
 230     ElementEntity elm1 = new ElementEntity(new Id());
 231     ElementEntity elm2 = new ElementEntity(new Id());
 232     List<ElementEntity> baseVersionElements = Arrays.asList(elm1, elm2);
 233 *//*    doReturn(baseVersionElements).when(elementCollaborationStore)
 234         .list(eq(context), eq(new ElementEntityContext(spaceName, itemId, versionId)));*//*
 235     return baseVersionElements;
 236   }*/
 237 }