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