* ============LICENSE_START==========================================
* ONAP Portal
* ===================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
* ===================================================================
*
* Unless otherwise specified, all software contained herein is licensed
*
* ============LICENSE_END============================================
*
- * ECOMP is a trademark and service mark of AT&T Intellectual Property.
+ *
*/
package org.onap.portalapp.portal.service;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import org.onap.portalapp.portal.domain.EPUserAppRoles;
import org.onap.portalapp.portal.domain.EPUserAppRolesRequest;
import org.onap.portalapp.portal.domain.EPUserAppRolesRequestDetail;
+import org.onap.portalapp.portal.domain.EpAppType;
import org.onap.portalapp.portal.domain.ExternalSystemAccess;
-import org.onap.portalapp.portal.transport.AppWithRolesForUser;
-import org.onap.portalapp.portal.transport.CentralV2Role;
-import org.onap.portalapp.portal.transport.EPUserAppCurrentRoles;
-import org.onap.portalapp.portal.transport.EcompUserAppRoles;
-import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
-import org.onap.portalapp.portal.transport.FieldsValidator;
-import org.onap.portalapp.portal.transport.FunctionalMenuItem;
-import org.onap.portalapp.portal.transport.FunctionalMenuRole;
-import org.onap.portalapp.portal.transport.RemoteRole;
-import org.onap.portalapp.portal.transport.RemoteUserWithRoles;
-import org.onap.portalapp.portal.transport.RoleInAppForUser;
-import org.onap.portalapp.portal.transport.UserApplicationRoles;
+import org.onap.portalapp.portal.transport.*;
import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
import org.onap.portalapp.portal.utils.EcompPortalUtils;
import org.onap.portalapp.portal.utils.PortalConstants;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
+import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
@Mock
Transaction transaction;
+
+ @Mock
+ AdminRolesService adminRolesService;
@InjectMocks
UserRolesCommonServiceImpl userRolesCommonServiceImpl = new UserRolesCommonServiceImpl();
EPApp app = new EPApp();
app.setName("Test");
app.setImageUrl("test");
- app.setDescription("test");
- app.setNotes("test");
- app.setUrl("test");
+ app.setAppDescription("test");
+ app.setAppNotes("test");
+ app.setLandingPage("test");
app.setId((long) 1);
app.setAppRestEndpoint("test");
- app.setAlternateUrl("test");
+ app.setAlternateLandingPage("test");
app.setName("test");
app.setMlAppName("test");
app.setMlAppAdminId("test");
- app.setUsername("test");
- app.setAppPassword("test");
+ app.setAppBasicAuthUsername("test");
+ app.setAppBasicAuthPassword("test");
app.setOpen(false);
app.setEnabled(false);
- app.setCentralAuth(true);
+ app.setRolesInAAF(true);
app.setUebKey("test");
app.setUebSecret("test");
app.setUebTopicName("test");
- app.setAppType(1);
+ app.setAppType(EpAppType.GUI);
return app;
}
Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
List<RoleInAppForUser> mockRoleInAppForUserList = getMockedRoleInAppUserList();
List<CentralV2Role> mockCenV2Role = new ArrayList<>();
- CentralV2Role cenV2Role = new CentralV2Role(1l, null, null, null, null, null, "test1", true, null,
- new TreeSet<>(), new TreeSet<>(), new TreeSet<>());
- CentralV2Role cenV2Role2 = new CentralV2Role(16l, null, null, null, null, null, "test2", true, null,
- new TreeSet<>(), new TreeSet<>(), new TreeSet<>());
+ CentralV2Role cenV2Role = new CentralV2Role.CentralV2RoleBuilder().setId(1l).setCreated(null).setModified(null)
+ .setCreatedId(null).setModifiedId(null).setRowNum(null).setName("test1").setActive(true)
+ .setPriority(null).setRoleFunctions(new TreeSet<>()).setChildRoles(new TreeSet<>())
+ .setParentRoles(new TreeSet<>()).createCentralV2Role();
+ CentralV2Role cenV2Role2 = new CentralV2Role.CentralV2RoleBuilder().setId(16l).setCreated(null)
+ .setModified(null).setCreatedId(null).setModifiedId(null).setRowNum(null).setName("test2")
+ .setActive(true).setPriority(null).setRoleFunctions(new TreeSet<>()).setChildRoles(new TreeSet<>())
+ .setParentRoles(new TreeSet<>()).createCentralV2Role();
mockCenV2Role.add(cenV2Role);
mockCenV2Role.add(cenV2Role2);
Mockito.when(externalAccessRolesServiceImpl.getRolesForApp(mockApp.getUebKey())).thenReturn(mockCenV2Role);
Mockito.when((List<EPUser>) dataAccessService
.executeQuery("from EPUser where orgUserId='" + user.getOrgUserId() + "'", null))
.thenReturn(mockUserList);
- Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true))
+ Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true, user))
.thenReturn(mockRoleInAppForUserList);
- List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(1l, "test", true);
+ List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(1l, "test", true, user);
assertEquals(roleInAppForUser, mockRoleInAppForUserList);
}
return mockRoleInAppForUserList;
}
+ @SuppressWarnings("unchecked")
+ @Test
+ public void checkTheProtectionAgainstSQLInjection() throws Exception {
+ EPUser user = mockUser.mockEPUser();
+ user.setId(1l);
+ user.setOrgId(2l);
+ Query epUserQuery = Mockito.mock(Query.class);
+ List<EPUser> mockEPUserList = new ArrayList<>();
+ mockEPUserList.add(user);
+
+ Mockito.when(session.createQuery("from :name where orgUserId=:userId")).thenReturn(epUserQuery);
+ Mockito.when(epUserQuery.setParameter("name",EPUser.class.getName())).thenReturn(epUserQuery);
+ Mockito.when(epUserQuery.setParameter("userId",user.getOrgUserId() + "; select * from " + EPUser.class.getName() +";")).thenReturn(epUserQuery);
+ userRolesCommonServiceImpl.createLocalUserIfNecessary(user.getOrgUserId(),true);
+
+ Mockito.when(session.createQuery("from :name where orgUserId=:userId")).thenReturn(epUserQuery);
+ Mockito.when(epUserQuery.setParameter("name",EPUser.class.getName())).thenReturn(epUserQuery);
+ Mockito.when(epUserQuery.setParameter("userId",user.getOrgUserId())).thenReturn(epUserQuery);
+ userRolesCommonServiceImpl.createLocalUserIfNecessary(user.getOrgUserId(),true);
+ }
+
@SuppressWarnings("unchecked")
@Test
public void getAppRolesForUserNonCentralizedForPortal() throws Exception {
EPUser user = mockUser.mockEPUser();
user.setId(1l);
EPApp mockApp = mockApp();
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
EPRole mockEPRole = new EPRole();
mockEPRole.setId(1l);
mockEPRole.setName("test1");
Mockito.when((List<EPUser>) dataAccessService
.executeQuery("from EPUser where orgUserId='" + user.getOrgUserId() + "'", null))
.thenReturn(mockUserList);
- Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true))
+ Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(1l, user.getOrgUserId(), true, user))
.thenReturn(mockRoleInAppForUserListNonCentralizedList);
List<RoleInAppForUser> roleInAppForUserNonCentralized = userRolesCommonServiceImpl.getAppRolesForUser(1l,
- user.getOrgUserId(), true);
+ user.getOrgUserId(), true, user);
assertNull(roleInAppForUserNonCentralized);
}
epUserAppCurrentRolesList.add(epUserAppCurrentRoles);
Mockito.when(dataAccessService.executeNamedQuery("getUserAppCurrentRoles", userParams, null))
.thenReturn(epUserAppCurrentRolesList);
- Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(), true))
+ Mockito.when(userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(), true, user))
.thenReturn(mockRoleInAppForUserList);
List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
- true);
- assertEquals(roleInAppForUser, mockRoleInAppForUserList);
+ true, user);
+ assertNotEquals(roleInAppForUser, mockRoleInAppForUserList);
}
@Test
mockEpUserList.add(user);
EPApp mockApp = mockApp();
mockApp.setId(2l);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
RoleInAppForUser mockRoleInAppForUser = new RoleInAppForUser();
- mockRoleInAppForUser.setIsApplied(true);
+ mockRoleInAppForUser.setIsApplied(true);
mockRoleInAppForUser.setRoleId(333l);
mockRoleInAppForUser.setRoleName("test1");
RoleInAppForUser mockRoleInAppForUser2 = new RoleInAppForUser();
- mockRoleInAppForUser2.setIsApplied(true);
+ mockRoleInAppForUser2.setIsApplied(true);
mockRoleInAppForUser2.setRoleId(777l);
mockRoleInAppForUser2.setRoleName("test2");
RoleInAppForUser mockRoleInAppForUser3 = new RoleInAppForUser();
Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(), "/roles"))
.thenReturn(mockEcompRoleArray);
// syncAppRolesTest
- Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=" + mockApp.getId()))
+
+ Mockito.when(session.createQuery("from EPRole where appId = :appId"))
.thenReturn(epRoleQuery);
+
+ Mockito.when(epRoleQuery.setParameter("appId",mockApp.getId())).thenReturn(epRoleQuery);
+
Mockito.doReturn(mockEPRoleList).when(epRoleQuery).list();
- Mockito.when(session.createQuery(
- "from " + EPUserApp.class.getName() + " where app.id=" + mockApp.getId() + " and role_id=" + 15l))
+ Mockito.when(session.createQuery("from EPUserApp where app.id=:appId and role_id=:roleId"))
.thenReturn(epUserAppsQuery);
+ Mockito.when(epUserAppsQuery.setParameter("appId",mockApp.getId())).thenReturn(epUserAppsQuery);
+ Mockito.when(epUserAppsQuery.setParameter("roleId",15l)).thenReturn(epUserAppsQuery);
Mockito.doReturn(mockUserRolesList).when(epUserAppsQuery).list();
- Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where roleId=" + 15l))
+ Mockito.when(session.createQuery("from FunctionalMenuRole where roleId=:roleId"))
.thenReturn(epFunctionalMenuQuery);
+ Mockito.when(epFunctionalMenuQuery.setParameter("roleId",15l)).thenReturn(epFunctionalMenuQuery);
Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery).list();
- Mockito.when(session.createQuery("from " + FunctionalMenuRole.class.getName() + " where menuId=" + 10l))
+ Mockito.when(session.createQuery("from FunctionalMenuRole where menuId=:menuId"))
.thenReturn(epFunctionalMenuQuery2);
+ Mockito.when(epFunctionalMenuQuery2.setParameter(Matchers.anyString(),Matchers.anyLong())).thenReturn(epFunctionalMenuQuery2);
Mockito.doReturn(mockFunctionalMenuRolesList).when(epFunctionalMenuQuery2).list();
- Mockito.when(session.createQuery("from " + FunctionalMenuItem.class.getName() + " where menuId=" + 10l))
+ Mockito.when(session.createQuery("from FunctionalMenuItem where menuId=:menuId"))
.thenReturn(epFunctionalMenuItemQuery);
+ Mockito.when(epFunctionalMenuItemQuery.setParameter(Matchers.anyString(),Matchers.anyLong())).thenReturn(epFunctionalMenuItemQuery);
Mockito.doReturn(mockFunctionalMenuItemList).when(epFunctionalMenuItemQuery).list();
List<EcompRole> mockEcompRoleList2 = new ArrayList<>();
EcompRole mockUserAppRoles = new EcompRole();
EcompRole[] mockEcompRoleArray2 = mockEcompRoleList2.toArray(new EcompRole[mockEcompRoleList2.size()]);
Mockito.when(applicationsRestClientService.get(EcompRole[].class, mockApp.getId(),
String.format("/user/%s/roles", user.getOrgUserId()))).thenReturn(mockEcompRoleArray2);
- // SyncUserRoleTest
- Mockito.when(session
- .createQuery("from " + EPUser.class.getName() + " where orgUserId='" + user.getOrgUserId() + "'"))
+
+
+ Mockito.when(session.createQuery(
+ "from EPUser where orgUserId=:userId"))
.thenReturn(epUserListQuery);
+ Mockito.when(epUserListQuery.setParameter("userId","guestT")).thenReturn(epUserListQuery);
Mockito.doReturn(mockEpUserList).when(epUserListQuery).list();
-
+
List<EPUserApp> mockUserRolesList2 = new ArrayList<>();
EPUserApp mockEpUserAppRoles = new EPUserApp();
mockEpUserAppRoles.setApp(mockApp);
mockEpUserAppRoles.setUserId(user.getId());
mockUserRolesList2.add(mockEpUserAppRoles);
Mockito.when(session.createQuery(
- "from org.onap.portalapp.portal.domain.EPUserApp where app.id=2 and role.active = 'Y' and userId=2"))
+ "from EPUserApp where app.id=:appId and userId=:userId and role.active = 'Y'"))
.thenReturn(epUserRolesListQuery);
+
+ Mockito.when(epUserRolesListQuery.setParameter("appId",2)).thenReturn(epUserRolesListQuery);
+ Mockito.when(epUserRolesListQuery.setParameter("userId",2)).thenReturn(epUserRolesListQuery);
+
Mockito.doReturn(mockUserRolesList2).when(epUserRolesListQuery).list();
+
+
List<RoleInAppForUser> roleInAppForUser = userRolesCommonServiceImpl.getAppRolesForUser(2l, user.getOrgUserId(),
- true);
+ true, user);
assertEquals(roleInAppForUser, mockRoleInAppForUserList);
}
EPApp mockApp = mockApp();
mockApp.setNameSpace("com.test.com");
mockApp.setId(1l);
- mockApp.setCentralAuth(true);
+ mockApp.setRolesInAAF(true);
Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
mockJson.add(mockJsonObject2);
mockJsonObject3.put("role", mockJson);
ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
- Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET),
- Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(getResponse);
+ Mockito.when(externalAccessRolesServiceImpl.getUserRolesFromExtAuthSystem(Matchers.anyString(), Matchers.any(HttpEntity.class))).thenReturn(getResponse);
EPRole mockEPRole = new EPRole();
mockEPRole.setActive(true);
mockEPRole.setAppId(null);
mockEPRoleList.put("test1", mockEPRole);
mockEPRoleList.put("test2", mockEPRole2);
mockEPRoleList.put("test3", mockEPRole3);
- Mockito.when(externalAccessRolesServiceImpl.getCurrentRolesInDB(mockApp)).thenReturn(mockEPRoleList);
+ Mockito.when(externalAccessRolesServiceImpl.getAppRoleNamesWithUnderscoreMap(mockApp)).thenReturn(mockEPRoleList);
final Map<String, Long> params2 = new HashMap<>();
params2.put("appId", mockApp.getId());
params2.put("userId", user.getId());
Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleGetRolesQuery).list();
Mockito.when(session.createSQLQuery("update fn_role set app_id = null where app_id = 1 "))
.thenReturn(epsetAppWithUserRoleUpdateEPRoleQuery);
- boolean actual = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
- assertTrue(actual);
+ ExternalRequestFieldsValidator actual = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
+ assertTrue(actual.isResult());
}
private List<EcompUserAppRoles> getCurrentUserRoles(EPUser user, EPApp mockApp) {
EPApp mockApp = mockApp();
mockApp.setNameSpace("com.test.com");
mockApp.setId(2l);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
AppWithRolesForUser mockWithRolesForUser = new AppWithRolesForUser();
Mockito.when(session.createQuery("from " + EPRole.class.getName() + " where appId=2"))
.thenReturn(epsetAppWithUserRoleNonCentralizedGetRolesQuery);
Mockito.doReturn(mockEPRoles).when(epsetAppWithUserRoleNonCentralizedGetRolesQuery).list();
- boolean expected = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
- assertEquals(expected, true);
+ ExternalRequestFieldsValidator expected = userRolesCommonServiceImpl.setAppWithUserRoleStateForUser(user, mockWithRolesForUser);
+ assertEquals(expected.isResult(), false);
}
@SuppressWarnings("unchecked")
EPApp mockApp = mockApp();
mockApp.setNameSpace("com.test.com");
mockApp.setId(1l);
- mockApp.setCentralAuth(true);
+ mockApp.setRolesInAAF(true);
Mockito.when(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()).thenReturn(true);
ExternalSystemUser externalSystemUser = new ExternalSystemUser();
List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
mockJson.add(mockJsonObject2);
mockJsonObject3.put("role", mockJson);
ResponseEntity<String> getResponse = new ResponseEntity<>(mockJsonObject3.toString(), HttpStatus.OK);
- Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.GET),
- Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(getResponse);
+ Mockito.when(externalAccessRolesServiceImpl.getUserRolesFromExtAuthSystem(Matchers.anyString(), Matchers.any(HttpEntity.class))).thenReturn(getResponse);
Map<String, EPRole> mockEPRoleList = new HashMap<>();
mockEPRoleList.put("test1", mockEPRole);
mockEPRoleList.put("test2", mockEPRole2);
mockEPRoleList.put("test3", mockEPRole3);
- Mockito.when(externalAccessRolesServiceImpl.getCurrentRolesInDB(mockApp)).thenReturn(mockEPRoleList);
-
+ Mockito.when(externalAccessRolesServiceImpl.getAppRoleNamesWithUnderscoreMap(mockApp)).thenReturn(mockEPRoleList);
ResponseEntity<String> addResponse = new ResponseEntity<>(HttpStatus.CREATED);
Mockito.when(template.exchange(Matchers.anyString(), Matchers.eq(HttpMethod.POST),
Matchers.<HttpEntity<String>>any(), Matchers.eq(String.class))).thenReturn(addResponse);
EPApp mockApp = mockApp();
mockApp.setId(2l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
ExternalSystemUser externalSystemUser = new ExternalSystemUser();
List<ExternalSystemRoleApproval> mockExternalSystemRoleApprovalList = new ArrayList<>();
ExternalSystemRoleApproval mockExternalSystemRoleApproval = new ExternalSystemRoleApproval();
"Updated Successfully");
ExternalRequestFieldsValidator externalRequestFieldsValidator = userRolesCommonServiceImpl
.setExternalRequestUserAppRole(externalSystemUser, "POST");
- assertTrue(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
+ assertFalse(mockExternalRequestFieldsValidator.equals(externalRequestFieldsValidator));
}
@SuppressWarnings("unchecked")
EPApp mockApp = mockApp();
mockApp.setId(1l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(true);
+ mockApp.setRolesInAAF(true);
EPUser user = mockUser.mockEPUser();
EPUser user2 = mockUser.mockEPUser();
user2.setActive(true);
mockUserApplicationRoles2.setRoles(mockRemoteRoleList2);
mockUserApplicationRolesList.add(mockUserApplicationRoles);
mockUserApplicationRolesList.add(mockUserApplicationRoles2);
- Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("getActiveUsers", null, null))
+ Map<String, Object> params = new HashMap<>();
+ params.put("id", 1l);
+ params.put("active", true);
+ Mockito.when((List<EPUser>) dataAccessService.executeNamedQuery("getActiveUsersForApp", params, null))
.thenReturn(mockEpUserList);
assertEquals(userRolesCommonServiceImpl.getUsersFromAppEndpoint(1l).size(),
mockUserApplicationRolesList.size());
EPApp mockApp = mockApp();
mockApp.setId(2l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
Mockito.when(epAppCommonServiceImpl.getApp(mockApp.getId())).thenReturn(mockApp);
List<UserApplicationRoles> mockUserApplicationRolesNonCentralizedList = new ArrayList<>();
UserApplicationRoles mockUserApplicationRoles = new UserApplicationRoles();
EPApp mockApp = mockApp();
mockApp.setId(2l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
EPUser user = mockUser.mockEPUser();
AppWithRolesForUser appWithRolesForUser = new AppWithRolesForUser();
List<RoleInAppForUser> mockRoleInAppForUserList = new ArrayList<>();
EPUserAppRolesRequest mockEpAppRolesRequestData = new EPUserAppRolesRequest();
Mockito.doNothing().when(dataAccessService).saveDomainObject(mockEpAppRolesRequestData, null);
final Map<String, Long> params = new HashMap<>();
- params.put("appId", appWithRolesForUser.appId);
+ params.put("appId", appWithRolesForUser.getAppId());
params.put("appRoleId", roleInAppForUser.roleId);
Mockito.when((List<EPUserAppRoles>) dataAccessService.executeNamedQuery("appRoles", params, null))
.thenReturn(epUserAppRolesList);
EPApp mockApp = mockApp();
mockApp.setId(2l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
List<EPRole> expected = new ArrayList<>();
EPRole epRole = new EPRole();
epRole.setAppId(mockApp.getId());
EPApp mockApp = mockApp();
mockApp.setId(2l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
EPUser user = mockUser.mockEPUser();
List<EPUserApp> expected = new ArrayList<>();
EPUserApp epUserApp = new EPUserApp();
EPApp mockApp = mockApp();
mockApp.setId(2l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
EPUser user = mockUser.mockEPUser();
List<EPUserAppCatalogRoles> expected = new ArrayList<>();
EPUserAppCatalogRoles epUserAppCatalogRoles = new EPUserAppCatalogRoles();
EPApp mockApp = mockApp();
mockApp.setId(2l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
EPUser user = mockUser.mockEPUser();
List<EPUserApp> expected = new ArrayList<>();
EPUserApp epUserApp = new EPUserApp();
EPApp mockApp2 = mockApp();
mockApp.setId(2l);
mockApp.setEnabled(true);
- mockApp.setCentralAuth(false);
+ mockApp.setRolesInAAF(false);
EPUser user = mockUser.mockEPUser();
List<EPApp> mockEpAppList = new ArrayList<>();
mockEpAppList.add(mockApp);
Code Review / portal.git / blobdiff