gerrit.onap Code Review - sdc.git/blob

   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.mockito.Mockito.doReturn;
  20 import static org.mockito.Mockito.verify;
  21 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.ITEM_ID_PROP;
  22 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_CHANGED;
  23 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_GRANTED;
  24 import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_ITEM;
  25 import static org.testng.Assert.assertEquals;
  26 import static org.testng.Assert.assertTrue;
  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.mockito.ArgumentCaptor;
  35 import org.mockito.Captor;
  36 import org.mockito.InjectMocks;
  37 import org.mockito.Matchers;
  38 import org.mockito.Mock;
  39 import org.mockito.MockitoAnnotations;
  40 import org.openecomp.sdc.common.errors.CoreException;
  41 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  42 import org.openecomp.sdc.itempermissions.PermissionsServices;
  43 import org.openecomp.sdc.notification.dtos.Event;
  44 import org.openecomp.sdc.notification.services.NotificationPropagationManager;
  45 import org.openecomp.sdc.notification.services.SubscriptionService;
  46 import org.openecomp.sdc.versioning.AsdcItemManager;
  47 import org.openecomp.sdc.versioning.types.Item;
  48 import org.testng.annotations.BeforeMethod;
  49 import org.testng.annotations.Test;
  50
  51 /**
  52  * Created by ayalaben on 7/6/2017
  53  */
  54 public class ItemPermissionsManagerImplTest {
  55
  56   private static final String ITEM1_ID = "1";
  57   private static final String PERMISSION = "Contributor";
  58   private static final String ACTION = "Change_Item_Permissions";
  59   private static final String USER = "user";
  60   private static final String AFFECTED_USER1 = "affected_user1";
  61   private static final String AFFECTED_USER2 = "affected_user2";
  62   private static final String AFFECTED_USER3 = "affected_user3";
  63   private static final String tenant = "dox";
  64
  65   @Mock
  66   private PermissionsServices permissionsServicesMock;
  67   @Mock
  68   private AsdcItemManager asdcItemManagerMock;
  69   @Mock
  70   private SubscriptionService subscriptionServiceMock;
  71   @Mock
  72   private NotificationPropagationManager notifierMock;
  73   @Captor
  74   private ArgumentCaptor<Event> eventArgumentCaptor;
  75
  76   @InjectMocks
  77   private ItemPermissionsManagerImpl permissionsManager;
  78
  79
  80   @BeforeMethod
  81   public void setUp() throws Exception {
  82     SessionContextProviderFactory.getInstance().createInterface().create(USER,
  83         tenant);
  84     MockitoAnnotations.initMocks(this);
  85   }
  86
  87   @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Permissions " +
  88           "Error. The user does not have permission to perform this action.")
  89   public void testUpdateItemPermissionsWhenNotAllowed() {
  90     doReturn(false).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
  91
  92     permissionsManager
  93             .updateItemPermissions(ITEM1_ID, PERMISSION, Collections.singleton(AFFECTED_USER1),
  94                     new HashSet<>());
  95   }
  96
  97   @Test
  98   public 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   private void verifyCallsToNotificationsFramework(String affectedUser, boolean permissionGranted) {
 122     verifyCallToSubscriptionService(affectedUser, permissionGranted);
 123     verifyDirectNotificationCallParameters(affectedUser, permissionGranted);
 124   }
 125
 126   private void verifyDirectNotificationCallParameters(String affectedUser, boolean permissionGranted) {
 127     verify(notifierMock).directNotification(eventArgumentCaptor.capture(), Matchers.eq(affectedUser));
 128     Event event = eventArgumentCaptor.getValue();
 129     assertTrue(event.getEventType().equals(PERMISSION_CHANGED));
 130     Map<String, Object> attributes = event.getAttributes();
 131     assertEquals(attributes.get(PERMISSION_GRANTED), permissionGranted);
 132     assertEquals(attributes.get(ITEM_ID_PROP), ITEM1_ID);
 133     assertEquals(attributes.get(PERMISSION_ITEM), PERMISSION);
 134   }
 135
 136   private void verifyCallToSubscriptionService(String affectedUser, boolean permissionGranted) {
 137     if (permissionGranted) {
 138       verify(subscriptionServiceMock).subscribe(affectedUser, ITEM1_ID);
 139     } else {
 140       verify(subscriptionServiceMock).unsubscribe(affectedUser, ITEM1_ID);
 141     }
 142   }
 143
 144
 145 }