You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ranger.apache.org by ve...@apache.org on 2015/04/09 20:49:42 UTC
[4/5] incubator-ranger git commit: RANGER-203 : Add unit test cases
for Pluggable Service model
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/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 c514bfb..eedacaf 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
@@ -18,6 +18,7 @@ package org.apache.ranger.biz;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Date;
import java.util.List;
import javax.persistence.EntityManager;
@@ -28,19 +29,31 @@ import org.apache.ranger.common.ContextUtil;
import org.apache.ranger.common.MessageEnums;
import org.apache.ranger.common.RESTErrorUtil;
import org.apache.ranger.common.SearchCriteria;
+import org.apache.ranger.common.SearchUtil;
import org.apache.ranger.common.StringUtil;
import org.apache.ranger.common.UserSessionBase;
import org.apache.ranger.db.RangerDaoManager;
+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.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.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.XUserPermissionService;
+import org.apache.ranger.view.VXGroupPermission;
import org.apache.ranger.view.VXPasswordChange;
import org.apache.ranger.view.VXPortalUser;
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.Assert;
import org.junit.FixMethodOrder;
import org.junit.Rule;
@@ -78,8 +91,20 @@ public class TestUserMgr {
StringUtil stringUtil;
@Mock
+ SearchUtil searchUtil;
+
+ @Mock
RangerBizUtil msBizUtil;
+ @Mock
+ XUserPermissionService xUserPermissionService;
+
+ @Mock
+ XGroupPermissionService xGroupPermissionService;
+
+ @Mock
+ SessionMgr sessionMgr;
+
@Rule
public ExpectedException thrown = ExpectedException.none();
@@ -140,20 +165,25 @@ public class TestUserMgr {
XXPortalUser dbxxPortalUser = userMgr.createUser(userProfile, 1,
userRoleList);
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 test12CreateUser() {
@@ -186,15 +216,21 @@ public class TestUserMgr {
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();
@@ -227,12 +263,14 @@ public class TestUserMgr {
Mockito.when(
stringUtil.validatePassword(Mockito.anyString(),
new String[] { Mockito.anyString() })).thenReturn(true);
-
+
VXResponse dbVXResponse = userMgr.changePassword(pwdChange);
- Assert.assertNotNull(dbVXResponse);
- Assert.assertEquals(userProfile.getStatus(), dbVXResponse.getStatusCode());
-
- Mockito.verify(stringUtil).equals(Mockito.anyString(),Mockito.anyString());
+ Assert.assertNotNull(dbVXResponse);
+ Assert.assertEquals(userProfile.getStatus(),
+ dbVXResponse.getStatusCode());
+
+ Mockito.verify(stringUtil).equals(Mockito.anyString(),
+ Mockito.anyString());
Mockito.verify(stringUtil).validatePassword(Mockito.anyString(),
new String[] { Mockito.anyString() });
}
@@ -264,17 +302,21 @@ public class TestUserMgr {
+ changeEmail)).thenThrow(
new WebApplicationException());
thrown.expect(WebApplicationException.class);
-
- VXPortalUser dbVXPortalUser = userMgr.changeEmailAddress(user,changeEmail);
+
+ 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());
-
- Mockito.verify(restErrorUtil).createRESTException("serverMsg.userMgrEmailChange",
- MessageEnums.OPER_NO_PERMISSION, null, null, ""
- + changeEmail);
+ Assert.assertEquals(userId, dbVXPortalUser.getId());
+ Assert.assertEquals(userProfile.getLastName(),
+ dbVXPortalUser.getLastName());
+ Assert.assertEquals(changeEmail.getLoginId(),
+ dbVXPortalUser.getLoginId());
+ Assert.assertEquals(changeEmail.getEmailAddress(),
+ dbVXPortalUser.getEmailAddress());
+
+ Mockito.verify(restErrorUtil).createRESTException(
+ "serverMsg.userMgrEmailChange",
+ MessageEnums.OPER_NO_PERMISSION, null, null, "" + changeEmail);
}
@Test
@@ -302,16 +344,20 @@ public class TestUserMgr {
"emailAddress", changeEmail.toString())).thenThrow(
new WebApplicationException());
thrown.expect(WebApplicationException.class);
-
+
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());
-
- Mockito.verify(restErrorUtil).createRESTException("serverMsg.userMgrInvalidEmail",
+ Assert.assertEquals(userId, dbVXPortalUser.getId());
+ Assert.assertEquals(userProfile.getLastName(),
+ dbVXPortalUser.getLastName());
+ Assert.assertEquals(changeEmail.getLoginId(),
+ dbVXPortalUser.getLoginId());
+ Assert.assertEquals(changeEmail.getEmailAddress(),
+ dbVXPortalUser.getEmailAddress());
+
+ Mockito.verify(restErrorUtil).createRESTException(
+ "serverMsg.userMgrInvalidEmail",
MessageEnums.INVALID_INPUT_DATA, changeEmail.getId(),
"emailAddress", changeEmail.toString());
}
@@ -321,6 +367,10 @@ public class TestUserMgr {
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);
XXPortalUser user = new XXPortalUser();
VXPortalUser userProfile = userProfile();
@@ -331,23 +381,63 @@ public class TestUserMgr {
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);
+
+ List<XXGroupPermission> xGroupPermissionList = new ArrayList<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);
+ xGroupPermissionList.add(xGroupPermissionObj);
+
Mockito.when(daoManager.getXXPortalUser()).thenReturn(userDao);
Mockito.when(userDao.create((XXPortalUser) Mockito.anyObject()))
.thenReturn(user);
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
Mockito.when(roleDao.findByUserId(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.findbyVXPoratUserId(userProfile.getId()))
+ .thenReturn(xGroupPermissionList);
+
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.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();
+ Mockito.verify(daoManager).getXXUserPermission();
+ Mockito.verify(daoManager).getXXGroupPermission();
}
@Test
@@ -375,13 +465,14 @@ public class TestUserMgr {
.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.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();
Mockito.verify(daoManager).getXXPortalUserRole();
}
@@ -403,7 +494,7 @@ public class TestUserMgr {
boolean isValue = userMgr.isUserInRole(userId, "ROLE_USER");
Assert.assertTrue(isValue);
-
+
Mockito.verify(daoManager).getXXPortalUserRole();
}
@@ -423,18 +514,25 @@ public class TestUserMgr {
MessageEnums.INVALID_INPUT_DATA)).thenThrow(
new WebApplicationException());
thrown.expect(WebApplicationException.class);
-
+
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.",
+ 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);
}
@@ -450,17 +548,17 @@ public class TestUserMgr {
searchCriteria.setOwnerId(userId);
searchCriteria.setStartIndex(1);
searchCriteria.setSortBy("asc");
-
+ Long count = 1l;
Mockito.when(daoManager.getEntityManager()).thenReturn(entityManager);
Mockito.when(entityManager.createQuery(Mockito.anyString()))
.thenReturn(query);
-
+ Mockito.when(query.getSingleResult()).thenReturn(count);
+
VXPortalUserList dbVXPortalUserList = userMgr
.searchUsers(searchCriteria);
Assert.assertNotNull(dbVXPortalUserList);
-
- Mockito.verify(daoManager).getEntityManager();
+ Mockito.verify(query).getSingleResult();
}
@Test
@@ -476,7 +574,7 @@ public class TestUserMgr {
XXPortalUser dbXXPortalUser = userMgr.findByEmailAddress(emailId);
Assert.assertNotNull(dbXXPortalUser);
Assert.assertNotEquals(emailId, dbXXPortalUser.getEmailAddress());
-
+
Mockito.verify(daoManager).getXXPortalUser();
}
@@ -503,10 +601,10 @@ public class TestUserMgr {
Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(roleDao);
Mockito.when(roleDao.findByUserId(userId)).thenReturn(list);
-
+
Collection<String> stringReturn = userMgr.getRolesForUser(user);
Assert.assertNotNull(stringReturn);
-
+
Mockito.verify(daoManager).getXXPortalUserRole();
}
@@ -524,7 +622,7 @@ 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);
}
@@ -533,6 +631,17 @@ public class TestUserMgr {
public void test29DeactivateUser() {
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);
+ XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ XXModuleDef xModuleDef = Mockito.mock(XXModuleDef.class);
+ VXUserPermission vXUserPermission = Mockito
+ .mock(VXUserPermission.class);
+
VXPortalUser userProfile = userProfile();
XXPortalUser user = new XXPortalUser();
@@ -545,6 +654,30 @@ public class TestUserMgr {
user.setPublicScreenName(userProfile.getPublicScreenName());
user.setId(userProfile.getId());
+ 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<XXGroupPermission> xGroupPermissionList = new ArrayList<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);
+ xGroupPermissionList.add(xGroupPermissionObj);
+
XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
XXPortalUserRole.setId(userId);
XXPortalUserRole.setUserRole("ROLE_USER");
@@ -558,14 +691,160 @@ public class TestUserMgr {
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.findbyVXPoratUserId(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);
+
VXPortalUser 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.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);
+ }
+
+ @Test
+ public void test30checkAccess() {
+ 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() {
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
+ XXUserPermissionDao xUserPermissionDao = Mockito
+ .mock(XXUserPermissionDao.class);
+ XXGroupPermissionDao xGroupPermissionDao = Mockito
+ .mock(XXGroupPermissionDao.class);
+
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito
+ .mock(XXPortalUserRoleDao.class);
+
+ List<XXPortalUserRole> xPortalUserRoleList = new ArrayList<XXPortalUserRole>();
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ xPortalUserRoleList.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);
+
+ List<XXGroupPermission> xGroupPermissionList = new ArrayList<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);
+ xGroupPermissionList.add(xGroupPermissionObj);
+ VXPortalUser userProfile = userProfile();
+
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.getById(userId)).thenReturn(xPortalUser);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(
+ xPortalUserRoleDao);
+ Mockito.when(xPortalUserRoleDao.findByParentId(userId)).thenReturn(
+ xPortalUserRoleList);
+ Mockito.when(daoManager.getXXUserPermission()).thenReturn(
+ xUserPermissionDao);
+ Mockito.when(
+ xUserPermissionDao
+ .findByUserPermissionIdAndIsAllowed(userProfile.getId()))
+ .thenReturn(xUserPermissionsList);
+
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
+ xGroupPermissionDao);
+ Mockito.when(
+ xGroupPermissionDao.findbyVXPoratUserId(userProfile.getId()))
+ .thenReturn(xGroupPermissionList);
+ VXPortalUser 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() {
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ XXPortalUser xPortalUser = Mockito.mock(XXPortalUser.class);
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.findByLoginId("1L"))
+ .thenReturn(xPortalUser);
+
+ VXPortalUser dbVXPortalUser = userMgr.getUserProfileByLoginId();
+ Assert.assertNull(dbVXPortalUser);
+
+ Mockito.verify(daoManager).getXXPortalUser();
+ }
+
+ @Test
+ public void test33setUserRoles() {
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito.mock(XXPortalUserRoleDao.class);
+ List<VXString> vStringRolesList = new ArrayList<VXString>();
+ VXString vXStringObj = new VXString();
+ vXStringObj.setValue("1L");
+ vStringRolesList.add(vXStringObj);
+
+ List<XXPortalUserRole> xPortalUserRoleList = new ArrayList<XXPortalUserRole>();
+ XXPortalUserRole XXPortalUserRole = new XXPortalUserRole();
+ XXPortalUserRole.setId(userId);
+ XXPortalUserRole.setUserRole("ROLE_USER");
+ xPortalUserRoleList.add(XXPortalUserRole);
+
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(xPortalUserRoleDao);
+ Mockito.when(xPortalUserRoleDao.findByUserId(userId))
+ .thenReturn(xPortalUserRoleList);
+ userMgr.setUserRoles(userId, vStringRolesList);
}
-}
\ No newline at end of file
+}
http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/376d3249/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 4ae1d02..4fba6df 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
@@ -18,8 +18,10 @@ package org.apache.ranger.biz;
import java.util.ArrayList;
import java.util.Collection;
+import java.util.Date;
import java.util.HashMap;
import java.util.List;
+import java.util.Set;
import org.apache.ranger.common.ContextUtil;
import org.apache.ranger.common.RESTErrorUtil;
@@ -28,23 +30,40 @@ import org.apache.ranger.common.StringUtil;
import org.apache.ranger.common.UserSessionBase;
import org.apache.ranger.db.RangerDaoManager;
import org.apache.ranger.db.XXGroupDao;
+import org.apache.ranger.db.XXGroupPermissionDao;
import org.apache.ranger.db.XXGroupUserDao;
+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.XXGroup;
+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.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.XGroupService;
import org.apache.ranger.service.XGroupUserService;
+import org.apache.ranger.service.XModuleDefService;
+import org.apache.ranger.service.XPortalUserService;
+import org.apache.ranger.service.XUserPermissionService;
import org.apache.ranger.service.XUserService;
import org.apache.ranger.view.VXGroup;
import org.apache.ranger.view.VXGroupList;
+import org.apache.ranger.view.VXGroupPermission;
import org.apache.ranger.view.VXGroupUser;
import org.apache.ranger.view.VXGroupUserList;
+import org.apache.ranger.view.VXModuleDef;
import org.apache.ranger.view.VXPortalUser;
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.junit.Assert;
import org.junit.FixMethodOrder;
import org.junit.Rule;
@@ -61,8 +80,8 @@ import org.mockito.runners.MockitoJUnitRunner;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class TestXUserMgr {
- private static Long userId = 10L;
-
+ private static Long userId = 8L;
+
private static Integer emptyValue;
@InjectMocks
@@ -92,6 +111,24 @@ public class TestXUserMgr {
@Mock
XUserService xUserService;
+ @Mock
+ XModuleDefService xModuleDefService;
+
+ @Mock
+ XUserPermissionService xUserPermissionService;
+
+ @Mock
+ XGroupPermissionService xGroupPermissionService;
+
+ @Mock
+ ContextUtil contextUtil;
+
+ @Mock
+ RangerSecurityContext rangerSecurityContext;
+
+ @Mock
+ XPortalUserService xPortalUserService;
+
@Rule
public ExpectedException thrown = ExpectedException.none();
@@ -118,17 +155,78 @@ public class TestXUserMgr {
return vxUser;
}
+ private VXModuleDef vXModuleDef() {
+ VXUserPermission userPermission = vXUserPermission();
+ List<VXUserPermission> userPermList = new ArrayList<VXUserPermission>();
+ userPermList.add(userPermission);
+
+ VXGroupPermission groupPermission = vXGroupPermission();
+ List<VXGroupPermission> groupPermList = new ArrayList<VXGroupPermission>();
+ groupPermList.add(groupPermission);
+
+ VXModuleDef vxModuleDef = new VXModuleDef();
+ vxModuleDef.setAddedById(userId);
+ vxModuleDef.setCreateDate(new Date());
+ vxModuleDef.setCreateTime(new Date());
+ vxModuleDef.setId(userId);
+ vxModuleDef.setModule("Policy manager");
+ vxModuleDef.setOwner("admin");
+ vxModuleDef.setUpdateDate(new Date());
+ vxModuleDef.setUpdatedBy("admin");
+ vxModuleDef.setUpdatedById(userId);
+ vxModuleDef.setUpdateTime(new Date());
+ vxModuleDef.setUrl("/policy manager");
+ vxModuleDef.setUserPermList(userPermList);
+ vxModuleDef.setGroupPermList(groupPermList);
+
+ return vxModuleDef;
+ }
+
+ private VXUserPermission vXUserPermission() {
+ VXUserPermission userPermission = new VXUserPermission();
+ userPermission.setId(1L);
+ userPermission.setIsAllowed(1);
+ userPermission.setModuleId(1L);
+ userPermission.setUserId(userId);
+ userPermission.setUserName("xyz");
+ userPermission.setOwner("admin");
+
+ return userPermission;
+ }
+
+ private VXGroupPermission vXGroupPermission() {
+ VXGroupPermission groupPermission = new VXGroupPermission();
+ groupPermission.setId(1L);
+ groupPermission.setIsAllowed(1);
+ groupPermission.setModuleId(1L);
+ groupPermission.setGroupId(userId);
+ groupPermission.setGroupName("xyz");
+ groupPermission.setOwner("admin");
+
+ return groupPermission;
+ }
+
@Test
public void test11CreateXUser() {
-
- setup();
VXUser vxUser = vxUser();
+ Collection<String> userRoleList = new ArrayList<String>();
+ userRoleList.add("test");
+ vxUser.setUserRoleList(userRoleList);
+
+ ArrayList<String> userRoleListVXPortaUser = new ArrayList<String>();
VXPortalUser vXPortalUser = new VXPortalUser();
+ vXPortalUser.setUserRoleList(userRoleListVXPortaUser);
- Mockito.when(userMgr.createDefaultAccountUser(vXPortalUser))
- .thenReturn(vXPortalUser);
Mockito.when(xUserService.createResource(vxUser)).thenReturn(vxUser);
+ XXModuleDefDao value = Mockito.mock(XXModuleDefDao.class);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(value);
+ List<XXModuleDef> lsvalue = new ArrayList<XXModuleDef>();
+ Mockito.when(value.findModuleNamesWithIds()).thenReturn(lsvalue);
+
+ Mockito.when(
+ userMgr.createDefaultAccountUser((VXPortalUser) Mockito
+ .anyObject())).thenReturn(vXPortalUser);
VXUser dbUser = xUserMgr.createXUser(vxUser);
Assert.assertNotNull(dbUser);
@@ -139,12 +237,17 @@ public class TestXUserMgr {
Assert.assertEquals(dbUser.getUserRoleList(), vxUser.getUserRoleList());
Assert.assertEquals(dbUser.getGroupNameList(),
vxUser.getGroupNameList());
-
+
Mockito.verify(xUserService).createResource(vxUser);
Mockito.when(xUserService.readResourceWithOutLogin(userId)).thenReturn(
vxUser);
VXUser dbvxUser = xUserMgr.getXUser(userId);
+
+ Mockito.verify(userMgr).createDefaultAccountUser(
+ (VXPortalUser) Mockito.anyObject());
+ Mockito.verify(daoManager).getXXModuleDef();
+ Mockito.verify(value).findModuleNamesWithIds();
Assert.assertNotNull(dbvxUser);
Assert.assertEquals(userId, dbvxUser.getId());
Assert.assertEquals(dbvxUser.getDescription(), vxUser.getDescription());
@@ -174,16 +277,16 @@ public class TestXUserMgr {
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
- Mockito.when(xUserService.updateResource(vxUser)).thenReturn(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());
@@ -191,45 +294,45 @@ public class TestXUserMgr {
Mockito.verify(daoManager).getXXUser();
Mockito.verify(xUserService).populateViewBean(xxUser);
}
-
+
@Test
public void test14ModifyUserVisibilitySetZero() {
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
- Mockito.when(xUserService.updateResource(vxUser)).thenReturn(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);
+
+ xUserMgr.modifyUserVisibility(visibilityMap);
Assert.assertEquals(value, vxUser.getIsVisible());
Assert.assertEquals(userId, vxUser.getId());
Mockito.verify(xUserService).updateResource(vxUser);
Mockito.verify(daoManager).getXXUser();
Mockito.verify(xUserService).populateViewBean(xxUser);
}
-
+
@Test
public void test15ModifyUserVisibilitySetEmpty() {
XXUserDao xxUserDao = Mockito.mock(XXUserDao.class);
XXUser xxUser = Mockito.mock(XXUser.class);
VXUser vxUser = vxUser();
-
- Mockito.when(xUserService.updateResource(vxUser)).thenReturn(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);
+
+ xUserMgr.modifyUserVisibility(visibilityMap);
Assert.assertEquals(emptyValue, vxUser.getIsVisible());
Assert.assertEquals(userId, vxUser.getId());
Mockito.verify(xUserService).updateResource(vxUser);
@@ -263,7 +366,7 @@ public class TestXUserMgr {
Assert.assertEquals(dbXGroup.getDescription(),
dbxGroup.getDescription());
Assert.assertEquals(dbXGroup.getName(), dbxGroup.getName());
- Mockito.verify(xGroupService).readResourceWithOutLogin(userId);
+ Mockito.verify(xGroupService).readResourceWithOutLogin(userId);
}
@Test
@@ -287,87 +390,90 @@ public class TestXUserMgr {
Assert.assertEquals(vXGroup.getDescription(),
dbvxGroup.getDescription());
Assert.assertEquals(vXGroup.getName(), dbvxGroup.getName());
- Mockito.verify(daoManager).getXXGroup();
- Mockito.verify(xGroupService).updateResource(vXGroup);
+ Mockito.verify(daoManager).getXXGroup();
+ Mockito.verify(xGroupService).updateResource(vXGroup);
}
@Test
public void test18ModifyGroupsVisibilitySetOne() {
- XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
+ XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
- XXGroup xxGroup = new XXGroup();
+ 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());
+ Assert.assertEquals(userId, vXGroup.getId());
Mockito.verify(daoManager).getXXGroup();
Mockito.verify(xGroupService).populateViewBean(xxGroup);
Mockito.verify(xGroupService).updateResource(vXGroup);
}
-
+
@Test
public void test19ModifyGroupsVisibilitySetZero() {
- XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
+ XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
- XXGroup xxGroup = new XXGroup();
+ 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());
+ Assert.assertEquals(userId, vXGroup.getId());
Mockito.verify(daoManager).getXXGroup();
Mockito.verify(xGroupService).populateViewBean(xxGroup);
Mockito.verify(xGroupService).updateResource(vXGroup);
}
-
+
@Test
public void test20ModifyGroupsVisibilitySetEmpty() {
- XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
+ XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
- XXGroup xxGroup = new XXGroup();
+ 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());
+ Assert.assertEquals(userId, vXGroup.getId());
Mockito.verify(daoManager).getXXGroup();
Mockito.verify(xGroupService).populateViewBean(xxGroup);
Mockito.verify(xGroupService).updateResource(vXGroup);
}
-
+
@Test
public void test21createXGroupUser() {
VXGroupUser vxGroupUser = new VXGroupUser();
@@ -390,14 +496,15 @@ public class TestXUserMgr {
Assert.assertEquals(dbVXGroupUser.getUserId(), vxGroupUser.getUserId());
Assert.assertEquals(dbVXGroupUser.getUpdatedBy(),
vxGroupUser.getUpdatedBy());
- Mockito.verify(xGroupUserService).createXGroupUserWithOutLogin(vxGroupUser);
+ 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");
+ vXGroup.setId(userId);
+ vXGroup.setDescription("group test");
+ vXGroup.setName("grouptest");
VXGroupUser dbvxGroupUser = xUserMgr.getXGroupUser(userId);
Assert.assertNotNull(dbvxGroupUser);
@@ -408,7 +515,7 @@ public class TestXUserMgr {
Assert.assertEquals(dbvxGroupUser.getUserId(), vxGroupUser.getUserId());
Assert.assertEquals(dbvxGroupUser.getUpdatedBy(),
vxGroupUser.getUpdatedBy());
- Mockito.verify(xGroupUserService).readResourceWithOutLogin(userId);
+ Mockito.verify(xGroupUserService).readResourceWithOutLogin(userId);
}
@Test
@@ -419,7 +526,8 @@ public class TestXUserMgr {
@Test
public void test23GetXGroupUsers() {
- VXUserList dbVXUserList = xUserMgr.getXGroupUsers(userId);VXGroup vXGroup = new VXGroup();
+ VXUserList dbVXUserList = xUserMgr.getXGroupUsers(userId);
+ VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
@@ -440,16 +548,16 @@ public class TestXUserMgr {
Assert.assertEquals(userId, dbVXUser.getId());
Assert.assertEquals(dbVXUser.getName(), vxUser.getName());
Assert.assertEquals(dbVXUser.getOwner(), vxUser.getOwner());
- Mockito.verify(xUserService).getXUserByUserName(userName);
+ Mockito.verify(xUserService).getXUserByUserName(userName);
}
@Test
- public void test25CreateXUserWithOutLogin(){
+ public void test25CreateXUserWithOutLogin() {
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();
@@ -459,29 +567,30 @@ public class TestXUserMgr {
Assert.assertEquals(dbUser.getUserRoleList(), vxUser.getUserRoleList());
Assert.assertEquals(dbUser.getGroupNameList(),
vxUser.getGroupNameList());
- Mockito.verify(xUserService).createXUserWithOutLogin(vxUser);
+ Mockito.verify(xUserService).createXUserWithOutLogin(vxUser);
}
-
+
@Test
- public void test26CreateXGroupWithoutLogin(){
+ public void test26CreateXGroupWithoutLogin() {
VXGroup vXGroup = new VXGroup();
vXGroup.setId(userId);
vXGroup.setDescription("group test");
vXGroup.setName("grouptest");
-
+
Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup))
- .thenReturn(vXGroup);
-
- VXGroup dbVXGroup = xUserMgr.createXGroupWithoutLogin(vXGroup);
- Assert.assertNotNull(dbVXGroup);
+ .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);
+ Mockito.verify(xGroupService).createXGroupWithOutLogin(vXGroup);
}
-
+
@Test
public void test27DeleteXGroup() {
XXGroupDao xxGroupDao = Mockito.mock(XXGroupDao.class);
@@ -497,7 +606,8 @@ public class TestXUserMgr {
Mockito.when(xxGroupDao.getById(userId)).thenReturn(xxGroup);
xUserMgr.deleteXGroup(userId, force);
- Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito.anyObject());
+ Mockito.verify(xGroupUserService).searchXGroupUsers(
+ (SearchCriteria) Mockito.anyObject());
}
@Test
@@ -515,8 +625,8 @@ public class TestXUserMgr {
Mockito.when(xxUserDao.remove(userId)).thenReturn(true);
xUserMgr.deleteXUser(userId, force);
- Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito
- .anyObject());
+ Mockito.verify(xGroupUserService).searchXGroupUsers(
+ (SearchCriteria) Mockito.anyObject());
Mockito.verify(daoManager).getXXGroupUser();
Mockito.verify(daoManager).getXXUser();
}
@@ -541,56 +651,479 @@ public class TestXUserMgr {
xUserMgr.deleteXGroupAndXUser(groupName, userName);
Mockito.verify(xGroupService).getGroupByGroupName(Mockito.anyString());
Mockito.verify(xUserService).getXUserByUserName(Mockito.anyString());
- Mockito.verify(xGroupUserService).searchXGroupUsers((SearchCriteria) Mockito
- .anyObject());
+ Mockito.verify(xGroupUserService).searchXGroupUsers(
+ (SearchCriteria) Mockito.anyObject());
}
-
+
@Test
- public void test30CreateVXUserGroupInfo(){
-
+ public void test30CreateVXUserGroupInfo() {
+
VXUserGroupInfo vXUserGroupInfo = new VXUserGroupInfo();
VXUser vXUser = new VXUser();
vXUser.setName("user1");
vXUser.setDescription("testuser1 -added for unit testing");
-
+
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);
- Mockito.when(xGroupUserService.createXGroupUserWithOutLogin(vXGroupUser1)).thenReturn(vXGroupUser1);
- Mockito.when(xGroupUserService.createXGroupUserWithOutLogin(vXGroupUser2)).thenReturn(vXGroupUser2);
-
- VXUserGroupInfo vxUserGroupTest = xUserMgr.createXUserGroupFromMap(vXUserGroupInfo);
- Assert.assertEquals("user1", vxUserGroupTest
- .getXuserInfo()
- .getName());
+
+ Mockito.when(xUserService.createXUserWithOutLogin(vXUser)).thenReturn(
+ vXUser);
+ Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup1))
+ .thenReturn(vXGroup1);
+ Mockito.when(xGroupService.createXGroupWithOutLogin(vXGroup2))
+ .thenReturn(vXGroup2);
+ Mockito.when(
+ xGroupUserService.createXGroupUserWithOutLogin(vXGroupUser1))
+ .thenReturn(vXGroupUser1);
+ Mockito.when(
+ xGroupUserService.createXGroupUserWithOutLogin(vXGroupUser2))
+ .thenReturn(vXGroupUser2);
+
+ 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));
- }
-}
\ No newline at end of file
+ }
+
+ // Module permission
+ @Test
+ public void test31createXModuleDefPermission() {
+ VXModuleDef vXModuleDef = vXModuleDef();
+
+ Mockito.when(xModuleDefService.createResource(vXModuleDef)).thenReturn(
+ vXModuleDef);
+
+ 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());
+ Mockito.verify(xModuleDefService).createResource(vXModuleDef);
+ }
+
+ @Test
+ public void test32getXModuleDefPermission() {
+ 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.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());
+
+ Mockito.verify(xModuleDefService).readResource(1L);
+ }
+
+ @Test
+ public void test33updateXModuleDefPermission() {
+ XXModuleDefDao xModuleDefDao = Mockito.mock(XXModuleDefDao.class);
+ XXModuleDef xModuleDef = Mockito.mock(XXModuleDef.class);
+
+ XXUserPermissionDao xUserPermissionDao = Mockito
+ .mock(XXUserPermissionDao.class);
+ XXUserPermission xUserPermission = Mockito.mock(XXUserPermission.class);
+
+ XXGroupPermissionDao xGroupPermissionDao = Mockito
+ .mock(XXGroupPermissionDao.class);
+ XXGroupPermission xGroupPermission = Mockito
+ .mock(XXGroupPermission.class);
+
+ VXUserPermission vXUserPermission = vXUserPermission();
+ VXGroupPermission vXGroupPermission = vXGroupPermission();
+ VXModuleDef vXModuleDef = vXModuleDef();
+
+ Mockito.when(xModuleDefService.updateResource(vXModuleDef)).thenReturn(
+ vXModuleDef);
+ Mockito.when(xGroupPermissionService.updateResource(vXGroupPermission))
+ .thenReturn(vXGroupPermission);
+ Mockito.when(xGroupPermissionService.createResource(vXGroupPermission))
+ .thenReturn(vXGroupPermission);
+ Mockito.when(xUserPermissionService.updateResource(vXUserPermission))
+ .thenReturn(vXUserPermission);
+ Mockito.when(xUserPermissionService.createResource(vXUserPermission))
+ .thenReturn(vXUserPermission);
+
+ 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(xUserPermissionDao.getById(userId)).thenReturn(
+ xUserPermission);
+ Mockito.when(xUserPermissionService.populateViewBean(xUserPermission))
+ .thenReturn(vXUserPermission);
+
+ Mockito.when(daoManager.getXXGroupPermission()).thenReturn(
+ xGroupPermissionDao);
+ Mockito.when(xGroupPermissionDao.getById(userId)).thenReturn(
+ xGroupPermission);
+ Mockito.when(xGroupPermissionService.populateViewBean(xGroupPermission))
+ .thenReturn(vXGroupPermission);
+
+ 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.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());
+
+ Mockito.verify(xModuleDefService).updateResource(vXModuleDef);
+ Mockito.verify(daoManager).getXXModuleDef();
+ Mockito.verify(xModuleDefService).populateViewBean(xModuleDef);
+ Mockito.verify(daoManager).getXXUserPermission();
+ Mockito.verify(daoManager).getXXGroupPermission();
+ }
+
+ @Test
+ public void test34deleteXModuleDefPermission() {
+
+ Mockito.when(xModuleDefService.deleteResource(1L)).thenReturn(true);
+ xUserMgr.deleteXModuleDefPermission(1L, true);
+ Mockito.verify(xModuleDefService).deleteResource(1L);
+ }
+
+ @Test
+ public void test35createXUserPermission() {
+ 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());
+
+ Mockito.verify(xUserPermissionService).createResource(vXUserPermission);
+ }
+
+ @Test
+ public void test36getXUserPermission() {
+ 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());
+
+ Mockito.verify(xUserPermissionService).readResource(1L);
+ }
+
+ @Test
+ public void test37updateXUserPermission() {
+ 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());
+
+ Mockito.verify(xUserPermissionService).updateResource(vXUserPermission);
+ }
+
+ @Test
+ public void test38deleteXUserPermission() {
+
+ Mockito.when(xUserPermissionService.deleteResource(1L))
+ .thenReturn(true);
+ xUserMgr.deleteXUserPermission(1L, true);
+ Mockito.verify(xUserPermissionService).deleteResource(1L);
+ }
+
+ @Test
+ public void test39createXGroupPermission() {
+ VXGroupPermission vXGroupPermission = vXGroupPermission();
+
+ Mockito.when(xGroupPermissionService.createResource(vXGroupPermission))
+ .thenReturn(vXGroupPermission);
+
+ 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);
+
+ 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());
+
+ Mockito.verify(xGroupPermissionService).readResource(1L);
+ }
+
+ @Test
+ public void test41updateXGroupPermission() {
+ VXGroupPermission vXGroupPermission = vXGroupPermission();
+
+ Mockito.when(xGroupPermissionService.updateResource(vXGroupPermission))
+ .thenReturn(vXGroupPermission);
+
+ 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() {
+
+ Mockito.when(xGroupPermissionService.deleteResource(1L)).thenReturn(
+ true);
+ xUserMgr.deleteXGroupPermission(1L, true);
+ Mockito.verify(xGroupPermissionService).deleteResource(1L);
+ }
+
+ @Test
+ public void test43updateExistingUserExisting() {
+ XXPortalUserDao xPortalUserDao = Mockito.mock(XXPortalUserDao.class);
+ VXPortalUser vXPortalUser = Mockito.mock(VXPortalUser.class);
+ XXPortalUser xXPortalUser = Mockito.mock(XXPortalUser.class);
+ List<XXPortalUser> portalUserList = new ArrayList<XXPortalUser>();
+ Mockito.when(daoManager.getXXPortalUser()).thenReturn(xPortalUserDao);
+ Mockito.when(xPortalUserDao.findAllXPortalUser()).thenReturn(
+ portalUserList);
+ Mockito.when(xPortalUserService.populateViewBean(xXPortalUser))
+ .thenReturn(vXPortalUser);
+ List<VXPortalUser> vObj = xUserMgr.updateExistingUserExisting();
+ Assert.assertNotNull(vObj);
+ Mockito.verify(daoManager).getXXPortalUser();
+ Mockito.verify(xPortalUserDao).findAllXPortalUser();
+ }
+
+ @Test
+ public void test44checkPermissionRoleByGivenUrls() {
+ XXModuleDefDao value = Mockito.mock(XXModuleDefDao.class);
+ XXPortalUserRoleDao xPortalUserRoleDao = Mockito
+ .mock(XXPortalUserRoleDao.class);
+
+ List<String> lsvalue = new ArrayList<String>();
+ List<XXPortalUserRole> xPortalUserRolesList = new ArrayList<XXPortalUserRole>();
+ XXPortalUserRole xPortalUserRole = new XXPortalUserRole();
+ xPortalUserRole.setAddedByUserId(userId);
+ xPortalUserRole.setCreateTime(new Date());
+ xPortalUserRole.setId(userId);
+ xPortalUserRole.setStatus(0);
+ xPortalUserRole.setUpdatedByUserId(userId);
+ xPortalUserRole.setUserId(userId);
+ xPortalUserRole.setUserRole("admin");
+ xPortalUserRolesList.add(xPortalUserRole);
+ Mockito.when(daoManager.getXXModuleDef()).thenReturn(value);
+ Mockito.when(value.findModuleURLOfPemittedModules(null)).thenReturn(
+ lsvalue);
+ Mockito.when(daoManager.getXXPortalUserRole()).thenReturn(
+ xPortalUserRoleDao);
+ Mockito.when(xPortalUserRoleDao.findByUserId(null)).thenReturn(
+ xPortalUserRolesList);
+ String enteredURL = "";
+ String method = "";
+ xUserMgr.checkPermissionRoleByGivenUrls(enteredURL, method);
+ Mockito.verify(daoManager).getXXModuleDef();
+ Mockito.verify(value).findModuleURLOfPemittedModules(null);
+ Mockito.verify(daoManager).getXXPortalUserRole();
+ Mockito.verify(xPortalUserRoleDao).findByUserId(null);
+ }
+
+ @Test
+ public void test45getGroupsForUser() {
+ VXUser vxUser = vxUser();
+ String userName = "test";
+ Mockito.when(xUserService.getXUserByUserName(userName)).thenReturn(
+ vxUser);
+ Set<String> list = xUserMgr.getGroupsForUser(userName);
+ Assert.assertNotNull(list);
+ Mockito.verify(xUserService).getXUserByUserName(userName);
+ }
+}