gerrit.onap Code Review - portal.git/blob

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