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

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