catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/UserAdminOperationTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 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.model.operations.impl;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.mockito.Mockito.doAnswer;
  26 import static org.mockito.Mockito.mock;
  27 import static org.mockito.Mockito.times;
  28 import static org.mockito.Mockito.verify;
  29 import static org.mockito.Mockito.when;
  30
  31 import java.time.Instant;
  32 import java.util.ArrayList;
  33 import java.util.Iterator;
  34 import java.util.List;
  35
  36 import org.apache.tinkerpop.gremlin.structure.Direction;
  37 import org.apache.tinkerpop.gremlin.structure.Edge;
  38 import org.apache.tinkerpop.gremlin.structure.Graph;
  39 import org.apache.tinkerpop.gremlin.structure.Property;
  40 import org.apache.tinkerpop.gremlin.structure.Vertex;
  41 import org.junit.Before;
  42 import org.junit.BeforeClass;
  43 import org.junit.Test;
  44 import org.mockito.InjectMocks;
  45 import org.mockito.Mockito;
  46 import org.mockito.MockitoAnnotations;
  47 import org.mockito.invocation.InvocationOnMock;
  48 import org.mockito.stubbing.Answer;
  49 import org.openecomp.sdc.be.dao.api.ActionStatus;
  50 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  51 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  52 import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
  53 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  54 import org.openecomp.sdc.be.model.ModelTestBase;
  55 import org.openecomp.sdc.be.model.User;
  56 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  57 import org.openecomp.sdc.be.resources.data.UserData;
  58 import org.openecomp.sdc.common.api.UserRoleEnum;
  59
  60 import fj.data.Either;
  61
  62 public class UserAdminOperationTest extends ModelTestBase {
  63         private static final TitanGenericDao titanGenericDao = mock(TitanGenericDao.class);
  64         @InjectMocks
  65         private static final UserAdminOperation userAdminOperation = new UserAdminOperation(titanGenericDao);
  66         private static final String ADMIN = "admin";
  67
  68         @BeforeClass
  69         public static void setup() {
  70                 ModelTestBase.init();
  71         }
  72
  73         @Before
  74         public void initMocks() {
  75                 MockitoAnnotations.initMocks(this);
  76                 Mockito.reset(titanGenericDao);
  77                 mockTitanUpdate();
  78                 mockTitanDelete();
  79
  80         }
  81
  82         @Test
  83         public void testDeActivateUserDataSuccess() {
  84                 UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
  85
  86                 Either<User, StorageOperationStatus> eitherUser = userAdminOperation.deActivateUser(userAdminOperation.convertToUser(userData));
  87
  88                 verify(titanGenericDao, times(1)).updateNode(Mockito.eq(userData), Mockito.eq(UserData.class));
  89                 verify(titanGenericDao, times(0)).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
  90                 assertTrue(eitherUser.isLeft());
  91                 User user = eitherUser.left().value();
  92                 assertTrue(user.getStatus() == UserStatusEnum.INACTIVE);
  93         }
  94
  95         @Test
  96         public void testDeleteUserWithoutResources() {
  97                 UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
  98
  99                 List<Edge> edgesList = new ArrayList<Edge>();
 100
 101                 Either<List<Edge>, TitanOperationStatus> eitherResult = Either.left(edgesList);
 102                 when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
 103
 104                 Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
 105                 verify(titanGenericDao, times(0)).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
 106                 verify(titanGenericDao, times(1)).deleteNode(userData, UserData.class);
 107                 assertTrue(eitherUser.isLeft());
 108
 109         }
 110
 111         @Test
 112         public void testDeleteUserWithResources() {
 113                 UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
 114
 115                 List<Edge> edgesList = new ArrayList<Edge>();
 116                 edgesList.add(getEmptyEdgeImpl());
 117
 118                 Either<List<Edge>, TitanOperationStatus> eitherResult = Either.left(edgesList);
 119                 when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
 120
 121                 Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
 122                 verify(titanGenericDao, times(0)).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
 123                 verify(titanGenericDao, times(0)).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
 124                 assertTrue(eitherUser.isRight());
 125                 assertTrue(eitherUser.right().value() == ActionStatus.USER_HAS_ACTIVE_ELEMENTS);
 126
 127         }
 128
 129         private Edge getEmptyEdgeImpl() {
 130                 return new Edge() {
 131
 132                         @Override
 133                         public Object id() {
 134                                 // TODO Auto-generated method stub
 135                                 return null;
 136                         }
 137
 138                         @Override
 139                         public String label() {
 140                                 // TODO Auto-generated method stub
 141                                 return null;
 142                         }
 143
 144                         @Override
 145                         public Graph graph() {
 146                                 // TODO Auto-generated method stub
 147                                 return null;
 148                         }
 149
 150                         @Override
 151                         public <V> Property<V> property(String key, V value) {
 152                                 // TODO Auto-generated method stub
 153                                 return null;
 154                         }
 155
 156                         @Override
 157                         public void remove() {
 158                                 // TODO Auto-generated method stub
 159
 160                         }
 161
 162                         @Override
 163                         public Iterator<Vertex> vertices(Direction direction) {
 164                                 // TODO Auto-generated method stub
 165                                 return null;
 166                         }
 167
 168                         @Override
 169                         public <V> Iterator<Property<V>> properties(String... propertyKeys) {
 170                                 // TODO Auto-generated method stub
 171                                 return null;
 172                         }
 173
 174                 };
 175         }
 176
 177         private UserData mockTitanGet(String userId, UserRoleEnum role, boolean isActive) {
 178                 UserData userData = buildUserData(userId, role, isActive);
 179                 Either<UserData, TitanOperationStatus> eitherUserData = Either.left(userData);
 180                 when(titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class)).thenReturn(eitherUserData);
 181                 return userData;
 182         }
 183
 184         private static void mockTitanUpdate() {
 185                 doAnswer(new Answer<Either<UserData, TitanOperationStatus>>() {
 186                         public Either<UserData, TitanOperationStatus> answer(InvocationOnMock invocation) {
 187                                 Object[] args = invocation.getArguments();
 188                                 UserData retValue = (UserData) args[0];
 189                                 Either<UserData, TitanOperationStatus> result = Either.left(retValue);
 190                                 return result;
 191                         }
 192
 193                 }).when(titanGenericDao).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
 194         }
 195
 196         private static void mockTitanDelete() {
 197                 doAnswer(new Answer<Either<UserData, TitanOperationStatus>>() {
 198                         public Either<UserData, TitanOperationStatus> answer(InvocationOnMock invocation) {
 199                                 Object[] args = invocation.getArguments();
 200                                 UserData retValue = (UserData) args[0];
 201                                 Either<UserData, TitanOperationStatus> result = Either.left(retValue);
 202                                 return result;
 203                         }
 204
 205                 }).when(titanGenericDao).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
 206         }
 207
 208         private void assertUserEquals(UserData expected, User actual) {
 209                 assertEquals(expected.getEmail(), actual.getEmail());
 210                 assertEquals(expected.getFirstName(), actual.getFirstName());
 211                 assertEquals(expected.getLastName(), actual.getLastName());
 212                 assertEquals(expected.getRole(), actual.getRole());
 213                 assertEquals(expected.getStatus(), actual.getStatus().name());
 214                 assertEquals(expected.getUserId(), actual.getUserId());
 215
 216         }
 217
 218         private static UserData buildUserData(String userId, UserRoleEnum role, boolean isActive) {
 219                 UserData userData = new UserData();
 220                 userData.setUserId(userId);
 221                 userData.setRole(role.getName());
 222                 userData.setEmail("someEmail@somePlace.com");
 223                 userData.setFirstName("israel");
 224                 userData.setLastName("israeli");
 225                 userData.setLastLoginTime(Instant.MIN.getEpochSecond());
 226                 userData.setStatus(isActive ? UserStatusEnum.ACTIVE.name() : UserStatusEnum.INACTIVE.name());
 227                 return userData;
 228         }
 229 }