You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ranger.apache.org by pr...@apache.org on 2018/07/23 05:57:42 UTC
[1/2] ranger git commit: RANGER-2150: Unit test coverage for XUserMgr
and UserMgr class
Repository: ranger
Updated Branches:
refs/heads/master f368dcb38 -> 344992900
http://git-wip-us.apache.org/repos/asf/ranger/blob/34499290/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java b/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java
index 39c60a9..4f4298a 100644
--- a/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java
+++ b/security-admin/src/test/java/org/apache/ranger/biz/TestXUserMgr.java
@@ -6,7 +6,7 @@
* (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
+ * 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,
@@ -22,9 +22,15 @@ import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
+import java.util.Map;
import java.util.Set;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.WebApplicationException;
+
+import org.apache.ranger.common.AppConstants;
import org.apache.ranger.common.ContextUtil;
+import org.apache.ranger.common.MessageEnums;
import org.apache.ranger.common.RESTErrorUtil;
import org.apache.ranger.common.RangerCommonEnums;
import org.apache.ranger.common.RangerConstants;
@@ -43,46 +49,67 @@ import org.apache.ranger.db.XXPermMapDao;
import org.apache.ranger.db.XXPolicyDao;
import org.apache.ranger.db.XXPortalUserDao;
import org.apache.ranger.db.XXPortalUserRoleDao;
+import org.apache.ranger.db.XXResourceDao;
import org.apache.ranger.db.XXUserDao;
import org.apache.ranger.db.XXUserPermissionDao;
+import org.apache.ranger.entity.XXAuditMap;
import org.apache.ranger.entity.XXAuthSession;
import org.apache.ranger.entity.XXGroup;
import org.apache.ranger.entity.XXGroupGroup;
import org.apache.ranger.entity.XXGroupPermission;
import org.apache.ranger.entity.XXGroupUser;
import org.apache.ranger.entity.XXModuleDef;
+import org.apache.ranger.entity.XXPermMap;
import org.apache.ranger.entity.XXPolicy;
import org.apache.ranger.entity.XXPortalUser;
import org.apache.ranger.entity.XXPortalUserRole;
+import org.apache.ranger.entity.XXResource;
import org.apache.ranger.entity.XXUser;
import org.apache.ranger.entity.XXUserPermission;
+import org.apache.ranger.plugin.model.RangerPolicy;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemCondition;
+import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
import org.apache.ranger.security.context.RangerContextHolder;
import org.apache.ranger.security.context.RangerSecurityContext;
import org.apache.ranger.service.RangerPolicyService;
import org.apache.ranger.service.XAuditMapService;
+import org.apache.ranger.service.XGroupGroupService;
import org.apache.ranger.service.XGroupPermissionService;
import org.apache.ranger.service.XGroupService;
import org.apache.ranger.service.XGroupUserService;
import org.apache.ranger.service.XModuleDefService;
import org.apache.ranger.service.XPermMapService;
import org.apache.ranger.service.XPortalUserService;
+import org.apache.ranger.service.XResourceService;
+import org.apache.ranger.service.XUgsyncAuditInfoService;
import org.apache.ranger.service.XUserPermissionService;
import org.apache.ranger.service.XUserService;
+import org.apache.ranger.view.VXAuditMap;
import org.apache.ranger.view.VXAuditMapList;
import org.apache.ranger.view.VXGroup;
+import org.apache.ranger.view.VXGroupGroup;
import org.apache.ranger.view.VXGroupList;
import org.apache.ranger.view.VXGroupPermission;
import org.apache.ranger.view.VXGroupUser;
+import org.apache.ranger.view.VXGroupUserInfo;
import org.apache.ranger.view.VXGroupUserList;
+import org.apache.ranger.view.VXLong;
import org.apache.ranger.view.VXModuleDef;
+import org.apache.ranger.view.VXPermMap;
import org.apache.ranger.view.VXPermMapList;
import org.apache.ranger.view.VXPortalUser;
+import org.apache.ranger.view.VXResource;
+import org.apache.ranger.view.VXResponse;
import org.apache.ranger.view.VXStringList;
+import org.apache.ranger.view.VXUgsyncAuditInfo;
import org.apache.ranger.view.VXUser;
import org.apache.ranger.view.VXUserGroupInfo;
import org.apache.ranger.view.VXUserList;
import org.apache.ranger.view.VXUserPermission;
import org.apache.ranger.view.VXString;
+import org.junit.After;
import org.junit.Assert;
import org.junit.FixMethodOrder;
import org.junit.Rule;
@@ -100,6 +127,10 @@ import org.mockito.junit.MockitoJUnitRunner;
public class TestXUserMgr {
private static Long userId = 8L;
+ private static String adminLoginID = "admin";
+ private static String keyadminLoginID = "keyadmin";
+ private static String userLoginID = "testuser";
+ private static String groupName = "public";
private static Integer emptyValue;
@@ -165,6 +196,15 @@ public class TestXUserMgr {
@Mock
ServiceDBStore svcStore;
+
+ @Mock
+ XGroupGroupService xGroupGroupService;
+
+ @Mock
+ XResourceService xResourceService;
+
+ @Mock
+ XUgsyncAuditInfoService xUgsyncAuditInfoService;
@Rule
public ExpectedException thrown = ExpectedException.none();
@@ -172,39 +212,63 @@ public class TestXUserMgr {
RangerSecurityContext context = new RangerSecurityContext();
context.setUserSession(new UserSessionBase());
RangerContextHolder.setSecurityContext(context);
- UserSessionBase currentUserSession = ContextUtil
- .getCurrentUserSession();
+ UserSessionBase currentUserSession = ContextUtil.getCurrentUserSession();
currentUserSession.setUserAdmin(true);
- XXPortalUser gjUser = new XXPortalUser();
- gjUser.setLoginId("test");
- gjUser.setId(1L);
- currentUserSession.setXXPortalUser(gjUser);
+ XXPortalUser xXPortalUser = new XXPortalUser();
+ xXPortalUser.setLoginId(adminLoginID);
+ xXPortalUser.setId(userId);
+ currentUserSession.setXXPortalUser(xXPortalUser);
+ }
+
+ @After
+ public void destroySession() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(null);
+ RangerContextHolder.setSecurityContext(context);
}
private VXUser vxUser() {
Collection<String> userRoleList = new ArrayList<String>();
userRoleList.add("ROLE_USER");
Collection<String> groupNameList = new ArrayList<String>();
- groupNameList.add("Grp2");
+ groupNameList.add(groupName);
VXUser vxUser = new VXUser();
vxUser.setId(userId);
vxUser.setDescription("group test working");
- vxUser.setName("grouptest");
+ vxUser.setName(userLoginID);
vxUser.setUserRoleList(userRoleList);
vxUser.setGroupNameList(groupNameList);
- vxUser.setPassword("usertest123");
+ vxUser.setPassword("usertest123");
+ vxUser.setEmailAddress("test@test.com");
return vxUser;
}
- private VXModuleDef vXModuleDef() {
- VXUserPermission userPermission = vXUserPermission();
+ private XXUser xxUser(VXUser vxUser) {
+ XXUser xXUser = new XXUser();
+ xXUser.setId(userId);
+ xXUser.setName(vxUser.getName());
+ xXUser.setStatus(vxUser.getStatus());
+ xXUser.setIsVisible(vxUser.getIsVisible());
+ xXUser.setDescription(vxUser.getDescription());
+ return xXUser;
+ }
+
+ private VXGroup vxGroup() {
+ VXGroup vXGroup = new VXGroup();
+ vXGroup.setId(userId);
+ vXGroup.setDescription("group test working");
+ vXGroup.setName(groupName);
+ vXGroup.setIsVisible(1);
+ return vXGroup;
+ }
+
+ private VXModuleDef vxModuleDef() {
+ VXUserPermission userPermission = vxUserPermission();
List<VXUserPermission> userPermList = new ArrayList<VXUserPermission>();
userPermList.add(userPermission);
-
- VXGroupPermission groupPermission = vXGroupPermission();
+ VXGroupPermission groupPermission = vxGroupPermission();
List<VXGroupPermission> groupPermList = new ArrayList<VXGroupPermission>();
groupPermList.add(groupPermission);
-
VXModuleDef vxModuleDef = new VXModuleDef();
vxModuleDef.setAddedById(userId);
vxModuleDef.setCreateDate(new Date());
@@ -219,31 +283,28 @@ public class TestXUserMgr {
vxModuleDef.setUrl("/policy manager");
vxModuleDef.setUserPermList(userPermList);
vxModuleDef.setGroupPermList(groupPermList);
-
return vxModuleDef;
}
- private VXUserPermission vXUserPermission() {
+ private VXUserPermission vxUserPermission() {
VXUserPermission userPermission = new VXUserPermission();
userPermission.setId(1L);
userPermission.setIsAllowed(1);
userPermission.setModuleId(1L);
userPermission.setUserId(userId);
- userPermission.setUserName("xyz");
+ userPermission.setUserName(userLoginID);
userPermission.setOwner("admin");
-
return userPermission;
}
- private VXGroupPermission vXGroupPermission() {
+ private VXGroupPermission vxGroupPermission() {
VXGroupPermission groupPermission = new VXGroupPermission();
groupPermission.setId(1L);
groupPermission.setIsAllowed(1);
groupPermission.setModuleId(1L);
groupPermission.setGroupId(userId);
- groupPermission.setGroupName("xyz");
+ groupPermission.setGroupName(groupName);
groupPermission.setOwner("admin");
-
return groupPermission;
}
@@ -252,35 +313,272 @@ public class TestXUserMgr {
userProfile.setEmailAddress("test@test.com");
userProfile.setFirstName("user12");
userProfile.setLastName("test12");
- userProfile.setLoginId("134");
- userProfile.setPassword("usertest12323");
- userProfile.setUserSource(123);
- userProfile.setPublicScreenName("user");
+ userProfile.setLoginId(userLoginID);
+ userProfile.setPassword("usertest123");
+ userProfile.setUserSource(1);
+ userProfile.setPublicScreenName("testuser");
userProfile.setId(userId);
return userProfile;
}
+ private XXPortalUser xxPortalUser(VXPortalUser userProfile) {
+ XXPortalUser xxPortalUser = new XXPortalUser();
+ xxPortalUser.setEmailAddress(userProfile.getEmailAddress());
+ xxPortalUser.setFirstName(userProfile.getFirstName());
+ xxPortalUser.setLastName(userProfile.getLastName());
+ xxPortalUser.setLoginId(userProfile.getLoginId());
+ xxPortalUser.setPassword(userProfile.getPassword());
+ xxPortalUser.setUserSource(userProfile.getUserSource());
+ xxPortalUser.setPublicScreenName(userProfile.getPublicScreenName());
+ return xxPortalUser;
+ }
+
+ public void setupKeyAdmin() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil.getCurrentUserSession();
+ XXPortalUser userKeyAdmin = new XXPortalUser();
+ userKeyAdmin.setId(userProfile().getId());
+ userKeyAdmin.setLoginId(keyadminLoginID);
+ currentUserSession.setXXPortalUser(userKeyAdmin);
+ currentUserSession.setKeyAdmin(true);
+ }
+
+ private List<XXModuleDef> xxModuleDefs(){
+ List<XXModuleDef> xXModuleDefs=new ArrayList<XXModuleDef>();
+ XXModuleDef xXModuleDef1=xxModuleDef();
+ XXModuleDef xXModuleDef2=xxModuleDef();
+ XXModuleDef xXModuleDef3=xxModuleDef();
+ XXModuleDef xXModuleDef4=xxModuleDef();
+ XXModuleDef xXModuleDef5=xxModuleDef();
+ xXModuleDef1.setId(1L);
+ xXModuleDef1.setModule("Resource Based Policies");
+ xXModuleDef1.setId(2L);
+ xXModuleDef1.setModule("Users/Groups");
+ xXModuleDef1.setId(3L);
+ xXModuleDef1.setModule("Reports");
+ xXModuleDef1.setId(4L);
+ xXModuleDef1.setModule("Audit");
+ xXModuleDef1.setId(5L);
+ xXModuleDef1.setModule("Key Manager");
+ xXModuleDefs.add(xXModuleDef1);
+ xXModuleDefs.add(xXModuleDef2);
+ xXModuleDefs.add(xXModuleDef3);
+ xXModuleDefs.add(xXModuleDef4);
+ xXModuleDefs.add(xXModuleDef5);
+ return xXModuleDefs;
+ }
+
+ private VXGroupUser vxGroupUser(){
+ VXUser vXUser = vxUser();
+ VXGroupUser vxGroupUser = new VXGroupUser();
+ vxGroupUser.setId(userId);
+ vxGroupUser.setName(vXUser.getName());
+ vxGroupUser.setOwner("Admin");
+ vxGroupUser.setUserId(vXUser.getId());
+ vxGroupUser.setUpdatedBy("User");
+ vxGroupUser.setParentGroupId(userId);
+ return vxGroupUser;
+ }
+
+ private VXGroupGroup vxGroupGroup(){
+ VXGroupGroup vXGroupGroup = new VXGroupGroup();
+ vXGroupGroup.setId(userId);
+ vXGroupGroup.setName("group user test");
+ vXGroupGroup.setOwner("Admin");
+ vXGroupGroup.setUpdatedBy("User");
+ return vXGroupGroup;
+ }
+
+ private XXGroupGroup xxGroupGroup(){
+ XXGroupGroup xXGroupGroup = new XXGroupGroup();
+ xXGroupGroup.setId(userId);
+ xXGroupGroup.setName("group user test");
+ return xXGroupGroup;
+ }
+
+ private XXPolicy getXXPolicy() {
+ XXPolicy xxPolicy = new XXPolicy();
+ xxPolicy.setId(userId);
+ xxPolicy.setName("HDFS_1-1-20150316062453");
+ xxPolicy.setAddedByUserId(userId);
+ xxPolicy.setCreateTime(new Date());
+ xxPolicy.setDescription("test");
+ xxPolicy.setIsAuditEnabled(false);
+ xxPolicy.setIsEnabled(false);
+ xxPolicy.setService(1L);
+ xxPolicy.setUpdatedByUserId(userId);
+ xxPolicy.setUpdateTime(new Date());
+ return xxPolicy;
+ }
+
+ private VXGroupUserList vxGroupUserList(){
+ VXGroupUserList vxGroupUserList = new VXGroupUserList();
+ List<VXGroupUser> vXGroupUsers =new ArrayList<VXGroupUser>();
+ VXGroupUser vxGroupUser = vxGroupUser();
+ vXGroupUsers.add(vxGroupUser);
+ vxGroupUserList.setVXGroupUsers(vXGroupUsers);
+ return vxGroupUserList;
+ }
+
+ private ArrayList<String> getRoleList() {
+ ArrayList<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+ return userRoleList;
+ }
+
+ private SearchCriteria createsearchCriteria(){
+ SearchCriteria testsearchCriteria = new SearchCriteria();
+ testsearchCriteria.setStartIndex(0);
+ testsearchCriteria.setMaxRows(Integer.MAX_VALUE);
+ testsearchCriteria.setSortBy("id");
+ testsearchCriteria.setSortType("asc");
+ testsearchCriteria.setGetCount(true);
+ testsearchCriteria.setOwnerId(null);
+ testsearchCriteria.setGetChildren(false);
+ testsearchCriteria.setDistinct(false);
+ return testsearchCriteria;
+ }
+
+ private XXUserPermission xxUserPermission(){
+ XXUserPermission xUserPermissionObj = new XXUserPermission();
+ xUserPermissionObj.setAddedByUserId(userId);
+ xUserPermissionObj.setCreateTime(new Date());
+ xUserPermissionObj.setId(userId);
+ xUserPermissionObj.setIsAllowed(1);
+ xUserPermissionObj.setModuleId(1L);
+ xUserPermissionObj.setUpdatedByUserId(userId);
+ xUserPermissionObj.setUpdateTime(new Date());
+ xUserPermissionObj.setUserId(userId);
+ return xUserPermissionObj;
+ }
+
+ private XXGroupPermission xxGroupPermission(){
+ XXGroupPermission xGroupPermissionObj = new XXGroupPermission();
+ xGroupPermissionObj.setAddedByUserId(userId);
+ xGroupPermissionObj.setCreateTime(new Date());
+ xGroupPermissionObj.setId(userId);
+ xGroupPermissionObj.setIsAllowed(1);
+ xGroupPermissionObj.setModuleId(1L);
+ xGroupPermissionObj.setUpdatedByUserId(userId);
+ xGroupPermissionObj.setUpdateTime(new Date());
+ xGroupPermissionObj.setGroupId(userId);
+ return xGroupPermissionObj;
+ }
+
+ private XXModuleDef xxModuleDef(){
+ XXModuleDef xModuleDef = new XXModuleDef();
+ xModuleDef.setUpdatedByUserId(userId);
+ xModuleDef.setAddedByUserId(userId);
+ xModuleDef.setCreateTime(new Date());
+ xModuleDef.setId(userId);
+ xModuleDef.setModule("Policy manager");
+ xModuleDef.setUpdateTime(new Date());
+ xModuleDef.setUrl("/policy manager");
+ return xModuleDef;
+ }
+
+ private VXPermMap getVXPermMap(){
+ VXPermMap testVXPermMap= new VXPermMap();
+ testVXPermMap.setCreateDate(new Date());
+ testVXPermMap.setGroupId(userId);
+ testVXPermMap.setGroupName("testGroup");
+ testVXPermMap.setId(userId);
+ testVXPermMap.setOwner("Admin");
+ testVXPermMap.setPermGroup("testPermGroup");
+ testVXPermMap.setPermType(1);
+ testVXPermMap.setResourceId(userId);
+ testVXPermMap.setUpdateDate(new Date());
+ testVXPermMap.setUpdatedBy("Admin");
+ testVXPermMap.setUserId(userId);
+ testVXPermMap.setUserName("testUser");
+ testVXPermMap.setPermFor(1);
+ return testVXPermMap;
+ }
+
+ private VXAuditMap getVXAuditMap() {
+ VXAuditMap testVXAuditMap=new VXAuditMap();
+ testVXAuditMap.setAuditType(1);
+ testVXAuditMap.setCreateDate(new Date());
+ testVXAuditMap.setGroupId(userId);
+ testVXAuditMap.setId(userId);
+ testVXAuditMap.setResourceId(userId);
+ testVXAuditMap.setUpdateDate(new Date());
+ testVXAuditMap.setOwner("Admin");
+ testVXAuditMap.setUpdatedBy("Admin");
+ testVXAuditMap.setUserId(userId);
+ return testVXAuditMap;
+ }
+
+ private RangerPolicy rangerPolicy() {
+ List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();
+ List<String> users = new ArrayList<String>();
+ List<String> groups = new ArrayList<String>();
+ List<String> policyLabels = new ArrayList<String>();
+ List<RangerPolicyItemCondition> conditions = new ArrayList<RangerPolicyItemCondition>();
+ List<RangerPolicyItem> policyItems = new ArrayList<RangerPolicyItem>();
+ RangerPolicyItem rangerPolicyItem = new RangerPolicyItem();
+ rangerPolicyItem.setAccesses(accesses);
+ rangerPolicyItem.setConditions(conditions);
+ rangerPolicyItem.setGroups(groups);
+ rangerPolicyItem.setUsers(users);
+ rangerPolicyItem.setDelegateAdmin(false);
+
+ policyItems.add(rangerPolicyItem);
+
+ Map<String, RangerPolicyResource> policyResource = new HashMap<String, RangerPolicyResource>();
+ RangerPolicyResource rangerPolicyResource = new RangerPolicyResource();
+ rangerPolicyResource.setIsExcludes(true);
+ rangerPolicyResource.setIsRecursive(true);
+ rangerPolicyResource.setValue("1");
+ rangerPolicyResource.setValues(users);
+ RangerPolicy policy = new RangerPolicy();
+ policy.setId(userId);
+ policy.setCreateTime(new Date());
+ policy.setDescription("policy");
+ policy.setGuid("policyguid");
+ policy.setIsEnabled(true);
+ policy.setName("HDFS_1-1-20150316062453");
+ policy.setUpdatedBy("Admin");
+ policy.setUpdateTime(new Date());
+ policy.setService("HDFS_1-1-20150316062453");
+ policy.setIsAuditEnabled(true);
+ policy.setPolicyItems(policyItems);
+ policy.setResources(policyResource);
+ policy.setPolicyLabels(policyLabels);
+ return policy;
+ }
+
+ public void setupUser() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil.getCurrentUserSession();
+ XXPortalUser user = new XXPortalUser();
+ user.setId(userProfile().getId());
+ user.setLoginId(userProfile().getLoginId());
+ currentUserSession.setXXPortalUser(user);
+ }
+
@Test
- public void test11CreateXUser() {
+ public void test01CreateXUser() {
setup();
VXUser vxUser = vxUser();
- Collection<String> userRoleList = new ArrayList<String>();
- userRoleList.add("test");
- vxUser.setUserRoleList(userRoleList);
-
- ArrayList<String> userRoleListVXPortaUser = new ArrayList<String>();
-
+ vxUser.setFirstName("user12");
+ vxUser.setLastName("test12");
+ Collection<Long> groupIdList = new ArrayList<Long>();
+ groupIdList.add(userId);
+ vxUser.setGroupIdList(groupIdList);
+ VXGroup vxGroup = vxGroup();
+ Mockito.when(xGroupService.readResource(userId)).thenReturn(vxGroup);
+ ArrayList<String> userRoleListVXPortaUser = getRoleList();
VXPortalUser vXPortalUser = new VXPortalUser();
vXPortalUser.setUserRoleList(userRoleListVXPortaUser);
-
Mockito.when(xUserService.createResource(vxUser)).thenReturn(vxUser);
XXModuleDefDao value = Mockito.mock(XXModuleDefDao.class);
Mockito.when(daoManager.getXXModuleDef()).thenReturn(value);
-
- Mockito.when(
- userMgr.createDefaultAccountUser((VXPortalUser) Mockito
- .any())).thenReturn(vXPortalUser);
-
+ Mockito.when(userMgr.createDefaultAccountUser((VXPortalUser) Mockito.any())).thenReturn(vXPortalUser);
VXUser dbUser = xUserMgr.createXUser(vxUser);
Assert.assertNotNull(dbUser);
userId = dbUser.getId();
@@ -289,38 +587,112 @@ public class TestXUserMgr {
Assert.assertEquals(dbUser.getName(), vxUser.getName());
Assert.assertEquals(dbUser.getUserRoleList(), vxUser.getUserRoleList());
Assert.assertEquals(dbUser.getGroupNameList(),
- vxUser.getGroupNameList());
-
+ vxUser.getGroupNameList());
Mockito.verify(xUserService).createResource(vxUser);
-
- Mockito.when(xUserService.readResourceWithOutLogin(userId)).thenReturn(
- vxUser);
+ Mockito.when(xUserService.readResourceWithOutLogin(userId)).thenReturn(vxUser);
VXUser dbvxUser = xUserMgr.getXUser(userId);
-
- Mockito.verify(userMgr).createDefaultAccountUser(
- (VXPortalUser) Mockito.any());
+ Mockito.verify(userMgr).createDefaultAccountUser((VXPortalUser) Mockito.any());
Mockito.verify(daoManager).getXXModuleDef();
Assert.assertNotNull(dbvxUser);
Assert.assertEquals(userId, dbvxUser.getId());
Assert.assertEquals(dbvxUser.getDescription(), vxUser.getDescription());
Assert.assertEquals(dbvxUser.getName(), vxUser.getName());
- Assert.assertEquals(dbvxUser.getUserRoleList(),
- vxUser.getUserRoleList());
- Assert.assertEquals(dbvxUser.getGroupNameList(),
- vxUser.getGroupNameList());
+ Assert.assertEquals(dbvxUser.getUserRoleList(),vxUser.getUserRoleList());
+ Assert.assertEquals(dbvxUser.getGroupNameList(),vxUser.getGroupNameList());
Mockito.verify(xUserService).readResourceWithOutLogin(userId);
}
@Test
- public void test12UpdateXUser() {
+ public void test02CreateXUser_WithBlankName() {
setup();
VXUser vxUser = vxUser();
- vxUser.setUserSource(RangerCommonEnums.USER_APP);
- vxUser.setName("name");
- Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
+ ArrayList<String> userRoleListVXPortaUser = getRoleList();
VXPortalUser vXPortalUser = new VXPortalUser();
- Mockito.when(userMgr.getUserProfileByLoginId(vxUser.getName())).thenReturn(vXPortalUser);
+ vXPortalUser.setUserRoleList(userRoleListVXPortaUser);
+ vxUser.setName(null);
+ Mockito.when(restErrorUtil.createRESTException("Please provide a valid username.",MessageEnums.INVALID_INPUT_DATA)).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ VXUser vXUser=xUserMgr.createXUser(vxUser);
+ Assert.assertNull(vXUser);
+ }
+
+ @Test
+ public void test03CreateXUser_WithBlankName() {
+ destroySession();
+ setup();
+ VXUser vxUser = vxUser();
+ ArrayList<String> userRoleListVXPortaUser = getRoleList();
+ VXPortalUser vXPortalUser = new VXPortalUser();
+ vXPortalUser.setUserRoleList(userRoleListVXPortaUser);
+ vxUser.setName("");
+ Mockito.when(restErrorUtil.createRESTException("Please provide a valid username.",MessageEnums.INVALID_INPUT_DATA)).thenThrow(new WebApplicationException());
+ thrown.expect(WebApplicationException.class);
+ xUserMgr.createXUser(vxUser);
+ }
+
+ @Test
+ public void test04CreateXUser_WithBlankValues() {
+ setup();
+ VXUser vxUser = vxUser();
+ ArrayList<String> userRoleListVXPortaUser = getRoleList();
+ VXPortalUser vXPortalUser = new VXPortalUser();
+ vXPortalUser.setUserRoleList(userRoleListVXPortaUser);
+ vxUser.setDescription(null);
+ vxUser.setFirstName("null");
+ vxUser.setLastName("null");
+ Mockito.when(xUserService.createResource(vxUser)).thenReturn(vxUser);
+ xUserMgr.createXUser(vxUser);
+ }
+ @Test
+ public void test05UpdateXUser() {
+ setup();
+ XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
+ Collection<String> existingRoleList = new ArrayList<String>();
+ existingRoleList.add(RangerConstants.ROLE_USER);
+ Collection<String> reqRoleList = new ArrayList<String>();
+ reqRoleList.add(RangerConstants.ROLE_SYS_ADMIN);
+ Collection<Long> groupIdList = new ArrayList<Long>();
+ groupIdList.add(userId);
+ VXUser vxUser = vxUser();
+ vxUser.setUserRoleList(reqRoleList);
+ vxUser.setUserSource(RangerCommonEnums.USER_EXTERNAL);
+ vxUser.setGroupIdList(groupIdList);
+ vxUser.setFirstName("user12");
+ vxUser.setLastName("test12");
+ Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
+ XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ VXPortalUser vXPortalUser = userProfile();
+ vXPortalUser.setUserRoleList(existingRoleList);
+ Mockito.when(userMgr.getUserProfileByLoginId(vxUser.getName())).thenReturn(vXPortalUser);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermissionDao);
+ List<XXUserPermission> xUserPermissionsList = new ArrayList<XXUserPermission>();
+ XXUserPermission xUserPermissionObj = new XXUserPermission();
+ xUserPermissionObj.setAddedByUserId(userId);
+ xUserPermissionObj.setCreateTime(new Date());
+ xUserPermissionObj.setId(userId);
+ xUserPermissionObj.setIsAllowed(1);
+ xUserPermissionObj.setModuleId(1L);
+ xUserPermissionObj.setUpdatedByUserId(userId);
+ xUserPermissionObj.setUpdateTime(new Date());
+ xUserPermissionObj.setUserId(userId);
+ xUserPermissionsList.add(xUserPermissionObj);
+ List<XXModuleDef> xXModuleDefs = xxModuleDefs();
+ Mockito.when(xUserPermissionDao.findByUserPermissionId(vXPortalUser.getId())).thenReturn(xUserPermissionsList);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
+ Mockito.when(xModuleDefDao.getAll()).thenReturn(xXModuleDefs);
+ XXUser xXUser = xxUser(vxUser);
+ XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xxUserDao);
+ Mockito.when(xxUserDao.findByPortalUserId(vXPortalUser.getId())).thenReturn(xXUser);
+ VXGroupUserList vxGroupUserList = vxGroupUserList();
+ Mockito.when(xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito.any())).thenReturn(vxGroupUserList);
+ UserSessionBase userSession = Mockito.mock(UserSessionBase.class);
+ Set<UserSessionBase> userSessions = new HashSet<UserSessionBase>();
+ userSessions.add(userSession);
+ VXUserPermission vXUserPermission = vxUserPermission();
+ Mockito.when(xUserPermissionService.createResource((VXUserPermission) Mockito.any())).thenReturn(vXUserPermission);
+ Mockito.when(sessionMgr.getActiveUserSessionsForPortalUserId(userId)).thenReturn(userSessions);
VXUser dbvxUser = xUserMgr.updateXUser(vxUser);
Assert.assertNotNull(dbvxUser);
Assert.assertEquals(dbvxUser.getId(), vxUser.getId());
@@ -330,20 +702,18 @@ public class TestXUserMgr {
}
@Test
- public void test13ModifyUserVisibilitySetOne() {
+ public void test06ModifyUserVisibilitySetOne() {
+ setup();
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
HashMap<Long, Integer> visibilityMap = new HashMap<Long, Integer>();
Integer value = 1;
visibilityMap.put(userId, value);
-
Mockito.when(daoManager.getXXUser()).thenReturn(xxUserDao);
Mockito.when(xxUserDao.getById(userId)).thenReturn(xxUser);
Mockito.when(xUserService.populateViewBean(xxUser)).thenReturn(vxUser);
-
xUserMgr.modifyUserVisibility(visibilityMap);
Assert.assertEquals(value, vxUser.getIsVisible());
Assert.assertEquals(userId, vxUser.getId());
@@ -353,20 +723,18 @@ public class TestXUserMgr {
}
@Test
- public void test14ModifyUserVisibilitySetZero() {
+ public void test07ModifyUserVisibilitySetZero() {
+ setup();
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
HashMap<Long, Integer> visibilityMap = new HashMap<Long, Integer>();
Integer value = 0;
visibilityMap.put(userId, value);
-
Mockito.when(daoManager.getXXUser()).thenReturn(xxUserDao);
Mockito.when(xxUserDao.getById(userId)).thenReturn(xxUser);
Mockito.when(xUserService.populateViewBean(xxUser)).thenReturn(vxUser);
-
xUserMgr.modifyUserVisibility(visibilityMap);
Assert.assertEquals(value, vxUser.getIsVisible());
Assert.assertEquals(userId, vxUser.getId());
@@ -376,19 +744,17 @@ public class TestXUserMgr {
}
@Test
- public void test15ModifyUserVisibilitySetEmpty() {
+ public void test08ModifyUserVisibilitySetEmpty() {
+ setup();
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
Mockito.when(xUserService.updateResource(vxUser)).thenReturn(vxUser);
HashMap<Long, Integer> visibilityMap = new HashMap<Long, Integer>();
visibilityMap.put(userId, emptyValue);
-
Mockito.when(daoManager.getXXUser()).thenReturn(xxUserDao);
Mockito.when(xxUserDao.getById(userId)).thenReturn(xxUser);
Mockito.when(xUserService.populateViewBean(xxUser)).thenReturn(vxUser);
-
xUserMgr.modifyUserVisibility(visibilityMap);
Assert.assertEquals(emptyValue, vxUser.getIsVisible());
Assert.assertEquals(userId, vxUser.getId());
@@ -398,45 +764,32 @@ public class TestXUserMgr {
}
@Test
- public void test16CreateXGroup() {
+ public void test09CreateXGroup() {
setup();
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
-
+ VXGroup vXGroup = vxGroup();
+ vXGroup.setDescription(null);
Mockito.when(xGroupService.createResource(vXGroup)).thenReturn(vXGroup);
-
VXGroup dbXGroup = xUserMgr.createXGroup(vXGroup);
Assert.assertNotNull(dbXGroup);
userId = dbXGroup.getId();
Assert.assertEquals(userId, dbXGroup.getId());
- Assert.assertEquals(vXGroup.getDescription(), dbXGroup.getDescription());
Assert.assertEquals(vXGroup.getName(), dbXGroup.getName());
Mockito.verify(xGroupService).createResource(vXGroup);
-
- Mockito.when(xGroupService.readResourceWithOutLogin(userId))
- .thenReturn(vXGroup);
+ Mockito.when(xGroupService.readResourceWithOutLogin(userId)).thenReturn(vXGroup);
VXGroup dbxGroup = xUserMgr.getXGroup(userId);
Assert.assertNotNull(dbXGroup);
Assert.assertEquals(userId, dbxGroup.getId());
- Assert.assertEquals(dbXGroup.getDescription(),
- dbxGroup.getDescription());
Assert.assertEquals(dbXGroup.getName(), dbxGroup.getName());
Mockito.verify(xGroupService).readResourceWithOutLogin(userId);
}
@Test
- public void test17UpdateXGroup() {
+ public void test10UpdateXGroup() {
XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
XXGroupUserDao xxGroupUserDao = Mockito.mock(XXGroupUserDao.class);
List<XXGroupUser> grpUsers =new ArrayList<XXGroupUser>();
setup();
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
-
+ VXGroup vXGroup = vxGroup();
XXGroup xxGroup = new XXGroup();
Mockito.when(daoManager.getXXGroup()).thenReturn(xxGroupDao);
Mockito.when(xxGroupDao.getById(vXGroup.getId())).thenReturn(xxGroup);
@@ -447,8 +800,7 @@ public class TestXUserMgr {
Assert.assertNotNull(dbvxGroup);
userId = dbvxGroup.getId();
Assert.assertEquals(userId, dbvxGroup.getId());
- Assert.assertEquals(vXGroup.getDescription(),
- dbvxGroup.getDescription());
+ Assert.assertEquals(vXGroup.getDescription(),dbvxGroup.getDescription());
Assert.assertEquals(vXGroup.getName(), dbvxGroup.getName());
Mockito.verify(daoManager).getXXGroup();
Mockito.verify(daoManager).getXXGroupUser();
@@ -457,24 +809,18 @@ public class TestXUserMgr {
}
@Test
- public void test18ModifyGroupsVisibilitySetOne() {
+ public void test11ModifyGroupsVisibilitySetOne() {
+ setup();
XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
-
+ VXGroup vXGroup = vxGroup();
XXGroup xxGroup = new XXGroup();
HashMap<Long, Integer> groupVisibilityMap = new HashMap<Long, Integer>();
Integer value = 1;
groupVisibilityMap.put(userId, value);
-
Mockito.when(daoManager.getXXGroup()).thenReturn(xxGroupDao);
Mockito.when(xxGroupDao.getById(vXGroup.getId())).thenReturn(xxGroup);
- Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(
- vXGroup);
+ Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(vXGroup);
Mockito.when(xGroupService.updateResource(vXGroup)).thenReturn(vXGroup);
-
xUserMgr.modifyGroupsVisibility(groupVisibilityMap);
Assert.assertEquals(value, vXGroup.getIsVisible());
Assert.assertEquals(userId, vXGroup.getId());
@@ -484,24 +830,18 @@ public class TestXUserMgr {
}
@Test
- public void test19ModifyGroupsVisibilitySetZero() {
+ public void test12ModifyGroupsVisibilitySetZero() {
+ setup();
XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
-
+ VXGroup vXGroup = vxGroup();
XXGroup xxGroup = new XXGroup();
HashMap<Long, Integer> groupVisibilityMap = new HashMap<Long, Integer>();
Integer value = 0;
groupVisibilityMap.put(userId, value);
-
Mockito.when(daoManager.getXXGroup()).thenReturn(xxGroupDao);
Mockito.when(xxGroupDao.getById(vXGroup.getId())).thenReturn(xxGroup);
- Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(
- vXGroup);
+ Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(vXGroup);
Mockito.when(xGroupService.updateResource(vXGroup)).thenReturn(vXGroup);
-
xUserMgr.modifyGroupsVisibility(groupVisibilityMap);
Assert.assertEquals(value, vXGroup.getIsVisible());
Assert.assertEquals(userId, vXGroup.getId());
@@ -511,23 +851,17 @@ public class TestXUserMgr {
}
@Test
- public void test20ModifyGroupsVisibilitySetEmpty() {
+ public void test13ModifyGroupsVisibilitySetEmpty() {
+ setup();
XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
-
+ VXGroup vXGroup = vxGroup();
XXGroup xxGroup = new XXGroup();
HashMap<Long, Integer> groupVisibilityMap = new HashMap<Long, Integer>();
groupVisibilityMap.put(userId, emptyValue);
-
Mockito.when(daoManager.getXXGroup()).thenReturn(xxGroupDao);
Mockito.when(xxGroupDao.getById(vXGroup.getId())).thenReturn(xxGroup);
- Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(
- vXGroup);
+ Mockito.when(xGroupService.populateViewBean(xxGroup)).thenReturn(vXGroup);
Mockito.when(xGroupService.updateResource(vXGroup)).thenReturn(vXGroup);
-
xUserMgr.modifyGroupsVisibility(groupVisibilityMap);
Assert.assertEquals(emptyValue, vXGroup.getIsVisible());
Assert.assertEquals(userId, vXGroup.getId());
@@ -537,19 +871,10 @@ public class TestXUserMgr {
}
@Test
- public void test21createXGroupUser() {
+ public void test14createXGroupUser() {
setup();
- VXGroupUser vxGroupUser = new VXGroupUser();
- vxGroupUser.setId(userId);
- vxGroupUser.setName("group user test");
- vxGroupUser.setOwner("Admin");
- vxGroupUser.setUserId(userId);
- vxGroupUser.setUpdatedBy("User");
-
- Mockito.when(
- xGroupUserService.createXGroupUserWithOutLogin(vxGroupUser))
- .thenReturn(vxGroupUser);
-
+ VXGroupUser vxGroupUser = vxGroupUser();
+ Mockito.when(xGroupUserService.createXGroupUserWithOutLogin(vxGroupUser)).thenReturn(vxGroupUser);
VXGroupUser dbVXGroupUser = xUserMgr.createXGroupUser(vxGroupUser);
Assert.assertNotNull(dbVXGroupUser);
userId = dbVXGroupUser.getId();
@@ -557,18 +882,9 @@ public class TestXUserMgr {
Assert.assertEquals(dbVXGroupUser.getOwner(), vxGroupUser.getOwner());
Assert.assertEquals(dbVXGroupUser.getName(), vxGroupUser.getName());
Assert.assertEquals(dbVXGroupUser.getUserId(), vxGroupUser.getUserId());
- Assert.assertEquals(dbVXGroupUser.getUpdatedBy(),
- vxGroupUser.getUpdatedBy());
- Mockito.verify(xGroupUserService).createXGroupUserWithOutLogin(
- vxGroupUser);
-
- Mockito.when(xGroupUserService.readResourceWithOutLogin(userId))
- .thenReturn(vxGroupUser);
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
-
+ Assert.assertEquals(dbVXGroupUser.getUpdatedBy(),vxGroupUser.getUpdatedBy());
+ Mockito.verify(xGroupUserService).createXGroupUserWithOutLogin(vxGroupUser);
+ Mockito.when(xGroupUserService.readResourceWithOutLogin(userId)).thenReturn(vxGroupUser);
VXGroupUser dbvxGroupUser = xUserMgr.getXGroupUser(userId);
Assert.assertNotNull(dbvxGroupUser);
userId = dbvxGroupUser.getId();
@@ -576,57 +892,56 @@ public class TestXUserMgr {
Assert.assertEquals(dbvxGroupUser.getOwner(), vxGroupUser.getOwner());
Assert.assertEquals(dbvxGroupUser.getName(), vxGroupUser.getName());
Assert.assertEquals(dbvxGroupUser.getUserId(), vxGroupUser.getUserId());
- Assert.assertEquals(dbvxGroupUser.getUpdatedBy(),
- vxGroupUser.getUpdatedBy());
+ Assert.assertEquals(dbvxGroupUser.getUpdatedBy(),vxGroupUser.getUpdatedBy());
Mockito.verify(xGroupUserService).readResourceWithOutLogin(userId);
}
@Test
- public void test22GetXUserGroups() {
+ public void test15GetXUserGroups() {
+ List<VXGroup> vXGroupList = new ArrayList<VXGroup>();
+ final VXGroup vXGroup1 = vxGroup();
+ vXGroup1.setName("users");
+ vXGroup1.setDescription("users -added for unit testing");
+ vXGroupList.add(vXGroup1);
+ SearchCriteria testSearchCriteria = createsearchCriteria();
+ testSearchCriteria.addParam("xUserId", userId);
+ VXGroupUserList vxGroupUserList = vxGroupUserList();
+ Mockito.when(xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito.any())).thenReturn(vxGroupUserList);
VXGroupList dbVXGroupList = xUserMgr.getXUserGroups(userId);
Assert.assertNotNull(dbVXGroupList);
}
@Test
- public void test23GetXGroupUsers() {
- SearchCriteria testSearchCriteria = createsearchCriteria();
- testSearchCriteria.addParam("xGroupId", userId);
- VXUserList dbVXUserList = xUserMgr.getXGroupUsers(testSearchCriteria);
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
+ public void test16GetXGroupUsers() {
+ SearchCriteria testSearchCriteria = createsearchCriteria();
+ testSearchCriteria.addParam("xGroupId", userId);
+ VXGroupUserList vxGroupUserList = vxGroupUserList();
+ Mockito.when(xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito.any())).thenReturn(vxGroupUserList);
+ VXUserList dbVXUserList = xUserMgr.getXGroupUsers(testSearchCriteria);
Assert.assertNotNull(dbVXUserList);
}
@Test
- public void test24GetXUserByUserName() {
+ public void test17GetXUserByUserName() {
+ setupUser();
VXUser vxUser = vxUser();
- String userName = "test";
-
- Mockito.when(xUserService.getXUserByUserName(userName)).thenReturn(
- vxUser);
- XXModuleDefDao xxModuleDefDao = Mockito.mock(XXModuleDefDao.class);
- Mockito.when(daoManager.getXXModuleDef()).thenReturn(xxModuleDefDao);
-
- VXUser dbVXUser = xUserMgr.getXUserByUserName(userName);
+ Mockito.when(xUserService.getXUserByUserName(vxUser.getName())).thenReturn(vxUser);
+ XXModuleDefDao xxModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(xxModuleDefDao);
+ VXUser dbVXUser = xUserMgr.getXUserByUserName(vxUser.getName());
Assert.assertNotNull(dbVXUser);
userId = dbVXUser.getId();
Assert.assertEquals(userId, dbVXUser.getId());
Assert.assertEquals(dbVXUser.getName(), vxUser.getName());
Assert.assertEquals(dbVXUser.getOwner(), vxUser.getOwner());
- Mockito.verify(xUserService, Mockito.atLeast(2)).getXUserByUserName(
- userName);
+ Mockito.verify(xUserService, Mockito.atLeast(2)).getXUserByUserName(vxUser.getName());
}
@Test
- public void test25CreateXUserWithOutLogin() {
+ public void test18CreateXUserWithOutLogin() {
setup();
VXUser vxUser = vxUser();
-
- Mockito.when(xUserService.createXUserWithOutLogin(vxUser)).thenReturn(
- vxUser);
-
+ Mockito.when(xUserService.createXUserWithOutLogin(vxUser)).thenReturn(vxUser);
VXUser dbUser = xUserMgr.createXUserWithOutLogin(vxUser);
Assert.assertNotNull(dbUser);
userId = dbUser.getId();
@@ -634,130 +949,140 @@ public class TestXUserMgr {
Assert.assertEquals(dbUser.getDescription(), vxUser.getDescription());
Assert.assertEquals(dbUser.getName(), vxUser.getName());
Assert.assertEquals(dbUser.getUserRoleList(), vxUser.getUserRoleList());
- Assert.assertEquals(dbUser.getGroupNameList(),
- vxUser.getGroupNameList());
+ Assert.assertEquals(dbUser.getGroupNameList(),vxUser.getGroupNameList());
Mockito.verify(xUserService).createXUserWithOutLogin(vxUser);
}
@Test
- public void test26CreateXGroupWithoutLogin() {
+ public void test19CreateXGroupWithoutLogin() {
setup();
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
-
- Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup))
- .thenReturn(vXGroup);
-
+ VXGroup vXGroup = vxGroup();
+ Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup)).thenReturn(vXGroup);
VXGroup dbVXGroup = xUserMgr.createXGroupWithoutLogin(vXGroup);
Assert.assertNotNull(dbVXGroup);
userId = dbVXGroup.getId();
Assert.assertEquals(userId, dbVXGroup.getId());
- Assert.assertEquals(vXGroup.getDescription(),
- dbVXGroup.getDescription());
+ Assert.assertEquals(vXGroup.getDescription(),dbVXGroup.getDescription());
Assert.assertEquals(vXGroup.getName(), dbVXGroup.getName());
Mockito.verify(xGroupService).createXGroupWithOutLogin(vXGroup);
}
@Test
- public void test27DeleteXGroup() {
+ public void test20DeleteXGroup() {
setup();
boolean force = true;
- VXGroup vXGroup = new VXGroup();
- vXGroup.setId(userId);
- vXGroup.setDescription("group test");
- vXGroup.setName("grouptest");
- // XXGroup
+ VXGroup vXGroup = vxGroup();
XXGroupDao xXGroupDao = Mockito.mock(XXGroupDao.class);
+ XXUserDao xXUserDao = Mockito.mock(XXUserDao.class);
+ VXUser vxUser=vxUser();
+ XXUser xXUser = xxUser(vxUser);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xXUserDao);
+ Mockito.when(xXUserDao.getById(xXUser.getId())).thenReturn(xXUser);
XXGroup xXGroup = new XXGroup();
Mockito.when(daoManager.getXXGroup()).thenReturn(xXGroupDao);
Mockito.when(xXGroupDao.getById(vXGroup.getId())).thenReturn(xXGroup);
Mockito.when(xGroupService.populateViewBean(xXGroup)).thenReturn(vXGroup);
- // VXGroupUser
- VXGroupUserList vxGroupUserList = new VXGroupUserList();
+ VXGroupUserList vxGroupUserList = vxGroupUserList();
XXGroupUserDao xGroupUserDao = Mockito.mock(XXGroupUserDao.class);
- VXGroupUser vxGroupUser = new VXGroupUser();
- vxGroupUser.setId(userId);
- vxGroupUser.setName("group user test");
- vxGroupUser.setOwner("Admin");
- vxGroupUser.setUserId(userId);
- vxGroupUser.setUpdatedBy("User");
- Mockito.when(xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito.any()))
- .thenReturn(vxGroupUserList);
+ Mockito.when(xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito.any())).thenReturn(vxGroupUserList);
Mockito.when(daoManager.getXXGroupUser()).thenReturn(xGroupUserDao);
- // VXPermMap
VXPermMapList vXPermMapList = new VXPermMapList();
+ VXPermMap vXPermMap1=getVXPermMap();
+ List<VXPermMap> vXPermMaps=new ArrayList<VXPermMap>();
+ vXPermMaps.add(vXPermMap1);
+ vXPermMapList.setVXPermMaps(vXPermMaps);
XXPermMapDao xXPermMapDao = Mockito.mock(XXPermMapDao.class);
Mockito.when(xPermMapService.searchXPermMaps((SearchCriteria) Mockito.any())).thenReturn(vXPermMapList);
Mockito.when(daoManager.getXXPermMap()).thenReturn(xXPermMapDao);
- // VXAuditMap
VXAuditMapList vXAuditMapList = new VXAuditMapList();
+ List<VXAuditMap> vXAuditMaps=new ArrayList<VXAuditMap>();
+ VXAuditMap vXAuditMap=getVXAuditMap();
+ vXAuditMaps.add(vXAuditMap);
+ vXAuditMapList.setVXAuditMaps(vXAuditMaps);
XXAuditMapDao xXAuditMapDao = Mockito.mock(XXAuditMapDao.class);
- Mockito.when(xAuditMapService.searchXAuditMaps((SearchCriteria) Mockito.any()))
- .thenReturn(vXAuditMapList);
+ Mockito.when(xAuditMapService.searchXAuditMaps((SearchCriteria) Mockito.any())).thenReturn(vXAuditMapList);
Mockito.when(daoManager.getXXAuditMap()).thenReturn(xXAuditMapDao);
- //XXGroupGroup
XXGroupGroupDao xXGroupGroupDao = Mockito.mock(XXGroupGroupDao.class);
List<XXGroupGroup> xXGroupGroups = new ArrayList<XXGroupGroup>();
+ XXGroupGroup xXGroupGroup = xxGroupGroup();
+ xXGroupGroups.add(xXGroupGroup);
Mockito.when(daoManager.getXXGroupGroup()).thenReturn(xXGroupGroupDao);
Mockito.when(xXGroupGroupDao.findByGroupId(userId)).thenReturn(xXGroupGroups);
- //update XXGroupPermission
XXGroupPermissionDao xXGroupPermissionDao= Mockito.mock(XXGroupPermissionDao.class);
Mockito.when(daoManager.getXXGroupPermission()).thenReturn(xXGroupPermissionDao);
List<XXGroupPermission> xXGroupPermissions=new ArrayList<XXGroupPermission>();
+ XXGroupPermission xGroupPermissionObj = xxGroupPermission();
+ xXGroupPermissions.add(xGroupPermissionObj);
Mockito.when(xXGroupPermissionDao.findByGroupId(vXGroup.getId())).thenReturn(xXGroupPermissions);
- //update XXPolicyItemUserPerm
XXPolicyDao xXPolicyDao = Mockito.mock(XXPolicyDao.class);
List<XXPolicy> xXPolicyList = new ArrayList<XXPolicy>();
+ XXPolicy xXPolicy=getXXPolicy();
+ xXPolicyList.add(xXPolicy);
Mockito.when(daoManager.getXXPolicy()).thenReturn(xXPolicyDao);
Mockito.when(xXPolicyDao.findByGroupId(userId)).thenReturn(xXPolicyList);
+ List<XXResource> xResourceList = new ArrayList<XXResource>();
+ XXResource xXResource = new XXResource();
+ xXResource.setId(userId);
+ xXResource.setName("hadoopdev");
+ xXResource.setIsRecursive(AppConstants.BOOL_TRUE);
+ xXResource.setResourceStatus(AppConstants.STATUS_ENABLED);
+ xResourceList.add(xXResource);
+ XXResourceDao xxResourceDao = Mockito.mock(XXResourceDao.class);
+ Mockito.when(daoManager.getXXResource()).thenReturn(xxResourceDao);
+ Mockito.when(xxResourceDao.getById(Mockito.anyLong())).thenReturn(xXResource);
+ RangerPolicy rangerPolicy=rangerPolicy();
+ Mockito.when(policyService.getPopulatedViewObject(xXPolicy)).thenReturn(rangerPolicy);
+ XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
+ XXModuleDef xModuleDef=xxModuleDef();
+ Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong())).thenReturn(xModuleDef);
xUserMgr.deleteXGroup(vXGroup.getId(), force);
- Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito.any());
}
@Test
- public void test28DeleteXUser() {
+ public void test21DeleteXUser() {
setup();
boolean force = true;
VXUser vXUser = vxUser();
- // XXUser
XXUser xXUser = new XXUser();
XXUserDao xXUserDao = Mockito.mock(XXUserDao.class);
Mockito.when(daoManager.getXXUser()).thenReturn(xXUserDao);
Mockito.when(xXUserDao.getById(vXUser.getId())).thenReturn(xXUser);
Mockito.when(xUserService.populateViewBean(xXUser)).thenReturn(vXUser);
- // VXGroupUser
- VXGroupUserList vxGroupUserList = new VXGroupUserList();
+ VXGroupUserList vxGroupUserList=vxGroupUserList();
XXGroupUserDao xGroupUserDao = Mockito.mock(XXGroupUserDao.class);
- VXGroupUser vxGroupUser = new VXGroupUser();
- vxGroupUser.setId(userId);
- vxGroupUser.setName("group user test");
- vxGroupUser.setOwner("Admin");
- vxGroupUser.setUserId(vXUser.getId());
- vxGroupUser.setUpdatedBy("User");
- Mockito.when(xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito.any()))
- .thenReturn(vxGroupUserList);
+ Mockito.when(xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito.any())).thenReturn(vxGroupUserList);
Mockito.when(daoManager.getXXGroupUser()).thenReturn(xGroupUserDao);
- // VXPermMap
VXPermMapList vXPermMapList = new VXPermMapList();
+ VXPermMap vXPermMap1=getVXPermMap();
+ List<VXPermMap> vXPermMaps=new ArrayList<VXPermMap>();
+ vXPermMaps.add(vXPermMap1);
+ vXPermMapList.setVXPermMaps(vXPermMaps);
XXPermMapDao xXPermMapDao = Mockito.mock(XXPermMapDao.class);
Mockito.when(xPermMapService.searchXPermMaps((SearchCriteria) Mockito.any())).thenReturn(vXPermMapList);
Mockito.when(daoManager.getXXPermMap()).thenReturn(xXPermMapDao);
- // VXAuditMap
VXAuditMapList vXAuditMapList = new VXAuditMapList();
+ List<VXAuditMap> vXAuditMaps=new ArrayList<VXAuditMap>();
+ VXAuditMap vXAuditMap=getVXAuditMap();
+ vXAuditMaps.add(vXAuditMap);
+ vXAuditMapList.setVXAuditMaps(vXAuditMaps);
XXAuditMapDao xXAuditMapDao = Mockito.mock(XXAuditMapDao.class);
- Mockito.when(xAuditMapService.searchXAuditMaps((SearchCriteria) Mockito.any()))
- .thenReturn(vXAuditMapList);
+ Mockito.when(xAuditMapService.searchXAuditMaps((SearchCriteria) Mockito.any())).thenReturn(vXAuditMapList);
Mockito.when(daoManager.getXXAuditMap()).thenReturn(xXAuditMapDao);
- //XXPortalUser
VXPortalUser vXPortalUser = userProfile();
- XXPortalUser xXPortalUser = new XXPortalUser();
+ XXPortalUser xXPortalUser = xxPortalUser(vXPortalUser);
XXPortalUserDao xXPortalUserDao = Mockito.mock(XXPortalUserDao.class);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(xXPortalUserDao);
Mockito.when(xXPortalUserDao.findByLoginId(vXUser.getName().trim())).thenReturn(xXPortalUser);
Mockito.when(xPortalUserService.populateViewBean(xXPortalUser)).thenReturn(vXPortalUser);
-
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
+ XXModuleDef xModuleDef=xxModuleDef();
+ Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong())).thenReturn(xModuleDef);
XXAuthSessionDao xXAuthSessionDao= Mockito.mock(XXAuthSessionDao.class);
XXUserPermissionDao xXUserPermissionDao= Mockito.mock(XXUserPermissionDao.class);
XXPortalUserRoleDao xXPortalUserRoleDao= Mockito.mock(XXPortalUserRoleDao.class);
@@ -765,230 +1090,214 @@ public class TestXUserMgr {
Mockito.when(daoManager.getXXUserPermission()).thenReturn(xXUserPermissionDao);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(xXPortalUserRoleDao);
List<XXAuthSession> xXAuthSessions=new ArrayList<XXAuthSession>();
+ XXAuthSession xXAuthSession = new XXAuthSession();
+ xXAuthSession.setId(userId);
+ xXAuthSession.setLoginId(vXPortalUser.getLoginId());
+ xXAuthSessions.add(xXAuthSession);
List<XXUserPermission> xXUserPermissions=new ArrayList<XXUserPermission>();
+ xXUserPermissions.add(xxUserPermission());
List<XXPortalUserRole> xXPortalUserRoles=new ArrayList<XXPortalUserRole>();
+ xXPortalUserRoles.add(XXPortalUserRole);
Mockito.when(xXAuthSessionDao.getAuthSessionByUserId(vXPortalUser.getId())).thenReturn(xXAuthSessions);
Mockito.when(xXUserPermissionDao.findByUserPermissionId(vXPortalUser.getId())).thenReturn(xXUserPermissions);
Mockito.when(xXPortalUserRoleDao.findByUserId(vXPortalUser.getId())).thenReturn(xXPortalUserRoles);
- //update XXPolicyItemUserPerm
XXPolicyDao xXPolicyDao = Mockito.mock(XXPolicyDao.class);
List<XXPolicy> xXPolicyList = new ArrayList<XXPolicy>();
+ XXPolicy xXPolicy=getXXPolicy();
+ xXPolicyList.add(xXPolicy);
Mockito.when(daoManager.getXXPolicy()).thenReturn(xXPolicyDao);
Mockito.when(xXPolicyDao.findByUserId(vXUser.getId())).thenReturn(xXPolicyList);
+ RangerPolicy rangerPolicy=rangerPolicy();
+ Mockito.when(policyService.getPopulatedViewObject(xXPolicy)).thenReturn(rangerPolicy);
+ xUserMgr.deleteXUser(vXUser.getId(), force);
+ force=false;
xUserMgr.deleteXUser(vXUser.getId(), force);
- Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito.any());
}
@Test
- public void test29deleteXGroupAndXUser() {
+ public void test22DeleteXGroupAndXUser() {
setup();
VXUser vxUser = vxUser();
- VXGroup vxGroup = new VXGroup();
+ VXGroup vxGroup = vxGroup();
VXGroupUserList vxGroupUserList = new VXGroupUserList();
-
- String groupName = "Grp2";
- String userName = "test";
-
- Mockito.when(xGroupService.getGroupByGroupName(Mockito.anyString()))
- .thenReturn(vxGroup);
- Mockito.when(xUserService.getXUserByUserName(Mockito.anyString()))
- .thenReturn(vxUser);
- Mockito.when(
- xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito
- .any())).thenReturn(vxGroupUserList);
-
- xUserMgr.deleteXGroupAndXUser(groupName, userName);
+ List<VXGroupUser> vXGroupUsers = new ArrayList<VXGroupUser>();
+ VXGroupUser vxGroupUser = vxGroupUser();
+ vXGroupUsers.add(vxGroupUser);
+ vxGroupUserList.setVXGroupUsers(vXGroupUsers);
+ Mockito.when(xGroupService.getGroupByGroupName(Mockito.anyString())).thenReturn(vxGroup);
+ Mockito.when(xUserService.getXUserByUserName(Mockito.anyString())).thenReturn(vxUser);
+ Mockito.when(xGroupUserService.searchXGroupUsers((SearchCriteria) Mockito.any())).thenReturn(vxGroupUserList);
+ XXGroupUserDao xGrpUserDao = Mockito.mock(XXGroupUserDao.class);
+ Mockito.when(daoManager.getXXGroupUser()).thenReturn(xGrpUserDao);
+ Mockito.when(xGrpUserDao.remove(vxGroupUser.getId())).thenReturn(true);
+ xUserMgr.deleteXGroupAndXUser(groupName, userLoginID);
Mockito.verify(xGroupService).getGroupByGroupName(Mockito.anyString());
Mockito.verify(xUserService).getXUserByUserName(Mockito.anyString());
- Mockito.verify(xGroupUserService).searchXGroupUsers(
- (SearchCriteria) Mockito.any());
- }
-
- @Test
- public void test30CreateVXUserGroupInfo() {
- setup();
- VXUserGroupInfo vXUserGroupInfo = new VXUserGroupInfo();
- VXUser vXUser = new VXUser();
- vXUser.setName("user1");
- vXUser.setDescription("testuser1 -added for unit testing");
- vXUser.setPassword("usertest123");
- List<VXGroupUser> vXGroupUserList = new ArrayList<VXGroupUser>();
- List<VXGroup> vXGroupList = new ArrayList<VXGroup>();
-
- final VXGroup vXGroup1 = new VXGroup();
- vXGroup1.setName("users");
- vXGroup1.setDescription("users -added for unit testing");
- vXGroupList.add(vXGroup1);
-
- VXGroupUser vXGroupUser1 = new VXGroupUser();
- vXGroupUser1.setName("users");
- vXGroupUserList.add(vXGroupUser1);
-
- final VXGroup vXGroup2 = new VXGroup();
- vXGroup2.setName("user1");
- vXGroup2.setDescription("user1 -added for unit testing");
- vXGroupList.add(vXGroup2);
-
- VXGroupUser vXGroupUser2 = new VXGroupUser();
- vXGroupUser2.setName("user1");
- vXGroupUserList.add(vXGroupUser2);
-
- vXUserGroupInfo.setXuserInfo(vXUser);
- vXUserGroupInfo.setXgroupInfo(vXGroupList);
-
- Mockito.when(xUserService.createXUserWithOutLogin(vXUser)).thenReturn(vXUser);
- Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup1)).thenReturn(vXGroup1);
- Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup2)).thenReturn(vXGroup2);
-
- XXPortalUserDao portalUser = Mockito.mock(XXPortalUserDao.class);
- Mockito.when(daoManager.getXXPortalUser()).thenReturn(portalUser);
- XXPortalUser user = new XXPortalUser();
- user.setId(1L);
- user.setUserSource(RangerCommonEnums.USER_APP);
- Mockito.when(portalUser.findByLoginId(vXUser.getName())).thenReturn(user);
-
- XXPortalUserRoleDao userDao = Mockito.mock(XXPortalUserRoleDao.class);
- Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(userDao);
- List<String> lstRole = new ArrayList<String>();
- lstRole.add(RangerConstants.ROLE_SYS_ADMIN);
- Mockito.when(userDao.findXPortalUserRolebyXPortalUserId(Mockito.anyLong())).thenReturn(lstRole);
-
- VXUserGroupInfo vxUserGroupTest = xUserMgr.createXUserGroupFromMap(vXUserGroupInfo);
- Assert.assertEquals("user1", vxUserGroupTest.getXuserInfo().getName());
- List<VXGroup> result = vxUserGroupTest.getXgroupInfo();
- List<VXGroup> expected = new ArrayList<VXGroup>();
- expected.add(vXGroup1);
- expected.add(vXGroup2);
- Assert.assertTrue(result.containsAll(expected));
-// Mockito.verify(daoManager).getXXPortalUser();
- Mockito.verify(portalUser).findByLoginId(vXUser.getName());
- // Mockito.verify(daoManager).getXXPortalUserRole();
- Mockito.verify(userDao).findXPortalUserRolebyXPortalUserId(
- Mockito.anyLong());
-
- }
-
- // Module permission
- @Test
- public void test31createXModuleDefPermission() {
- VXModuleDef vXModuleDef = vXModuleDef();
-
- Mockito.when(xModuleDefService.createResource(vXModuleDef)).thenReturn(
- vXModuleDef);
- XXModuleDefDao obj = Mockito.mock(XXModuleDefDao.class);
- Mockito.when(daoManager.getXXModuleDef()).thenReturn(obj);
+ Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito.any());
+ }
- VXModuleDef dbMuduleDef = xUserMgr
- .createXModuleDefPermission(vXModuleDef);
- Assert.assertNotNull(dbMuduleDef);
- Assert.assertEquals(dbMuduleDef, vXModuleDef);
- Assert.assertEquals(dbMuduleDef.getId(), vXModuleDef.getId());
- Assert.assertEquals(dbMuduleDef.getOwner(), vXModuleDef.getOwner());
- Assert.assertEquals(dbMuduleDef.getUpdatedBy(),
- vXModuleDef.getUpdatedBy());
+ @Test
+ public void test23CreateVXUserGroupInfo() {
+ setup();
+ VXUserGroupInfo vXUserGroupInfo = new VXUserGroupInfo();
+ VXUser vXUser = vxUser();
+ List<VXGroupUser> vXGroupUserList = new ArrayList<VXGroupUser>();
+ List<VXGroup> vXGroupList = new ArrayList<VXGroup>();
+ final VXGroup vXGroup1 = vxGroup();
+ vXGroup1.setName("users");
+ vXGroup1.setDescription("users -added for unit testing");
+ vXGroupList.add(vXGroup1);
+ VXGroupUser vXGroupUser1 = vxGroupUser();
+ vXGroupUser1.setName("users");
+ vXGroupUserList.add(vXGroupUser1);
+ final VXGroup vXGroup2 = vxGroup();
+ vXGroup2.setName("user1");
+ vXGroup2.setDescription("user1 -added for unit testing");
+ vXGroupList.add(vXGroup2);
+ VXGroupUser vXGroupUser2 = vxGroupUser();
+ vXGroupUser2.setName("user1");
+ vXGroupUserList.add(vXGroupUser2);
+ vXUserGroupInfo.setXuserInfo(vXUser);
+ vXUserGroupInfo.setXgroupInfo(vXGroupList);
+ Mockito.when(xUserService.createXUserWithOutLogin(vXUser)).thenReturn(vXUser);
+ Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup1)).thenReturn(vXGroup1);
+ Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup2)).thenReturn(vXGroup2);
+ XXPortalUserDao portalUser = Mockito.mock(XXPortalUserDao.class);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(portalUser);
+ XXPortalUser user = new XXPortalUser();
+ user.setId(1L);
+ user.setUserSource(RangerCommonEnums.USER_EXTERNAL);
+ Mockito.when(portalUser.findByLoginId(vXUser.getName())).thenReturn(user);
+ XXPortalUserRoleDao userDao = Mockito.mock(XXPortalUserRoleDao.class);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(userDao);
+ List<String> existingRole = new ArrayList<String>();
+ existingRole.add(RangerConstants.ROLE_USER);
+ List<String> reqRoleList = new ArrayList<String>();
+ reqRoleList.add(RangerConstants.ROLE_SYS_ADMIN);
+ Mockito.when(userDao.findXPortalUserRolebyXPortalUserId(Mockito.anyLong())).thenReturn(reqRoleList);
+ VXPortalUser vXPortalUser = userProfile();
+ Mockito.when(userMgr.getUserProfileByLoginId(Mockito.anyString())).thenReturn(vXPortalUser);
+ Mockito.when(userMgr.updateRoleForExternalUsers(Mockito.any(), Mockito.any(), (VXPortalUser)Mockito.any())).thenReturn(vXPortalUser);
+ XXModuleDefDao xXModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ XXUserPermissionDao xXUserPermissionDao= Mockito.mock(XXUserPermissionDao.class);
+ XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+ vXPortalUser.setUserRoleList(userRoleList);
+ VXUser vxUser = vxUser();
+ XXUser xXUser = xxUser(vxUser);
+ List<XXModuleDef> xXModuleDefs = xxModuleDefs();
+ VXUserPermission userPermission = vxUserPermission();
+ List<VXUserPermission> userPermList = new ArrayList<VXUserPermission>();
+ userPermList.add(userPermission);
+ List<XXUserPermission> xUserPermissionsList = new ArrayList<XXUserPermission>();
+ XXUserPermission xUserPermissionObj = xxUserPermission();
+ xUserPermissionObj.setModuleId(userPermission.getModuleId());
+ xUserPermissionObj.setUserId(userPermission.getUserId());
+ xUserPermissionsList.add(xUserPermissionObj);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(xXModuleDefDao);
+ Mockito.when(xXModuleDefDao.getAll()).thenReturn(xXModuleDefs);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xXUserPermissionDao);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xxUserDao);
+ Mockito.when(xxUserDao.findByPortalUserId(vXPortalUser.getId())).thenReturn(xXUser);
+ UserSessionBase userSession = Mockito.mock(UserSessionBase.class);
+ Set<UserSessionBase> userSessions = new HashSet<UserSessionBase>();
+ userSessions.add(userSession);
+ Mockito.when(xUserPermissionService.createResource((VXUserPermission) Mockito.any())).thenReturn(userPermission);
+ Mockito.when(sessionMgr.getActiveUserSessionsForPortalUserId(userId)).thenReturn(userSessions);
+ VXUserGroupInfo vxUserGroupTest = xUserMgr.createXUserGroupFromMap(vXUserGroupInfo);
+ Assert.assertEquals(userLoginID, vxUserGroupTest.getXuserInfo().getName());
+ List<VXGroup> result = vxUserGroupTest.getXgroupInfo();
+ List<VXGroup> expected = new ArrayList<VXGroup>();
+ expected.add(vXGroup1);
+ expected.add(vXGroup2);
+ Assert.assertTrue(result.containsAll(expected));
+ Mockito.verify(portalUser).findByLoginId(vXUser.getName());
+ Mockito.verify(userDao).findXPortalUserRolebyXPortalUserId(
+ Mockito.anyLong());
+ }
+
+ @Test
+ public void test24createXModuleDefPermission() {
+ VXModuleDef vXModuleDef = vxModuleDef();
+ Mockito.when(xModuleDefService.createResource(vXModuleDef)).thenReturn(vXModuleDef);
+ XXModuleDefDao obj = Mockito.mock(XXModuleDefDao.class);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(obj);
+ VXModuleDef dbMuduleDef = xUserMgr.createXModuleDefPermission(vXModuleDef);
+ Assert.assertNotNull(dbMuduleDef);
+ Assert.assertEquals(dbMuduleDef, vXModuleDef);
+ Assert.assertEquals(dbMuduleDef.getId(), vXModuleDef.getId());
+ Assert.assertEquals(dbMuduleDef.getOwner(), vXModuleDef.getOwner());
+ Assert.assertEquals(dbMuduleDef.getUpdatedBy(),vXModuleDef.getUpdatedBy());
Assert.assertEquals(dbMuduleDef.getUrl(), vXModuleDef.getUrl());
- Assert.assertEquals(dbMuduleDef.getAddedById(),
- vXModuleDef.getAddedById());
- Assert.assertEquals(dbMuduleDef.getCreateDate(),
- vXModuleDef.getCreateDate());
- Assert.assertEquals(dbMuduleDef.getCreateTime(),
- vXModuleDef.getCreateTime());
- Assert.assertEquals(dbMuduleDef.getUserPermList(),
- vXModuleDef.getUserPermList());
- Assert.assertEquals(dbMuduleDef.getGroupPermList(),
- vXModuleDef.getGroupPermList());
+ Assert.assertEquals(dbMuduleDef.getAddedById(),vXModuleDef.getAddedById());
+ Assert.assertEquals(dbMuduleDef.getCreateDate(),vXModuleDef.getCreateDate());
+ Assert.assertEquals(dbMuduleDef.getCreateTime(),vXModuleDef.getCreateTime());
+ Assert.assertEquals(dbMuduleDef.getUserPermList(),vXModuleDef.getUserPermList());
+ Assert.assertEquals(dbMuduleDef.getGroupPermList(),vXModuleDef.getGroupPermList());
Mockito.verify(xModuleDefService).createResource(vXModuleDef);
}
@Test
- public void test32getXModuleDefPermission() {
- VXModuleDef vXModuleDef = vXModuleDef();
-
- Mockito.when(xModuleDefService.readResource(1L))
- .thenReturn(vXModuleDef);
-
+ public void test25getXModuleDefPermission() {
+ VXModuleDef vXModuleDef = vxModuleDef();
+ Mockito.when(xModuleDefService.readResource(1L)).thenReturn(vXModuleDef);
VXModuleDef dbMuduleDef = xUserMgr.getXModuleDefPermission(1L);
Assert.assertNotNull(dbMuduleDef);
Assert.assertEquals(dbMuduleDef, vXModuleDef);
Assert.assertEquals(dbMuduleDef.getId(), vXModuleDef.getId());
Assert.assertEquals(dbMuduleDef.getOwner(), vXModuleDef.getOwner());
- Assert.assertEquals(dbMuduleDef.getUpdatedBy(),
- vXModuleDef.getUpdatedBy());
+ Assert.assertEquals(dbMuduleDef.getUpdatedBy(),vXModuleDef.getUpdatedBy());
Assert.assertEquals(dbMuduleDef.getUrl(), vXModuleDef.getUrl());
- Assert.assertEquals(dbMuduleDef.getAddedById(),
- vXModuleDef.getAddedById());
- Assert.assertEquals(dbMuduleDef.getCreateDate(),
- vXModuleDef.getCreateDate());
- Assert.assertEquals(dbMuduleDef.getCreateTime(),
- vXModuleDef.getCreateTime());
- Assert.assertEquals(dbMuduleDef.getUserPermList(),
- vXModuleDef.getUserPermList());
- Assert.assertEquals(dbMuduleDef.getGroupPermList(),
- vXModuleDef.getGroupPermList());
-
+ Assert.assertEquals(dbMuduleDef.getAddedById(),vXModuleDef.getAddedById());
+ Assert.assertEquals(dbMuduleDef.getCreateDate(),vXModuleDef.getCreateDate());
+ Assert.assertEquals(dbMuduleDef.getCreateTime(),vXModuleDef.getCreateTime());
+ Assert.assertEquals(dbMuduleDef.getUserPermList(),vXModuleDef.getUserPermList());
+ Assert.assertEquals(dbMuduleDef.getGroupPermList(),vXModuleDef.getGroupPermList());
Mockito.verify(xModuleDefService).readResource(1L);
}
@Test
- public void test33updateXModuleDefPermission() {
+ public void test26updateXModuleDefPermission() {
XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
XXModuleDef xModuleDef = Mockito.mock(XXModuleDef.class);
-
- XXUserPermissionDao xUserPermissionDao = Mockito
- .mock(XXUserPermissionDao.class);
-
- XXGroupPermissionDao xGroupPermissionDao = Mockito
- .mock(XXGroupPermissionDao.class);
-
- VXUserPermission vXUserPermission = vXUserPermission();
- VXGroupPermission vXGroupPermission = vXGroupPermission();
- VXModuleDef vXModuleDef = vXModuleDef();
-
- Mockito.when(xModuleDefService.updateResource(vXModuleDef)).thenReturn(
- vXModuleDef);
-
+ XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito.mock(XXGroupPermissionDao.class);
+ VXModuleDef vXModuleDef = vxModuleDef();
+ Mockito.when(xModuleDefService.updateResource(vXModuleDef)).thenReturn(vXModuleDef);
Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
Mockito.when(xModuleDefDao.getById(userId)).thenReturn(xModuleDef);
- Mockito.when(xModuleDefService.populateViewBean(xModuleDef))
- .thenReturn(vXModuleDef);
-
- Mockito.when(daoManager.getXXUserPermission()).thenReturn(
- xUserPermissionDao);
-
- Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
- xGroupPermissionDao);
- XXGroupUserDao xGrpUserDao = Mockito.mock(XXGroupUserDao.class);
- Mockito.when(daoManager.getXXGroupUser()).thenReturn(xGrpUserDao);
-
+ Mockito.when(xModuleDefService.populateViewBean(xModuleDef)).thenReturn(vXModuleDef);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermissionDao);
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(xGroupPermissionDao);
+ List<XXGroupPermission> xXGroupPermissions=new ArrayList<XXGroupPermission>();
+ XXGroupPermission xGroupPermissionObj = xxGroupPermission();
+ xXGroupPermissions.add(xGroupPermissionObj);
+ VXGroupPermission groupPermission=vxGroupPermission();
+ Mockito.when(xGroupPermissionDao.findByModuleId(vXModuleDef.getId(),true)).thenReturn(xXGroupPermissions);
+ Mockito.when(xGroupPermissionService.populateViewBean(xGroupPermissionObj)).thenReturn(groupPermission);
+ List<XXUserPermission> xXUserPermissions=new ArrayList<XXUserPermission>();
+ XXUserPermission xUserPermissionObj=xxUserPermission();
+ xXUserPermissions.add(xUserPermissionObj);
+ VXUserPermission vxUserPermission=vxUserPermission();
+ Mockito.when(xUserPermissionDao.findByModuleId(vXModuleDef.getId(),true)).thenReturn(xXUserPermissions);
+ Mockito.when(xUserPermissionService.populateViewBean(xUserPermissionObj)).thenReturn(vxUserPermission);
UserSessionBase userSession = Mockito.mock(UserSessionBase.class);
Set<UserSessionBase> userSessions = new HashSet<UserSessionBase>();
userSessions.add(userSession);
-
- Mockito.when(xGroupPermissionService.createResource((VXGroupPermission) Mockito.any())).thenReturn(vXGroupPermission);
- Mockito.when(xUserPermissionService.createResource((VXUserPermission) Mockito.any())).thenReturn(vXUserPermission);
- Mockito.when(sessionMgr.getActiveUserSessionsForPortalUserId(userId)).thenReturn(userSessions);
-
- VXModuleDef dbMuduleDef = xUserMgr
- .updateXModuleDefPermission(vXModuleDef);
+ VXModuleDef dbMuduleDef = xUserMgr.updateXModuleDefPermission(vXModuleDef);
Assert.assertEquals(dbMuduleDef, vXModuleDef);
Assert.assertNotNull(dbMuduleDef);
Assert.assertEquals(dbMuduleDef, vXModuleDef);
Assert.assertEquals(dbMuduleDef.getId(), vXModuleDef.getId());
Assert.assertEquals(dbMuduleDef.getOwner(), vXModuleDef.getOwner());
- Assert.assertEquals(dbMuduleDef.getUpdatedBy(),
- vXModuleDef.getUpdatedBy());
+ Assert.assertEquals(dbMuduleDef.getUpdatedBy(),vXModuleDef.getUpdatedBy());
Assert.assertEquals(dbMuduleDef.getUrl(), vXModuleDef.getUrl());
- Assert.assertEquals(dbMuduleDef.getAddedById(),
- vXModuleDef.getAddedById());
- Assert.assertEquals(dbMuduleDef.getCreateDate(),
- vXModuleDef.getCreateDate());
- Assert.assertEquals(dbMuduleDef.getCreateTime(),
- vXModuleDef.getCreateTime());
- Assert.assertEquals(dbMuduleDef.getUserPermList(),
- vXModuleDef.getUserPermList());
- Assert.assertEquals(dbMuduleDef.getGroupPermList(),
- vXModuleDef.getGroupPermList());
-
+ Assert.assertEquals(dbMuduleDef.getAddedById(),vXModuleDef.getAddedById());
+ Assert.assertEquals(dbMuduleDef.getCreateDate(),vXModuleDef.getCreateDate());
+ Assert.assertEquals(dbMuduleDef.getCreateTime(),vXModuleDef.getCreateTime());
+ Assert.assertEquals(dbMuduleDef.getUserPermList(),vXModuleDef.getUserPermList());
+ Assert.assertEquals(dbMuduleDef.getGroupPermList(),vXModuleDef.getGroupPermList());
Mockito.verify(xModuleDefService).updateResource(vXModuleDef);
Mockito.verify(daoManager).getXXModuleDef();
Mockito.verify(xModuleDefService).populateViewBean(xModuleDef);
@@ -997,7 +1306,7 @@ public class TestXUserMgr {
}
@Test
- public void test34deleteXModuleDefPermission() {
+ public void test27deleteXModuleDefPermission() {
Long moduleId=Long.valueOf(1);
XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
XXGroupPermissionDao xGroupPermissionDao = Mockito.mock(XXGroupPermissionDao.class);
@@ -1011,668 +1320,1815 @@ public class TestXUserMgr {
}
@Test
- public void test35createXUserPermission() {
- VXUserPermission vXUserPermission = vXUserPermission();
-
- Mockito.when(xUserPermissionService.createResource(vXUserPermission))
- .thenReturn(vXUserPermission);
-
- VXUserPermission dbUserPermission = xUserMgr
- .createXUserPermission(vXUserPermission);
+ public void test28createXUserPermission() {
+ VXUserPermission vXUserPermission = vxUserPermission();
+ Mockito.when(xUserPermissionService.createResource(vXUserPermission)).thenReturn(vXUserPermission);
+ VXUserPermission dbUserPermission = xUserMgr.createXUserPermission(vXUserPermission);
Assert.assertNotNull(dbUserPermission);
Assert.assertEquals(dbUserPermission, vXUserPermission);
Assert.assertEquals(dbUserPermission.getId(), vXUserPermission.getId());
- Assert.assertEquals(dbUserPermission.getOwner(),
- vXUserPermission.getOwner());
- Assert.assertEquals(dbUserPermission.getUpdatedBy(),
- vXUserPermission.getUpdatedBy());
- Assert.assertEquals(dbUserPermission.getUserName(),
- vXUserPermission.getUserName());
- Assert.assertEquals(dbUserPermission.getCreateDate(),
- vXUserPermission.getCreateDate());
- Assert.assertEquals(dbUserPermission.getIsAllowed(),
- vXUserPermission.getIsAllowed());
- Assert.assertEquals(dbUserPermission.getModuleId(),
- vXUserPermission.getModuleId());
- Assert.assertEquals(dbUserPermission.getUpdateDate(),
- vXUserPermission.getUpdateDate());
- Assert.assertEquals(dbUserPermission.getUserId(),
- vXUserPermission.getUserId());
-
+ Assert.assertEquals(dbUserPermission.getOwner(),vXUserPermission.getOwner());
+ Assert.assertEquals(dbUserPermission.getUpdatedBy(),vXUserPermission.getUpdatedBy());
+ Assert.assertEquals(dbUserPermission.getUserName(),vXUserPermission.getUserName());
+ Assert.assertEquals(dbUserPermission.getCreateDate(),vXUserPermission.getCreateDate());
+ Assert.assertEquals(dbUserPermission.getIsAllowed(),vXUserPermission.getIsAllowed());
+ Assert.assertEquals(dbUserPermission.getModuleId(),vXUserPermission.getModuleId());
+ Assert.assertEquals(dbUserPermission.getUpdateDate(),vXUserPermission.getUpdateDate());
+ Assert.assertEquals(dbUserPermission.getUserId(),vXUserPermission.getUserId());
Mockito.verify(xUserPermissionService).createResource(vXUserPermission);
}
@Test
- public void test36getXUserPermission() {
- VXUserPermission vXUserPermission = vXUserPermission();
-
- Mockito.when(xUserPermissionService.readResource(1L)).thenReturn(
- vXUserPermission);
-
+ public void test29getXUserPermission() {
+ VXUserPermission vXUserPermission = vxUserPermission();
+ Mockito.when(xUserPermissionService.readResource(1L)).thenReturn(vXUserPermission);
VXUserPermission dbUserPermission = xUserMgr.getXUserPermission(1L);
Assert.assertNotNull(dbUserPermission);
Assert.assertEquals(dbUserPermission, vXUserPermission);
Assert.assertEquals(dbUserPermission.getId(), vXUserPermission.getId());
- Assert.assertEquals(dbUserPermission.getOwner(),
- vXUserPermission.getOwner());
- Assert.assertEquals(dbUserPermission.getUpdatedBy(),
- vXUserPermission.getUpdatedBy());
- Assert.assertEquals(dbUserPermission.getUserName(),
- vXUserPermission.getUserName());
- Assert.assertEquals(dbUserPermission.getCreateDate(),
- vXUserPermission.getCreateDate());
- Assert.assertEquals(dbUserPermission.getIsAllowed(),
- vXUserPermission.getIsAllowed());
- Assert.assertEquals(dbUserPermission.getModuleId(),
- vXUserPermission.getModuleId());
- Assert.assertEquals(dbUserPermission.getUpdateDate(),
- vXUserPermission.getUpdateDate());
- Assert.assertEquals(dbUserPermission.getUserId(),
- vXUserPermission.getUserId());
-
+ Assert.assertEquals(dbUserPermission.getOwner(),vXUserPermission.getOwner());
+ Assert.assertEquals(dbUserPermission.getUpdatedBy(),vXUserPermission.getUpdatedBy());
+ Assert.assertEquals(dbUserPermission.getUserName(),vXUserPermission.getUserName());
+ Assert.assertEquals(dbUserPermission.getCreateDate(),vXUserPermission.getCreateDate());
+ Assert.assertEquals(dbUserPermission.getIsAllowed(),vXUserPermission.getIsAllowed());
+ Assert.assertEquals(dbUserPermission.getModuleId(),vXUserPermission.getModuleId());
+ Assert.assertEquals(dbUserPermission.getUpdateDate(),vXUserPermission.getUpdateDate());
+ Assert.assertEquals(dbUserPermission.getUserId(),vXUserPermission.getUserId());
Mockito.verify(xUserPermissionService).readResource(1L);
}
@Test
- public void test37updateXUserPermission() {
- VXUserPermission vXUserPermission = vXUserPermission();
-
- Mockito.when(xUserPermissionService.updateResource(vXUserPermission))
- .thenReturn(vXUserPermission);
-
- VXUserPermission dbUserPermission = xUserMgr
- .updateXUserPermission(vXUserPermission);
+ public void test30updateXUserPermission() {
+ VXUserPermission vXUserPermission = vxUserPermission();
+ Mockito.when(xUserPermissionService.updateResource(vXUserPermission)).thenReturn(vXUserPermission);
+ VXUserPermission dbUserPermission = xUserMgr.updateXUserPermission(vXUserPermission);
Assert.assertNotNull(dbUserPermission);
Assert.assertEquals(dbUserPermission, vXUserPermission);
Assert.assertEquals(dbUserPermission.getId(), vXUserPermission.getId());
- Assert.assertEquals(dbUserPermission.getOwner(),
- vXUserPermission.getOwner());
- Assert.assertEquals(dbUserPermission.getUpdatedBy(),
- vXUserPermission.getUpdatedBy());
- Assert.assertEquals(dbUserPermission.getUserName(),
- vXUserPermission.getUserName());
- Assert.assertEquals(dbUserPermission.getCreateDate(),
- vXUserPermission.getCreateDate());
- Assert.assertEquals(dbUserPermission.getIsAllowed(),
- vXUserPermission.getIsAllowed());
- Assert.assertEquals(dbUserPermission.getModuleId(),
- vXUserPermission.getModuleId());
- Assert.assertEquals(dbUserPermission.getUpdateDate(),
- vXUserPermission.getUpdateDate());
- Assert.assertEquals(dbUserPermission.getUserId(),
- vXUserPermission.getUserId());
-
+ Assert.assertEquals(dbUserPermission.getOwner(),vXUserPermission.getOwner());
+ Assert.assertEquals(dbUserPermission.getUpdatedBy(),vXUserPermission.getUpdatedBy());
+ Assert.assertEquals(dbUserPermission.getUserName(),vXUserPermission.getUserName());
+ Assert.assertEquals(dbUserPermission.getCreateDate(),vXUserPermission.getCreateDate());
+ Assert.assertEquals(dbUserPermission.getIsAllowed(),vXUserPermission.getIsAllowed());
+ Assert.assertEquals(dbUserPermission.getModuleId(),vXUserPermission.getModuleId());
+ Assert.assertEquals(dbUserPermission.getUpdateDate(),vXUserPermission.getUpdateDate());
+ Assert.assertEquals(dbUserPermission.getUserId(),vXUserPermission.getUserId());
Mockito.verify(xUserPermissionService).updateResource(vXUserPermission);
}
@Test
- public void test38deleteXUserPermission() {
-
- Mockito.when(xUserPermissionService.deleteResource(1L))
- .thenReturn(true);
- XXUserPermission xUserPerm = Mockito.mock(XXUserPermission.class);
+ public void test31deleteXUserPermission() {
+ UserSessionBase userSession = Mockito.mock(UserSessionBase.class);
+ Set<UserSessionBase> userSessions = new HashSet<UserSessionBase>();
+ userSessions.add(userSession);
+ XXUserPermission xUserPermissionObj = xxUserPermission();
XXUserPermissionDao xUserPermDao = Mockito.mock(XXUserPermissionDao.class);
Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermDao);
- Mockito.when(daoManager.getXXUserPermission().getById(1L)).thenReturn(xUserPerm);
+ Mockito.when(xUserPermDao.getById(1L)).thenReturn(xUserPermissionObj);
+ Mockito.when(xUserPermissionService.deleteResource(1L)).thenReturn(true);
+ Mockito.when(sessionMgr.getActiveUserSessionsForPortalUserId(xUserPermissionObj.getUserId())).thenReturn(userSessions);
xUserMgr.deleteXUserPermission(1L, true);
Mockito.verify(xUserPermissionService).deleteResource(1L);
}
@Test
- public void test39createXGroupPermission() {
- VXGroupPermission vXGroupPermission = vXGroupPermission();
-
+ public void test32createXGroupPermission() {
+ VXGroupPermission vXGroupPermission = vxGroupPermission();
XXGroupUserDao xGrpUserDao = Mockito.mock(XXGroupUserDao.class);
Mockito.when(daoManager.getXXGroupUser()).thenReturn(xGrpUserDao);
-
Mockito.when(xGroupPermissionService.createResource(vXGroupPermission)).thenReturn(vXGroupPermission);
-
- VXGroupPermission dbGroupPermission = xUserMgr
- .createXGroupPermission(vXGroupPermission);
+ List<XXGroupUser> xXGroupUserList = new ArrayList<XXGroupUser>();
+ VXGroupUser vxGroupUser = vxGroupUser();
+ XXGroupUser xXGroupUser =new XXGroupUser();
+ xXGroupUser.setId(vxGroupUser.getId());
+ xXGroupUser.setName(vxGroupUser.getName());
+ xXGroupUser.setParentGroupId(vxGroupUser.getParentGroupId());
+ xXGroupUser.setUserId(vxGroupUser.getUserId());
+ xXGroupUserList.add(xXGroupUser);
+ Mockito.when(xGrpUserDao.findByGroupId(vXGroupPermission.getGroupId())).thenReturn(xXGroupUserList);
+ UserSessionBase userSession = Mockito.mock(UserSessionBase.class);
+ Set<UserSessionBase> userSessions = new HashSet<UserSessionBase>();
+ userSessions.add(userSession);
+ Mockito.when(sessionMgr.getActiveUserSessionsForXUserId(xXGroupUser.getUserId())).thenReturn(userSessions);
+ VXGroupPermission dbGroupPermission = xUserMgr.createXGroupPermission(vXGroupPermission);
Assert.assertNotNull(dbGroupPermission);
Assert.assertEquals(dbGroupPermission, vXGroupPermission);
- Assert.assertEquals(dbGroupPermission.getId(),
- vXGroupPermission.getId());
- Assert.assertEquals(dbGroupPermission.getGroupName(),
- vXGroupPermission.getGroupName());
- Assert.assertEquals(dbGroupPermission.getOwner(),
- vXGroupPermission.getOwner());
- Assert.assertEquals(dbGroupPermission.getUpdatedBy(),
- vXGroupPermission.getUpdatedBy());
- Assert.assertEquals(dbGroupPermission.getCreateDate(),
- vXGroupPermission.getCreateDate());
- Assert.assertEquals(dbGroupPermission.getGroupId(),
- vXGroupPermission.getGroupId());
- Assert.assertEquals(dbGroupPermission.getIsAllowed(),
- vXGroupPermission.getIsAllowed());
- Assert.assertEquals(dbGroupPermission.getModuleId(),
- vXGroupPermission.getModuleId());
- Assert.assertEquals(dbGroupPermission.getUpdateDate(),
- vXGroupPermission.getUpdateDate());
-
- Mockito.verify(xGroupPermissionService).createResource(
- vXGroupPermission);
- }
-
- @Test
- public void test40getXGroupPermission() {
- VXGroupPermission vXGroupPermission = vXGroupPermission();
-
- Mockito.when(xGroupPermissionService.readResource(1L)).thenReturn(
- vXGroupPermission);
+ Assert.assertEquals(dbGroupPermission.getId(),vXGroupPermission.getId());
+ Assert.assertEquals(dbGroupPermission.getGroupName(),vXGroupPermission.getGroupName());
+ Assert.assertEquals(dbGroupPermission.getOwner(),vXGroupPermission.getOwner());
+ Assert.assertEquals(dbGroupPermission.getUpdatedBy(),vXGroupPermission.getUpdatedBy());
+ Assert.assertEquals(dbGroupPermission.getCreateDate(),vXGroupPermission.getCreateDate());
+ Assert.assertEquals(dbGroupPermission.getGroupId(),vXGroupPermission.getGroupId());
+ Assert.assertEquals(dbGroupPermission.getIsAllowed(),vXGroupPermission.getIsAllowed());
+ Assert.assertEquals(dbGroupPermission.getModuleId(),vXGroupPermission.getModuleId());
+ Assert.assertEquals(dbGroupPermission.getUpdateDate(),vXGroupPermission.getUpdateDate());
+ Mockito.verify(xGroupPermissionService).createResource(vXGroupPermission);
+ }
+ @Test
+ public void test33getXGroupPermission() {
+ VXGroupPermission vXGroupPermission = vxGroupPermission();
+ Mockito.when(xGroupPermissionService.readResource(1L)).thenReturn(vXGroupPermission);
VXGroupPermission dbGroupPermission = xUserMgr.getXGroupPermission(1L);
Assert.assertNotNull(dbGroupPermission);
Assert.assertEquals(dbGroupPermission, vXGroupPermission);
- Assert.assertEquals(dbGroupPermission.getId(),
- vXGroupPermission.getId());
- Assert.assertEquals(dbGroupPermission.getGroupName(),
- vXGroupPermission.getGroupName());
- Assert.assertEquals(dbGroupPermission.getOwner(),
- vXGroupPermission.getOwner());
- Assert.assertEquals(dbGroupPermission.getUpdatedBy(),
- vXGroupPermission.getUpdatedBy());
- Assert.assertEquals(dbGroupPermission.getCreateDate(),
- vXGroupPermission.getCreateDate());
- Assert.assertEquals(dbGroupPermission.getGroupId(),
- vXGroupPermission.getGroupId());
- Assert.assertEquals(dbGroupPermission.getIsAllowed(),
- vXGroupPermission.getIsAllowed());
- Assert.assertEquals(dbGroupPermission.getModuleId(),
- vXGroupPermission.getModuleId());
- Assert.assertEquals(dbGroupPermission.getUpdateDate(),
- vXGroupPermission.getUpdateDate());
-
+ Assert.assertEquals(dbGroupPermission.getId(),vXGroupPermission.getId());
+ Assert.assertEquals(dbGroupPermission.getGroupName(),vXGroupPermission.getGroupName());
+ Assert.assertEquals(dbGroupPermission.getOwner(),vXGroupPermission.getOwner());
+ Assert.assertEquals(dbGroupPermission.getUpdatedBy(),vXGroupPermission.getUpdatedBy());
+ Assert.assertEquals(dbGroupPermission.getCreateDate(),vXGroupPermission.getCreateDate());
+ Assert.assertEquals(dbGroupPermission.getGroupId(),vXGroupPermission.getGroupId());
+ Assert.assertEquals(dbGroupPermission.getIsAllowed(),vXGroupPermission.getIsAllowed());
+ Assert.assertEquals(dbGroupPermission.getModuleId(),vXGroupPermission.getModuleId());
+ Assert.assertEquals(dbGroupPermission.getUpdateDate(),vXGroupPermission.getUpdateDate());
Mockito.verify(xGroupPermissionService).readResource(1L);
}
@Test
- public void test41updateXGroupPermission() {
- VXGroupPermission vXGroupPermission = vXGroupPermission();
-
+ public void test34updateXGroupPermission() {
+ setup();
+ VXGroupPermission vXGroupPermission = vxGroupPermission();
XXGroupUserDao xGrpUserDao = Mockito.mock(XXGroupUserDao.class);
Mockito.when(daoManager.getXXGroupUser()).thenReturn(xGrpUserDao);
Mockito.when(xGroupPermissionService.updateResource(vXGroupPermission)).thenReturn(vXGroupPermission);
-
- VXGroupPermission dbGroupPermission = xUserMgr
- .updateXGroupPermission(vXGroupPermission);
+ UserSessionBase userSession = Mockito.mock(UserSessionBase.class);
+ Set<UserSessionBase> userSessions = new HashSet<UserSessionBase>();
+ userSessions.add(userSession);
+ Mockito.when(sessionMgr.getActiveUserSessionsForXUserId(userId)).thenReturn(userSessions);
+ List<XXGroupUser> xXGroupUserList = new ArrayList<XXGroupUser>();
+ VXGroupUser vxGroupUser = vxGroupUser();
+ XXGroupUser xXGroupUser =new XXGroupUser();
+ xXGroupUser.setId(vxGroupUser.getId());
+ xXGroupUser.setName(vxGroupUser.getName());
+ xXGroupUser.setParentGroupId(vxGroupUser.getParentGroupId());
+ xXGroupUser.setUserId(vxGroupUser.getUserId());
+ xXGroupUserList.add(xXGroupUser);
+ Mockito.when(xGrpUserDao.findByGroupId(vXGroupPermission.getGroupId())).thenReturn(xXGroupUserList);
+ VXGroupPermission dbGroupPermission = xUserMgr.updateXGroupPermission(vXGroupPermission);
Assert.assertNotNull(dbGroupPermission);
Assert.assertEquals(dbGroupPermission, vXGroupPermission);
- Assert.assertEquals(dbGroupPermission.getId(),
- vXGroupPermission.getId());
- Assert.assertEquals(dbGroupPermission.getGroupName(),
- vXGroupPermission.getGroupName());
- Assert.assertEquals(dbGroupPermission.getOwner(),
- vXGroupPermission.getOwner());
- Assert.assertEquals(dbGroupPermission.getUpdatedBy(),
- vXGroupPermission.getUpdatedBy());
- Assert.assertEquals(dbGroupPermission.getCreateDate(),
- vXGroupPermission.getCreateDate());
- Assert.assertEquals(dbGroupPermission.getGroupId(),
- vXGroupPermission.getGroupId());
- Assert.assertEquals(dbGroupPermission.getIsAllowed(),
- vXGroupPermission.getIsAllowed());
- Assert.assertEquals(dbGroupPermission.getModuleId(),
- vXGroupPermission.getModuleId());
- Assert.assertEquals(dbGroupPermission.getUpdateDate(),
- vXGroupPermission.getUpdateDate());
-
- Mockito.verify(xGroupPermissionService).updateResource(
- vXGroupPermission);
- }
-
- @Test
- public void test42deleteXGroupPermission() {
+ Assert.assertEquals(dbGroupPermission.getId(),vXGroupPermission.getId());
+ Assert.assertEquals(dbGroupPermission.getGroupName(),vXGroupPermission.getGroupName());
+ Assert.assertEquals(dbGroupPermission.getOwner(),vXGroupPermission.getOwner());
+ Assert.assertEquals(dbGroupPermission.getUpdatedBy(),vXGroupPermission.getUpdatedBy());
+ Assert.assertEquals(dbGroupPermission.getCreateDate(),vXGroupPermission.getCreateDate());
+ Assert.assertEquals(dbGroupPermission.getGroupId(),vXGroupPermission.getGroupId());
+ Assert.assertEquals(dbGroupPermission.getIsAllowed(),vXGroupPermission.getIsAllowed());
+ Assert.assertEquals(dbGroupPermission.getModuleId(),vXGroupPermission.getModuleId());
+ Assert.assertEquals(dbGroupPermission.getUpdateDate(),vXGroupPermission.getUpdateDate());
+ Mockito.verify(xGroupPermissionService).updateResource(vXGroupPermission);
+ }
+ @Test
+ public void test35deleteXGroupPermission() {
XXGroupPermissionDao xGrpPermDao = Mockito.mock(XXGroupPermissionDao.class);
- XXGroupPermission xGrpPerm = Mockito.mock(XXGroupPermission.class);
-
+ XXGroupPermission xGroupPermissionObj = xxGroupPermission();
Mockito.when(daoManager.getXXGroupPermission()).thenReturn(xGrpPermDao);
- Mockito.when(daoManager.getXXGroupPermission().getById(1L)).thenReturn(xGrpPerm);
-
+ Mockito.when(xGrpPermDao.getById(1L)).thenReturn(xGroupPermissionObj);
XXGroupUserDao xGrpUserDao = Mockito.mock(XXGroupUserDao.class);
Mockito.when(daoManager.getXXGroupUser()).thenReturn(xGrpUserDao);
-
+ List<XXGroupUser> xXGroupUserList = new ArrayList<XXGroupUser>();
+ VXGroupUser vxGroupUser = vxGroupUser();
+ XXGroupUser xXGroupUser =new XXGroupUser();
+ xXGroupUser.setId(vxGroupUser.getId());
+ xXGroupUser.setName(vxGroupUser.getName());
+ xXGroupUser.setParentGroupId(vxGroupUser.getParentGroupId());
+ xXGroupUser.setUserId(vxGroupUser.getUserId());
+ xXGroupUserList.add(xXGroupUser);
+ Mockito.when(xGrpUserDao.findByGroupId(xGroupPermissionObj.getGroupId())).thenReturn(xXGroupUserList);
+ UserSessionBase userSession = Mockito.mock(UserSe
<TRUNCATED>
[2/2] ranger git commit: RANGER-2150: Unit test coverage for XUserMgr
and UserMgr class
Posted by pr...@apache.org.
RANGER-2150: Unit test coverage for XUserMgr and UserMgr class
Project: http://git-wip-us.apache.org/repos/asf/ranger/repo
Commit: http://git-wip-us.apache.org/repos/asf/ranger/commit/34499290
Tree: http://git-wip-us.apache.org/repos/asf/ranger/tree/34499290
Diff: http://git-wip-us.apache.org/repos/asf/ranger/diff/34499290
Branch: refs/heads/master
Commit: 34499290059a28f5084f0fa3b249d70ba11d1e83
Parents: f368dcb
Author: pradeep <pr...@apache.org>
Authored: Fri Jul 6 01:28:54 2018 +0530
Committer: pradeep <pr...@apache.org>
Committed: Mon Jul 23 11:24:22 2018 +0530
----------------------------------------------------------------------
.../java/org/apache/ranger/biz/UserMgr.java | 4 +-
.../java/org/apache/ranger/biz/XUserMgr.java | 33 +-
.../java/org/apache/ranger/biz/TestUserMgr.java | 1036 ++++--
.../org/apache/ranger/biz/TestXUserMgr.java | 3284 +++++++++++++-----
4 files changed, 3166 insertions(+), 1191 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/ranger/blob/34499290/security-admin/src/main/java/org/apache/ranger/biz/UserMgr.java
----------------------------------------------------------------------
diff --git a/security-admin/src/main/java/org/apache/ranger/biz/UserMgr.java b/security-admin/src/main/java/org/apache/ranger/biz/UserMgr.java
index 6d94e4f..2a638f8 100644
--- a/security-admin/src/main/java/org/apache/ranger/biz/UserMgr.java
+++ b/security-admin/src/main/java/org/apache/ranger/biz/UserMgr.java
@@ -618,7 +618,7 @@ public class UserMgr {
return userProfile;
}
- private void gjUserToUserProfile(XXPortalUser user, VXPortalUser userProfile) {
+ protected void gjUserToUserProfile(XXPortalUser user, VXPortalUser userProfile) {
UserSessionBase sess = ContextUtil.getCurrentUserSession();
if (sess == null) {
return;
@@ -810,7 +810,7 @@ public class UserMgr {
* @param searchCriteria
* @return
*/
- private Query createUserSearchQuery(String queryStr, String sortClause,
+ protected Query createUserSearchQuery(String queryStr, String sortClause,
SearchCriteria searchCriteria) {
HashMap<String, Object> paramList = searchCriteria.getParamList();
http://git-wip-us.apache.org/repos/asf/ranger/blob/34499290/security-admin/src/main/java/org/apache/ranger/biz/XUserMgr.java
----------------------------------------------------------------------
diff --git a/security-admin/src/main/java/org/apache/ranger/biz/XUserMgr.java b/security-admin/src/main/java/org/apache/ranger/biz/XUserMgr.java
index 7f5eab7..ea60e99 100644
--- a/security-admin/src/main/java/org/apache/ranger/biz/XUserMgr.java
+++ b/security-admin/src/main/java/org/apache/ranger/biz/XUserMgr.java
@@ -132,12 +132,12 @@ public class XUserMgr extends XUserMgrBase {
@Autowired
GUIDUtil guidUtil;
- @Autowired
- UserMgr userManager;
-
@Autowired
XUgsyncAuditInfoService xUgsyncAuditInfoService;
+ @Autowired
+ XGroupUserService xGroupUserService;
+
static final Logger logger = Logger.getLogger(XUserMgr.class);
@@ -173,7 +173,7 @@ public class XUserMgr extends XUserMgrBase {
}
if (vXUser.getDescription() == null) {
- setUserDesc(vXUser);
+ vXUser.setDescription(vXUser.getName());
}
String actualPassword = vXUser.getPassword();
@@ -325,7 +325,7 @@ public class XUserMgr extends XUserMgrBase {
return null;
}
- private VXGroupUser createXGroupUser(Long userId, Long groupId) {
+ protected VXGroupUser createXGroupUser(Long userId, Long groupId) {
VXGroupUser vXGroupUser = new VXGroupUser();
vXGroupUser.setParentGroupId(groupId);
vXGroupUser.setUserId(userId);
@@ -538,8 +538,7 @@ public class XUserMgr extends XUserMgrBase {
List<String> existingRole = daoManager.getXXPortalUserRole()
.findXPortalUserRolebyXPortalUserId(xxPortalUser.getId());
if (xxPortalUser.getUserSource() == RangerCommonEnums.USER_EXTERNAL) {
- vXPortalUser = userManager.updateRoleForExternalUsers(reqRoleList,
- existingRole, vXPortalUser);
+ vXPortalUser = userMgr.updateRoleForExternalUsers(reqRoleList, existingRole, vXPortalUser);
}
vXUser = xUserService.createXUserWithOutLogin(vXUser);
vxUGInfo.setXuserInfo(vXUser);
@@ -603,10 +602,10 @@ public class XUserMgr extends XUserMgrBase {
List<String> existingRole = daoManager.getXXPortalUserRole()
.findXPortalUserRolebyXPortalUserId(
xxPortalUser.getId());
- VXPortalUser vxPortalUser = userManager
+ VXPortalUser vxPortalUser = userMgr
.mapXXPortalUserToVXPortalUserForDefaultAccount(xxPortalUser);
if (xxPortalUser.getUserSource() == RangerCommonEnums.USER_EXTERNAL) {
- vxPortalUser = userManager.updateRoleForExternalUsers(
+ vxPortalUser = userMgr.updateRoleForExternalUsers(
reqRoleList, existingRole, vxPortalUser);
assignPermissionToUser(vxPortalUser, true);
}
@@ -851,11 +850,6 @@ public class XUserMgr extends XUserMgrBase {
return vXUserList;
}
- // FIXME Hack : Unnecessary, to be removed after discussion.
- private void setUserDesc(VXUser vXUser) {
- vXUser.setDescription(vXUser.getName());
- }
-
@Override
public VXGroup updateXGroup(VXGroup vXGroup) {
checkAdminAccess();
@@ -872,7 +866,7 @@ public class XUserMgr extends XUserMgrBase {
return vXGroup;
}
- private void updateXgroupUserForGroupUpdate(VXGroup vXGroup) {
+ protected void updateXgroupUserForGroupUpdate(VXGroup vXGroup) {
List<XXGroupUser> grpUsers = daoManager.getXXGroupUser().findByGroupId(vXGroup.getId());
if(CollectionUtils.isNotEmpty(grpUsers)){
for (XXGroupUser grpUser : grpUsers) {
@@ -1264,10 +1258,8 @@ public class XUserMgr extends XUserMgrBase {
}
public VXPermMapList searchXPermMaps(SearchCriteria searchCriteria) {
-
- VXPermMapList returnList;
+ VXPermMapList returnList = null;
UserSessionBase currentUserSession = ContextUtil.getCurrentUserSession();
- // If user is system admin
if (currentUserSession != null && currentUserSession.isUserAdmin()) {
returnList = super.searchXPermMaps(searchCriteria);
} else {
@@ -1310,13 +1302,12 @@ public class XUserMgr extends XUserMgrBase {
public VXAuditMapList searchXAuditMaps(SearchCriteria searchCriteria) {
- VXAuditMapList returnList;
+ VXAuditMapList returnList=new VXAuditMapList();
UserSessionBase currentUserSession = ContextUtil.getCurrentUserSession();
// If user is system admin
if (currentUserSession != null && currentUserSession.isUserAdmin()) {
returnList = super.searchXAuditMaps(searchCriteria);
} else {
- returnList = new VXAuditMapList();
int startIndex = searchCriteria.getStartIndex();
int pageSize = searchCriteria.getMaxRows();
searchCriteria.setStartIndex(0);
@@ -2255,7 +2246,7 @@ public class XUserMgr extends XUserMgrBase {
}
return createdXUser;
}
- private void validatePassword(VXUser vXUser) {
+ protected void validatePassword(VXUser vXUser) {
if (vXUser.getPassword() != null && !vXUser.getPassword().isEmpty()) {
boolean checkPassword = false;
String pattern = "(?=.*[0-9])(?=.*[a-zA-Z]).{8,}";
http://git-wip-us.apache.org/repos/asf/ranger/blob/34499290/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java
----------------------------------------------------------------------
diff --git a/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java b/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java
index 10453a5..202a113 100644
--- a/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java
+++ b/security-admin/src/test/java/org/apache/ranger/biz/TestUserMgr.java
@@ -23,11 +23,11 @@ import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.Query;
-import javax.ws.rs.WebApplicationException;
-
+import org.apache.ranger.common.AppConstants;
import org.apache.ranger.common.ContextUtil;
-import org.apache.ranger.common.MessageEnums;
import org.apache.ranger.common.RESTErrorUtil;
+import org.apache.ranger.common.RangerCommonEnums;
+import org.apache.ranger.common.RangerConstants;
import org.apache.ranger.common.SearchCriteria;
import org.apache.ranger.common.SearchUtil;
import org.apache.ranger.common.StringUtil;
@@ -37,15 +37,19 @@ import org.apache.ranger.db.XXGroupPermissionDao;
import org.apache.ranger.db.XXModuleDefDao;
import org.apache.ranger.db.XXPortalUserDao;
import org.apache.ranger.db.XXPortalUserRoleDao;
+import org.apache.ranger.db.XXUserDao;
import org.apache.ranger.db.XXUserPermissionDao;
import org.apache.ranger.entity.XXGroupPermission;
import org.apache.ranger.entity.XXModuleDef;
import org.apache.ranger.entity.XXPortalUser;
import org.apache.ranger.entity.XXPortalUserRole;
+import org.apache.ranger.entity.XXTrxLog;
+import org.apache.ranger.entity.XXUser;
import org.apache.ranger.entity.XXUserPermission;
import org.apache.ranger.security.context.RangerContextHolder;
import org.apache.ranger.security.context.RangerSecurityContext;
import org.apache.ranger.service.XGroupPermissionService;
+import org.apache.ranger.service.XPortalUserService;
import org.apache.ranger.service.XUserPermissionService;
import org.apache.ranger.view.VXGroupPermission;
import org.apache.ranger.view.VXPasswordChange;
@@ -54,6 +58,7 @@ import org.apache.ranger.view.VXPortalUserList;
import org.apache.ranger.view.VXResponse;
import org.apache.ranger.view.VXString;
import org.apache.ranger.view.VXUserPermission;
+import org.junit.After;
import org.junit.Assert;
import org.junit.FixMethodOrder;
import org.junit.Rule;
@@ -71,6 +76,7 @@ import org.mockito.junit.MockitoJUnitRunner;
public class TestUserMgr {
private static Long userId = 1L;
+ private static String userLoginID = "testuser";
@InjectMocks
UserMgr userMgr = new UserMgr();
@@ -94,7 +100,7 @@ public class TestUserMgr {
SearchUtil searchUtil;
@Mock
- RangerBizUtil rangerBizUtil;
+ RangerBizUtil rangerBizUtil;
@Mock
XUserPermissionService xUserPermissionService;
@@ -108,6 +114,9 @@ public class TestUserMgr {
@Mock
XUserMgr xUserMgr;
+ @Mock
+ XPortalUserService xPortalUserService;
+
@Rule
public ExpectedException thrown = ExpectedException.none();
@@ -115,8 +124,7 @@ public class TestUserMgr {
RangerSecurityContext context = new RangerSecurityContext();
context.setUserSession(new UserSessionBase());
RangerContextHolder.setSecurityContext(context);
- UserSessionBase currentUserSession = ContextUtil
- .getCurrentUserSession();
+ UserSessionBase currentUserSession = ContextUtil.getCurrentUserSession();
currentUserSession.setUserAdmin(true);
}
@@ -148,16 +156,48 @@ public class TestUserMgr {
userProfile.setEmailAddress("test@test.com");
userProfile.setFirstName("user12");
userProfile.setLastName("test12");
- userProfile.setLoginId("134");
+ userProfile.setLoginId(userLoginID);
userProfile.setPassword("usertest12323");
- userProfile.setUserSource(123);
- userProfile.setPublicScreenName("user");
+ userProfile.setUserSource(1);
+ userProfile.setPublicScreenName("testuser");
userProfile.setId(userId);
return userProfile;
}
+ private XXPortalUser xxPortalUser(VXPortalUser userProfile) {
+ XXPortalUser xxPortalUser = new XXPortalUser();
+ xxPortalUser.setEmailAddress(userProfile.getEmailAddress());
+ xxPortalUser.setFirstName(userProfile.getFirstName());
+ xxPortalUser.setLastName(userProfile.getLastName());
+ xxPortalUser.setLoginId(userProfile.getLoginId());
+ xxPortalUser.setPassword(userProfile.getPassword());
+ xxPortalUser.setUserSource(userProfile.getUserSource());
+ xxPortalUser.setPublicScreenName(userProfile.getPublicScreenName());
+ return xxPortalUser;
+ }
+
+ public void setupRangerUserSyncUser() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(new UserSessionBase());
+ RangerContextHolder.setSecurityContext(context);
+ UserSessionBase currentUserSession = ContextUtil.getCurrentUserSession();
+ XXPortalUser user = new XXPortalUser();
+ user.setId(1L);
+ user.setLoginId("rangerusersync");
+ user.setEmailAddress("test@test.com");
+ currentUserSession.setXXPortalUser(user);
+ currentUserSession.setUserAdmin(true);
+ }
+
+ @After
+ public void destroySession() {
+ RangerSecurityContext context = new RangerSecurityContext();
+ context.setUserSession(null);
+ RangerContextHolder.setSecurityContext(context);
+ }
+
@Test
- public void test11CreateUser() {
+ public void test01CreateUser() {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
@@ -184,41 +224,36 @@ public class TestUserMgr {
list.add(XXPortalUserRole);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
- Mockito.when(userDao.create((XXPortalUser) Mockito.any()))
- .thenReturn(user);
+ Mockito.when(userDao.create((XXPortalUser) Mockito.any())).thenReturn(user);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
- XXPortalUser dbxxPortalUser = userMgr.createUser(userProfile, 1,
- userRoleList);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ XXPortalUser dbxxPortalUser = userMgr.createUser(userProfile, 1,userRoleList);
Assert.assertNotNull(dbxxPortalUser);
userId = dbxxPortalUser.getId();
Assert.assertEquals(userId, dbxxPortalUser.getId());
- Assert.assertEquals(userProfile.getFirstName(),
- dbxxPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getFirstName(),
- dbxxPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getLastName(),
- dbxxPortalUser.getLastName());
- Assert.assertEquals(userProfile.getLoginId(),
- dbxxPortalUser.getLoginId());
- Assert.assertEquals(userProfile.getEmailAddress(),
- dbxxPortalUser.getEmailAddress());
- Assert.assertEquals(userProfile.getPassword(),
- dbxxPortalUser.getPassword());
+ Assert.assertEquals(userProfile.getFirstName(),dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getFirstName(),dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),dbxxPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),dbxxPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),dbxxPortalUser.getEmailAddress());
+ Assert.assertEquals(userProfile.getPassword(),dbxxPortalUser.getPassword());
Mockito.verify(daoManager).getXXPortalUser();
Mockito.verify(daoManager).getXXPortalUserRole();
}
@Test
- public void test12CreateUser() {
+ public void test02CreateUser() {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
VXPortalUser userProfile = userProfile();
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+ userProfile.setUserRoleList(userRoleList);
XXPortalUser user = new XXPortalUser();
user.setEmailAddress(userProfile.getEmailAddress());
@@ -237,35 +272,28 @@ public class TestUserMgr {
list.add(XXPortalUserRole);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
- Mockito.when(userDao.create((XXPortalUser) Mockito.any()))
- .thenReturn(user);
+ Mockito.when(userDao.create((XXPortalUser) Mockito.any())).thenReturn(user);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
XXPortalUser dbxxPortalUser = userMgr.createUser(userProfile, 1);
userId = dbxxPortalUser.getId();
Assert.assertNotNull(dbxxPortalUser);
Assert.assertEquals(userId, dbxxPortalUser.getId());
- Assert.assertEquals(userProfile.getFirstName(),
- dbxxPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getFirstName(),
- dbxxPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getLastName(),
- dbxxPortalUser.getLastName());
- Assert.assertEquals(userProfile.getLoginId(),
- dbxxPortalUser.getLoginId());
- Assert.assertEquals(userProfile.getEmailAddress(),
- dbxxPortalUser.getEmailAddress());
- Assert.assertEquals(userProfile.getPassword(),
- dbxxPortalUser.getPassword());
+ Assert.assertEquals(userProfile.getFirstName(),dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getFirstName(),dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),dbxxPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),dbxxPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),dbxxPortalUser.getEmailAddress());
+ Assert.assertEquals(userProfile.getPassword(),dbxxPortalUser.getPassword());
Mockito.verify(daoManager).getXXPortalUser();
Mockito.verify(daoManager).getXXPortalUserRole();
}
@Test
- public void test13ChangePasswordAsAdmin() {
+ public void test03ChangePasswordAsAdmin() {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
VXPortalUser userProfile = userProfile();
@@ -281,26 +309,20 @@ public class TestUserMgr {
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
Mockito.when(userDao.findByLoginId(Mockito.nullable(String.class))).thenReturn(user);
- Mockito.when(
- stringUtil.equals(Mockito.anyString(), Mockito.nullable(String.class)))
- .thenReturn(true);
+ Mockito.when(stringUtil.equals(Mockito.anyString(), Mockito.nullable(String.class))).thenReturn(true);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
- Mockito.when(
- stringUtil.validatePassword(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(true);
+ Mockito.when(stringUtil.validatePassword(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(true);
VXResponse dbVXResponse = userMgr.changePassword(pwdChange);
Assert.assertNotNull(dbVXResponse);
- Assert.assertEquals(userProfile.getStatus(),
- dbVXResponse.getStatusCode());
+ Assert.assertEquals(userProfile.getStatus(),dbVXResponse.getStatusCode());
- Mockito.verify(stringUtil).equals(Mockito.anyString(),
- Mockito.nullable(String.class));
- Mockito.verify(stringUtil).validatePassword(Mockito.anyString(),
- Mockito.any(String[].class));
+ Mockito.verify(stringUtil).equals(Mockito.anyString(),Mockito.nullable(String.class));
+ Mockito.verify(stringUtil).validatePassword(Mockito.anyString(),Mockito.any(String[].class));
}
@Test
- public void test14ChangePasswordAsKeyAdmin() {
+ public void test04ChangePasswordAsKeyAdmin() {
setupKeyAdmin();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
VXPortalUser userProfile = userProfile();
@@ -330,7 +352,7 @@ public class TestUserMgr {
}
@Test
- public void test15ChangePasswordAsUser() {
+ public void test05ChangePasswordAsUser() {
setupUser();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
VXPortalUser userProfile = userProfile();
@@ -360,7 +382,7 @@ public class TestUserMgr {
}
@Test
- public void test16ChangeEmailAddressAsAdmin() {
+ public void test06ChangeEmailAddressAsAdmin() {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
@@ -448,21 +470,22 @@ public class TestUserMgr {
Mockito.when(xUserPermissionService.populateViewBean(xUserPermissionObj)).thenReturn(userPermission);
Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong())).thenReturn(xModuleDef);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
- VXPortalUser dbVXPortalUser = userMgr.changeEmailAddress(user,
- changeEmail);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ VXPortalUser dbVXPortalUser = userMgr.changeEmailAddress(user,changeEmail);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(userId, dbVXPortalUser.getId());
- Assert.assertEquals(userProfile.getLastName(),
- dbVXPortalUser.getLastName());
- Assert.assertEquals(changeEmail.getLoginId(),
- dbVXPortalUser.getLoginId());
- Assert.assertEquals(changeEmail.getEmailAddress(),
- dbVXPortalUser.getEmailAddress());
+ Assert.assertEquals(userProfile.getLastName(),dbVXPortalUser.getLastName());
+ Assert.assertEquals(changeEmail.getLoginId(),dbVXPortalUser.getLoginId());
+ Assert.assertEquals(changeEmail.getEmailAddress(),dbVXPortalUser.getEmailAddress());
+ user.setUserSource(RangerCommonEnums.USER_APP);
+ dbVXPortalUser = userMgr.changeEmailAddress(user,changeEmail);
+ user.setUserSource(RangerCommonEnums.USER_EXTERNAL);
+ changeEmail.setEmailAddress("");
+ dbVXPortalUser = userMgr.changeEmailAddress(user,changeEmail);
}
@Test
- public void test17ChangeEmailAddressAsKeyAdmin() {
+ public void test07ChangeEmailAddressAsKeyAdmin() {
setupKeyAdmin();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
@@ -549,7 +572,7 @@ public class TestUserMgr {
Mockito.when(xUserPermissionService.populateViewBean(xUserPermissionObj)).thenReturn(userPermission);
Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong())).thenReturn(xModuleDef);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
VXPortalUser dbVXPortalUser = userMgr.changeEmailAddress(userKeyAdmin,changeEmail);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(userId, dbVXPortalUser.getId());
@@ -560,7 +583,7 @@ public class TestUserMgr {
@Test
- public void test18ChangeEmailAddressAsUser() {
+ public void test08ChangeEmailAddressAsUser() {
setupUser();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
@@ -647,7 +670,7 @@ public class TestUserMgr {
Mockito.when(xUserPermissionService.populateViewBean(xUserPermissionObj)).thenReturn(userPermission);
Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong())).thenReturn(xModuleDef);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
VXPortalUser dbVXPortalUser = userMgr.changeEmailAddress(user,changeEmail);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(userId, dbVXPortalUser.getId());
@@ -657,14 +680,12 @@ public class TestUserMgr {
}
@Test
- public void test21CreateUser() {
+ public void test09CreateUser() {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
- XXUserPermissionDao xUserPermissionDao = Mockito
- .mock(XXUserPermissionDao.class);
- XXGroupPermissionDao xGroupPermissionDao = Mockito
- .mock(XXGroupPermissionDao.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito.mock(XXGroupPermissionDao.class);
XXPortalUser user = new XXPortalUser();
VXPortalUser userProfile = userProfile();
@@ -700,25 +721,20 @@ public class TestUserMgr {
xGroupPermissionList.add(xGroupPermissionObj);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
- Mockito.when(userDao.create((XXPortalUser) Mockito.any()))
- .thenReturn(user);
+ Mockito.when(userDao.create((XXPortalUser) Mockito.any())).thenReturn(user);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
- Mockito.when(daoManager.getXXUserPermission()).thenReturn(
- xUserPermissionDao);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermissionDao);
- Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
- xGroupPermissionDao);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(xGroupPermissionDao);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
VXPortalUser dbVXPortalUser = userMgr.createUser(userProfile);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(user.getId(), dbVXPortalUser.getId());
Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
- Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getLastName(), dbVXPortalUser.getLastName());
Assert.assertEquals(user.getLoginId(), dbVXPortalUser.getLoginId());
- Assert.assertEquals(user.getEmailAddress(),
- dbVXPortalUser.getEmailAddress());
+ Assert.assertEquals(user.getEmailAddress(),dbVXPortalUser.getEmailAddress());
Assert.assertEquals(user.getPassword(), dbVXPortalUser.getPassword());
Mockito.verify(daoManager).getXXPortalUser();
@@ -727,13 +743,16 @@ public class TestUserMgr {
}
@Test
- public void test22CreateDefaultAccountUser() {
+ public void test10CreateDefaultAccountUser() {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
VXPortalUser userProfile = userProfile();
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+ userProfile.setUserRoleList(userRoleList);
XXPortalUser user = new XXPortalUser();
-
+ user.setEmailAddress(userProfile.getEmailAddress());
XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
XXPortalUserRole.setId(userId);
XXPortalUserRole.setUserRole("ROLE_USER");
@@ -742,30 +761,72 @@ public class TestUserMgr {
list.add(XXPortalUserRole);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
- Mockito.when(userDao.findByLoginId(Mockito.anyString())).thenReturn(
- user);
+ Mockito.when(userDao.findByLoginId(Mockito.anyString())).thenReturn(user);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
- VXPortalUser dbVXPortalUser = userMgr
- .createDefaultAccountUser(userProfile);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ VXPortalUser dbVXPortalUser = userMgr.createDefaultAccountUser(userProfile);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(user.getId(), dbVXPortalUser.getId());
Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
- Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getLastName(), dbVXPortalUser.getLastName());
Assert.assertEquals(user.getLoginId(), dbVXPortalUser.getLoginId());
- Assert.assertEquals(user.getEmailAddress(),
- dbVXPortalUser.getEmailAddress());
+ Assert.assertEquals(user.getEmailAddress(),dbVXPortalUser.getEmailAddress());
Assert.assertEquals(user.getPassword(), dbVXPortalUser.getPassword());
-
- Mockito.verify(daoManager, Mockito.atLeast(1)).getXXPortalUser();
- Mockito.verify(daoManager, Mockito.atLeast(1)).getXXPortalUserRole();
+ Mockito.verify(daoManager, Mockito.atLeast(1)).getXXPortalUser();
+ Mockito.verify(daoManager, Mockito.atLeast(1)).getXXPortalUserRole();
}
@Test
- public void test23IsUserInRole() {
+ public void test11CreateDefaultAccountUser() {
+ setup();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ VXPortalUser userProfile = userProfile();
+ userProfile.setStatus(RangerCommonEnums.USER_EXTERNAL);
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+ userProfile.setUserRoleList(userRoleList);
+ XXPortalUser user = new XXPortalUser();
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setUserSource(RangerCommonEnums.USER_EXTERNAL);
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+
+ List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
+ list.add(XXPortalUserRole);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(userDao.findByLoginId(Mockito.anyString())).thenReturn(null);
+ Mockito.when(userDao.findByEmailAddress(Mockito.anyString())).thenReturn(null);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
+ Mockito.when(userDao.create((XXPortalUser) Mockito.any())).thenReturn(user);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ VXPortalUser dbVXPortalUser = userMgr.createDefaultAccountUser(userProfile);
+ Assert.assertNotNull(dbVXPortalUser);
+ Assert.assertEquals(user.getId(), dbVXPortalUser.getId());
+ Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
+ Assert.assertEquals(user.getLastName(), dbVXPortalUser.getLastName());
+ Assert.assertEquals(user.getLoginId(), dbVXPortalUser.getLoginId());
+ Assert.assertEquals(user.getEmailAddress(),dbVXPortalUser.getEmailAddress());
+ Assert.assertEquals(user.getPassword(), dbVXPortalUser.getPassword());
+ Mockito.verify(daoManager, Mockito.atLeast(1)).getXXPortalUser();
+ Mockito.verify(daoManager, Mockito.atLeast(1)).getXXPortalUserRole();
+ }
+
+ @Test
+ public void test12CreateDefaultAccountUser() {
+ setup();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ VXPortalUser userProfile = userProfile();
+ userProfile.setStatus(RangerCommonEnums.USER_EXTERNAL);
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+ userProfile.setUserRoleList(userRoleList);
+ XXPortalUser xxPortalUser = new XXPortalUser();
+ xxPortalUser.setEmailAddress(userProfile.getEmailAddress());
+ xxPortalUser.setUserSource(RangerCommonEnums.USER_EXTERNAL);
XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
XXPortalUserRole.setId(userId);
XXPortalUserRole.setUserRole("ROLE_USER");
@@ -773,57 +834,76 @@ public class TestUserMgr {
List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
list.add(XXPortalUserRole);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(userDao.findByLoginId(Mockito.anyString())).thenReturn(xxPortalUser);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
- Mockito.when(roleDao.findByRoleUserId(userId, "ROLE_USER")).thenReturn(
- XXPortalUserRole);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ userProfile.setPassword("");
+ userProfile.setEmailAddress(null);
+ VXPortalUser dbVXPortalUser = userMgr.createDefaultAccountUser(userProfile);
+ Assert.assertNotNull(dbVXPortalUser);
+ Assert.assertEquals(xxPortalUser.getId(), dbVXPortalUser.getId());
+ Assert.assertEquals(xxPortalUser.getFirstName(), dbVXPortalUser.getFirstName());
+ Assert.assertEquals(xxPortalUser.getLastName(), dbVXPortalUser.getLastName());
+ Assert.assertEquals(xxPortalUser.getLoginId(), dbVXPortalUser.getLoginId());
+ Assert.assertEquals(xxPortalUser.getEmailAddress(),dbVXPortalUser.getEmailAddress());
+ Assert.assertEquals(xxPortalUser.getPassword(), dbVXPortalUser.getPassword());
+ Mockito.verify(daoManager, Mockito.atLeast(1)).getXXPortalUser();
+ Mockito.verify(daoManager, Mockito.atLeast(1)).getXXPortalUserRole();
+ }
+ @Test
+ public void test13IsUserInRole() {
+ XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
+ list.add(XXPortalUserRole);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
+ Mockito.when(roleDao.findByRoleUserId(userId, "ROLE_USER")).thenReturn(XXPortalUserRole);
boolean isValue = userMgr.isUserInRole(userId, "ROLE_USER");
Assert.assertTrue(isValue);
-
- Mockito.verify(daoManager).getXXPortalUserRole();
+ Mockito.when(roleDao.findByRoleUserId(userId, "ROLE_USER")).thenReturn(null);
+ isValue = userMgr.isUserInRole(userId, "ROLE_USER");
+ Assert.assertFalse(isValue);
}
@Test
- public void test24UpdateUserWithPass() {
+ public void test14UpdateUserWithPass() {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
-
VXPortalUser userProfile = userProfile();
+ userProfile.setPassword("password1234");
XXPortalUser user = new XXPortalUser();
-
+ user.setId(userProfile.getId());
+ user.setLoginId(userProfile.getLoginId());
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setLoginId(userProfile.getLoginId());
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ user.setPassword(encryptedPwd);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
Mockito.when(userDao.getById(userProfile.getId())).thenReturn(user);
-
- Mockito.when(
- restErrorUtil.createRESTException(
- "Please provide valid email address.",
- MessageEnums.INVALID_INPUT_DATA)).thenThrow(
- new WebApplicationException());
- thrown.expect(WebApplicationException.class);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.when(stringUtil.validateEmail(Mockito.anyString())).thenReturn(true);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.when(stringUtil.validatePassword(Mockito.anyString(), Mockito.any(String[].class))).thenReturn(true);
+ Mockito.when(userDao.update(user)).thenReturn(user);
XXPortalUser dbXXPortalUser = userMgr.updateUserWithPass(userProfile);
Assert.assertNotNull(dbXXPortalUser);
Assert.assertEquals(userId, dbXXPortalUser.getId());
- Assert.assertEquals(userProfile.getFirstName(),
- dbXXPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getFirstName(),
- dbXXPortalUser.getFirstName());
- Assert.assertEquals(userProfile.getLastName(),
- dbXXPortalUser.getLastName());
- Assert.assertEquals(userProfile.getLoginId(),
- dbXXPortalUser.getLoginId());
- Assert.assertEquals(userProfile.getEmailAddress(),
- dbXXPortalUser.getEmailAddress());
- Assert.assertEquals(userProfile.getPassword(),
- dbXXPortalUser.getPassword());
-
- Mockito.verify(restErrorUtil).createRESTException(
- "Please provide valid email address.",
- MessageEnums.INVALID_INPUT_DATA);
+ Assert.assertEquals(userProfile.getFirstName(),dbXXPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getFirstName(),dbXXPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),dbXXPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),dbXXPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),dbXXPortalUser.getEmailAddress());
+ Assert.assertEquals(encryptedPwd, dbXXPortalUser.getPassword());
+ Mockito.when(userDao.getById(userProfile.getId())).thenReturn(null);
+ dbXXPortalUser = userMgr.updateUserWithPass(userProfile);
+ Assert.assertNull(dbXXPortalUser);
}
@Test
- public void test25searchUsers() {
+ public void test15searchUsers() {
Query query = Mockito.mock(Query.class);
EntityManager entityManager = Mockito.mock(EntityManager.class);
SearchCriteria searchCriteria = new SearchCriteria();
@@ -833,27 +913,44 @@ public class TestUserMgr {
searchCriteria.setMaxRows(12);
searchCriteria.setOwnerId(userId);
searchCriteria.setStartIndex(1);
- searchCriteria.setSortBy("asc");
+ searchCriteria.setSortBy("userId");
+ searchCriteria.setSortType("asc");
Long count = 1l;
Mockito.when(daoManager.getEntityManager()).thenReturn(entityManager);
- Mockito.when(entityManager.createQuery(Mockito.anyString()))
- .thenReturn(query);
+ Mockito.when(entityManager.createQuery(Mockito.anyString())).thenReturn(query);
Mockito.when(query.getSingleResult()).thenReturn(count);
- VXPortalUserList dbVXPortalUserList = userMgr
- .searchUsers(searchCriteria);
-
+ VXPortalUserList dbVXPortalUserList = userMgr.searchUsers(searchCriteria);
+ Assert.assertNotNull(dbVXPortalUserList);
+ searchCriteria.setSortBy("loginId");
+ dbVXPortalUserList = userMgr.searchUsers(searchCriteria);
+ Assert.assertNotNull(dbVXPortalUserList);
+ searchCriteria.setSortBy("emailAddress");
+ dbVXPortalUserList = userMgr.searchUsers(searchCriteria);
+ Assert.assertNotNull(dbVXPortalUserList);
+ searchCriteria.setSortBy("firstName");
+ dbVXPortalUserList = userMgr.searchUsers(searchCriteria);
+ Assert.assertNotNull(dbVXPortalUserList);
+ searchCriteria.setSortBy("lastName");
+ dbVXPortalUserList = userMgr.searchUsers(searchCriteria);
+ Assert.assertNotNull(dbVXPortalUserList);
+ searchCriteria.setSortBy("source");
+ searchCriteria.setSortType("");
+ dbVXPortalUserList = userMgr.searchUsers(searchCriteria);
+ Assert.assertNotNull(dbVXPortalUserList);
+ searchCriteria.setSortBy("");
+ searchCriteria.setSortType("desc");
+ dbVXPortalUserList = userMgr.searchUsers(searchCriteria);
Assert.assertNotNull(dbVXPortalUserList);
- Mockito.verify(query).getSingleResult();
}
@Test
- public void test26FindByEmailAddress() {
+ public void test16FindByEmailAddress() {
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUser user = new XXPortalUser();
- String emailId = "jeet786sonkar@gmail.com";
+ String emailId = "test001user@apache.org";
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
Mockito.when(userDao.findByEmailAddress(emailId)).thenReturn(user);
@@ -865,7 +962,7 @@ public class TestUserMgr {
}
@Test
- public void test27GetRolesForUser() {
+ public void test17GetRolesForUser() {
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
VXPortalUser userProfile = userProfile();
@@ -895,7 +992,7 @@ public class TestUserMgr {
}
@Test
- public void test28DeleteUserRole() {
+ public void test18DeleteUserRole() {
setup();
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
@@ -909,26 +1006,22 @@ public class TestUserMgr {
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
-
+
boolean deleteValue = userMgr.deleteUserRole(userId, userRole);
Assert.assertTrue(deleteValue);
}
@Test
- public void test29DeactivateUser() {
+ public void test19DeactivateUser() {
setup();
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
- XXUserPermissionDao xUserPermissionDao = Mockito
- .mock(XXUserPermissionDao.class);
- XXGroupPermissionDao xGroupPermissionDao = Mockito
- .mock(XXGroupPermissionDao.class);
- VXGroupPermission vXGroupPermission = Mockito
- .mock(VXGroupPermission.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito.mock(XXGroupPermissionDao.class);
+ VXGroupPermission vXGroupPermission = Mockito.mock(VXGroupPermission.class);
XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
XXModuleDef xModuleDef = Mockito.mock(XXModuleDef.class);
- VXUserPermission vXUserPermission = Mockito
- .mock(VXUserPermission.class);
+ VXUserPermission vXUserPermission = Mockito.mock(VXUserPermission.class);
VXPortalUser userProfile = userProfile();
@@ -976,75 +1069,56 @@ public class TestUserMgr {
Mockito.when(userDao.update(user)).thenReturn(user);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
- Mockito.when(roleDao.findByParentId(Mockito.anyLong()))
- .thenReturn(list);
-
- Mockito.when(daoManager.getXXUserPermission()).thenReturn(
- xUserPermissionDao);
- Mockito.when(
- xUserPermissionDao
- .findByUserPermissionIdAndIsAllowed(userProfile.getId()))
- .thenReturn(xUserPermissionsList);
-
- Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
- xGroupPermissionDao);
- Mockito.when(
- xGroupPermissionDao.findbyVXPortalUserId(userProfile.getId()))
- .thenReturn(xGroupPermissionList);
-
- Mockito.when(
- xGroupPermissionService.populateViewBean(xGroupPermissionObj))
- .thenReturn(vXGroupPermission);
+ Mockito.when(roleDao.findByParentId(Mockito.anyLong())).thenReturn(list);
+
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermissionDao);
+ Mockito.when(xUserPermissionDao.findByUserPermissionIdAndIsAllowed(userProfile.getId())).thenReturn(xUserPermissionsList);
+
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(xGroupPermissionDao);
+ Mockito.when(xGroupPermissionDao.findbyVXPortalUserId(userProfile.getId())).thenReturn(xGroupPermissionList);
+
+ Mockito.when(xGroupPermissionService.populateViewBean(xGroupPermissionObj)).thenReturn(vXGroupPermission);
Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
- Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong()))
- .thenReturn(xModuleDef);
-
- Mockito.when(
- xUserPermissionService.populateViewBean(xUserPermissionObj))
- .thenReturn(vXUserPermission);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
- VXPortalUser dbVXPortalUser = userMgr.deactivateUser(user);
+ Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong())).thenReturn(xModuleDef);
+
+ Mockito.when(xUserPermissionService.populateViewBean(xUserPermissionObj)).thenReturn(vXUserPermission);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ VXPortalUser dbVXPortalUser = userMgr.deactivateUser(null);
+ Assert.assertNull(dbVXPortalUser);
+ dbVXPortalUser = userMgr.deactivateUser(user);
Assert.assertNotNull(dbVXPortalUser);
Assert.assertEquals(user.getId(), dbVXPortalUser.getId());
Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
- Assert.assertEquals(user.getFirstName(), dbVXPortalUser.getFirstName());
Assert.assertEquals(user.getLastName(), dbVXPortalUser.getLastName());
Assert.assertEquals(user.getLoginId(), dbVXPortalUser.getLoginId());
Mockito.verify(daoManager).getXXPortalUser();
Mockito.verify(daoManager).getXXUserPermission();
Mockito.verify(daoManager).getXXGroupPermission();
- Mockito.verify(xUserPermissionService).populateViewBean(
- xUserPermissionObj);
- Mockito.verify(xGroupPermissionService).populateViewBean(
- xGroupPermissionObj);
+ Mockito.verify(xUserPermissionService).populateViewBean(xUserPermissionObj);
+ Mockito.verify(xGroupPermissionService).populateViewBean(xGroupPermissionObj);
}
@Test
- public void test30checkAccess() {
+ public void test20checkAccess() {
setup();
XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
Mockito.when(xPortalUserDao.getById(userId)).thenReturn(xPortalUser);
-
userMgr.checkAccess(userId);
- Mockito.verify(daoManager).getXXPortalUser();
}
@Test
- public void test31getUserProfile() {
+ public void test21getUserProfile() {
setup();
XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
- XXUserPermissionDao xUserPermissionDao = Mockito
- .mock(XXUserPermissionDao.class);
- XXGroupPermissionDao xGroupPermissionDao = Mockito
- .mock(XXGroupPermissionDao.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito.mock(XXGroupPermissionDao.class);
- XXPortalUserRoleDao xPortalUserRoleDao = Mockito
- .mock(XXPortalUserRoleDao.class);
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito.mock(XXPortalUserRoleDao.class);
List<XXPortalUserRole> xPortalUserRoleList = new ArrayList<XXPortalUserRole>();
XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
@@ -1077,45 +1151,62 @@ public class TestUserMgr {
xGroupPermissionList.add(xGroupPermissionObj);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
- Mockito.when(xPortalUserDao.getById(userId)).thenReturn(xPortalUser);
- Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(
- xPortalUserRoleDao);
- Mockito.when(daoManager.getXXUserPermission()).thenReturn(
- xUserPermissionDao);
+ Mockito.when(xPortalUserDao.getById(userId)).thenReturn(null);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(xPortalUserRoleDao);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermissionDao);
- Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
- xGroupPermissionDao);
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(xGroupPermissionDao);
VXPortalUser dbVXPortalUser = userMgr.getUserProfile(userId);
+ Mockito.when(xPortalUserDao.getById(userId)).thenReturn(xPortalUser);
+ dbVXPortalUser = userMgr.getUserProfile(userId);
Assert.assertNotNull(dbVXPortalUser);
-
- Mockito.verify(daoManager).getXXPortalUser();
- Mockito.verify(daoManager).getXXUserPermission();
- Mockito.verify(daoManager).getXXUserPermission();
- Mockito.verify(daoManager).getXXGroupPermission();
}
@Test
- public void test32getUserProfileByLoginId() {
+ public void test22getUserProfileByLoginId() {
setup();
XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
-
+ VXPortalUser userProfile = userProfile();
+ XXPortalUser user = new XXPortalUser();
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setFirstName(userProfile.getFirstName());
+ user.setLastName(userProfile.getLastName());
+ user.setLoginId(userProfile.getLoginId());
+ user.setPassword(userProfile.getPassword());
+ user.setUserSource(userProfile.getUserSource());
+ user.setPublicScreenName(userProfile.getPublicScreenName());
+ user.setId(userProfile.getId());
VXPortalUser dbVXPortalUser = userMgr.getUserProfileByLoginId();
- Assert.assertNull(dbVXPortalUser);
-
- Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.when(xPortalUserDao.findByLoginId(Mockito.anyString())).thenReturn(user);
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(xPortalUserRoleDao);
+ List<XXPortalUserRole> xPortalUserRoleList = new ArrayList<XXPortalUserRole>();
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ xPortalUserRoleList.add(XXPortalUserRole);
+ Mockito.when(xPortalUserRoleDao.findByParentId(Mockito.anyLong())).thenReturn(xPortalUserRoleList);
+ XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito.mock(XXGroupPermissionDao.class);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermissionDao);
+ List<XXUserPermission> xUserPermissionsList = new ArrayList<XXUserPermission>();
+ List<XXGroupPermission> xGroupPermissionList = new ArrayList<XXGroupPermission>();
+ Mockito.when(xUserPermissionDao.findByUserPermissionIdAndIsAllowed(userProfile.getId())).thenReturn(xUserPermissionsList);
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(xGroupPermissionDao);
+ Mockito.when(xGroupPermissionDao.findbyVXPortalUserId(userProfile.getId())).thenReturn(xGroupPermissionList);
+ dbVXPortalUser = userMgr.getUserProfileByLoginId(user.getLoginId());
+ Assert.assertNotNull(dbVXPortalUser);
}
@Test
- public void test33setUserRoles() {
+ public void test23setUserRoles() {
setup();
- XXPortalUserRoleDao xPortalUserRoleDao = Mockito
- .mock(XXPortalUserRoleDao.class);
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito.mock(XXPortalUserRoleDao.class);
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
- XXUserPermissionDao xUserPermissionDao = Mockito
- .mock(XXUserPermissionDao.class);
- XXGroupPermissionDao xGroupPermissionDao = Mockito
- .mock(XXGroupPermissionDao.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito.mock(XXGroupPermissionDao.class);
XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
VXPortalUser userProfile = userProfile();
@@ -1192,47 +1283,31 @@ public class TestUserMgr {
userPermission.setUserName("xyz");
userPermission.setOwner("admin");
- Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(
- xPortalUserRoleDao);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(xPortalUserRoleDao);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
Mockito.when(userDao.getById(userId)).thenReturn(user);
- Mockito.when(daoManager.getXXUserPermission()).thenReturn(
- xUserPermissionDao);
- Mockito.when(
- xUserPermissionDao
- .findByUserPermissionIdAndIsAllowed(userProfile.getId()))
- .thenReturn(xUserPermissionsList);
- Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
- xGroupPermissionDao);
- Mockito.when(
- xGroupPermissionDao.findbyVXPortalUserId(userProfile.getId()))
- .thenReturn(xGroupPermissionList);
- Mockito.when(
- xGroupPermissionService.populateViewBean(xGroupPermissionObj))
- .thenReturn(groupPermission);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermissionDao);
+ Mockito.when(xUserPermissionDao.findByUserPermissionIdAndIsAllowed(userProfile.getId())).thenReturn(xUserPermissionsList);
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(xGroupPermissionDao);
+ Mockito.when(xGroupPermissionDao.findbyVXPortalUserId(userProfile.getId())).thenReturn(xGroupPermissionList);
+ Mockito.when(xGroupPermissionService.populateViewBean(xGroupPermissionObj)).thenReturn(groupPermission);
Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
- Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong()))
- .thenReturn(xModuleDef);
- Mockito.when(
- xUserPermissionService.populateViewBean(xUserPermissionObj))
- .thenReturn(userPermission);
+ Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong())).thenReturn(xModuleDef);
+ Mockito.when(xUserPermissionService.populateViewBean(xUserPermissionObj)).thenReturn(userPermission);
Mockito.when(daoManager.getXXModuleDef()).thenReturn(xModuleDefDao);
- Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong()))
- .thenReturn(xModuleDef);
- Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.when(xModuleDefDao.findByModuleId(Mockito.anyLong())).thenReturn(xModuleDef);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
userMgr.checkAccess(userId);
userMgr.setUserRoles(userId, vStringRolesList);
Mockito.verify(daoManager).getXXUserPermission();
Mockito.verify(daoManager).getXXGroupPermission();
- Mockito.verify(xGroupPermissionService).populateViewBean(
- xGroupPermissionObj);
- Mockito.verify(xUserPermissionService).populateViewBean(
- xUserPermissionObj);
+ Mockito.verify(xGroupPermissionService).populateViewBean(xGroupPermissionObj);
+ Mockito.verify(xUserPermissionService).populateViewBean(xUserPermissionObj);
}
@Test
- public void test19updateRoles() {
+ public void test24updateRoles() {
setup();
Collection<String> rolesList = new ArrayList<String>();
rolesList.add("ROLE_USER");
@@ -1250,7 +1325,7 @@ public class TestUserMgr {
}
@Test
- public void test20UpdateUserWithPass() {
+ public void test25updatePasswordInSHA256() {
XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
VXPortalUser userProfile = userProfile();
String userName = userProfile.getFirstName();
@@ -1261,17 +1336,470 @@ public class TestUserMgr {
user.setLastName(userProfile.getLastName());
user.setLoginId(userProfile.getLoginId());
user.setPassword(userProfile.getPassword());
- user.setUserSource(userProfile.getUserSource());
+ user.setUserSource(RangerCommonEnums.USER_APP);
user.setPublicScreenName(userProfile.getPublicScreenName());
user.setId(userProfile.getId());
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
- Mockito.when(userDao.findByLoginId(Mockito.anyString())).thenReturn(
- user);
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
Mockito.when(userDao.update(user)).thenReturn(user);
- XXPortalUser dbXXPortalUser = userMgr.updatePasswordInSHA256(userName,
- userPassword,false);
+ XXPortalUser dbXXPortalUser = userMgr.updatePasswordInSHA256(null,userPassword,false);
+ Assert.assertNull(dbXXPortalUser);
+ Mockito.when(userDao.findByLoginId(Mockito.anyString())).thenReturn(null);
+ dbXXPortalUser = userMgr.updatePasswordInSHA256(userName,userPassword,false);
+ Assert.assertNull(dbXXPortalUser);
+ Mockito.when(userDao.findByLoginId(Mockito.anyString())).thenReturn(user);
+ dbXXPortalUser = userMgr.updatePasswordInSHA256(userName,userPassword,true);
+ Assert.assertNotNull(dbXXPortalUser);
+ dbXXPortalUser = userMgr.updatePasswordInSHA256(userName,"Secret",true);
Assert.assertNotNull(dbXXPortalUser);
+
}
+ @Test
+ public void test26CreateUser() {
+ setup();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+
+ VXPortalUser userProfile = userProfile();
+
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+
+ XXPortalUser user = new XXPortalUser();
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setFirstName(userProfile.getFirstName());
+ user.setLastName(userProfile.getLastName());
+ user.setLoginId(userProfile.getLoginId());
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ user.setPassword(encryptedPwd);
+ user.setUserSource(userProfile.getUserSource());
+ user.setPublicScreenName(userProfile.getPublicScreenName());
+ user.setId(userProfile.getId());
+
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(user.getId());
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
+ list.add(XXPortalUserRole);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(userDao.create((XXPortalUser) Mockito.any())).thenReturn(user);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
+ Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
+ XXPortalUser dbxxPortalUser = userMgr.createUser(userProfile, 1,userRoleList);
+ Assert.assertNotNull(dbxxPortalUser);
+ userId = dbxxPortalUser.getId();
+ Assert.assertEquals(userId, dbxxPortalUser.getId());
+ Assert.assertEquals(userProfile.getFirstName(),dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getFirstName(),dbxxPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),dbxxPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),dbxxPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),dbxxPortalUser.getEmailAddress());
+ Assert.assertEquals(encryptedPwd,dbxxPortalUser.getPassword());
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(daoManager).getXXPortalUserRole();
+ }
+
+ @Test
+ public void test27UpdateUser() {
+ setup();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
+
+ VXPortalUser userProfile = userProfile();
+ XXPortalUser user = new XXPortalUser();
+ user.setId(userProfile.getId());
+ user.setLoginId(userProfile.getLoginId());
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setLoginId(userProfile.getLoginId());
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ user.setPassword(encryptedPwd);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(userDao.getById(userProfile.getId())).thenReturn(user);
+ Mockito.when(stringUtil.validateEmail(Mockito.anyString())).thenReturn(true);
+
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ XXPortalUser dbXXPortalUser = userMgr.updateUser(userProfile);
+ Assert.assertNotNull(dbXXPortalUser);
+ Assert.assertEquals(userId, dbXXPortalUser.getId());
+ Assert.assertEquals(userProfile.getFirstName(),dbXXPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getFirstName(),dbXXPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),dbXXPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),dbXXPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),dbXXPortalUser.getEmailAddress());
+ Assert.assertEquals(encryptedPwd,dbXXPortalUser.getPassword());
+ }
+
+ @Test
+ public void test28UpdateUser() {
+ setup();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
+
+ VXPortalUser userProfile = userProfile();
+ XXPortalUser user = new XXPortalUser();
+ user.setId(userProfile.getId());
+ user.setLoginId(userProfile.getLoginId());
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setLoginId(userProfile.getLoginId());
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ user.setPassword(encryptedPwd);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(userDao.getById(userProfile.getId())).thenReturn(null);
+ XXPortalUser dbXXPortalUser = userMgr.updateUser(userProfile);
+ Assert.assertNull(dbXXPortalUser);
+ user.setStatus(RangerCommonEnums.USER_EXTERNAL);
+ user.setFirstName("null");
+ user.setLastName("null");
+ Mockito.when(userDao.getById(userProfile.getId())).thenReturn(user);
+ Mockito.when(stringUtil.validateEmail(Mockito.anyString())).thenReturn(true);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.when(userDao.findByEmailAddress(Mockito.anyString())).thenReturn(user);
+ dbXXPortalUser = userMgr.updateUser(userProfile);
+ Assert.assertNotNull(dbXXPortalUser);
+ Assert.assertEquals(userId, dbXXPortalUser.getId());
+ Assert.assertEquals(userProfile.getLoginId(),dbXXPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),dbXXPortalUser.getEmailAddress());
+ Assert.assertEquals(encryptedPwd,dbXXPortalUser.getPassword());
+ }
+
+ @Test
+ public void test29UpdateOldUserName() {
+ setup();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
+ XXUserDao xXUserDao = Mockito.mock(XXUserDao.class);
+ VXPortalUser userProfile = userProfile();
+ String userLoginId = userProfile.getLoginId();
+ String newUserName= "newUserName";
+ String currentPassword = userProfile.getPassword();
+
+ XXPortalUser xXPortalUser = new XXPortalUser();
+ xXPortalUser.setEmailAddress(userProfile.getEmailAddress());
+ xXPortalUser.setFirstName(userProfile.getFirstName());
+ xXPortalUser.setLastName(userProfile.getLastName());
+ xXPortalUser.setLoginId(userProfile.getLoginId());
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ xXPortalUser.setPassword(encryptedPwd);
+ xXPortalUser.setUserSource(userProfile.getUserSource());
+ xXPortalUser.setPublicScreenName(userProfile.getPublicScreenName());
+ xXPortalUser.setId(userProfile.getId());
+ xXPortalUser.setUserSource(RangerCommonEnums.USER_APP);
+
+ XXUser xXUser = new XXUser();
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+ Collection<String> groupNameList = new ArrayList<String>();
+ groupNameList.add("Grp2");
+ xXUser.setId(userId);
+ xXUser.setDescription(userProfile.getPublicScreenName());
+ xXUser.setName(userProfile.getLoginId());
+
+ List<XXTrxLog> trxLogList = new ArrayList<XXTrxLog>();
+ XXTrxLog xTrxLogObj = new XXTrxLog();
+ xTrxLogObj.setAction("update");
+ xTrxLogObj.setAddedByUserId(userId);
+ xTrxLogObj.setAttributeName("User Name");
+ xTrxLogObj.setCreateTime(new Date());
+ xTrxLogObj.setId(userId);
+ xTrxLogObj.setPreviousValue(userLoginId);
+ xTrxLogObj.setNewValue(newUserName);
+ xTrxLogObj.setObjectClassType(AppConstants.CLASS_TYPE_USER_PROFILE);
+ xTrxLogObj.setObjectName(xXPortalUser.getLoginId());
+ xTrxLogObj.setObjectId(userId);
+ xTrxLogObj.setParentObjectClassType(AppConstants.CLASS_TYPE_USER_PROFILE);
+ xTrxLogObj.setParentObjectId(userId);
+ xTrxLogObj.setUpdatedByUserId(xXPortalUser.getId());
+ trxLogList.add(xTrxLogObj);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(userDao.findByLoginId(userProfile.getLoginId())).thenReturn(xXPortalUser);
+ Mockito.when(daoManager.getXXUser()).thenReturn(xXUserDao);
+ Mockito.when(xXUserDao.findByUserName(xXUser.getName())).thenReturn(xXUser);
+
+ xXUser.setName(newUserName);
+ Mockito.when(xXUserDao.update(xXUser)).thenReturn(xXUser);
+
+ xXPortalUser.setLoginId(newUserName);
+ Mockito.when(userDao.update(xXPortalUser)).thenReturn(xXPortalUser);
+
+ xXPortalUser=userMgr.updateOldUserName(userLoginId, newUserName, currentPassword);
+
+ Assert.assertNotNull(xXPortalUser);
+ Assert.assertEquals(newUserName,xXPortalUser.getLoginId());
+ xXPortalUser.setUserSource(RangerCommonEnums.USER_EXTERNAL);
+ Mockito.when(userDao.findByLoginId(userProfile.getLoginId())).thenReturn(xXPortalUser);
+ xXPortalUser=userMgr.updateOldUserName(userLoginId, newUserName, currentPassword);
+ xXPortalUser=userMgr.updateOldUserName(null, newUserName, currentPassword);
+ Mockito.when(userDao.findByLoginId(userProfile.getLoginId())).thenReturn(null);
+ xXPortalUser=userMgr.updateOldUserName(userLoginId, newUserName, currentPassword);
+ }
+
+ @Test
+ public void test30getRolesByLoginId() {
+ setup();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+
+ VXPortalUser userProfile = userProfile();
+ String userLoginId = userProfile.getLoginId();
+
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+
+ XXPortalUser user = new XXPortalUser();
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setFirstName(userProfile.getFirstName());
+ user.setLastName(userProfile.getLastName());
+ user.setLoginId(userProfile.getLoginId());
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ user.setPassword(encryptedPwd);
+ user.setUserSource(userProfile.getUserSource());
+ user.setPublicScreenName(userProfile.getPublicScreenName());
+ user.setId(userProfile.getId());
+
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(user.getId());
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
+ list.add(XXPortalUserRole);
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(userDao.findByLoginId(userProfile.getLoginId())).thenReturn(user);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
+ Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
+ Collection<String> roleList = userMgr.getRolesByLoginId(userLoginId);
+ Assert.assertNotNull(roleList);
+ Assert.assertEquals(userLoginId, user.getLoginId());
+ Assert.assertEquals(userRoleList, roleList);
+ roleList = userMgr.getRolesByLoginId(null);
+ Mockito.when(roleDao.findByUserId(userId)).thenReturn(null);
+ roleList = userMgr.getRolesByLoginId(userLoginId);
+ }
+
+ @Test
+ public void test31checkAccess() {
+ setup();
+ XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
+ userMgr.checkAccess(xPortalUser);
+ destroySession();
+ VXPortalUser userProfile = userProfile();
+ xPortalUser = xxPortalUser(userProfile);
+ xPortalUser.setId(userProfile.getId());
+ setupUser();
+ userMgr.checkAccess(xPortalUser);
+ }
+
+ @Test
+ public void test32checkAdminAccess() {
+ setup();
+ userMgr.checkAdminAccess();
+ }
+
+ @Test
+ public void test33checkAccessForUpdate() {
+ setup();
+ XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
+ userMgr.checkAccessForUpdate(xPortalUser);
+ }
+
+ @Test
+ public void test34updateRoleForExternalUsers() {
+ setupRangerUserSyncUser();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito.mock(XXUserPermissionDao.class);
+ Collection<String> existingRoleList = new ArrayList<String>();
+ existingRoleList.add(RangerConstants.ROLE_USER);
+ Collection<String> reqRoleList = new ArrayList<String>();
+ reqRoleList.add(RangerConstants.ROLE_SYS_ADMIN);
+
+ VXPortalUser userProfile = userProfile();
+ XXPortalUser user = new XXPortalUser();
+ user.setId(userProfile.getId());
+ user.setLoginId(userProfile.getLoginId());
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setLoginId(userProfile.getLoginId());
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ user.setPassword(encryptedPwd);
+
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userProfile.getId());
+ XXPortalUserRole.setUserRole(RangerConstants.ROLE_USER);
+ List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
+ list.add(XXPortalUserRole);
+
+ List<XXUserPermission> xUserPermissionsList = new ArrayList<XXUserPermission>();
+ XXUserPermission xUserPermissionObj = new XXUserPermission();
+ xUserPermissionObj.setAddedByUserId(userId);
+ xUserPermissionObj.setCreateTime(new Date());
+ xUserPermissionObj.setId(userId);
+ xUserPermissionObj.setIsAllowed(1);
+ xUserPermissionObj.setModuleId(1L);
+ xUserPermissionObj.setUpdatedByUserId(userId);
+ xUserPermissionObj.setUpdateTime(new Date());
+ xUserPermissionObj.setUserId(userId);
+ xUserPermissionsList.add(xUserPermissionObj);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
+ Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
+ Mockito.when(userDao.getById(userProfile.getId())).thenReturn(user);
+ Mockito.when(stringUtil.validateEmail(Mockito.anyString())).thenReturn(true);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(xUserPermissionDao);
+ Mockito.when(xUserPermissionDao.findByUserPermissionId(userProfile.getId())).thenReturn(xUserPermissionsList);
+ VXPortalUser dbVXPortalUser = userMgr.updateRoleForExternalUsers(reqRoleList,existingRoleList,userProfile);
+ Assert.assertNotNull(dbVXPortalUser);
+ Assert.assertEquals(userId, dbVXPortalUser.getId());
+ Assert.assertEquals(userProfile.getFirstName(),dbVXPortalUser.getFirstName());
+ Assert.assertEquals(userProfile.getLastName(),dbVXPortalUser.getLastName());
+ Assert.assertEquals(userProfile.getLoginId(),dbVXPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),dbVXPortalUser.getEmailAddress());
+ }
+
+ @Test
+ public void test35mapVXPortalUserToXXPortalUser() {
+ setup();
+ Collection<String> existingRoleList = new ArrayList<String>();
+ existingRoleList.add(RangerConstants.ROLE_USER);
+ Collection<String> reqRoleList = new ArrayList<String>();
+ reqRoleList.add(RangerConstants.ROLE_SYS_ADMIN);
+
+ VXPortalUser userProfile = userProfile();
+ userProfile.setFirstName("null");
+ userProfile.setLastName("null");
+ XXPortalUser user = new XXPortalUser();
+ user.setId(userProfile.getId());
+ user.setLoginId(userProfile.getLoginId());
+ user.setEmailAddress(userProfile.getEmailAddress());
+ user.setLoginId(userProfile.getLoginId());
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ user.setPassword(encryptedPwd);
+
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userProfile.getId());
+ XXPortalUserRole.setUserRole(RangerConstants.ROLE_USER);
+ List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
+ list.add(XXPortalUserRole);
+
+ List<XXUserPermission> xUserPermissionsList = new ArrayList<XXUserPermission>();
+ XXUserPermission xUserPermissionObj = new XXUserPermission();
+ xUserPermissionObj.setAddedByUserId(userId);
+ xUserPermissionObj.setCreateTime(new Date());
+ xUserPermissionObj.setId(userId);
+ xUserPermissionObj.setIsAllowed(1);
+ xUserPermissionObj.setModuleId(1L);
+ xUserPermissionObj.setUpdatedByUserId(userId);
+ xUserPermissionObj.setUpdateTime(new Date());
+ xUserPermissionObj.setUserId(userId);
+ xUserPermissionsList.add(xUserPermissionObj);
+ XXPortalUser dbVXPortalUser = userMgr.mapVXPortalUserToXXPortalUser(userProfile);
+ Assert.assertNotNull(dbVXPortalUser);
+ Assert.assertEquals(userProfile.getLoginId(),dbVXPortalUser.getLoginId());
+ Assert.assertEquals(userProfile.getEmailAddress(),dbVXPortalUser.getEmailAddress());
+ }
+
+ @Test
+ public void test36UpdateUser() {
+ setup();
+ XXPortalUserDao userDao = Mockito.mock(XXPortalUserDao.class);
+ VXPortalUser userProfile = userProfile();
+ XXPortalUser user = new XXPortalUser();
+ user.setId(userProfile.getId());
+ user.setLoginId(userProfile.getLoginId());
+ userProfile.setFirstName("User");
+ userProfile.setLastName("User");
+ Mockito.when(stringUtil.validateEmail(Mockito.anyString())).thenReturn(true);
+ String encryptedPwd = userMgr.encrypt(userProfile.getLoginId(),userProfile.getPassword());
+ user.setPassword(encryptedPwd);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
+ Mockito.when(userDao.getById(userProfile.getId())).thenReturn(user);
+ Mockito.doNothing().when(rangerBizUtil).blockAuditorRoleUser();
+ Mockito.when(stringUtil.toCamelCaseAllWords(Mockito.anyString())).thenReturn(userProfile.getFirstName());
+ XXPortalUser dbXXPortalUser = userMgr.updateUser(userProfile);
+ Assert.assertNotNull(dbXXPortalUser);
+ Mockito.when(stringUtil.isEmpty(Mockito.anyString())).thenReturn(true);
+ userProfile.setFirstName("null");
+ userProfile.setLastName("null");
+ userProfile.setEmailAddress("");
+ dbXXPortalUser = userMgr.updateUser(userProfile);
+ }
+
+ @Test
+ public void test37createUserSearchQuery() {
+ EntityManager entityManager = Mockito.mock(EntityManager.class);
+ String queryString="Select id,loginId,emailAddress,firstName,lastName,statusList,publicScreenName,status from XXPortalUser";
+ Query query = Mockito.mock(Query.class);
+ SearchCriteria searchCriteria = new SearchCriteria();
+ searchCriteria.setDistinct(true);
+ searchCriteria.setGetChildren(true);
+ searchCriteria.setGetCount(true);
+ searchCriteria.setMaxRows(12);
+ searchCriteria.setOwnerId(userId);
+ searchCriteria.setStartIndex(1);
+ searchCriteria.setSortBy("asc");
+ VXPortalUser vXPortalUser=userProfile();
+ List<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("ROLE_USER");
+ List<Integer> statusList = new ArrayList<Integer>();
+ statusList.add(1);
+ searchCriteria.addParam("roleList", userRoleList);
+ searchCriteria.addParam("userId", vXPortalUser.getId());
+ searchCriteria.addParam("loginId", vXPortalUser.getLoginId());
+ searchCriteria.addParam("emailAddress", vXPortalUser.getEmailAddress());
+ searchCriteria.addParam("firstName", vXPortalUser.getFirstName());
+ searchCriteria.addParam("lastName", vXPortalUser.getLastName());
+ searchCriteria.addParam("statusList", statusList);
+ searchCriteria.addParam("publicScreenName", vXPortalUser.getPublicScreenName());
+ searchCriteria.addParam("status", vXPortalUser.getStatus());
+ searchCriteria.addParam("familyScreenName", vXPortalUser.getPublicScreenName());
+ Mockito.when(daoManager.getEntityManager()).thenReturn(entityManager);
+ Mockito.when(entityManager.createQuery(Mockito.anyString())).thenReturn(query);
+ Query newQuery = userMgr.createUserSearchQuery(query.toString(),queryString,searchCriteria);
+ Assert.assertNotNull(newQuery);
+ userRoleList.add("ROLE_SYS_ADMIN");
+ statusList.add(0);
+ searchCriteria.addParam("statusList", statusList);
+ searchCriteria.addParam("roleList", userRoleList);
+ newQuery = userMgr.createUserSearchQuery(query.toString(),queryString,searchCriteria);
+ }
+
+ @Test
+ public void test38mapVXPortalUserToXXPortalUser() {
+ Collection<String> existingRoleList = new ArrayList<String>();
+ existingRoleList.add(RangerConstants.ROLE_USER);
+ VXPortalUser dbVXPortalUser = userMgr.mapXXPortalUserToVXPortalUser(null,existingRoleList);
+ XXPortalUser user = new XXPortalUser();
+ Assert.assertNull(dbVXPortalUser);
+ dbVXPortalUser = userMgr.mapXXPortalUserToVXPortalUser(user,existingRoleList);
+ Assert.assertNull(dbVXPortalUser);
+ }
+
+ @Test
+ public void test39gjUserToUserProfile() {
+ VXPortalUser vXPortalUser = new VXPortalUser();
+ XXPortalUser xXPortalUser = new XXPortalUser();
+ userMgr.gjUserToUserProfile(xXPortalUser,vXPortalUser);
+ }
+
+ @Test
+ public void test40deleteUserRole() {
+ XXPortalUserRole xXPortalUserRole = new XXPortalUserRole();
+ userMgr.deleteUserRole(1L,xXPortalUserRole);
+ }
+
+ @Test
+ public void test41mapXXPortalUserToVXPortalUserForDefaultAccount() {
+ VXPortalUser vXPortalUser=userProfile();
+ XXPortalUser xXPortalUser = xxPortalUser(vXPortalUser);
+ XXPortalUserRoleDao roleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ List<XXPortalUserRole> list = new ArrayList<XXPortalUserRole>();
+ list.add(XXPortalUserRole);
+ Mockito.when(roleDao.findByParentId(xXPortalUser.getId())).thenReturn(list);
+ VXPortalUser dbVXPortalUser = userMgr.mapXXPortalUserToVXPortalUserForDefaultAccount(xXPortalUser);
+ Assert.assertNotNull(dbVXPortalUser);
+ }
+
}