aboutsummaryrefslogtreecommitdiffstats
path: root/catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicExtTest.java
diff options
context:
space:
mode:
Diffstat (limited to 'catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicExtTest.java')
-rw-r--r--catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicExtTest.java311
1 files changed, 311 insertions, 0 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicExtTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicExtTest.java
new file mode 100644
index 0000000000..2fbca05e26
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/user/UserBusinessLogicExtTest.java
@@ -0,0 +1,311 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * SDC
+ * ================================================================================
+ * Copyright (C) 2020 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.openecomp.sdc.be.user;
+
+
+import fj.data.Either;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.openecomp.sdc.be.auditing.impl.AuditingManager;
+import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
+import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic;
+import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
+import org.openecomp.sdc.be.exception.ComponentExceptionMatcher;
+import org.openecomp.sdc.be.facade.operations.UserOperation;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentMetadataDefinition;
+import org.openecomp.sdc.be.model.LifeCycleTransitionEnum;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.ResourceMetadataDefinition;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.operations.StorageException;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation;
+import org.openecomp.sdc.common.api.ConfigurationSource;
+import org.openecomp.sdc.common.api.UserRoleEnum;
+import org.openecomp.sdc.common.impl.ExternalConfiguration;
+import org.openecomp.sdc.common.impl.FSConfigurationSource;
+import org.openecomp.sdc.exception.ResponseFormat;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@RunWith(MockitoJUnitRunner.class)
+public class UserBusinessLogicExtTest {
+
+ private static final String MOCK_MODIFIER = "mockMod";
+ private static final String ID1 = "A";
+ private static final String ID2 = "B";
+ private UserBusinessLogicExt testSubject;
+
+ @Mock
+ private UserAdminOperation userAdminOperation;
+
+ @Mock
+ private LifecycleBusinessLogic lifecycleBusinessLogic;
+ @Mock
+ private static UserOperation facadeUserOperation;
+
+
+ @Before
+ public void setUp() {
+ // init Configuration
+ String appConfigDir = "src/test/resources/config/catalog-be";
+ ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(),
+ appConfigDir);
+ @SuppressWarnings("unused")
+ ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
+ ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
+ UserBusinessLogic userBusinessLogic = new UserBusinessLogic(userAdminOperation, componentsUtils, facadeUserOperation);
+ testSubject = new UserBusinessLogicExt(userBusinessLogic, userAdminOperation, lifecycleBusinessLogic,
+ componentsUtils);
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testDeActivateUserMissingID() {
+ testSubject.deActivateUser(null, "");
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testDeActivateUserModifierNotFound() {
+ String userUniqueIdToDeactivate = "";
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.right(ActionStatus.USER_NOT_FOUND));
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testDeActivateUserModNotAdmin() {
+ User modifier = new User(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.DESIGNER.getName());
+ String userUniqueIdToDeactivate = "";
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testDeActivateUserDeactivatedUserNotFound() {
+ User modifier = new User(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+ String userUniqueIdToDeactivate = "mockDU";
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.right(ActionStatus.USER_NOT_FOUND));
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testDeActivateUser_DeactivatedAndModifierAreSame() {
+ User modifier = new User(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ testSubject.deActivateUser(MOCK_MODIFIER, MOCK_MODIFIER);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Test(expected = StorageException.class)
+ public void testDeActivateUserFailToGetTasks() {
+ User modifier = new User(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+ String userUniqueIdToDeactivate = "mockDU";
+ User deacUser = new User();
+ deacUser.setStatus(UserStatusEnum.ACTIVE);
+ deacUser.setRole(UserRoleEnum.DESIGNER.name());
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
+ when(userAdminOperation.getUserActiveComponents(any(), any())).thenThrow(new StorageException(StorageOperationStatus.INCONSISTENCY));
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Test
+ public void testDeActivateUserWithPendingTasks_verifyActionsWereDone() {
+ User modifier = new User();
+ modifier.setUserId(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+ String userUniqueIdToDeactivate = "mockDU";
+ User userToDeactivate = new User();
+ userToDeactivate.setStatus(UserStatusEnum.ACTIVE);
+ userToDeactivate.setRole(UserRoleEnum.DESIGNER.name());
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(userToDeactivate));
+ List<Component> components = new ArrayList<>();
+ Resource componentCheckedOut = createComponent(ID1, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ components.add(componentCheckedOut);
+ when(userAdminOperation.getUserActiveComponents(any(), any())).thenReturn(components);
+ doReturn(Either.left(componentCheckedOut)).when(lifecycleBusinessLogic).changeComponentState(any(), eq(ID1), eq(userToDeactivate), eq(LifeCycleTransitionEnum.CHECKIN),
+ any(), eq(false), eq(true));
+ when(userAdminOperation.deActivateUser(userToDeactivate)).thenReturn(userToDeactivate);
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+ verify(userAdminOperation, times(1)).deActivateUser(userToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Test
+ public void testDeActivateUserWithPendingTasks_FailToCheckIn_shouldFail() {
+ User modifier = new User();
+ modifier.setUserId(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+ String userUniqueIdToDeactivate = "mockDU";
+ User deacUser = new User();
+ deacUser.setStatus(UserStatusEnum.ACTIVE);
+ deacUser.setRole(UserRoleEnum.DESIGNER.name());
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
+ List<Component> components = new ArrayList<>();
+ Component componentCheckedOut = createComponent(ID1, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ components.add(componentCheckedOut);
+ when(userAdminOperation.getUserActiveComponents(any(), any())).thenReturn(components);
+ when(lifecycleBusinessLogic.changeComponentState(any(), eq(ID1), eq(deacUser), eq(LifeCycleTransitionEnum.CHECKIN), any(), eq(false), eq(true)))
+ .thenReturn(Either.right(new ResponseFormat()));
+ thrown.expect(ComponentException.class);
+ thrown.expect(ComponentExceptionMatcher.hasStatus("SVC4569"));
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Test
+ public void testDeActivateUserWithPendingTasks_FailToCertify_shouldFail() {
+ User modifier = new User();
+ modifier.setUserId(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+ String userUniqueIdToDeactivate = "mockDU";
+ User deacUser = new User();
+ deacUser.setStatus(UserStatusEnum.ACTIVE);
+ deacUser.setRole(UserRoleEnum.DESIGNER.name());
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
+ List<Component> components = new ArrayList<>();
+ Component componentCheckedOut = createComponent(ID1, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
+ components.add(componentCheckedOut);
+ when(userAdminOperation.getUserActiveComponents(any(), any())).thenReturn(components);
+ when(lifecycleBusinessLogic.changeComponentState(any(), eq(ID1), eq(deacUser), eq(LifeCycleTransitionEnum.CHECKIN), any(), eq(false), eq(true)))
+ .thenReturn(Either.right(new ResponseFormat()));
+ thrown.expect(ComponentException.class);
+ thrown.expect(ComponentExceptionMatcher.hasStatus("SVC4569"));
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ private Resource createComponent(String id, LifecycleStateEnum state) {
+ ComponentMetadataDefinition componentMetadataDefinition = new ResourceMetadataDefinition();
+ Resource resource = new Resource(componentMetadataDefinition);
+ resource.setUniqueId(id);
+ resource.setName(id);
+ resource.setLifecycleState(state);
+ return resource;
+ }
+
+ @Test(expected = StorageException.class)
+ public void testDeActivateUserDeactivateFails() {
+ User modifier = new User(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+ String userUniqueIdToDeactivate = "mockDU";
+ User deacUser = new User();
+ deacUser.setStatus(UserStatusEnum.ACTIVE);
+ deacUser.setRole(UserRoleEnum.DESIGNER.name());
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
+ when(userAdminOperation.deActivateUser(deacUser)).thenThrow(new StorageException(StorageOperationStatus.BAD_REQUEST));
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+ @Test
+ public void testDeActivateUser_noTasks_shouldSucceed() {
+
+ User modifier = new User(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+ String userUniqueIdToDeactivate = "mockDU";
+ User deacUser = new User(userUniqueIdToDeactivate);
+ deacUser.setStatus(UserStatusEnum.ACTIVE);
+ deacUser.setRole(UserRoleEnum.DESIGNER.name());
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
+ when(userAdminOperation.getUserActiveComponents(any(), any())).thenReturn(new LinkedList<>());
+ when(userAdminOperation.deActivateUser(deacUser)).thenReturn(deacUser);
+ User user = testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+ assertThat(user.getUserId()).isEqualTo(userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation).updateUserCache(UserOperationEnum.DEACTIVATE, deacUser.getUserId(), deacUser.getRole());
+ }
+
+ @Test(expected = ComponentException.class)
+ public void testDeActivateUser_AlreadyInactive() {
+ User modifier = new User(MOCK_MODIFIER);
+ modifier.setRole(UserRoleEnum.ADMIN.getName());
+ String userUniqueIdToDeactivate = "mockDU";
+ User deacUser = new User();
+ deacUser.setStatus(UserStatusEnum.INACTIVE);
+
+ when(userAdminOperation.getUserData(MOCK_MODIFIER, false)).thenReturn(Either.left(modifier));
+ when(userAdminOperation.getUserData("mockDU", false)).thenReturn(Either.left(deacUser));
+ testSubject.deActivateUser(MOCK_MODIFIER, userUniqueIdToDeactivate);
+
+ verify(facadeUserOperation, never()).updateUserCache(any(UserOperationEnum.class), anyString(), anyString());
+ }
+
+
+} \ No newline at end of file