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