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