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