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