openecomp-be/lib/openecomp-item-permissions-lib/openecomp-item-permissions-core/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/PermissionsServicesImplTest.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.mockito.Matchers.anyObject;
  20 import static org.mockito.Matchers.anyString;
  21 import static org.mockito.Mockito.doReturn;
  22 import static org.mockito.Mockito.times;
  23 import static org.mockito.Mockito.verify;
  24 import static org.mockito.Mockito.when;
  25
  26 import java.util.Arrays;
  27 import java.util.Collection;
  28 import java.util.Collections;
  29 import java.util.HashSet;
  30 import java.util.Optional;
  31 import java.util.Set;
  32 import org.mockito.InjectMocks;
  33 import org.mockito.Mock;
  34 import org.mockito.Mockito;
  35 import org.mockito.MockitoAnnotations;
  36 import org.mockito.Spy;
  37 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
  38 import org.openecomp.sdc.itempermissions.PermissionsRules;
  39 import org.openecomp.sdc.itempermissions.dao.ItemPermissionsDao;
  40 import org.openecomp.sdc.itempermissions.dao.UserPermissionsDao;
  41 import org.openecomp.sdc.itempermissions.type.ItemPermissionsEntity;
  42 import org.junit.Test;
  43 import org.junit.Before;
  44 import org.junit.Assert;
  45
  46
  47 /**
  48  * Created by ayalaben on 7/9/2017
  49  */
  50 public class PermissionsServicesImplTest {
  51
  52     private static final String ITEM1_ID = "1";
  53     private static final String PERMISSION = "Owner";
  54     private static final String USER2_ID = "testUser2";
  55     private static final String USER1_ID = "testUser1";
  56     private static final String ACTION_SUBMIT = "Submit_Item";
  57     private static final String CHANGE_PERMISSIONS = "Change_Item_Permissions";
  58
  59     static {
  60         SessionContextProviderFactory.getInstance().createInterface().create("testUser1", "dox");
  61     }
  62
  63     @Mock
  64     private ItemPermissionsDao permissionsDaoMock;
  65     @Mock
  66     private UserPermissionsDao userPermissionsDao;  // do not delete. needed for permissionService
  67     @Mock
  68     private PermissionsRules permissionsRulesMock;
  69     @InjectMocks
  70     @Spy
  71     private PermissionsServicesImpl permissionsServices;
  72
  73
  74     @Before
  75     public void setUp() {
  76         MockitoAnnotations.initMocks(this);
  77     }
  78
  79     @Test
  80     public void testListUserPermittedItems() {
  81         Set<String> userPermissionSet = Collections.emptySet();
  82
  83         Mockito.when(userPermissionsDao.listUserPermittedItems(anyString(), anyString())).thenReturn(userPermissionSet);
  84
  85         Set<String> permissionsSet = permissionsServices.listUserPermittedItems(USER1_ID, PERMISSION);
  86
  87         Assert.assertEquals(0, permissionsSet.size());
  88     }
  89
  90     @Test
  91     public void testExecute() {
  92         Mockito.doNothing().when(permissionsRulesMock).executeAction(anyString(), anyString(), anyString());
  93
  94         permissionsServices.execute(ITEM1_ID, USER1_ID, PERMISSION);
  95
  96         Mockito.verify(permissionsRulesMock, times(1)).executeAction(anyString(), anyString(), anyString());
  97     }
  98
  99     @Test
 100     public void testDeleteItemPermissions() {
 101         Mockito.doNothing().when(permissionsDaoMock).deleteItemPermissions(anyString());
 102
 103         permissionsServices.deleteItemPermissions(ITEM1_ID);
 104
 105         Mockito.verify(permissionsDaoMock, times(1)).deleteItemPermissions(anyString());
 106     }
 107
 108     @Test
 109     public void testGetUserItemPermission() {
 110         Mockito.when(permissionsDaoMock.getUserItemPermission(anyString(), anyString()))
 111                .thenReturn(Optional.of(PERMISSION));
 112
 113         Optional<String> permission = permissionsServices.getUserItemPermission(ITEM1_ID, USER1_ID);
 114
 115         Assert.assertTrue(permission.isPresent());
 116         Assert.assertEquals(PERMISSION, permission.get());
 117     }
 118
 119     @Test
 120     public void testListItemPermissionsWhenNone() {
 121         Collection<ItemPermissionsEntity> permissions = permissionsServices.listItemPermissions(ITEM1_ID);
 122         Assert.assertEquals( 0, permissions.size());
 123     }
 124
 125
 126     @Test
 127     public void testListItemPermissions() {
 128         doReturn(Arrays.asList(createPermissionEntity(ITEM1_ID, USER1_ID, PERMISSION),
 129                 createPermissionEntity(ITEM1_ID, USER2_ID, PERMISSION))).when(permissionsDaoMock)
 130                                                                         .listItemPermissions(anyObject());
 131
 132         Collection<ItemPermissionsEntity> actual = permissionsServices.listItemPermissions(ITEM1_ID);
 133         Assert.assertEquals(2, actual.size());
 134     }
 135
 136
 137     @Test
 138     public void testIsAllowed() {
 139         when(permissionsDaoMock.getUserItemPermission(ITEM1_ID, USER1_ID)).thenReturn(Optional.of(PERMISSION));
 140         when(permissionsRulesMock.isAllowed(PERMISSION, ACTION_SUBMIT)).thenReturn(true);
 141
 142         boolean result = permissionsServices.isAllowed(ITEM1_ID, USER1_ID, ACTION_SUBMIT);
 143
 144         Assert.assertTrue(result);
 145
 146     }
 147
 148     @Test
 149     public void shouldUpdatePermissions() {
 150
 151         Set<String> addedUsers = new HashSet<>();
 152         addedUsers.add(USER2_ID);
 153
 154         permissionsServices.updateItemPermissions(ITEM1_ID, PERMISSION, addedUsers, new HashSet<>());
 155
 156         verify(permissionsRulesMock).executeAction(ITEM1_ID, USER1_ID, CHANGE_PERMISSIONS);
 157         verify(permissionsRulesMock).updatePermission(ITEM1_ID, USER1_ID, PERMISSION, addedUsers, new HashSet<>());
 158         verify(permissionsDaoMock).updateItemPermissions(ITEM1_ID, PERMISSION, addedUsers, new HashSet<>());
 159     }
 160
 161     @Test
 162     public void shouldExecutePermissionRules() {
 163         permissionsServices.execute(ITEM1_ID, USER1_ID, ACTION_SUBMIT);
 164         verify(permissionsRulesMock).executeAction(ITEM1_ID, USER1_ID, ACTION_SUBMIT);
 165     }
 166
 167     @Test
 168     public void shouldReturnUserItemPermission() {
 169         doReturn(Optional.of(PERMISSION)).when(permissionsDaoMock).getUserItemPermission(ITEM1_ID, USER1_ID);
 170         Optional<String> actual = permissionsServices.getUserItemPermission(ITEM1_ID, USER1_ID);
 171         Assert.assertTrue(actual.isPresent());
 172         Assert.assertEquals(PERMISSION, actual.get());
 173     }
 174
 175     @Test
 176     public void shouldDeleteItemPermissions() {
 177         permissionsServices.deleteItemPermissions(ITEM1_ID);
 178         verify(permissionsDaoMock).deleteItemPermissions(ITEM1_ID);
 179     }
 180
 181
 182     private static ItemPermissionsEntity createPermissionEntity(String itemId, String userId, String permission) {
 183         ItemPermissionsEntity permissionsEntity = new ItemPermissionsEntity();
 184         permissionsEntity.setItemId(itemId);
 185         permissionsEntity.setUserId(userId);
 186         permissionsEntity.setPermission(permission);
 187         return permissionsEntity;
 188     }
 189
 190 }