2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (C) 2017 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 getAppRolesForUserNonCentralizedForPortal() throws Exception {
243 EPUser user = mockUser.mockEPUser();
245 EPApp mockApp = mockApp();
246 mockApp.setCentralAuth(false);
247 EPRole mockEPRole = new EPRole();
248 mockEPRole.setId(1l);
249 mockEPRole.setName("test1");
250 mockEPRole.setActive(true);
251 SortedSet<EPUserApp> mockUserApps = new TreeSet<EPUserApp>();
252 EPUserApp mockEPUserApp = new EPUserApp();
253 mockEPUserApp.setApp(mockApp);
254 mockEPUserApp.setRole(mockEPRole);
255 mockEPUserApp.setUserId(1l);
256 mockUserApps.add(mockEPUserApp);
257 user.setEPUserApps(mockUserApps);
258 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
259 List<RoleInAppForUser> mockRoleInAppForUserListNonCentralizedList = getMockedRoleInAppUserList();
260 List<Role> mockRole = new ArrayList<>();
261 Role role = new Role();
263 role.setName("test1");
264 role.setActive(true);
265 Role role2 = new Role();
267 role.setName("test2");
268 role.setActive(true);
271 Mockito.when(roleServiceImpl.getAvailableRoles(user.getOrgUserId())).thenReturn(mockRole);
272 List<EPUser> mockUserList = new ArrayList<>();
273 mockUserList.add(user);
274 Mockito.when((List<EPUser>) dataAccessService
275 .executeQuery("from EPUser where orgUserId='" + user.getOrgUserId() + "'", null))
276 .thenReturn(mockUserList);
277 Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true, user))
278 .thenReturn(mockRoleInAppForUserListNonCentralizedList);
279 List<RoleInAppForUser> roleInAppForUserNonCentralized = userRolesCommonServiceImpl.getAppRolesForUser(1l,
280 user.getOrgUserId(), true, user);
281 assertNull(roleInAppForUserNonCentralized);
285 public void getAppRolesForCentralizedPartnerAppTest() throws Exception {
286 EPUser user = mockUser.mockEPUser();
287 EPApp mockApp = mockApp();
289 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
290 List<RoleInAppForUser> mockRoleInAppForUserList = getMockedRoleInAppUserList();
291 List<EPRole> mockEPRoleList = new ArrayList<>();
292 EPRole mockEpRole = new EPRole();
293 mockEpRole.setActive(true);
294 mockEpRole.setAppId(2l);
295 mockEpRole.setName("test1");
296 mockEpRole.setAppRoleId(333l);
297 mockEpRole.setId(1l);
298 EPRole mockEpRole2 = new EPRole();
299 mockEpRole2.setActive(true);
300 mockEpRole2.setAppId(2l);
301 mockEpRole2.setName("test2");
302 mockEpRole2.setAppRoleId(444l);
303 mockEpRole2.setId(16l);
304 mockEPRoleList.add(mockEpRole);
305 mockEPRoleList.add(mockEpRole2);
306 final Map<String, Long> appParams = new HashMap<>();
307 appParams.put("appId", 2l);
308 Mockito.when(dataAccessService.executeNamedQuery("getActiveRolesOfApplication", appParams, null))
309 .thenReturn(mockEPRoleList);
310 final Map<String, String> params = new HashMap<>();
311 params.put("orgUserIdValue", "guestT");
312 List<EPUser> mockEPUserList = new ArrayList<>();
313 mockEPUserList.add(user);
314 Mockito.when(dataAccessService.executeNamedQuery("epUserAppId", params, null)).thenReturn(mockEPUserList);
315 final Map<String, Long> userParams = new HashMap<>();
316 userParams.put("appId", mockApp.getId());
317 userParams.put("userId", mockEPUserList.get(0).getId());
318 List<EPUserAppCurrentRoles> epUserAppCurrentRolesList = new ArrayList<>();
319 EPUserAppCurrentRoles epUserAppCurrentRoles = new EPUserAppCurrentRoles();
320 epUserAppCurrentRoles.setRoleId(444l);
321 epUserAppCurrentRoles.setRoleName("TestPartnerRole2");
322 epUserAppCurrentRoles.setUserId(mockEPUserList.get(0).getId());
323 epUserAppCurrentRolesList.add(epUserAppCurrentRoles);
324 Mockito.when(dataAccessService.executeNamedQuery("getUserAppCurrentRoles", userParams, null))
325 .thenReturn(epUserAppCurrentRolesList);
326 Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(), true, user))
327 .thenReturn(mockRoleInAppForUserList);
328 List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
330 assertNotEquals(roleInAppForUser, mockRoleInAppForUserList);
334 public void getAppRolesForNonCentralizedPartnerAppTest() throws Exception {
335 EPUser user = mockUser.mockEPUser();
337 List<EPUser> mockEpUserList = new ArrayList<>();
338 mockEpUserList.add(user);
339 EPApp mockApp = mockApp();
341 mockApp.setCentralAuth(false);
342 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
343 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
344 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
345 mockRoleInAppForUser.setIsApplied(true);
346 mockRoleInAppForUser.setRoleId(333l);
347 mockRoleInAppForUser.setRoleName("test1");
348 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
349 mockRoleInAppForUser2.setIsApplied(true);
350 mockRoleInAppForUser2.setRoleId(777l);
351 mockRoleInAppForUser2.setRoleName("test2");
352 RoleInAppForUser mockRoleInAppForUser3 = new RoleInAppForUser();
353 mockRoleInAppForUser3.setIsApplied(false);
354 mockRoleInAppForUser3.setRoleId(888l);
355 mockRoleInAppForUser3.setRoleName("test5");
356 mockRoleInAppForUserList.add(mockRoleInAppForUser);
357 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
358 mockRoleInAppForUserList.add(mockRoleInAppForUser3);
359 List<EcompRole> mockEcompRoleList = new ArrayList<>();
360 EcompRole mockEcompRole = new EcompRole();
361 mockEcompRole.setId(333l);
362 mockEcompRole.setName("test1");
363 EcompRole mockEcompRole2 = new EcompRole();
364 mockEcompRole2.setId(777l);
365 mockEcompRole2.setName("test2");
366 EcompRole mockEcompRole3 = new EcompRole();
367 mockEcompRole3.setId(888l);
368 mockEcompRole3.setName("test5");
369 mockEcompRoleList.add(mockEcompRole);
370 mockEcompRoleList.add(mockEcompRole2);
371 mockEcompRoleList.add(mockEcompRole3);
372 EcompRole[] mockEcompRoleArray = mockEcompRoleList.toArray(new EcompRole[mockEcompRoleList.size()]);
373 List<EPRole> mockEPRoleList = new ArrayList<>();
374 EPRole mockEpRole = new EPRole();
375 mockEpRole.setActive(true);
376 mockEpRole.setAppId(2l);
377 mockEpRole.setName("test1");
378 mockEpRole.setAppRoleId(333l);
379 mockEpRole.setId(16l);
380 EPRole mockEpRole2 = new EPRole();
381 mockEpRole2.setActive(true);
382 mockEpRole2.setAppId(2l);
383 mockEpRole2.setName("test3");
384 mockEpRole2.setAppRoleId(555l);
385 mockEpRole2.setId(15l);
386 EPRole mockEpRole3 = new EPRole();
387 mockEpRole3.setActive(true);
388 mockEpRole3.setAppId(2l);
389 mockEpRole3.setName("test4");
390 mockEpRole3.setAppRoleId(888l);
391 mockEpRole3.setId(17l);
392 mockEPRoleList.add(mockEpRole);
393 mockEPRoleList.add(mockEpRole2);
394 mockEPRoleList.add(mockEpRole3);
395 List<EPUserApp> mockUserRolesList = new ArrayList<>();
396 EPUserApp mockEpUserApp = new EPUserApp();
397 mockEpUserApp.setApp(mockApp);
398 mockEpUserApp.setRole(mockEpRole2);
399 mockEpUserApp.setUserId(user.getId());
400 mockUserRolesList.add(mockEpUserApp);
401 List<FunctionalMenuRole> mockFunctionalMenuRolesList = new ArrayList<>();
402 FunctionalMenuRole mockFunctionalMenuRole = new FunctionalMenuRole();
403 mockFunctionalMenuRole.setAppId((int) (long) mockApp.getId());
404 mockFunctionalMenuRole.setRoleId((int) (long) 15l);
405 mockFunctionalMenuRole.setMenuId(10l);
406 mockFunctionalMenuRole.setId(10);
407 mockFunctionalMenuRolesList.add(mockFunctionalMenuRole);
408 List<FunctionalMenuItem> mockFunctionalMenuItemList = new ArrayList<>();
409 FunctionalMenuItem mockFunctionalMenuItem = new FunctionalMenuItem();
410 List<Integer> mockRolesList = new ArrayList<>();
412 mockRolesList.add(role1);
413 mockFunctionalMenuItem.setRestrictedApp(false);
414 mockFunctionalMenuItem.setRoles(mockRolesList);
415 mockFunctionalMenuItem.setUrl("http://test.com");
416 mockFunctionalMenuItemList.add(mockFunctionalMenuItem);
417 Query epRoleQuery = Mockito.mock(Query.class);
418 Query epUserAppsQuery = Mockito.mock(Query.class);
419 Query epFunctionalMenuQuery = Mockito.mock(Query.class);
420 Query epFunctionalMenuQuery2 = Mockito.mock(Query.class);
421 Query epFunctionalMenuItemQuery = Mockito.mock(Query.class);
422 Query epUserListQuery = Mockito.mock(Query.class);
423 Query epUserRolesListQuery = Mockito.mock(Query.class);
424 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
425 .thenReturn(mockEcompRoleArray);
427 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=" + mockApp.getId()))
428 .thenReturn(epRoleQuery);
429 Mockito.doReturn(mockEPRoleList).when(epRoleQuery).list();
430 Mockito.when(session.createQuery(
431 "from " + EPUserApp.class.getName() + " where app.id=" + mockApp.getId() + " and role_id=" + 15l))
432 .thenReturn(epUserAppsQuery);
433 Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
435 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where roleId=" + 15l))
436 .thenReturn(epFunctionalMenuQuery);
437 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
439 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where menuId=" + 10l))
440 .thenReturn(epFunctionalMenuQuery2);
441 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
443 Mockito.when(session.createQuery("from " + FunctionalMenuItem.class.getName() + " where menuId=" + 10l))
444 .thenReturn(epFunctionalMenuItemQuery);
445 Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
446 List<EcompRole> mockEcompRoleList2 = new ArrayList<>();
447 EcompRole mockUserAppRoles = new EcompRole();
448 mockUserAppRoles.setId(333l);
449 mockUserAppRoles.setName("test1");
450 EcompRole mockUserAppRoles2 = new EcompRole();
451 mockUserAppRoles2.setId(777l);
452 mockUserAppRoles2.setName("test2");
453 mockEcompRoleList2.add(mockUserAppRoles);
454 mockEcompRoleList2.add(mockUserAppRoles2);
455 EcompRole[] mockEcompRoleArray2 = mockEcompRoleList2.toArray(new EcompRole[mockEcompRoleList2.size()]);
456 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(),
457 String.format("/user/%s/roles", user.getOrgUserId()))).thenReturn(mockEcompRoleArray2);
460 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
461 .thenReturn(epUserListQuery);
462 Mockito.doReturn(mockEpUserList).when(epUserListQuery).list();
464 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
465 EPUserApp mockEpUserAppRoles = new EPUserApp();
466 mockEpUserAppRoles.setApp(mockApp);
467 mockEpUserAppRoles.setRole(mockEpRole3);
468 mockEpUserAppRoles.setUserId(user.getId());
469 mockUserRolesList2.add(mockEpUserAppRoles);
470 Mockito.when(session.createQuery(
471 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
472 .thenReturn(epUserRolesListQuery);
473 Mockito.doReturn(mockUserRolesList2).when(epUserRolesListQuery).list();
474 List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
476 assertEquals(roleInAppForUser, mockRoleInAppForUserList);
479 @SuppressWarnings("unchecked")
481 public void setAppWithUserRoleStateForUserTestForCentralizedAppForPortal() throws Exception {
482 PowerMockito.mockStatic(SystemProperties.class);
483 PowerMockito.mockStatic(EcompPortalUtils.class);
484 PowerMockito.mockStatic(EPCommonSystemProperties.class);
485 PowerMockito.mockStatic(PortalConstants.class);
486 EPUser user = mockUser.mockEPUser();
488 List<EPUser> mockEpUserList = new ArrayList<>();
489 mockEpUserList.add(user);
490 EPApp mockApp = mockApp();
491 mockApp.setNameSpace("com.test.com");
493 mockApp.setCentralAuth(true);
494 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
495 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
496 AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
497 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
498 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
499 mockRoleInAppForUser.setIsApplied(true);
500 mockRoleInAppForUser.setRoleId(1l);
501 mockRoleInAppForUser.setRoleName("test1");
502 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
503 mockRoleInAppForUser2.setIsApplied(true);
504 mockRoleInAppForUser2.setRoleId(1000l);
505 mockRoleInAppForUser2.setRoleName("test3");
506 mockRoleInAppForUserList.add(mockRoleInAppForUser);
507 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
508 mockWithRolesForUser.setAppId(mockApp.getId());
509 mockWithRolesForUser.setAppName(mockApp.getName());
510 mockWithRolesForUser.setOrgUserId(user.getOrgUserId());
511 mockWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
512 List<EPUserAppRolesRequest> mockEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
513 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
514 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
515 mockEpUserAppRolesRequestDetail.setId(2l);
516 mockEpUserAppRolesRequestDetail.setReqType("P");
517 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
518 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
519 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
520 mockEPUserAppRolesRequest.setId(1l);
521 mockEPUserAppRolesRequest.setRequestStatus("P");
522 mockEPUserAppRolesRequest.setUserId(user.getId());
523 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
524 mockEpRequestIdValList.add(mockEPUserAppRolesRequest);
525 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
526 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
528 // Update Requests if any requests are pending
529 final Map<String, Long> params = new HashMap<>();
530 params.put("appId", mockApp.getId());
531 params.put("userId", user.getId());
532 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
533 params, null)).thenReturn(mockEpRequestIdValList);
534 mockEPUserAppRolesRequest.setUpdatedDate(new Date());
535 mockEPUserAppRolesRequest.setRequestStatus("O");
536 HashMap<String, Long> additionalUpdateParam = new HashMap<String, Long>();
537 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPUserAppRolesRequest, additionalUpdateParam);
538 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
539 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
540 mockEpUserAppRolesRequestDetail.setId(2l);
541 mockEpUserAppRolesRequestDetail.setReqType("P");
542 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
543 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
544 // Updates in External Auth System
545 final Map<String, String> userParams = new HashMap<>();
546 userParams.put("orgUserIdValue", user.getOrgUserId());
547 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
548 .thenReturn(mockEpUserList);
550 .when(EPCommonSystemProperties
551 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
553 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
554 .thenReturn("@test.com");
555 HttpHeaders headers = new HttpHeaders();
556 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
557 JSONObject mockJsonObject1 = new JSONObject();
558 JSONObject mockJsonObject2 = new JSONObject();
559 JSONObject mockJsonObject3 = new JSONObject();
560 mockJsonObject1.put("name", "com.test.com.test1");
561 mockJsonObject2.put("name", "com.test.com.test2");
562 List<JSONObject> mockJson = new ArrayList<>();
563 mockJson.add(mockJsonObject1);
564 mockJson.add(mockJsonObject2);
565 mockJsonObject3.put("role", mockJson);
566 ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
567 Mockito.when(externalAccessRolesServiceImpl.getUserRolesFromExtAuthSystem(Matchers.anyString(), Matchers.any(HttpEntity.class))).thenReturn(getResponse);
568 EPRole mockEPRole = new EPRole();
569 mockEPRole.setActive(true);
570 mockEPRole.setAppId(null);
571 mockEPRole.setAppRoleId(null);
572 mockEPRole.setId(1l);
573 mockEPRole.setName("test1");
574 EPRole mockEPRole2 = new EPRole();
575 mockEPRole2.setActive(true);
576 mockEPRole2.setAppId(null);
577 mockEPRole2.setAppRoleId(null);
578 mockEPRole2.setId(16l);
579 mockEPRole2.setName("test2");
580 EPRole mockEPRole3 = new EPRole();
581 mockEPRole3.setActive(true);
582 mockEPRole3.setAppId(null);
583 mockEPRole3.setAppRoleId(null);
584 mockEPRole3.setId(1000l);
585 mockEPRole3.setName("test3");
586 Map<String, EPRole> mockEPRoleList = new HashMap<>();
587 mockEPRoleList.put("test1", mockEPRole);
588 mockEPRoleList.put("test2", mockEPRole2);
589 mockEPRoleList.put("test3", mockEPRole3);
590 Mockito.when(externalAccessRolesServiceImpl.getAppRoleNamesWithUnderscoreMap(mockApp)).thenReturn(mockEPRoleList);
591 final Map<String, Long> params2 = new HashMap<>();
592 params2.put("appId", mockApp.getId());
593 params2.put("userId", user.getId());
594 List<EcompUserAppRoles> mockEPuserAppList = getCurrentUserRoles(user, mockApp);
595 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
596 .thenReturn(mockEPuserAppList);
597 final Map<String, Long> epDetailParams = new HashMap<>();
598 epDetailParams.put("reqId", mockEPUserAppRolesRequest.getId());
599 Mockito.when(dataAccessService.executeNamedQuery("userAppRolesRequestDetailList", epDetailParams, null))
600 .thenReturn(mockGetEpUserAppRolesRequestDetailList);
602 ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
603 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
604 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
606 ResponseEntity<String> deleteResponse = new ResponseEntity<>(HttpStatus.OK);
607 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE),
608 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(deleteResponse);
611 Query epsetAppWithUserRoleGetUserQuery = Mockito.mock(Query.class);
612 Query epsetAppWithUserRoleGetUserAppsQuery = Mockito.mock(Query.class);
613 Query epsetAppWithUserRoleGetRolesQuery = Mockito.mock(Query.class);
614 SQLQuery epsetAppWithUserRoleUpdateEPRoleQuery = Mockito.mock(SQLQuery.class);
615 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
617 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
618 .thenReturn(epsetAppWithUserRoleGetUserQuery);
619 Mockito.doReturn(mockEpUserList).when(epsetAppWithUserRoleGetUserQuery).list();
620 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
621 EPUserApp mockEpUserAppRoles = new EPUserApp();
622 mockEpUserAppRoles.setApp(mockApp);
623 mockEpUserAppRoles.setRole(mockEPRole);
624 mockEpUserAppRoles.setUserId(user.getId());
625 mockUserRolesList2.add(mockEpUserAppRoles);
626 Mockito.when(session.createQuery(
627 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=1 and role.active = 'Y' and userId=2"))
628 .thenReturn(epsetAppWithUserRoleGetUserAppsQuery);
629 Mockito.doReturn(mockUserRolesList2).when(epsetAppWithUserRoleGetUserAppsQuery).list();
630 List<EPRole> mockEPRoles = new ArrayList<>();
631 mockEPRoles.add(mockEPRole2);
632 mockEPRoles.add(mockEPRole3);
633 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId is null and id != 1"))
634 .thenReturn(epsetAppWithUserRoleGetRolesQuery);
635 Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleGetRolesQuery).list();
636 Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
637 .thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
638 ExternalRequestFieldsValidator actual = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
639 assertTrue(actual.isResult());
642 private List<EcompUserAppRoles> getCurrentUserRoles(EPUser user, EPApp mockApp) {
643 List<EcompUserAppRoles> mockEPuserAppList = new ArrayList<>();
644 EcompUserAppRoles mockEcompUserAppRoles = new EcompUserAppRoles();
645 mockEcompUserAppRoles.setAppId(String.valueOf(mockApp.getId()));
646 mockEcompUserAppRoles.setRoleId(1l);
647 mockEcompUserAppRoles.setRoleName("test1");
648 mockEcompUserAppRoles.setUserId(user.getId());
649 mockEPuserAppList.add(mockEcompUserAppRoles);
650 return mockEPuserAppList;
653 @SuppressWarnings("unchecked")
655 public void setAppWithUserRoleStateForUserTestForNonCentralizedApp() throws Exception {
656 PowerMockito.mockStatic(SystemProperties.class);
657 PowerMockito.mockStatic(EcompPortalUtils.class);
658 PowerMockito.mockStatic(EPCommonSystemProperties.class);
659 PowerMockito.mockStatic(PortalConstants.class);
660 EPUser user = mockUser.mockEPUser();
662 List<EPUser> mockEpUserList = new ArrayList<>();
663 mockEpUserList.add(user);
664 EPApp mockApp = mockApp();
665 mockApp.setNameSpace("com.test.com");
667 mockApp.setCentralAuth(false);
668 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
669 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
670 AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
671 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
672 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
673 mockRoleInAppForUser.setIsApplied(true);
674 mockRoleInAppForUser.setRoleId(1l);
675 mockRoleInAppForUser.setRoleName("test1");
676 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
677 mockRoleInAppForUser2.setIsApplied(true);
678 mockRoleInAppForUser2.setRoleId(1000l);
679 mockRoleInAppForUser2.setRoleName("test3");
680 mockRoleInAppForUserList.add(mockRoleInAppForUser);
681 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
682 mockWithRolesForUser.setAppId(mockApp.getId());
683 mockWithRolesForUser.setAppName(mockApp.getName());
684 mockWithRolesForUser.setOrgUserId(user.getOrgUserId());
685 mockWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
686 List<EPUserAppRolesRequest> mockEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
687 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
688 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
689 mockEpUserAppRolesRequestDetail.setId(2l);
690 mockEpUserAppRolesRequestDetail.setReqType("P");
691 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
692 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
693 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
694 mockEPUserAppRolesRequest.setId(1l);
695 mockEPUserAppRolesRequest.setRequestStatus("P");
696 mockEPUserAppRolesRequest.setUserId(user.getId());
697 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
698 mockEpRequestIdValList.add(mockEPUserAppRolesRequest);
699 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
700 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
702 // Update Requests if any requests are pending
703 final Map<String, Long> params = new HashMap<>();
704 params.put("appId", mockApp.getId());
705 params.put("userId", user.getId());
706 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
707 params, null)).thenReturn(mockEpRequestIdValList);
708 mockEPUserAppRolesRequest.setUpdatedDate(new Date());
709 mockEPUserAppRolesRequest.setRequestStatus("O");
710 HashMap<String, Long> additionalUpdateParam = new HashMap<String, Long>();
711 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPUserAppRolesRequest, additionalUpdateParam);
712 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
713 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
714 mockEpUserAppRolesRequestDetail.setId(2l);
715 mockEpUserAppRolesRequestDetail.setReqType("P");
716 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
717 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
718 final Map<String, Long> epDetailParams = new HashMap<>();
719 epDetailParams.put("reqId", mockEPUserAppRolesRequest.getId());
721 final Map<String, String> userParams = new HashMap<>();
722 userParams.put("orgUserIdValue", user.getOrgUserId());
723 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
724 .thenReturn(mockEpUserList);
727 .when(EPCommonSystemProperties
728 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
730 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
731 .thenReturn("@test.com");
732 HttpHeaders headers = new HttpHeaders();
733 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
734 EPRole mockEPRole = new EPRole();
735 mockEPRole.setActive(true);
736 mockEPRole.setAppId(2l);
737 mockEPRole.setAppRoleId(null);
738 mockEPRole.setId(10l);
739 mockEPRole.setAppRoleId(1l);
740 mockEPRole.setName("test1");
741 EPRole mockEPRole2 = new EPRole();
742 mockEPRole2.setActive(true);
743 mockEPRole2.setAppId(2l);
744 mockEPRole2.setAppRoleId(null);
745 mockEPRole2.setId(160l);
746 mockEPRole2.setName("test2");
747 mockEPRole2.setAppRoleId(16l);
748 EPRole mockEPRole3 = new EPRole();
749 mockEPRole3.setActive(true);
750 mockEPRole3.setAppId(2l);
751 mockEPRole3.setAppRoleId(null);
752 mockEPRole3.setId(1100l);
753 mockEPRole3.setAppRoleId(100l);
754 mockEPRole3.setName("test3");
755 Mockito.when(applicationsRestClientService.get(EPUser.class, mockApp.getId(),
756 String.format("/user/%s", user.getOrgUserId()), true)).thenReturn(user);
758 Query epsetAppWithUserRoleNonCentralizedGetUserQuery = Mockito.mock(Query.class);
759 Query epsetAppWithUserRoleNonCentralizedGetUserAppsQuery = Mockito.mock(Query.class);
760 Query epsetAppWithUserRoleNonCentralizedGetRolesQuery = Mockito.mock(Query.class);
761 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
763 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
764 .thenReturn(epsetAppWithUserRoleNonCentralizedGetUserQuery);
765 Mockito.doReturn(mockEpUserList).when(epsetAppWithUserRoleNonCentralizedGetUserQuery).list();
766 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
767 EPUserApp mockEpUserAppRoles = new EPUserApp();
768 mockEpUserAppRoles.setApp(mockApp);
769 mockEpUserAppRoles.setRole(mockEPRole);
770 mockEpUserAppRoles.setUserId(user.getId());
771 mockUserRolesList2.add(mockEpUserAppRoles);
772 Mockito.when(session.createQuery(
773 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
774 .thenReturn(epsetAppWithUserRoleNonCentralizedGetUserAppsQuery);
775 Mockito.doReturn(mockUserRolesList2).when(epsetAppWithUserRoleNonCentralizedGetUserAppsQuery).list();
776 List<EPRole> mockEPRoles = new ArrayList<>();
777 mockEPRoles.add(mockEPRole2);
778 mockEPRoles.add(mockEPRole3);
779 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=2"))
780 .thenReturn(epsetAppWithUserRoleNonCentralizedGetRolesQuery);
781 Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleNonCentralizedGetRolesQuery).list();
782 ExternalRequestFieldsValidator expected = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
783 assertEquals(expected.isResult(), false);
786 /*@SuppressWarnings("unchecked")
788 public void setExternalRequestUserAppRoleMerdianCentralizedAppTest() throws Exception {
789 PowerMockito.mockStatic(SystemProperties.class);
790 PowerMockito.mockStatic(EcompPortalUtils.class);
791 PowerMockito.mockStatic(EPCommonSystemProperties.class);
792 PowerMockito.mockStatic(PortalConstants.class);
793 EPUser user = mockUser.mockEPUser();
795 List<EPUser> mockEpUserList = new ArrayList<>();
796 mockEpUserList.add(user);
797 EPApp mockApp = mockApp();
798 mockApp.setNameSpace("com.test.com");
800 mockApp.setCentralAuth(true);
801 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
802 ExternalSystemUser externalSystemUser = new ExternalSystemUser();
803 List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
804 ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
805 mockExternalSystemRoleApproval.setRoleName("test1");
806 ExternalSystemRoleApproval mockExternalSystemRoleApproval2 = new ExternalSystemRoleApproval();
807 mockExternalSystemRoleApproval2.setRoleName("test2");
808 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval);
809 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval2);
810 externalSystemUser.setApplicationName(mockApp.getMlAppName());
811 externalSystemUser.setLoginId(user.getOrgUserId());
812 externalSystemUser.setRoles(mockExternalSystemRoleApprovalList);
813 EPRole mockEPRole = new EPRole();
814 mockEPRole.setActive(true);
815 mockEPRole.setAppId(null);
816 mockEPRole.setAppRoleId(null);
817 mockEPRole.setId(1l);
818 mockEPRole.setName("test1");
819 EPRole mockEPRole2 = new EPRole();
820 mockEPRole2.setActive(true);
821 mockEPRole2.setAppId(null);
822 mockEPRole2.setAppRoleId(null);
823 mockEPRole2.setId(16l);
824 mockEPRole2.setName("test2");
825 EPRole mockEPRole3 = new EPRole();
826 mockEPRole3.setActive(true);
827 mockEPRole3.setAppId(null);
828 mockEPRole3.setAppRoleId(null);
829 mockEPRole3.setId(1000l);
830 mockEPRole3.setName("test3");
832 Mockito.when(epAppCommonServiceImpl.getAppDetail(mockApp.getMlAppName())).thenReturn(mockApp);
833 final Map<String, String> userParams = new HashMap<>();
834 userParams.put("orgUserIdValue", user.getOrgUserId());
835 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
836 .thenReturn(mockEpUserList);
838 List<EPUserAppRolesRequest> mockMerdianEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
839 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
840 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
841 mockEpUserAppRolesRequestDetail.setId(2l);
842 mockEpUserAppRolesRequestDetail.setReqType("P");
843 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
844 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
845 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
846 mockEPUserAppRolesRequest.setId(1l);
847 mockEPUserAppRolesRequest.setRequestStatus("P");
848 mockEPUserAppRolesRequest.setUserId(user.getId());
849 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
850 mockMerdianEpRequestIdValList.add(mockEPUserAppRolesRequest);
851 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
852 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
854 final Map<String, Long> params = new HashMap<>();
855 params.put("appId", mockApp.getId());
856 params.put("userId", user.getId());
857 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
858 params, null)).thenReturn(mockMerdianEpRequestIdValList);
859 RoleInAppForUser mockRoleInAppForUser1 = new RoleInAppForUser();
860 mockRoleInAppForUser1.setIsApplied(true);
861 mockRoleInAppForUser1.setRoleId(1l);
862 mockRoleInAppForUser1.setRoleName("test1");
863 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
864 mockRoleInAppForUser2.setIsApplied(true);
865 mockRoleInAppForUser2.setRoleId(16l);
866 mockRoleInAppForUser2.setRoleName("test2");
867 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval.getRoleName(), mockApp.getId()))
868 .thenReturn(mockEPRole);
869 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval2.getRoleName(), mockApp.getId()))
870 .thenReturn(mockEPRole2);
871 List<EcompUserAppRoles> mockEPuserAppList = getCurrentUserRoles(user, mockApp);
872 final Map<String, Long> params2 = new HashMap<>();
873 params2.put("userId", user.getId());
874 params2.put("appId", mockApp.getId());
875 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
876 .thenReturn(mockEPuserAppList);
877 // Updates in External Auth System
878 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
879 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
880 mockEpUserAppRolesRequestDetail.setId(2l);
881 mockEpUserAppRolesRequestDetail.setReqType("P");
882 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
883 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
884 final Map<String, String> userParams2 = new HashMap<>();
885 userParams2.put("orgUserIdValue", user.getOrgUserId());
886 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams2, null))
887 .thenReturn(mockEpUserList);
889 .when(EPCommonSystemProperties
890 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
892 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
893 .thenReturn("@test.com");
894 HttpHeaders headers = new HttpHeaders();
895 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
896 JSONObject mockJsonObject1 = new JSONObject();
897 JSONObject mockJsonObject2 = new JSONObject();
898 JSONObject mockJsonObject3 = new JSONObject();
899 mockJsonObject1.put("name", "com.test.com.test1");
900 mockJsonObject2.put("name", "com.test.com.test2");
901 List<JSONObject> mockJson = new ArrayList<>();
902 mockJson.add(mockJsonObject1);
903 mockJson.add(mockJsonObject2);
904 mockJsonObject3.put("role", mockJson);
905 ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
906 Mockito.when(externalAccessRolesServiceImpl.getUserRolesFromExtAuthSystem(Matchers.anyString(), Matchers.any(HttpEntity.class))).thenReturn(getResponse);
907 Map<String, EPRole> mockEPRoleList = new HashMap<>();
908 mockEPRoleList.put("test1", mockEPRole);
909 mockEPRoleList.put("test2", mockEPRole2);
910 mockEPRoleList.put("test3", mockEPRole3);
911 Mockito.when(externalAccessRolesServiceImpl.getAppRoleNamesWithUnderscoreMap(mockApp)).thenReturn(mockEPRoleList);
912 ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
913 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
914 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
916 ResponseEntity<String> deleteResponse = new ResponseEntity<>(HttpStatus.OK);
917 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE),
918 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(deleteResponse);
920 Query epsetExternalRequestUserAppRoleGetUserQuery = Mockito.mock(Query.class);
921 Query epsetExternalRequestUserAppRoleGetUserAppsQuery = Mockito.mock(Query.class);
922 Query epsetExternalRequestUserAppRoleGetRolesQuery = Mockito.mock(Query.class);
923 SQLQuery epsetAppWithUserRoleUpdateEPRoleQuery = Mockito.mock(SQLQuery.class);
924 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
926 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
927 .thenReturn(epsetExternalRequestUserAppRoleGetUserQuery);
928 Mockito.doReturn(mockEpUserList).when(epsetExternalRequestUserAppRoleGetUserQuery).list();
929 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
930 EPUserApp mockEpUserAppRoles = new EPUserApp();
931 mockEpUserAppRoles.setApp(mockApp);
932 mockEpUserAppRoles.setRole(mockEPRole);
933 mockEpUserAppRoles.setUserId(user.getId());
934 mockUserRolesList2.add(mockEpUserAppRoles);
935 Mockito.when(session.createQuery(
936 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=1 and role.active = 'Y' and userId=2"))
937 .thenReturn(epsetExternalRequestUserAppRoleGetUserAppsQuery);
938 Mockito.doReturn(mockUserRolesList2).when(epsetExternalRequestUserAppRoleGetUserAppsQuery).list();
939 List<EPRole> mockEPRoles = new ArrayList<>();
940 mockEPRoles.add(mockEPRole2);
941 mockEPRoles.add(mockEPRole3);
942 Mockito.when(session.createQuery("from org.onap.portalapp.portal.domain.EPRole where appId is null "))
943 .thenReturn(epsetExternalRequestUserAppRoleGetRolesQuery);
944 Mockito.doReturn(mockEPRoles).when(epsetExternalRequestUserAppRoleGetRolesQuery).list();
945 Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
946 .thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
948 ExternalRequestFieldsValidator mockExternalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
949 "Updated Successfully");
950 ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
951 .setExternalRequestUserAppRole(externalSystemUser, "POST");
952 assertTrue(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
955 @SuppressWarnings("unchecked")
957 public void setExternalRequestUserAppRoleMerdianNonCentralizedAppTest() throws Exception {
958 PowerMockito.mockStatic(SystemProperties.class);
959 PowerMockito.mockStatic(EPCommonSystemProperties.class);
960 PowerMockito.mockStatic(PortalConstants.class);
961 EPUser user = mockUser.mockEPUser();
963 List<EPUser> mockEpUserList = new ArrayList<>();
964 mockEpUserList.add(user);
965 EPApp mockApp = mockApp();
967 mockApp.setEnabled(true);
968 mockApp.setCentralAuth(false);
969 ExternalSystemUser externalSystemUser = new ExternalSystemUser();
970 List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
971 ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
972 mockExternalSystemRoleApproval.setRoleName("test1");
973 ExternalSystemRoleApproval mockExternalSystemRoleApproval2 = new ExternalSystemRoleApproval();
974 mockExternalSystemRoleApproval2.setRoleName("test2");
975 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval);
976 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval2);
977 externalSystemUser.setApplicationName(mockApp.getMlAppName());
978 externalSystemUser.setLoginId(user.getOrgUserId());
979 externalSystemUser.setRoles(mockExternalSystemRoleApprovalList);
981 EPRole mockEPRole = new EPRole();
982 mockEPRole.setActive(true);
983 mockEPRole.setAppId(2l);
984 mockEPRole.setAppRoleId(1l);
985 mockEPRole.setId(1000l);
986 mockEPRole.setName("test1");
987 EPRole mockEPRole2 = new EPRole();
988 mockEPRole2.setActive(true);
989 mockEPRole2.setAppId(2l);
990 mockEPRole2.setAppRoleId(16l);
991 mockEPRole2.setId(160l);
992 mockEPRole2.setName("test2");
993 EPRole mockEPRole3 = new EPRole();
994 mockEPRole3.setActive(true);
995 mockEPRole3.setAppId(2l);
996 mockEPRole3.setAppRoleId(10l);
997 mockEPRole3.setId(100l);
998 mockEPRole3.setName("test3");
1000 Mockito.when(epAppCommonServiceImpl.getAppDetail(mockApp.getMlAppName())).thenReturn(mockApp);
1001 final Map<String, String> userParams = new HashMap<>();
1002 userParams.put("orgUserIdValue", user.getOrgUserId());
1003 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
1004 .thenReturn(mockEpUserList);
1006 List<EPUserAppRolesRequest> mockMerdianEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
1007 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
1008 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
1009 mockEpUserAppRolesRequestDetail.setId(2l);
1010 mockEpUserAppRolesRequestDetail.setReqType("P");
1011 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
1012 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
1013 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
1014 mockEPUserAppRolesRequest.setId(1l);
1015 mockEPUserAppRolesRequest.setRequestStatus("P");
1016 mockEPUserAppRolesRequest.setUserId(user.getId());
1017 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
1018 mockMerdianEpRequestIdValList.add(mockEPUserAppRolesRequest);
1019 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
1020 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
1022 final Map<String, Long> params = new HashMap<>();
1023 params.put("appId", mockApp.getId());
1024 params.put("userId", user.getId());
1025 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
1026 params, null)).thenReturn(mockMerdianEpRequestIdValList);
1027 RoleInAppForUser mockRoleInAppForUser1 = new RoleInAppForUser();
1028 mockRoleInAppForUser1.setIsApplied(true);
1029 mockRoleInAppForUser1.setRoleId(1l);
1030 mockRoleInAppForUser1.setRoleName("test1");
1031 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
1032 mockRoleInAppForUser2.setIsApplied(true);
1033 mockRoleInAppForUser2.setRoleId(16l);
1034 mockRoleInAppForUser2.setRoleName("test2");
1035 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval.getRoleName(), mockApp.getId()))
1036 .thenReturn(mockEPRole);
1037 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval2.getRoleName(), mockApp.getId()))
1038 .thenReturn(mockEPRole2);
1039 List<EcompUserAppRoles> mockEPuserAppList = new ArrayList<>();
1040 EcompUserAppRoles mockEcompUserAppRoles = new EcompUserAppRoles();
1041 mockEcompUserAppRoles.setAppId(String.valueOf(mockApp.getId()));
1042 mockEcompUserAppRoles.setRoleId(100l);
1043 mockEcompUserAppRoles.setRoleName("test1");
1044 mockEcompUserAppRoles.setUserId(user.getId());
1045 mockEPuserAppList.add(mockEcompUserAppRoles);
1046 final Map<String, Long> params2 = new HashMap<>();
1047 params2.put("userId", user.getId());
1048 params2.put("appId", mockApp.getId());
1049 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
1050 .thenReturn(mockEPuserAppList);
1051 List<EcompRole> mockEcompRoleList = new ArrayList<>();
1052 EcompRole mockEcompRole = new EcompRole();
1053 mockEcompRole.setId(1l);
1054 mockEcompRole.setName("test1");
1055 EcompRole mockEcompRole2 = new EcompRole();
1056 mockEcompRole2.setId(16l);
1057 mockEcompRole2.setName("test2");
1058 mockEcompRoleList.add(mockEcompRole);
1059 mockEcompRoleList.add(mockEcompRole2);
1060 EcompRole[] mockEcompRoleArray = mockEcompRoleList.toArray(new EcompRole[mockEcompRoleList.size()]);
1061 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
1062 .thenReturn(mockEcompRoleArray);
1065 List<EPUserApp> mockUserRolesList = new ArrayList<>();
1066 EPUserApp mockEpUserApp = new EPUserApp();
1067 mockEpUserApp.setApp(mockApp);
1068 mockEpUserApp.setRole(mockEPRole2);
1069 mockEpUserApp.setUserId(user.getId());
1070 mockUserRolesList.add(mockEpUserApp);
1071 List<FunctionalMenuRole> mockFunctionalMenuRolesList = new ArrayList<>();
1072 FunctionalMenuRole mockFunctionalMenuRole = new FunctionalMenuRole();
1073 mockFunctionalMenuRole.setAppId((int) (long) mockApp.getId());
1074 mockFunctionalMenuRole.setRoleId((int) (long) 15l);
1075 mockFunctionalMenuRole.setMenuId(10l);
1076 mockFunctionalMenuRole.setId(10);
1077 mockFunctionalMenuRolesList.add(mockFunctionalMenuRole);
1078 List<FunctionalMenuItem> mockFunctionalMenuItemList = new ArrayList<>();
1079 FunctionalMenuItem mockFunctionalMenuItem = new FunctionalMenuItem();
1080 List<Integer> mockRolesList = new ArrayList<>();
1082 mockRolesList.add(role1);
1083 mockFunctionalMenuItem.setRestrictedApp(false);
1084 mockFunctionalMenuItem.setRoles(mockRolesList);
1085 mockFunctionalMenuItem.setUrl("http://test.com");
1086 mockFunctionalMenuItemList.add(mockFunctionalMenuItem);
1087 Query epRoleQuery = Mockito.mock(Query.class);
1088 Query epUserAppsQuery = Mockito.mock(Query.class);
1089 Query epFunctionalMenuQuery = Mockito.mock(Query.class);
1090 Query epFunctionalMenuQuery2 = Mockito.mock(Query.class);
1091 Query epFunctionalMenuItemQuery = Mockito.mock(Query.class);
1092 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
1093 .thenReturn(mockEcompRoleArray);
1095 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=" + mockApp.getId()))
1096 .thenReturn(epRoleQuery);
1097 Mockito.doReturn(mockEcompRoleList).when(epRoleQuery).list();
1098 Mockito.when(session.createQuery(
1099 "from " + EPUserApp.class.getName() + " where app.id=" + mockApp.getId() + " and role_id=" + 100l))
1100 .thenReturn(epUserAppsQuery);
1101 Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
1103 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where roleId=" + 100l))
1104 .thenReturn(epFunctionalMenuQuery);
1105 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
1107 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where menuId=" + 10l))
1108 .thenReturn(epFunctionalMenuQuery2);
1109 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
1111 Mockito.when(session.createQuery("from " + FunctionalMenuItem.class.getName() + " where menuId=" + 10l))
1112 .thenReturn(epFunctionalMenuItemQuery);
1113 Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
1115 Mockito.when(applicationsRestClientService.get(EPUser.class, mockApp.getId(),
1116 String.format("/user/%s", user.getOrgUserId()), true)).thenReturn(user);
1118 Query epsetExternalRequestUserAppRoleGetUserQuery = Mockito.mock(Query.class);
1119 Query epsetExternalRequestUserAppRoleGetUserAppsQuery = Mockito.mock(Query.class);
1120 Query epsetExternalRequestUserAppRoleGetRolesQuery = Mockito.mock(Query.class);
1121 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
1122 Mockito.when(session
1123 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
1124 .thenReturn(epsetExternalRequestUserAppRoleGetUserQuery);
1125 Mockito.doReturn(mockEpUserList).when(epsetExternalRequestUserAppRoleGetUserQuery).list();
1126 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
1127 EPUserApp mockEpUserAppRoles = new EPUserApp();
1128 mockEpUserAppRoles.setApp(mockApp);
1129 mockEpUserAppRoles.setRole(mockEPRole);
1130 mockEpUserAppRoles.setUserId(user.getId());
1131 mockUserRolesList2.add(mockEpUserAppRoles);
1132 Mockito.when(session.createQuery(
1133 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
1134 .thenReturn(epsetExternalRequestUserAppRoleGetUserAppsQuery);
1135 Mockito.doReturn(mockUserRolesList2).when(epsetExternalRequestUserAppRoleGetUserAppsQuery).list();
1136 List<EPRole> mockEPRoles = new ArrayList<>();
1137 mockEPRoles.add(mockEPRole2);
1138 mockEPRoles.add(mockEPRole3);
1139 Mockito.when(session.createQuery("from org.onap.portalapp.portal.domain.EPRole where appId=2"))
1140 .thenReturn(epsetExternalRequestUserAppRoleGetRolesQuery);
1141 Mockito.doReturn(mockEPRoles).when(epsetExternalRequestUserAppRoleGetRolesQuery).list();
1143 ExternalRequestFieldsValidator mockExternalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1144 "Updated Successfully");
1145 ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
1146 .setExternalRequestUserAppRole(externalSystemUser, "POST");
1147 assertFalse(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
1150 @SuppressWarnings("unchecked")
1152 public void getUsersFromAppEndpointCentralizedAppTest() throws HTTPException {
1153 EPApp mockApp = mockApp();
1155 mockApp.setEnabled(true);
1156 mockApp.setCentralAuth(true);
1157 EPUser user = mockUser.mockEPUser();
1158 EPUser user2 = mockUser.mockEPUser();
1159 user2.setActive(true);
1160 user2.setOrgUserId("guestT2");
1162 user2.setFirstName("Guest2");
1163 user2.setLastName("Test2");
1165 user.setFirstName("Guest");
1166 user.setLastName("Test");
1167 EPRole mockEPRole1 = new EPRole();
1168 mockEPRole1.setId(1l);
1169 mockEPRole1.setName("test1");
1170 mockEPRole1.setActive(true);
1171 EPRole mockEPRole2 = new EPRole();
1172 mockEPRole2.setId(16l);
1173 mockEPRole2.setName("test2");
1174 mockEPRole2.setActive(true);
1175 SortedSet<EPUserApp> mockUserApps1 = new TreeSet<EPUserApp>();
1176 EPUserApp mockEPUserApp1 = new EPUserApp();
1177 mockEPUserApp1.setApp(mockApp);
1178 mockEPUserApp1.setRole(mockEPRole1);
1179 mockEPUserApp1.setUserId(1l);
1180 mockUserApps1.add(mockEPUserApp1);
1181 user.setEPUserApps(mockUserApps1);
1182 SortedSet<EPUserApp> mockUserApps2 = new TreeSet<EPUserApp>();
1183 EPUserApp mockEPUserApp2 = new EPUserApp();
1184 mockEPUserApp2.setApp(mockApp);
1185 mockEPUserApp2.setRole(mockEPRole2);
1186 mockEPUserApp2.setUserId(2l);
1187 mockUserApps2.add(mockEPUserApp2);
1188 user2.setEPUserApps(mockUserApps2);
1189 List<EPUser> mockEpUserList = new ArrayList<>();
1190 mockEpUserList.add(user);
1191 mockEpUserList.add(user2);
1192 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
1193 List<UserApplicationRoles> mockUserApplicationRolesList = new ArrayList<>();
1194 UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
1195 List<RemoteRole> mockRemoteRoleList = new ArrayList<>();
1196 RemoteRole mockRemoteRole = new RemoteRole();
1197 mockRemoteRole.setId(1l);
1198 mockRemoteRole.setName("test1");
1199 mockRemoteRoleList.add(mockRemoteRole);
1200 mockUserApplicationRoles.setAppId(mockApp.getId());
1201 mockUserApplicationRoles.setFirstName("Guest");
1202 mockUserApplicationRoles.setLastName("Test");
1203 mockUserApplicationRoles.setOrgUserId("guestT");
1204 mockUserApplicationRoles.setRoles(mockRemoteRoleList);
1205 UserApplicationRoles mockUserApplicationRoles2 = new UserApplicationRoles();
1206 List<RemoteRole> mockRemoteRoleList2 = new ArrayList<>();
1207 RemoteRole mockRemoteRole2 = new RemoteRole();
1208 mockRemoteRole2.setId(16l);
1209 mockRemoteRole2.setName("test2");
1210 mockRemoteRoleList2.add(mockRemoteRole2);
1211 mockUserApplicationRoles2.setAppId(mockApp.getId());
1212 mockUserApplicationRoles2.setFirstName("Guest2");
1213 mockUserApplicationRoles2.setLastName("Test2");
1214 mockUserApplicationRoles2.setOrgUserId("guestT2");
1215 mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
1216 mockUserApplicationRolesList.add(mockUserApplicationRoles);
1217 mockUserApplicationRolesList.add(mockUserApplicationRoles2);
1218 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("getActiveUsers", null, null))
1219 .thenReturn(mockEpUserList);
1220 assertEquals(userRolesCommonServiceImpl.getUsersFromAppEndpoint(1l).size(),
1221 mockUserApplicationRolesList.size());
1225 public void getUsersFromAppEndpointNonCentralizedAppTest() throws HTTPException, JsonProcessingException {
1226 EPApp mockApp = mockApp();
1228 mockApp.setEnabled(true);
1229 mockApp.setCentralAuth(false);
1230 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
1231 List<UserApplicationRoles> mockUserApplicationRolesNonCentralizedList = new ArrayList<>();
1232 UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
1233 List<RemoteRole> mockRemoteRoleList = new ArrayList<>();
1234 RemoteRole mockRemoteRole = new RemoteRole();
1235 mockRemoteRole.setId(1l);
1236 mockRemoteRole.setName("test1");
1237 mockRemoteRoleList.add(mockRemoteRole);
1238 mockUserApplicationRoles.setAppId(mockApp.getId());
1239 mockUserApplicationRoles.setFirstName("Guest");
1240 mockUserApplicationRoles.setLastName("Test");
1241 mockUserApplicationRoles.setOrgUserId("guestT");
1242 mockUserApplicationRoles.setRoles(mockRemoteRoleList);
1243 UserApplicationRoles mockUserApplicationRoles2 = new UserApplicationRoles();
1244 List<RemoteRole> mockRemoteRoleList2 = new ArrayList<>();
1245 RemoteRole mockRemoteRole2 = new RemoteRole();
1246 mockRemoteRole2.setId(16l);
1247 mockRemoteRole2.setName("test2");
1248 mockRemoteRoleList2.add(mockRemoteRole2);
1249 mockUserApplicationRoles2.setAppId(mockApp.getId());
1250 mockUserApplicationRoles2.setFirstName("Guest2");
1251 mockUserApplicationRoles2.setLastName("Test2");
1252 mockUserApplicationRoles2.setOrgUserId("guestT2");
1253 mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
1254 mockUserApplicationRolesNonCentralizedList.add(mockUserApplicationRoles);
1255 mockUserApplicationRolesNonCentralizedList.add(mockUserApplicationRoles2);
1256 RemoteUserWithRoles mockRemoteUserWithRoles1 = new RemoteUserWithRoles();
1257 mockRemoteUserWithRoles1.setFirstName("Guest1");
1258 mockRemoteUserWithRoles1.setLastName("Test1");
1259 mockRemoteUserWithRoles1.setOrgUserId("guestT");
1260 mockRemoteUserWithRoles1.setRoles(mockRemoteRoleList);
1261 RemoteUserWithRoles mockRemoteUserWithRoles2 = new RemoteUserWithRoles();
1262 mockRemoteUserWithRoles2.setFirstName("Guest2");
1263 mockRemoteUserWithRoles2.setLastName("Test2");
1264 mockRemoteUserWithRoles2.setOrgUserId("guestT");
1265 mockRemoteUserWithRoles2.setRoles(mockRemoteRoleList2);
1266 List<RemoteUserWithRoles> mockRemoteUserWithRolesList = new ArrayList<>();
1267 mockRemoteUserWithRolesList.add(mockRemoteUserWithRoles1);
1268 mockRemoteUserWithRolesList.add(mockRemoteUserWithRoles2);
1269 ObjectMapper mapper = new ObjectMapper();
1270 String mockGetRemoteUsersWithRoles = mapper.writeValueAsString(mockRemoteUserWithRolesList);
1271 Mockito.when(applicationsRestClientService.getIncomingJsonString(mockApp.getId(), "/users"))
1272 .thenReturn(mockGetRemoteUsersWithRoles);
1273 List<UserApplicationRoles> userApplicationRolesNonCentralizedList = userRolesCommonServiceImpl
1274 .getUsersFromAppEndpoint(2l);
1275 assertEquals(mockUserApplicationRolesNonCentralizedList.size(), userApplicationRolesNonCentralizedList.size());
1278 @SuppressWarnings("unchecked")
1280 public void putUserAppRolesRequestTest() {
1281 EPApp mockApp = mockApp();
1283 mockApp.setEnabled(true);
1284 mockApp.setCentralAuth(false);
1285 EPUser user = mockUser.mockEPUser();
1286 AppWithRolesForUser appWithRolesForUser = new AppWithRolesForUser();
1287 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
1288 RoleInAppForUser roleInAppForUser = new RoleInAppForUser();
1289 roleInAppForUser.setIsApplied(true);
1290 roleInAppForUser.setRoleId(1l);
1291 roleInAppForUser.setRoleName("test1");
1292 RoleInAppForUser roleInAppForUser2 = new RoleInAppForUser();
1293 roleInAppForUser2.setIsApplied(true);
1294 roleInAppForUser2.setRoleId(1000l);
1295 roleInAppForUser2.setRoleName("test3");
1296 mockRoleInAppForUserList.add(roleInAppForUser);
1297 mockRoleInAppForUserList.add(roleInAppForUser2);
1298 appWithRolesForUser.setAppId(mockApp.getId());
1299 appWithRolesForUser.setAppName(mockApp.getName());
1300 appWithRolesForUser.setOrgUserId(user.getOrgUserId());
1301 appWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
1302 List<EPUserAppRoles> epUserAppRolesList = new ArrayList<>();
1303 EPUserAppRoles appRole1 = new EPUserAppRoles();
1304 appRole1.setAppId(mockApp.getId());
1305 appRole1.setId(10l);
1306 appRole1.setRoleId(roleInAppForUser.roleId);
1307 epUserAppRolesList.add(appRole1);
1308 List<EPUserAppRoles> epUserAppRolesList2 = new ArrayList<>();
1309 EPUserAppRoles appRole2 = new EPUserAppRoles();
1310 appRole2.setAppId(mockApp.getId());
1311 appRole2.setId(11l);
1312 appRole2.setRoleId(roleInAppForUser2.roleId);
1313 epUserAppRolesList2.add(appRole2);
1314 EPUserAppRolesRequest mockEpAppRolesRequestData = new EPUserAppRolesRequest();
1315 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEpAppRolesRequestData, null);
1316 final Map<String, Long> params = new HashMap<>();
1317 params.put("appId", appWithRolesForUser.appId);
1318 params.put("appRoleId", roleInAppForUser.roleId);
1319 Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
1320 .thenReturn(epUserAppRolesList);
1321 params.put("appRoleId", roleInAppForUser2.roleId);
1322 Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
1323 .thenReturn(epUserAppRolesList2);
1324 EPUserAppRolesRequestDetail mockEPAppRoleDetail = new EPUserAppRolesRequestDetail();
1325 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPAppRoleDetail, null);
1326 FieldsValidator expected = new FieldsValidator();
1327 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
1328 FieldsValidator actual = userRolesCommonServiceImpl.putUserAppRolesRequest(appWithRolesForUser, user);
1329 assertEquals(expected, actual);
1333 public void importRolesFromRemoteApplicationTest() throws HTTPException {
1334 EPApp mockApp = mockApp();
1336 mockApp.setEnabled(true);
1337 mockApp.setCentralAuth(false);
1338 List<EPRole> expected = new ArrayList<>();
1339 EPRole epRole = new EPRole();
1340 epRole.setAppId(mockApp.getId());
1341 epRole.setActive(true);
1343 epRole.setName("test1");
1344 EPRole epRole2 = new EPRole();
1345 epRole2.setAppId(mockApp.getId());
1346 epRole2.setActive(true);
1348 epRole2.setName("test2");
1349 expected.add(epRole);
1350 expected.add(epRole2);
1351 EPRole[] epRoleArray = expected.toArray(new EPRole[expected.size()]);
1352 Mockito.when(applicationsRestClientService.get(EPRole[].class, mockApp.getId(), "/rolesFull"))
1353 .thenReturn(epRoleArray);
1354 Mockito.when(epRoleServiceImpl.getRole(mockApp.getId(), epRole.getId())).thenReturn(epRole);
1355 Mockito.when(epRoleServiceImpl.getRole(mockApp.getId(), epRole2.getId())).thenReturn(epRole2);
1356 List<EPRole> actual = userRolesCommonServiceImpl.importRolesFromRemoteApplication(mockApp.getId());
1357 assertEquals(expected.size(), actual.size());
1360 @SuppressWarnings("deprecation")
1362 public void getCachedAppRolesForUserTest() {
1363 EPApp mockApp = mockApp();
1365 mockApp.setEnabled(true);
1366 mockApp.setCentralAuth(false);
1367 EPUser user = mockUser.mockEPUser();
1368 List<EPUserApp> expected = new ArrayList<>();
1369 EPUserApp epUserApp = new EPUserApp();
1370 EPRole epRole = new EPRole();
1371 epRole.setAppId(mockApp.getId());
1372 epRole.setActive(true);
1374 epRole.setName("test1");
1375 epUserApp.setApp(mockApp);
1376 epUserApp.setRole(epRole);
1377 epUserApp.setUserId(user.getId());
1378 expected.add(epUserApp);
1379 String filter = " where user_id = " + Long.toString(user.getId()) + " and app_id = "
1380 + Long.toString(mockApp.getId());
1381 Mockito.when(dataAccessService.getList(EPUserApp.class, filter, null, null)).thenReturn(expected);
1382 List<EPUserApp> actual = userRolesCommonServiceImpl.getCachedAppRolesForUser(mockApp.getId(), user.getId());
1383 assertEquals(expected.size(), actual.size());
1386 @SuppressWarnings("unchecked")
1388 public void getUserAppCatalogRolesTest() {
1389 EPApp mockApp = mockApp();
1391 mockApp.setEnabled(true);
1392 mockApp.setCentralAuth(false);
1393 EPUser user = mockUser.mockEPUser();
1394 List<EPUserAppCatalogRoles> expected = new ArrayList<>();
1395 EPUserAppCatalogRoles epUserAppCatalogRoles = new EPUserAppCatalogRoles();
1396 epUserAppCatalogRoles.setAppId(mockApp.getId());
1397 epUserAppCatalogRoles.setId(2l);
1398 epUserAppCatalogRoles.setRequestedRoleId(10l);
1399 epUserAppCatalogRoles.setRequestStatus("S");
1400 epUserAppCatalogRoles.setRolename("test1");
1401 expected.add(epUserAppCatalogRoles);
1402 Map<String, String> params = new HashMap<>();
1403 params.put("userid", user.getId().toString());
1404 params.put("appName", mockApp.getName());
1406 (List<EPUserAppCatalogRoles>) dataAccessService.executeNamedQuery("userAppCatalogRoles", params, null))
1407 .thenReturn(expected);
1408 List<EPUserAppCatalogRoles> actual = userRolesCommonServiceImpl.getUserAppCatalogRoles(user, mockApp.getName());
1409 assertEquals(expected.size(), actual.size());
1413 public void getExternalRequestAccessTest() {
1414 ExternalSystemAccess expected = new ExternalSystemAccess("external_access_enable", false);
1415 ExternalSystemAccess actual = userRolesCommonServiceImpl.getExternalRequestAccess();
1416 assertEquals(expected, actual);
1420 public void getEPUserAppListTest() {
1421 EPApp mockApp = mockApp();
1423 mockApp.setEnabled(true);
1424 mockApp.setCentralAuth(false);
1425 EPUser user = mockUser.mockEPUser();
1426 List<EPUserApp> expected = new ArrayList<>();
1427 EPUserApp epUserApp = new EPUserApp();
1428 EPRole epRole = new EPRole();
1429 epRole.setAppId(mockApp.getId());
1430 epRole.setActive(true);
1432 epRole.setName("test1");
1433 epUserApp.setApp(mockApp);
1434 epUserApp.setRole(epRole);
1435 epUserApp.setUserId(user.getId());
1436 expected.add(epUserApp);
1437 final Map<String, Long> params = new HashMap<>();
1438 params.put("appId", mockApp.getId());
1439 params.put("userId", user.getId());
1440 params.put("roleId", epRole.getId());
1441 Mockito.when(dataAccessService.executeNamedQuery("getUserRoleOnUserIdAndRoleIdAndAppId", params, null))
1442 .thenReturn(expected);
1443 List<EPUserApp> actual = userRolesCommonServiceImpl.getEPUserAppList(mockApp.getId(), user.getId(),
1445 assertEquals(expected.size(), actual.size());
1449 public void updateRemoteUserProfileTest() {
1450 EPApp mockApp = mockApp();
1451 EPApp mockApp2 = mockApp();
1453 mockApp.setEnabled(true);
1454 mockApp.setCentralAuth(false);
1455 EPUser user = mockUser.mockEPUser();
1456 List<EPApp> mockEpAppList = new ArrayList<>();
1457 mockEpAppList.add(mockApp);
1458 mockEpAppList.add(mockApp2);
1459 Mockito.when(searchServiceImpl.searchUserByUserId(user.getOrgUserId())).thenReturn(user);
1460 Mockito.when(epAppCommonServiceImpl.getUserRemoteApps(user.getId().toString())).thenReturn(mockEpAppList);
1461 String expected = "success";
1462 String actual = userRolesCommonServiceImpl.updateRemoteUserProfile(user.getOrgUserId(), mockApp.getId());
1463 assertEquals(expected, actual);