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); + } +}
