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