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