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 org.janusgraph.core.*;
  24 import org.janusgraph.graphdb.relations.StandardVertexProperty;
  25 import org.janusgraph.graphdb.types.system.EmptyVertex;
  26 import org.janusgraph.graphdb.types.system.ImplicitKey;
  27 import fj.data.Either;
  28 import org.apache.tinkerpop.gremlin.structure.*;
  29 import org.junit.Before;
  30 import org.junit.BeforeClass;
  31 import org.junit.Test;
  32 import org.mockito.InjectMocks;
  33 import org.mockito.Mockito;
  34 import org.mockito.MockitoAnnotations;
  35 import org.mockito.stubbing.Answer;
  36 import org.openecomp.sdc.be.dao.api.ActionStatus;
  37 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  38 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  39 import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
  40 import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
  41 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  42 import org.openecomp.sdc.be.model.ModelTestBase;
  43 import org.openecomp.sdc.be.model.User;
  44 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  45 import org.openecomp.sdc.be.resources.data.UserData;
  46 import org.openecomp.sdc.common.api.UserRoleEnum;
  47
  48 import java.time.Instant;
  49 import java.util.ArrayList;
  50 import java.util.HashMap;
  51 import java.util.Iterator;
  52 import java.util.List;
  53
  54 import static org.assertj.core.api.Assertions.assertThat;
  55 import static org.junit.Assert.assertSame;
  56 import static org.junit.Assert.assertTrue;
  57 import static org.mockito.ArgumentMatchers.any;
  58 import static org.mockito.ArgumentMatchers.eq;
  59 import static org.mockito.Mockito.*;
  60
  61 public class UserAdminOperationTest extends ModelTestBase {
  62     private static final JanusGraphGenericDao JANUS_GRAPH_GENERIC_DAO = mock(JanusGraphGenericDao.class);
  63     @InjectMocks
  64     private static final UserAdminOperation userAdminOperation = new UserAdminOperation(
  65         JANUS_GRAPH_GENERIC_DAO);
  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(JANUS_GRAPH_GENERIC_DAO);
  77         mockJanusGraphUpdate();
  78         mockJanusGraphDelete();
  79
  80     }
  81
  82     @Test
  83     public void testDeActivateUserDataSuccess() {
  84         UserData userData = mockJanusGraphGet(ADMIN, UserRoleEnum.ADMIN, true);
  85
  86         Either<User, StorageOperationStatus> eitherUser = userAdminOperation.deActivateUser(userAdminOperation.convertToUser(userData));
  87
  88         verify(JANUS_GRAPH_GENERIC_DAO, times(1)).updateNode(eq(userData), eq(UserData.class));
  89         verify(JANUS_GRAPH_GENERIC_DAO, times(0)).deleteNode(any(UserData.class), eq(UserData.class));
  90         assertTrue(eitherUser.isLeft());
  91         User user = eitherUser.left().value();
  92         assertSame(user.getStatus(), UserStatusEnum.INACTIVE);
  93     }
  94
  95     @Test
  96     public void testDeleteUserWithoutResources() {
  97         UserData userData = mockJanusGraphGet(ADMIN, UserRoleEnum.ADMIN, true);
  98
  99         List<Edge> edgesList = new ArrayList<>();
 100
 101         Either<List<Edge>, JanusGraphOperationStatus> eitherResult = Either.left(edgesList);
 102         when(JANUS_GRAPH_GENERIC_DAO.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
 103
 104         Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
 105         verify(JANUS_GRAPH_GENERIC_DAO, times(0)).updateNode(any(UserData.class), eq(UserData.class));
 106         verify(JANUS_GRAPH_GENERIC_DAO, times(1)).deleteNode(userData, UserData.class);
 107         assertTrue(eitherUser.isLeft());
 108
 109     }
 110
 111     @Test
 112     public void testDeleteUserWithResources() {
 113         UserData userData = mockJanusGraphGet(ADMIN, UserRoleEnum.ADMIN, true);
 114
 115         List<Edge> edgesList = new ArrayList<>();
 116         edgesList.add(getEmptyEdgeImpl());
 117
 118         Either<List<Edge>, JanusGraphOperationStatus> eitherResult = Either.left(edgesList);
 119         when(JANUS_GRAPH_GENERIC_DAO.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
 120
 121         Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
 122         verify(JANUS_GRAPH_GENERIC_DAO, times(0)).updateNode(any(UserData.class), eq(UserData.class));
 123         verify(JANUS_GRAPH_GENERIC_DAO, times(0)).deleteNode(any(UserData.class), eq(UserData.class));
 124         assertTrue(eitherUser.isRight());
 125         assertSame(eitherUser.right().value(), ActionStatus.USER_HAS_ACTIVE_ELEMENTS);
 126
 127     }
 128
 129     @Test
 130     public void getUserPendingTasks_shouldReturnNonDeleted() {
 131         String userId = "abc123";
 132         String userKey = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User);
 133         User user = new User();
 134         user.setUserId(userId);
 135         JanusGraphVertex userVertex = null;
 136         TestVertex component1 = new TestVertex(null);
 137         TestVertex component2 = new TestVertex(true);
 138         TestVertex component3 = new TestVertex(false);
 139         List<Edge> edges = new ArrayList<>();
 140         Edge edge1 = new TestEdge(component1, "1");
 141         Edge edge2 = new TestEdge(component2, "2");
 142         Edge edge3 = new TestEdge(component3, "3");
 143         edges.add(edge1);
 144         edges.add(edge2);
 145         edges.add(edge3);
 146         when(JANUS_GRAPH_GENERIC_DAO.getVertexByProperty(userKey, userId)).thenReturn(Either.left(userVertex));
 147         when(JANUS_GRAPH_GENERIC_DAO.getOutgoingEdgesByCriteria(any(), any(), any())).thenReturn(Either.left(edges));
 148         Either<List<Edge>, StorageOperationStatus> result = userAdminOperation.getUserPendingTasksList(user, new HashMap<>());
 149         assertThat(result.isLeft()).isTrue();
 150         List<Edge> pendingTasks = result.left().value();
 151         assertThat(pendingTasks.size()).isEqualTo(2);
 152         assertThat(((TestEdge)pendingTasks.get(0)).getName()).isNotEqualTo("2");
 153         assertThat(((TestEdge)pendingTasks.get(1)).getName()).isNotEqualTo("2");
 154     }
 155
 156     private class TestVertex implements JanusGraphVertex {
 157
 158         private final Boolean isDeleted;
 159
 160         private TestVertex(Boolean isDeleted) {
 161             this.isDeleted = isDeleted;
 162         }
 163
 164         @Override
 165         public JanusGraphEdge addEdge(String s, Vertex vertex, Object... objects) {
 166             return null;
 167         }
 168
 169         @Override
 170         public <V> JanusGraphVertexProperty<V> property(String s, V v, Object... objects) {
 171             return null;
 172         }
 173
 174         @Override
 175         public <V> VertexProperty<V> property(String key) {
 176             if (key.equals(GraphPropertiesDictionary.IS_DELETED.getProperty())) {
 177                 if (isDeleted==null)
 178                     return VertexProperty.empty();
 179                 return new StandardVertexProperty(1, ImplicitKey.ID, new EmptyVertex(), isDeleted, (byte)1);
 180             }
 181             return VertexProperty.empty();
 182         }
 183
 184         @Override
 185         public <V> JanusGraphVertexProperty<V> property(VertexProperty.Cardinality cardinality, String s, V v, Object... objects) {
 186             return null;
 187         }
 188
 189         @Override
 190         public Iterator<Edge> edges(Direction direction, String... strings) {
 191             return null;
 192         }
 193
 194         @Override
 195         public Iterator<Vertex> vertices(Direction direction, String... strings) {
 196             return null;
 197         }
 198
 199         @Override
 200         public Object id() {
 201             return null;
 202         }
 203
 204         @Override
 205         public long longId() {
 206             return 0;
 207         }
 208
 209         @Override
 210         public boolean hasId() {
 211             return false;
 212         }
 213
 214         @Override
 215         public String label() {
 216             return null;
 217         }
 218
 219         @Override
 220         public VertexLabel vertexLabel() {
 221             return null;
 222         }
 223
 224         @Override
 225         public JanusGraphVertexQuery<? extends JanusGraphVertexQuery> query() {
 226             return null;
 227         }
 228
 229         @Override
 230         public boolean isModified() {
 231             return false;
 232         }
 233
 234         @Override
 235         public JanusGraphTransaction graph() {
 236             return null;
 237         }
 238
 239         @Override
 240         public void remove() {
 241
 242         }
 243
 244         @Override
 245         public <V> V valueOrNull(PropertyKey propertyKey) {
 246             return null;
 247         }
 248
 249         @Override
 250         public boolean isNew() {
 251             return false;
 252         }
 253
 254         @Override
 255         public boolean isLoaded() {
 256             return false;
 257         }
 258
 259         @Override
 260         public boolean isRemoved() {
 261             return false;
 262         }
 263
 264         @Override
 265         public <V> Iterator<VertexProperty<V>> properties(String... strings) {
 266             return null;
 267         }
 268     }
 269
 270     private class TestEdge implements Edge {
 271
 272         private final Vertex inVertx;
 273         private final String name;
 274
 275         TestEdge(Vertex inVertx, String name) {
 276             this.inVertx = inVertx;
 277             this.name = name;
 278         }
 279
 280         public String getName() {
 281             return name;
 282         }
 283
 284         @Override
 285         public Iterator<Vertex> vertices(Direction direction) {
 286             return null;
 287         }
 288
 289         @Override
 290         public Vertex inVertex() {
 291             return inVertx;
 292         }
 293
 294         @Override
 295         public Object id() {
 296             return null;
 297         }
 298
 299         @Override
 300         public String label() {
 301             return null;
 302         }
 303
 304         @Override
 305         public Graph graph() {
 306             return null;
 307         }
 308
 309         @Override
 310         public <V> Property<V> property(String s, V v) {
 311             return null;
 312         }
 313
 314         @Override
 315         public void remove() {
 316
 317         }
 318
 319         @Override
 320         public <V> Iterator<Property<V>> properties(String... strings) {
 321             return null;
 322         }
 323     }
 324
 325     private Edge getEmptyEdgeImpl() {
 326         return new Edge() {
 327
 328             @Override
 329             public Object id() {
 330                 // TODO Auto-generated method stub
 331                 return null;
 332             }
 333
 334             @Override
 335             public String label() {
 336                 // TODO Auto-generated method stub
 337                 return null;
 338             }
 339
 340             @Override
 341             public Graph graph() {
 342                 // TODO Auto-generated method stub
 343                 return null;
 344             }
 345
 346             @Override
 347             public <V> Property<V> property(String key, V value) {
 348                 // TODO Auto-generated method stub
 349                 return null;
 350             }
 351
 352             @Override
 353             public void remove() {
 354                 // TODO Auto-generated method stub
 355
 356             }
 357
 358             @Override
 359             public Iterator<Vertex> vertices(Direction direction) {
 360                 // TODO Auto-generated method stub
 361                 return null;
 362             }
 363
 364             @Override
 365             public <V> Iterator<Property<V>> properties(String... propertyKeys) {
 366                 // TODO Auto-generated method stub
 367                 return null;
 368             }
 369
 370         };
 371     }
 372
 373     private UserData mockJanusGraphGet(String userId, UserRoleEnum role, boolean isActive) {
 374         UserData userData = buildUserData(userId, role, isActive);
 375         Either<UserData, JanusGraphOperationStatus> eitherUserData = Either.left(userData);
 376         when(JANUS_GRAPH_GENERIC_DAO
 377             .getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class)).thenReturn(eitherUserData);
 378         return userData;
 379     }
 380
 381     private static void mockJanusGraphUpdate() {
 382         doAnswer((Answer<Either<UserData, JanusGraphOperationStatus>>) invocation -> {
 383             Object[] args = invocation.getArguments();
 384             UserData retValue = (UserData) args[0];
 385             return Either.left(retValue);
 386         }).when(JANUS_GRAPH_GENERIC_DAO).updateNode(any(UserData.class), eq(UserData.class));
 387     }
 388
 389     private static void mockJanusGraphDelete() {
 390         doAnswer((Answer<Either<UserData, JanusGraphOperationStatus>>) invocation -> {
 391             Object[] args = invocation.getArguments();
 392             UserData retValue = (UserData) args[0];
 393             return Either.left(retValue);
 394         }).when(JANUS_GRAPH_GENERIC_DAO).deleteNode(any(UserData.class), eq(UserData.class));
 395     }
 396
 397     private static UserData buildUserData(String userId, UserRoleEnum role, boolean isActive) {
 398         UserData userData = new UserData();
 399         userData.setUserId(userId);
 400         userData.setRole(role.getName());
 401         userData.setEmail("someEmail@somePlace.com");
 402         userData.setFirstName("israel");
 403         userData.setLastName("israeli");
 404         userData.setLastLoginTime(Instant.MIN.getEpochSecond());
 405         userData.setStatus(isActive ? UserStatusEnum.ACTIVE.name() : UserStatusEnum.INACTIVE.name());
 406         return userData;
 407     }
 408 }