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);
428 Mockito.when(session.createQuery("from :name where appId = :appId"))
429 .thenReturn(epRoleQuery);
431 Mockito.when(epRoleQuery.setParameter("name",EPRole.class.getName())).thenReturn(epRoleQuery);
432 Mockito.when(epRoleQuery.setParameter("appId",mockApp.getId())).thenReturn(epRoleQuery);
434 Mockito.doReturn(mockEPRoleList).when(epRoleQuery).list();
435 Mockito.when(session.createQuery(
436 "from " + EPUserApp.class.getName() + " where app.id=" + mockApp.getId() + " and role_id=" + 15l))
437 .thenReturn(epUserAppsQuery);
438 Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
440 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where roleId=" + 15l))
441 .thenReturn(epFunctionalMenuQuery);
442 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
444 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where menuId=" + 10l))
445 .thenReturn(epFunctionalMenuQuery2);
446 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
448 Mockito.when(session.createQuery("from " + FunctionalMenuItem.class.getName() + " where menuId=" + 10l))
449 .thenReturn(epFunctionalMenuItemQuery);
450 Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
451 List<EcompRole> mockEcompRoleList2 = new ArrayList<>();
452 EcompRole mockUserAppRoles = new EcompRole();
453 mockUserAppRoles.setId(333l);
454 mockUserAppRoles.setName("test1");
455 EcompRole mockUserAppRoles2 = new EcompRole();
456 mockUserAppRoles2.setId(777l);
457 mockUserAppRoles2.setName("test2");
458 mockEcompRoleList2.add(mockUserAppRoles);
459 mockEcompRoleList2.add(mockUserAppRoles2);
460 EcompRole[] mockEcompRoleArray2 = mockEcompRoleList2.toArray(new EcompRole[mockEcompRoleList2.size()]);
461 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(),
462 String.format("/user/%s/roles", user.getOrgUserId()))).thenReturn(mockEcompRoleArray2);
465 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
466 .thenReturn(epUserListQuery);
467 Mockito.doReturn(mockEpUserList).when(epUserListQuery).list();
469 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
470 EPUserApp mockEpUserAppRoles = new EPUserApp();
471 mockEpUserAppRoles.setApp(mockApp);
472 mockEpUserAppRoles.setRole(mockEpRole3);
473 mockEpUserAppRoles.setUserId(user.getId());
474 mockUserRolesList2.add(mockEpUserAppRoles);
475 Mockito.when(session.createQuery(
476 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
477 .thenReturn(epUserRolesListQuery);
478 Mockito.doReturn(mockUserRolesList2).when(epUserRolesListQuery).list();
479 List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
481 assertEquals(roleInAppForUser, mockRoleInAppForUserList);
484 @SuppressWarnings("unchecked")
486 public void setAppWithUserRoleStateForUserTestForCentralizedAppForPortal() throws Exception {
487 PowerMockito.mockStatic(SystemProperties.class);
488 PowerMockito.mockStatic(EcompPortalUtils.class);
489 PowerMockito.mockStatic(EPCommonSystemProperties.class);
490 PowerMockito.mockStatic(PortalConstants.class);
491 EPUser user = mockUser.mockEPUser();
493 List<EPUser> mockEpUserList = new ArrayList<>();
494 mockEpUserList.add(user);
495 EPApp mockApp = mockApp();
496 mockApp.setNameSpace("com.test.com");
498 mockApp.setCentralAuth(true);
499 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
500 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
501 AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
502 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
503 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
504 mockRoleInAppForUser.setIsApplied(true);
505 mockRoleInAppForUser.setRoleId(1l);
506 mockRoleInAppForUser.setRoleName("test1");
507 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
508 mockRoleInAppForUser2.setIsApplied(true);
509 mockRoleInAppForUser2.setRoleId(1000l);
510 mockRoleInAppForUser2.setRoleName("test3");
511 mockRoleInAppForUserList.add(mockRoleInAppForUser);
512 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
513 mockWithRolesForUser.setAppId(mockApp.getId());
514 mockWithRolesForUser.setAppName(mockApp.getName());
515 mockWithRolesForUser.setOrgUserId(user.getOrgUserId());
516 mockWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
517 List<EPUserAppRolesRequest> mockEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
518 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
519 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
520 mockEpUserAppRolesRequestDetail.setId(2l);
521 mockEpUserAppRolesRequestDetail.setReqType("P");
522 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
523 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
524 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
525 mockEPUserAppRolesRequest.setId(1l);
526 mockEPUserAppRolesRequest.setRequestStatus("P");
527 mockEPUserAppRolesRequest.setUserId(user.getId());
528 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
529 mockEpRequestIdValList.add(mockEPUserAppRolesRequest);
530 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
531 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
533 // Update Requests if any requests are pending
534 final Map<String, Long> params = new HashMap<>();
535 params.put("appId", mockApp.getId());
536 params.put("userId", user.getId());
537 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
538 params, null)).thenReturn(mockEpRequestIdValList);
539 mockEPUserAppRolesRequest.setUpdatedDate(new Date());
540 mockEPUserAppRolesRequest.setRequestStatus("O");
541 HashMap<String, Long> additionalUpdateParam = new HashMap<String, Long>();
542 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPUserAppRolesRequest, additionalUpdateParam);
543 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
544 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
545 mockEpUserAppRolesRequestDetail.setId(2l);
546 mockEpUserAppRolesRequestDetail.setReqType("P");
547 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
548 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
549 // Updates in External Auth System
550 final Map<String, String> userParams = new HashMap<>();
551 userParams.put("orgUserIdValue", user.getOrgUserId());
552 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
553 .thenReturn(mockEpUserList);
555 .when(EPCommonSystemProperties
556 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
558 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
559 .thenReturn("@test.com");
560 HttpHeaders headers = new HttpHeaders();
561 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
562 JSONObject mockJsonObject1 = new JSONObject();
563 JSONObject mockJsonObject2 = new JSONObject();
564 JSONObject mockJsonObject3 = new JSONObject();
565 mockJsonObject1.put("name", "com.test.com.test1");
566 mockJsonObject2.put("name", "com.test.com.test2");
567 List<JSONObject> mockJson = new ArrayList<>();
568 mockJson.add(mockJsonObject1);
569 mockJson.add(mockJsonObject2);
570 mockJsonObject3.put("role", mockJson);
571 ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
572 Mockito.when(externalAccessRolesServiceImpl.getUserRolesFromExtAuthSystem(Matchers.anyString(), Matchers.any(HttpEntity.class))).thenReturn(getResponse);
573 EPRole mockEPRole = new EPRole();
574 mockEPRole.setActive(true);
575 mockEPRole.setAppId(null);
576 mockEPRole.setAppRoleId(null);
577 mockEPRole.setId(1l);
578 mockEPRole.setName("test1");
579 EPRole mockEPRole2 = new EPRole();
580 mockEPRole2.setActive(true);
581 mockEPRole2.setAppId(null);
582 mockEPRole2.setAppRoleId(null);
583 mockEPRole2.setId(16l);
584 mockEPRole2.setName("test2");
585 EPRole mockEPRole3 = new EPRole();
586 mockEPRole3.setActive(true);
587 mockEPRole3.setAppId(null);
588 mockEPRole3.setAppRoleId(null);
589 mockEPRole3.setId(1000l);
590 mockEPRole3.setName("test3");
591 Map<String, EPRole> mockEPRoleList = new HashMap<>();
592 mockEPRoleList.put("test1", mockEPRole);
593 mockEPRoleList.put("test2", mockEPRole2);
594 mockEPRoleList.put("test3", mockEPRole3);
595 Mockito.when(externalAccessRolesServiceImpl.getAppRoleNamesWithUnderscoreMap(mockApp)).thenReturn(mockEPRoleList);
596 final Map<String, Long> params2 = new HashMap<>();
597 params2.put("appId", mockApp.getId());
598 params2.put("userId", user.getId());
599 List<EcompUserAppRoles> mockEPuserAppList = getCurrentUserRoles(user, mockApp);
600 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
601 .thenReturn(mockEPuserAppList);
602 final Map<String, Long> epDetailParams = new HashMap<>();
603 epDetailParams.put("reqId", mockEPUserAppRolesRequest.getId());
604 Mockito.when(dataAccessService.executeNamedQuery("userAppRolesRequestDetailList", epDetailParams, null))
605 .thenReturn(mockGetEpUserAppRolesRequestDetailList);
607 ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
608 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
609 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
611 ResponseEntity<String> deleteResponse = new ResponseEntity<>(HttpStatus.OK);
612 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE),
613 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(deleteResponse);
616 Query epsetAppWithUserRoleGetUserQuery = Mockito.mock(Query.class);
617 Query epsetAppWithUserRoleGetUserAppsQuery = Mockito.mock(Query.class);
618 Query epsetAppWithUserRoleGetRolesQuery = Mockito.mock(Query.class);
619 SQLQuery epsetAppWithUserRoleUpdateEPRoleQuery = Mockito.mock(SQLQuery.class);
620 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
622 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
623 .thenReturn(epsetAppWithUserRoleGetUserQuery);
624 Mockito.doReturn(mockEpUserList).when(epsetAppWithUserRoleGetUserQuery).list();
625 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
626 EPUserApp mockEpUserAppRoles = new EPUserApp();
627 mockEpUserAppRoles.setApp(mockApp);
628 mockEpUserAppRoles.setRole(mockEPRole);
629 mockEpUserAppRoles.setUserId(user.getId());
630 mockUserRolesList2.add(mockEpUserAppRoles);
631 Mockito.when(session.createQuery(
632 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=1 and role.active = 'Y' and userId=2"))
633 .thenReturn(epsetAppWithUserRoleGetUserAppsQuery);
634 Mockito.doReturn(mockUserRolesList2).when(epsetAppWithUserRoleGetUserAppsQuery).list();
635 List<EPRole> mockEPRoles = new ArrayList<>();
636 mockEPRoles.add(mockEPRole2);
637 mockEPRoles.add(mockEPRole3);
638 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId is null and id != 1"))
639 .thenReturn(epsetAppWithUserRoleGetRolesQuery);
640 Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleGetRolesQuery).list();
641 Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
642 .thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
643 ExternalRequestFieldsValidator actual = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
644 assertTrue(actual.isResult());
647 private List<EcompUserAppRoles> getCurrentUserRoles(EPUser user, EPApp mockApp) {
648 List<EcompUserAppRoles> mockEPuserAppList = new ArrayList<>();
649 EcompUserAppRoles mockEcompUserAppRoles = new EcompUserAppRoles();
650 mockEcompUserAppRoles.setAppId(String.valueOf(mockApp.getId()));
651 mockEcompUserAppRoles.setRoleId(1l);
652 mockEcompUserAppRoles.setRoleName("test1");
653 mockEcompUserAppRoles.setUserId(user.getId());
654 mockEPuserAppList.add(mockEcompUserAppRoles);
655 return mockEPuserAppList;
658 @SuppressWarnings("unchecked")
660 public void setAppWithUserRoleStateForUserTestForNonCentralizedApp() throws Exception {
661 PowerMockito.mockStatic(SystemProperties.class);
662 PowerMockito.mockStatic(EcompPortalUtils.class);
663 PowerMockito.mockStatic(EPCommonSystemProperties.class);
664 PowerMockito.mockStatic(PortalConstants.class);
665 EPUser user = mockUser.mockEPUser();
667 List<EPUser> mockEpUserList = new ArrayList<>();
668 mockEpUserList.add(user);
669 EPApp mockApp = mockApp();
670 mockApp.setNameSpace("com.test.com");
672 mockApp.setCentralAuth(false);
673 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
674 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
675 AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
676 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
677 RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
678 mockRoleInAppForUser.setIsApplied(true);
679 mockRoleInAppForUser.setRoleId(1l);
680 mockRoleInAppForUser.setRoleName("test1");
681 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
682 mockRoleInAppForUser2.setIsApplied(true);
683 mockRoleInAppForUser2.setRoleId(1000l);
684 mockRoleInAppForUser2.setRoleName("test3");
685 mockRoleInAppForUserList.add(mockRoleInAppForUser);
686 mockRoleInAppForUserList.add(mockRoleInAppForUser2);
687 mockWithRolesForUser.setAppId(mockApp.getId());
688 mockWithRolesForUser.setAppName(mockApp.getName());
689 mockWithRolesForUser.setOrgUserId(user.getOrgUserId());
690 mockWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
691 List<EPUserAppRolesRequest> mockEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
692 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
693 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
694 mockEpUserAppRolesRequestDetail.setId(2l);
695 mockEpUserAppRolesRequestDetail.setReqType("P");
696 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
697 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
698 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
699 mockEPUserAppRolesRequest.setId(1l);
700 mockEPUserAppRolesRequest.setRequestStatus("P");
701 mockEPUserAppRolesRequest.setUserId(user.getId());
702 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
703 mockEpRequestIdValList.add(mockEPUserAppRolesRequest);
704 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
705 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
707 // Update Requests if any requests are pending
708 final Map<String, Long> params = new HashMap<>();
709 params.put("appId", mockApp.getId());
710 params.put("userId", user.getId());
711 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
712 params, null)).thenReturn(mockEpRequestIdValList);
713 mockEPUserAppRolesRequest.setUpdatedDate(new Date());
714 mockEPUserAppRolesRequest.setRequestStatus("O");
715 HashMap<String, Long> additionalUpdateParam = new HashMap<String, Long>();
716 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPUserAppRolesRequest, additionalUpdateParam);
717 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
718 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
719 mockEpUserAppRolesRequestDetail.setId(2l);
720 mockEpUserAppRolesRequestDetail.setReqType("P");
721 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
722 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
723 final Map<String, Long> epDetailParams = new HashMap<>();
724 epDetailParams.put("reqId", mockEPUserAppRolesRequest.getId());
726 final Map<String, String> userParams = new HashMap<>();
727 userParams.put("orgUserIdValue", user.getOrgUserId());
728 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
729 .thenReturn(mockEpUserList);
732 .when(EPCommonSystemProperties
733 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
735 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
736 .thenReturn("@test.com");
737 HttpHeaders headers = new HttpHeaders();
738 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
739 EPRole mockEPRole = new EPRole();
740 mockEPRole.setActive(true);
741 mockEPRole.setAppId(2l);
742 mockEPRole.setAppRoleId(null);
743 mockEPRole.setId(10l);
744 mockEPRole.setAppRoleId(1l);
745 mockEPRole.setName("test1");
746 EPRole mockEPRole2 = new EPRole();
747 mockEPRole2.setActive(true);
748 mockEPRole2.setAppId(2l);
749 mockEPRole2.setAppRoleId(null);
750 mockEPRole2.setId(160l);
751 mockEPRole2.setName("test2");
752 mockEPRole2.setAppRoleId(16l);
753 EPRole mockEPRole3 = new EPRole();
754 mockEPRole3.setActive(true);
755 mockEPRole3.setAppId(2l);
756 mockEPRole3.setAppRoleId(null);
757 mockEPRole3.setId(1100l);
758 mockEPRole3.setAppRoleId(100l);
759 mockEPRole3.setName("test3");
760 Mockito.when(applicationsRestClientService.get(EPUser.class, mockApp.getId(),
761 String.format("/user/%s", user.getOrgUserId()), true)).thenReturn(user);
763 Query epsetAppWithUserRoleNonCentralizedGetUserQuery = Mockito.mock(Query.class);
764 Query epsetAppWithUserRoleNonCentralizedGetUserAppsQuery = Mockito.mock(Query.class);
765 Query epsetAppWithUserRoleNonCentralizedGetRolesQuery = Mockito.mock(Query.class);
766 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
768 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
769 .thenReturn(epsetAppWithUserRoleNonCentralizedGetUserQuery);
770 Mockito.doReturn(mockEpUserList).when(epsetAppWithUserRoleNonCentralizedGetUserQuery).list();
771 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
772 EPUserApp mockEpUserAppRoles = new EPUserApp();
773 mockEpUserAppRoles.setApp(mockApp);
774 mockEpUserAppRoles.setRole(mockEPRole);
775 mockEpUserAppRoles.setUserId(user.getId());
776 mockUserRolesList2.add(mockEpUserAppRoles);
777 Mockito.when(session.createQuery(
778 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
779 .thenReturn(epsetAppWithUserRoleNonCentralizedGetUserAppsQuery);
780 Mockito.doReturn(mockUserRolesList2).when(epsetAppWithUserRoleNonCentralizedGetUserAppsQuery).list();
781 List<EPRole> mockEPRoles = new ArrayList<>();
782 mockEPRoles.add(mockEPRole2);
783 mockEPRoles.add(mockEPRole3);
784 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=2"))
785 .thenReturn(epsetAppWithUserRoleNonCentralizedGetRolesQuery);
786 Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleNonCentralizedGetRolesQuery).list();
787 ExternalRequestFieldsValidator expected = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
788 assertEquals(expected.isResult(), false);
791 /*@SuppressWarnings("unchecked")
793 public void setExternalRequestUserAppRoleMerdianCentralizedAppTest() throws Exception {
794 PowerMockito.mockStatic(SystemProperties.class);
795 PowerMockito.mockStatic(EcompPortalUtils.class);
796 PowerMockito.mockStatic(EPCommonSystemProperties.class);
797 PowerMockito.mockStatic(PortalConstants.class);
798 EPUser user = mockUser.mockEPUser();
800 List<EPUser> mockEpUserList = new ArrayList<>();
801 mockEpUserList.add(user);
802 EPApp mockApp = mockApp();
803 mockApp.setNameSpace("com.test.com");
805 mockApp.setCentralAuth(true);
806 Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
807 ExternalSystemUser externalSystemUser = new ExternalSystemUser();
808 List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
809 ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
810 mockExternalSystemRoleApproval.setRoleName("test1");
811 ExternalSystemRoleApproval mockExternalSystemRoleApproval2 = new ExternalSystemRoleApproval();
812 mockExternalSystemRoleApproval2.setRoleName("test2");
813 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval);
814 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval2);
815 externalSystemUser.setApplicationName(mockApp.getMlAppName());
816 externalSystemUser.setLoginId(user.getOrgUserId());
817 externalSystemUser.setRoles(mockExternalSystemRoleApprovalList);
818 EPRole mockEPRole = new EPRole();
819 mockEPRole.setActive(true);
820 mockEPRole.setAppId(null);
821 mockEPRole.setAppRoleId(null);
822 mockEPRole.setId(1l);
823 mockEPRole.setName("test1");
824 EPRole mockEPRole2 = new EPRole();
825 mockEPRole2.setActive(true);
826 mockEPRole2.setAppId(null);
827 mockEPRole2.setAppRoleId(null);
828 mockEPRole2.setId(16l);
829 mockEPRole2.setName("test2");
830 EPRole mockEPRole3 = new EPRole();
831 mockEPRole3.setActive(true);
832 mockEPRole3.setAppId(null);
833 mockEPRole3.setAppRoleId(null);
834 mockEPRole3.setId(1000l);
835 mockEPRole3.setName("test3");
837 Mockito.when(epAppCommonServiceImpl.getAppDetail(mockApp.getMlAppName())).thenReturn(mockApp);
838 final Map<String, String> userParams = new HashMap<>();
839 userParams.put("orgUserIdValue", user.getOrgUserId());
840 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
841 .thenReturn(mockEpUserList);
843 List<EPUserAppRolesRequest> mockMerdianEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
844 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
845 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
846 mockEpUserAppRolesRequestDetail.setId(2l);
847 mockEpUserAppRolesRequestDetail.setReqType("P");
848 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
849 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
850 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
851 mockEPUserAppRolesRequest.setId(1l);
852 mockEPUserAppRolesRequest.setRequestStatus("P");
853 mockEPUserAppRolesRequest.setUserId(user.getId());
854 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
855 mockMerdianEpRequestIdValList.add(mockEPUserAppRolesRequest);
856 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
857 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
859 final Map<String, Long> params = new HashMap<>();
860 params.put("appId", mockApp.getId());
861 params.put("userId", user.getId());
862 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
863 params, null)).thenReturn(mockMerdianEpRequestIdValList);
864 RoleInAppForUser mockRoleInAppForUser1 = new RoleInAppForUser();
865 mockRoleInAppForUser1.setIsApplied(true);
866 mockRoleInAppForUser1.setRoleId(1l);
867 mockRoleInAppForUser1.setRoleName("test1");
868 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
869 mockRoleInAppForUser2.setIsApplied(true);
870 mockRoleInAppForUser2.setRoleId(16l);
871 mockRoleInAppForUser2.setRoleName("test2");
872 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval.getRoleName(), mockApp.getId()))
873 .thenReturn(mockEPRole);
874 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval2.getRoleName(), mockApp.getId()))
875 .thenReturn(mockEPRole2);
876 List<EcompUserAppRoles> mockEPuserAppList = getCurrentUserRoles(user, mockApp);
877 final Map<String, Long> params2 = new HashMap<>();
878 params2.put("userId", user.getId());
879 params2.put("appId", mockApp.getId());
880 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
881 .thenReturn(mockEPuserAppList);
882 // Updates in External Auth System
883 List<EPUserAppRolesRequestDetail> mockGetEpUserAppRolesRequestDetailList = new ArrayList<EPUserAppRolesRequestDetail>();
884 EPUserAppRolesRequestDetail mockGetEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
885 mockEpUserAppRolesRequestDetail.setId(2l);
886 mockEpUserAppRolesRequestDetail.setReqType("P");
887 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
888 mockGetEpUserAppRolesRequestDetailList.add(mockGetEpUserAppRolesRequestDetail);
889 final Map<String, String> userParams2 = new HashMap<>();
890 userParams2.put("orgUserIdValue", user.getOrgUserId());
891 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams2, null))
892 .thenReturn(mockEpUserList);
894 .when(EPCommonSystemProperties
895 .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
897 PowerMockito.when(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN))
898 .thenReturn("@test.com");
899 HttpHeaders headers = new HttpHeaders();
900 Mockito.when(EcompPortalUtils.base64encodeKeyForAAFBasicAuth()).thenReturn(headers);
901 JSONObject mockJsonObject1 = new JSONObject();
902 JSONObject mockJsonObject2 = new JSONObject();
903 JSONObject mockJsonObject3 = new JSONObject();
904 mockJsonObject1.put("name", "com.test.com.test1");
905 mockJsonObject2.put("name", "com.test.com.test2");
906 List<JSONObject> mockJson = new ArrayList<>();
907 mockJson.add(mockJsonObject1);
908 mockJson.add(mockJsonObject2);
909 mockJsonObject3.put("role", mockJson);
910 ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
911 Mockito.when(externalAccessRolesServiceImpl.getUserRolesFromExtAuthSystem(Matchers.anyString(), Matchers.any(HttpEntity.class))).thenReturn(getResponse);
912 Map<String, EPRole> mockEPRoleList = new HashMap<>();
913 mockEPRoleList.put("test1", mockEPRole);
914 mockEPRoleList.put("test2", mockEPRole2);
915 mockEPRoleList.put("test3", mockEPRole3);
916 Mockito.when(externalAccessRolesServiceImpl.getAppRoleNamesWithUnderscoreMap(mockApp)).thenReturn(mockEPRoleList);
917 ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
918 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
919 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
921 ResponseEntity<String> deleteResponse = new ResponseEntity<>(HttpStatus.OK);
922 Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.DELETE),
923 Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(deleteResponse);
925 Query epsetExternalRequestUserAppRoleGetUserQuery = Mockito.mock(Query.class);
926 Query epsetExternalRequestUserAppRoleGetUserAppsQuery = Mockito.mock(Query.class);
927 Query epsetExternalRequestUserAppRoleGetRolesQuery = Mockito.mock(Query.class);
928 SQLQuery epsetAppWithUserRoleUpdateEPRoleQuery = Mockito.mock(SQLQuery.class);
929 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
931 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
932 .thenReturn(epsetExternalRequestUserAppRoleGetUserQuery);
933 Mockito.doReturn(mockEpUserList).when(epsetExternalRequestUserAppRoleGetUserQuery).list();
934 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
935 EPUserApp mockEpUserAppRoles = new EPUserApp();
936 mockEpUserAppRoles.setApp(mockApp);
937 mockEpUserAppRoles.setRole(mockEPRole);
938 mockEpUserAppRoles.setUserId(user.getId());
939 mockUserRolesList2.add(mockEpUserAppRoles);
940 Mockito.when(session.createQuery(
941 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=1 and role.active = 'Y' and userId=2"))
942 .thenReturn(epsetExternalRequestUserAppRoleGetUserAppsQuery);
943 Mockito.doReturn(mockUserRolesList2).when(epsetExternalRequestUserAppRoleGetUserAppsQuery).list();
944 List<EPRole> mockEPRoles = new ArrayList<>();
945 mockEPRoles.add(mockEPRole2);
946 mockEPRoles.add(mockEPRole3);
947 Mockito.when(session.createQuery("from org.onap.portalapp.portal.domain.EPRole where appId is null "))
948 .thenReturn(epsetExternalRequestUserAppRoleGetRolesQuery);
949 Mockito.doReturn(mockEPRoles).when(epsetExternalRequestUserAppRoleGetRolesQuery).list();
950 Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
951 .thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
953 ExternalRequestFieldsValidator mockExternalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
954 "Updated Successfully");
955 ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
956 .setExternalRequestUserAppRole(externalSystemUser, "POST");
957 assertTrue(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
960 @SuppressWarnings("unchecked")
962 public void setExternalRequestUserAppRoleMerdianNonCentralizedAppTest() throws Exception {
963 PowerMockito.mockStatic(SystemProperties.class);
964 PowerMockito.mockStatic(EPCommonSystemProperties.class);
965 PowerMockito.mockStatic(PortalConstants.class);
966 EPUser user = mockUser.mockEPUser();
968 List<EPUser> mockEpUserList = new ArrayList<>();
969 mockEpUserList.add(user);
970 EPApp mockApp = mockApp();
972 mockApp.setEnabled(true);
973 mockApp.setCentralAuth(false);
974 ExternalSystemUser externalSystemUser = new ExternalSystemUser();
975 List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
976 ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
977 mockExternalSystemRoleApproval.setRoleName("test1");
978 ExternalSystemRoleApproval mockExternalSystemRoleApproval2 = new ExternalSystemRoleApproval();
979 mockExternalSystemRoleApproval2.setRoleName("test2");
980 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval);
981 mockExternalSystemRoleApprovalList.add(mockExternalSystemRoleApproval2);
982 externalSystemUser.setApplicationName(mockApp.getMlAppName());
983 externalSystemUser.setLoginId(user.getOrgUserId());
984 externalSystemUser.setRoles(mockExternalSystemRoleApprovalList);
986 EPRole mockEPRole = new EPRole();
987 mockEPRole.setActive(true);
988 mockEPRole.setAppId(2l);
989 mockEPRole.setAppRoleId(1l);
990 mockEPRole.setId(1000l);
991 mockEPRole.setName("test1");
992 EPRole mockEPRole2 = new EPRole();
993 mockEPRole2.setActive(true);
994 mockEPRole2.setAppId(2l);
995 mockEPRole2.setAppRoleId(16l);
996 mockEPRole2.setId(160l);
997 mockEPRole2.setName("test2");
998 EPRole mockEPRole3 = new EPRole();
999 mockEPRole3.setActive(true);
1000 mockEPRole3.setAppId(2l);
1001 mockEPRole3.setAppRoleId(10l);
1002 mockEPRole3.setId(100l);
1003 mockEPRole3.setName("test3");
1005 Mockito.when(epAppCommonServiceImpl.getAppDetail(mockApp.getMlAppName())).thenReturn(mockApp);
1006 final Map<String, String> userParams = new HashMap<>();
1007 userParams.put("orgUserIdValue", user.getOrgUserId());
1008 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("epUserAppId", userParams, null))
1009 .thenReturn(mockEpUserList);
1011 List<EPUserAppRolesRequest> mockMerdianEpRequestIdValList = new ArrayList<EPUserAppRolesRequest>();
1012 Set<EPUserAppRolesRequestDetail> mockEpUserAppRolesRequestDetailList = new TreeSet<>();
1013 EPUserAppRolesRequestDetail mockEpUserAppRolesRequestDetail = new EPUserAppRolesRequestDetail();
1014 mockEpUserAppRolesRequestDetail.setId(2l);
1015 mockEpUserAppRolesRequestDetail.setReqType("P");
1016 mockEpUserAppRolesRequestDetail.setReqRoleId(16l);
1017 EPUserAppRolesRequest mockEPUserAppRolesRequest = new EPUserAppRolesRequest();
1018 mockEPUserAppRolesRequest.setAppId(mockApp.getId());
1019 mockEPUserAppRolesRequest.setId(1l);
1020 mockEPUserAppRolesRequest.setRequestStatus("P");
1021 mockEPUserAppRolesRequest.setUserId(user.getId());
1022 mockEPUserAppRolesRequest.setEpRequestIdDetail(mockEpUserAppRolesRequestDetailList);
1023 mockMerdianEpRequestIdValList.add(mockEPUserAppRolesRequest);
1024 mockEpUserAppRolesRequestDetail.setEpRequestIdData(mockEPUserAppRolesRequest);
1025 mockEpUserAppRolesRequestDetailList.add(mockEpUserAppRolesRequestDetail);
1027 final Map<String, Long> params = new HashMap<>();
1028 params.put("appId", mockApp.getId());
1029 params.put("userId", user.getId());
1030 Mockito.when((List<EPUserAppRolesRequest>) dataAccessService.executeNamedQuery("userAppRolesRequestList",
1031 params, null)).thenReturn(mockMerdianEpRequestIdValList);
1032 RoleInAppForUser mockRoleInAppForUser1 = new RoleInAppForUser();
1033 mockRoleInAppForUser1.setIsApplied(true);
1034 mockRoleInAppForUser1.setRoleId(1l);
1035 mockRoleInAppForUser1.setRoleName("test1");
1036 RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
1037 mockRoleInAppForUser2.setIsApplied(true);
1038 mockRoleInAppForUser2.setRoleId(16l);
1039 mockRoleInAppForUser2.setRoleName("test2");
1040 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval.getRoleName(), mockApp.getId()))
1041 .thenReturn(mockEPRole);
1042 Mockito.when(epRoleServiceImpl.getAppRole(mockExternalSystemRoleApproval2.getRoleName(), mockApp.getId()))
1043 .thenReturn(mockEPRole2);
1044 List<EcompUserAppRoles> mockEPuserAppList = new ArrayList<>();
1045 EcompUserAppRoles mockEcompUserAppRoles = new EcompUserAppRoles();
1046 mockEcompUserAppRoles.setAppId(String.valueOf(mockApp.getId()));
1047 mockEcompUserAppRoles.setRoleId(100l);
1048 mockEcompUserAppRoles.setRoleName("test1");
1049 mockEcompUserAppRoles.setUserId(user.getId());
1050 mockEPuserAppList.add(mockEcompUserAppRoles);
1051 final Map<String, Long> params2 = new HashMap<>();
1052 params2.put("userId", user.getId());
1053 params2.put("appId", mockApp.getId());
1054 Mockito.when(dataAccessService.executeNamedQuery("getUserAppExistingRoles", params2, null))
1055 .thenReturn(mockEPuserAppList);
1056 List<EcompRole> mockEcompRoleList = new ArrayList<>();
1057 EcompRole mockEcompRole = new EcompRole();
1058 mockEcompRole.setId(1l);
1059 mockEcompRole.setName("test1");
1060 EcompRole mockEcompRole2 = new EcompRole();
1061 mockEcompRole2.setId(16l);
1062 mockEcompRole2.setName("test2");
1063 mockEcompRoleList.add(mockEcompRole);
1064 mockEcompRoleList.add(mockEcompRole2);
1065 EcompRole[] mockEcompRoleArray = mockEcompRoleList.toArray(new EcompRole[mockEcompRoleList.size()]);
1066 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
1067 .thenReturn(mockEcompRoleArray);
1070 List<EPUserApp> mockUserRolesList = new ArrayList<>();
1071 EPUserApp mockEpUserApp = new EPUserApp();
1072 mockEpUserApp.setApp(mockApp);
1073 mockEpUserApp.setRole(mockEPRole2);
1074 mockEpUserApp.setUserId(user.getId());
1075 mockUserRolesList.add(mockEpUserApp);
1076 List<FunctionalMenuRole> mockFunctionalMenuRolesList = new ArrayList<>();
1077 FunctionalMenuRole mockFunctionalMenuRole = new FunctionalMenuRole();
1078 mockFunctionalMenuRole.setAppId((int) (long) mockApp.getId());
1079 mockFunctionalMenuRole.setRoleId((int) (long) 15l);
1080 mockFunctionalMenuRole.setMenuId(10l);
1081 mockFunctionalMenuRole.setId(10);
1082 mockFunctionalMenuRolesList.add(mockFunctionalMenuRole);
1083 List<FunctionalMenuItem> mockFunctionalMenuItemList = new ArrayList<>();
1084 FunctionalMenuItem mockFunctionalMenuItem = new FunctionalMenuItem();
1085 List<Integer> mockRolesList = new ArrayList<>();
1087 mockRolesList.add(role1);
1088 mockFunctionalMenuItem.setRestrictedApp(false);
1089 mockFunctionalMenuItem.setRoles(mockRolesList);
1090 mockFunctionalMenuItem.setUrl("http://test.com");
1091 mockFunctionalMenuItemList.add(mockFunctionalMenuItem);
1092 Query epRoleQuery = Mockito.mock(Query.class);
1093 Query epUserAppsQuery = Mockito.mock(Query.class);
1094 Query epFunctionalMenuQuery = Mockito.mock(Query.class);
1095 Query epFunctionalMenuQuery2 = Mockito.mock(Query.class);
1096 Query epFunctionalMenuItemQuery = Mockito.mock(Query.class);
1097 Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
1098 .thenReturn(mockEcompRoleArray);
1100 Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=" + mockApp.getId()))
1101 .thenReturn(epRoleQuery);
1102 Mockito.doReturn(mockEcompRoleList).when(epRoleQuery).list();
1103 Mockito.when(session.createQuery(
1104 "from " + EPUserApp.class.getName() + " where app.id=" + mockApp.getId() + " and role_id=" + 100l))
1105 .thenReturn(epUserAppsQuery);
1106 Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
1108 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where roleId=" + 100l))
1109 .thenReturn(epFunctionalMenuQuery);
1110 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
1112 Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where menuId=" + 10l))
1113 .thenReturn(epFunctionalMenuQuery2);
1114 Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
1116 Mockito.when(session.createQuery("from " + FunctionalMenuItem.class.getName() + " where menuId=" + 10l))
1117 .thenReturn(epFunctionalMenuItemQuery);
1118 Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
1120 Mockito.when(applicationsRestClientService.get(EPUser.class, mockApp.getId(),
1121 String.format("/user/%s", user.getOrgUserId()), true)).thenReturn(user);
1123 Query epsetExternalRequestUserAppRoleGetUserQuery = Mockito.mock(Query.class);
1124 Query epsetExternalRequestUserAppRoleGetUserAppsQuery = Mockito.mock(Query.class);
1125 Query epsetExternalRequestUserAppRoleGetRolesQuery = Mockito.mock(Query.class);
1126 Mockito.when(session.get(EPApp.class, mockApp.getId())).thenReturn(mockApp);
1127 Mockito.when(session
1128 .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
1129 .thenReturn(epsetExternalRequestUserAppRoleGetUserQuery);
1130 Mockito.doReturn(mockEpUserList).when(epsetExternalRequestUserAppRoleGetUserQuery).list();
1131 List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
1132 EPUserApp mockEpUserAppRoles = new EPUserApp();
1133 mockEpUserAppRoles.setApp(mockApp);
1134 mockEpUserAppRoles.setRole(mockEPRole);
1135 mockEpUserAppRoles.setUserId(user.getId());
1136 mockUserRolesList2.add(mockEpUserAppRoles);
1137 Mockito.when(session.createQuery(
1138 "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
1139 .thenReturn(epsetExternalRequestUserAppRoleGetUserAppsQuery);
1140 Mockito.doReturn(mockUserRolesList2).when(epsetExternalRequestUserAppRoleGetUserAppsQuery).list();
1141 List<EPRole> mockEPRoles = new ArrayList<>();
1142 mockEPRoles.add(mockEPRole2);
1143 mockEPRoles.add(mockEPRole3);
1144 Mockito.when(session.createQuery("from org.onap.portalapp.portal.domain.EPRole where appId=2"))
1145 .thenReturn(epsetExternalRequestUserAppRoleGetRolesQuery);
1146 Mockito.doReturn(mockEPRoles).when(epsetExternalRequestUserAppRoleGetRolesQuery).list();
1148 ExternalRequestFieldsValidator mockExternalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1149 "Updated Successfully");
1150 ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
1151 .setExternalRequestUserAppRole(externalSystemUser, "POST");
1152 assertFalse(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
1155 @SuppressWarnings("unchecked")
1157 public void getUsersFromAppEndpointCentralizedAppTest() throws HTTPException {
1158 EPApp mockApp = mockApp();
1160 mockApp.setEnabled(true);
1161 mockApp.setCentralAuth(true);
1162 EPUser user = mockUser.mockEPUser();
1163 EPUser user2 = mockUser.mockEPUser();
1164 user2.setActive(true);
1165 user2.setOrgUserId("guestT2");
1167 user2.setFirstName("Guest2");
1168 user2.setLastName("Test2");
1170 user.setFirstName("Guest");
1171 user.setLastName("Test");
1172 EPRole mockEPRole1 = new EPRole();
1173 mockEPRole1.setId(1l);
1174 mockEPRole1.setName("test1");
1175 mockEPRole1.setActive(true);
1176 EPRole mockEPRole2 = new EPRole();
1177 mockEPRole2.setId(16l);
1178 mockEPRole2.setName("test2");
1179 mockEPRole2.setActive(true);
1180 SortedSet<EPUserApp> mockUserApps1 = new TreeSet<EPUserApp>();
1181 EPUserApp mockEPUserApp1 = new EPUserApp();
1182 mockEPUserApp1.setApp(mockApp);
1183 mockEPUserApp1.setRole(mockEPRole1);
1184 mockEPUserApp1.setUserId(1l);
1185 mockUserApps1.add(mockEPUserApp1);
1186 user.setEPUserApps(mockUserApps1);
1187 SortedSet<EPUserApp> mockUserApps2 = new TreeSet<EPUserApp>();
1188 EPUserApp mockEPUserApp2 = new EPUserApp();
1189 mockEPUserApp2.setApp(mockApp);
1190 mockEPUserApp2.setRole(mockEPRole2);
1191 mockEPUserApp2.setUserId(2l);
1192 mockUserApps2.add(mockEPUserApp2);
1193 user2.setEPUserApps(mockUserApps2);
1194 List<EPUser> mockEpUserList = new ArrayList<>();
1195 mockEpUserList.add(user);
1196 mockEpUserList.add(user2);
1197 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
1198 List<UserApplicationRoles> mockUserApplicationRolesList = new ArrayList<>();
1199 UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
1200 List<RemoteRole> mockRemoteRoleList = new ArrayList<>();
1201 RemoteRole mockRemoteRole = new RemoteRole();
1202 mockRemoteRole.setId(1l);
1203 mockRemoteRole.setName("test1");
1204 mockRemoteRoleList.add(mockRemoteRole);
1205 mockUserApplicationRoles.setAppId(mockApp.getId());
1206 mockUserApplicationRoles.setFirstName("Guest");
1207 mockUserApplicationRoles.setLastName("Test");
1208 mockUserApplicationRoles.setOrgUserId("guestT");
1209 mockUserApplicationRoles.setRoles(mockRemoteRoleList);
1210 UserApplicationRoles mockUserApplicationRoles2 = new UserApplicationRoles();
1211 List<RemoteRole> mockRemoteRoleList2 = new ArrayList<>();
1212 RemoteRole mockRemoteRole2 = new RemoteRole();
1213 mockRemoteRole2.setId(16l);
1214 mockRemoteRole2.setName("test2");
1215 mockRemoteRoleList2.add(mockRemoteRole2);
1216 mockUserApplicationRoles2.setAppId(mockApp.getId());
1217 mockUserApplicationRoles2.setFirstName("Guest2");
1218 mockUserApplicationRoles2.setLastName("Test2");
1219 mockUserApplicationRoles2.setOrgUserId("guestT2");
1220 mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
1221 mockUserApplicationRolesList.add(mockUserApplicationRoles);
1222 mockUserApplicationRolesList.add(mockUserApplicationRoles2);
1223 Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("getActiveUsers", null, null))
1224 .thenReturn(mockEpUserList);
1225 assertEquals(userRolesCommonServiceImpl.getUsersFromAppEndpoint(1l).size(),
1226 mockUserApplicationRolesList.size());
1230 public void getUsersFromAppEndpointNonCentralizedAppTest() throws HTTPException, JsonProcessingException {
1231 EPApp mockApp = mockApp();
1233 mockApp.setEnabled(true);
1234 mockApp.setCentralAuth(false);
1235 Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
1236 List<UserApplicationRoles> mockUserApplicationRolesNonCentralizedList = new ArrayList<>();
1237 UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
1238 List<RemoteRole> mockRemoteRoleList = new ArrayList<>();
1239 RemoteRole mockRemoteRole = new RemoteRole();
1240 mockRemoteRole.setId(1l);
1241 mockRemoteRole.setName("test1");
1242 mockRemoteRoleList.add(mockRemoteRole);
1243 mockUserApplicationRoles.setAppId(mockApp.getId());
1244 mockUserApplicationRoles.setFirstName("Guest");
1245 mockUserApplicationRoles.setLastName("Test");
1246 mockUserApplicationRoles.setOrgUserId("guestT");
1247 mockUserApplicationRoles.setRoles(mockRemoteRoleList);
1248 UserApplicationRoles mockUserApplicationRoles2 = new UserApplicationRoles();
1249 List<RemoteRole> mockRemoteRoleList2 = new ArrayList<>();
1250 RemoteRole mockRemoteRole2 = new RemoteRole();
1251 mockRemoteRole2.setId(16l);
1252 mockRemoteRole2.setName("test2");
1253 mockRemoteRoleList2.add(mockRemoteRole2);
1254 mockUserApplicationRoles2.setAppId(mockApp.getId());
1255 mockUserApplicationRoles2.setFirstName("Guest2");
1256 mockUserApplicationRoles2.setLastName("Test2");
1257 mockUserApplicationRoles2.setOrgUserId("guestT2");
1258 mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
1259 mockUserApplicationRolesNonCentralizedList.add(mockUserApplicationRoles);
1260 mockUserApplicationRolesNonCentralizedList.add(mockUserApplicationRoles2);
1261 RemoteUserWithRoles mockRemoteUserWithRoles1 = new RemoteUserWithRoles();
1262 mockRemoteUserWithRoles1.setFirstName("Guest1");
1263 mockRemoteUserWithRoles1.setLastName("Test1");
1264 mockRemoteUserWithRoles1.setOrgUserId("guestT");
1265 mockRemoteUserWithRoles1.setRoles(mockRemoteRoleList);
1266 RemoteUserWithRoles mockRemoteUserWithRoles2 = new RemoteUserWithRoles();
1267 mockRemoteUserWithRoles2.setFirstName("Guest2");
1268 mockRemoteUserWithRoles2.setLastName("Test2");
1269 mockRemoteUserWithRoles2.setOrgUserId("guestT");
1270 mockRemoteUserWithRoles2.setRoles(mockRemoteRoleList2);
1271 List<RemoteUserWithRoles> mockRemoteUserWithRolesList = new ArrayList<>();
1272 mockRemoteUserWithRolesList.add(mockRemoteUserWithRoles1);
1273 mockRemoteUserWithRolesList.add(mockRemoteUserWithRoles2);
1274 ObjectMapper mapper = new ObjectMapper();
1275 String mockGetRemoteUsersWithRoles = mapper.writeValueAsString(mockRemoteUserWithRolesList);
1276 Mockito.when(applicationsRestClientService.getIncomingJsonString(mockApp.getId(), "/users"))
1277 .thenReturn(mockGetRemoteUsersWithRoles);
1278 List<UserApplicationRoles> userApplicationRolesNonCentralizedList = userRolesCommonServiceImpl
1279 .getUsersFromAppEndpoint(2l);
1280 assertEquals(mockUserApplicationRolesNonCentralizedList.size(), userApplicationRolesNonCentralizedList.size());
1283 @SuppressWarnings("unchecked")
1285 public void putUserAppRolesRequestTest() {
1286 EPApp mockApp = mockApp();
1288 mockApp.setEnabled(true);
1289 mockApp.setCentralAuth(false);
1290 EPUser user = mockUser.mockEPUser();
1291 AppWithRolesForUser appWithRolesForUser = new AppWithRolesForUser();
1292 List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
1293 RoleInAppForUser roleInAppForUser = new RoleInAppForUser();
1294 roleInAppForUser.setIsApplied(true);
1295 roleInAppForUser.setRoleId(1l);
1296 roleInAppForUser.setRoleName("test1");
1297 RoleInAppForUser roleInAppForUser2 = new RoleInAppForUser();
1298 roleInAppForUser2.setIsApplied(true);
1299 roleInAppForUser2.setRoleId(1000l);
1300 roleInAppForUser2.setRoleName("test3");
1301 mockRoleInAppForUserList.add(roleInAppForUser);
1302 mockRoleInAppForUserList.add(roleInAppForUser2);
1303 appWithRolesForUser.setAppId(mockApp.getId());
1304 appWithRolesForUser.setAppName(mockApp.getName());
1305 appWithRolesForUser.setOrgUserId(user.getOrgUserId());
1306 appWithRolesForUser.setAppRoles(mockRoleInAppForUserList);
1307 List<EPUserAppRoles> epUserAppRolesList = new ArrayList<>();
1308 EPUserAppRoles appRole1 = new EPUserAppRoles();
1309 appRole1.setAppId(mockApp.getId());
1310 appRole1.setId(10l);
1311 appRole1.setRoleId(roleInAppForUser.roleId);
1312 epUserAppRolesList.add(appRole1);
1313 List<EPUserAppRoles> epUserAppRolesList2 = new ArrayList<>();
1314 EPUserAppRoles appRole2 = new EPUserAppRoles();
1315 appRole2.setAppId(mockApp.getId());
1316 appRole2.setId(11l);
1317 appRole2.setRoleId(roleInAppForUser2.roleId);
1318 epUserAppRolesList2.add(appRole2);
1319 EPUserAppRolesRequest mockEpAppRolesRequestData = new EPUserAppRolesRequest();
1320 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEpAppRolesRequestData, null);
1321 final Map<String, Long> params = new HashMap<>();
1322 params.put("appId", appWithRolesForUser.appId);
1323 params.put("appRoleId", roleInAppForUser.roleId);
1324 Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
1325 .thenReturn(epUserAppRolesList);
1326 params.put("appRoleId", roleInAppForUser2.roleId);
1327 Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
1328 .thenReturn(epUserAppRolesList2);
1329 EPUserAppRolesRequestDetail mockEPAppRoleDetail = new EPUserAppRolesRequestDetail();
1330 Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEPAppRoleDetail, null);
1331 FieldsValidator expected = new FieldsValidator();
1332 expected.setHttpStatusCode(Long.valueOf(HttpServletResponse.SC_OK));
1333 FieldsValidator actual = userRolesCommonServiceImpl.putUserAppRolesRequest(appWithRolesForUser, user);
1334 assertEquals(expected, actual);
1338 public void importRolesFromRemoteApplicationTest() throws HTTPException {
1339 EPApp mockApp = mockApp();
1341 mockApp.setEnabled(true);
1342 mockApp.setCentralAuth(false);
1343 List<EPRole> expected = new ArrayList<>();
1344 EPRole epRole = new EPRole();
1345 epRole.setAppId(mockApp.getId());
1346 epRole.setActive(true);
1348 epRole.setName("test1");
1349 EPRole epRole2 = new EPRole();
1350 epRole2.setAppId(mockApp.getId());
1351 epRole2.setActive(true);
1353 epRole2.setName("test2");
1354 expected.add(epRole);
1355 expected.add(epRole2);
1356 EPRole[] epRoleArray = expected.toArray(new EPRole[expected.size()]);
1357 Mockito.when(applicationsRestClientService.get(EPRole[].class, mockApp.getId(), "/rolesFull"))
1358 .thenReturn(epRoleArray);
1359 Mockito.when(epRoleServiceImpl.getRole(mockApp.getId(), epRole.getId())).thenReturn(epRole);
1360 Mockito.when(epRoleServiceImpl.getRole(mockApp.getId(), epRole2.getId())).thenReturn(epRole2);
1361 List<EPRole> actual = userRolesCommonServiceImpl.importRolesFromRemoteApplication(mockApp.getId());
1362 assertEquals(expected.size(), actual.size());
1365 @SuppressWarnings("deprecation")
1367 public void getCachedAppRolesForUserTest() {
1368 EPApp mockApp = mockApp();
1370 mockApp.setEnabled(true);
1371 mockApp.setCentralAuth(false);
1372 EPUser user = mockUser.mockEPUser();
1373 List<EPUserApp> expected = new ArrayList<>();
1374 EPUserApp epUserApp = new EPUserApp();
1375 EPRole epRole = new EPRole();
1376 epRole.setAppId(mockApp.getId());
1377 epRole.setActive(true);
1379 epRole.setName("test1");
1380 epUserApp.setApp(mockApp);
1381 epUserApp.setRole(epRole);
1382 epUserApp.setUserId(user.getId());
1383 expected.add(epUserApp);
1384 String filter = " where user_id = " + Long.toString(user.getId()) + " and app_id = "
1385 + Long.toString(mockApp.getId());
1386 Mockito.when(dataAccessService.getList(EPUserApp.class, filter, null, null)).thenReturn(expected);
1387 List<EPUserApp> actual = userRolesCommonServiceImpl.getCachedAppRolesForUser(mockApp.getId(), user.getId());
1388 assertEquals(expected.size(), actual.size());
1391 @SuppressWarnings("unchecked")
1393 public void getUserAppCatalogRolesTest() {
1394 EPApp mockApp = mockApp();
1396 mockApp.setEnabled(true);
1397 mockApp.setCentralAuth(false);
1398 EPUser user = mockUser.mockEPUser();
1399 List<EPUserAppCatalogRoles> expected = new ArrayList<>();
1400 EPUserAppCatalogRoles epUserAppCatalogRoles = new EPUserAppCatalogRoles();
1401 epUserAppCatalogRoles.setAppId(mockApp.getId());
1402 epUserAppCatalogRoles.setId(2l);
1403 epUserAppCatalogRoles.setRequestedRoleId(10l);
1404 epUserAppCatalogRoles.setRequestStatus("S");
1405 epUserAppCatalogRoles.setRolename("test1");
1406 expected.add(epUserAppCatalogRoles);
1407 Map<String, String> params = new HashMap<>();
1408 params.put("userid", user.getId().toString());
1409 params.put("appName", mockApp.getName());
1411 (List<EPUserAppCatalogRoles>) dataAccessService.executeNamedQuery("userAppCatalogRoles", params, null))
1412 .thenReturn(expected);
1413 List<EPUserAppCatalogRoles> actual = userRolesCommonServiceImpl.getUserAppCatalogRoles(user, mockApp.getName());
1414 assertEquals(expected.size(), actual.size());
1418 public void getExternalRequestAccessTest() {
1419 ExternalSystemAccess expected = new ExternalSystemAccess("external_access_enable", false);
1420 ExternalSystemAccess actual = userRolesCommonServiceImpl.getExternalRequestAccess();
1421 assertEquals(expected, actual);
1425 public void getEPUserAppListTest() {
1426 EPApp mockApp = mockApp();
1428 mockApp.setEnabled(true);
1429 mockApp.setCentralAuth(false);
1430 EPUser user = mockUser.mockEPUser();
1431 List<EPUserApp> expected = new ArrayList<>();
1432 EPUserApp epUserApp = new EPUserApp();
1433 EPRole epRole = new EPRole();
1434 epRole.setAppId(mockApp.getId());
1435 epRole.setActive(true);
1437 epRole.setName("test1");
1438 epUserApp.setApp(mockApp);
1439 epUserApp.setRole(epRole);
1440 epUserApp.setUserId(user.getId());
1441 expected.add(epUserApp);
1442 final Map<String, Long> params = new HashMap<>();
1443 params.put("appId", mockApp.getId());
1444 params.put("userId", user.getId());
1445 params.put("roleId", epRole.getId());
1446 Mockito.when(dataAccessService.executeNamedQuery("getUserRoleOnUserIdAndRoleIdAndAppId", params, null))
1447 .thenReturn(expected);
1448 List<EPUserApp> actual = userRolesCommonServiceImpl.getEPUserAppList(mockApp.getId(), user.getId(),
1450 assertEquals(expected.size(), actual.size());
1454 public void updateRemoteUserProfileTest() {
1455 EPApp mockApp = mockApp();
1456 EPApp mockApp2 = mockApp();
1458 mockApp.setEnabled(true);
1459 mockApp.setCentralAuth(false);
1460 EPUser user = mockUser.mockEPUser();
1461 List<EPApp> mockEpAppList = new ArrayList<>();
1462 mockEpAppList.add(mockApp);
1463 mockEpAppList.add(mockApp2);
1464 Mockito.when(searchServiceImpl.searchUserByUserId(user.getOrgUserId())).thenReturn(user);
1465 Mockito.when(epAppCommonServiceImpl.getUserRemoteApps(user.getId().toString())).thenReturn(mockEpAppList);
1466 String expected = "success";
1467 String actual = userRolesCommonServiceImpl.updateRemoteUserProfile(user.getOrgUserId(), mockApp.getId());
1468 assertEquals(expected, actual);