ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/service/UserRolesCommonServiceImplTest.java

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   8  * Unless otherwise specified, all software contained herein is licensed
   9  * under the Apache License, Version 2.0 (the "License");
  10  * you may not use this software except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * Unless otherwise specified, all documentation contained herein is licensed
  22  * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
  23  * you may not use this documentation except in compliance with the License.
  24  * You may obtain a copy of the License at
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  28  * Unless required by applicable law or agreed to in writing, documentation
  29  * distributed under the License is distributed on an "AS IS" BASIS,
  30  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  * See the License for the specific language governing permissions and
  32  * limitations under the License.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  *
  37  */
  38 package org.onap.portalapp.portal.service;
  39
  40 import static org.junit.Assert.assertEquals;
  41 import static org.junit.Assert.assertFalse;
  42 import static org.junit.Assert.assertNotEquals;
  43 import static org.junit.Assert.assertNull;
  44 import static org.junit.Assert.assertTrue;
  45
  46 import java.util.ArrayList;
  47 import java.util.Date;
  48 import java.util.HashMap;
  49 import java.util.List;
  50 import java.util.Map;
  51 import java.util.Set;
  52 import java.util.SortedSet;
  53 import java.util.TreeSet;
  54
  55 import javax.servlet.http.HttpServletResponse;
  56
  57 import org.apache.cxf.transport.http.HTTPException;
  58 import org.hibernate.Query;
  59 import org.hibernate.SQLQuery;
  60 import org.hibernate.Session;
  61 import org.hibernate.SessionFactory;
  62 import org.hibernate.Transaction;
  63 import org.json.JSONObject;
  64 import org.junit.After;
  65 import org.junit.Before;
  66 import org.junit.Test;
  67 import org.junit.runner.RunWith;
  68 import org.mockito.InjectMocks;
  69 import org.mockito.Matchers;
  70 import org.mockito.Mock;
  71 import org.mockito.Mockito;
  72 import org.mockito.MockitoAnnotations;
  73 import org.onap.portalapp.externalsystemapproval.model.ExternalSystemRoleApproval;
  74 import org.onap.portalapp.externalsystemapproval.model.ExternalSystemUser;
  75 import org.onap.portalapp.portal.core.MockEPUser;
  76 import org.onap.portalapp.portal.domain.EPApp;
  77 import org.onap.portalapp.portal.domain.EPRole;
  78 import org.onap.portalapp.portal.domain.EPUser;
  79 import org.onap.portalapp.portal.domain.EPUserApp;
  80 import org.onap.portalapp.portal.domain.EPUserAppCatalogRoles;
  81 import org.onap.portalapp.portal.domain.EPUserAppRoles;
  82 import org.onap.portalapp.portal.domain.EPUserAppRolesRequest;
  83 import org.onap.portalapp.portal.domain.EPUserAppRolesRequestDetail;
  84 import org.onap.portalapp.portal.domain.EpAppType;
  85 import org.onap.portalapp.portal.domain.ExternalSystemAccess;
  86 import org.onap.portalapp.portal.transport.*;
  87 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
  88 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  89 import org.onap.portalapp.portal.utils.PortalConstants;
  90 import org.onap.portalsdk.core.domain.Role;
  91 import org.onap.portalsdk.core.restful.domain.EcompRole;
  92 import org.onap.portalsdk.core.service.DataAccessService;
  93 import org.onap.portalsdk.core.service.DataAccessServiceImpl;
  94 import org.onap.portalsdk.core.service.RoleServiceImpl;
  95 import org.onap.portalsdk.core.util.SystemProperties;
  96 import org.powermock.api.mockito.PowerMockito;
  97 import org.powermock.core.classloader.annotations.PrepareForTest;
  98 import org.powermock.modules.junit4.PowerMockRunner;
  99 import org.springframework.beans.factory.annotation.Autowired;
 100 import org.springframework.http.HttpEntity;
 101 import org.springframework.http.HttpHeaders;
 102 import org.springframework.http.HttpMethod;
 103 import org.springframework.http.HttpStatus;
 104 import org.springframework.http.ResponseEntity;
 105 import org.springframework.web.client.RestTemplate;
 106
 107 import com.fasterxml.jackson.core.JsonProcessingException;
 108 import com.fasterxml.jackson.databind.ObjectMapper;
 109
 110 @RunWith(PowerMockRunner.class)
 111 @PrepareForTest({ EcompPortalUtils.class, SystemProperties.class, PortalConstants.class,
 112                 EPCommonSystemProperties.class })
 113 public class UserRolesCommonServiceImplTest {
 114
 115         @Mock
 116         DataAccessService dataAccessService = new DataAccessServiceImpl();
 117
 118         @Mock
 119         EPAppCommonServiceImpl epAppCommonServiceImpl = new EPAppCommonServiceImpl();
 120
 121         @Mock
 122         ExternalAccessRolesServiceImpl externalAccessRolesServiceImpl = new ExternalAccessRolesServiceImpl();
 123
 124         @Mock
 125         ApplicationsRestClientService applicationsRestClientService;
 126
 127         @Mock
 128         RoleServiceImpl roleServiceImpl = new RoleServiceImpl();
 129
 130         @Mock
 131         SearchServiceImpl searchServiceImpl = new SearchServiceImpl();
 132
 133         @Mock
 134         EPRoleServiceImpl epRoleServiceImpl = new EPRoleServiceImpl();
 135
 136         @Mock
 137         RestTemplate template = new RestTemplate();
 138
 139         @Mock
 140         SessionFactory sessionFactory;
 141
 142         @Mock
 143         Session session;
 144
 145         @Mock
 146         Transaction transaction;
 147
 148         @Mock
 149         AdminRolesService adminRolesService;
 150
 151         @InjectMocks
 152         UserRolesCommonServiceImpl userRolesCommonServiceImpl = new UserRolesCommonServiceImpl();
 153
 154         @Before
 155         public void setup() {
 156                 MockitoAnnotations.initMocks(this);
 157                 Mockito.when(sessionFactory.openSession()).thenReturn(session);
 158                 Mockito.when(session.beginTransaction()).thenReturn(transaction);
 159         }
 160
 161         @After
 162         public void after() {
 163                 session.close();
 164         }
 165
 166         MockEPUser mockUser = new MockEPUser();
 167
 168         public EPApp mockApp() {
 169                 EPApp app = new EPApp();
 170                 app.setName("Test");
 171                 app.setImageUrl("test");
 172                 app.setAppDescription("test");
 173                 app.setAppNotes("test");
 174                 app.setLandingPage("test");
 175                 app.setId((long) 1);
 176                 app.setAppRestEndpoint("test");
 177                 app.setAlternateLandingPage("test");
 178                 app.setName("test");
 179                 app.setMlAppName("test");
 180                 app.setMlAppAdminId("test");
 181                 app.setAppBasicAuthUsername("test");
 182                 app.setAppBasicAuthPassword("test");
 183                 app.setOpen(false);
 184                 app.setEnabled(false);
 185                 app.setRolesInAAF(true);
 186                 app.setUebKey("test");
 187                 app.setUebSecret("test");
 188                 app.setUebTopicName("test");
 189                 app.setAppType(EpAppType.GUI);
 190                 return app;
 191         }
 192
 193         @SuppressWarnings("unchecked")
 194         @Test
 195         public void getAppRolesForUserCentralizedForPortal() throws Exception {
 196                 EPUser user = mockUser.mockEPUser();
 197                 EPApp mockApp = mockApp();
 198                 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
 199                 List<RoleInAppForUser> mockRoleInAppForUserList = getMockedRoleInAppUserList();
 200                 List<CentralV2Role> mockCenV2Role = new ArrayList<>();
 201         CentralV2Role cenV2Role = new CentralV2Role.CentralV2RoleBuilder().setId(1l).setCreated(null).setModified(null)
 202                 .setCreatedId(null).setModifiedId(null).setRowNum(null).setName("test1").setActive(true)
 203                 .setPriority(null).setRoleFunctions(new TreeSet<>()).setChildRoles(new TreeSet<>())
 204                 .setParentRoles(new TreeSet<>()).createCentralV2Role();
 205         CentralV2Role cenV2Role2 = new CentralV2Role.CentralV2RoleBuilder().setId(16l).setCreated(null)
 206                 .setModified(null).setCreatedId(null).setModifiedId(null).setRowNum(null).setName("test2")
 207                 .setActive(true).setPriority(null).setRoleFunctions(new TreeSet<>()).setChildRoles(new TreeSet<>())
 208                 .setParentRoles(new TreeSet<>()).createCentralV2Role();
 209                 mockCenV2Role.add(cenV2Role);
 210                 mockCenV2Role.add(cenV2Role2);
 211                 Mockito.when(externalAccessRolesServiceImpl.getRolesForApp(mockApp.getUebKey())).thenReturn(mockCenV2Role);
 212                 List<EPUser> mockUserList = new ArrayList<>();
 213                 mockUserList.add(user);
 214                 Mockito.when((List<EPUser>) dataAccessService
 215                                 .executeQuery("from EPUser where orgUserId='" + user.getOrgUserId() + "'", null))
 216                                 .thenReturn(mockUserList);
 217                 Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true, user))
 218                                 .thenReturn(mockRoleInAppForUserList);
 219                 List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(1l, "test", true, user);
 220                 assertEquals(roleInAppForUser, mockRoleInAppForUserList);
 221         }
 222
 223         private List<RoleInAppForUser> getMockedRoleInAppUserList() {
 224                 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
 225                 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
 226                 mockRoleInAppForUser.setIsApplied(false);
 227                 mockRoleInAppForUser.setRoleId(1l);
 228                 mockRoleInAppForUser.setRoleName("test1");
 229                 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
 230                 mockRoleInAppForUser2.setIsApplied(false);
 231                 mockRoleInAppForUser2.setRoleId(16l);
 232                 mockRoleInAppForUser2.setRoleName("test2");
 233                 mockRoleInAppForUserList.add(mockRoleInAppForUser);
 234                 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
 235                 return mockRoleInAppForUserList;
 236         }
 237
 238         @SuppressWarnings("unchecked")
 239         @Test
 240         public void checkTheProtectionAgainstSQLInjection() throws Exception {
 241                 EPUser user = mockUser.mockEPUser();
 242                 user.setId(1l);
 243                 user.setOrgId(2l);
 244                 Query epUserQuery = Mockito.mock(Query.class);
 245                 List<EPUser> mockEPUserList = new ArrayList<>();
 246                 mockEPUserList.add(user);
 247
 248                 Mockito.when(session.createQuery("from :name where orgUserId=:userId")).thenReturn(epUserQuery);
 249                 Mockito.when(epUserQuery.setParameter("name",EPUser.class.getName())).thenReturn(epUserQuery);
 250                 Mockito.when(epUserQuery.setParameter("userId",user.getOrgUserId() + "; select * from " + EPUser.class.getName() +";")).thenReturn(epUserQuery);
 251                 userRolesCommonServiceImpl.createLocalUserIfNecessary(user.getOrgUserId(),true);
 252
 253                 Mockito.when(session.createQuery("from :name where orgUserId=:userId")).thenReturn(epUserQuery);
 254                 Mockito.when(epUserQuery.setParameter("name",EPUser.class.getName())).thenReturn(epUserQuery);
 255                 Mockito.when(epUserQuery.setParameter("userId",user.getOrgUserId())).thenReturn(epUserQuery);
 256                 userRolesCommonServiceImpl.createLocalUserIfNecessary(user.getOrgUserId(),true);
 257         }
 258
 259         @SuppressWarnings("unchecked")
 260         @Test
 261         public void getAppRolesForUserNonCentralizedForPortal() throws Exception {
 262                 EPUser user = mockUser.mockEPUser();
 263                 user.setId(1l);
 264                 EPApp mockApp = mockApp();
 265                 mockApp.setRolesInAAF(false);
 266                 EPRole mockEPRole = new EPRole();
 267                 mockEPRole.setId(1l);
 268                 mockEPRole.setName("test1");
 269                 mockEPRole.setActive(true);
 270                 SortedSet<EPUserApp> mockUserApps = new TreeSet<EPUserApp>();
 271                 EPUserApp mockEPUserApp = new EPUserApp();
 272                 mockEPUserApp.setApp(mockApp);
 273                 mockEPUserApp.setRole(mockEPRole);
 274                 mockEPUserApp.setUserId(1l);
 275                 mockUserApps.add(mockEPUserApp);
 276                 user.setEPUserApps(mockUserApps);
 277                 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
 278                 List<RoleInAppForUser> mockRoleInAppForUserListNonCentralizedList = getMockedRoleInAppUserList();
 279                 List<Role> mockRole = new ArrayList<>();
 280                 Role role = new Role();
 281                 role.setId(1l);
 282                 role.setName("test1");
 283                 role.setActive(true);
 284                 Role role2 = new Role();
 285                 role.setId(16l);
 286                 role.setName("test2");
 287                 role.setActive(true);
 288                 mockRole.add(role);
 289                 mockRole.add(role2);
 290                 Mockito.when(roleServiceImpl.getAvailableRoles(user.getOrgUserId())).thenReturn(mockRole);
 291                 List<EPUser> mockUserList = new ArrayList<>();
 292                 mockUserList.add(user);
 293                 Mockito.when((List<EPUser>) dataAccessService
 294                                 .executeQuery("from EPUser where orgUserId='" + user.getOrgUserId() + "'", null))
 295                                 .thenReturn(mockUserList);
 296                 Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true, user))
 297                                 .thenReturn(mockRoleInAppForUserListNonCentralizedList);
 298                 List<RoleInAppForUser> roleInAppForUserNonCentralized = userRolesCommonServiceImpl.getAppRolesForUser(1l,
 299                                 user.getOrgUserId(), true, user);
 300                 assertNull(roleInAppForUserNonCentralized);
 301         }
 302
 303         @Test
 304         public void getAppRolesForCentralizedPartnerAppTest() throws Exception {
 305                 EPUser user = mockUser.mockEPUser();
 306                 EPApp mockApp = mockApp();
 307                 mockApp.setId(2l);
 308                 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
 309                 List<RoleInAppForUser> mockRoleInAppForUserList = getMockedRoleInAppUserList();
 310                 List<EPRole> mockEPRoleList = new ArrayList<>();
 311                 EPRole mockEpRole = new EPRole();
 312                 mockEpRole.setActive(true);
 313                 mockEpRole.setAppId(2l);
 314                 mockEpRole.setName("test1");
 315                 mockEpRole.setAppRoleId(333l);
 316                 mockEpRole.setId(1l);
 317                 EPRole mockEpRole2 = new EPRole();
 318                 mockEpRole2.setActive(true);
 319                 mockEpRole2.setAppId(2l);
 320                 mockEpRole2.setName("test2");
 321                 mockEpRole2.setAppRoleId(444l);
 322                 mockEpRole2.setId(16l);
 323                 mockEPRoleList.add(mockEpRole);
 324                 mockEPRoleList.add(mockEpRole2);
 325                 final Map<String, Long> appParams = new HashMap<>();
 326                 appParams.put("appId", 2l);
 327                 Mockito.when(dataAccessService.executeNamedQuery("getActiveRolesOfApplication", appParams, null))
 328                                 .thenReturn(mockEPRoleList);
 329                 final Map<String, String> params = new HashMap<>();
 330                 params.put("orgUserIdValue", "guestT");
 331                 List<EPUser> mockEPUserList = new ArrayList<>();
 332                 mockEPUserList.add(user);
 333                 Mockito.when(dataAccessService.executeNamedQuery("epUserAppId", params, null)).thenReturn(mockEPUserList);
 334                 final Map<String, Long> userParams = new HashMap<>();
 335                 userParams.put("appId", mockApp.getId());
 336                 userParams.put("userId", mockEPUserList.get(0).getId());
 337                 List<EPUserAppCurrentRoles> epUserAppCurrentRolesList = new ArrayList<>();
 338                 EPUserAppCurrentRoles epUserAppCurrentRoles = new EPUserAppCurrentRoles();
 339                 epUserAppCurrentRoles.setRoleId(444l);
 340                 epUserAppCurrentRoles.setRoleName("TestPartnerRole2");
 341                 epUserAppCurrentRoles.setUserId(mockEPUserList.get(0).getId());
 342                 epUserAppCurrentRolesList.add(epUserAppCurrentRoles);
 343                 Mockito.when(dataAccessService.executeNamedQuery("getUserAppCurrentRoles", userParams, null))
 344                                 .thenReturn(epUserAppCurrentRolesList);
 345                 Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(), true, user))
 346                                 .thenReturn(mockRoleInAppForUserList);
 347                 List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
 348                                 true, user);
 349                 assertNotEquals(roleInAppForUser, mockRoleInAppForUserList);
 350         }
 351
 352         @Test
 353         public void getAppRolesForNonCentralizedPartnerAppTest() throws Exception {
 354                 EPUser user = mockUser.mockEPUser();
 355                 user.setId(2l);
 356                 List<EPUser> mockEpUserList = new ArrayList<>();
 357                 mockEpUserList.add(user);
 358                 EPApp mockApp = mockApp();
 359                 mockApp.setId(2l);
 360                 mockApp.setRolesInAAF(false);
 361                 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
 362                 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
 363                 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
 364             mockRoleInAppForUser.setIsApplied(true);
 365                 mockRoleInAppForUser.setRoleId(333l);
 366                 mockRoleInAppForUser.setRoleName("test1");
 367                 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
 368             mockRoleInAppForUser2.setIsApplied(true);
 369                 mockRoleInAppForUser2.setRoleId(777l);
 370                 mockRoleInAppForUser2.setRoleName("test2");
 371                 RoleInAppForUser mockRoleInAppForUser3 = new RoleInAppForUser();
 372                 mockRoleInAppForUser3.setIsApplied(false);
 373                 mockRoleInAppForUser3.setRoleId(888l);
 374                 mockRoleInAppForUser3.setRoleName("test5");
 375                 mockRoleInAppForUserList.add(mockRoleInAppForUser);
 376                 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
 377                 mockRoleInAppForUserList.add(mockRoleInAppForUser3);
 378                 List<EcompRole> mockEcompRoleList = new ArrayList<>();
 379                 EcompRole mockEcompRole = new EcompRole();
 380                 mockEcompRole.setId(333l);
 381                 mockEcompRole.setName("test1");
 382                 EcompRole mockEcompRole2 = new EcompRole();
 383                 mockEcompRole2.setId(777l);
 384                 mockEcompRole2.setName("test2");
 385                 EcompRole mockEcompRole3 = new EcompRole();
 386                 mockEcompRole3.setId(888l);
 387                 mockEcompRole3.setName("test5");
 388                 mockEcompRoleList.add(mockEcompRole);
 389                 mockEcompRoleList.add(mockEcompRole2);
 390                 mockEcompRoleList.add(mockEcompRole3);
 391                 EcompRole[] mockEcompRoleArray = mockEcompRoleList.toArray(new EcompRole[mockEcompRoleList.size()]);
 392                 List<EPRole> mockEPRoleList = new ArrayList<>();
 393                 EPRole mockEpRole = new EPRole();
 394                 mockEpRole.setActive(true);
 395                 mockEpRole.setAppId(2l);
 396                 mockEpRole.setName("test1");
 397                 mockEpRole.setAppRoleId(333l);
 398                 mockEpRole.setId(16l);
 399                 EPRole mockEpRole2 = new EPRole();
 400                 mockEpRole2.setActive(true);
 401                 mockEpRole2.setAppId(2l);
 402                 mockEpRole2.setName("test3");
 403                 mockEpRole2.setAppRoleId(555l);
 404                 mockEpRole2.setId(15l);
 405                 EPRole mockEpRole3 = new EPRole();
 406                 mockEpRole3.setActive(true);
 407                 mockEpRole3.setAppId(2l);
 408                 mockEpRole3.setName("test4");
 409                 mockEpRole3.setAppRoleId(888l);
 410                 mockEpRole3.setId(17l);
 411                 mockEPRoleList.add(mockEpRole);
 412                 mockEPRoleList.add(mockEpRole2);
 413                 mockEPRoleList.add(mockEpRole3);
 414                 List<EPUserApp> mockUserRolesList = new ArrayList<>();
 415                 EPUserApp mockEpUserApp = new EPUserApp();
 416                 mockEpUserApp.setApp(mockApp);
 417                 mockEpUserApp.setRole(mockEpRole2);
 418                 mockEpUserApp.setUserId(user.getId());
 419                 mockUserRolesList.add(mockEpUserApp);
 420                 List<FunctionalMenuRole> mockFunctionalMenuRolesList = new ArrayList<>();
 421                 FunctionalMenuRole mockFunctionalMenuRole = new FunctionalMenuRole();
 422                 mockFunctionalMenuRole.setAppId((int) (long) mockApp.getId());
 423                 mockFunctionalMenuRole.setRoleId((int) (long) 15l);
 424                 mockFunctionalMenuRole.setMenuId(10l);
 425                 mockFunctionalMenuRole.setId(10);
 426                 mockFunctionalMenuRolesList.add(mockFunctionalMenuRole);
 427                 List<FunctionalMenuItem> mockFunctionalMenuItemList = new ArrayList<>();
 428                 FunctionalMenuItem mockFunctionalMenuItem = new FunctionalMenuItem();
 429                 List<Integer> mockRolesList = new ArrayList<>();
 430                 Integer role1 = 1;
 431                 mockRolesList.add(role1);
 432                 mockFunctionalMenuItem.setRestrictedApp(false);
 433                 mockFunctionalMenuItem.setRoles(mockRolesList);
 434                 mockFunctionalMenuItem.setUrl("http://test.com");
 435                 mockFunctionalMenuItemList.add(mockFunctionalMenuItem);
 436                 Query epRoleQuery = Mockito.mock(Query.class);
 437                 Query epUserAppsQuery = Mockito.mock(Query.class);
 438                 Query epFunctionalMenuQuery = Mockito.mock(Query.class);
 439                 Query epFunctionalMenuQuery2 = Mockito.mock(Query.class);
 440                 Query epFunctionalMenuItemQuery = Mockito.mock(Query.class);
 441                 Query epUserListQuery = Mockito.mock(Query.class);
 442                 Query epUserRolesListQuery = Mockito.mock(Query.class);
 443                 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
 444                                 .thenReturn(mockEcompRoleArray);
 445                 // syncAppRolesTest
 446
 447                 Mockito.when(session.createQuery("from EPRole where appId = :appId"))
 448                                 .thenReturn(epRoleQuery);
 449
 450                 Mockito.when(epRoleQuery.setParameter("appId",mockApp.getId())).thenReturn(epRoleQuery);
 451
 452                 Mockito.doReturn(mockEPRoleList).when(epRoleQuery).list();
 453                 Mockito.when(session.createQuery("from EPUserApp where app.id=:appId and role_id=:roleId"))
 454                                 .thenReturn(epUserAppsQuery);
 455                 Mockito.when(epUserAppsQuery.setParameter("appId",mockApp.getId())).thenReturn(epUserAppsQuery);
 456                 Mockito.when(epUserAppsQuery.setParameter("roleId",15l)).thenReturn(epUserAppsQuery);
 457                 Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
 458
 459                 Mockito.when(session.createQuery("from FunctionalMenuRole where roleId=:roleId"))
 460                                 .thenReturn(epFunctionalMenuQuery);
 461                 Mockito.when(epFunctionalMenuQuery.setParameter("roleId",15l)).thenReturn(epFunctionalMenuQuery);
 462                 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
 463
 464                 Mockito.when(session.createQuery("from FunctionalMenuRole where menuId=:menuId"))
 465                                 .thenReturn(epFunctionalMenuQuery2);
 466                 Mockito.when(epFunctionalMenuQuery2.setParameter(Matchers.anyString(),Matchers.anyLong())).thenReturn(epFunctionalMenuQuery2);
 467                 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
 468
 469                 Mockito.when(session.createQuery("from FunctionalMenuItem where menuId=:menuId"))
 470                                 .thenReturn(epFunctionalMenuItemQuery);
 471                 Mockito.when(epFunctionalMenuItemQuery.setParameter(Matchers.anyString(),Matchers.anyLong())).thenReturn(epFunctionalMenuItemQuery);
 472                 Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
 473                 List<EcompRole> mockEcompRoleList2 = new ArrayList<>();
 474                 EcompRole mockUserAppRoles = new EcompRole();
 475                 mockUserAppRoles.setId(333l);
 476                 mockUserAppRoles.setName("test1");
 477                 EcompRole mockUserAppRoles2 = new EcompRole();
 478                 mockUserAppRoles2.setId(777l);
 479                 mockUserAppRoles2.setName("test2");
 480                 mockEcompRoleList2.add(mockUserAppRoles);
 481                 mockEcompRoleList2.add(mockUserAppRoles2);
 482                 EcompRole[] mockEcompRoleArray2 = mockEcompRoleList2.toArray(new EcompRole[mockEcompRoleList2.size()]);
 483                 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(),
 484                                 String.format("/user/%s/roles", user.getOrgUserId()))).thenReturn(mockEcompRoleArray2);
 485
 486
 487                 Mockito.when(session.createQuery(
 488                                 "from EPUser where orgUserId=:userId"))
 489                                 .thenReturn(epUserListQuery);
 490                 Mockito.when(epUserListQuery.setParameter("userId","guestT")).thenReturn(epUserListQuery);
 491                 Mockito.doReturn(mockEpUserList).when(epUserListQuery).list();
 492
 493                 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
 494                 EPUserApp mockEpUserAppRoles = new EPUserApp();
 495                 mockEpUserAppRoles.setApp(mockApp);
 496                 mockEpUserAppRoles.setRole(mockEpRole3);
 497                 mockEpUserAppRoles.setUserId(user.getId());
 498                 mockUserRolesList2.add(mockEpUserAppRoles);
 499                 Mockito.when(session.createQuery(
 500                                 "from EPUserApp where app.id=:appId and userId=:userId and role.active = 'Y'"))
 501                                 .thenReturn(epUserRolesListQuery);
 502
 503                 Mockito.when(epUserRolesListQuery.setParameter("appId",2)).thenReturn(epUserRolesListQuery);
 504                 Mockito.when(epUserRolesListQuery.setParameter("userId",2)).thenReturn(epUserRolesListQuery);
 505
 506                 Mockito.doReturn(mockUserRolesList2).when(epUserRolesListQuery).list();
 507
 508
 509                 List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
 510                                 true, user);
 511                 assertEquals(roleInAppForUser, mockRoleInAppForUserList);
 512         }
 513
 514         @SuppressWarnings("unchecked")
 515         @Test
 516         public void setAppWithUserRoleStateForUserTestForCentralizedAppForPortal() throws Exception {
 517                 PowerMockito.mockStatic(SystemProperties.class);
 518                 PowerMockito.mockStatic(EcompPortalUtils.class);
 519                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 520                 PowerMockito.mockStatic(PortalConstants.class);
 521                 EPUser user = mockUser.mockEPUser();
 522                 user.setId(2l);
 523                 List<EPUser> mockEpUserList = new ArrayList<>();
 524                 mockEpUserList.add(user);
 525                 EPApp mockApp = mockApp();
 526                 mockApp.setNameSpace("com.test.com");
 527                 mockApp.setId(1l);
 528                 mockApp.setRolesInAAF(true);
 529                 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
 530                 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
 531                 AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
 532                 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
 533                 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
 534                 mockRoleInAppForUser.setIsApplied(true);
 535                 mockRoleInAppForUser.setRoleId(1l);
 536                 mockRoleInAppForUser.setRoleName("test1");
 537                 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
 538                 mockRoleInAppForUser2.setIsApplied(true);
 539                 mockRoleInAppForUser2.setRoleId(1000l);
 540                 mockRoleInAppForUser2.setRoleName("test3");
 541                 mockRoleInAppForUserList.add(mockRoleInAppForUser);
 542                 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
 543                 mockWithRolesForUser.setAppId(mockApp.getId());
 544                 mockWithRolesForUser.setAppName(mockApp.getName());
 545                 mockWithRolesForUser.setOrgUserId(user.getOrgUserId());
 546                 mockWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
 547                 List<EPUserAppRolesRequest> mockEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
 548                 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
 549                 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
 550                 mockEpUserAppRolesRequestDetail.setId(2l);
 551                 mockEpUserAppRolesRequestDetail.setReqType("P");
 552                 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
 553                 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
 554                 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
 555                 mockEPUserAppRolesRequest.setId(1l);
 556                 mockEPUserAppRolesRequest.setRequestStatus("P");
 557                 mockEPUserAppRolesRequest.setUserId(user.getId());
 558                 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
 559                 mockEpRequestIdValList.add(mockEPUserAppRolesRequest);
 560                 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
 561                 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
 562
 563                 // Update Requests if any requests are pending
 564                 final Map<String, Long> params = new HashMap<>();
 565                 params.put("appId", mockApp.getId());
 566                 params.put("userId", user.getId());
 567                 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
 568                                 params, null)).thenReturn(mockEpRequestIdValList);
 569                 mockEPUserAppRolesRequest.setUpdatedDate(new Date());
 570                 mockEPUserAppRolesRequest.setRequestStatus("O");
 571                 HashMap<String, Long> additionalUpdateParam = new HashMap<String, Long>();
 572                 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPUserAppRolesRequest, additionalUpdateParam);
 573                 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
 574                 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
 575                 mockEpUserAppRolesRequestDetail.setId(2l);
 576                 mockEpUserAppRolesRequestDetail.setReqType("P");
 577                 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
 578                 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
 579                 // Updates in External Auth System
 580                 final Map<String, String> userParams = new HashMap<>();
 581                 userParams.put("orgUserIdValue", user.getOrgUserId());
 582                 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
 583                                 .thenReturn(mockEpUserList);
 584                 PowerMockito
 585                                 .when(EPCommonSystemProperties
 586                                                 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
 587                                 .thenReturn(true);
 588                 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
 589                                 .thenReturn("@test.com");
 590                 HttpHeaders headers = new HttpHeaders();
 591                 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
 592                 JSONObject mockJsonObject1 = new JSONObject();
 593                 JSONObject mockJsonObject2 = new JSONObject();
 594                 JSONObject mockJsonObject3 = new JSONObject();
 595                 mockJsonObject1.put("name", "com.test.com.test1");
 596                 mockJsonObject2.put("name", "com.test.com.test2");
 597                 List<JSONObject> mockJson = new ArrayList<>();
 598                 mockJson.add(mockJsonObject1);
 599                 mockJson.add(mockJsonObject2);
 600                 mockJsonObject3.put("role", mockJson);
 601                 ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
 602                 Mockito.when(externalAccessRolesServiceImpl.getUserRolesFromExtAuthSystem(Matchers.anyString(), Matchers.any(HttpEntity.class))).thenReturn(getResponse);
 603                 EPRole mockEPRole = new EPRole();
 604                 mockEPRole.setActive(true);
 605                 mockEPRole.setAppId(null);
 606                 mockEPRole.setAppRoleId(null);
 607                 mockEPRole.setId(1l);
 608                 mockEPRole.setName("test1");
 609                 EPRole mockEPRole2 = new EPRole();
 610                 mockEPRole2.setActive(true);
 611                 mockEPRole2.setAppId(null);
 612                 mockEPRole2.setAppRoleId(null);
 613                 mockEPRole2.setId(16l);
 614                 mockEPRole2.setName("test2");
 615                 EPRole mockEPRole3 = new EPRole();
 616                 mockEPRole3.setActive(true);
 617                 mockEPRole3.setAppId(null);
 618                 mockEPRole3.setAppRoleId(null);
 619                 mockEPRole3.setId(1000l);
 620                 mockEPRole3.setName("test3");
 621                 Map<String, EPRole> mockEPRoleList = new HashMap<>();
 622                 mockEPRoleList.put("test1", mockEPRole);
 623                 mockEPRoleList.put("test2", mockEPRole2);
 624                 mockEPRoleList.put("test3", mockEPRole3);
 625                 Mockito.when(externalAccessRolesServiceImpl.getAppRoleNamesWithUnderscoreMap(mockApp)).thenReturn(mockEPRoleList);
 626                 final Map<String, Long> params2 = new HashMap<>();
 627                 params2.put("appId", mockApp.getId());
 628                 params2.put("userId", user.getId());
 629                 List<EcompUserAppRoles> mockEPuserAppList = getCurrentUserRoles(user, mockApp);
 630                 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
 631                                 .thenReturn(mockEPuserAppList);
 632                 final Map<String, Long> epDetailParams = new HashMap<>();
 633                 epDetailParams.put("reqId", mockEPUserAppRolesRequest.getId());
 634                 Mockito.when(dataAccessService.executeNamedQuery("userAppRolesRequestDetailList", epDetailParams, null))
 635                                 .thenReturn(mockGetEpUserAppRolesRequestDetailList);
 636
 637                 ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
 638                 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
 639                                 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
 640
 641                 ResponseEntity<String> deleteResponse = new ResponseEntity<>(HttpStatus.OK);
 642                 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE),
 643                                 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(deleteResponse);
 644
 645                 // Updates in EP DB
 646                 Query epsetAppWithUserRoleGetUserQuery = Mockito.mock(Query.class);
 647                 Query epsetAppWithUserRoleGetUserAppsQuery = Mockito.mock(Query.class);
 648                 Query epsetAppWithUserRoleGetRolesQuery = Mockito.mock(Query.class);
 649                 SQLQuery epsetAppWithUserRoleUpdateEPRoleQuery = Mockito.mock(SQLQuery.class);
 650                 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
 651                 Mockito.when(session
 652                                 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
 653                                 .thenReturn(epsetAppWithUserRoleGetUserQuery);
 654                 Mockito.doReturn(mockEpUserList).when(epsetAppWithUserRoleGetUserQuery).list();
 655                 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
 656                 EPUserApp mockEpUserAppRoles = new EPUserApp();
 657                 mockEpUserAppRoles.setApp(mockApp);
 658                 mockEpUserAppRoles.setRole(mockEPRole);
 659                 mockEpUserAppRoles.setUserId(user.getId());
 660                 mockUserRolesList2.add(mockEpUserAppRoles);
 661                 Mockito.when(session.createQuery(
 662                                 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=1 and role.active = 'Y' and userId=2"))
 663                                 .thenReturn(epsetAppWithUserRoleGetUserAppsQuery);
 664                 Mockito.doReturn(mockUserRolesList2).when(epsetAppWithUserRoleGetUserAppsQuery).list();
 665                 List<EPRole> mockEPRoles = new ArrayList<>();
 666                 mockEPRoles.add(mockEPRole2);
 667                 mockEPRoles.add(mockEPRole3);
 668                 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId is null and id != 1"))
 669                                 .thenReturn(epsetAppWithUserRoleGetRolesQuery);
 670                 Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleGetRolesQuery).list();
 671                 Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
 672                                 .thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
 673                 ExternalRequestFieldsValidator actual = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
 674                 assertTrue(actual.isResult());
 675         }
 676
 677         private List<EcompUserAppRoles> getCurrentUserRoles(EPUser user, EPApp mockApp) {
 678                 List<EcompUserAppRoles> mockEPuserAppList = new ArrayList<>();
 679                 EcompUserAppRoles mockEcompUserAppRoles = new EcompUserAppRoles();
 680                 mockEcompUserAppRoles.setAppId(String.valueOf(mockApp.getId()));
 681                 mockEcompUserAppRoles.setRoleId(1l);
 682                 mockEcompUserAppRoles.setRoleName("test1");
 683                 mockEcompUserAppRoles.setUserId(user.getId());
 684                 mockEPuserAppList.add(mockEcompUserAppRoles);
 685                 return mockEPuserAppList;
 686         }
 687
 688         @SuppressWarnings("unchecked")
 689         @Test
 690         public void setAppWithUserRoleStateForUserTestForNonCentralizedApp() throws Exception {
 691                 PowerMockito.mockStatic(SystemProperties.class);
 692                 PowerMockito.mockStatic(EcompPortalUtils.class);
 693                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 694                 PowerMockito.mockStatic(PortalConstants.class);
 695                 EPUser user = mockUser.mockEPUser();
 696                 user.setId(2l);
 697                 List<EPUser> mockEpUserList = new ArrayList<>();
 698                 mockEpUserList.add(user);
 699                 EPApp mockApp = mockApp();
 700                 mockApp.setNameSpace("com.test.com");
 701                 mockApp.setId(2l);
 702                 mockApp.setRolesInAAF(false);
 703                 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
 704                 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
 705                 AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
 706                 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
 707                 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
 708                 mockRoleInAppForUser.setIsApplied(true);
 709                 mockRoleInAppForUser.setRoleId(1l);
 710                 mockRoleInAppForUser.setRoleName("test1");
 711                 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
 712                 mockRoleInAppForUser2.setIsApplied(true);
 713                 mockRoleInAppForUser2.setRoleId(1000l);
 714                 mockRoleInAppForUser2.setRoleName("test3");
 715                 mockRoleInAppForUserList.add(mockRoleInAppForUser);
 716                 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
 717                 mockWithRolesForUser.setAppId(mockApp.getId());
 718                 mockWithRolesForUser.setAppName(mockApp.getName());
 719                 mockWithRolesForUser.setOrgUserId(user.getOrgUserId());
 720                 mockWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
 721                 List<EPUserAppRolesRequest> mockEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
 722                 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
 723                 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
 724                 mockEpUserAppRolesRequestDetail.setId(2l);
 725                 mockEpUserAppRolesRequestDetail.setReqType("P");
 726                 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
 727                 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
 728                 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
 729                 mockEPUserAppRolesRequest.setId(1l);
 730                 mockEPUserAppRolesRequest.setRequestStatus("P");
 731                 mockEPUserAppRolesRequest.setUserId(user.getId());
 732                 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
 733                 mockEpRequestIdValList.add(mockEPUserAppRolesRequest);
 734                 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
 735                 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
 736
 737                 // Update Requests if any requests are pending
 738                 final Map<String, Long> params = new HashMap<>();
 739                 params.put("appId", mockApp.getId());
 740                 params.put("userId", user.getId());
 741                 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
 742                                 params, null)).thenReturn(mockEpRequestIdValList);
 743                 mockEPUserAppRolesRequest.setUpdatedDate(new Date());
 744                 mockEPUserAppRolesRequest.setRequestStatus("O");
 745                 HashMap<String, Long> additionalUpdateParam = new HashMap<String, Long>();
 746                 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPUserAppRolesRequest, additionalUpdateParam);
 747                 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
 748                 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
 749                 mockEpUserAppRolesRequestDetail.setId(2l);
 750                 mockEpUserAppRolesRequestDetail.setReqType("P");
 751                 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
 752                 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
 753                 final Map<String, Long> epDetailParams = new HashMap<>();
 754                 epDetailParams.put("reqId", mockEPUserAppRolesRequest.getId());
 755
 756                 final Map<String, String> userParams = new HashMap<>();
 757                 userParams.put("orgUserIdValue", user.getOrgUserId());
 758                 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
 759                                 .thenReturn(mockEpUserList);
 760
 761                 PowerMockito
 762                                 .when(EPCommonSystemProperties
 763                                                 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
 764                                 .thenReturn(true);
 765                 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
 766                                 .thenReturn("@test.com");
 767                 HttpHeaders headers = new HttpHeaders();
 768                 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
 769                 EPRole mockEPRole = new EPRole();
 770                 mockEPRole.setActive(true);
 771                 mockEPRole.setAppId(2l);
 772                 mockEPRole.setAppRoleId(null);
 773                 mockEPRole.setId(10l);
 774                 mockEPRole.setAppRoleId(1l);
 775                 mockEPRole.setName("test1");
 776                 EPRole mockEPRole2 = new EPRole();
 777                 mockEPRole2.setActive(true);
 778                 mockEPRole2.setAppId(2l);
 779                 mockEPRole2.setAppRoleId(null);
 780                 mockEPRole2.setId(160l);
 781                 mockEPRole2.setName("test2");
 782                 mockEPRole2.setAppRoleId(16l);
 783                 EPRole mockEPRole3 = new EPRole();
 784                 mockEPRole3.setActive(true);
 785                 mockEPRole3.setAppId(2l);
 786                 mockEPRole3.setAppRoleId(null);
 787                 mockEPRole3.setId(1100l);
 788                 mockEPRole3.setAppRoleId(100l);
 789                 mockEPRole3.setName("test3");
 790                 Mockito.when(applicationsRestClientService.get(EPUser.class, mockApp.getId(),
 791                                 String.format("/user/%s", user.getOrgUserId()), true)).thenReturn(user);
 792                 // Updates in EP DB
 793                 Query epsetAppWithUserRoleNonCentralizedGetUserQuery = Mockito.mock(Query.class);
 794                 Query epsetAppWithUserRoleNonCentralizedGetUserAppsQuery = Mockito.mock(Query.class);
 795                 Query epsetAppWithUserRoleNonCentralizedGetRolesQuery = Mockito.mock(Query.class);
 796                 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
 797                 Mockito.when(session
 798                                 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
 799                                 .thenReturn(epsetAppWithUserRoleNonCentralizedGetUserQuery);
 800                 Mockito.doReturn(mockEpUserList).when(epsetAppWithUserRoleNonCentralizedGetUserQuery).list();
 801                 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
 802                 EPUserApp mockEpUserAppRoles = new EPUserApp();
 803                 mockEpUserAppRoles.setApp(mockApp);
 804                 mockEpUserAppRoles.setRole(mockEPRole);
 805                 mockEpUserAppRoles.setUserId(user.getId());
 806                 mockUserRolesList2.add(mockEpUserAppRoles);
 807                 Mockito.when(session.createQuery(
 808                                 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
 809                                 .thenReturn(epsetAppWithUserRoleNonCentralizedGetUserAppsQuery);
 810                 Mockito.doReturn(mockUserRolesList2).when(epsetAppWithUserRoleNonCentralizedGetUserAppsQuery).list();
 811                 List<EPRole> mockEPRoles = new ArrayList<>();
 812                 mockEPRoles.add(mockEPRole2);
 813                 mockEPRoles.add(mockEPRole3);
 814                 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=2"))
 815                                 .thenReturn(epsetAppWithUserRoleNonCentralizedGetRolesQuery);
 816                 Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleNonCentralizedGetRolesQuery).list();
 817                 ExternalRequestFieldsValidator expected = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
 818                 assertEquals(expected.isResult(), false);
 819         }
 820
 821         @SuppressWarnings("unchecked")
 822         @Test
 823         public void setExternalRequestUserAppRoleMerdianCentralizedAppTest() throws Exception {
 824                 PowerMockito.mockStatic(SystemProperties.class);
 825                 PowerMockito.mockStatic(EcompPortalUtils.class);
 826                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 827                 PowerMockito.mockStatic(PortalConstants.class);
 828                 EPUser user = mockUser.mockEPUser();
 829                 user.setId(2l);
 830                 List<EPUser> mockEpUserList = new ArrayList<>();
 831                 mockEpUserList.add(user);
 832                 EPApp mockApp = mockApp();
 833                 mockApp.setNameSpace("com.test.com");
 834                 mockApp.setId(1l);
 835                 mockApp.setRolesInAAF(true);
 836                 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
 837                 ExternalSystemUser externalSystemUser = new ExternalSystemUser();
 838                 List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
 839                 ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
 840                 mockExternalSystemRoleApproval.setRoleName("test1");
 841                 ExternalSystemRoleApproval mockExternalSystemRoleApproval2 = new ExternalSystemRoleApproval();
 842                 mockExternalSystemRoleApproval2.setRoleName("test2");
 843                 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval);
 844                 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval2);
 845                 externalSystemUser.setApplicationName(mockApp.getMlAppName());
 846                 externalSystemUser.setLoginId(user.getOrgUserId());
 847                 externalSystemUser.setRoles(mockExternalSystemRoleApprovalList);
 848                 EPRole mockEPRole = new EPRole();
 849                 mockEPRole.setActive(true);
 850                 mockEPRole.setAppId(null);
 851                 mockEPRole.setAppRoleId(null);
 852                 mockEPRole.setId(1l);
 853                 mockEPRole.setName("test1");
 854                 EPRole mockEPRole2 = new EPRole();
 855                 mockEPRole2.setActive(true);
 856                 mockEPRole2.setAppId(null);
 857                 mockEPRole2.setAppRoleId(null);
 858                 mockEPRole2.setId(16l);
 859                 mockEPRole2.setName("test2");
 860                 EPRole mockEPRole3 = new EPRole();
 861                 mockEPRole3.setActive(true);
 862                 mockEPRole3.setAppId(null);
 863                 mockEPRole3.setAppRoleId(null);
 864                 mockEPRole3.setId(1000l);
 865                 mockEPRole3.setName("test3");
 866
 867                 Mockito.when(epAppCommonServiceImpl.getAppDetail(mockApp.getMlAppName())).thenReturn(mockApp);
 868                 final Map<String, String> userParams = new HashMap<>();
 869                 userParams.put("orgUserIdValue", user.getOrgUserId());
 870                 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
 871                                 .thenReturn(mockEpUserList);
 872
 873                 List<EPUserAppRolesRequest> mockMerdianEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
 874                 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
 875                 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
 876                 mockEpUserAppRolesRequestDetail.setId(2l);
 877                 mockEpUserAppRolesRequestDetail.setReqType("P");
 878                 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
 879                 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
 880                 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
 881                 mockEPUserAppRolesRequest.setId(1l);
 882                 mockEPUserAppRolesRequest.setRequestStatus("P");
 883                 mockEPUserAppRolesRequest.setUserId(user.getId());
 884                 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
 885                 mockMerdianEpRequestIdValList.add(mockEPUserAppRolesRequest);
 886                 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
 887                 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
 888
 889                 final Map<String, Long> params = new HashMap<>();
 890                 params.put("appId", mockApp.getId());
 891                 params.put("userId", user.getId());
 892                 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
 893                                 params, null)).thenReturn(mockMerdianEpRequestIdValList);
 894                 RoleInAppForUser mockRoleInAppForUser1 = new RoleInAppForUser();
 895                 mockRoleInAppForUser1.setIsApplied(true);
 896                 mockRoleInAppForUser1.setRoleId(1l);
 897                 mockRoleInAppForUser1.setRoleName("test1");
 898                 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
 899                 mockRoleInAppForUser2.setIsApplied(true);
 900                 mockRoleInAppForUser2.setRoleId(16l);
 901                 mockRoleInAppForUser2.setRoleName("test2");
 902                 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval.getRoleName(), mockApp.getId()))
 903                                 .thenReturn(mockEPRole);
 904                 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval2.getRoleName(), mockApp.getId()))
 905                                 .thenReturn(mockEPRole2);
 906                 List<EcompUserAppRoles> mockEPuserAppList = getCurrentUserRoles(user, mockApp);
 907                 final Map<String, Long> params2 = new HashMap<>();
 908                 params2.put("userId", user.getId());
 909                 params2.put("appId", mockApp.getId());
 910                 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
 911                                 .thenReturn(mockEPuserAppList);
 912                 // Updates in External Auth System
 913                 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
 914                 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
 915                 mockEpUserAppRolesRequestDetail.setId(2l);
 916                 mockEpUserAppRolesRequestDetail.setReqType("P");
 917                 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
 918                 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
 919                 final Map<String, String> userParams2 = new HashMap<>();
 920                 userParams2.put("orgUserIdValue", user.getOrgUserId());
 921                 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams2, null))
 922                                 .thenReturn(mockEpUserList);
 923                 PowerMockito
 924                                 .when(EPCommonSystemProperties
 925                                                 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
 926                                 .thenReturn(true);
 927                 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
 928                                 .thenReturn("@test.com");
 929                 HttpHeaders headers = new HttpHeaders();
 930                 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
 931                 JSONObject mockJsonObject1 = new JSONObject();
 932                 JSONObject mockJsonObject2 = new JSONObject();
 933                 JSONObject mockJsonObject3 = new JSONObject();
 934                 mockJsonObject1.put("name", "com.test.com.test1");
 935                 mockJsonObject2.put("name", "com.test.com.test2");
 936                 List<JSONObject> mockJson = new ArrayList<>();
 937                 mockJson.add(mockJsonObject1);
 938                 mockJson.add(mockJsonObject2);
 939                 mockJsonObject3.put("role", mockJson);
 940                 ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
 941                 Mockito.when(externalAccessRolesServiceImpl.getUserRolesFromExtAuthSystem(Matchers.anyString(), Matchers.any(HttpEntity.class))).thenReturn(getResponse);
 942                 Map<String, EPRole> mockEPRoleList = new HashMap<>();
 943                 mockEPRoleList.put("test1", mockEPRole);
 944                 mockEPRoleList.put("test2", mockEPRole2);
 945                 mockEPRoleList.put("test3", mockEPRole3);
 946                 Mockito.when(externalAccessRolesServiceImpl.getAppRoleNamesWithUnderscoreMap(mockApp)).thenReturn(mockEPRoleList);
 947                 ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
 948                 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
 949                                 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
 950
 951                 ResponseEntity<String> deleteResponse = new ResponseEntity<>(HttpStatus.OK);
 952                 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE),
 953                                 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(deleteResponse);
 954                 // Updated in EP DB
 955                 Query epsetExternalRequestUserAppRoleGetUserQuery = Mockito.mock(Query.class);
 956                 Query epsetExternalRequestUserAppRoleGetUserAppsQuery = Mockito.mock(Query.class);
 957                 Query epsetExternalRequestUserAppRoleGetRolesQuery = Mockito.mock(Query.class);
 958                 SQLQuery epsetAppWithUserRoleUpdateEPRoleQuery = Mockito.mock(SQLQuery.class);
 959                 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
 960                 Mockito.when(session
 961                                 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
 962                                 .thenReturn(epsetExternalRequestUserAppRoleGetUserQuery);
 963                 Mockito.doReturn(mockEpUserList).when(epsetExternalRequestUserAppRoleGetUserQuery).list();
 964                 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
 965                 EPUserApp mockEpUserAppRoles = new EPUserApp();
 966                 mockEpUserAppRoles.setApp(mockApp);
 967                 mockEpUserAppRoles.setRole(mockEPRole);
 968                 mockEpUserAppRoles.setUserId(user.getId());
 969                 mockUserRolesList2.add(mockEpUserAppRoles);
 970                 Mockito.when(session.createQuery(
 971                                 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=1 and role.active = 'Y' and userId=2"))
 972                                 .thenReturn(epsetExternalRequestUserAppRoleGetUserAppsQuery);
 973                 Mockito.doReturn(mockUserRolesList2).when(epsetExternalRequestUserAppRoleGetUserAppsQuery).list();
 974                 List<EPRole> mockEPRoles = new ArrayList<>();
 975                 mockEPRoles.add(mockEPRole2);
 976                 mockEPRoles.add(mockEPRole3);
 977                 Mockito.when(session.createQuery("from org.onap.portalapp.portal.domain.EPRole where appId is null "))
 978                                 .thenReturn(epsetExternalRequestUserAppRoleGetRolesQuery);
 979                 Mockito.doReturn(mockEPRoles).when(epsetExternalRequestUserAppRoleGetRolesQuery).list();
 980                 Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
 981                                 .thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
 982
 983                 ExternalRequestFieldsValidator mockExternalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
 984                                 "Updated Successfully");
 985                 ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
 986                                 .setExternalRequestUserAppRole(externalSystemUser, "POST");
 987                 assertTrue(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
 988         }
 989
 990         @SuppressWarnings("unchecked")
 991         @Test
 992         public void setExternalRequestUserAppRoleMerdianNonCentralizedAppTest() throws Exception {
 993                 PowerMockito.mockStatic(SystemProperties.class);
 994                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 995                 PowerMockito.mockStatic(PortalConstants.class);
 996                 EPUser user = mockUser.mockEPUser();
 997                 user.setId(2l);
 998                 List<EPUser> mockEpUserList = new ArrayList<>();
 999                 mockEpUserList.add(user);
1000                 EPApp mockApp = mockApp();
1001                 mockApp.setId(2l);
1002                 mockApp.setEnabled(true);
1003                 mockApp.setRolesInAAF(false);
1004                 ExternalSystemUser externalSystemUser = new ExternalSystemUser();
1005                 List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
1006                 ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
1007                 mockExternalSystemRoleApproval.setRoleName("test1");
1008                 ExternalSystemRoleApproval mockExternalSystemRoleApproval2 = new ExternalSystemRoleApproval();
1009                 mockExternalSystemRoleApproval2.setRoleName("test2");
1010                 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval);
1011                 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval2);
1012                 externalSystemUser.setApplicationName(mockApp.getMlAppName());
1013                 externalSystemUser.setLoginId(user.getOrgUserId());
1014                 externalSystemUser.setRoles(mockExternalSystemRoleApprovalList);
1015
1016                 EPRole mockEPRole = new EPRole();
1017                 mockEPRole.setActive(true);
1018                 mockEPRole.setAppId(2l);
1019                 mockEPRole.setAppRoleId(1l);
1020                 mockEPRole.setId(1000l);
1021                 mockEPRole.setName("test1");
1022                 EPRole mockEPRole2 = new EPRole();
1023                 mockEPRole2.setActive(true);
1024                 mockEPRole2.setAppId(2l);
1025                 mockEPRole2.setAppRoleId(16l);
1026                 mockEPRole2.setId(160l);
1027                 mockEPRole2.setName("test2");
1028                 EPRole mockEPRole3 = new EPRole();
1029                 mockEPRole3.setActive(true);
1030                 mockEPRole3.setAppId(2l);
1031                 mockEPRole3.setAppRoleId(10l);
1032                 mockEPRole3.setId(100l);
1033                 mockEPRole3.setName("test3");
1034
1035                 Mockito.when(epAppCommonServiceImpl.getAppDetail(mockApp.getMlAppName())).thenReturn(mockApp);
1036                 final Map<String, String> userParams = new HashMap<>();
1037                 userParams.put("orgUserIdValue", user.getOrgUserId());
1038                 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
1039                                 .thenReturn(mockEpUserList);
1040
1041                 List<EPUserAppRolesRequest> mockMerdianEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
1042                 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
1043                 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
1044                 mockEpUserAppRolesRequestDetail.setId(2l);
1045                 mockEpUserAppRolesRequestDetail.setReqType("P");
1046                 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
1047                 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
1048                 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
1049                 mockEPUserAppRolesRequest.setId(1l);
1050                 mockEPUserAppRolesRequest.setRequestStatus("P");
1051                 mockEPUserAppRolesRequest.setUserId(user.getId());
1052                 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
1053                 mockMerdianEpRequestIdValList.add(mockEPUserAppRolesRequest);
1054                 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
1055                 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
1056
1057                 final Map<String, Long> params = new HashMap<>();
1058                 params.put("appId", mockApp.getId());
1059                 params.put("userId", user.getId());
1060                 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
1061                                 params, null)).thenReturn(mockMerdianEpRequestIdValList);
1062                 RoleInAppForUser mockRoleInAppForUser1 = new RoleInAppForUser();
1063                 mockRoleInAppForUser1.setIsApplied(true);
1064                 mockRoleInAppForUser1.setRoleId(1l);
1065                 mockRoleInAppForUser1.setRoleName("test1");
1066                 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
1067                 mockRoleInAppForUser2.setIsApplied(true);
1068                 mockRoleInAppForUser2.setRoleId(16l);
1069                 mockRoleInAppForUser2.setRoleName("test2");
1070                 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval.getRoleName(), mockApp.getId()))
1071                                 .thenReturn(mockEPRole);
1072                 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval2.getRoleName(), mockApp.getId()))
1073                                 .thenReturn(mockEPRole2);
1074                 List<EcompUserAppRoles> mockEPuserAppList = new ArrayList<>();
1075                 EcompUserAppRoles mockEcompUserAppRoles = new EcompUserAppRoles();
1076                 mockEcompUserAppRoles.setAppId(String.valueOf(mockApp.getId()));
1077                 mockEcompUserAppRoles.setRoleId(100l);
1078                 mockEcompUserAppRoles.setRoleName("test1");
1079                 mockEcompUserAppRoles.setUserId(user.getId());
1080                 mockEPuserAppList.add(mockEcompUserAppRoles);
1081                 final Map<String, Long> params2 = new HashMap<>();
1082                 params2.put("userId", user.getId());
1083                 params2.put("appId", mockApp.getId());
1084                 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
1085                                 .thenReturn(mockEPuserAppList);
1086                 List<EcompRole> mockEcompRoleList = new ArrayList<>();
1087                 EcompRole mockEcompRole = new EcompRole();
1088                 mockEcompRole.setId(1l);
1089                 mockEcompRole.setName("test1");
1090                 EcompRole mockEcompRole2 = new EcompRole();
1091                 mockEcompRole2.setId(16l);
1092                 mockEcompRole2.setName("test2");
1093                 mockEcompRoleList.add(mockEcompRole);
1094                 mockEcompRoleList.add(mockEcompRole2);
1095                 EcompRole[] mockEcompRoleArray = mockEcompRoleList.toArray(new EcompRole[mockEcompRoleList.size()]);
1096                 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
1097                                 .thenReturn(mockEcompRoleArray);
1098
1099                 // SyncAppRoles
1100                 List<EPUserApp> mockUserRolesList = new ArrayList<>();
1101                 EPUserApp mockEpUserApp = new EPUserApp();
1102                 mockEpUserApp.setApp(mockApp);
1103                 mockEpUserApp.setRole(mockEPRole2);
1104                 mockEpUserApp.setUserId(user.getId());
1105                 mockUserRolesList.add(mockEpUserApp);
1106                 List<FunctionalMenuRole> mockFunctionalMenuRolesList = new ArrayList<>();
1107                 FunctionalMenuRole mockFunctionalMenuRole = new FunctionalMenuRole();
1108                 mockFunctionalMenuRole.setAppId((int) (long) mockApp.getId());
1109                 mockFunctionalMenuRole.setRoleId((int) (long) 15l);
1110                 mockFunctionalMenuRole.setMenuId(10l);
1111                 mockFunctionalMenuRole.setId(10);
1112                 mockFunctionalMenuRolesList.add(mockFunctionalMenuRole);
1113                 List<FunctionalMenuItem> mockFunctionalMenuItemList = new ArrayList<>();
1114                 FunctionalMenuItem mockFunctionalMenuItem = new FunctionalMenuItem();
1115                 List<Integer> mockRolesList = new ArrayList<>();
1116                 Integer role1 = 1;
1117                 mockRolesList.add(role1);
1118                 mockFunctionalMenuItem.setRestrictedApp(false);
1119                 mockFunctionalMenuItem.setRoles(mockRolesList);
1120                 mockFunctionalMenuItem.setUrl("http://test.com");
1121                 mockFunctionalMenuItemList.add(mockFunctionalMenuItem);
1122                 Query epRoleQuery = Mockito.mock(Query.class);
1123                 Query epUserAppsQuery = Mockito.mock(Query.class);
1124                 Query epFunctionalMenuQuery = Mockito.mock(Query.class);
1125                 Query epFunctionalMenuQuery2 = Mockito.mock(Query.class);
1126                 Query epFunctionalMenuItemQuery = Mockito.mock(Query.class);
1127                 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
1128                                 .thenReturn(mockEcompRoleArray);
1129                 // syncAppRolesTest
1130                 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=" + mockApp.getId()))
1131                                 .thenReturn(epRoleQuery);
1132                 Mockito.doReturn(mockEcompRoleList).when(epRoleQuery).list();
1133                 Mockito.when(session.createQuery(
1134                                 "from " + EPUserApp.class.getName() + " where app.id=" + mockApp.getId() + " and role_id=" + 100l))
1135                                 .thenReturn(epUserAppsQuery);
1136                 Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
1137
1138                 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where roleId=" + 100l))
1139                                 .thenReturn(epFunctionalMenuQuery);
1140                 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
1141
1142                 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where menuId=" + 10l))
1143                                 .thenReturn(epFunctionalMenuQuery2);
1144                 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
1145
1146                 Mockito.when(session.createQuery("from " + FunctionalMenuItem.class.getName() + " where menuId=" + 10l))
1147                                 .thenReturn(epFunctionalMenuItemQuery);
1148                 Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
1149
1150                 Mockito.when(applicationsRestClientService.get(EPUser.class, mockApp.getId(),
1151                                 String.format("/user/%s", user.getOrgUserId()), true)).thenReturn(user);
1152                 // Updated in EP DB
1153                 Query epsetExternalRequestUserAppRoleGetUserQuery = Mockito.mock(Query.class);
1154                 Query epsetExternalRequestUserAppRoleGetUserAppsQuery = Mockito.mock(Query.class);
1155                 Query epsetExternalRequestUserAppRoleGetRolesQuery = Mockito.mock(Query.class);
1156                 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
1157                 Mockito.when(session
1158                                 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
1159                                 .thenReturn(epsetExternalRequestUserAppRoleGetUserQuery);
1160                 Mockito.doReturn(mockEpUserList).when(epsetExternalRequestUserAppRoleGetUserQuery).list();
1161                 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
1162                 EPUserApp mockEpUserAppRoles = new EPUserApp();
1163                 mockEpUserAppRoles.setApp(mockApp);
1164                 mockEpUserAppRoles.setRole(mockEPRole);
1165                 mockEpUserAppRoles.setUserId(user.getId());
1166                 mockUserRolesList2.add(mockEpUserAppRoles);
1167                 Mockito.when(session.createQuery(
1168                                 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
1169                                 .thenReturn(epsetExternalRequestUserAppRoleGetUserAppsQuery);
1170                 Mockito.doReturn(mockUserRolesList2).when(epsetExternalRequestUserAppRoleGetUserAppsQuery).list();
1171                 List<EPRole> mockEPRoles = new ArrayList<>();
1172                 mockEPRoles.add(mockEPRole2);
1173                 mockEPRoles.add(mockEPRole3);
1174                 Mockito.when(session.createQuery("from org.onap.portalapp.portal.domain.EPRole where appId=2"))
1175                                 .thenReturn(epsetExternalRequestUserAppRoleGetRolesQuery);
1176                 Mockito.doReturn(mockEPRoles).when(epsetExternalRequestUserAppRoleGetRolesQuery).list();
1177
1178                 ExternalRequestFieldsValidator mockExternalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1179                                 "Updated Successfully");
1180                 ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
1181                                 .setExternalRequestUserAppRole(externalSystemUser, "POST");
1182                 assertFalse(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
1183         }
1184
1185         @SuppressWarnings("unchecked")
1186         @Test
1187         public void getUsersFromAppEndpointCentralizedAppTest() throws HTTPException {
1188                 EPApp mockApp = mockApp();
1189                 mockApp.setId(1l);
1190                 mockApp.setEnabled(true);
1191                 mockApp.setRolesInAAF(true);
1192                 EPUser user = mockUser.mockEPUser();
1193                 EPUser user2 = mockUser.mockEPUser();
1194                 user2.setActive(true);
1195                 user2.setOrgUserId("guestT2");
1196                 user2.setId(2l);
1197                 user2.setFirstName("Guest2");
1198                 user2.setLastName("Test2");
1199                 user.setId(1l);
1200                 user.setFirstName("Guest");
1201                 user.setLastName("Test");
1202                 EPRole mockEPRole1 = new EPRole();
1203                 mockEPRole1.setId(1l);
1204                 mockEPRole1.setName("test1");
1205                 mockEPRole1.setActive(true);
1206                 EPRole mockEPRole2 = new EPRole();
1207                 mockEPRole2.setId(16l);
1208                 mockEPRole2.setName("test2");
1209                 mockEPRole2.setActive(true);
1210                 SortedSet<EPUserApp> mockUserApps1 = new TreeSet<EPUserApp>();
1211                 EPUserApp mockEPUserApp1 = new EPUserApp();
1212                 mockEPUserApp1.setApp(mockApp);
1213                 mockEPUserApp1.setRole(mockEPRole1);
1214                 mockEPUserApp1.setUserId(1l);
1215                 mockUserApps1.add(mockEPUserApp1);
1216                 user.setEPUserApps(mockUserApps1);
1217                 SortedSet<EPUserApp> mockUserApps2 = new TreeSet<EPUserApp>();
1218                 EPUserApp mockEPUserApp2 = new EPUserApp();
1219                 mockEPUserApp2.setApp(mockApp);
1220                 mockEPUserApp2.setRole(mockEPRole2);
1221                 mockEPUserApp2.setUserId(2l);
1222                 mockUserApps2.add(mockEPUserApp2);
1223                 user2.setEPUserApps(mockUserApps2);
1224                 List<EPUser> mockEpUserList = new ArrayList<>();
1225                 mockEpUserList.add(user);
1226                 mockEpUserList.add(user2);
1227                 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
1228                 List<UserApplicationRoles> mockUserApplicationRolesList = new ArrayList<>();
1229                 UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
1230                 List<RemoteRole> mockRemoteRoleList = new ArrayList<>();
1231                 RemoteRole mockRemoteRole = new RemoteRole();
1232                 mockRemoteRole.setId(1l);
1233                 mockRemoteRole.setName("test1");
1234                 mockRemoteRoleList.add(mockRemoteRole);
1235                 mockUserApplicationRoles.setAppId(mockApp.getId());
1236                 mockUserApplicationRoles.setFirstName("Guest");
1237                 mockUserApplicationRoles.setLastName("Test");
1238                 mockUserApplicationRoles.setOrgUserId("guestT");
1239                 mockUserApplicationRoles.setRoles(mockRemoteRoleList);
1240                 UserApplicationRoles mockUserApplicationRoles2 = new UserApplicationRoles();
1241                 List<RemoteRole> mockRemoteRoleList2 = new ArrayList<>();
1242                 RemoteRole mockRemoteRole2 = new RemoteRole();
1243                 mockRemoteRole2.setId(16l);
1244                 mockRemoteRole2.setName("test2");
1245                 mockRemoteRoleList2.add(mockRemoteRole2);
1246                 mockUserApplicationRoles2.setAppId(mockApp.getId());
1247                 mockUserApplicationRoles2.setFirstName("Guest2");
1248                 mockUserApplicationRoles2.setLastName("Test2");
1249                 mockUserApplicationRoles2.setOrgUserId("guestT2");
1250                 mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
1251                 mockUserApplicationRolesList.add(mockUserApplicationRoles);
1252                 mockUserApplicationRolesList.add(mockUserApplicationRoles2);
1253                 Map<String, Object> params = new HashMap<>();
1254                 params.put("id", 1l);
1255                 params.put("active", true);
1256                 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("getActiveUsersForApp", params, null))
1257                                 .thenReturn(mockEpUserList);
1258                 assertEquals(userRolesCommonServiceImpl.getUsersFromAppEndpoint(1l).size(),
1259                                 mockUserApplicationRolesList.size());
1260         }
1261
1262         @Test
1263         public void getUsersFromAppEndpointNonCentralizedAppTest() throws HTTPException, JsonProcessingException {
1264                 EPApp mockApp = mockApp();
1265                 mockApp.setId(2l);
1266                 mockApp.setEnabled(true);
1267                 mockApp.setRolesInAAF(false);
1268                 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
1269                 List<UserApplicationRoles> mockUserApplicationRolesNonCentralizedList = new ArrayList<>();
1270                 UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
1271                 List<RemoteRole> mockRemoteRoleList = new ArrayList<>();
1272                 RemoteRole mockRemoteRole = new RemoteRole();
1273                 mockRemoteRole.setId(1l);
1274                 mockRemoteRole.setName("test1");
1275                 mockRemoteRoleList.add(mockRemoteRole);
1276                 mockUserApplicationRoles.setAppId(mockApp.getId());
1277                 mockUserApplicationRoles.setFirstName("Guest");
1278                 mockUserApplicationRoles.setLastName("Test");
1279                 mockUserApplicationRoles.setOrgUserId("guestT");
1280                 mockUserApplicationRoles.setRoles(mockRemoteRoleList);
1281                 UserApplicationRoles mockUserApplicationRoles2 = new UserApplicationRoles();
1282                 List<RemoteRole> mockRemoteRoleList2 = new ArrayList<>();
1283                 RemoteRole mockRemoteRole2 = new RemoteRole();
1284                 mockRemoteRole2.setId(16l);
1285                 mockRemoteRole2.setName("test2");
1286                 mockRemoteRoleList2.add(mockRemoteRole2);
1287                 mockUserApplicationRoles2.setAppId(mockApp.getId());
1288                 mockUserApplicationRoles2.setFirstName("Guest2");
1289                 mockUserApplicationRoles2.setLastName("Test2");
1290                 mockUserApplicationRoles2.setOrgUserId("guestT2");
1291                 mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
1292                 mockUserApplicationRolesNonCentralizedList.add(mockUserApplicationRoles);
1293                 mockUserApplicationRolesNonCentralizedList.add(mockUserApplicationRoles2);
1294                 RemoteUserWithRoles mockRemoteUserWithRoles1 = new RemoteUserWithRoles();
1295                 mockRemoteUserWithRoles1.setFirstName("Guest1");
1296                 mockRemoteUserWithRoles1.setLastName("Test1");
1297                 mockRemoteUserWithRoles1.setOrgUserId("guestT");
1298                 mockRemoteUserWithRoles1.setRoles(mockRemoteRoleList);
1299                 RemoteUserWithRoles mockRemoteUserWithRoles2 = new RemoteUserWithRoles();
1300                 mockRemoteUserWithRoles2.setFirstName("Guest2");
1301                 mockRemoteUserWithRoles2.setLastName("Test2");
1302                 mockRemoteUserWithRoles2.setOrgUserId("guestT");
1303                 mockRemoteUserWithRoles2.setRoles(mockRemoteRoleList2);
1304                 List<RemoteUserWithRoles> mockRemoteUserWithRolesList = new ArrayList<>();
1305                 mockRemoteUserWithRolesList.add(mockRemoteUserWithRoles1);
1306                 mockRemoteUserWithRolesList.add(mockRemoteUserWithRoles2);
1307                 ObjectMapper mapper = new ObjectMapper();
1308                 String mockGetRemoteUsersWithRoles = mapper.writeValueAsString(mockRemoteUserWithRolesList);
1309                 Mockito.when(applicationsRestClientService.getIncomingJsonString(mockApp.getId(), "/users"))
1310                                 .thenReturn(mockGetRemoteUsersWithRoles);
1311                 List<UserApplicationRoles> userApplicationRolesNonCentralizedList = userRolesCommonServiceImpl
1312                                 .getUsersFromAppEndpoint(2l);
1313                 assertEquals(mockUserApplicationRolesNonCentralizedList.size(), userApplicationRolesNonCentralizedList.size());
1314         }
1315
1316         @SuppressWarnings("unchecked")
1317         @Test
1318         public void putUserAppRolesRequestTest() {
1319                 EPApp mockApp = mockApp();
1320                 mockApp.setId(2l);
1321                 mockApp.setEnabled(true);
1322                 mockApp.setRolesInAAF(false);
1323                 EPUser user = mockUser.mockEPUser();
1324                 AppWithRolesForUser appWithRolesForUser = new AppWithRolesForUser();
1325                 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
1326                 RoleInAppForUser roleInAppForUser = new RoleInAppForUser();
1327                 roleInAppForUser.setIsApplied(true);
1328                 roleInAppForUser.setRoleId(1l);
1329                 roleInAppForUser.setRoleName("test1");
1330                 RoleInAppForUser roleInAppForUser2 = new RoleInAppForUser();
1331                 roleInAppForUser2.setIsApplied(true);
1332                 roleInAppForUser2.setRoleId(1000l);
1333                 roleInAppForUser2.setRoleName("test3");
1334                 mockRoleInAppForUserList.add(roleInAppForUser);
1335                 mockRoleInAppForUserList.add(roleInAppForUser2);
1336                 appWithRolesForUser.setAppId(mockApp.getId());
1337                 appWithRolesForUser.setAppName(mockApp.getName());
1338                 appWithRolesForUser.setOrgUserId(user.getOrgUserId());
1339                 appWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
1340                 List<EPUserAppRoles> epUserAppRolesList = new ArrayList<>();
1341                 EPUserAppRoles appRole1 = new EPUserAppRoles();
1342                 appRole1.setAppId(mockApp.getId());
1343                 appRole1.setId(10l);
1344                 appRole1.setRoleId(roleInAppForUser.roleId);
1345                 epUserAppRolesList.add(appRole1);
1346                 List<EPUserAppRoles> epUserAppRolesList2 = new ArrayList<>();
1347                 EPUserAppRoles appRole2 = new EPUserAppRoles();
1348                 appRole2.setAppId(mockApp.getId());
1349                 appRole2.setId(11l);
1350                 appRole2.setRoleId(roleInAppForUser2.roleId);
1351                 epUserAppRolesList2.add(appRole2);
1352                 EPUserAppRolesRequest mockEpAppRolesRequestData = new EPUserAppRolesRequest();
1353                 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEpAppRolesRequestData, null);
1354                 final Map<String, Long> params = new HashMap<>();
1355                 params.put("appId", appWithRolesForUser.getAppId());
1356                 params.put("appRoleId", roleInAppForUser.roleId);
1357                 Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
1358                                 .thenReturn(epUserAppRolesList);
1359                 params.put("appRoleId", roleInAppForUser2.roleId);
1360                 Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
1361                                 .thenReturn(epUserAppRolesList2);
1362                 EPUserAppRolesRequestDetail mockEPAppRoleDetail = new EPUserAppRolesRequestDetail();
1363                 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPAppRoleDetail, null);
1364                 FieldsValidator expected = new FieldsValidator();
1365                 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
1366                 FieldsValidator actual = userRolesCommonServiceImpl.putUserAppRolesRequest(appWithRolesForUser, user);
1367                 assertEquals(expected, actual);
1368         }
1369
1370         @Test
1371         public void importRolesFromRemoteApplicationTest() throws HTTPException {
1372                 EPApp mockApp = mockApp();
1373                 mockApp.setId(2l);
1374                 mockApp.setEnabled(true);
1375                 mockApp.setRolesInAAF(false);
1376                 List<EPRole> expected = new ArrayList<>();
1377                 EPRole epRole = new EPRole();
1378                 epRole.setAppId(mockApp.getId());
1379                 epRole.setActive(true);
1380                 epRole.setId(10l);
1381                 epRole.setName("test1");
1382                 EPRole epRole2 = new EPRole();
1383                 epRole2.setAppId(mockApp.getId());
1384                 epRole2.setActive(true);
1385                 epRole2.setId(11l);
1386                 epRole2.setName("test2");
1387                 expected.add(epRole);
1388                 expected.add(epRole2);
1389                 EPRole[] epRoleArray = expected.toArray(new EPRole[expected.size()]);
1390                 Mockito.when(applicationsRestClientService.get(EPRole[].class, mockApp.getId(), "/rolesFull"))
1391                                 .thenReturn(epRoleArray);
1392                 Mockito.when(epRoleServiceImpl.getRole(mockApp.getId(), epRole.getId())).thenReturn(epRole);
1393                 Mockito.when(epRoleServiceImpl.getRole(mockApp.getId(), epRole2.getId())).thenReturn(epRole2);
1394                 List<EPRole> actual = userRolesCommonServiceImpl.importRolesFromRemoteApplication(mockApp.getId());
1395                 assertEquals(expected.size(), actual.size());
1396         }
1397
1398         @SuppressWarnings("deprecation")
1399         @Test
1400         public void getCachedAppRolesForUserTest() {
1401                 EPApp mockApp = mockApp();
1402                 mockApp.setId(2l);
1403                 mockApp.setEnabled(true);
1404                 mockApp.setRolesInAAF(false);
1405                 EPUser user = mockUser.mockEPUser();
1406                 List<EPUserApp> expected = new ArrayList<>();
1407                 EPUserApp epUserApp = new EPUserApp();
1408                 EPRole epRole = new EPRole();
1409                 epRole.setAppId(mockApp.getId());
1410                 epRole.setActive(true);
1411                 epRole.setId(10l);
1412                 epRole.setName("test1");
1413                 epUserApp.setApp(mockApp);
1414                 epUserApp.setRole(epRole);
1415                 epUserApp.setUserId(user.getId());
1416                 expected.add(epUserApp);
1417                 String filter = " where user_id = " + Long.toString(user.getId()) + " and app_id = "
1418                                 + Long.toString(mockApp.getId());
1419                 Mockito.when(dataAccessService.getList(EPUserApp.class, filter, null, null)).thenReturn(expected);
1420                 List<EPUserApp> actual = userRolesCommonServiceImpl.getCachedAppRolesForUser(mockApp.getId(), user.getId());
1421                 assertEquals(expected.size(), actual.size());
1422         }
1423
1424         @SuppressWarnings("unchecked")
1425         @Test
1426         public void getUserAppCatalogRolesTest() {
1427                 EPApp mockApp = mockApp();
1428                 mockApp.setId(2l);
1429                 mockApp.setEnabled(true);
1430                 mockApp.setRolesInAAF(false);
1431                 EPUser user = mockUser.mockEPUser();
1432                 List<EPUserAppCatalogRoles> expected = new ArrayList<>();
1433                 EPUserAppCatalogRoles epUserAppCatalogRoles = new EPUserAppCatalogRoles();
1434                 epUserAppCatalogRoles.setAppId(mockApp.getId());
1435                 epUserAppCatalogRoles.setId(2l);
1436                 epUserAppCatalogRoles.setRequestedRoleId(10l);
1437                 epUserAppCatalogRoles.setRequestStatus("S");
1438                 epUserAppCatalogRoles.setRolename("test1");
1439                 expected.add(epUserAppCatalogRoles);
1440                 Map<String, String> params = new HashMap<>();
1441                 params.put("userid", user.getId().toString());
1442                 params.put("appName", mockApp.getName());
1443                 Mockito.when(
1444                                 (List<EPUserAppCatalogRoles>) dataAccessService.executeNamedQuery("userAppCatalogRoles", params, null))
1445                                 .thenReturn(expected);
1446                 List<EPUserAppCatalogRoles> actual = userRolesCommonServiceImpl.getUserAppCatalogRoles(user, mockApp.getName());
1447                 assertEquals(expected.size(), actual.size());
1448         }
1449
1450         @Test
1451         public void getExternalRequestAccessTest() {
1452                 ExternalSystemAccess expected = new ExternalSystemAccess("external_access_enable", false);
1453                 ExternalSystemAccess actual = userRolesCommonServiceImpl.getExternalRequestAccess();
1454                 assertEquals(expected, actual);
1455         }
1456
1457         @Test
1458         public void getEPUserAppListTest() {
1459                 EPApp mockApp = mockApp();
1460                 mockApp.setId(2l);
1461                 mockApp.setEnabled(true);
1462                 mockApp.setRolesInAAF(false);
1463                 EPUser user = mockUser.mockEPUser();
1464                 List<EPUserApp> expected = new ArrayList<>();
1465                 EPUserApp epUserApp = new EPUserApp();
1466                 EPRole epRole = new EPRole();
1467                 epRole.setAppId(mockApp.getId());
1468                 epRole.setActive(true);
1469                 epRole.setId(10l);
1470                 epRole.setName("test1");
1471                 epUserApp.setApp(mockApp);
1472                 epUserApp.setRole(epRole);
1473                 epUserApp.setUserId(user.getId());
1474                 expected.add(epUserApp);
1475                 final Map<String, Long> params = new HashMap<>();
1476                 params.put("appId", mockApp.getId());
1477                 params.put("userId", user.getId());
1478                 params.put("roleId", epRole.getId());
1479                 Mockito.when(dataAccessService.executeNamedQuery("getUserRoleOnUserIdAndRoleIdAndAppId", params, null))
1480                                 .thenReturn(expected);
1481                 List<EPUserApp> actual = userRolesCommonServiceImpl.getEPUserAppList(mockApp.getId(), user.getId(),
1482                                 epRole.getId());
1483                 assertEquals(expected.size(), actual.size());
1484         }
1485
1486         @Test
1487         public void updateRemoteUserProfileTest() {
1488                 EPApp mockApp = mockApp();
1489                 EPApp mockApp2 = mockApp();
1490                 mockApp.setId(2l);
1491                 mockApp.setEnabled(true);
1492                 mockApp.setRolesInAAF(false);
1493                 EPUser user = mockUser.mockEPUser();
1494                 List<EPApp> mockEpAppList = new ArrayList<>();
1495                 mockEpAppList.add(mockApp);
1496                 mockEpAppList.add(mockApp2);
1497                 Mockito.when(searchServiceImpl.searchUserByUserId(user.getOrgUserId())).thenReturn(user);
1498                 Mockito.when(epAppCommonServiceImpl.getUserRemoteApps(user.getId().toString())).thenReturn(mockEpAppList);
1499                 String expected = "success";
1500                 String actual = userRolesCommonServiceImpl.updateRemoteUserProfile(user.getOrgUserId(), mockApp.getId());
1501                 assertEquals(expected, actual);
1502         }
1503 }