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