http://git-wip-us.apache.org/repos/asf/incubator-ranger/blob/26bfd131/security-admin/src/test/java/org/apache/ranger/rest/TestXUserREST.java ---------------------------------------------------------------------- diff --git a/security-admin/src/test/java/org/apache/ranger/rest/TestXUserREST.java b/security-admin/src/test/java/org/apache/ranger/rest/TestXUserREST.java new file mode 100644 index 0000000..c544832 --- /dev/null +++ b/security-admin/src/test/java/org/apache/ranger/rest/TestXUserREST.java @@ -0,0 +1,2238 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.ranger.rest; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertEquals; + +import javax.ws.rs.WebApplicationException; +import javax.ws.rs.core.Response; + +import org.apache.ranger.audit.dao.DaoManager; +import org.apache.ranger.biz.RangerBizUtil; +import org.apache.ranger.biz.SessionMgr; +import org.apache.ranger.biz.XUserMgr; +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.SortField; +import org.apache.ranger.common.AppConstants; +import org.apache.ranger.common.RangerConstants; +import org.apache.ranger.common.StringUtil; +import org.apache.ranger.db.RangerDaoManager; +import org.apache.ranger.db.XXGroupDao; +import org.apache.ranger.entity.XXResource; +import org.apache.ranger.plugin.model.RangerPolicy; +import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem; +import org.apache.ranger.plugin.model.RangerPolicy.RangerDataMaskPolicyItem; +import org.apache.ranger.plugin.model.RangerPolicy.RangerRowFilterPolicyItem; +import org.apache.ranger.service.AuthSessionService; +import org.apache.ranger.service.XGroupGroupService; +import org.apache.ranger.service.XGroupPermissionService; +import org.apache.ranger.service.XGroupService; +import org.apache.ranger.service.XGroupUserService; +import org.apache.ranger.service.XModuleDefService; +import org.apache.ranger.service.XResourceService; +import org.apache.ranger.service.XUserPermissionService; +import org.apache.ranger.service.XUserService; +import org.apache.ranger.view.VXAuditMap; +import org.apache.ranger.view.VXAuditMapList; +import org.apache.ranger.view.VXAuthSession; +import org.apache.ranger.view.VXAuthSessionList; +import org.apache.ranger.view.VXGroup; +import org.apache.ranger.view.VXGroupGroup; +import org.apache.ranger.view.VXGroupGroupList; +import org.apache.ranger.view.VXGroupList; +import org.apache.ranger.view.VXGroupPermission; +import org.apache.ranger.view.VXGroupPermissionList; +import org.apache.ranger.view.VXGroupUser; +import org.apache.ranger.view.VXGroupUserList; +import org.apache.ranger.view.VXLong; +import org.apache.ranger.view.VXModuleDef; +import org.apache.ranger.view.VXModuleDefList; +import org.apache.ranger.view.VXPermMap; +import org.apache.ranger.view.VXPermMapList; +import org.apache.ranger.view.VXResponse; +import org.apache.ranger.view.VXString; +import org.apache.ranger.view.VXStringList; +import org.apache.ranger.view.VXUser; +import org.apache.ranger.view.VXUserGroupInfo; +import org.apache.ranger.view.VXUserList; +import org.apache.ranger.view.VXDataObject; +import org.apache.ranger.view.VXResource; +import org.apache.ranger.view.VXUserPermission; +import org.apache.ranger.view.VXUserPermissionList; +import org.apache.ranger.entity.XXAuditMap; +import org.apache.ranger.service.XAuditMapService; +import org.apache.ranger.entity.XXAsset; +import org.apache.ranger.entity.XXGroupGroup; +import org.apache.ranger.entity.XXGroupPermission; +import org.apache.ranger.entity.XXPermMap; +import org.apache.ranger.service.XPermMapService; +import org.junit.FixMethodOrder; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.runner.RunWith; +import org.junit.runners.MethodSorters; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; +import org.apache.ranger.entity.XXGroup; +import org.apache.ranger.db.XXGroupPermissionDao; +import org.apache.ranger.db.XXResourceDao; +import org.apache.ranger.db.XXPermMapDao; +import org.apache.ranger.db.XXPolicyDao; +import org.apache.ranger.db.XXGroupUserDao; +import org.apache.ranger.db.XXUserDao; +import org.apache.ranger.entity.XXPolicy; +import org.apache.ranger.entity.XXUser; +import org.apache.ranger.db.XXAuditMapDao; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import javax.servlet.http.HttpServletRequest; + +@RunWith(MockitoJUnitRunner.class) +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class TestXUserREST { + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @InjectMocks + XUserREST xUserRest = new XUserREST(); + + VXUser vxUser=createVXUser(); + Long id=1L; + + @Mock XUserMgr xUserMgr; + @Mock VXGroup vxGroup; + @Mock SearchCriteria searchCriteria; + @Mock XGroupService xGroupService; + @Mock SearchUtil searchUtil; + @Mock VXLong vXLong; + @Mock HttpServletRequest request; + @Mock VXUser vXUser1; + @Mock VXUserGroupInfo vXUserGroupInfo; + @Mock RangerBizUtil bizUtil; + @Mock XUserService xUserService; + @Mock VXUserList vXUserList; + @Mock VXGroupUser vXGroupUser; + @Mock XGroupUserService xGroupUserService; + @Mock VXGroupUserList vXGroupUserList; + @Mock VXGroupGroup vXGroupGroup; + @Mock VXGroupGroupList vXGroupGroupList; + @Mock XGroupGroupService xGroupGroupService; + @Mock VXPermMap vXPermMap; + @Mock RESTErrorUtil restErrorUtil; + @Mock WebApplicationException webApplicationException; + @Mock XResourceService xResourceService; + @Mock VXDataObject VXDataObject; + @Mock AppConstants AppConstants; + @Mock RangerConstants RangerConstants; + @Mock VXResource vXResource; + @Mock VXResponse vXResponse; + @Mock XXResource xXResource; + @Mock XXAuditMap XXAuditMap; + @Mock XAuditMapService xAuditMapService; + @Mock DaoManager daoManager; + @Mock XPermMapService xPermMapService; + @Mock XXAsset XXAsset; + @Mock RangerDaoManager rangerDaoManager; + @Mock XXPermMap XXPermMap; + @Mock Response response; + @Mock VXPermMapList vXPermMapList; + @Mock VXAuditMap vXAuditMap; + @Mock VXAuditMapList vXAuditMapList; + @Mock AuthSessionService authSessionService; + @Mock SessionMgr sessionMgr; + @Mock VXAuthSessionList vXAuthSessionList; + @Mock VXModuleDef vXModuleDef; + @Mock VXUserPermission vXUserPermission; + @Mock VXUserPermissionList vXUserPermissionList; + @Mock VXGroupPermission vXGroupPermission; + @Mock XModuleDefService xModuleDefService; + @Mock VXModuleDefList VXModuleDefList; + @Mock XUserPermissionService xUserPermissionService; + @Mock VXGroupPermissionList vXGroupPermissionList; + @Mock XGroupPermissionService xGroupPermissionService; + @Mock VXStringList vXStringList; + @Mock VXString vXString; + @Mock XXGroupDao xXGroupDao; + @Mock XXGroup xXGroup; + @Mock XXGroupGroup xXGroupGroup; + @Mock XXGroupPermission xXGroupPermission; + @Mock XXGroupPermissionDao xXGroupPermissionDao; + @Mock XXPolicyDao xXPolicyDao; + @Mock XXPolicy xXPolicy; + @Mock XXGroupUserDao xXGroupUserDao; + @Mock XXUserDao xXUserDao; + @Mock XXUser xXUser; + @Mock XXPermMapDao xXPermMapDao; + @Mock XXResourceDao xXResourceDao; + @Mock XXAuditMapDao xXAuditMapDao; + @Mock RangerPolicy rangerPolicy; + @Mock RangerPolicyItem rangerPolicyItem; + @Mock RangerDataMaskPolicyItem rangerDataMaskPolicyItem; + @Mock RangerRowFilterPolicyItem rangerRowFilterPolicyItem; + + @Test + public void test1getXGroup() { + VXGroup compareTestVXGroup=createVXGroup(); + + Mockito.when(xUserMgr.getXGroup(id)).thenReturn(compareTestVXGroup); + VXGroup retVxGroup= xUserRest.getXGroup(id); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + assertEquals(compareTestVXGroup.getName(),retVxGroup.getName()); + Mockito.verify(xUserMgr).getXGroup(id); + } + + @Test + public void test2secureGetXGroup() { + VXGroup compareTestVXGroup=createVXGroup(); + + Mockito.when(xUserMgr.getXGroup(id)).thenReturn(compareTestVXGroup); + VXGroup retVxGroup=xUserRest.secureGetXGroup(id); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + assertEquals(compareTestVXGroup.getName(),retVxGroup.getName()); + Mockito.verify(xUserMgr).getXGroup(id); + } + + @Test + public void test3createXGroup() { + VXGroup compareTestVXGroup=createVXGroup(); + + Mockito.when(xUserMgr.createXGroupWithoutLogin(compareTestVXGroup)).thenReturn(compareTestVXGroup); + VXGroup retVxGroup=xUserRest.createXGroup(compareTestVXGroup); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + assertEquals(compareTestVXGroup.getName(),retVxGroup.getName()); + Mockito.verify(xUserMgr).createXGroupWithoutLogin(compareTestVXGroup); + } + @Test + public void test4secureCreateXGroup() { + VXGroup compareTestVXGroup=createVXGroup(); + + Mockito.when(xUserMgr.createXGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup); + VXGroup retVxGroup=xUserRest.secureCreateXGroup(compareTestVXGroup); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + assertEquals(compareTestVXGroup.getName(),retVxGroup.getName()); + Mockito.verify(xUserMgr).createXGroup(compareTestVXGroup); + } + @Test + public void test5updateXGroup() { + VXGroup compareTestVXGroup=createVXGroup(); + + Mockito.when(xUserMgr.updateXGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup); + VXGroup retVxGroup=xUserRest.updateXGroup(compareTestVXGroup); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + assertEquals(compareTestVXGroup.getName(),retVxGroup.getName()); + Mockito.verify(xUserMgr).updateXGroup(compareTestVXGroup); + } + @Test + public void test6secureUpdateXGroup() { + VXGroup compareTestVXGroup=createVXGroup(); + + Mockito.when(xUserMgr.updateXGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup); + VXGroup retVxGroup=xUserRest.secureUpdateXGroup(compareTestVXGroup); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + assertEquals(compareTestVXGroup.getName(),retVxGroup.getName()); + Mockito.verify(xUserMgr).updateXGroup(compareTestVXGroup); + } + @Test + public void test7modifyGroupsVisibility() { + HashMap<Long, Integer> groupVisibilityMap=creategroupVisibilityMap(); + xUserRest.modifyGroupsVisibility(groupVisibilityMap); + + Mockito.doNothing().when(xUserMgr).modifyGroupsVisibility(groupVisibilityMap); + + Mockito.verify(xUserMgr).modifyGroupsVisibility(groupVisibilityMap); + } + @Test + public void test8deleteXGroupTrue() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="true"; + boolean forceDelete = false; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + + forceDelete=true; + Mockito.doNothing().when(xUserMgr).deleteXGroup(id, forceDelete); + xUserRest.deleteXGroup(id,request); + Mockito.verify(xUserMgr).deleteXGroup(id,forceDelete); + Mockito.verify(request).getParameter("forceDelete"); + } + @Test + public void test9deleteXGroupFalse() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + boolean forceDelete ; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXGroup(id, forceDelete); + xUserRest.deleteXGroup(id,request); + Mockito.verify(xUserMgr).deleteXGroup(id,forceDelete); + Mockito.verify(request).getParameter("forceDelete"); + } + @Test + public void test10deleteXGroupNotEmpty() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr=null; + boolean forceDelete ; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXGroup(id, forceDelete); + xUserRest.deleteXGroup(id,request); + Mockito.verify(xUserMgr).deleteXGroup(id,forceDelete); + Mockito.verify(request).getParameter("forceDelete"); + } + @SuppressWarnings("unchecked") + @Test + public void test11searchXGroups() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "name", "group name", null)).thenReturn(""); + Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "isVisible", "Group Visibility")).thenReturn(1); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "groupSource", "group source", null)).thenReturn(""); + VXGroupList testvXGroupList=createxGroupList(); + Mockito.when(xUserMgr.searchXGroups(testSearchCriteria)).thenReturn(testvXGroupList); + VXGroupList outputvXGroupList=xUserRest.searchXGroups(request); + + Mockito.verify(xUserMgr).searchXGroups(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "name", "group name", null); + Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "isVisible", "Group Visibility"); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "groupSource", "group source", null); + assertNotNull(outputvXGroupList); + assertEquals(outputvXGroupList.getTotalCount(),testvXGroupList.getTotalCount()); + assertEquals(outputvXGroupList.getClass(),testvXGroupList.getClass()); + + } + @SuppressWarnings("unchecked") + @Test + public void test12countXGroups() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + + Mockito.when(xUserMgr.getXGroupSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXGroups(request); + Mockito.verify(xUserMgr).getXGroupSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(testvxLong); + assertEquals(testvxLong.getValue(),vXLong.getValue()); + assertEquals(testvxLong.getClass(),vXLong.getClass()); + + } + @Test + public void test13getXUser() { + + Mockito.when(xUserMgr.getXUser(id)).thenReturn(vxUser); + VXUser gotVXUser=xUserRest.getXUser(id); + Mockito.verify(xUserMgr).getXUser(id); + + assertNotNull(gotVXUser); + assertEquals(vxUser.getId(), gotVXUser.getId()); + assertEquals(vxUser.getName(), gotVXUser.getName()); + } + @Test + public void test14secureGetXUser() { + + Mockito.when(xUserMgr.getXUser(id)).thenReturn(vxUser); + VXUser gotVXUser=xUserRest.secureGetXUser(id); + Mockito.verify(xUserMgr).getXUser(id); + + assertNotNull(gotVXUser); + assertEquals(vxUser.getId(), gotVXUser.getId()); + assertEquals(vxUser.getName(), gotVXUser.getName()); + } + @Test + public void test15createXUser() { + + Mockito.when(xUserMgr.createXUserWithOutLogin(vxUser)).thenReturn(vxUser); + VXUser gotVXUser=xUserRest.createXUser(vxUser); + Mockito.verify(xUserMgr).createXUserWithOutLogin(vxUser); + + assertNotNull(gotVXUser); + assertEquals(vxUser.getId(), gotVXUser.getId()); + assertEquals(vxUser.getName(), gotVXUser.getName()); + } + @Test + public void test16createXUserGroupFromMap() { + VXUserGroupInfo vXUserGroupInfo= new VXUserGroupInfo(); + vXUserGroupInfo.setXuserInfo(vxUser); + + Mockito.when(xUserMgr.createXUserGroupFromMap(vXUserGroupInfo)).thenReturn(vXUserGroupInfo); + VXUserGroupInfo gotVXUserGroupInfo=xUserRest.createXUserGroupFromMap(vXUserGroupInfo); + Mockito.verify(xUserMgr).createXUserGroupFromMap(vXUserGroupInfo); + + assertNotNull(gotVXUserGroupInfo); + assertEquals(vXUserGroupInfo.getId(), gotVXUserGroupInfo.getId()); + assertEquals(vXUserGroupInfo.getOwner(), gotVXUserGroupInfo.getOwner()); + } + @Test + public void test17secureCreateXUser() { + Boolean val= true; + Mockito.when(bizUtil.checkUserAccessible(vxUser)).thenReturn(val); + Mockito.when(xUserMgr.createXUser(vxUser)).thenReturn(vxUser); + VXUser gotVXUser=xUserRest.secureCreateXUser(vxUser); + Mockito.verify(xUserMgr).createXUser(vxUser); + Mockito.verify(bizUtil).checkUserAccessible(vxUser); + assertNotNull(gotVXUser); + assertEquals(vxUser.getId(), gotVXUser.getId()); + assertEquals(vxUser.getName(), gotVXUser.getName()); + + } + @Test + public void test18updateXUser() { + Mockito.when(xUserMgr.updateXUser(vxUser)).thenReturn(vxUser); + VXUser gotVXUser=xUserRest.updateXUser(vxUser); + Mockito.verify(xUserMgr).updateXUser(vxUser); + assertNotNull(gotVXUser); + assertEquals(vxUser.getId(), gotVXUser.getId()); + assertEquals(vxUser.getName(), gotVXUser.getName()); + } + @Test + public void test19secureUpdateXUser() { + + Boolean val= true; + Mockito.when(bizUtil.checkUserAccessible(vxUser)).thenReturn(val); + Mockito.when(xUserMgr.updateXUser(vxUser)).thenReturn(vxUser); + VXUser gotVXUser=xUserRest.secureUpdateXUser(vxUser); + Mockito.verify(xUserMgr).updateXUser(vxUser); + Mockito.verify(bizUtil).checkUserAccessible(vxUser); + + assertNotNull(gotVXUser); + assertEquals(vxUser.getId(), gotVXUser.getId()); + assertEquals(vxUser.getName(), gotVXUser.getName()); + } + @Test + public void test20modifyUserVisibility() { + HashMap<Long, Integer> testVisibilityMap= new HashMap<Long, Integer>(); + testVisibilityMap.put(1L,0); + Mockito.doNothing().when(xUserMgr).modifyUserVisibility(testVisibilityMap); + xUserRest.modifyUserVisibility(testVisibilityMap); + Mockito.verify(xUserMgr).modifyUserVisibility(testVisibilityMap); + } + @Test + public void test21deleteXUser() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + boolean forceDelete = false; + String TestforceDeleteStr="true"; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + forceDelete = true; + Mockito.doNothing().when(xUserMgr).deleteXUser(id, forceDelete); + xUserRest.deleteXUser(id, request); + Mockito.verify(xUserMgr).deleteXUser(id,forceDelete); + Mockito.verify(request).getParameter("forceDelete"); + } + @Test + public void test22deleteXUserFalse() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + boolean forceDelete ; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXUser(id, forceDelete); + xUserRest.deleteXUser(id,request); + Mockito.verify(xUserMgr).deleteXUser(id,forceDelete); + Mockito.verify(request).getParameter("forceDelete"); + } + @Test + public void test23deleteXUserNotEmpty() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr=null; + boolean forceDelete ; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXUser(id, forceDelete); + xUserRest.deleteXUser(id,request); + Mockito.verify(xUserMgr).deleteXUser(id,forceDelete); + Mockito.verify(request).getParameter("forceDelete"); + } + @SuppressWarnings("unchecked") + @Test + public void test24searchXUsers() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyList())).thenReturn(testSearchCriteria); + + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "name", "User name", null)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "emailAddress", "Email Address",null)).thenReturn(""); + Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "userSource", "User Source")).thenReturn(1); + Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "isVisible", "User Visibility")).thenReturn(1); + Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "status", "User Status")).thenReturn(1); + Mockito.when(searchUtil.extractStringList(request, testSearchCriteria, "userRoleList", "User Role List", "userRoleList", null,null)).thenReturn(new ArrayList<String>()); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "userRole", "UserRole", null)).thenReturn(""); + + List<VXUser> vXUsersList= new ArrayList<VXUser>(); + vXUsersList.add(vxUser); + VXUserList testVXUserList= new VXUserList(); + testVXUserList.setVXUsers(vXUsersList); + + Mockito.when(xUserMgr.searchXUsers(testSearchCriteria)).thenReturn(testVXUserList); + VXUserList gotVXUserList=xUserRest.searchXUsers(request); + + Mockito.verify(xUserMgr).searchXUsers(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "name", "User name", null); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "emailAddress", "Email Address",null); + Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "userSource", "User Source"); + Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "isVisible", "User Visibility"); + Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "status", "User Status"); + Mockito.verify(searchUtil).extractStringList(request, testSearchCriteria, "userRoleList", "User Role List", "userRoleList", null,null); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "userRole", "UserRole", null); + assertNotNull(gotVXUserList); + assertEquals(testVXUserList.getTotalCount(),gotVXUserList.getTotalCount()); + assertEquals(testVXUserList.getClass(),gotVXUserList.getClass()); + } + @SuppressWarnings("unchecked") + @Test + public void test25countXUsers() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + + Mockito.when(xUserMgr.getXUserSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXUsers(request); + Mockito.verify(xUserMgr).getXUserSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(testvxLong); + assertEquals(testvxLong.getValue(),vXLong.getValue()); + assertEquals(testvxLong.getClass(),vXLong.getClass()); + } + @Test + public void test26getXGroupUser() { + VXGroupUser testVXGroupUser= createVXGroupUser(); + + Mockito.when(xUserMgr.getXGroupUser(id)).thenReturn(testVXGroupUser); + VXGroupUser retVxGroupUser= xUserRest.getXGroupUser(id); + + assertNotNull(retVxGroupUser); + assertEquals(testVXGroupUser.getClass(),retVxGroupUser.getClass()); + assertEquals(testVXGroupUser.getId(),retVxGroupUser.getId()); + Mockito.verify(xUserMgr).getXGroupUser(id); + } + @Test + public void test27createXGroupUser() { + VXGroupUser testVXGroupUser= createVXGroupUser(); + + Mockito.when(xUserMgr.createXGroupUser(testVXGroupUser)).thenReturn(testVXGroupUser); + VXGroupUser retVxGroupUser= xUserRest.createXGroupUser(testVXGroupUser); + + assertNotNull(retVxGroupUser); + assertEquals(testVXGroupUser.getClass(),retVxGroupUser.getClass()); + assertEquals(testVXGroupUser.getId(),retVxGroupUser.getId()); + Mockito.verify(xUserMgr).createXGroupUser(testVXGroupUser); + } + @Test + public void test28updateXGroupUser() { + VXGroupUser testVXGroupUser= createVXGroupUser(); + + Mockito.when(xUserMgr.updateXGroupUser(testVXGroupUser)).thenReturn(testVXGroupUser); + VXGroupUser retVxGroupUser= xUserRest.updateXGroupUser(testVXGroupUser); + + assertNotNull(retVxGroupUser); + assertEquals(testVXGroupUser.getClass(),retVxGroupUser.getClass()); + assertEquals(testVXGroupUser.getId(),retVxGroupUser.getId()); + Mockito.verify(xUserMgr).updateXGroupUser(testVXGroupUser); + } + + @Test + public void test29deleteXGroupUser() { + boolean force = true; + + Mockito.doNothing().when(xUserMgr).deleteXGroupUser(id, force); + xUserRest.deleteXGroupUser(id,request); + Mockito.verify(xUserMgr).deleteXGroupUser(id,force); + } + @SuppressWarnings("unchecked") + @Test + public void test30searchXGroupUsers() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + VXGroupUserList testVXGroupUserList=new VXGroupUserList(); + VXGroupUser vXGroupUser = createVXGroupUser(); + List<VXGroupUser> vXGroupUsers= new ArrayList<VXGroupUser>(); + vXGroupUsers.add(vXGroupUser); + testVXGroupUserList.setVXGroupUsers(vXGroupUsers); + Mockito.when(xUserMgr.searchXGroupUsers(testSearchCriteria)).thenReturn(testVXGroupUserList); + VXGroupUserList outputvXGroupList=xUserRest.searchXGroupUsers(request); + + Mockito.verify(xUserMgr).searchXGroupUsers(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(outputvXGroupList); + assertEquals(outputvXGroupList.getClass(),testVXGroupUserList.getClass()); + assertEquals(outputvXGroupList.getResultSize(),testVXGroupUserList.getResultSize()); + + } @SuppressWarnings("unchecked") + @Test + public void test31countXGroupUserst() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + + Mockito.when(xUserMgr.getXGroupUserSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXGroupUsers(request); + Mockito.verify(xUserMgr).getXGroupUserSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(testvxLong); + assertEquals(testvxLong.getValue(),vXLong.getValue()); + assertEquals(testvxLong.getClass(),vXLong.getClass()); + } + @Test + public void test32getXGroupGroup() { + VXGroupGroup compareTestVXGroup=createVXGroupGroup(); + + Mockito.when(xUserMgr.getXGroupGroup(id)).thenReturn(compareTestVXGroup); + VXGroupGroup retVxGroup= xUserRest.getXGroupGroup(id); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getClass(),retVxGroup.getClass()); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + Mockito.verify(xUserMgr).getXGroupGroup(id); + } @Test + public void test33createXGroupGroup() { + VXGroupGroup compareTestVXGroup=createVXGroupGroup(); + + Mockito.when(xUserMgr.createXGroupGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup); + VXGroupGroup retVxGroup= xUserRest.createXGroupGroup(compareTestVXGroup); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getClass(),retVxGroup.getClass()); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + Mockito.verify(xUserMgr).createXGroupGroup(compareTestVXGroup); + } + @Test + public void test34updateXGroupGroup() { + VXGroupGroup compareTestVXGroup=createVXGroupGroup(); + + Mockito.when(xUserMgr.updateXGroupGroup(compareTestVXGroup)).thenReturn(compareTestVXGroup); + VXGroupGroup retVxGroup= xUserRest.updateXGroupGroup(compareTestVXGroup); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getClass(),retVxGroup.getClass()); + assertEquals(compareTestVXGroup.getId(),retVxGroup.getId()); + Mockito.verify(xUserMgr).updateXGroupGroup(compareTestVXGroup); + } + @Test + public void test35deleteXGroupGroup() { + boolean forceDelete = false; + + Mockito.doNothing().when(xUserMgr).deleteXGroupGroup(id, forceDelete); + xUserRest.deleteXGroupGroup(id,request); + Mockito.verify(xUserMgr).deleteXGroupGroup(id,forceDelete); + } + @SuppressWarnings("unchecked") + @Test + public void test36searchXGroupGroups() { + VXGroupGroupList testvXGroupGroupList=new VXGroupGroupList(); + VXGroupGroup testVXGroup=createVXGroupGroup(); + List<VXGroupGroup> testVXGroupGroups= new ArrayList<VXGroupGroup>(); + testVXGroupGroups.add(testVXGroup); + testvXGroupGroupList.setVXGroupGroups(testVXGroupGroups); + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + Mockito.when(xUserMgr.searchXGroupGroups(testSearchCriteria)).thenReturn(testvXGroupGroupList); + VXGroupGroupList outputvXGroupGroupList=xUserRest.searchXGroupGroups(request); + + Mockito.verify(xUserMgr).searchXGroupGroups(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(outputvXGroupGroupList); + assertEquals(outputvXGroupGroupList.getClass(),testvXGroupGroupList.getClass()); + assertEquals(outputvXGroupGroupList.getResultSize(),testvXGroupGroupList.getResultSize()); + } + @SuppressWarnings("unchecked") + @Test + public void test37countXGroupGroups() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + + Mockito.when(xUserMgr.getXGroupGroupSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXGroupGroups(request); + Mockito.verify(xUserMgr).getXGroupGroupSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(testvxLong); + assertEquals(testvxLong.getClass(),vXLong.getClass()); + assertEquals(testvxLong.getValue(),vXLong.getValue()); + } + @Test + public void test38getXPermMapVXResourceNull() throws Exception{ + VXPermMap permMap = testcreateXPermMap(); + + Mockito.when(xUserMgr.getXPermMap(id)).thenReturn(permMap); + VXResource testVxResource= new VXResource(); + Mockito.when(xResourceService.readResource(null)).thenReturn(testVxResource); + + Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException()); + thrown.expect(WebApplicationException.class); + + VXPermMap retVxGroup= xUserRest.getXPermMap(id); + + Mockito.verify(xUserMgr).getXPermMap(id); + Mockito.verify(xResourceService).readResource(null); + Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject()); + assertEquals(permMap.getId(),retVxGroup.getId()); + assertEquals(permMap.getClass(),retVxGroup.getClass()); + assertNotNull(retVxGroup); + + + } + @Test + public void test39getXPermMapNotNull() throws Exception{ + VXPermMap permMap = testcreateXPermMap(); + + Mockito.when(xUserMgr.getXPermMap(id)).thenReturn(permMap); + VXResource testVxResource= new VXResource(); + Mockito.when(xResourceService.readResource(id)).thenReturn(testVxResource); + + VXPermMap retVxGroup=xUserRest.getXPermMap(id); + assertEquals(permMap.getId(),retVxGroup.getId()); + assertEquals(permMap.getClass(),retVxGroup.getClass()); + assertNotNull(retVxGroup); + Mockito.verify(xUserMgr).getXPermMap(id); + Mockito.verify(xResourceService).readResource(id); + } + @Test + public void test40getXPermMapNull() { + + Mockito.when(xUserMgr.getXPermMap(id)).thenReturn(null); + VXPermMap retVxGroup=xUserRest.getXPermMap(id); + assertNull(retVxGroup); + Mockito.verify(xUserMgr).getXPermMap(id); + } + + @Test + public void test41createXPermMap() { + + VXPermMap permMap = testcreateXPermMap(); + permMap.setResourceId(null); + Mockito.when(xUserMgr.createXPermMap(permMap)).thenReturn(permMap); + Mockito.when(xResourceService.readResource(permMap.getResourceId())).thenReturn(null); + Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException()); + thrown.expect(WebApplicationException.class); + + VXPermMap retVxGroup=xUserRest.createXPermMap(permMap); + + assertEquals(permMap.getId(),retVxGroup.getId()); + assertEquals(permMap.getClass(),retVxGroup.getClass()); + assertNotNull(retVxGroup); + + Mockito.verify(xUserMgr).createXPermMap(permMap); + Mockito.verify(xResourceService).readResource(permMap.getResourceId()); + Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject()); + } + + @Test + public void test42createXPermMapNull() { + + Mockito.when(xUserMgr.createXPermMap(null)).thenReturn(null); + VXPermMap retVxGroup=xUserRest.createXPermMap(null); + Mockito.verify(xUserMgr).createXPermMap(null); + assertNull(retVxGroup); + + } + + @Test + public void test43createXPermMapNullVXResource() { + VXPermMap permMap = testcreateXPermMap(); + permMap.setResourceId(null); + Mockito.when(xUserMgr.createXPermMap(permMap)).thenReturn(permMap); + VXResource testVxResource= new VXResource(); + Mockito.when(xResourceService.readResource(permMap.getResourceId())).thenReturn(testVxResource); + + VXPermMap retVxGroup=xUserRest.createXPermMap(permMap); + + assertEquals(permMap.getId(),retVxGroup.getId()); + assertEquals(permMap.getClass(),retVxGroup.getClass()); + assertNotNull(retVxGroup); + + Mockito.verify(xUserMgr).createXPermMap(permMap); + Mockito.verify(xResourceService).readResource(permMap.getResourceId()); + } + + @Test + public void test44updateXPermMap() { + + VXPermMap permMap = testcreateXPermMap(); + + VXResource testVxResource= new VXResource(); + Mockito.when(xResourceService.readResource(id)).thenReturn(testVxResource); + Mockito.when(xUserMgr.updateXPermMap(permMap)).thenReturn(permMap); + VXPermMap retVxGroup=xUserRest.updateXPermMap(permMap); + + assertEquals(permMap.getId(),retVxGroup.getId()); + assertEquals(permMap.getClass(),retVxGroup.getClass()); + assertNotNull(retVxGroup); + + Mockito.verify(xUserMgr).updateXPermMap(permMap); + Mockito.verify(xResourceService).readResource(permMap.getResourceId()); + } + @Test + public void test45updateXPermMap() { + Mockito.when(xUserMgr.updateXPermMap(null)).thenReturn(null); + VXPermMap retVxGroup=xUserRest.updateXPermMap(null); + assertNull(retVxGroup); + Mockito.verify(xUserMgr).updateXPermMap(null); + } + @Test + public void test46updateXPermMap() { + VXPermMap permMap = testcreateXPermMap(); + + Mockito.when(xUserMgr.updateXPermMap(permMap)).thenReturn(permMap); + Mockito.when(xResourceService.readResource(permMap.getResourceId())).thenReturn(null); + Mockito.when(restErrorUtil.createRESTException(Mockito.anyString())).thenThrow(new WebApplicationException()); + thrown.expect(WebApplicationException.class); + + VXPermMap retVxGroup=xUserRest.updateXPermMap(permMap); + + assertEquals(permMap.getId(),retVxGroup.getId()); + assertEquals(permMap.getClass(),retVxGroup.getClass()); + assertNotNull(retVxGroup); + + Mockito.verify(xUserMgr).updateXPermMap(permMap); + Mockito.verify(xResourceService).readResource(permMap.getResourceId()); + Mockito.verify(restErrorUtil).createRESTException(Mockito.anyString()); + + } + @Test + public void test47deleteXPermMap() { + Boolean forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXPermMap(id, forceDelete); + xUserRest.deleteXPermMap(id,request); + Mockito.verify(xUserMgr).deleteXPermMap(id,forceDelete); + } + @SuppressWarnings("unchecked") + @Test + public void test48searchXPermMaps() { + VXPermMap permMap = testcreateXPermMap(); + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + List <VXPermMap> vXPermMaps= new ArrayList<VXPermMap>(); + vXPermMaps.add(permMap); + VXPermMapList testvXGroupList=new VXPermMapList() ; + testvXGroupList.setTotalCount(1); + testvXGroupList.setVXPermMaps(vXPermMaps); + Mockito.when(xUserMgr.searchXPermMaps(testSearchCriteria)).thenReturn(testvXGroupList); + VXPermMapList outputvXGroupList=xUserRest.searchXPermMaps(request); + + Mockito.verify(xUserMgr).searchXPermMaps(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(outputvXGroupList); + assertEquals(outputvXGroupList.getClass(),testvXGroupList.getClass()); + assertEquals(outputvXGroupList.getTotalCount(),testvXGroupList.getTotalCount()); + } + @SuppressWarnings("unchecked") + @Test + public void test49countXPermMaps() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + Mockito.when(xUserMgr.getXPermMapSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXPermMaps(request); + Mockito.verify(xUserMgr).getXPermMapSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(testvxLong); + } + @Test + public void test50getXAuditMapVXAuditMapNull() { + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + Mockito.when(xUserMgr.getXAuditMap(testvXAuditMap.getResourceId())).thenReturn(testvXAuditMap); + VXResource testVxResource= createVXResource(); + Mockito.when(xResourceService.readResource(null)).thenReturn(testVxResource); + + Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException()); + thrown.expect(WebApplicationException.class); + + VXAuditMap retVXAuditMap=xUserRest.getXAuditMap(testvXAuditMap.getResourceId()); + + assertEquals(testvXAuditMap.getId(),retVXAuditMap.getId()); + assertEquals(testvXAuditMap.getClass(),retVXAuditMap.getClass()); + assertNotNull(retVXAuditMap); + + Mockito.verify(xUserMgr).getXAuditMap(testvXAuditMap.getResourceId()); + Mockito.verify(xResourceService).readResource(null); + Mockito.verify(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())); + + } + @Test + public void test51getXAuditMapNull() { + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + Mockito.when(xUserMgr.getXAuditMap(testvXAuditMap.getResourceId())).thenReturn(null); + VXAuditMap retVXAuditMap=xUserRest.getXAuditMap(testvXAuditMap.getResourceId()); + + assertNull(retVXAuditMap); + + Mockito.verify(xUserMgr).getXAuditMap(testvXAuditMap.getResourceId()); + + + } + @Test + public void test52getXAuditMap() { + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + + + Mockito.when(xUserMgr.getXAuditMap(id)).thenReturn(testvXAuditMap); + VXResource testVxResource= createVXResource(); + Mockito.when(xResourceService.readResource(testvXAuditMap.getResourceId())).thenReturn(testVxResource); + + VXAuditMap retVXAuditMap=xUserRest.getXAuditMap(id); + + assertEquals(testvXAuditMap.getId(),retVXAuditMap.getId()); + assertEquals(testvXAuditMap.getClass(),retVXAuditMap.getClass()); + assertNotNull(retVXAuditMap); + + Mockito.verify(xUserMgr).getXAuditMap(id); + Mockito.verify(xResourceService).readResource(testvXAuditMap.getResourceId()); + + + } + + @Test + public void test53createXAuditMap() { + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + + Mockito.when(xUserMgr.createXAuditMap(testvXAuditMap)).thenReturn(testvXAuditMap); + VXResource testVxResource= createVXResource(); + Mockito.when(xResourceService.readResource(testvXAuditMap.getResourceId())).thenReturn(testVxResource); + VXAuditMap retvXAuditMap= xUserRest.createXAuditMap(testvXAuditMap); + assertEquals(testvXAuditMap.getId(),retvXAuditMap.getId()); + assertEquals(testvXAuditMap.getClass(),retvXAuditMap.getClass()); + assertNotNull(retvXAuditMap); + + Mockito.verify(xUserMgr).createXAuditMap(testvXAuditMap); + Mockito.verify(xResourceService).readResource(testvXAuditMap.getResourceId()); + + + } + + @Test + public void test54createXAuditMapVxResourceNull() { + + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + testvXAuditMap.setResourceId(null); + Mockito.when(xUserMgr.createXAuditMap(testvXAuditMap)).thenReturn(testvXAuditMap); + + Mockito.when(xResourceService.readResource(testvXAuditMap.getResourceId())).thenReturn(null); + + Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException()); + thrown.expect(WebApplicationException.class); + + VXAuditMap retvXAuditMap= xUserRest.createXAuditMap(testvXAuditMap); + assertEquals(testvXAuditMap.getId(),retvXAuditMap.getId()); + assertEquals(testvXAuditMap.getClass(),retvXAuditMap.getClass()); + assertNotNull(retvXAuditMap); + + Mockito.verify(xUserMgr).createXAuditMap(testvXAuditMap); + Mockito.verify(xResourceService).readResource(testvXAuditMap.getResourceId()); + Mockito.verify(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())); + + }@Test + public void test55createXAuditMapNull() { + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + testvXAuditMap.setResourceId(null); + Mockito.when(xUserMgr.createXAuditMap(testvXAuditMap)).thenReturn(null); + VXAuditMap retvXAuditMap=xUserRest.createXAuditMap(null); + assertNull(retvXAuditMap); + Mockito.verify(xUserMgr).createXAuditMap(null); + + } + + @Test + public void test56updateXAuditMap() { + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + testvXAuditMap.setResourceId(id); + Mockito.when(xUserMgr.updateXAuditMap(testvXAuditMap)).thenReturn(testvXAuditMap); + VXResource testVxResource= createVXResource(); + Mockito.when(xResourceService.readResource(testvXAuditMap.getResourceId())).thenReturn(testVxResource); + + VXAuditMap retvXAuditMap=xUserRest.updateXAuditMap(testvXAuditMap); + assertEquals(testvXAuditMap.getId(),retvXAuditMap.getId()); + assertEquals(testvXAuditMap.getClass(),retvXAuditMap.getClass()); + assertNotNull(retvXAuditMap); + + Mockito.verify(xUserMgr).updateXAuditMap(testvXAuditMap); + Mockito.verify(xResourceService).readResource(testvXAuditMap.getResourceId()); + + + } + @Test + public void test57updateXAuditMapNull() { + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + + + Mockito.when(xUserMgr.updateXAuditMap(testvXAuditMap)).thenReturn(testvXAuditMap); + Mockito.when(xResourceService.readResource(null)).thenReturn(null); + Mockito.when(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())).thenThrow(new WebApplicationException()); + thrown.expect(WebApplicationException.class); + VXAuditMap retvXAuditMap=xUserRest.updateXAuditMap(testvXAuditMap); + assertNull(retvXAuditMap); + Mockito.verify(xUserMgr).updateXAuditMap(testvXAuditMap); + Mockito.verify(xResourceService).readResource(null); + Mockito.verify(restErrorUtil.createRESTException(Mockito.anyString(), (MessageEnums)Mockito.anyObject())); + } + @Test + public void test58updateXAuditMapVXResourceNull() { + + Mockito.when(xUserMgr.updateXAuditMap(null)).thenReturn(null); + VXAuditMap retvXAuditMap=xUserRest.updateXAuditMap(null); + Mockito.verify(xUserMgr).updateXAuditMap(null); + assertNull(retvXAuditMap); + + } + @Test + public void test59deleteXAuditMap() { + + Boolean forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXAuditMap(id, forceDelete); + xUserRest.deleteXAuditMap(id,request); + Mockito.verify(xUserMgr).deleteXAuditMap(id,forceDelete); + } + @SuppressWarnings("unchecked") + @Test + public void test60searchXAuditMaps() { + VXAuditMap testvXAuditMap = createVXAuditMapObj(); + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + List <VXAuditMap> testvXAuditMaps= new ArrayList<VXAuditMap>(); + testvXAuditMaps.add(testvXAuditMap); + VXAuditMapList testVXAuditMapList=new VXAuditMapList() ; + testVXAuditMapList.setVXAuditMaps(testvXAuditMaps); + Mockito.when(xUserMgr.searchXAuditMaps(testSearchCriteria)).thenReturn(testVXAuditMapList); + VXAuditMapList outputVXAuditMapList=xUserRest.searchXAuditMaps(request); + + Mockito.verify(xUserMgr).searchXAuditMaps(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(outputVXAuditMapList); + assertEquals(outputVXAuditMapList.getClass(),testVXAuditMapList.getClass()); + assertEquals(outputVXAuditMapList.getResultSize(),testVXAuditMapList.getResultSize()); + + + } + @SuppressWarnings("unchecked") + @Test + public void test61countXAuditMaps() { + + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + Mockito.when(xUserMgr.getXAuditMapSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXAuditMaps(request); + Mockito.verify(xUserMgr).getXAuditMapSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + assertEquals(testvxLong.getClass(),vXLong.getClass()); + assertEquals(testvxLong.getValue(),vXLong.getValue()); + assertNotNull(testvxLong); + } + @Test + public void test62getXUserByUserName() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + VXUser compareTestVxUser=createVXUser(); + + Mockito.when(xUserMgr.getXUserByUserName("User1")).thenReturn(compareTestVxUser); + VXUser retVXUser= xUserRest.getXUserByUserName(request,"User1"); + + assertNotNull(retVXUser); + assertEquals(compareTestVxUser.getClass(),retVXUser.getClass()); + assertEquals(compareTestVxUser.getId(),retVXUser.getId()); + Mockito.verify(xUserMgr).getXUserByUserName("User1"); + } + @Test + public void test63getXGroupByGroupName() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + VXGroup compareTestVXGroup=createVXGroup(); + + Mockito.when(xGroupService.getGroupByGroupName(compareTestVXGroup.getName())).thenReturn(compareTestVXGroup); + + VXGroup retVxGroup= xUserRest.getXGroupByGroupName(request,compareTestVXGroup.getName()); + + assertNotNull(retVxGroup); + assertEquals(compareTestVXGroup.getClass(),compareTestVXGroup.getClass()); + assertEquals(compareTestVXGroup.getId(),compareTestVXGroup.getId()); + Mockito.verify(xGroupService).getGroupByGroupName(compareTestVXGroup.getName()); + } + @Test + public void test64deleteXUserByUserName() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="true"; + boolean forceDelete = false; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXUser testUser= createVXUser(); + Mockito.when(xUserService.getXUserByUserName(testUser.getName())).thenReturn(testUser); + forceDelete=true; + Mockito.doNothing().when(xUserMgr).deleteXUser(testUser.getId(), forceDelete); + xUserRest.deleteXUserByUserName(testUser.getName(),request); + Mockito.verify(xUserMgr).deleteXUser(testUser.getId(),forceDelete); + Mockito.verify(xUserService).getXUserByUserName(testUser.getName()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test65deleteXUserByUserNametrue() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXUser testUser= createVXUser(); + Mockito.when(xUserService.getXUserByUserName(testUser.getName())).thenReturn(testUser); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXUser(testUser.getId(), forceDelete); + xUserRest.deleteXUserByUserName(testUser.getName(),request); + Mockito.verify(xUserMgr).deleteXUser(testUser.getId(),forceDelete); + Mockito.verify(xUserService).getXUserByUserName(testUser.getName()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test66deleteXUserByUserNameNull() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr=null; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXUser testUser= createVXUser(); + Mockito.when(xUserService.getXUserByUserName(testUser.getName())).thenReturn(testUser); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXUser(testUser.getId(), forceDelete); + xUserRest.deleteXUserByUserName(testUser.getName(),request); + Mockito.verify(xUserMgr).deleteXUser(testUser.getId(),forceDelete); + Mockito.verify(xUserService).getXUserByUserName(testUser.getName()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test67deleteXGroupByGroupName() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXGroup testVXGroup= createVXGroup(); + Mockito.when(xGroupService.getGroupByGroupName(testVXGroup.getName())).thenReturn(testVXGroup); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete); + xUserRest.deleteXGroupByGroupName(testVXGroup.getName(),request); + Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete); + Mockito.verify(xGroupService).getGroupByGroupName(testVXGroup.getName()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test68deleteXGroupByGroupNameNull() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr=null; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXGroup testVXGroup= createVXGroup(); + Mockito.when(xGroupService.getGroupByGroupName(testVXGroup.getName())).thenReturn(testVXGroup); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete); + xUserRest.deleteXGroupByGroupName(testVXGroup.getName(),request); + Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete); + Mockito.verify(xGroupService).getGroupByGroupName(testVXGroup.getName()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test69deleteXGroupByGroupNameflase() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="true"; + boolean forceDelete = false; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXGroup testVXGroup= createVXGroup(); + Mockito.when(xGroupService.getGroupByGroupName(testVXGroup.getName())).thenReturn(testVXGroup); + forceDelete=true; + Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete); + xUserRest.deleteXGroupByGroupName(testVXGroup.getName(),request); + Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete); + Mockito.verify(xGroupService).getGroupByGroupName(testVXGroup.getName()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test70deleteXGroupAndXUser() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + VXGroup testVXGroup= createVXGroup(); + VXUser testVXuser= createVXUser(); + + Mockito.doNothing().when(xUserMgr).deleteXGroupAndXUser(testVXGroup.getName(),testVXuser.getName()); + xUserRest.deleteXGroupAndXUser(testVXGroup.getName(),testVXuser.getName(),request); + Mockito.verify(xUserMgr).deleteXGroupAndXUser(testVXGroup.getName(),testVXuser.getName()); + + + } + @Test + public void test71getXUserGroups() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + VXGroupList groupList = createxGroupList(); + Mockito.when(xUserMgr.getXUserGroups(id)).thenReturn(groupList); + VXGroupList retVxGroupList= xUserRest.getXUserGroups(request,id); + + assertNotNull(retVxGroupList); + assertEquals(groupList.getClass(),retVxGroupList.getClass()); + assertEquals(groupList.getResultSize(),retVxGroupList.getResultSize()); + Mockito.verify(xUserMgr).getXUserGroups(id); + } + @Test + public void test72getXGroupUsers() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + VXGroupList groupList = createxGroupList(); + Mockito.when(xUserMgr.getXUserGroups(id)).thenReturn(groupList); + VXGroupList retVxGroupList= xUserRest.getXUserGroups(request,id); + + assertNotNull(retVxGroupList); + assertEquals(groupList.getClass(),retVxGroupList.getClass()); + assertEquals(groupList.getResultSize(),retVxGroupList.getResultSize()); + Mockito.verify(xUserMgr).getXUserGroups(id); + } + @Test + public void test73getXGroupUsers() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + VXUser testVXUser=createVXUser(); + VXUserList testVXUserList= new VXUserList(); + List<VXUser> testVXUsers = new ArrayList<VXUser>(); + testVXUsers.add(testVXUser); + testVXUserList.setVXUsers(testVXUsers); + testVXUserList.setStartIndex(1); + testVXUserList.setTotalCount(1); + Mockito.when(xUserMgr.getXGroupUsers(id)).thenReturn(testVXUserList); + VXUserList retVxGroupList= xUserRest.getXGroupUsers(request,id); + + assertNotNull(retVxGroupList); + assertEquals(testVXUserList.getTotalCount(),retVxGroupList.getTotalCount()); + assertEquals(testVXUserList.getStartIndex(),retVxGroupList.getStartIndex()); + Mockito.verify(xUserMgr).getXGroupUsers(id); + } + @SuppressWarnings("unchecked") + @Test + public void test74getAuthSessions() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + + Mockito.when(searchUtil.extractLong(request, testSearchCriteria, "id", "Auth Session Id")).thenReturn(1L); + Mockito.when(searchUtil.extractLong(request, testSearchCriteria, "userId", "User Id")).thenReturn(1L); + Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "authStatus", "Auth Status")).thenReturn(1); + Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "authType", "Auth Type")).thenReturn(1); + Mockito.when(searchUtil.extractInt(request, testSearchCriteria, "deviceType", "Device Type")).thenReturn(1); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "firstName", "User First Name", StringUtil.VALIDATION_NAME)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "lastName", "User Last Name", StringUtil.VALIDATION_NAME)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "requestUserAgent", "User Agent", StringUtil.VALIDATION_TEXT)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "requestIP", "Request IP Address", StringUtil.VALIDATION_IP_ADDRESS)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "loginId", "Login ID", StringUtil.VALIDATION_TEXT)).thenReturn(""); + Mockito.when(searchUtil.extractDate(request, testSearchCriteria, "startDate", "Start date for search", null)).thenReturn(new Date()); + Mockito.when(searchUtil.extractDate(request, testSearchCriteria, "endDate", "End date for search", null)).thenReturn(new Date()); + + + VXAuthSessionList testVXAuthSessionList=new VXAuthSessionList(); + testVXAuthSessionList.setTotalCount(1); + testVXAuthSessionList.setStartIndex(1); + VXAuthSession testVXAuthSession = createVXAuthSession(); + List<VXAuthSession> testvXAuthSessions = new ArrayList<VXAuthSession>(); + testvXAuthSessions.add(testVXAuthSession); + + testVXAuthSessionList.setVXAuthSessions(testvXAuthSessions); + Mockito.when(sessionMgr.searchAuthSessions(testSearchCriteria)).thenReturn(testVXAuthSessionList); + VXAuthSessionList outputvXGroupList=xUserRest.getAuthSessions(request); + + Mockito.verify(sessionMgr).searchAuthSessions(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + Mockito.verify(searchUtil).extractLong(request, testSearchCriteria, "id", "Auth Session Id"); + Mockito.verify(searchUtil).extractLong(request, testSearchCriteria, "userId", "User Id"); + Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "authStatus", "Auth Status"); + Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "authType", "Auth Type"); + Mockito.verify(searchUtil).extractInt(request, testSearchCriteria, "deviceType", "Device Type"); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "firstName", "User First Name", StringUtil.VALIDATION_NAME); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "lastName", "User Last Name", StringUtil.VALIDATION_NAME); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "requestUserAgent", "User Agent", StringUtil.VALIDATION_TEXT); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "requestIP", "Request IP Address", StringUtil.VALIDATION_IP_ADDRESS); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "loginId", "Login ID", StringUtil.VALIDATION_TEXT); + Mockito.verify(searchUtil).extractDate(request, testSearchCriteria, "startDate", "Start date for search", null); + Mockito.verify(searchUtil).extractDate(request, testSearchCriteria, "endDate", "End date for search", null); + assertNotNull(outputvXGroupList); + assertEquals(outputvXGroupList.getStartIndex(),testVXAuthSessionList.getStartIndex()); + assertEquals(outputvXGroupList.getTotalCount(), testVXAuthSessionList.getTotalCount()); + } + @Test + public void test75getAuthSession() { + String authSessionId ="testauthSessionId"; + VXAuthSession testVXAuthSession= createVXAuthSession(); + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + Mockito.when(request.getParameter("extSessionId")).thenReturn(authSessionId); + Mockito.when(sessionMgr.getAuthSessionBySessionId(authSessionId)).thenReturn(testVXAuthSession); + VXAuthSession retVXAuthSession=xUserRest.getAuthSession(request); + Mockito.verify(sessionMgr).getAuthSessionBySessionId(authSessionId); + Mockito.verify(request).getParameter("extSessionId"); + assertEquals(testVXAuthSession.getId(), retVXAuthSession.getId()); + assertEquals(testVXAuthSession.getClass(), retVXAuthSession.getClass()); + assertNotNull(retVXAuthSession); + } + @Test + public void test76createXModuleDefPermission() { + + VXModuleDef testVXModuleDef = createVXModuleDef(); + + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + + Mockito.when(xUserMgr.createXModuleDefPermission(testVXModuleDef)).thenReturn(testVXModuleDef); + VXModuleDef retVxModuleDef=xUserRest.createXModuleDefPermission(testVXModuleDef); + + assertNotNull(retVxModuleDef); + assertEquals(testVXModuleDef.getId(),retVxModuleDef.getId()); + assertEquals(testVXModuleDef.getOwner(),retVxModuleDef.getOwner()); + Mockito.verify(xUserMgr).createXModuleDefPermission(testVXModuleDef); + Mockito.verify(xUserMgr).checkAdminAccess(); + + } + @Test + public void test77getXModuleDefPermission() { + VXModuleDef testVXModuleDef=createVXModuleDef(); + Mockito.when(xUserMgr.getXModuleDefPermission(testVXModuleDef.getId())).thenReturn(testVXModuleDef); + VXModuleDef retVxModuleDef=xUserRest.getXModuleDefPermission(testVXModuleDef.getId()); + + assertNotNull(retVxModuleDef); + assertEquals(testVXModuleDef.getId(),retVxModuleDef.getId()); + assertEquals(testVXModuleDef.getOwner(),retVxModuleDef.getOwner()); + + Mockito.verify(xUserMgr).getXModuleDefPermission(testVXModuleDef.getId()); + + } + @Test + public void test78updateXModuleDefPermission() { + + VXModuleDef testVXModuleDef = createVXModuleDef(); + + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + + Mockito.when(xUserMgr.updateXModuleDefPermission(testVXModuleDef)).thenReturn(testVXModuleDef); + VXModuleDef retVxModuleDef=xUserRest.updateXModuleDefPermission(testVXModuleDef); + + assertNotNull(retVxModuleDef); + assertEquals(testVXModuleDef.getId(),retVxModuleDef.getId()); + assertEquals(testVXModuleDef.getOwner(),retVxModuleDef.getOwner()); + + Mockito.verify(xUserMgr).updateXModuleDefPermission(testVXModuleDef); + Mockito.verify(xUserMgr).checkAdminAccess(); + } + @Test + public void test79deleteXModuleDefPermission() { + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + boolean forceDelete = true; + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + Mockito.doNothing().when(xUserMgr).deleteXModuleDefPermission(id, forceDelete); + xUserRest.deleteXModuleDefPermission(id,request); + Mockito.verify(xUserMgr).deleteXModuleDefPermission(id,forceDelete); + Mockito.verify(xUserMgr).checkAdminAccess(); + + } + @SuppressWarnings("unchecked") + @Test + public void test80searchXModuleDef() { + VXModuleDefList testVXModuleDefList= new VXModuleDefList() ; + VXModuleDef vXModuleDef=createVXModuleDef(); + List<VXModuleDef> VXModuleDefs= new ArrayList<VXModuleDef>(); + VXModuleDefs.add(vXModuleDef); + testVXModuleDefList.setvXModuleDef(VXModuleDefs); + testVXModuleDefList.setTotalCount(1); + testVXModuleDefList.setStartIndex(1); + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "module","modulename", null)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "moduleDefList","id", null)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "userName","userName", null)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "groupName","groupName", null)).thenReturn(""); + + Mockito.when(xUserMgr.searchXModuleDef(testSearchCriteria)).thenReturn(testVXModuleDefList); + VXModuleDefList outputVXModuleDefList=xUserRest.searchXModuleDef(request); + assertNotNull(outputVXModuleDefList); + assertEquals(outputVXModuleDefList.getTotalCount(),testVXModuleDefList.getTotalCount()); + assertEquals(outputVXModuleDefList.getStartIndex(),testVXModuleDefList.getStartIndex()); + + Mockito.verify(xUserMgr).searchXModuleDef(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "module","modulename", null); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "moduleDefList","id", null); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "userName","userName", null); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "groupName","groupName", null); + + } + @SuppressWarnings("unchecked") + @Test + public void test81countXModuleDef() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + + Mockito.when(xUserMgr.getXModuleDefSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXModuleDef(request); + Mockito.verify(xUserMgr).getXModuleDefSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(testvxLong); + assertEquals(testvxLong.getValue(),vXLong.getValue()); + assertEquals(testvxLong.getClass(),vXLong.getClass()); + } + @Test + public void test82createXUserPermission() { + VXUserPermission testvXUserPermission = createVXUserPermission(); + + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + Mockito.when(xUserMgr.createXUserPermission(testvXUserPermission)).thenReturn(testvXUserPermission); + VXUserPermission retVXUserPermission=xUserRest.createXUserPermission(testvXUserPermission); + Mockito.verify(xUserMgr).createXUserPermission(testvXUserPermission); + Mockito.verify(xUserMgr).checkAdminAccess(); + assertNotNull(retVXUserPermission); + assertEquals(retVXUserPermission.getId(), testvXUserPermission.getId()); + assertEquals(retVXUserPermission.getUserName(), testvXUserPermission.getUserName()); + } + @Test + public void test83getXUserPermission() { + VXUserPermission testVXUserPermission=createVXUserPermission(); + Mockito.when(xUserMgr.getXUserPermission(testVXUserPermission.getId())).thenReturn(testVXUserPermission); + VXUserPermission retVXUserPermission=xUserRest.getXUserPermission(testVXUserPermission.getId()); + Mockito.verify(xUserMgr).getXUserPermission(id); + assertNotNull(retVXUserPermission); + assertEquals(retVXUserPermission.getId(), testVXUserPermission.getId()); + assertEquals(retVXUserPermission.getUserName(), testVXUserPermission.getUserName()); + } + @Test + public void test84updateXUserPermission() { + VXUserPermission testvXUserPermission = createVXUserPermission(); + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + Mockito.when(xUserMgr.updateXUserPermission(testvXUserPermission)).thenReturn(testvXUserPermission); + VXUserPermission retVXUserPermission=xUserRest.updateXUserPermission(testvXUserPermission); + Mockito.verify(xUserMgr).updateXUserPermission(testvXUserPermission); + Mockito.verify(xUserMgr).checkAdminAccess(); + assertNotNull(retVXUserPermission); + assertEquals(retVXUserPermission.getId(), testvXUserPermission.getId()); + assertEquals(retVXUserPermission.getUserName(), testvXUserPermission.getUserName()); + + } + @Test + public void test85deleteXUserPermission() { + boolean forceDelete = true; + + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + + Mockito.doNothing().when(xUserMgr).deleteXUserPermission(id, forceDelete); + xUserRest.deleteXUserPermission(id,request); + Mockito.verify(xUserMgr).deleteXUserPermission(id,forceDelete); + Mockito.verify(xUserMgr).checkAdminAccess(); + + } + @SuppressWarnings("unchecked") + @Test + public void test86searchXUserPermission() { + VXUserPermissionList testVXUserPermissionList= new VXUserPermissionList() ; + testVXUserPermissionList.setTotalCount(1); + testVXUserPermissionList.setStartIndex(1); + VXUserPermission testVXUserPermission=createVXUserPermission(); + List<VXUserPermission> testVXUserPermissions= new ArrayList<VXUserPermission>(); + testVXUserPermissions.add(testVXUserPermission); + testVXUserPermissionList.setvXModuleDef(testVXUserPermissions); + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "id", "id",StringUtil.VALIDATION_NAME)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "userPermissionList","userId", StringUtil.VALIDATION_NAME)).thenReturn(""); + + + Mockito.when(xUserMgr.searchXUserPermission(testSearchCriteria)).thenReturn(testVXUserPermissionList); + VXUserPermissionList outputVXUserPermissionList=xUserRest.searchXUserPermission(request); + assertNotNull(outputVXUserPermissionList); + assertEquals(outputVXUserPermissionList.getStartIndex(),testVXUserPermissionList.getStartIndex()); + assertEquals(outputVXUserPermissionList.getTotalCount(),testVXUserPermissionList.getTotalCount()); + + Mockito.verify(xUserMgr).searchXUserPermission(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "id", "id",StringUtil.VALIDATION_NAME); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "userPermissionList","userId", StringUtil.VALIDATION_NAME); + + } + @SuppressWarnings("unchecked") + @Test + public void test87countXUserPermission() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + + Mockito.when(xUserMgr.getXUserPermissionSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXUserPermission(request); + Mockito.verify(xUserMgr).getXUserPermissionSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(testvxLong); + assertEquals(testvxLong.getValue(),vXLong.getValue()); + assertEquals(testvxLong.getClass(),vXLong.getClass()); + + } + @Test + public void test88createXGroupPermission() { + + VXGroupPermission testVXGroupPermission = createVXGroupPermission(); + + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + Mockito.when(xUserMgr.createXGroupPermission(testVXGroupPermission)).thenReturn(testVXGroupPermission); + VXGroupPermission retVXGroupPermission=xUserRest.createXGroupPermission(testVXGroupPermission); + Mockito.verify(xUserMgr).createXGroupPermission(testVXGroupPermission); + Mockito.verify(xUserMgr).checkAdminAccess(); + assertNotNull(retVXGroupPermission); + assertEquals(retVXGroupPermission.getId(), testVXGroupPermission.getId()); + assertEquals(retVXGroupPermission.getClass(), testVXGroupPermission.getClass()); + + } + @Test + public void test89getXGroupPermission() { + VXGroupPermission testVXGroupPermission =createVXGroupPermission(); + Mockito.when(xUserMgr.getXGroupPermission(testVXGroupPermission.getId())).thenReturn(testVXGroupPermission); + VXGroupPermission retVXGroupPermission=xUserRest.getXGroupPermission(testVXGroupPermission.getId()); + Mockito.verify(xUserMgr).getXGroupPermission(testVXGroupPermission.getId()); + assertNotNull(retVXGroupPermission); + assertEquals(retVXGroupPermission.getId(), testVXGroupPermission.getId()); + assertEquals(retVXGroupPermission.getClass(), testVXGroupPermission.getClass()); + + } + @Test + public void test90updateXGroupPermission() { + + VXGroupPermission testVXGroupPermission = createVXGroupPermission(); + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + Mockito.when(xUserMgr.updateXGroupPermission(testVXGroupPermission)).thenReturn(testVXGroupPermission); + VXGroupPermission retVXGroupPermission=xUserRest.updateXGroupPermission(testVXGroupPermission); + Mockito.verify(xUserMgr).updateXGroupPermission(testVXGroupPermission); + Mockito.verify(xUserMgr).checkAdminAccess(); + assertNotNull(retVXGroupPermission); + assertEquals(retVXGroupPermission.getId(), testVXGroupPermission.getId()); + assertEquals(retVXGroupPermission.getClass(), testVXGroupPermission.getClass()); + + + } + @Test + public void test91deleteXGroupPermission() { + + boolean forceDelete = true; + + Mockito.doNothing().when(xUserMgr).checkAdminAccess(); + + Mockito.doNothing().when(xUserMgr).deleteXGroupPermission(id, forceDelete); + xUserRest.deleteXGroupPermission(id,request); + Mockito.verify(xUserMgr).deleteXGroupPermission(id,forceDelete); + Mockito.verify(xUserMgr).checkAdminAccess(); + } + @SuppressWarnings("unchecked") + @Test + public void test92searchXGroupPermission() { + VXGroupPermissionList testVXGroupPermissionList= new VXGroupPermissionList() ; + testVXGroupPermissionList.setTotalCount(1); + VXGroupPermission testVXGroupPermission=createVXGroupPermission(); + List<VXGroupPermission> testVXGroupPermissions= new ArrayList<VXGroupPermission>(); + testVXGroupPermissions.add(testVXGroupPermission); + testVXGroupPermissionList.setvXGroupPermission(testVXGroupPermissions); + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + Mockito.when(searchUtil.extractString(request, testSearchCriteria, "id", "id",StringUtil.VALIDATION_NAME)).thenReturn(""); + Mockito.when(searchUtil.extractString(request, testSearchCriteria,"groupPermissionList", "groupId", StringUtil.VALIDATION_NAME)).thenReturn(""); + Mockito.when(xUserMgr.searchXGroupPermission(testSearchCriteria)).thenReturn(testVXGroupPermissionList); + VXGroupPermissionList outputVXGroupPermissionList=xUserRest.searchXGroupPermission(request); + assertNotNull(outputVXGroupPermissionList); + assertEquals(outputVXGroupPermissionList.getClass(),testVXGroupPermissionList.getClass()); + assertEquals(outputVXGroupPermissionList.getTotalCount(),testVXGroupPermissionList.getTotalCount()); + + Mockito.verify(xUserMgr).searchXGroupPermission(testSearchCriteria); + + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria, "id", "id",StringUtil.VALIDATION_NAME); + Mockito.verify(searchUtil).extractString(request, testSearchCriteria,"groupPermissionList", "groupId", StringUtil.VALIDATION_NAME); + } + @SuppressWarnings("unchecked") + @Test + public void test93countXGroupPermission() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + SearchCriteria testSearchCriteria=createsearchCriteria(); + + Mockito.when(searchUtil.extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject())).thenReturn(testSearchCriteria); + + vXLong.setValue(1); + + Mockito.when(xUserMgr.getXGroupPermissionSearchCount(testSearchCriteria)).thenReturn(vXLong); + VXLong testvxLong=xUserRest.countXGroupPermission(request); + Mockito.verify(xUserMgr).getXGroupPermissionSearchCount(testSearchCriteria); + Mockito.verify(searchUtil).extractCommonCriterias((HttpServletRequest)Mockito.anyObject() ,(List<SortField>)Mockito.anyObject()); + + assertNotNull(testvxLong); + assertEquals(testvxLong.getValue(),vXLong.getValue()); + assertEquals(testvxLong.getClass(),vXLong.getClass()); + + } + @Test + public void test94modifyUserActiveStatus() { + HashMap<Long, Integer> statusMap= new HashMap<Long, Integer>(); + statusMap.put(id, 1); + Mockito.doNothing().when(xUserMgr).modifyUserActiveStatus(statusMap); + xUserRest.modifyUserActiveStatus(statusMap); + Mockito.verify(xUserMgr).modifyUserActiveStatus(statusMap); + } + @Test + public void test95setUserRolesByExternalID() { + VXStringList testVXStringList= createVXStringList(); + Mockito.when(xUserMgr.setUserRolesByExternalID(id, testVXStringList.getVXStrings())).thenReturn(testVXStringList); + VXStringList retVXStringList=xUserRest.setUserRolesByExternalID(id, testVXStringList); + Mockito.verify(xUserMgr).setUserRolesByExternalID(id, testVXStringList.getVXStrings()); + + assertNotNull(retVXStringList); + assertEquals(testVXStringList.getTotalCount(), retVXStringList.getTotalCount()); + assertEquals(testVXStringList.getClass(), retVXStringList.getClass()); + } + @Test + public void test96setUserRolesByName() { + VXStringList testVXStringList= createVXStringList(); + Mockito.when(xUserMgr.setUserRolesByName("Admin", testVXStringList.getVXStrings())).thenReturn(testVXStringList); + VXStringList retVXStringList=xUserRest.setUserRolesByName("Admin", testVXStringList); + Mockito.verify(xUserMgr).setUserRolesByName("Admin", testVXStringList.getVXStrings()); + + assertNotNull(retVXStringList); + assertEquals(testVXStringList.getTotalCount(), retVXStringList.getTotalCount()); + assertEquals(testVXStringList.getClass(), retVXStringList.getClass()); + } + @Test + public void test97getUserRolesByExternalID() { + VXStringList testVXStringList=createVXStringList(); + + Mockito.when(xUserMgr.getUserRolesByExternalID(id)).thenReturn(testVXStringList); + VXStringList retVXStringList=xUserRest.getUserRolesByExternalID(id); + Mockito.verify(xUserMgr).getUserRolesByExternalID(id); + assertNotNull(retVXStringList); + assertEquals(testVXStringList.getTotalCount(), retVXStringList.getTotalCount()); + assertEquals(testVXStringList.getClass(), retVXStringList.getClass()); + + } + @Test + public void test98getUserRolesByName() { + + VXStringList testVXStringList=createVXStringList(); + + Mockito.when(xUserMgr.getUserRolesByName("Admin")).thenReturn(testVXStringList); + VXStringList retVXStringList=xUserRest.getUserRolesByName("Admin"); + Mockito.verify(xUserMgr).getUserRolesByName("Admin"); + assertNotNull(retVXStringList); + assertEquals(testVXStringList.getTotalCount(), retVXStringList.getTotalCount()); + assertEquals(testVXStringList.getClass(), retVXStringList.getClass()); + } + @Test + public void test99deleteUsersByUserName() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="true"; + boolean forceDelete = false; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue("User1"); + VXUser testVXUser= createVXUser(); + VXStringList vxStringList=createVXStringList(); + + Mockito.when(xUserService.getXUserByUserName(testVXString.getValue())).thenReturn(testVXUser); + forceDelete=true; + Mockito.doNothing().when(xUserMgr).deleteXUser(testVXUser.getId(), forceDelete); + xUserRest.deleteUsersByUserName(request,vxStringList); + Mockito.verify(xUserMgr).deleteXUser(testVXUser.getId(),forceDelete); + Mockito.verify(xUserService).getXUserByUserName(testVXString.getValue()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test100deleteUsersByUserNameNull() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue("User1"); + VXUser testVXUser= createVXUser(); + VXStringList vxStringList=createVXStringList(); + + Mockito.when(xUserService.getXUserByUserName(testVXString.getValue())).thenReturn(testVXUser); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXUser(testVXUser.getId(), forceDelete); + xUserRest.deleteUsersByUserName(request,vxStringList); + Mockito.verify(xUserMgr).deleteXUser(testVXUser.getId(),forceDelete); + Mockito.verify(xUserService).getXUserByUserName(testVXString.getValue()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test101deleteUsersByUserNameNull() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr=null; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue("User1"); + VXUser testVXUser= createVXUser(); + VXStringList vxStringList=createVXStringList(); + + Mockito.when(xUserService.getXUserByUserName(testVXString.getValue())).thenReturn(testVXUser); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXUser(testVXUser.getId(), forceDelete); + xUserRest.deleteUsersByUserName(request,vxStringList); + Mockito.verify(xUserMgr).deleteXUser(testVXUser.getId(),forceDelete); + Mockito.verify(xUserService).getXUserByUserName(testVXString.getValue()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test102deleteUsersByUserNameSetValueNull() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue("User1"); + VXUser testVXUser= createVXUser(); + VXStringList vxStringList=createVXStringList(); + + Mockito.when(xUserService.getXUserByUserName(testVXString.getValue())).thenReturn(testVXUser); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXUser(testVXUser.getId(), forceDelete); + xUserRest.deleteUsersByUserName(request,vxStringList); + Mockito.verify(xUserMgr).deleteXUser(testVXUser.getId(),forceDelete); + Mockito.verify(xUserService).getXUserByUserName(testVXString.getValue()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test103deleteUsersByUserNameListNull() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue("User1"); + xUserRest.deleteUsersByUserName(request,null); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test104deleteUsersByUserNameListGetListNull() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXStringList vxStringList=createVXStringList(); + vxStringList.setVXStrings(null); + xUserRest.deleteUsersByUserName(request,vxStringList); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test105deleteUsersByUserNameNull() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="true"; + + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue(null); + + VXStringList vxStringList=createVXStringList(); + List<VXString> testVXStrings=new ArrayList<VXString>(); + testVXStrings.add(testVXString); + vxStringList.setVXStrings(testVXStrings); + xUserRest.deleteUsersByUserName(request,vxStringList); + Mockito.verify(request).getParameter("forceDelete"); + + } + //////////////////////////////// + @Test + public void test106deleteGroupsByGroupName() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="true"; + boolean forceDelete = false; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue("testVXGroup"); + VXGroup testVXGroup= createVXGroup(); + VXStringList vxStringList=createVXStringListGroup(); + + Mockito.when(xGroupService.getGroupByGroupName(testVXString.getValue())).thenReturn(testVXGroup); + forceDelete=true; + Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete); + xUserRest.deleteGroupsByGroupName(request,vxStringList); + Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete); + Mockito.verify(xGroupService).getGroupByGroupName(testVXString.getValue()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test107GroupsByGroupNameNull() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr="false"; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue("testVXGroup"); + VXGroup testVXGroup= createVXGroup(); + VXStringList vxStringList=createVXStringListGroup(); + + Mockito.when(xGroupService.getGroupByGroupName(testVXString.getValue())).thenReturn(testVXGroup); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete); + xUserRest.deleteGroupsByGroupName(request,vxStringList); + Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete); + Mockito.verify(xGroupService).getGroupByGroupName(testVXString.getValue()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test108deleteGroupsByGroupNameNull() { + + HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + String TestforceDeleteStr=null; + boolean forceDelete = true; + Mockito.when(request.getParameter("forceDelete")).thenReturn(TestforceDeleteStr); + VXString testVXString= new VXString(); + testVXString.setValue("testVXGroup"); + VXGroup testVXGroup= createVXGroup(); + VXStringList vxStringList=createVXStringListGroup(); + + Mockito.when(xGroupService.getGroupByGroupName(testVXString.getValue())).thenReturn(testVXGroup); + forceDelete=false; + Mockito.doNothing().when(xUserMgr).deleteXGroup(testVXGroup.getId(), forceDelete); + xUserRest.deleteGroupsByGroupName(request,vxStringList); + Mockito.verify(xUserMgr).deleteXGroup(testVXGroup.getId(),forceDelete); + Mockito.verify(xGroupService).getGroupByGroupName(testVXString.getValue()); + Mockito.verify(request).getParameter("forceDelete"); + + } + @Test + public void test109deleteGroupsByGroupN
<TRUNCATED>
