X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=ecomp-portal-BE-common%2Fsrc%2Ftest%2Fjava%2Forg%2Fonap%2Fportalapp%2Fportal%2Fservice%2FExternalAccessRolesServiceImplTest.java;h=0fe5a2c61b15cb8ad427ab1d06f84702efd88467;hb=3aa28e9dd68cce134644223505f326378b5d91a8;hp=66cfdd3148ea8ec1f17cd51925760042f48530f7;hpb=08f55be6a0a9708ceeb176d5e1a0a56f885fad59;p=portal.git diff --git a/ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/service/ExternalAccessRolesServiceImplTest.java b/ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/service/ExternalAccessRolesServiceImplTest.java index 66cfdd31..0fe5a2c6 100644 --- a/ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/service/ExternalAccessRolesServiceImplTest.java +++ b/ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/service/ExternalAccessRolesServiceImplTest.java @@ -45,10 +45,18 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.SortedSet; +import java.util.TreeSet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; +import org.hibernate.SQLQuery; +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.Transaction; +import org.json.JSONObject; +import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -64,11 +72,19 @@ import org.onap.portalapp.portal.domain.EPAppRoleFunction; import org.onap.portalapp.portal.domain.EPRole; import org.onap.portalapp.portal.domain.EPUser; import org.onap.portalapp.portal.exceptions.InactiveApplicationException; +import org.onap.portalapp.portal.exceptions.InvalidUserException; import org.onap.portalapp.portal.framework.MockitoTestSuite; +import org.onap.portalapp.portal.transport.BulkUploadUserRoles; +import org.onap.portalapp.portal.transport.CentralV2Role; import org.onap.portalapp.portal.transport.EcompUserRoles; +import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator; +import org.onap.portalapp.portal.transport.GlobalRoleWithApplicationRoleFunction; +import org.onap.portalapp.portal.transport.LocalRole; import org.onap.portalapp.portal.utils.EPCommonSystemProperties; import org.onap.portalapp.portal.utils.EcompPortalUtils; +import org.onap.portalapp.portal.utils.PortalConstants; import org.onap.portalsdk.core.domain.Role; +import org.onap.portalsdk.core.domain.RoleFunction; import org.onap.portalsdk.core.restful.domain.EcompUser; import org.onap.portalsdk.core.service.DataAccessService; import org.onap.portalsdk.core.service.DataAccessServiceImpl; @@ -88,7 +104,7 @@ import org.springframework.web.client.RestTemplate; @PrepareForTest({ EcompPortalUtils.class, SystemProperties.class, EPCommonSystemProperties.class }) public class ExternalAccessRolesServiceImplTest { @Mock - DataAccessService dataAccessService1 = new DataAccessServiceImpl(); + DataAccessService dataAccessService = new DataAccessServiceImpl(); @Mock RestTemplate template = new RestTemplate(); @@ -96,10 +112,73 @@ public class ExternalAccessRolesServiceImplTest { @InjectMocks ExternalAccessRolesServiceImpl externalAccessRolesServiceImpl = new ExternalAccessRolesServiceImpl(); + @Mock + EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl(); + + @Mock + SessionFactory sessionFactory; + + @Mock + Session session; + + @Mock + Transaction transaction; + @Before public void setup() { MockitoAnnotations.initMocks(this); + Mockito.when(sessionFactory.openSession()).thenReturn(session); + Mockito.when(session.beginTransaction()).thenReturn(transaction); } + + @After + public void after() { + session.close(); + } + + private static final String APP_ROLE_NAME_PARAM = "appRoleName"; + + private static final String GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM = "getRoletoUpdateInExternalAuthSystem"; + + private static final String GET_PORTAL_APP_ROLES_QUERY = "getPortalAppRoles"; + + private static final String GET_ROLE_FUNCTION_QUERY = "getRoleFunction"; + + private static final String FUNCTION_CODE_PARAMS = "functionCode"; + + private static final String AND_FUNCTION_CD_EQUALS = " and function_cd = '"; + + private static final String OWNER = ".owner"; + + private static final String ADMIN = ".admin"; + + private static final String ACCOUNT_ADMINISTRATOR = ".Account_Administrator"; + + private static final String FUNCTION_PIPE = "|"; + + private static final String IS_NULL_STRING = "null"; + + private static final String EXTERNAL_AUTH_PERMS = "perms"; + + private static final String EXTERNAL_AUTH_ROLE_DESCRIPTION = "description"; + + private static final String IS_EMPTY_JSON_STRING = "{}"; + + private static final String CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE = "Connecting to External Auth system"; + + private static final String APP_ROLE_ID = "appRoleId"; + + private static final String APP_ID = "appId"; + + private static final String PRIORITY = "priority"; + + private static final String ACTIVE = "active"; + + private static final String ROLE_NAME = "name"; + + private static final String ID = "id"; + + private static final String APP_ID_EQUALS = " app_id = "; MockitoTestSuite mockitoTestSuite = new MockitoTestSuite(); @@ -113,6 +192,8 @@ public class ExternalAccessRolesServiceImplTest { EPApp app = new EPApp(); app.setName("Test"); app.setImageUrl("test"); + app.setNameSpace("com.test.app"); + app.setCentralAuth(true); app.setDescription("test"); app.setNotes("test"); app.setUrl("test"); @@ -125,7 +206,7 @@ public class ExternalAccessRolesServiceImplTest { app.setUsername("test"); app.setAppPassword("test"); app.setOpen(false); - app.setEnabled(false); + app.setEnabled(true); app.setUebKey("test"); app.setUebSecret("test"); app.setUebTopicName("test"); @@ -133,38 +214,29 @@ public class ExternalAccessRolesServiceImplTest { return app; } + @SuppressWarnings("deprecation") @Test public void getAppRolesIfAppIsPortalTest() throws Exception { List applicationRoles = new ArrayList<>(); - Mockito.when(dataAccessService1.getList(EPRole.class, "test", null, null)).thenReturn(applicationRoles); + Mockito.when(dataAccessService.getList(EPRole.class, "test", null, null)).thenReturn(applicationRoles); List expectedApplicationRoles = externalAccessRolesServiceImpl.getAppRoles((long) 1); assertEquals(expectedApplicationRoles, applicationRoles); } + @SuppressWarnings("deprecation") @Test public void getAppRolesTest() throws Exception { List applicationRoles = new ArrayList<>(); - Mockito.when(dataAccessService1.getList(EPRole.class, "test", null, null)).thenReturn(applicationRoles); + Mockito.when(dataAccessService.getList(EPRole.class, "test", null, null)).thenReturn(applicationRoles); List expectedApplicationRoles = externalAccessRolesServiceImpl.getAppRoles((long) 10); assertEquals(expectedApplicationRoles, applicationRoles); } - // @SuppressWarnings("null") - // @Test(expected = java.lang.Exception.class) - // public void getAppRolesExceptionTest() throws Exception{ - // List applicationRoles = new ArrayList<>(); - // DataAccessService dataAccessService = null ; - // Mockito.when(dataAccessService.getList(EPRole.class, "where app_id = 10", - // null, null)).thenThrow(nullPointerException); - // List expectedApplicationRoles = - // externalAccessRolesServiceImpl.getAppRoles((long) 10); - // assertEquals(expectedApplicationRoles,applicationRoles); - // } - + @SuppressWarnings("deprecation") @Test public void getAppExceptionTest() throws Exception { List app = new ArrayList<>(); - Mockito.when(dataAccessService1.getList(EPApp.class, " where ueb_key = '" + uebKey + "'", null, null)) + Mockito.when(dataAccessService.getList(EPApp.class, " where ueb_key = '" + uebKey + "'", null, null)) .thenReturn(app); List expectedapp = externalAccessRolesServiceImpl.getApp(uebKey); assertEquals(app, expectedapp); @@ -174,11 +246,12 @@ public class ExternalAccessRolesServiceImplTest { public void getAppErrorTest() throws Exception { List appList = new ArrayList<>(); EPApp app = mockApp(); + app.setEnabled(false); appList.add(app); final Map appUebkeyParams = new HashMap<>(); appUebkeyParams.put("appKey", "test-ueb-key"); - Mockito.when(dataAccessService1.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) - .thenReturn(appList); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); externalAccessRolesServiceImpl.getApp(uebKey); } @@ -190,7 +263,7 @@ public class ExternalAccessRolesServiceImplTest { appList.add(app); final Map appUebkeyParams = new HashMap<>(); appUebkeyParams.put("appKey", "test-ueb-key"); - Mockito.when(dataAccessService1.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) .thenReturn(appList); List expectedapp = externalAccessRolesServiceImpl.getApp(uebKey); assertEquals(appList, expectedapp); @@ -218,12 +291,13 @@ public class ExternalAccessRolesServiceImplTest { roleList.add(ePRole); final Map appUebkeyParams = new HashMap<>(); appUebkeyParams.put("appKey", "test-ueb-key"); - Mockito.when(dataAccessService1.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) .thenReturn(appList); final Map getPartnerAppRoleParams = new HashMap<>(); getPartnerAppRoleParams.put("appRoleId", role.getId()); - getPartnerAppRoleParams.put("appId", app.getId()); - Mockito.when(dataAccessService1.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams, null)).thenReturn(roleList); + getPartnerAppRoleParams.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams, null)) + .thenReturn(roleList); Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)) .thenReturn("Testurl"); ResponseEntity addResponse = new ResponseEntity<>(HttpStatus.CREATED); @@ -233,7 +307,6 @@ public class ExternalAccessRolesServiceImplTest { assertTrue(externalAccessRolesServiceImpl.addRole(role, uebKey)); } - @Test public void addRoleMethodNotAllowedTest() throws Exception { HttpHeaders headers = new HttpHeaders(); @@ -255,12 +328,13 @@ public class ExternalAccessRolesServiceImplTest { roleList.add(ePRole); final Map appUebkeyParams = new HashMap<>(); appUebkeyParams.put("appKey", "test-ueb-key"); - Mockito.when(dataAccessService1.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) .thenReturn(appList); final Map getPartnerAppRoleParams = new HashMap<>(); getPartnerAppRoleParams.put("appRoleId", role.getId()); - getPartnerAppRoleParams.put("appId", app.getId()); - Mockito.when(dataAccessService1.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams, null)).thenReturn(roleList); + getPartnerAppRoleParams.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams, null)) + .thenReturn(roleList); Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)) .thenReturn("Testurl"); ResponseEntity addResponse = new ResponseEntity<>(HttpStatus.METHOD_NOT_ALLOWED); @@ -303,7 +377,7 @@ public class ExternalAccessRolesServiceImplTest { CentralV2RoleFunction domainCentralRoleFunction = new CentralV2RoleFunction(); domainCentralRoleFunction.setCode("menu_fun_code"); centralRoleFunctionList.add(domainCentralRoleFunction); - Mockito.when(dataAccessService1.executeNamedQuery("getRoleFunction", params, null)) + Mockito.when(dataAccessService.executeNamedQuery("getRoleFunction", params, null)) .thenReturn(centralRoleFunctionList); ResponseEntity addResponse = new ResponseEntity<>(HttpStatus.OK); Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE), @@ -312,11 +386,12 @@ public class ExternalAccessRolesServiceImplTest { PowerMockito.mockStatic(EcompPortalUtils.class); Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers); - Mockito.doNothing().when(dataAccessService1).deleteDomainObjects(EPAppRoleFunction.class, + Mockito.doNothing().when(dataAccessService).deleteDomainObjects(EPAppRoleFunction.class, "app_id = " + app.getId() + " and function_cd = '" + "menu_fun_code" + "'", null); - + assertTrue(externalAccessRolesServiceImpl.deleteCentralRoleFunction("menu_fun_code", app)); } + @Test public void deleteCentralRoleFunctionFailTest() throws Exception { final Map params = new HashMap<>(); @@ -328,16 +403,14 @@ public class ExternalAccessRolesServiceImplTest { domainCentralRoleFunction.setCode("menu_fun_code"); centralRoleFunctionList.add(domainCentralRoleFunction); HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.NOT_FOUND); - Mockito.when(dataAccessService1.executeNamedQuery("getRoleFunction", params, null)) + Mockito.when(dataAccessService.executeNamedQuery("getRoleFunction", params, null)) .thenReturn(centralRoleFunctionList); - ResponseEntity addResponse = new ResponseEntity<>(HttpStatus.NOT_FOUND); Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE), Matchers.>any(), Matchers.eq(String.class))).thenThrow(httpClientErrorException); HttpHeaders headers = new HttpHeaders(); PowerMockito.mockStatic(EcompPortalUtils.class); Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers); - - Mockito.doNothing().when(dataAccessService1).deleteDomainObjects(EPAppRoleFunction.class, + Mockito.doNothing().when(dataAccessService).deleteDomainObjects(EPAppRoleFunction.class, "app_id = " + app.getId() + " and function_cd = '" + "menu_fun_code" + "'", null); boolean returnedValue = externalAccessRolesServiceImpl.deleteCentralRoleFunction("menu_fun_code", app); @@ -354,71 +427,123 @@ public class ExternalAccessRolesServiceImplTest { CentralV2RoleFunction domainCentralRoleFunction = new CentralV2RoleFunction(); domainCentralRoleFunction.setCode("menu_fun_code"); centralRoleFunctionList.add(domainCentralRoleFunction); - Mockito.when(dataAccessService1.executeNamedQuery("getAppFunctionDetails", params, null)) + Mockito.when(dataAccessService.executeNamedQuery("getAppFunctionDetails", params, null)) .thenThrow(nullPointerException); assertTrue(externalAccessRolesServiceImpl.deleteCentralRoleFunction("menu_fun_code", app)); } @Test - public void getUserTest() { + public void getUserTest() throws InvalidUserException { List userList = new ArrayList<>(); EPUser user = mockUser.mockEPUser(); userList.add(user); final Map userParams = new HashMap<>(); userParams.put("org_user_id", "guestT"); - Mockito.when(dataAccessService1.executeNamedQuery("getEPUserByOrgUserId", userParams, null)) + Mockito.when(dataAccessService.executeNamedQuery("getEPUserByOrgUserId", userParams, null)) .thenReturn(userList); List expectedUserList = externalAccessRolesServiceImpl.getUser("guestT"); assertEquals(expectedUserList, userList); } - - - public void saveCentralRoleFunctionTest() throws Exception { - CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction(); - centralV2RoleFunction.setCode("menu_test"); + + @Test + public void saveCentralRoleFunctionNewTestForV2() throws Exception { + PowerMockito.mockStatic(EcompPortalUtils.class); EPApp app = mockApp(); app.setId((long) 1); + CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction(); + centralV2RoleFunction.setCode("test_code"); + centralV2RoleFunction.setName("test name"); + centralV2RoleFunction.setAppId(app.getId()); + centralV2RoleFunction.setAction("*"); + centralV2RoleFunction.setType("test_type"); final Map params = new HashMap<>(); - params.put("functionCd", "menu_test"); params.put("appId", String.valueOf(1)); + + List appRoleFunc = new ArrayList<>(); + appRoleFunc.add(centralV2RoleFunction); + params.put(FUNCTION_CODE_PARAMS, centralV2RoleFunction.getType() + FUNCTION_PIPE + + centralV2RoleFunction.getCode() + FUNCTION_PIPE + centralV2RoleFunction.getAction()); + Mockito.when(dataAccessService.executeNamedQuery("getRoleFunction", params, null)).thenReturn(appRoleFunc); + Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true); + HttpHeaders headers = new HttpHeaders(); + Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers); + JSONObject mockJsonObjectPerm = new JSONObject(); + JSONObject mockJsonObjectFinalPerm = new JSONObject(); + mockJsonObjectPerm.put("type", "com.test.app.test_type"); + mockJsonObjectPerm.put("instance", "com.test.app.test_code"); + mockJsonObjectPerm.put("action", "*"); + mockJsonObjectPerm.put("description", "test name"); + List mockJson = new ArrayList<>(); + mockJson.add(mockJsonObjectPerm); + mockJsonObjectFinalPerm.put("perm", mockJson); + ResponseEntity getResponse = new ResponseEntity<>(mockJsonObjectFinalPerm.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + ResponseEntity updateResponse = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(updateResponse); + Boolean actual = externalAccessRolesServiceImpl.saveCentralRoleFunction(centralV2RoleFunction, app); + assertEquals(true, actual); + } + + @Test + public void saveCentralRoleFunctionUpdateForV2Test() throws Exception { PowerMockito.mockStatic(EcompPortalUtils.class); + EPApp app = mockApp(); + app.setId((long) 1); + CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction(); + centralV2RoleFunction.setCode("test_code"); + centralV2RoleFunction.setName("test name2"); + centralV2RoleFunction.setAppId(app.getId()); + centralV2RoleFunction.setAction("*"); + centralV2RoleFunction.setType("test_type"); + CentralV2RoleFunction centralV2RoleFunctionExisting = new CentralV2RoleFunction(); + centralV2RoleFunctionExisting.setCode("test_code"); + centralV2RoleFunctionExisting.setName("test name"); + centralV2RoleFunctionExisting.setAppId(app.getId()); + centralV2RoleFunctionExisting.setAction("*"); + centralV2RoleFunctionExisting.setType("test_type"); + final Map params = new HashMap<>(); + params.put("appId", String.valueOf(1)); + List appRoleFunc = new ArrayList<>(); + appRoleFunc.add(centralV2RoleFunctionExisting); + params.put(FUNCTION_CODE_PARAMS, centralV2RoleFunction.getType() + FUNCTION_PIPE + + centralV2RoleFunction.getCode() + FUNCTION_PIPE + centralV2RoleFunction.getAction()); + Mockito.when(dataAccessService.executeNamedQuery("getRoleFunction", params, null)).thenReturn(appRoleFunc); + Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true); HttpHeaders headers = new HttpHeaders(); Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers); - List appRoleFunc = new ArrayList<>(); - appRoleFunc.add(centralV2RoleFunction); - Mockito.when(dataAccessService1.executeNamedQuery("getAppFunctionDetails", params, - null)).thenReturn(appRoleFunc); - ResponseEntity addResponse = new ResponseEntity<>(HttpStatus.OK); + JSONObject mockJsonObjectPerm = new JSONObject(); + JSONObject mockJsonObjectFinalPerm = new JSONObject(); + mockJsonObjectPerm.put("type", "com.test.app.test_type"); + mockJsonObjectPerm.put("instance", "test_code"); + mockJsonObjectPerm.put("action", "*"); + mockJsonObjectPerm.put("description", "test name"); + List mockJson = new ArrayList<>(); + mockJson.add(mockJsonObjectPerm); + mockJsonObjectFinalPerm.put("perm", mockJson); + ResponseEntity getResponse = new ResponseEntity<>(mockJsonObjectFinalPerm.toString(), HttpStatus.OK); Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), - Matchers.>any(), Matchers.eq(String.class))).thenReturn(addResponse); + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + ResponseEntity updateResponse = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.PUT), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(updateResponse); + Boolean actual = externalAccessRolesServiceImpl.saveCentralRoleFunction(centralV2RoleFunction, app); + assertEquals(true, actual); } - -// @Test -// public void getAllAppUsersIfAppIsPortalTest() throws Exception -// { -// List expectedapps = new ArrayList<>(); -// EPApp app = new EPApp(); -// app.setEnabled(true); -// app.setId((long) 1); -// expectedapps.add(app); -// List applicationRoles = new ArrayList<>(); -// Mockito.when(dataAccessService1.getList(EPRole.class, "test", null, null)).thenReturn(applicationRoles); -// Mockito.when(dataAccessService1.getList(EPApp.class, " where ueb_key = '" + uebKey + "'", null, null)).thenReturn(expectedapps); -// externalAccessRolesServiceImpl.getAllAppUsers(uebKey); -// } - - + + @SuppressWarnings("deprecation") @Test(expected = IndexOutOfBoundsException.class) - public void getAllAppUsersTest() throws Exception - { - List expectedapps = new ArrayList<>(); + public void getAllAppUsersTest() throws Exception { + List expectedapps = new ArrayList<>(); EPApp app = new EPApp(); app.setEnabled(true); app.setId((long) 10); expectedapps.add(app); List applicationRoles = new ArrayList<>(); - Mockito.when(dataAccessService1.getList(EPRole.class, "test", null, null)).thenReturn(applicationRoles); - Mockito.when(dataAccessService1.getList(EPApp.class, " where ueb_key = '" + uebKey + "'", null, null)).thenReturn(expectedapps); + Mockito.when(dataAccessService.getList(EPRole.class, "test", null, null)).thenReturn(applicationRoles); + Mockito.when(dataAccessService.getList(EPApp.class, " where ueb_key = '" + uebKey + "'", null, null)) + .thenReturn(expectedapps); final Map appParams = new HashMap<>(); appParams.put("appId", app.getId()); List userList = new ArrayList<>(); @@ -426,31 +551,804 @@ public class ExternalAccessRolesServiceImplTest { ecompUserRoles.setOrgUserId("guestT"); ecompUserRoles.setRoleId((long) 1); ecompUserRoles.setRoleName("test"); - + EcompUserRoles ecompUserRoles2 = new EcompUserRoles(); ecompUserRoles2.setOrgUserId("guestT"); ecompUserRoles2.setRoleId((long) 2); ecompUserRoles2.setRoleName("test new"); userList.add(ecompUserRoles); userList.add(ecompUserRoles2); - - Mockito.when(dataAccessService1.executeNamedQuery("ApplicationUserRoles", appParams, null)).thenReturn(userList); + + Mockito.when(dataAccessService.executeNamedQuery("ApplicationUserRoles", appParams, null)).thenReturn(userList); List usersfinalList = externalAccessRolesServiceImpl.getAllAppUsers(uebKey); assertEquals(usersfinalList.get(0).getRoles().size(), 2); } - + @Test - public void getGlobalRolesOfPortalTest() - { - Mockito.when(dataAccessService1.executeNamedQuery("getGlobalRolesOfPortal", null, null)).thenReturn(null); + public void getGlobalRolesOfPortalTest() { + Mockito.when(dataAccessService.executeNamedQuery("getGlobalRolesOfPortal", null, null)).thenReturn(null); assertEquals(externalAccessRolesServiceImpl.getGlobalRolesOfPortal(), null); } - + @Test - public void getGlobalRolesOfPortalExceptionTest() - { + public void getGlobalRolesOfPortalExceptionTest() { List globalRoles = new ArrayList<>(); - Mockito.when(dataAccessService1.executeNamedQuery("getGlobalRolesOfPortal", null, null)).thenThrow(nullPointerException); + Mockito.when(dataAccessService.executeNamedQuery("getGlobalRolesOfPortal", null, null)) + .thenThrow(nullPointerException); assertEquals(externalAccessRolesServiceImpl.getGlobalRolesOfPortal(), globalRoles); } + + @Test + public void getRolesForAppTest() throws Exception { + EPApp app = mockApp(); + app.setId(2l); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + List applicationRoles = new ArrayList<>(); + EPRole appRole = new EPRole(); + appRole.setActive(true); + appRole.setAppId(app.getId()); + appRole.setAppRoleId(100l); + appRole.setId(10l); + appRole.setName("test"); + applicationRoles.add(appRole); + final Map appParams = new HashMap<>(); + appParams.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null)) + .thenReturn(applicationRoles); + List cenRoleFuncList = new ArrayList<>(); + CentralV2RoleFunction v2RoleFunction = new CentralV2RoleFunction(); + v2RoleFunction.setAppId(app.getId()); + v2RoleFunction.setCode("test_type|test_code|*"); + v2RoleFunction.setName("test name"); + cenRoleFuncList.add(v2RoleFunction); + final Map params = new HashMap<>(); + params.put("roleId", appRole.getId()); + params.put(APP_ID, appList.get(0).getId()); + Mockito.when(dataAccessService.executeNamedQuery("getAppRoleFunctionList", params, null)) + .thenReturn(cenRoleFuncList); + List mockGlobalRoles = new ArrayList<>(); + GlobalRoleWithApplicationRoleFunction mockGlobalRole = new GlobalRoleWithApplicationRoleFunction(); + mockGlobalRole.setActive(true); + mockGlobalRole.setAppId(app.getId()); + mockGlobalRole.setRoleId(1111l); + mockGlobalRole.setRoleName("global_test"); + mockGlobalRole.setFunctionCd("test_type|test_code|*"); + mockGlobalRole.setFunctionName("test name"); + mockGlobalRoles.add(mockGlobalRole); + Map params2 = new HashMap<>(); + params2.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getGlobalRoleWithApplicationRoleFunctions", params2, null)) + .thenReturn(mockGlobalRoles); + List globalRoles = new ArrayList<>(); + EPRole globalRole = new EPRole(); + globalRole.setName("global_test"); + globalRole.setId(1111l); + globalRole.setActive(true); + globalRoles.add(globalRole); + Mockito.when(dataAccessService.executeNamedQuery("getGlobalRolesOfPortal", null, null)).thenReturn(globalRoles); + List expected = new ArrayList<>(); + CentralV2Role cenV2Role = new CentralV2Role(); + CentralV2Role cenV2Role2 = new CentralV2Role(); + expected.add(cenV2Role); + expected.add(cenV2Role2); + List actual = externalAccessRolesServiceImpl.getRolesForApp(app.getUebKey()); + assertEquals(expected.size(), actual.size()); + } + + @Test + public void saveRoleForPortalApplicationNewTest() throws Exception { + PowerMockito.mockStatic(EcompPortalUtils.class); + EPApp app = mockApp(); + app.setId(1l); + Role addRoleTest = new Role(); + addRoleTest.setActive(true); + addRoleTest.setName("Test"); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true); + HttpHeaders headers = new HttpHeaders(); + JSONObject mockJsonObjectRole = new JSONObject(); + Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers); + ResponseEntity getResponse = new ResponseEntity<>(mockJsonObjectRole.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + final Map epAppPortalRoleParams = new HashMap<>(); + epAppPortalRoleParams.put(APP_ROLE_NAME_PARAM, addRoleTest.getName()); + List getRoleCreated = new ArrayList<>(); + EPRole roleCreate = new EPRole(); + roleCreate.setActive(true); + roleCreate.setId(10l); + roleCreate.setName("test"); + getRoleCreated.add(roleCreate); + Mockito.when(dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, epAppPortalRoleParams, null)) + .thenReturn(getRoleCreated); + Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true); + ResponseEntity addResponse = new ResponseEntity<>(HttpStatus.CREATED); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(addResponse); + ExternalRequestFieldsValidator actual = externalAccessRolesServiceImpl.saveRoleForApplication(addRoleTest, + app.getUebKey()); + ExternalRequestFieldsValidator expected = new ExternalRequestFieldsValidator(true, ""); + assertEquals(expected, actual); + } + + @Test + public void saveRoleForPortalApplicationUpdateTest() throws Exception { + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + EPApp app = mockApp(); + app.setId(1l); + Role addRoleTest = new Role(); + SortedSet roleFuncSet = new TreeSet<>(); + RoleFunction roleFunc= new RoleFunction(); + roleFunc.setName("Test Name"); + roleFunc.setCode("test_type|test_instance|*"); + RoleFunction roleFunc2 = new RoleFunction(); + roleFunc2.setName("Test Name3"); + roleFunc2.setCode("test_type3|test_instance3|*"); + roleFuncSet.add(roleFunc); + roleFuncSet.add(roleFunc2); + addRoleTest.setActive(true); + addRoleTest.setName("Test2"); + addRoleTest.setId(2l); + addRoleTest.setRoleFunctions(roleFuncSet); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + List globalRoles = new ArrayList<>(); + EPRole globalRole = new EPRole(); + globalRole.setName("global_test"); + globalRole.setId(1111l); + globalRole.setActive(true); + globalRoles.add(globalRole); + Mockito.when(dataAccessService.executeNamedQuery("getGlobalRolesOfPortal", null, null)).thenReturn(globalRoles); + List epRoleList = new ArrayList<>(); + EPRole getEPRole = new EPRole(); + getEPRole.setName("Test"); + getEPRole.setId(2l); + getEPRole.setActive(true); + epRoleList.add(getEPRole); + final Map getPortalAppRoleParams = new HashMap<>(); + getPortalAppRoleParams.put("roleId", addRoleTest.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPortalAppRoleByRoleId", getPortalAppRoleParams, null)) + .thenReturn(epRoleList); + Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true); + HttpHeaders headers = new HttpHeaders(); + Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers); + JSONObject mockJsonObjectRole = new JSONObject(); + JSONObject mockJsonObjectFinalRole = new JSONObject(); + JSONObject mockJsonObjectPerm1 = new JSONObject(); + JSONObject mockJsonObjectPerm2 = new JSONObject(); + mockJsonObjectPerm1.put("type", "com.test.app.test_type"); + mockJsonObjectPerm1.put("instance", "test_instance"); + mockJsonObjectPerm1.put("action", "*"); + mockJsonObjectPerm2.put("type", "com.test.app.test_type2"); + mockJsonObjectPerm2.put("instance", "test_instance2"); + mockJsonObjectPerm2.put("action", "*"); + List permsList = new ArrayList<>(); + permsList.add(mockJsonObjectPerm1); + permsList.add(mockJsonObjectPerm2); + mockJsonObjectRole.put("name", "com.test.app.Test"); + mockJsonObjectRole.put("perms", permsList); + mockJsonObjectRole.put("description", + "{\"id\":\"2\",\"name\":\"Test\",\"active\":\"true\",\"priority\":\"null\",\"appId\":\"null\",\"appRoleId\":\"null\"}"); + List roleList = new ArrayList<>(); + roleList.add(mockJsonObjectRole); + mockJsonObjectFinalRole.put("role", roleList); + ResponseEntity getResponse = new ResponseEntity<>(mockJsonObjectFinalRole.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + ResponseEntity delResponse = new ResponseEntity<>(roleList.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(delResponse); + ResponseEntity addRoleResponse = new ResponseEntity<>(HttpStatus.CREATED); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(addRoleResponse); + final Map params = new HashMap<>(); + params.put("uebKey", app.getUebKey()); + params.put("roleId", String.valueOf(getEPRole.getId())); + List userRolesList = new ArrayList<>(); + BulkUploadUserRoles bulkUploadUserRoles = new BulkUploadUserRoles(); + bulkUploadUserRoles.setAppNameSpace("com.test.app"); + bulkUploadUserRoles.setOrgUserId("guestT"); + bulkUploadUserRoles.setRoleName("Test2"); + userRolesList.add(bulkUploadUserRoles); + Mockito.when(dataAccessService.executeNamedQuery("getBulkUsersForSingleRole", params, null)) + .thenReturn(userRolesList); + Mockito.when( + EPCommonSystemProperties.containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)) + .thenReturn(true); + Mockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)).thenReturn("@test.com"); + ResponseEntity mockBulkUsersUpload = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(mockBulkUsersUpload); + List appRoleFunctionList = new ArrayList<>(); + final Map appRoleFuncsParams = new HashMap<>(); + appRoleFuncsParams.put("appId", app.getId()); + appRoleFuncsParams.put("roleId", getEPRole.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", appRoleFuncsParams, null)).thenReturn(appRoleFunctionList); + Mockito.when(EcompPortalUtils.getFunctionCode(roleFunc.getCode())).thenReturn("test_instance"); + Mockito.when(EcompPortalUtils.getFunctionCode(roleFunc2.getCode())).thenReturn("test_instance3"); + final Map getAppFunctionParams = new HashMap<>(); + getAppFunctionParams.put("appId", String.valueOf(app.getId())); + getAppFunctionParams.put(FUNCTION_CODE_PARAMS, roleFunc.getCode()); + List v2RoleFunction = new ArrayList<>(); + CentralV2RoleFunction v2RoleFunction1 = new CentralV2RoleFunction("test_type|test_instance|*", "Test Name"); + v2RoleFunction.add(v2RoleFunction1); + Mockito.when(dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, getAppFunctionParams, null)).thenReturn(v2RoleFunction); + final Map getAppFunctionParams2 = new HashMap<>(); + getAppFunctionParams2.put("appId", String.valueOf(app.getId())); + getAppFunctionParams2.put(FUNCTION_CODE_PARAMS, roleFunc2.getCode()); + List v2RoleFunction2 = new ArrayList<>(); + CentralV2RoleFunction v2RoleFunction3 = new CentralV2RoleFunction("test_type3|test_instance3|*", "Test Name3"); + v2RoleFunction2.add(v2RoleFunction3); + Mockito.when(dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, getAppFunctionParams2, null)).thenReturn(v2RoleFunction2); + ExternalRequestFieldsValidator actual = externalAccessRolesServiceImpl.saveRoleForApplication(addRoleTest, + app.getUebKey()); + ExternalRequestFieldsValidator expected = new ExternalRequestFieldsValidator(true, ""); + assertEquals(expected, actual); + } + + @Test + public void saveGlobalRoleFunctionsForPartnerApplicationUpdateTest() throws Exception { + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + EPApp app = mockApp(); + app.setId(2l); + Role addRoleTest = new Role(); + SortedSet roleFuncSet = new TreeSet<>(); + RoleFunction roleFunc= new RoleFunction(); + roleFunc.setName("Test Name"); + roleFunc.setCode("test_type|test_instance|*"); + RoleFunction roleFunc2 = new RoleFunction(); + roleFunc2.setName("Test Name3"); + roleFunc2.setCode("test_type3|test_instance3|*"); + roleFuncSet.add(roleFunc); + roleFuncSet.add(roleFunc2); + addRoleTest.setActive(true); + addRoleTest.setName("global_test"); + addRoleTest.setId(1111l); + addRoleTest.setRoleFunctions(roleFuncSet); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + List globalRoles = new ArrayList<>(); + EPRole globalRole = new EPRole(); + globalRole.setName("global_test"); + globalRole.setId(1111l); + globalRole.setActive(true); + EPRole globalRole2 = new EPRole(); + globalRole2.setName("global_test2"); + globalRole2.setId(2222l); + globalRole2.setActive(true); + globalRoles.add(globalRole); + globalRoles.add(globalRole2); + Mockito.when(dataAccessService.executeNamedQuery("getGlobalRolesOfPortal", null, null)).thenReturn(globalRoles); + List getGlobalRoles = new ArrayList<>(); + EPRole getEPGlobalRole = new EPRole(); + getEPGlobalRole.setName("global_test"); + getEPGlobalRole.setId(1111l); + getEPGlobalRole.setActive(true); + getGlobalRoles.add(getEPGlobalRole); + final Map getPortalAppRoleParams = new HashMap<>(); + getPortalAppRoleParams.put("roleId", globalRole.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPortalAppRoleByRoleId", getPortalAppRoleParams, null)) + .thenReturn(getGlobalRoles); + Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true); + Mockito.when(epAppCommonServiceImpl.getApp(PortalConstants.PORTAL_APP_ID)).thenReturn(app); + JSONObject mockJsonObjectPerm = new JSONObject(); + JSONObject mockJsonObjectPerm2 = new JSONObject(); + JSONObject mockJsonObjectPerm3 = new JSONObject(); + JSONObject mockJsonObjectFinalPerm = new JSONObject(); + mockJsonObjectPerm.put("type", "com.test.app.test_type"); + mockJsonObjectPerm.put("instance", "test_instance"); + mockJsonObjectPerm.put("action", "*"); + mockJsonObjectPerm.put("description", "Test Name"); + mockJsonObjectPerm2.put("type", "com.test.app.access"); + mockJsonObjectPerm2.put("instance", "test_instance2"); + mockJsonObjectPerm2.put("action", "*"); + mockJsonObjectPerm2.put("description", "Test Name2"); + mockJsonObjectPerm3.put("type", "com.test.app.test_type3"); + mockJsonObjectPerm3.put("instance", "test_instance3"); + mockJsonObjectPerm3.put("action", "*"); + mockJsonObjectPerm3.put("description", "Test Name3"); + List mockJson = new ArrayList<>(); + mockJson.add(mockJsonObjectPerm); + mockJson.add(mockJsonObjectPerm2); + mockJson.add(mockJsonObjectPerm3); + mockJsonObjectFinalPerm.put("perm", mockJson); + ResponseEntity getResponse = new ResponseEntity<>(mockJsonObjectFinalPerm.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + Mockito.when(EcompPortalUtils.getFunctionCode(roleFunc.getCode())).thenReturn("test_instance"); + ResponseEntity postResponse = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(postResponse); + Mockito.when(EcompPortalUtils.getFunctionCode(roleFunc.getCode())).thenReturn("test_instance"); + final Map epAppRoleFuncParams = new HashMap<>(); + epAppRoleFuncParams.put("requestedAppId", app.getId()); + epAppRoleFuncParams.put("roleId",globalRole.getId()); + List globalRoleFunctionList = new ArrayList<>(); + Mockito.when(dataAccessService.executeNamedQuery("getGlobalRoleForRequestedApp", epAppRoleFuncParams, null)).thenReturn(globalRoleFunctionList); + final Map appRoleFuncsParams = new HashMap<>(); + appRoleFuncsParams.put("appId", app.getId()); + appRoleFuncsParams.put("roleId", globalRole.getId()); + List appRoleFunctionList = new ArrayList<>(); + EPAppRoleFunction epAppRoleFunction = new EPAppRoleFunction(); + epAppRoleFunction.setAppId(app.getId()); + epAppRoleFunction.setRoleAppId("1"); + epAppRoleFunction.setCode("test"); + epAppRoleFunction.setRoleId(1111l); + appRoleFunctionList.add(epAppRoleFunction); + Mockito.when(dataAccessService.executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", appRoleFuncsParams, null)).thenReturn(appRoleFunctionList); + final Map getAppFunctionParams = new HashMap<>(); + Mockito.when(EcompPortalUtils.getFunctionCode(roleFunc.getCode())).thenReturn("test_instance"); + Mockito.when(EcompPortalUtils.getFunctionCode(roleFunc2.getCode())).thenReturn("test_instance3"); + getAppFunctionParams.put("appId", String.valueOf(app.getId())); + getAppFunctionParams.put(FUNCTION_CODE_PARAMS, roleFunc.getCode()); + List roleFunction = new ArrayList<>(); + CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction(null, roleFunc.getCode(), roleFunc.getName(), app.getId(), null); + roleFunction.add(centralV2RoleFunction); + Mockito.when(dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, getAppFunctionParams, null)).thenReturn(roleFunction); + final Map getAppFunctionParams2 = new HashMap<>(); + getAppFunctionParams2.put("appId", String.valueOf(app.getId())); + getAppFunctionParams2.put(FUNCTION_CODE_PARAMS, roleFunc2.getCode()); + List roleFunction2 = new ArrayList<>(); + CentralV2RoleFunction centralV2RoleFunction2 = new CentralV2RoleFunction(null, roleFunc2.getCode(), roleFunc2.getName(), app.getId(), null); + roleFunction2.add(centralV2RoleFunction2); + Mockito.when(dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, getAppFunctionParams2, null)).thenReturn(roleFunction2); + ExternalRequestFieldsValidator actual = externalAccessRolesServiceImpl.saveRoleForApplication(addRoleTest, + app.getUebKey()); + ExternalRequestFieldsValidator expected = new ExternalRequestFieldsValidator(true, ""); + assertEquals(expected, actual); + } + + @Test + public void syncRoleFunctionFromExternalAccessSystemTest() { + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + EPApp app = mockApp(); + app.setId(2l); + JSONObject mockJsonObjectFinalPerm = new JSONObject(); + JSONObject mockJsonObjectPerm = new JSONObject(); + JSONObject mockJsonObjectPerm2 = new JSONObject(); + JSONObject mockJsonObjectPerm3 = new JSONObject(); + mockJsonObjectPerm.put("type", "com.test.app.test_type"); + mockJsonObjectPerm.put("instance", "test_instance"); + mockJsonObjectPerm.put("action", "*"); + mockJsonObjectPerm.put("description", "test_name"); + List rolePermList = new ArrayList<>(); + rolePermList.add("com.test.app|test1"); + mockJsonObjectPerm.put("roles", rolePermList); + mockJsonObjectPerm2.put("type", "com.test.app.test_type2"); + mockJsonObjectPerm2.put("instance", "test_instance2"); + mockJsonObjectPerm2.put("action", "*"); + mockJsonObjectPerm2.put("description", "test_name2"); + mockJsonObjectPerm3.put("type", "com.test.app.access"); + mockJsonObjectPerm3.put("instance", "test_instance3"); + mockJsonObjectPerm3.put("action", "*"); + mockJsonObjectPerm3.put("description", "test_name3"); + List permsList = new ArrayList<>(); + permsList.add(mockJsonObjectPerm); + permsList.add(mockJsonObjectPerm2); + permsList.add(mockJsonObjectPerm3); + mockJsonObjectFinalPerm.put("perm", permsList); + ResponseEntity getResponse = new ResponseEntity<>(mockJsonObjectFinalPerm.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + final Map params = new HashMap<>(); + params.put(APP_ID, app.getId()); + List appFunctions = new ArrayList<>(); + CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction(null, "test_type|test_instance|*", "test_name", app.getId(), null); + appFunctions.add(centralV2RoleFunction); + Mockito.when(dataAccessService.executeNamedQuery("getAllRoleFunctions", params,null)).thenReturn(appFunctions); + List globalRoles = new ArrayList<>(); + EPRole globalRole = new EPRole(); + globalRole.setName("global_test"); + globalRole.setId(1111l); + globalRole.setActive(true); + globalRoles.add(globalRole); + Mockito.when(dataAccessService.executeNamedQuery("getGlobalRolesOfPortal", null, null)).thenReturn(globalRoles); + List getCurrentRoleList = new ArrayList<>(); + EPRole getEPRole = new EPRole(); + getEPRole.setName("test1"); + getEPRole.setId(2l); + getEPRole.setActive(true); + EPRole getEPRole2 = new EPRole(); + getEPRole2.setName("global_test"); + getEPRole2.setId(1111l); + getEPRole2.setActive(true); + getCurrentRoleList.add(getEPRole); + getCurrentRoleList.add(getEPRole2); + Mockito.when(dataAccessService.executeNamedQuery("getPortalAppRolesList", null, null)).thenReturn(getCurrentRoleList); + final Map appSyncFuncsParams = new HashMap<>(); + appSyncFuncsParams.put("appId", String.valueOf(app.getId())); + appSyncFuncsParams.put("functionCd", ""); + List roleFunctionList = new ArrayList<>(); + Mockito.when(dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appSyncFuncsParams, + null)).thenReturn(roleFunctionList); + String code = centralV2RoleFunction.getCode(); + appSyncFuncsParams.put("functionCd", code); + CentralV2RoleFunction getCentralV2RoleFunction = new CentralV2RoleFunction(null, "test_type|test_instance|*", "test_name", app.getId(), null); + roleFunctionList.add(getCentralV2RoleFunction); + Mockito.when(dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appSyncFuncsParams, + null)).thenReturn(roleFunctionList); + final Map appRoleFuncParams = new HashMap<>(); + appRoleFuncParams.put("functionCd", roleFunctionList.get(0).getCode()); + appRoleFuncParams.put("appId", String.valueOf(app.getId())); + Mockito.when(dataAccessService.executeNamedQuery("getCurrentAppRoleFunctions", + appRoleFuncParams, null)).thenReturn(new ArrayList()); + Mockito.when(EcompPortalUtils.checkNameSpaceMatching("com.test.app", app.getNameSpace())).thenReturn(true); + Mockito.when(EcompPortalUtils.getFunctionCode("test_type2|test_instance2|*")).thenReturn("test_instance2"); + appSyncFuncsParams.put("functionCd", "test_instance2"); + List roleFunctionList2 = new ArrayList<>(); + Mockito.when(dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appSyncFuncsParams, + null)).thenReturn(roleFunctionList2); + String code2 = "test_type2|test_instance2|*"; + appSyncFuncsParams.put("functionCd", code2); + CentralV2RoleFunction getCentralV2RoleFunction2 = new CentralV2RoleFunction(null, "test_type2|test_instance2|*", "test_name2", app.getId(), null); + roleFunctionList2.add(getCentralV2RoleFunction2); + Mockito.when(dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appSyncFuncsParams, + null)).thenReturn(roleFunctionList2); + externalAccessRolesServiceImpl.syncRoleFunctionFromExternalAccessSystem(app); + } + + @Test + public void syncApplicationRolesWithEcompDBTest(){ + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + EPApp app = mockApp(); + app.setId(2l); + JSONObject mockJsonObjectRole = new JSONObject(); + JSONObject mockJsonObjectRole2 = new JSONObject(); + JSONObject mockJsonObjectFinalRole = new JSONObject(); + JSONObject mockJsonObjectPerm1 = new JSONObject(); + JSONObject mockJsonObjectPerm2 = new JSONObject(); + mockJsonObjectPerm1.put("type", "com.test.app.test_type"); + mockJsonObjectPerm1.put("instance", "test_instance"); + mockJsonObjectPerm1.put("action", "*"); + mockJsonObjectPerm2.put("type", "com.test.app.test_type2"); + mockJsonObjectPerm2.put("instance", "test_instance2"); + mockJsonObjectPerm2.put("action", "*"); + List permsList = new ArrayList<>(); + permsList.add(mockJsonObjectPerm1); + permsList.add(mockJsonObjectPerm2); + mockJsonObjectRole.put("name", "com.test.app.Test"); + mockJsonObjectRole.put("perms", permsList); + mockJsonObjectRole.put("description", + "{\"id\":\"2\",\"name\":\"test1\",\"active\":\"true\",\"priority\":\"null\",\"appId\":\"2\",\"appRoleId\":\"2\"}"); + mockJsonObjectRole2.put("name", "com.test.app.Test2"); + List permsList2 = new ArrayList<>(); + permsList2.add(mockJsonObjectPerm1); + mockJsonObjectRole2.put("perms", permsList2); + List roleList = new ArrayList<>(); + roleList.add(mockJsonObjectRole); + roleList.add(mockJsonObjectRole2); + mockJsonObjectFinalRole.put("role", roleList); + ResponseEntity getResponse = new ResponseEntity<>(mockJsonObjectFinalRole.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + List getCurrentRoleList = new ArrayList<>(); + EPRole getEPRole = new EPRole(); + getEPRole.setName("Test"); + getEPRole.setId(2l); + getEPRole.setAppId(app.getId()); + getEPRole.setAppRoleId(2l); + getEPRole.setActive(true); + EPRole getEPRole2 = new EPRole(); + getEPRole2.setName("Test3"); + getEPRole2.setId(3l); + getEPRole.setAppId(app.getId()); + getEPRole.setAppRoleId(3l); + getEPRole2.setActive(true); + getCurrentRoleList.add(getEPRole); + getCurrentRoleList.add(getEPRole2); + final Map appParams = new HashMap<>(); + appParams.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null)).thenReturn(getCurrentRoleList); + Mockito.when(EcompPortalUtils.checkNameSpaceMatching("com.test.app.test_type", app.getNameSpace())).thenReturn(true); + Mockito.when(EcompPortalUtils.checkNameSpaceMatching("com.test.app.test_type2", app.getNameSpace())).thenReturn(true); + List appRoleFunctions = new ArrayList<>(); + EPAppRoleFunction epAppRoleFunction = new EPAppRoleFunction(); + epAppRoleFunction.setAppId(app.getId()); + epAppRoleFunction.setCode("test_type|test_instance|*"); + epAppRoleFunction.setRoleId(getEPRole.getId()); + appRoleFunctions.add(epAppRoleFunction); + final Map appRoleFuncsParams = new HashMap<>(); + appRoleFuncsParams.put("appId", app.getId()); + appRoleFuncsParams.put("roleId", Long.valueOf(getEPRole.getId())); + Mockito.when(dataAccessService.executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", appRoleFuncsParams, null)).thenReturn(appRoleFunctions); + List getV2RoleFunction = new ArrayList<>(); + final Map appFuncsParams = new HashMap<>(); + appFuncsParams.put("appId", String.valueOf(app.getId())); + appFuncsParams.put("functionCd", "test_instance2"); + Mockito.when(dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appFuncsParams, null)).thenReturn(getV2RoleFunction); + appFuncsParams.put("functionCd", "test_type2|test_instance2|*"); + CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction(); + centralV2RoleFunction.setAppId(app.getId()); + centralV2RoleFunction.setCode("test_type2|test_instance2|*"); + centralV2RoleFunction.setName("test_name2"); + getV2RoleFunction.add(centralV2RoleFunction); + final Map extRoleParams = new HashMap<>(); + List roleListDeactivate = new ArrayList<>(); + extRoleParams.put(APP_ROLE_NAME_PARAM, "Test3"); + extRoleParams.put(APP_ID, app.getId().toString()); + EPRole getEPRoleDeactivate = new EPRole(); + getEPRoleDeactivate.setName("Test3"); + getEPRoleDeactivate.setId(3l); + getEPRoleDeactivate.setAppId(app.getId()); + getEPRoleDeactivate.setAppRoleId(3l); + roleListDeactivate.add(getEPRoleDeactivate); + Mockito.when(dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, extRoleParams, null)).thenReturn(roleListDeactivate); + Mockito.when(dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appFuncsParams, null)).thenReturn(getV2RoleFunction); + List updateLocalFromExtAuth = new ArrayList<>(); + updateLocalFromExtAuth.add(getEPRole); + final Map roleParams = new HashMap<>(); + roleParams.put(APP_ROLE_NAME_PARAM, getEPRole.getName()); + roleParams.put(APP_ID, app.getId().toString()); + Mockito.when(dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, roleParams, null)).thenReturn(updateLocalFromExtAuth); + roleParams.put(APP_ROLE_NAME_PARAM, getEPRole2.getName()); + List updateLocalFromExtAuth2 = new ArrayList<>(); + updateLocalFromExtAuth.add(getEPRole); + Mockito.when(dataAccessService.executeNamedQuery("getRoletoUpdateInExternalAuthSystem", roleParams, null)).thenReturn(updateLocalFromExtAuth2); + final Map globalRoleParams = new HashMap<>(); + globalRoleParams.put("appId", String.valueOf(app.getId())); + globalRoleParams.put("appRoleName", "Test2"); + List addNewRoleList = new ArrayList<>(); + EPRole addRoleInLocal = new EPRole(); + addRoleInLocal.setName("Test2"); + addRoleInLocal.setId(4l); + addRoleInLocal.setAppId(app.getId()); + addRoleInLocal.setActive(true); + addNewRoleList.add(addRoleInLocal); + Mockito.when(dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, globalRoleParams, null)).thenReturn(addNewRoleList); + final Map params = new HashMap<>(); + params.put(APP_ROLE_NAME_PARAM, "Test2"); + params.put(APP_ID, app.getId().toString()); + addRoleInLocal.setAppRoleId(4l); + addNewRoleList.add(addRoleInLocal); + Mockito.when(dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, params, null)).thenReturn(addNewRoleList); + externalAccessRolesServiceImpl.syncApplicationRolesWithEcompDB(app); + } + + @Test + public void deleteDependencyRoleRecord() throws Exception { + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + SQLQuery SqlQuery = Mockito.mock(SQLQuery.class); + EPApp app = mockApp(); + app.setId(2l); + EPUser user = mockUser.mockEPUser(); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + List epRoleList = new ArrayList<>(); + EPRole getEPRole = new EPRole(); + getEPRole.setName("Test"); + getEPRole.setId(2l); + getEPRole.setAppRoleId(2l); + getEPRole.setActive(true); + epRoleList.add(getEPRole); + final Map getPartnerAppRoleParams = new HashMap<>(); + getPartnerAppRoleParams.put("appRoleId", getEPRole.getId()); + getPartnerAppRoleParams.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams, null)) + .thenReturn(epRoleList); + Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true); + JSONObject getUser = new JSONObject(); + getUser.put("name", "com.test.app.test1"); + ResponseEntity getResponse = new ResponseEntity<>(getUser.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + ResponseEntity DelResponse = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(DelResponse); + Mockito.when(session.createSQLQuery(Matchers.anyString())).thenReturn(SqlQuery); + ExternalRequestFieldsValidator actual = externalAccessRolesServiceImpl.deleteDependencyRoleRecord(2l, app.getUebKey(), user.getOrgUserId()); + ExternalRequestFieldsValidator expected = new ExternalRequestFieldsValidator(true, ""); + assertEquals(expected, actual); + } + + @Test + public void deleteDependencyRoleRecordForPortal() throws Exception { + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + SQLQuery SqlQuery = Mockito.mock(SQLQuery.class); + EPApp app = mockApp(); + app.setId(1l); + EPUser user = mockUser.mockEPUser(); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + List epRoleList = new ArrayList<>(); + EPRole getEPRole = new EPRole(); + getEPRole.setName("Test"); + getEPRole.setId(2l); + getEPRole.setAppRoleId(2l); + getEPRole.setActive(true); + epRoleList.add(getEPRole); + final Map getPartnerAppRoleParams = new HashMap<>(); + getPartnerAppRoleParams.put("roleId", getEPRole.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPortalAppRoleByRoleId", getPartnerAppRoleParams, null)) + .thenReturn(epRoleList); + Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true); + JSONObject getUser = new JSONObject(); + getUser.put("name", "com.test.app.test1"); + ResponseEntity getResponse = new ResponseEntity<>(getUser.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + ResponseEntity DelResponse = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(DelResponse); + Mockito.when(session.createSQLQuery(Matchers.anyString())).thenReturn(SqlQuery); + ExternalRequestFieldsValidator actual = externalAccessRolesServiceImpl.deleteDependencyRoleRecord(2l, app.getUebKey(), user.getOrgUserId()); + ExternalRequestFieldsValidator expected = new ExternalRequestFieldsValidator(true, ""); + assertEquals(expected, actual); + } + + @Test + public void bulkUploadFunctionsTest() throws Exception { + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + EPApp app = mockApp(); + app.setId(2l); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + List roleFuncList = new ArrayList<>(); + RoleFunction roleFunc = new RoleFunction(); + roleFunc.setCode("test_code"); + roleFunc.setName("test_name"); + RoleFunction roleFunc2 = new RoleFunction(); + roleFunc2.setCode("test_code2"); + roleFunc2.setName("test_name2"); + roleFuncList.add(roleFunc); + roleFuncList.add(roleFunc2); + Mockito.when(dataAccessService.executeNamedQuery("getAllFunctions", null, null)).thenReturn(roleFuncList); + JSONObject perm = new JSONObject(); + JSONObject permList = new JSONObject(); + perm.put("type", app.getNameSpace()+".access"); + perm.put("instance", "type_instance"); + perm.put("action", "*"); + List addPerms = new ArrayList<>(); + addPerms.add(perm); + permList.put("perm", addPerms); + ResponseEntity getResponse = new ResponseEntity<>(permList.toString(), HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(getResponse); + ResponseEntity postResponse = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(postResponse); + Integer actual = externalAccessRolesServiceImpl.bulkUploadFunctions(app.getUebKey()); + Integer expected = 2; + assertEquals(expected, actual); + } + + @Test + public void bulkUploadRolesTest() throws Exception{ + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + EPApp app = mockApp(); + app.setId(2l); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + List epRoleList = new ArrayList<>(); + EPRole getEPRole = new EPRole(); + getEPRole.setName("Test"); + getEPRole.setId(2l); + getEPRole.setAppRoleId(2l); + getEPRole.setActive(true); + EPRole getEPRole2 = new EPRole(); + getEPRole2.setName("Test2"); + getEPRole2.setId(3l); + getEPRole2.setAppRoleId(3l); + getEPRole2.setActive(true); + epRoleList.add(getEPRole); + epRoleList.add(getEPRole2); + final Map appParams = new HashMap<>(); + appParams.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null)).thenReturn(epRoleList); + List epRoleList1 = new ArrayList<>(); + EPRole ePRole = new EPRole(); + ePRole.setName("Test"); + ePRole.setId(2l); + ePRole.setAppRoleId(2l); + ePRole.setActive(true); + epRoleList1.add(ePRole); + final Map getPartnerAppRoleParams = new HashMap<>(); + getPartnerAppRoleParams.put("appRoleId", ePRole.getId()); + getPartnerAppRoleParams.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams, null)).thenReturn(epRoleList1); + List epRoleList2 = new ArrayList<>(); + EPRole ePRole2 = new EPRole(); + ePRole2.setName("Test2"); + ePRole2.setId(3l); + ePRole2.setAppRoleId(3l); + ePRole2.setActive(true); + epRoleList2.add(ePRole2); + final Map getPartnerAppRoleParams2 = new HashMap<>(); + getPartnerAppRoleParams2.put("appRoleId", ePRole2.getId()); + getPartnerAppRoleParams2.put("appId", app.getId()); + Mockito.when(dataAccessService.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams2, null)).thenReturn(epRoleList2); + ResponseEntity postResponse = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(postResponse); + Integer actual = externalAccessRolesServiceImpl.bulkUploadRoles(app.getUebKey()); + Integer expected = 2; + assertEquals(expected, actual); + } + + @Test + public void bulkUploadUserRolesTest() throws Exception{ + PowerMockito.mockStatic(EPCommonSystemProperties.class); + PowerMockito.mockStatic(EcompPortalUtils.class); + PowerMockito.mockStatic(SystemProperties.class); + EPApp app = mockApp(); + app.setId(2l); + EPUser user = mockUser.mockEPUser(); + List appList = new ArrayList<>(); + final Map appUebkeyParams = new HashMap<>(); + appList.add(app); + appUebkeyParams.put("appKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null)) + .thenReturn(appList); + List userRolesList = new ArrayList<>(); + BulkUploadUserRoles bulkUploadUserRoles = new BulkUploadUserRoles(); + bulkUploadUserRoles.setAppNameSpace(app.getName()); + bulkUploadUserRoles.setOrgUserId(user.getOrgUserId()); + bulkUploadUserRoles.setRoleName("Test1"); + BulkUploadUserRoles bulkUploadUserRoles2 = new BulkUploadUserRoles(); + bulkUploadUserRoles2.setAppNameSpace(app.getName()); + bulkUploadUserRoles2.setOrgUserId(user.getOrgUserId()); + bulkUploadUserRoles2.setRoleName("Test2"); + userRolesList.add(bulkUploadUserRoles); + userRolesList.add(bulkUploadUserRoles2); + final Map appParams = new HashMap<>(); + appParams.put("uebKey", app.getUebKey()); + Mockito.when(dataAccessService.executeNamedQuery("getBulkUserRoles", appParams, null)).thenReturn(userRolesList); + ResponseEntity postResponse = new ResponseEntity<>(HttpStatus.OK); + Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST), + Matchers.>any(), Matchers.eq(String.class))).thenReturn(postResponse); + Integer actual = externalAccessRolesServiceImpl.bulkUploadUserRoles(app.getUebKey()); + Integer expected = 2; + assertEquals(expected, actual); + } + + }