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