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