catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicExtTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.be.user;
  22
  23
  24 import fj.data.Either;
  25 import org.junit.Before;
  26 import org.junit.Rule;
  27 import org.junit.Test;
  28 import org.junit.rules.ExpectedException;
  29 import org.junit.runner.RunWith;
  30 import org.mockito.Mock;
  31 import org.mockito.Mockito;
  32 import org.mockito.junit.MockitoJUnitRunner;
  33 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  34 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  35 import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
  36 import org.openecomp.sdc.be.config.ConfigurationManager;
  37 import org.openecomp.sdc.be.dao.api.ActionStatus;
  38 import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
  39 import org.openecomp.sdc.be.exception.ComponentExceptionMatcher;
  40 import org.openecomp.sdc.be.facade.operations.UserOperation;
  41 import org.openecomp.sdc.be.impl.ComponentsUtils;
  42 import org.openecomp.sdc.be.model.Component;
  43 import org.openecomp.sdc.be.model.ComponentMetadataDefinition;
  44 import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
  45 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  46 import org.openecomp.sdc.be.model.Resource;
  47 import org.openecomp.sdc.be.model.ResourceMetadataDefinition;
  48 import org.openecomp.sdc.be.model.User;
  49 import org.openecomp.sdc.be.model.operations.StorageException;
  50 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  51 import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation;
  52 import org.openecomp.sdc.common.api.ConfigurationSource;
  53 import org.openecomp.sdc.common.api.UserRoleEnum;
  54 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  55 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  56 import org.openecomp.sdc.exception.ResponseFormat;
  57
  58 import java.util.ArrayList;
  59 import java.util.LinkedList;
  60 import java.util.List;
  61
  62 import static org.assertj.core.api.Assertions.assertThat;
  63 import static org.mockito.ArgumentMatchers.any;
  64 import static org.mockito.ArgumentMatchers.anyString;
  65 import static org.mockito.ArgumentMatchers.eq;
  66 import static org.mockito.Mockito.doReturn;
  67 import static org.mockito.Mockito.never;
  68 import static org.mockito.Mockito.times;
  69 import static org.mockito.Mockito.verify;
  70 import static org.mockito.Mockito.when;
  71
  72 @RunWith(MockitoJUnitRunner.class)
  73 public class UserBusinessLogicExtTest {
  74
  75     private static final String MOCK_MODIFIER = "mockMod";
  76     private static final String ID1 = "A";
  77     private static final String ID2 = "B";
  78     private UserBusinessLogicExt testSubject;
  79
  80     @Mock
  81     private UserAdminOperation userAdminOperation;
  82
  83     @Mock
  84     private LifecycleBusinessLogic lifecycleBusinessLogic;
  85     @Mock
  86     private static UserOperation facadeUserOperation;
  87
  88
  89     @Before
  90     public void setUp() {
  91         // init Configuration
  92         String appConfigDir = "src/test/resources/config/catalog-be";
  93         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(),
  94                 appConfigDir);
  95         @SuppressWarnings("unused")
  96         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
  97         ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
  98         UserBusinessLogic userBusinessLogic = new UserBusinessLogic(userAdminOperation, componentsUtils, facadeUserOperation);
  99         testSubject = new UserBusinessLogicExt(userBusinessLogic, userAdminOperation, lifecycleBusinessLogic,
 100                 componentsUtils);
 101     }
 102
 103     @Test(expected = ComponentException.class)
 104     public void testDeActivateUserMissingID() {
 105         testSubject.deActivateUser(null, "");
 106
 107         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 108     }
 109
 110     @Test(expected = ComponentException.class)
 111     public void testDeActivateUserModifierNotFound() {
 112         String userUniqueIdToDeactivate = "";
 113         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.right(ActionStatus.USER_NOT_FOUND));
 114         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 115
 116         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 117     }
 118
 119     @Test(expected = ComponentException.class)
 120     public void testDeActivateUserModNotAdmin() {
 121         User modifier = new User(MOCK_MODIFIER);
 122         modifier.setRole(UserRoleEnum.DESIGNER.getName());
 123         String userUniqueIdToDeactivate = "";
 124         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 125         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 126
 127         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 128     }
 129
 130     @Test(expected = ComponentException.class)
 131     public void testDeActivateUserDeactivatedUserNotFound() {
 132         User modifier = new User(MOCK_MODIFIER);
 133         modifier.setRole(UserRoleEnum.ADMIN.getName());
 134         String userUniqueIdToDeactivate = "mockDU";
 135
 136         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 137         when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.right(ActionStatus.USER_NOT_FOUND));
 138         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 139
 140         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 141     }
 142
 143     @Test(expected = ComponentException.class)
 144     public void testDeActivateUser_DeactivatedAndModifierAreSame() {
 145         User modifier = new User(MOCK_MODIFIER);
 146         modifier.setRole(UserRoleEnum.ADMIN.getName());
 147
 148         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 149         testSubject.deActivateUser(MOCK_MODIFIER, MOCK_MODIFIER);
 150
 151         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 152     }
 153
 154     @Test(expected = StorageException.class)
 155     public void testDeActivateUserFailToGetTasks() {
 156         User modifier = new User(MOCK_MODIFIER);
 157         modifier.setRole(UserRoleEnum.ADMIN.getName());
 158         String userUniqueIdToDeactivate = "mockDU";
 159         User deacUser = new User();
 160         deacUser.setStatus(UserStatusEnum.ACTIVE);
 161         deacUser.setRole(UserRoleEnum.DESIGNER.name());
 162
 163         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 164         when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
 165         when(userAdminOperation.getUserActiveComponents(any(), any())).thenThrow(new StorageException(StorageOperationStatus.INCONSISTENCY));
 166         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 167
 168         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 169     }
 170
 171     @Test
 172     public void testDeActivateUserWithPendingTasks_verifyActionsWereDone() {
 173         User modifier = new User();
 174         modifier.setUserId(MOCK_MODIFIER);
 175         modifier.setRole(UserRoleEnum.ADMIN.getName());
 176         String userUniqueIdToDeactivate = "mockDU";
 177         User userToDeactivate = new User();
 178         userToDeactivate.setStatus(UserStatusEnum.ACTIVE);
 179         userToDeactivate.setRole(UserRoleEnum.DESIGNER.name());
 180
 181         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 182         when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(userToDeactivate));
 183         List<Component> components = new ArrayList<>();
 184         Resource componentCheckedOut = createComponent(ID1, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 185         components.add(componentCheckedOut);
 186         when(userAdminOperation.getUserActiveComponents(any(), any())).thenReturn(components);
 187         doReturn(Either.left(componentCheckedOut)).when(lifecycleBusinessLogic).changeComponentState(any(), eq(ID1), eq(userToDeactivate), eq(LifeCycleTransitionEnum.CHECKIN),
 188                 any(), eq(false), eq(true));
 189         when(userAdminOperation.deActivateUser(userToDeactivate)).thenReturn(userToDeactivate);
 190         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 191         verify(userAdminOperation, times(1)).deActivateUser(userToDeactivate);
 192
 193         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 194     }
 195
 196     @Rule
 197     public ExpectedException thrown = ExpectedException.none();
 198
 199     @Test
 200     public void testDeActivateUserWithPendingTasks_FailToCheckIn_shouldFail() {
 201         User modifier = new User();
 202         modifier.setUserId(MOCK_MODIFIER);
 203         modifier.setRole(UserRoleEnum.ADMIN.getName());
 204         String userUniqueIdToDeactivate = "mockDU";
 205         User deacUser = new User();
 206         deacUser.setStatus(UserStatusEnum.ACTIVE);
 207         deacUser.setRole(UserRoleEnum.DESIGNER.name());
 208
 209         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 210         when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
 211         List<Component> components = new ArrayList<>();
 212         Component componentCheckedOut = createComponent(ID1, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 213         components.add(componentCheckedOut);
 214         when(userAdminOperation.getUserActiveComponents(any(), any())).thenReturn(components);
 215         when(lifecycleBusinessLogic.changeComponentState(any(), eq(ID1), eq(deacUser), eq(LifeCycleTransitionEnum.CHECKIN), any(), eq(false), eq(true)))
 216                 .thenReturn(Either.right(new ResponseFormat()));
 217         thrown.expect(ComponentException.class);
 218         thrown.expect(ComponentExceptionMatcher.hasStatus("SVC4569"));
 219         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 220
 221         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 222     }
 223
 224     @Test
 225     public void testDeActivateUserWithPendingTasks_FailToCertify_shouldFail() {
 226         User modifier = new User();
 227         modifier.setUserId(MOCK_MODIFIER);
 228         modifier.setRole(UserRoleEnum.ADMIN.getName());
 229         String userUniqueIdToDeactivate = "mockDU";
 230         User deacUser = new User();
 231         deacUser.setStatus(UserStatusEnum.ACTIVE);
 232         deacUser.setRole(UserRoleEnum.DESIGNER.name());
 233
 234         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 235         when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
 236         List<Component> components = new ArrayList<>();
 237         Component componentCheckedOut = createComponent(ID1, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 238         components.add(componentCheckedOut);
 239         when(userAdminOperation.getUserActiveComponents(any(), any())).thenReturn(components);
 240         when(lifecycleBusinessLogic.changeComponentState(any(), eq(ID1), eq(deacUser), eq(LifeCycleTransitionEnum.CHECKIN), any(), eq(false), eq(true)))
 241                 .thenReturn(Either.right(new ResponseFormat()));
 242         thrown.expect(ComponentException.class);
 243         thrown.expect(ComponentExceptionMatcher.hasStatus("SVC4569"));
 244         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 245
 246         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 247     }
 248
 249     private Resource createComponent(String id, LifecycleStateEnum state) {
 250         ComponentMetadataDefinition componentMetadataDefinition = new ResourceMetadataDefinition();
 251         Resource resource = new Resource(componentMetadataDefinition);
 252         resource.setUniqueId(id);
 253         resource.setName(id);
 254         resource.setLifecycleState(state);
 255         return resource;
 256     }
 257
 258     @Test(expected = StorageException.class)
 259     public void testDeActivateUserDeactivateFails() {
 260         User modifier = new User(MOCK_MODIFIER);
 261         modifier.setRole(UserRoleEnum.ADMIN.getName());
 262         String userUniqueIdToDeactivate = "mockDU";
 263         User deacUser = new User();
 264         deacUser.setStatus(UserStatusEnum.ACTIVE);
 265         deacUser.setRole(UserRoleEnum.DESIGNER.name());
 266
 267         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 268         when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
 269         when(userAdminOperation.deActivateUser(deacUser)).thenThrow(new StorageException(StorageOperationStatus.BAD_REQUEST));
 270         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 271
 272         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 273     }
 274
 275     @Test
 276     public void testDeActivateUser_noTasks_shouldSucceed() {
 277
 278         User modifier = new User(MOCK_MODIFIER);
 279         modifier.setRole(UserRoleEnum.ADMIN.getName());
 280         String userUniqueIdToDeactivate = "mockDU";
 281         User deacUser = new User(userUniqueIdToDeactivate);
 282         deacUser.setStatus(UserStatusEnum.ACTIVE);
 283         deacUser.setRole(UserRoleEnum.DESIGNER.name());
 284
 285         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 286         when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
 287         when(userAdminOperation.getUserActiveComponents(any(), any())).thenReturn(new LinkedList<>());
 288         when(userAdminOperation.deActivateUser(deacUser)).thenReturn(deacUser);
 289         User user = testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 290         assertThat(user.getUserId()).isEqualTo(userUniqueIdToDeactivate);
 291
 292         verify(facadeUserOperation).updateUserCache(UserOperationEnum.DEACTIVATE, deacUser.getUserId(), deacUser.getRole());
 293     }
 294
 295     @Test(expected = ComponentException.class)
 296     public void testDeActivateUser_AlreadyInactive()  {
 297         User modifier = new User(MOCK_MODIFIER);
 298         modifier.setRole(UserRoleEnum.ADMIN.getName());
 299         String userUniqueIdToDeactivate = "mockDU";
 300         User deacUser = new User();
 301         deacUser.setStatus(UserStatusEnum.INACTIVE);
 302
 303         when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
 304         when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
 305         testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
 306
 307         verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
 308     }
 309
 310
 311 }