* 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.
package org.openecomp.sdc.be.model.operations.impl;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-import org.apache.tinkerpop.gremlin.structure.Direction;
-import org.apache.tinkerpop.gremlin.structure.Edge;
-import org.apache.tinkerpop.gremlin.structure.Graph;
-import org.apache.tinkerpop.gremlin.structure.Property;
-import org.apache.tinkerpop.gremlin.structure.Vertex;
+import com.thinkaurelius.titan.core.*;
+import com.thinkaurelius.titan.graphdb.relations.StandardVertexProperty;
+import com.thinkaurelius.titan.graphdb.types.system.EmptyVertex;
+import com.thinkaurelius.titan.graphdb.types.system.ImplicitKey;
+import fj.data.Either;
+import org.apache.tinkerpop.gremlin.structure.*;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.neo4j.GraphPropertiesDictionary;
import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.dao.utils.UserStatusEnum;
import org.openecomp.sdc.be.resources.data.UserData;
import org.openecomp.sdc.common.api.UserRoleEnum;
-import fj.data.Either;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
public class UserAdminOperationTest extends ModelTestBase {
- private static final TitanGenericDao titanGenericDao = mock(TitanGenericDao.class);
- @InjectMocks
- private static final UserAdminOperation userAdminOperation = new UserAdminOperation(titanGenericDao);
- private static final String ADMIN = "admin";
-
- @BeforeClass
- public static void setup() {
- ModelTestBase.init();
- }
-
- @Before
- public void initMocks() {
- MockitoAnnotations.initMocks(this);
- Mockito.reset(titanGenericDao);
- mockTitanUpdate();
- mockTitanDelete();
-
- }
-
- @Test
- public void testDeActivateUserDataSuccess() {
- UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
-
- Either<User, StorageOperationStatus> eitherUser = userAdminOperation.deActivateUser(userAdminOperation.convertToUser(userData));
-
- verify(titanGenericDao, times(1)).updateNode(Mockito.eq(userData), Mockito.eq(UserData.class));
- verify(titanGenericDao, times(0)).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
- assertTrue(eitherUser.isLeft());
- User user = eitherUser.left().value();
- assertTrue(user.getStatus() == UserStatusEnum.INACTIVE);
- }
-
- @Test
- public void testDeleteUserWithoutResources() {
- UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
-
- List<Edge> edgesList = new ArrayList<Edge>();
-
- Either<List<Edge>, TitanOperationStatus> eitherResult = Either.left(edgesList);
- when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
-
- Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
- verify(titanGenericDao, times(0)).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
- verify(titanGenericDao, times(1)).deleteNode(userData, UserData.class);
- assertTrue(eitherUser.isLeft());
-
- }
-
- @Test
- public void testDeleteUserWithResources() {
- UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
-
- List<Edge> edgesList = new ArrayList<Edge>();
- edgesList.add(getEmptyEdgeImpl());
-
- Either<List<Edge>, TitanOperationStatus> eitherResult = Either.left(edgesList);
- when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
-
- Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
- verify(titanGenericDao, times(0)).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
- verify(titanGenericDao, times(0)).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
- assertTrue(eitherUser.isRight());
- assertTrue(eitherUser.right().value() == ActionStatus.USER_HAS_ACTIVE_ELEMENTS);
-
- }
-
- private Edge getEmptyEdgeImpl() {
- return new Edge() {
-
- @Override
- public Object id() {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public String label() {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public Graph graph() {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public <V> Property<V> property(String key, V value) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public void remove() {
- // TODO Auto-generated method stub
-
- }
-
- @Override
- public Iterator<Vertex> vertices(Direction direction) {
- // TODO Auto-generated method stub
- return null;
- }
-
- @Override
- public <V> Iterator<Property<V>> properties(String... propertyKeys) {
- // TODO Auto-generated method stub
- return null;
- }
-
- };
- }
-
- private UserData mockTitanGet(String userId, UserRoleEnum role, boolean isActive) {
- UserData userData = buildUserData(userId, role, isActive);
- Either<UserData, TitanOperationStatus> eitherUserData = Either.left(userData);
- when(titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class)).thenReturn(eitherUserData);
- return userData;
- }
-
- private static void mockTitanUpdate() {
- doAnswer(new Answer<Either<UserData, TitanOperationStatus>>() {
- public Either<UserData, TitanOperationStatus> answer(InvocationOnMock invocation) {
- Object[] args = invocation.getArguments();
- UserData retValue = (UserData) args[0];
- Either<UserData, TitanOperationStatus> result = Either.left(retValue);
- return result;
- }
-
- }).when(titanGenericDao).updateNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
- }
-
- private static void mockTitanDelete() {
- doAnswer(new Answer<Either<UserData, TitanOperationStatus>>() {
- public Either<UserData, TitanOperationStatus> answer(InvocationOnMock invocation) {
- Object[] args = invocation.getArguments();
- UserData retValue = (UserData) args[0];
- Either<UserData, TitanOperationStatus> result = Either.left(retValue);
- return result;
- }
-
- }).when(titanGenericDao).deleteNode(Mockito.any(UserData.class), Mockito.eq(UserData.class));
- }
-
- private void assertUserEquals(UserData expected, User actual) {
- assertEquals(expected.getEmail(), actual.getEmail());
- assertEquals(expected.getFirstName(), actual.getFirstName());
- assertEquals(expected.getLastName(), actual.getLastName());
- assertEquals(expected.getRole(), actual.getRole());
- assertEquals(expected.getStatus(), actual.getStatus().name());
- assertEquals(expected.getUserId(), actual.getUserId());
-
- }
-
- private static UserData buildUserData(String userId, UserRoleEnum role, boolean isActive) {
- UserData userData = new UserData();
- userData.setUserId(userId);
- userData.setRole(role.getName());
- userData.setEmail("someEmail@somePlace.com");
- userData.setFirstName("israel");
- userData.setLastName("israeli");
- userData.setLastLoginTime(Instant.MIN.getEpochSecond());
- userData.setStatus(isActive ? UserStatusEnum.ACTIVE.name() : UserStatusEnum.INACTIVE.name());
- return userData;
- }
+ private static final TitanGenericDao titanGenericDao = mock(TitanGenericDao.class);
+ @InjectMocks
+ private static final UserAdminOperation userAdminOperation = new UserAdminOperation(titanGenericDao);
+ private static final String ADMIN = "admin";
+
+ @BeforeClass
+ public static void setup() {
+ ModelTestBase.init();
+ }
+
+ @Before
+ public void initMocks() {
+ MockitoAnnotations.initMocks(this);
+ Mockito.reset(titanGenericDao);
+ mockTitanUpdate();
+ mockTitanDelete();
+
+ }
+
+ @Test
+ public void testDeActivateUserDataSuccess() {
+ UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
+
+ Either<User, StorageOperationStatus> eitherUser = userAdminOperation.deActivateUser(userAdminOperation.convertToUser(userData));
+
+ verify(titanGenericDao, times(1)).updateNode(eq(userData), eq(UserData.class));
+ verify(titanGenericDao, times(0)).deleteNode(any(UserData.class), eq(UserData.class));
+ assertTrue(eitherUser.isLeft());
+ User user = eitherUser.left().value();
+ assertSame(user.getStatus(), UserStatusEnum.INACTIVE);
+ }
+
+ @Test
+ public void testDeleteUserWithoutResources() {
+ UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
+
+ List<Edge> edgesList = new ArrayList<>();
+
+ Either<List<Edge>, TitanOperationStatus> eitherResult = Either.left(edgesList);
+ when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
+
+ Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
+ verify(titanGenericDao, times(0)).updateNode(any(UserData.class), eq(UserData.class));
+ verify(titanGenericDao, times(1)).deleteNode(userData, UserData.class);
+ assertTrue(eitherUser.isLeft());
+
+ }
+
+ @Test
+ public void testDeleteUserWithResources() {
+ UserData userData = mockTitanGet(ADMIN, UserRoleEnum.ADMIN, true);
+
+ List<Edge> edgesList = new ArrayList<>();
+ edgesList.add(getEmptyEdgeImpl());
+
+ Either<List<Edge>, TitanOperationStatus> eitherResult = Either.left(edgesList);
+ when(titanGenericDao.getEdgesForNode(userData, Direction.BOTH)).thenReturn(eitherResult);
+
+ Either<User, ActionStatus> eitherUser = userAdminOperation.deleteUserData(ADMIN);
+ verify(titanGenericDao, times(0)).updateNode(any(UserData.class), eq(UserData.class));
+ verify(titanGenericDao, times(0)).deleteNode(any(UserData.class), eq(UserData.class));
+ assertTrue(eitherUser.isRight());
+ assertSame(eitherUser.right().value(), ActionStatus.USER_HAS_ACTIVE_ELEMENTS);
+
+ }
+
+ @Test
+ public void getUserPendingTasks_shouldReturnNonDeleted() {
+ String userId = "abc123";
+ String userKey = UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User);
+ User user = new User();
+ user.setUserId(userId);
+ TitanVertex userVertex = null;
+ TestVertex component1 = new TestVertex(null);
+ TestVertex component2 = new TestVertex(true);
+ TestVertex component3 = new TestVertex(false);
+ List<Edge> edges = new ArrayList<>();
+ Edge edge1 = new TestEdge(component1, "1");
+ Edge edge2 = new TestEdge(component2, "2");
+ Edge edge3 = new TestEdge(component3, "3");
+ edges.add(edge1);
+ edges.add(edge2);
+ edges.add(edge3);
+ when(titanGenericDao.getVertexByProperty(userKey, userId)).thenReturn(Either.left(userVertex));
+ when(titanGenericDao.getOutgoingEdgesByCriteria(any(), any(), any())).thenReturn(Either.left(edges));
+ Either<List<Edge>, StorageOperationStatus> result = userAdminOperation.getUserPendingTasksList(user, new HashMap<>());
+ assertThat(result.isLeft()).isTrue();
+ List<Edge> pendingTasks = result.left().value();
+ assertThat(pendingTasks.size()).isEqualTo(2);
+ assertThat(((TestEdge)pendingTasks.get(0)).getName()).isNotEqualTo("2");
+ assertThat(((TestEdge)pendingTasks.get(1)).getName()).isNotEqualTo("2");
+ }
+
+ private class TestVertex implements TitanVertex {
+
+ private final Boolean isDeleted;
+
+ private TestVertex(Boolean isDeleted) {
+ this.isDeleted = isDeleted;
+ }
+
+ @Override
+ public TitanEdge addEdge(String s, Vertex vertex, Object... objects) {
+ return null;
+ }
+
+ @Override
+ public <V> TitanVertexProperty<V> property(String s, V v, Object... objects) {
+ return null;
+ }
+
+ @Override
+ public <V> VertexProperty<V> property(String key) {
+ if (key.equals(GraphPropertiesDictionary.IS_DELETED.getProperty())) {
+ if (isDeleted==null)
+ return VertexProperty.empty();
+ return new StandardVertexProperty(1, ImplicitKey.ID, new EmptyVertex(), isDeleted, (byte)1);
+ }
+ return VertexProperty.empty();
+ }
+
+ @Override
+ public <V> TitanVertexProperty<V> property(VertexProperty.Cardinality cardinality, String s, V v, Object... objects) {
+ return null;
+ }
+
+ @Override
+ public Iterator<Edge> edges(Direction direction, String... strings) {
+ return null;
+ }
+
+ @Override
+ public Iterator<Vertex> vertices(Direction direction, String... strings) {
+ return null;
+ }
+
+ @Override
+ public Object id() {
+ return null;
+ }
+
+ @Override
+ public long longId() {
+ return 0;
+ }
+
+ @Override
+ public boolean hasId() {
+ return false;
+ }
+
+ @Override
+ public String label() {
+ return null;
+ }
+
+ @Override
+ public VertexLabel vertexLabel() {
+ return null;
+ }
+
+ @Override
+ public TitanVertexQuery<? extends TitanVertexQuery> query() {
+ return null;
+ }
+
+ @Override
+ public boolean isModified() {
+ return false;
+ }
+
+ @Override
+ public TitanTransaction graph() {
+ return null;
+ }
+
+ @Override
+ public void remove() {
+
+ }
+
+ @Override
+ public <V> V valueOrNull(PropertyKey propertyKey) {
+ return null;
+ }
+
+ @Override
+ public boolean isNew() {
+ return false;
+ }
+
+ @Override
+ public boolean isLoaded() {
+ return false;
+ }
+
+ @Override
+ public boolean isRemoved() {
+ return false;
+ }
+
+ @Override
+ public <V> Iterator<VertexProperty<V>> properties(String... strings) {
+ return null;
+ }
+ }
+
+ private class TestEdge implements Edge {
+
+ private final Vertex inVertx;
+ private final String name;
+
+ TestEdge(Vertex inVertx, String name) {
+ this.inVertx = inVertx;
+ this.name = name;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public Iterator<Vertex> vertices(Direction direction) {
+ return null;
+ }
+
+ @Override
+ public Vertex inVertex() {
+ return inVertx;
+ }
+
+ @Override
+ public Object id() {
+ return null;
+ }
+
+ @Override
+ public String label() {
+ return null;
+ }
+
+ @Override
+ public Graph graph() {
+ return null;
+ }
+
+ @Override
+ public <V> Property<V> property(String s, V v) {
+ return null;
+ }
+
+ @Override
+ public void remove() {
+
+ }
+
+ @Override
+ public <V> Iterator<Property<V>> properties(String... strings) {
+ return null;
+ }
+ }
+
+ private Edge getEmptyEdgeImpl() {
+ return new Edge() {
+
+ @Override
+ public Object id() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public String label() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public Graph graph() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <V> Property<V> property(String key, V value) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public void remove() {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ public Iterator<Vertex> vertices(Direction direction) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public <V> Iterator<Property<V>> properties(String... propertyKeys) {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ };
+ }
+
+ private UserData mockTitanGet(String userId, UserRoleEnum role, boolean isActive) {
+ UserData userData = buildUserData(userId, role, isActive);
+ Either<UserData, TitanOperationStatus> eitherUserData = Either.left(userData);
+ when(titanGenericDao.getNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class)).thenReturn(eitherUserData);
+ return userData;
+ }
+
+ private static void mockTitanUpdate() {
+ doAnswer((Answer<Either<UserData, TitanOperationStatus>>) invocation -> {
+ Object[] args = invocation.getArguments();
+ UserData retValue = (UserData) args[0];
+ return Either.left(retValue);
+ }).when(titanGenericDao).updateNode(any(UserData.class), eq(UserData.class));
+ }
+
+ private static void mockTitanDelete() {
+ doAnswer((Answer<Either<UserData, TitanOperationStatus>>) invocation -> {
+ Object[] args = invocation.getArguments();
+ UserData retValue = (UserData) args[0];
+ return Either.left(retValue);
+ }).when(titanGenericDao).deleteNode(any(UserData.class), eq(UserData.class));
+ }
+
+ private static UserData buildUserData(String userId, UserRoleEnum role, boolean isActive) {
+ UserData userData = new UserData();
+ userData.setUserId(userId);
+ userData.setRole(role.getName());
+ userData.setEmail("someEmail@somePlace.com");
+ userData.setFirstName("israel");
+ userData.setLastName("israeli");
+ userData.setLastLoginTime(Instant.MIN.getEpochSecond());
+ userData.setStatus(isActive ? UserStatusEnum.ACTIVE.name() : UserStatusEnum.INACTIVE.name());
+ return userData;
+ }
}
Code Review / sdc.git / blobdiff