--- /dev/null
+/*-
+ * ============LICENSE_START==========================================
+ * ONAP Portal
+ * ===================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ===================================================================
+ *
+ * Unless otherwise specified, all software contained herein is licensed
+ * under the Apache License, Version 2.0 (the "License");
+ * you may not use this software 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.
+ *
+ * Unless otherwise specified, all documentation contained herein is licensed
+ * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
+ * you may not use this documentation except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://creativecommons.org/licenses/by/4.0/
+ *
+ * Unless required by applicable law or agreed to in writing, documentation
+ * 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.
+ *
+ * ============LICENSE_END============================================
+ *
+ * ECOMP is a trademark and service mark of AT&T Intellectual Property.
+ */
+package org.onap.portalapp.portal.service;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.cxf.transport.http.HTTPException;
+import org.hibernate.Query;
+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;
+import org.mockito.InjectMocks;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.onap.portalapp.externalsystemapproval.model.ExternalSystemRoleApproval;
+import org.onap.portalapp.externalsystemapproval.model.ExternalSystemUser;
+import org.onap.portalapp.portal.core.MockEPUser;
+import org.onap.portalapp.portal.domain.EPApp;
+import org.onap.portalapp.portal.domain.EPRole;
+import org.onap.portalapp.portal.domain.EPUser;
+import org.onap.portalapp.portal.domain.EPUserApp;
+import org.onap.portalapp.portal.domain.EPUserAppCatalogRoles;
+import org.onap.portalapp.portal.domain.EPUserAppRoles;
+import org.onap.portalapp.portal.domain.EPUserAppRolesRequest;
+import org.onap.portalapp.portal.domain.EPUserAppRolesRequestDetail;
+import org.onap.portalapp.portal.domain.ExternalSystemAccess;
+import org.onap.portalapp.portal.transport.AppWithRolesForUser;
+import org.onap.portalapp.portal.transport.CentralV2Role;
+import org.onap.portalapp.portal.transport.EPUserAppCurrentRoles;
+import org.onap.portalapp.portal.transport.EcompUserAppRoles;
+import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
+import org.onap.portalapp.portal.transport.FieldsValidator;
+import org.onap.portalapp.portal.transport.FunctionalMenuItem;
+import org.onap.portalapp.portal.transport.FunctionalMenuRole;
+import org.onap.portalapp.portal.transport.RemoteRole;
+import org.onap.portalapp.portal.transport.RemoteUserWithRoles;
+import org.onap.portalapp.portal.transport.RoleInAppForUser;
+import org.onap.portalapp.portal.transport.UserApplicationRoles;
+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.restful.domain.EcompRole;
+import org.onap.portalsdk.core.service.DataAccessService;
+import org.onap.portalsdk.core.service.DataAccessServiceImpl;
+import org.onap.portalsdk.core.service.RoleServiceImpl;
+import org.onap.portalsdk.core.util.SystemProperties;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({ EcompPortalUtils.class, SystemProperties.class, PortalConstants.class,
+ EPCommonSystemProperties.class })
+public class UserRolesCommonServiceImplTest {
+
+ @Mock
+ DataAccessService dataAccessService = new DataAccessServiceImpl();
+
+ @Mock
+ EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
+
+ @Mock
+ ExternalAccessRolesServiceImpl externalAccessRolesServiceImpl = new ExternalAccessRolesServiceImpl();
+
+ @Mock
+ ApplicationsRestClientService applicationsRestClientService;
+
+ @Mock
+ RoleServiceImpl roleServiceImpl = new RoleServiceImpl();
+
+ @Mock
+ SearchServiceImpl searchServiceImpl = new SearchServiceImpl();
+
+ @Mock
+ EPRoleServiceImpl epRoleServiceImpl = new EPRoleServiceImpl();
+
+ @Mock
+ RestTemplate template = new RestTemplate();
+
+ @Mock
+ SessionFactory sessionFactory;
+
+ @Mock
+ Session session;
+
+ @Mock
+ Transaction transaction;
+
+ @InjectMocks
+ UserRolesCommonServiceImpl userRolesCommonServiceImpl = new UserRolesCommonServiceImpl();
+
+ @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();
+ }
+
+ MockEPUser mockUser = new MockEPUser();
+
+ public EPApp mockApp() {
+ EPApp app = new EPApp();
+ app.setName("Test");
+ app.setImageUrl("test");
+ app.setDescription("test");
+ app.setNotes("test");
+ app.setUrl("test");
+ app.setId((long) 1);
+ app.setAppRestEndpoint("test");
+ app.setAlternateUrl("test");
+ app.setName("test");
+ app.setMlAppName("test");
+ app.setMlAppAdminId("test");
+ app.setUsername("test");
+ app.setAppPassword("test");
+ app.setOpen(false);
+ app.setEnabled(false);
+ app.setCentralAuth(true);
+ app.setUebKey("test");
+ app.setUebSecret("test");
+ app.setUebTopicName("test");
+ app.setAppType(1);
+ return app;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void getAppRolesForUserCentralizedForPortal() throws Exception {
+ EPUser user = mockUser.mockEPUser();
+ EPApp mockApp = mockApp();
+ Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
+ List<RoleInAppForUser> mockRoleInAppForUserList = getMockedRoleInAppUserList();
+ List<CentralV2Role> mockCenV2Role = new ArrayList<>();
+ CentralV2Role cenV2Role = new CentralV2Role(1l, null, null, null, null, null, "test1", true, null,
+ new TreeSet<>(), new TreeSet<>(), new TreeSet<>());
+ CentralV2Role cenV2Role2 = new CentralV2Role(16l, null, null, null, null, null, "test2", true, null,
+ new TreeSet<>(), new TreeSet<>(), new TreeSet<>());
+ mockCenV2Role.add(cenV2Role);
+ mockCenV2Role.add(cenV2Role2);
+ Mockito.when(externalAccessRolesServiceImpl.getRolesForApp(mockApp.getUebKey())).thenReturn(mockCenV2Role);
+ List<EPUser> mockUserList = new ArrayList<>();
+ mockUserList.add(user);
+ Mockito.when((List<EPUser>) dataAccessService
+ .executeQuery("from EPUser where orgUserId='" + user.getOrgUserId() + "'", null))
+ .thenReturn(mockUserList);
+ Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true))
+ .thenReturn(mockRoleInAppForUserList);
+ List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(1l, "test", true);
+ assertEquals(roleInAppForUser, mockRoleInAppForUserList);
+ }
+
+ private List<RoleInAppForUser> getMockedRoleInAppUserList() {
+ List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
+ RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
+ mockRoleInAppForUser.setIsApplied(false);
+ mockRoleInAppForUser.setRoleId(1l);
+ mockRoleInAppForUser.setRoleName("test1");
+ RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
+ mockRoleInAppForUser2.setIsApplied(false);
+ mockRoleInAppForUser2.setRoleId(16l);
+ mockRoleInAppForUser2.setRoleName("test2");
+ mockRoleInAppForUserList.add(mockRoleInAppForUser);
+ mockRoleInAppForUserList.add(mockRoleInAppForUser2);
+ return mockRoleInAppForUserList;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void getAppRolesForUserNonCentralizedForPortal() throws Exception {
+ EPUser user = mockUser.mockEPUser();
+ user.setId(1l);
+ EPApp mockApp = mockApp();
+ mockApp.setCentralAuth(false);
+ EPRole mockEPRole = new EPRole();
+ mockEPRole.setId(1l);
+ mockEPRole.setName("test1");
+ mockEPRole.setActive(true);
+ SortedSet<EPUserApp> mockUserApps = new TreeSet<EPUserApp>();
+ EPUserApp mockEPUserApp = new EPUserApp();
+ mockEPUserApp.setApp(mockApp);
+ mockEPUserApp.setRole(mockEPRole);
+ mockEPUserApp.setUserId(1l);
+ mockUserApps.add(mockEPUserApp);
+ user.setEPUserApps(mockUserApps);
+ Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
+ List<RoleInAppForUser> mockRoleInAppForUserListNonCentralizedList = getMockedRoleInAppUserList();
+ List<Role> mockRole = new ArrayList<>();
+ Role role = new Role();
+ role.setId(1l);
+ role.setName("test1");
+ role.setActive(true);
+ Role role2 = new Role();
+ role.setId(16l);
+ role.setName("test2");
+ role.setActive(true);
+ mockRole.add(role);
+ mockRole.add(role2);
+ Mockito.when(roleServiceImpl.getAvailableRoles(user.getOrgUserId())).thenReturn(mockRole);
+ List<EPUser> mockUserList = new ArrayList<>();
+ mockUserList.add(user);
+ Mockito.when((List<EPUser>) dataAccessService
+ .executeQuery("from EPUser where orgUserId='" + user.getOrgUserId() + "'", null))
+ .thenReturn(mockUserList);
+ Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true))
+ .thenReturn(mockRoleInAppForUserListNonCentralizedList);
+ List<RoleInAppForUser> roleInAppForUserNonCentralized = userRolesCommonServiceImpl.getAppRolesForUser(1l,
+ user.getOrgUserId(), true);
+ assertNull(roleInAppForUserNonCentralized);
+ }
+
+ @Test
+ public void getAppRolesForCentralizedPartnerAppTest() throws Exception {
+ EPUser user = mockUser.mockEPUser();
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
+ List<RoleInAppForUser> mockRoleInAppForUserList = getMockedRoleInAppUserList();
+ List<EPRole> mockEPRoleList = new ArrayList<>();
+ EPRole mockEpRole = new EPRole();
+ mockEpRole.setActive(true);
+ mockEpRole.setAppId(2l);
+ mockEpRole.setName("test1");
+ mockEpRole.setAppRoleId(333l);
+ mockEpRole.setId(1l);
+ EPRole mockEpRole2 = new EPRole();
+ mockEpRole2.setActive(true);
+ mockEpRole2.setAppId(2l);
+ mockEpRole2.setName("test2");
+ mockEpRole2.setAppRoleId(444l);
+ mockEpRole2.setId(16l);
+ mockEPRoleList.add(mockEpRole);
+ mockEPRoleList.add(mockEpRole2);
+ final Map<String, Long> appParams = new HashMap<>();
+ appParams.put("appId", 2l);
+ Mockito.when(dataAccessService.executeNamedQuery("getActiveRolesOfApplication", appParams, null))
+ .thenReturn(mockEPRoleList);
+ final Map<String, String> params = new HashMap<>();
+ params.put("orgUserIdValue", "guestT");
+ List<EPUser> mockEPUserList = new ArrayList<>();
+ mockEPUserList.add(user);
+ Mockito.when(dataAccessService.executeNamedQuery("epUserAppId", params, null)).thenReturn(mockEPUserList);
+ final Map<String, Long> userParams = new HashMap<>();
+ userParams.put("appId", mockApp.getId());
+ userParams.put("userId", mockEPUserList.get(0).getId());
+ List<EPUserAppCurrentRoles> epUserAppCurrentRolesList = new ArrayList<>();
+ EPUserAppCurrentRoles epUserAppCurrentRoles = new EPUserAppCurrentRoles();
+ epUserAppCurrentRoles.setRoleId(444l);
+ epUserAppCurrentRoles.setRoleName("TestPartnerRole2");
+ epUserAppCurrentRoles.setUserId(mockEPUserList.get(0).getId());
+ epUserAppCurrentRolesList.add(epUserAppCurrentRoles);
+ Mockito.when(dataAccessService.executeNamedQuery("getUserAppCurrentRoles", userParams, null))
+ .thenReturn(epUserAppCurrentRolesList);
+ Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(), true))
+ .thenReturn(mockRoleInAppForUserList);
+ List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
+ true);
+ assertEquals(roleInAppForUser, mockRoleInAppForUserList);
+ }
+
+ @Test
+ public void getAppRolesForNonCentralizedPartnerAppTest() throws Exception {
+ EPUser user = mockUser.mockEPUser();
+ user.setId(2l);
+ List<EPUser> mockEpUserList = new ArrayList<>();
+ mockEpUserList.add(user);
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ mockApp.setCentralAuth(false);
+ Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
+ List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
+ RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
+ mockRoleInAppForUser.setIsApplied(true);
+ mockRoleInAppForUser.setRoleId(333l);
+ mockRoleInAppForUser.setRoleName("test1");
+ RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
+ mockRoleInAppForUser2.setIsApplied(true);
+ mockRoleInAppForUser2.setRoleId(777l);
+ mockRoleInAppForUser2.setRoleName("test2");
+ RoleInAppForUser mockRoleInAppForUser3 = new RoleInAppForUser();
+ mockRoleInAppForUser3.setIsApplied(false);
+ mockRoleInAppForUser3.setRoleId(888l);
+ mockRoleInAppForUser3.setRoleName("test5");
+ mockRoleInAppForUserList.add(mockRoleInAppForUser);
+ mockRoleInAppForUserList.add(mockRoleInAppForUser2);
+ mockRoleInAppForUserList.add(mockRoleInAppForUser3);
+ List<EcompRole> mockEcompRoleList = new ArrayList<>();
+ EcompRole mockEcompRole = new EcompRole();
+ mockEcompRole.setId(333l);
+ mockEcompRole.setName("test1");
+ EcompRole mockEcompRole2 = new EcompRole();
+ mockEcompRole2.setId(777l);
+ mockEcompRole2.setName("test2");
+ EcompRole mockEcompRole3 = new EcompRole();
+ mockEcompRole3.setId(888l);
+ mockEcompRole3.setName("test5");
+ mockEcompRoleList.add(mockEcompRole);
+ mockEcompRoleList.add(mockEcompRole2);
+ mockEcompRoleList.add(mockEcompRole3);
+ EcompRole[] mockEcompRoleArray = mockEcompRoleList.toArray(new EcompRole[mockEcompRoleList.size()]);
+ List<EPRole> mockEPRoleList = new ArrayList<>();
+ EPRole mockEpRole = new EPRole();
+ mockEpRole.setActive(true);
+ mockEpRole.setAppId(2l);
+ mockEpRole.setName("test1");
+ mockEpRole.setAppRoleId(333l);
+ mockEpRole.setId(16l);
+ EPRole mockEpRole2 = new EPRole();
+ mockEpRole2.setActive(true);
+ mockEpRole2.setAppId(2l);
+ mockEpRole2.setName("test3");
+ mockEpRole2.setAppRoleId(555l);
+ mockEpRole2.setId(15l);
+ EPRole mockEpRole3 = new EPRole();
+ mockEpRole3.setActive(true);
+ mockEpRole3.setAppId(2l);
+ mockEpRole3.setName("test4");
+ mockEpRole3.setAppRoleId(888l);
+ mockEpRole3.setId(17l);
+ mockEPRoleList.add(mockEpRole);
+ mockEPRoleList.add(mockEpRole2);
+ mockEPRoleList.add(mockEpRole3);
+ List<EPUserApp> mockUserRolesList = new ArrayList<>();
+ EPUserApp mockEpUserApp = new EPUserApp();
+ mockEpUserApp.setApp(mockApp);
+ mockEpUserApp.setRole(mockEpRole2);
+ mockEpUserApp.setUserId(user.getId());
+ mockUserRolesList.add(mockEpUserApp);
+ List<FunctionalMenuRole> mockFunctionalMenuRolesList = new ArrayList<>();
+ FunctionalMenuRole mockFunctionalMenuRole = new FunctionalMenuRole();
+ mockFunctionalMenuRole.setAppId((int) (long) mockApp.getId());
+ mockFunctionalMenuRole.setRoleId((int) (long) 15l);
+ mockFunctionalMenuRole.setMenuId(10l);
+ mockFunctionalMenuRole.setId(10);
+ mockFunctionalMenuRolesList.add(mockFunctionalMenuRole);
+ List<FunctionalMenuItem> mockFunctionalMenuItemList = new ArrayList<>();
+ FunctionalMenuItem mockFunctionalMenuItem = new FunctionalMenuItem();
+ List<Integer> mockRolesList = new ArrayList<>();
+ Integer role1 = 1;
+ mockRolesList.add(role1);
+ mockFunctionalMenuItem.setRestrictedApp(false);
+ mockFunctionalMenuItem.setRoles(mockRolesList);
+ mockFunctionalMenuItem.setUrl("http://test.com");
+ mockFunctionalMenuItemList.add(mockFunctionalMenuItem);
+ Query epRoleQuery = Mockito.mock(Query.class);
+ Query epUserAppsQuery = Mockito.mock(Query.class);
+ Query epFunctionalMenuQuery = Mockito.mock(Query.class);
+ Query epFunctionalMenuQuery2 = Mockito.mock(Query.class);
+ Query epFunctionalMenuItemQuery = Mockito.mock(Query.class);
+ Query epUserListQuery = Mockito.mock(Query.class);
+ Query epUserRolesListQuery = Mockito.mock(Query.class);
+ Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
+ .thenReturn(mockEcompRoleArray);
+ // syncAppRolesTest
+ Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=" + mockApp.getId()))
+ .thenReturn(epRoleQuery);
+ Mockito.doReturn(mockEPRoleList).when(epRoleQuery).list();
+ Mockito.when(session.createQuery(
+ "from " + EPUserApp.class.getName() + " where app.id=" + mockApp.getId() + " and role_id=" + 15l))
+ .thenReturn(epUserAppsQuery);
+ Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
+
+ Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where roleId=" + 15l))
+ .thenReturn(epFunctionalMenuQuery);
+ Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
+
+ Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where menuId=" + 10l))
+ .thenReturn(epFunctionalMenuQuery2);
+ Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
+
+ Mockito.when(session.createQuery("from " + FunctionalMenuItem.class.getName() + " where menuId=" + 10l))
+ .thenReturn(epFunctionalMenuItemQuery);
+ Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
+ List<EcompRole> mockEcompRoleList2 = new ArrayList<>();
+ EcompRole mockUserAppRoles = new EcompRole();
+ mockUserAppRoles.setId(333l);
+ mockUserAppRoles.setName("test1");
+ EcompRole mockUserAppRoles2 = new EcompRole();
+ mockUserAppRoles2.setId(777l);
+ mockUserAppRoles2.setName("test2");
+ mockEcompRoleList2.add(mockUserAppRoles);
+ mockEcompRoleList2.add(mockUserAppRoles2);
+ EcompRole[] mockEcompRoleArray2 = mockEcompRoleList2.toArray(new EcompRole[mockEcompRoleList2.size()]);
+ Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(),
+ String.format("/user/%s/roles", user.getOrgUserId()))).thenReturn(mockEcompRoleArray2);
+ // SyncUserRoleTest
+ Mockito.when(session
+ .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
+ .thenReturn(epUserListQuery);
+ Mockito.doReturn(mockEpUserList).when(epUserListQuery).list();
+
+ List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
+ EPUserApp mockEpUserAppRoles = new EPUserApp();
+ mockEpUserAppRoles.setApp(mockApp);
+ mockEpUserAppRoles.setRole(mockEpRole3);
+ mockEpUserAppRoles.setUserId(user.getId());
+ mockUserRolesList2.add(mockEpUserAppRoles);
+ Mockito.when(session.createQuery(
+ "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
+ .thenReturn(epUserRolesListQuery);
+ Mockito.doReturn(mockUserRolesList2).when(epUserRolesListQuery).list();
+ List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
+ true);
+ assertEquals(roleInAppForUser, mockRoleInAppForUserList);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void setAppWithUserRoleStateForUserTestForCentralizedAppForPortal() throws Exception {
+ PowerMockito.mockStatic(SystemProperties.class);
+ PowerMockito.mockStatic(EcompPortalUtils.class);
+ PowerMockito.mockStatic(EPCommonSystemProperties.class);
+ PowerMockito.mockStatic(PortalConstants.class);
+ EPUser user = mockUser.mockEPUser();
+ user.setId(2l);
+ List<EPUser> mockEpUserList = new ArrayList<>();
+ mockEpUserList.add(user);
+ EPApp mockApp = mockApp();
+ mockApp.setNameSpace("com.test.com");
+ mockApp.setId(1l);
+ mockApp.setCentralAuth(true);
+ Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
+ Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
+ AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
+ List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
+ RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
+ mockRoleInAppForUser.setIsApplied(true);
+ mockRoleInAppForUser.setRoleId(1l);
+ mockRoleInAppForUser.setRoleName("test1");
+ RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
+ mockRoleInAppForUser2.setIsApplied(true);
+ mockRoleInAppForUser2.setRoleId(1000l);
+ mockRoleInAppForUser2.setRoleName("test3");
+ mockRoleInAppForUserList.add(mockRoleInAppForUser);
+ mockRoleInAppForUserList.add(mockRoleInAppForUser2);
+ mockWithRolesForUser.setAppId(mockApp.getId());
+ mockWithRolesForUser.setAppName(mockApp.getName());
+ mockWithRolesForUser.setOrgUserId(user.getOrgUserId());
+ mockWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
+ List<EPUserAppRolesRequest> mockEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
+ Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
+ EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
+ mockEpUserAppRolesRequestDetail.setId(2l);
+ mockEpUserAppRolesRequestDetail.setReqType("P");
+ mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
+ EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
+ mockEPUserAppRolesRequest.setAppId(mockApp.getId());
+ mockEPUserAppRolesRequest.setId(1l);
+ mockEPUserAppRolesRequest.setRequestStatus("P");
+ mockEPUserAppRolesRequest.setUserId(user.getId());
+ mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
+ mockEpRequestIdValList.add(mockEPUserAppRolesRequest);
+ mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
+ mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
+
+ // Update Requests if any requests are pending
+ final Map<String, Long> params = new HashMap<>();
+ params.put("appId", mockApp.getId());
+ params.put("userId", user.getId());
+ Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
+ params, null)).thenReturn(mockEpRequestIdValList);
+ mockEPUserAppRolesRequest.setUpdatedDate(new Date());
+ mockEPUserAppRolesRequest.setRequestStatus("O");
+ HashMap<String, Long> additionalUpdateParam = new HashMap<String, Long>();
+ Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPUserAppRolesRequest, additionalUpdateParam);
+ List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
+ EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
+ mockEpUserAppRolesRequestDetail.setId(2l);
+ mockEpUserAppRolesRequestDetail.setReqType("P");
+ mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
+ mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
+ // Updates in External Auth System
+ final Map<String, String> userParams = new HashMap<>();
+ userParams.put("orgUserIdValue", user.getOrgUserId());
+ Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
+ .thenReturn(mockEpUserList);
+ PowerMockito
+ .when(EPCommonSystemProperties
+ .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
+ .thenReturn(true);
+ PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
+ .thenReturn("@test.com");
+ HttpHeaders headers = new HttpHeaders();
+ Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
+ JSONObject mockJsonObject1 = new JSONObject();
+ JSONObject mockJsonObject2 = new JSONObject();
+ JSONObject mockJsonObject3 = new JSONObject();
+ mockJsonObject1.put("name", "com.test.com.test1");
+ mockJsonObject2.put("name", "com.test.com.test2");
+ List<JSONObject> mockJson = new ArrayList<>();
+ mockJson.add(mockJsonObject1);
+ mockJson.add(mockJsonObject2);
+ mockJsonObject3.put("role", mockJson);
+ ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
+ Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET),
+ Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(getResponse);
+ EPRole mockEPRole = new EPRole();
+ mockEPRole.setActive(true);
+ mockEPRole.setAppId(null);
+ mockEPRole.setAppRoleId(null);
+ mockEPRole.setId(1l);
+ mockEPRole.setName("test1");
+ EPRole mockEPRole2 = new EPRole();
+ mockEPRole2.setActive(true);
+ mockEPRole2.setAppId(null);
+ mockEPRole2.setAppRoleId(null);
+ mockEPRole2.setId(16l);
+ mockEPRole2.setName("test2");
+ EPRole mockEPRole3 = new EPRole();
+ mockEPRole3.setActive(true);
+ mockEPRole3.setAppId(null);
+ mockEPRole3.setAppRoleId(null);
+ mockEPRole3.setId(1000l);
+ mockEPRole3.setName("test3");
+ Map<String, EPRole> mockEPRoleList = new HashMap<>();
+ mockEPRoleList.put("test1", mockEPRole);
+ mockEPRoleList.put("test2", mockEPRole2);
+ mockEPRoleList.put("test3", mockEPRole3);
+ Mockito.when(externalAccessRolesServiceImpl.getCurrentRolesInDB(mockApp)).thenReturn(mockEPRoleList);
+ final Map<String, Long> params2 = new HashMap<>();
+ params2.put("appId", mockApp.getId());
+ params2.put("userId", user.getId());
+ List<EcompUserAppRoles> mockEPuserAppList = getCurrentUserRoles(user, mockApp);
+ Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
+ .thenReturn(mockEPuserAppList);
+ final Map<String, Long> epDetailParams = new HashMap<>();
+ epDetailParams.put("reqId", mockEPUserAppRolesRequest.getId());
+ Mockito.when(dataAccessService.executeNamedQuery("userAppRolesRequestDetailList", epDetailParams, null))
+ .thenReturn(mockGetEpUserAppRolesRequestDetailList);
+
+ ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
+ Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
+ Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
+
+ ResponseEntity<String> deleteResponse = new ResponseEntity<>(HttpStatus.OK);
+ Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE),
+ Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(deleteResponse);
+
+ // Updates in EP DB
+ Query epsetAppWithUserRoleGetUserQuery = Mockito.mock(Query.class);
+ Query epsetAppWithUserRoleGetUserAppsQuery = Mockito.mock(Query.class);
+ Query epsetAppWithUserRoleGetRolesQuery = Mockito.mock(Query.class);
+ SQLQuery epsetAppWithUserRoleUpdateEPRoleQuery = Mockito.mock(SQLQuery.class);
+ Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
+ Mockito.when(session
+ .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
+ .thenReturn(epsetAppWithUserRoleGetUserQuery);
+ Mockito.doReturn(mockEpUserList).when(epsetAppWithUserRoleGetUserQuery).list();
+ List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
+ EPUserApp mockEpUserAppRoles = new EPUserApp();
+ mockEpUserAppRoles.setApp(mockApp);
+ mockEpUserAppRoles.setRole(mockEPRole);
+ mockEpUserAppRoles.setUserId(user.getId());
+ mockUserRolesList2.add(mockEpUserAppRoles);
+ Mockito.when(session.createQuery(
+ "from org.onap.portalapp.portal.domain.EPUserApp where app.id=1 and role.active = 'Y' and userId=2"))
+ .thenReturn(epsetAppWithUserRoleGetUserAppsQuery);
+ Mockito.doReturn(mockUserRolesList2).when(epsetAppWithUserRoleGetUserAppsQuery).list();
+ List<EPRole> mockEPRoles = new ArrayList<>();
+ mockEPRoles.add(mockEPRole2);
+ mockEPRoles.add(mockEPRole3);
+ Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId is null and id != 1"))
+ .thenReturn(epsetAppWithUserRoleGetRolesQuery);
+ Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleGetRolesQuery).list();
+ Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
+ .thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
+ boolean actual = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
+ assertTrue(actual);
+ }
+
+ private List<EcompUserAppRoles> getCurrentUserRoles(EPUser user, EPApp mockApp) {
+ List<EcompUserAppRoles> mockEPuserAppList = new ArrayList<>();
+ EcompUserAppRoles mockEcompUserAppRoles = new EcompUserAppRoles();
+ mockEcompUserAppRoles.setAppId(String.valueOf(mockApp.getId()));
+ mockEcompUserAppRoles.setRoleId(1l);
+ mockEcompUserAppRoles.setRoleName("test1");
+ mockEcompUserAppRoles.setUserId(user.getId());
+ mockEPuserAppList.add(mockEcompUserAppRoles);
+ return mockEPuserAppList;
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void setAppWithUserRoleStateForUserTestForNonCentralizedApp() throws Exception {
+ PowerMockito.mockStatic(SystemProperties.class);
+ PowerMockito.mockStatic(EcompPortalUtils.class);
+ PowerMockito.mockStatic(EPCommonSystemProperties.class);
+ PowerMockito.mockStatic(PortalConstants.class);
+ EPUser user = mockUser.mockEPUser();
+ user.setId(2l);
+ List<EPUser> mockEpUserList = new ArrayList<>();
+ mockEpUserList.add(user);
+ EPApp mockApp = mockApp();
+ mockApp.setNameSpace("com.test.com");
+ mockApp.setId(2l);
+ mockApp.setCentralAuth(false);
+ Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
+ Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
+ AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
+ List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
+ RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
+ mockRoleInAppForUser.setIsApplied(true);
+ mockRoleInAppForUser.setRoleId(1l);
+ mockRoleInAppForUser.setRoleName("test1");
+ RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
+ mockRoleInAppForUser2.setIsApplied(true);
+ mockRoleInAppForUser2.setRoleId(1000l);
+ mockRoleInAppForUser2.setRoleName("test3");
+ mockRoleInAppForUserList.add(mockRoleInAppForUser);
+ mockRoleInAppForUserList.add(mockRoleInAppForUser2);
+ mockWithRolesForUser.setAppId(mockApp.getId());
+ mockWithRolesForUser.setAppName(mockApp.getName());
+ mockWithRolesForUser.setOrgUserId(user.getOrgUserId());
+ mockWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
+ List<EPUserAppRolesRequest> mockEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
+ Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
+ EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
+ mockEpUserAppRolesRequestDetail.setId(2l);
+ mockEpUserAppRolesRequestDetail.setReqType("P");
+ mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
+ EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
+ mockEPUserAppRolesRequest.setAppId(mockApp.getId());
+ mockEPUserAppRolesRequest.setId(1l);
+ mockEPUserAppRolesRequest.setRequestStatus("P");
+ mockEPUserAppRolesRequest.setUserId(user.getId());
+ mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
+ mockEpRequestIdValList.add(mockEPUserAppRolesRequest);
+ mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
+ mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
+
+ // Update Requests if any requests are pending
+ final Map<String, Long> params = new HashMap<>();
+ params.put("appId", mockApp.getId());
+ params.put("userId", user.getId());
+ Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
+ params, null)).thenReturn(mockEpRequestIdValList);
+ mockEPUserAppRolesRequest.setUpdatedDate(new Date());
+ mockEPUserAppRolesRequest.setRequestStatus("O");
+ HashMap<String, Long> additionalUpdateParam = new HashMap<String, Long>();
+ Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPUserAppRolesRequest, additionalUpdateParam);
+ List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
+ EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
+ mockEpUserAppRolesRequestDetail.setId(2l);
+ mockEpUserAppRolesRequestDetail.setReqType("P");
+ mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
+ mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
+ final Map<String, Long> epDetailParams = new HashMap<>();
+ epDetailParams.put("reqId", mockEPUserAppRolesRequest.getId());
+
+ final Map<String, String> userParams = new HashMap<>();
+ userParams.put("orgUserIdValue", user.getOrgUserId());
+ Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
+ .thenReturn(mockEpUserList);
+
+ PowerMockito
+ .when(EPCommonSystemProperties
+ .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
+ .thenReturn(true);
+ PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
+ .thenReturn("@test.com");
+ HttpHeaders headers = new HttpHeaders();
+ Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
+ EPRole mockEPRole = new EPRole();
+ mockEPRole.setActive(true);
+ mockEPRole.setAppId(2l);
+ mockEPRole.setAppRoleId(null);
+ mockEPRole.setId(10l);
+ mockEPRole.setAppRoleId(1l);
+ mockEPRole.setName("test1");
+ EPRole mockEPRole2 = new EPRole();
+ mockEPRole2.setActive(true);
+ mockEPRole2.setAppId(2l);
+ mockEPRole2.setAppRoleId(null);
+ mockEPRole2.setId(160l);
+ mockEPRole2.setName("test2");
+ mockEPRole2.setAppRoleId(16l);
+ EPRole mockEPRole3 = new EPRole();
+ mockEPRole3.setActive(true);
+ mockEPRole3.setAppId(2l);
+ mockEPRole3.setAppRoleId(null);
+ mockEPRole3.setId(1100l);
+ mockEPRole3.setAppRoleId(100l);
+ mockEPRole3.setName("test3");
+ Mockito.when(applicationsRestClientService.get(EPUser.class, mockApp.getId(),
+ String.format("/user/%s", user.getOrgUserId()), true)).thenReturn(user);
+ // Updates in EP DB
+ Query epsetAppWithUserRoleNonCentralizedGetUserQuery = Mockito.mock(Query.class);
+ Query epsetAppWithUserRoleNonCentralizedGetUserAppsQuery = Mockito.mock(Query.class);
+ Query epsetAppWithUserRoleNonCentralizedGetRolesQuery = Mockito.mock(Query.class);
+ Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
+ Mockito.when(session
+ .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
+ .thenReturn(epsetAppWithUserRoleNonCentralizedGetUserQuery);
+ Mockito.doReturn(mockEpUserList).when(epsetAppWithUserRoleNonCentralizedGetUserQuery).list();
+ List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
+ EPUserApp mockEpUserAppRoles = new EPUserApp();
+ mockEpUserAppRoles.setApp(mockApp);
+ mockEpUserAppRoles.setRole(mockEPRole);
+ mockEpUserAppRoles.setUserId(user.getId());
+ mockUserRolesList2.add(mockEpUserAppRoles);
+ Mockito.when(session.createQuery(
+ "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
+ .thenReturn(epsetAppWithUserRoleNonCentralizedGetUserAppsQuery);
+ Mockito.doReturn(mockUserRolesList2).when(epsetAppWithUserRoleNonCentralizedGetUserAppsQuery).list();
+ List<EPRole> mockEPRoles = new ArrayList<>();
+ mockEPRoles.add(mockEPRole2);
+ mockEPRoles.add(mockEPRole3);
+ Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=2"))
+ .thenReturn(epsetAppWithUserRoleNonCentralizedGetRolesQuery);
+ Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleNonCentralizedGetRolesQuery).list();
+ boolean expected = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
+ assertEquals(expected, true);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void setExternalRequestUserAppRoleMerdianCentralizedAppTest() throws Exception {
+ PowerMockito.mockStatic(SystemProperties.class);
+ PowerMockito.mockStatic(EcompPortalUtils.class);
+ PowerMockito.mockStatic(EPCommonSystemProperties.class);
+ PowerMockito.mockStatic(PortalConstants.class);
+ EPUser user = mockUser.mockEPUser();
+ user.setId(2l);
+ List<EPUser> mockEpUserList = new ArrayList<>();
+ mockEpUserList.add(user);
+ EPApp mockApp = mockApp();
+ mockApp.setNameSpace("com.test.com");
+ mockApp.setId(1l);
+ mockApp.setCentralAuth(true);
+ Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
+ ExternalSystemUser externalSystemUser = new ExternalSystemUser();
+ List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
+ ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
+ mockExternalSystemRoleApproval.setRoleName("test1");
+ ExternalSystemRoleApproval mockExternalSystemRoleApproval2 = new ExternalSystemRoleApproval();
+ mockExternalSystemRoleApproval2.setRoleName("test2");
+ mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval);
+ mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval2);
+ externalSystemUser.setApplicationName(mockApp.getMlAppName());
+ externalSystemUser.setLoginId(user.getOrgUserId());
+ externalSystemUser.setRoles(mockExternalSystemRoleApprovalList);
+ EPRole mockEPRole = new EPRole();
+ mockEPRole.setActive(true);
+ mockEPRole.setAppId(null);
+ mockEPRole.setAppRoleId(null);
+ mockEPRole.setId(1l);
+ mockEPRole.setName("test1");
+ EPRole mockEPRole2 = new EPRole();
+ mockEPRole2.setActive(true);
+ mockEPRole2.setAppId(null);
+ mockEPRole2.setAppRoleId(null);
+ mockEPRole2.setId(16l);
+ mockEPRole2.setName("test2");
+ EPRole mockEPRole3 = new EPRole();
+ mockEPRole3.setActive(true);
+ mockEPRole3.setAppId(null);
+ mockEPRole3.setAppRoleId(null);
+ mockEPRole3.setId(1000l);
+ mockEPRole3.setName("test3");
+
+ Mockito.when(epAppCommonServiceImpl.getAppDetail(mockApp.getMlAppName())).thenReturn(mockApp);
+ final Map<String, String> userParams = new HashMap<>();
+ userParams.put("orgUserIdValue", user.getOrgUserId());
+ Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
+ .thenReturn(mockEpUserList);
+
+ List<EPUserAppRolesRequest> mockMerdianEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
+ Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
+ EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
+ mockEpUserAppRolesRequestDetail.setId(2l);
+ mockEpUserAppRolesRequestDetail.setReqType("P");
+ mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
+ EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
+ mockEPUserAppRolesRequest.setAppId(mockApp.getId());
+ mockEPUserAppRolesRequest.setId(1l);
+ mockEPUserAppRolesRequest.setRequestStatus("P");
+ mockEPUserAppRolesRequest.setUserId(user.getId());
+ mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
+ mockMerdianEpRequestIdValList.add(mockEPUserAppRolesRequest);
+ mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
+ mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
+
+ final Map<String, Long> params = new HashMap<>();
+ params.put("appId", mockApp.getId());
+ params.put("userId", user.getId());
+ Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
+ params, null)).thenReturn(mockMerdianEpRequestIdValList);
+ RoleInAppForUser mockRoleInAppForUser1 = new RoleInAppForUser();
+ mockRoleInAppForUser1.setIsApplied(true);
+ mockRoleInAppForUser1.setRoleId(1l);
+ mockRoleInAppForUser1.setRoleName("test1");
+ RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
+ mockRoleInAppForUser2.setIsApplied(true);
+ mockRoleInAppForUser2.setRoleId(16l);
+ mockRoleInAppForUser2.setRoleName("test2");
+ Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval.getRoleName(), mockApp.getId()))
+ .thenReturn(mockEPRole);
+ Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval2.getRoleName(), mockApp.getId()))
+ .thenReturn(mockEPRole2);
+ List<EcompUserAppRoles> mockEPuserAppList = getCurrentUserRoles(user, mockApp);
+ final Map<String, Long> params2 = new HashMap<>();
+ params2.put("userId", user.getId());
+ params2.put("appId", mockApp.getId());
+ Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
+ .thenReturn(mockEPuserAppList);
+ // Updates in External Auth System
+ List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
+ EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
+ mockEpUserAppRolesRequestDetail.setId(2l);
+ mockEpUserAppRolesRequestDetail.setReqType("P");
+ mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
+ mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
+ final Map<String, String> userParams2 = new HashMap<>();
+ userParams2.put("orgUserIdValue", user.getOrgUserId());
+ Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams2, null))
+ .thenReturn(mockEpUserList);
+ PowerMockito
+ .when(EPCommonSystemProperties
+ .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
+ .thenReturn(true);
+ PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
+ .thenReturn("@test.com");
+ HttpHeaders headers = new HttpHeaders();
+ Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
+ JSONObject mockJsonObject1 = new JSONObject();
+ JSONObject mockJsonObject2 = new JSONObject();
+ JSONObject mockJsonObject3 = new JSONObject();
+ mockJsonObject1.put("name", "com.test.com.test1");
+ mockJsonObject2.put("name", "com.test.com.test2");
+ List<JSONObject> mockJson = new ArrayList<>();
+ mockJson.add(mockJsonObject1);
+ mockJson.add(mockJsonObject2);
+ mockJsonObject3.put("role", mockJson);
+ ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
+ Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET),
+ Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(getResponse);
+ Map<String, EPRole> mockEPRoleList = new HashMap<>();
+ mockEPRoleList.put("test1", mockEPRole);
+ mockEPRoleList.put("test2", mockEPRole2);
+ mockEPRoleList.put("test3", mockEPRole3);
+ Mockito.when(externalAccessRolesServiceImpl.getCurrentRolesInDB(mockApp)).thenReturn(mockEPRoleList);
+
+ ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
+ Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
+ Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
+
+ ResponseEntity<String> deleteResponse = new ResponseEntity<>(HttpStatus.OK);
+ Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE),
+ Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(deleteResponse);
+ // Updated in EP DB
+ Query epsetExternalRequestUserAppRoleGetUserQuery = Mockito.mock(Query.class);
+ Query epsetExternalRequestUserAppRoleGetUserAppsQuery = Mockito.mock(Query.class);
+ Query epsetExternalRequestUserAppRoleGetRolesQuery = Mockito.mock(Query.class);
+ SQLQuery epsetAppWithUserRoleUpdateEPRoleQuery = Mockito.mock(SQLQuery.class);
+ Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
+ Mockito.when(session
+ .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
+ .thenReturn(epsetExternalRequestUserAppRoleGetUserQuery);
+ Mockito.doReturn(mockEpUserList).when(epsetExternalRequestUserAppRoleGetUserQuery).list();
+ List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
+ EPUserApp mockEpUserAppRoles = new EPUserApp();
+ mockEpUserAppRoles.setApp(mockApp);
+ mockEpUserAppRoles.setRole(mockEPRole);
+ mockEpUserAppRoles.setUserId(user.getId());
+ mockUserRolesList2.add(mockEpUserAppRoles);
+ Mockito.when(session.createQuery(
+ "from org.onap.portalapp.portal.domain.EPUserApp where app.id=1 and role.active = 'Y' and userId=2"))
+ .thenReturn(epsetExternalRequestUserAppRoleGetUserAppsQuery);
+ Mockito.doReturn(mockUserRolesList2).when(epsetExternalRequestUserAppRoleGetUserAppsQuery).list();
+ List<EPRole> mockEPRoles = new ArrayList<>();
+ mockEPRoles.add(mockEPRole2);
+ mockEPRoles.add(mockEPRole3);
+ Mockito.when(session.createQuery("from org.onap.portalapp.portal.domain.EPRole where appId is null "))
+ .thenReturn(epsetExternalRequestUserAppRoleGetRolesQuery);
+ Mockito.doReturn(mockEPRoles).when(epsetExternalRequestUserAppRoleGetRolesQuery).list();
+ Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
+ .thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
+
+ ExternalRequestFieldsValidator mockExternalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
+ "Updated Successfully");
+ ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
+ .setExternalRequestUserAppRole(externalSystemUser, "POST");
+ assertTrue(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void setExternalRequestUserAppRoleMerdianNonCentralizedAppTest() throws Exception {
+ PowerMockito.mockStatic(SystemProperties.class);
+ PowerMockito.mockStatic(EPCommonSystemProperties.class);
+ PowerMockito.mockStatic(PortalConstants.class);
+ EPUser user = mockUser.mockEPUser();
+ user.setId(2l);
+ List<EPUser> mockEpUserList = new ArrayList<>();
+ mockEpUserList.add(user);
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(false);
+ ExternalSystemUser externalSystemUser = new ExternalSystemUser();
+ List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
+ ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
+ mockExternalSystemRoleApproval.setRoleName("test1");
+ ExternalSystemRoleApproval mockExternalSystemRoleApproval2 = new ExternalSystemRoleApproval();
+ mockExternalSystemRoleApproval2.setRoleName("test2");
+ mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval);
+ mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval2);
+ externalSystemUser.setApplicationName(mockApp.getMlAppName());
+ externalSystemUser.setLoginId(user.getOrgUserId());
+ externalSystemUser.setRoles(mockExternalSystemRoleApprovalList);
+
+ EPRole mockEPRole = new EPRole();
+ mockEPRole.setActive(true);
+ mockEPRole.setAppId(2l);
+ mockEPRole.setAppRoleId(1l);
+ mockEPRole.setId(1000l);
+ mockEPRole.setName("test1");
+ EPRole mockEPRole2 = new EPRole();
+ mockEPRole2.setActive(true);
+ mockEPRole2.setAppId(2l);
+ mockEPRole2.setAppRoleId(16l);
+ mockEPRole2.setId(160l);
+ mockEPRole2.setName("test2");
+ EPRole mockEPRole3 = new EPRole();
+ mockEPRole3.setActive(true);
+ mockEPRole3.setAppId(2l);
+ mockEPRole3.setAppRoleId(10l);
+ mockEPRole3.setId(100l);
+ mockEPRole3.setName("test3");
+
+ Mockito.when(epAppCommonServiceImpl.getAppDetail(mockApp.getMlAppName())).thenReturn(mockApp);
+ final Map<String, String> userParams = new HashMap<>();
+ userParams.put("orgUserIdValue", user.getOrgUserId());
+ Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
+ .thenReturn(mockEpUserList);
+
+ List<EPUserAppRolesRequest> mockMerdianEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
+ Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
+ EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
+ mockEpUserAppRolesRequestDetail.setId(2l);
+ mockEpUserAppRolesRequestDetail.setReqType("P");
+ mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
+ EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
+ mockEPUserAppRolesRequest.setAppId(mockApp.getId());
+ mockEPUserAppRolesRequest.setId(1l);
+ mockEPUserAppRolesRequest.setRequestStatus("P");
+ mockEPUserAppRolesRequest.setUserId(user.getId());
+ mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
+ mockMerdianEpRequestIdValList.add(mockEPUserAppRolesRequest);
+ mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
+ mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
+
+ final Map<String, Long> params = new HashMap<>();
+ params.put("appId", mockApp.getId());
+ params.put("userId", user.getId());
+ Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
+ params, null)).thenReturn(mockMerdianEpRequestIdValList);
+ RoleInAppForUser mockRoleInAppForUser1 = new RoleInAppForUser();
+ mockRoleInAppForUser1.setIsApplied(true);
+ mockRoleInAppForUser1.setRoleId(1l);
+ mockRoleInAppForUser1.setRoleName("test1");
+ RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
+ mockRoleInAppForUser2.setIsApplied(true);
+ mockRoleInAppForUser2.setRoleId(16l);
+ mockRoleInAppForUser2.setRoleName("test2");
+ Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval.getRoleName(), mockApp.getId()))
+ .thenReturn(mockEPRole);
+ Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval2.getRoleName(), mockApp.getId()))
+ .thenReturn(mockEPRole2);
+ List<EcompUserAppRoles> mockEPuserAppList = new ArrayList<>();
+ EcompUserAppRoles mockEcompUserAppRoles = new EcompUserAppRoles();
+ mockEcompUserAppRoles.setAppId(String.valueOf(mockApp.getId()));
+ mockEcompUserAppRoles.setRoleId(100l);
+ mockEcompUserAppRoles.setRoleName("test1");
+ mockEcompUserAppRoles.setUserId(user.getId());
+ mockEPuserAppList.add(mockEcompUserAppRoles);
+ final Map<String, Long> params2 = new HashMap<>();
+ params2.put("userId", user.getId());
+ params2.put("appId", mockApp.getId());
+ Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
+ .thenReturn(mockEPuserAppList);
+ List<EcompRole> mockEcompRoleList = new ArrayList<>();
+ EcompRole mockEcompRole = new EcompRole();
+ mockEcompRole.setId(1l);
+ mockEcompRole.setName("test1");
+ EcompRole mockEcompRole2 = new EcompRole();
+ mockEcompRole2.setId(16l);
+ mockEcompRole2.setName("test2");
+ mockEcompRoleList.add(mockEcompRole);
+ mockEcompRoleList.add(mockEcompRole2);
+ EcompRole[] mockEcompRoleArray = mockEcompRoleList.toArray(new EcompRole[mockEcompRoleList.size()]);
+ Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
+ .thenReturn(mockEcompRoleArray);
+
+ // SyncAppRoles
+ List<EPUserApp> mockUserRolesList = new ArrayList<>();
+ EPUserApp mockEpUserApp = new EPUserApp();
+ mockEpUserApp.setApp(mockApp);
+ mockEpUserApp.setRole(mockEPRole2);
+ mockEpUserApp.setUserId(user.getId());
+ mockUserRolesList.add(mockEpUserApp);
+ List<FunctionalMenuRole> mockFunctionalMenuRolesList = new ArrayList<>();
+ FunctionalMenuRole mockFunctionalMenuRole = new FunctionalMenuRole();
+ mockFunctionalMenuRole.setAppId((int) (long) mockApp.getId());
+ mockFunctionalMenuRole.setRoleId((int) (long) 15l);
+ mockFunctionalMenuRole.setMenuId(10l);
+ mockFunctionalMenuRole.setId(10);
+ mockFunctionalMenuRolesList.add(mockFunctionalMenuRole);
+ List<FunctionalMenuItem> mockFunctionalMenuItemList = new ArrayList<>();
+ FunctionalMenuItem mockFunctionalMenuItem = new FunctionalMenuItem();
+ List<Integer> mockRolesList = new ArrayList<>();
+ Integer role1 = 1;
+ mockRolesList.add(role1);
+ mockFunctionalMenuItem.setRestrictedApp(false);
+ mockFunctionalMenuItem.setRoles(mockRolesList);
+ mockFunctionalMenuItem.setUrl("http://test.com");
+ mockFunctionalMenuItemList.add(mockFunctionalMenuItem);
+ Query epRoleQuery = Mockito.mock(Query.class);
+ Query epUserAppsQuery = Mockito.mock(Query.class);
+ Query epFunctionalMenuQuery = Mockito.mock(Query.class);
+ Query epFunctionalMenuQuery2 = Mockito.mock(Query.class);
+ Query epFunctionalMenuItemQuery = Mockito.mock(Query.class);
+ Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
+ .thenReturn(mockEcompRoleArray);
+ // syncAppRolesTest
+ Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=" + mockApp.getId()))
+ .thenReturn(epRoleQuery);
+ Mockito.doReturn(mockEcompRoleList).when(epRoleQuery).list();
+ Mockito.when(session.createQuery(
+ "from " + EPUserApp.class.getName() + " where app.id=" + mockApp.getId() + " and role_id=" + 100l))
+ .thenReturn(epUserAppsQuery);
+ Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
+
+ Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where roleId=" + 100l))
+ .thenReturn(epFunctionalMenuQuery);
+ Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
+
+ Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where menuId=" + 10l))
+ .thenReturn(epFunctionalMenuQuery2);
+ Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
+
+ Mockito.when(session.createQuery("from " + FunctionalMenuItem.class.getName() + " where menuId=" + 10l))
+ .thenReturn(epFunctionalMenuItemQuery);
+ Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
+
+ Mockito.when(applicationsRestClientService.get(EPUser.class, mockApp.getId(),
+ String.format("/user/%s", user.getOrgUserId()), true)).thenReturn(user);
+ // Updated in EP DB
+ Query epsetExternalRequestUserAppRoleGetUserQuery = Mockito.mock(Query.class);
+ Query epsetExternalRequestUserAppRoleGetUserAppsQuery = Mockito.mock(Query.class);
+ Query epsetExternalRequestUserAppRoleGetRolesQuery = Mockito.mock(Query.class);
+ Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
+ Mockito.when(session
+ .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
+ .thenReturn(epsetExternalRequestUserAppRoleGetUserQuery);
+ Mockito.doReturn(mockEpUserList).when(epsetExternalRequestUserAppRoleGetUserQuery).list();
+ List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
+ EPUserApp mockEpUserAppRoles = new EPUserApp();
+ mockEpUserAppRoles.setApp(mockApp);
+ mockEpUserAppRoles.setRole(mockEPRole);
+ mockEpUserAppRoles.setUserId(user.getId());
+ mockUserRolesList2.add(mockEpUserAppRoles);
+ Mockito.when(session.createQuery(
+ "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
+ .thenReturn(epsetExternalRequestUserAppRoleGetUserAppsQuery);
+ Mockito.doReturn(mockUserRolesList2).when(epsetExternalRequestUserAppRoleGetUserAppsQuery).list();
+ List<EPRole> mockEPRoles = new ArrayList<>();
+ mockEPRoles.add(mockEPRole2);
+ mockEPRoles.add(mockEPRole3);
+ Mockito.when(session.createQuery("from org.onap.portalapp.portal.domain.EPRole where appId=2"))
+ .thenReturn(epsetExternalRequestUserAppRoleGetRolesQuery);
+ Mockito.doReturn(mockEPRoles).when(epsetExternalRequestUserAppRoleGetRolesQuery).list();
+
+ ExternalRequestFieldsValidator mockExternalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
+ "Updated Successfully");
+ ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
+ .setExternalRequestUserAppRole(externalSystemUser, "POST");
+ assertTrue(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void getUsersFromAppEndpointCentralizedAppTest() throws HTTPException {
+ EPApp mockApp = mockApp();
+ mockApp.setId(1l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(true);
+ EPUser user = mockUser.mockEPUser();
+ EPUser user2 = mockUser.mockEPUser();
+ user2.setActive(true);
+ user2.setOrgUserId("guestT2");
+ user2.setId(2l);
+ user2.setFirstName("Guest2");
+ user2.setLastName("Test2");
+ user.setId(1l);
+ user.setFirstName("Guest");
+ user.setLastName("Test");
+ EPRole mockEPRole1 = new EPRole();
+ mockEPRole1.setId(1l);
+ mockEPRole1.setName("test1");
+ mockEPRole1.setActive(true);
+ EPRole mockEPRole2 = new EPRole();
+ mockEPRole2.setId(16l);
+ mockEPRole2.setName("test2");
+ mockEPRole2.setActive(true);
+ SortedSet<EPUserApp> mockUserApps1 = new TreeSet<EPUserApp>();
+ EPUserApp mockEPUserApp1 = new EPUserApp();
+ mockEPUserApp1.setApp(mockApp);
+ mockEPUserApp1.setRole(mockEPRole1);
+ mockEPUserApp1.setUserId(1l);
+ mockUserApps1.add(mockEPUserApp1);
+ user.setEPUserApps(mockUserApps1);
+ SortedSet<EPUserApp> mockUserApps2 = new TreeSet<EPUserApp>();
+ EPUserApp mockEPUserApp2 = new EPUserApp();
+ mockEPUserApp2.setApp(mockApp);
+ mockEPUserApp2.setRole(mockEPRole2);
+ mockEPUserApp2.setUserId(2l);
+ mockUserApps2.add(mockEPUserApp2);
+ user2.setEPUserApps(mockUserApps2);
+ List<EPUser> mockEpUserList = new ArrayList<>();
+ mockEpUserList.add(user);
+ mockEpUserList.add(user2);
+ Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
+ List<UserApplicationRoles> mockUserApplicationRolesList = new ArrayList<>();
+ UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
+ List<RemoteRole> mockRemoteRoleList = new ArrayList<>();
+ RemoteRole mockRemoteRole = new RemoteRole();
+ mockRemoteRole.setId(1l);
+ mockRemoteRole.setName("test1");
+ mockRemoteRoleList.add(mockRemoteRole);
+ mockUserApplicationRoles.setAppId(mockApp.getId());
+ mockUserApplicationRoles.setFirstName("Guest");
+ mockUserApplicationRoles.setLastName("Test");
+ mockUserApplicationRoles.setOrgUserId("guestT");
+ mockUserApplicationRoles.setRoles(mockRemoteRoleList);
+ UserApplicationRoles mockUserApplicationRoles2 = new UserApplicationRoles();
+ List<RemoteRole> mockRemoteRoleList2 = new ArrayList<>();
+ RemoteRole mockRemoteRole2 = new RemoteRole();
+ mockRemoteRole2.setId(16l);
+ mockRemoteRole2.setName("test2");
+ mockRemoteRoleList2.add(mockRemoteRole2);
+ mockUserApplicationRoles2.setAppId(mockApp.getId());
+ mockUserApplicationRoles2.setFirstName("Guest2");
+ mockUserApplicationRoles2.setLastName("Test2");
+ mockUserApplicationRoles2.setOrgUserId("guestT2");
+ mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
+ mockUserApplicationRolesList.add(mockUserApplicationRoles);
+ mockUserApplicationRolesList.add(mockUserApplicationRoles2);
+ Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("getActiveUsers", null, null))
+ .thenReturn(mockEpUserList);
+ assertEquals(userRolesCommonServiceImpl.getUsersFromAppEndpoint(1l).size(),
+ mockUserApplicationRolesList.size());
+ }
+
+ @Test
+ public void getUsersFromAppEndpointNonCentralizedAppTest() throws HTTPException, JsonProcessingException {
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(false);
+ Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
+ List<UserApplicationRoles> mockUserApplicationRolesNonCentralizedList = new ArrayList<>();
+ UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
+ List<RemoteRole> mockRemoteRoleList = new ArrayList<>();
+ RemoteRole mockRemoteRole = new RemoteRole();
+ mockRemoteRole.setId(1l);
+ mockRemoteRole.setName("test1");
+ mockRemoteRoleList.add(mockRemoteRole);
+ mockUserApplicationRoles.setAppId(mockApp.getId());
+ mockUserApplicationRoles.setFirstName("Guest");
+ mockUserApplicationRoles.setLastName("Test");
+ mockUserApplicationRoles.setOrgUserId("guestT");
+ mockUserApplicationRoles.setRoles(mockRemoteRoleList);
+ UserApplicationRoles mockUserApplicationRoles2 = new UserApplicationRoles();
+ List<RemoteRole> mockRemoteRoleList2 = new ArrayList<>();
+ RemoteRole mockRemoteRole2 = new RemoteRole();
+ mockRemoteRole2.setId(16l);
+ mockRemoteRole2.setName("test2");
+ mockRemoteRoleList2.add(mockRemoteRole2);
+ mockUserApplicationRoles2.setAppId(mockApp.getId());
+ mockUserApplicationRoles2.setFirstName("Guest2");
+ mockUserApplicationRoles2.setLastName("Test2");
+ mockUserApplicationRoles2.setOrgUserId("guestT2");
+ mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
+ mockUserApplicationRolesNonCentralizedList.add(mockUserApplicationRoles);
+ mockUserApplicationRolesNonCentralizedList.add(mockUserApplicationRoles2);
+ RemoteUserWithRoles mockRemoteUserWithRoles1 = new RemoteUserWithRoles();
+ mockRemoteUserWithRoles1.setFirstName("Guest1");
+ mockRemoteUserWithRoles1.setLastName("Test1");
+ mockRemoteUserWithRoles1.setOrgUserId("guestT");
+ mockRemoteUserWithRoles1.setRoles(mockRemoteRoleList);
+ RemoteUserWithRoles mockRemoteUserWithRoles2 = new RemoteUserWithRoles();
+ mockRemoteUserWithRoles2.setFirstName("Guest2");
+ mockRemoteUserWithRoles2.setLastName("Test2");
+ mockRemoteUserWithRoles2.setOrgUserId("guestT");
+ mockRemoteUserWithRoles2.setRoles(mockRemoteRoleList2);
+ List<RemoteUserWithRoles> mockRemoteUserWithRolesList = new ArrayList<>();
+ mockRemoteUserWithRolesList.add(mockRemoteUserWithRoles1);
+ mockRemoteUserWithRolesList.add(mockRemoteUserWithRoles2);
+ ObjectMapper mapper = new ObjectMapper();
+ String mockGetRemoteUsersWithRoles = mapper.writeValueAsString(mockRemoteUserWithRolesList);
+ Mockito.when(applicationsRestClientService.getIncomingJsonString(mockApp.getId(), "/users"))
+ .thenReturn(mockGetRemoteUsersWithRoles);
+ List<UserApplicationRoles> userApplicationRolesNonCentralizedList = userRolesCommonServiceImpl
+ .getUsersFromAppEndpoint(2l);
+ assertEquals(mockUserApplicationRolesNonCentralizedList.size(), userApplicationRolesNonCentralizedList.size());
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void putUserAppRolesRequestTest() {
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(false);
+ EPUser user = mockUser.mockEPUser();
+ AppWithRolesForUser appWithRolesForUser = new AppWithRolesForUser();
+ List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
+ RoleInAppForUser roleInAppForUser = new RoleInAppForUser();
+ roleInAppForUser.setIsApplied(true);
+ roleInAppForUser.setRoleId(1l);
+ roleInAppForUser.setRoleName("test1");
+ RoleInAppForUser roleInAppForUser2 = new RoleInAppForUser();
+ roleInAppForUser2.setIsApplied(true);
+ roleInAppForUser2.setRoleId(1000l);
+ roleInAppForUser2.setRoleName("test3");
+ mockRoleInAppForUserList.add(roleInAppForUser);
+ mockRoleInAppForUserList.add(roleInAppForUser2);
+ appWithRolesForUser.setAppId(mockApp.getId());
+ appWithRolesForUser.setAppName(mockApp.getName());
+ appWithRolesForUser.setOrgUserId(user.getOrgUserId());
+ appWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
+ List<EPUserAppRoles> epUserAppRolesList = new ArrayList<>();
+ EPUserAppRoles appRole1 = new EPUserAppRoles();
+ appRole1.setAppId(mockApp.getId());
+ appRole1.setId(10l);
+ appRole1.setRoleId(roleInAppForUser.roleId);
+ epUserAppRolesList.add(appRole1);
+ List<EPUserAppRoles> epUserAppRolesList2 = new ArrayList<>();
+ EPUserAppRoles appRole2 = new EPUserAppRoles();
+ appRole2.setAppId(mockApp.getId());
+ appRole2.setId(11l);
+ appRole2.setRoleId(roleInAppForUser2.roleId);
+ epUserAppRolesList2.add(appRole2);
+ EPUserAppRolesRequest mockEpAppRolesRequestData = new EPUserAppRolesRequest();
+ Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEpAppRolesRequestData, null);
+ final Map<String, Long> params = new HashMap<>();
+ params.put("appId", appWithRolesForUser.appId);
+ params.put("appRoleId", roleInAppForUser.roleId);
+ Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
+ .thenReturn(epUserAppRolesList);
+ params.put("appRoleId", roleInAppForUser2.roleId);
+ Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
+ .thenReturn(epUserAppRolesList2);
+ EPUserAppRolesRequestDetail mockEPAppRoleDetail = new EPUserAppRolesRequestDetail();
+ Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPAppRoleDetail, null);
+ FieldsValidator expected = new FieldsValidator();
+ expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
+ FieldsValidator actual = userRolesCommonServiceImpl.putUserAppRolesRequest(appWithRolesForUser, user);
+ assertEquals(expected, actual);
+ }
+
+ @Test
+ public void importRolesFromRemoteApplicationTest() throws HTTPException {
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(false);
+ List<EPRole> expected = new ArrayList<>();
+ EPRole epRole = new EPRole();
+ epRole.setAppId(mockApp.getId());
+ epRole.setActive(true);
+ epRole.setId(10l);
+ epRole.setName("test1");
+ EPRole epRole2 = new EPRole();
+ epRole2.setAppId(mockApp.getId());
+ epRole2.setActive(true);
+ epRole2.setId(11l);
+ epRole2.setName("test2");
+ expected.add(epRole);
+ expected.add(epRole2);
+ EPRole[] epRoleArray = expected.toArray(new EPRole[expected.size()]);
+ Mockito.when(applicationsRestClientService.get(EPRole[].class, mockApp.getId(), "/rolesFull"))
+ .thenReturn(epRoleArray);
+ Mockito.when(epRoleServiceImpl.getRole(mockApp.getId(), epRole.getId())).thenReturn(epRole);
+ Mockito.when(epRoleServiceImpl.getRole(mockApp.getId(), epRole2.getId())).thenReturn(epRole2);
+ List<EPRole> actual = userRolesCommonServiceImpl.importRolesFromRemoteApplication(mockApp.getId());
+ assertEquals(expected.size(), actual.size());
+ }
+
+ @SuppressWarnings("deprecation")
+ @Test
+ public void getCachedAppRolesForUserTest() {
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(false);
+ EPUser user = mockUser.mockEPUser();
+ List<EPUserApp> expected = new ArrayList<>();
+ EPUserApp epUserApp = new EPUserApp();
+ EPRole epRole = new EPRole();
+ epRole.setAppId(mockApp.getId());
+ epRole.setActive(true);
+ epRole.setId(10l);
+ epRole.setName("test1");
+ epUserApp.setApp(mockApp);
+ epUserApp.setRole(epRole);
+ epUserApp.setUserId(user.getId());
+ expected.add(epUserApp);
+ String filter = " where user_id = " + Long.toString(user.getId()) + " and app_id = "
+ + Long.toString(mockApp.getId());
+ Mockito.when(dataAccessService.getList(EPUserApp.class, filter, null, null)).thenReturn(expected);
+ List<EPUserApp> actual = userRolesCommonServiceImpl.getCachedAppRolesForUser(mockApp.getId(), user.getId());
+ assertEquals(expected.size(), actual.size());
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void getUserAppCatalogRolesTest() {
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(false);
+ EPUser user = mockUser.mockEPUser();
+ List<EPUserAppCatalogRoles> expected = new ArrayList<>();
+ EPUserAppCatalogRoles epUserAppCatalogRoles = new EPUserAppCatalogRoles();
+ epUserAppCatalogRoles.setAppId(mockApp.getId());
+ epUserAppCatalogRoles.setId(2l);
+ epUserAppCatalogRoles.setRequestedRoleId(10l);
+ epUserAppCatalogRoles.setRequestStatus("S");
+ epUserAppCatalogRoles.setRolename("test1");
+ expected.add(epUserAppCatalogRoles);
+ Map<String, String> params = new HashMap<>();
+ params.put("userid", user.getId().toString());
+ params.put("appName", mockApp.getName());
+ Mockito.when(
+ (List<EPUserAppCatalogRoles>) dataAccessService.executeNamedQuery("userAppCatalogRoles", params, null))
+ .thenReturn(expected);
+ List<EPUserAppCatalogRoles> actual = userRolesCommonServiceImpl.getUserAppCatalogRoles(user, mockApp.getName());
+ assertEquals(expected.size(), actual.size());
+ }
+
+ @Test
+ public void getExternalRequestAccessTest() {
+ ExternalSystemAccess expected = new ExternalSystemAccess("external_access_enable", false);
+ ExternalSystemAccess actual = userRolesCommonServiceImpl.getExternalRequestAccess();
+ assertEquals(expected, actual);
+ }
+
+ @Test
+ public void getEPUserAppListTest() {
+ EPApp mockApp = mockApp();
+ mockApp.setId(2l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(false);
+ EPUser user = mockUser.mockEPUser();
+ List<EPUserApp> expected = new ArrayList<>();
+ EPUserApp epUserApp = new EPUserApp();
+ EPRole epRole = new EPRole();
+ epRole.setAppId(mockApp.getId());
+ epRole.setActive(true);
+ epRole.setId(10l);
+ epRole.setName("test1");
+ epUserApp.setApp(mockApp);
+ epUserApp.setRole(epRole);
+ epUserApp.setUserId(user.getId());
+ expected.add(epUserApp);
+ final Map<String, Long> params = new HashMap<>();
+ params.put("appId", mockApp.getId());
+ params.put("userId", user.getId());
+ params.put("roleId", epRole.getId());
+ Mockito.when(dataAccessService.executeNamedQuery("getUserRoleOnUserIdAndRoleIdAndAppId", params, null))
+ .thenReturn(expected);
+ List<EPUserApp> actual = userRolesCommonServiceImpl.getEPUserAppList(mockApp.getId(), user.getId(),
+ epRole.getId());
+ assertEquals(expected.size(), actual.size());
+ }
+
+ @Test
+ public void updateRemoteUserProfileTest() {
+ EPApp mockApp = mockApp();
+ EPApp mockApp2 = mockApp();
+ mockApp.setId(2l);
+ mockApp.setEnabled(true);
+ mockApp.setCentralAuth(false);
+ EPUser user = mockUser.mockEPUser();
+ List<EPApp> mockEpAppList = new ArrayList<>();
+ mockEpAppList.add(mockApp);
+ mockEpAppList.add(mockApp2);
+ Mockito.when(searchServiceImpl.searchUserByUserId(user.getOrgUserId())).thenReturn(user);
+ Mockito.when(epAppCommonServiceImpl.getUserRemoteApps(user.getId().toString())).thenReturn(mockEpAppList);
+ String expected = "success";
+ String actual = userRolesCommonServiceImpl.updateRemoteUserProfile(user.getOrgUserId(), mockApp.getId());
+ assertEquals(expected, actual);
+ }
+}
Code Review / portal.git / blobdiff