openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/PermissionsManagerImplTest.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.itempermissions.dao.impl;
  18
  19 import static org.junit.jupiter.api.Assertions.assertEquals;
  20 import static org.junit.jupiter.api.Assertions.assertTrue;
  21 import static org.mockito.Mockito.doReturn;
  22 import static org.mockito.Mockito.verify;
  23 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.ITEM_ID_PROP;
  24 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_CHANGED;
  25 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_GRANTED;
  26 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_ITEM;
  27
  28 import java.util.Collections;
  29 import java.util.HashSet;
  30 import java.util.Map;
  31 import java.util.Set;
  32 import java.util.stream.Collectors;
  33 import java.util.stream.Stream;
  34 import org.junit.jupiter.api.Assertions;
  35 import org.junit.jupiter.api.BeforeEach;
  36 import org.junit.jupiter.api.Test;
  37 import org.junit.jupiter.api.extension.ExtendWith;
  38 import org.mockito.ArgumentCaptor;
  39 import org.mockito.Captor;
  40 import org.mockito.InjectMocks;
  41 import org.mockito.Matchers;
  42 import org.mockito.Mock;
  43 import org.mockito.MockitoAnnotations;
  44 import org.mockito.junit.jupiter.MockitoExtension;
  45 import org.openecomp.sdc.common.errors.CoreException;
  46 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  47 import org.openecomp.sdc.itempermissions.PermissionsServices;
  48 import org.openecomp.sdc.notification.dtos.Event;
  49 import org.openecomp.sdc.notification.services.NotificationPropagationManager;
  50 import org.openecomp.sdc.notification.services.SubscriptionService;
  51 import org.openecomp.sdc.versioning.AsdcItemManager;
  52 import org.openecomp.sdc.versioning.types.Item;
  53
  54 @ExtendWith(MockitoExtension.class)
  55 class PermissionsManagerImplTest {
  56
  57     private static final String ITEM1_ID = "1";
  58     private static final String PERMISSION = "Contributor";
  59     private static final String ACTION = "Change_Item_Permissions";
  60     private static final String USER = "user";
  61     private static final String AFFECTED_USER1 = "affected_user1";
  62     private static final String AFFECTED_USER2 = "affected_user2";
  63     private static final String AFFECTED_USER3 = "affected_user3";
  64     private static final String tenant = "dox";
  65
  66     @Mock
  67     private PermissionsServices permissionsServicesMock;
  68     @Mock
  69     private AsdcItemManager asdcItemManagerMock;
  70     @Mock
  71     private SubscriptionService subscriptionServiceMock;
  72     @Mock
  73     private NotificationPropagationManager notifierMock;
  74     @Captor
  75     private ArgumentCaptor<Event> eventArgumentCaptor;
  76
  77     @InjectMocks
  78     private PermissionsManagerImpl permissionsManager;
  79
  80     @BeforeEach
  81     public void setUp() throws Exception {
  82         SessionContextProviderFactory.getInstance().createInterface().create(USER,
  83             tenant);
  84         MockitoAnnotations.openMocks(this);
  85     }
  86
  87     @Test
  88     void testUpdateItemPermissionsWhenNotAllowed() {
  89         doReturn(false).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
  90         final HashSet<String> removedUsersIds = new HashSet<>();
  91         final Set<String> addedUsersIds = Collections.singleton(AFFECTED_USER1);
  92         Assertions.assertThrows(CoreException.class, () -> {
  93             permissionsManager.updateItemPermissions(ITEM1_ID, PERMISSION, addedUsersIds, removedUsersIds);
  94         });
  95     }
  96
  97     @Test
  98     void testUpdateItemPermissions() {
  99         doReturn(true).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
 100         Item item = new Item();
 101         item.setName("Item 1 Name");
 102         doReturn(item).when(asdcItemManagerMock).get(ITEM1_ID);
 103
 104         Set<String> addedUsersIds =
 105             Stream.of(AFFECTED_USER1, AFFECTED_USER2).collect(Collectors.toSet());
 106         Set<String> removedUsersIds = Collections.singleton(AFFECTED_USER3);
 107         permissionsManager
 108             .updateItemPermissions(ITEM1_ID, PERMISSION, addedUsersIds, removedUsersIds);
 109
 110         verify(permissionsServicesMock)
 111             .updateItemPermissions(ITEM1_ID, PERMISSION, addedUsersIds, removedUsersIds);
 112
 113         for (String addedUsersId : addedUsersIds) {
 114             verifyCallsToNotificationsFramework(addedUsersId, true);
 115         }
 116         for (String removedUsersId : removedUsersIds) {
 117             verifyCallsToNotificationsFramework(removedUsersId, false);
 118         }
 119     }
 120
 121     @Test
 122     void testListUserPermittedItems() {
 123         permissionsManager.listUserPermittedItems(AFFECTED_USER1, PERMISSION);
 124
 125         verify(permissionsServicesMock)
 126             .listUserPermittedItems(AFFECTED_USER1, PERMISSION);
 127
 128     }
 129
 130     private void verifyCallsToNotificationsFramework(String affectedUser, boolean permissionGranted) {
 131         verifyCallToSubscriptionService(affectedUser, permissionGranted);
 132         verifyDirectNotificationCallParameters(affectedUser, permissionGranted);
 133     }
 134
 135     private void verifyDirectNotificationCallParameters(String affectedUser, boolean permissionGranted) {
 136         verify(notifierMock).directNotification(eventArgumentCaptor.capture(), Matchers.eq(affectedUser));
 137         Event event = eventArgumentCaptor.getValue();
 138         assertTrue(event.getEventType().equals(PERMISSION_CHANGED));
 139         Map<String, Object> attributes = event.getAttributes();
 140         assertEquals(attributes.get(PERMISSION_GRANTED), permissionGranted);
 141         assertEquals(attributes.get(ITEM_ID_PROP), ITEM1_ID);
 142         assertEquals(attributes.get(PERMISSION_ITEM), PERMISSION);
 143     }
 144
 145     private void verifyCallToSubscriptionService(String affectedUser, boolean permissionGranted) {
 146         if (permissionGranted) {
 147             verify(subscriptionServiceMock).subscribe(affectedUser, ITEM1_ID);
 148         } else {
 149             verify(subscriptionServiceMock).unsubscribe(affectedUser, ITEM1_ID);
 150         }
 151     }
 152
 153 }