ecomp-portal-BE-common/src/test/java/org/onap/portalapp/portal/controller/ExternalAccessRolesControllerTest.java

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   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
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  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.
  20  *
  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
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  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.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  *
  37  */
  38 package org.onap.portalapp.portal.controller;
  39
  40 import static org.junit.Assert.assertEquals;
  41 import static org.junit.Assert.assertNull;
  42
  43 import java.io.PrintWriter;
  44 import java.io.StringWriter;
  45 import java.util.ArrayList;
  46 import java.util.HashMap;
  47 import java.util.List;
  48 import java.util.Map;
  49
  50 import javax.servlet.http.HttpServletRequest;
  51 import javax.servlet.http.HttpServletResponse;
  52
  53 import org.json.JSONObject;
  54 import org.junit.Before;
  55 import org.junit.Test;
  56 import org.junit.runner.RunWith;
  57 import org.mockito.InjectMocks;
  58 import org.mockito.Matchers;
  59 import org.mockito.Mock;
  60 import org.mockito.Mockito;
  61 import org.mockito.MockitoAnnotations;
  62 import org.onap.portalapp.portal.core.MockEPUser;
  63 import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
  64 import org.onap.portalapp.portal.domain.EPApp;
  65 import org.onap.portalapp.portal.domain.EPUser;
  66 import org.onap.portalapp.portal.domain.EpAppType;
  67 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
  68 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  69 import org.onap.portalapp.portal.framework.MockitoTestSuite;
  70 import org.onap.portalapp.portal.service.ExternalAccessRolesService;
  71 import org.onap.portalapp.portal.service.ExternalAccessRolesServiceImpl;
  72 import org.onap.portalapp.portal.transport.*;
  73 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
  74 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  75 import org.onap.portalapp.portal.utils.PortalConstants;
  76 import org.onap.portalsdk.core.domain.AuditLog;
  77 import org.onap.portalsdk.core.domain.Role;
  78 import org.onap.portalsdk.core.domain.User;
  79 import org.onap.portalsdk.core.restful.domain.EcompRole;
  80 import org.onap.portalsdk.core.restful.domain.EcompUser;
  81 import org.onap.portalsdk.core.service.AuditService;
  82 import org.onap.portalsdk.core.service.UserService;
  83 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
  84 import org.onap.portalsdk.core.util.SystemProperties;
  85 import org.powermock.api.mockito.PowerMockito;
  86 import org.powermock.core.classloader.annotations.PrepareForTest;
  87 import org.powermock.modules.junit4.PowerMockRunner;
  88 import org.springframework.http.HttpStatus;
  89 import org.springframework.http.ResponseEntity;
  90 import org.springframework.web.client.HttpClientErrorException;
  91
  92 import com.fasterxml.jackson.core.JsonProcessingException;
  93 import com.fasterxml.jackson.databind.DeserializationFeature;
  94 import com.fasterxml.jackson.databind.ObjectMapper;
  95
  96 @RunWith(PowerMockRunner.class)
  97 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
  98                 EPCommonSystemProperties.class })
  99 public class ExternalAccessRolesControllerTest {
 100         @Mock
 101         ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
 102         @InjectMocks
 103         ExternalAccessRolesController externalAccessRolesController;
 104         @Mock
 105         UserService userservice = new UserServiceCentalizedImpl();
 106         @Mock
 107         AuditService auditService;
 108
 109         @Before
 110         public void setup() {
 111                 MockitoAnnotations.initMocks(this);
 112         }
 113
 114         @Mock
 115         AuditLog auditLog = new AuditLog();
 116         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
 117         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
 118         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
 119         NullPointerException nullPointerException = new NullPointerException();
 120         HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
 121         MockEPUser mockUser = new MockEPUser();
 122         String loginId = "guestT";
 123         String uebKey = "testUebKey";
 124
 125         public EPApp mockApp() {
 126                 EPApp app = new EPApp();
 127                 app.setName("Test");
 128                 app.setImageUrl("test");
 129                 app.setAppDescription("test");
 130                 app.setAppNotes("test");
 131                 app.setLandingPage("test");
 132                 app.setId((long) 1);
 133                 app.setAppRestEndpoint("test");
 134                 app.setAlternateLandingPage("test");
 135                 app.setName("test");
 136                 app.setMlAppName("test");
 137                 app.setMlAppAdminId("test");
 138                 app.setAppBasicAuthUsername("test");
 139                 app.setAppBasicAuthPassword("test");
 140                 app.setOpen(false);
 141                 app.setEnabled(false);
 142                 app.setUebKey("test");
 143                 app.setUebSecret("test");
 144                 app.setUebTopicName("test");
 145                 app.setAppType(EpAppType.GUI);
 146                 return app;
 147         }
 148
 149         @Test
 150         public void getUserTest() throws Exception {
 151         CentralUser expectedCentralUser =
 152                 new CentralUser.CentralUserBuilder().setId(null).setCreated(null).setModified(null).setCreatedId(null)
 153                         .setModifiedId(null).setRowNum(null).setOrgId(null).setManagerId(null).setFirstName(loginId)
 154                         .setMiddleInitial(loginId).setLastName(loginId).setPhone(loginId).setFax(loginId)
 155                         .setCellular(loginId).setEmail(loginId).setAddressId(null).setAlertMethodCd(loginId)
 156                         .setHrid(loginId).setOrgUserId(loginId).setOrgCode(loginId).setAddress1(loginId)
 157                         .setAddress2(loginId).setCity(loginId).setState(loginId).setZipCode(loginId).setCountry(loginId)
 158                         .setOrgManagerUserId(loginId).setLocationClli(loginId).setBusinessCountryCode(loginId)
 159                         .setBusinessCountryName(loginId).setBusinessUnit(loginId).setBusinessUnitName(loginId)
 160                         .setDepartment(loginId).setDepartmentName(loginId).setCompanyCode(loginId).setCompany(loginId)
 161                         .setZipCodeSuffix(loginId).setJobTitle(loginId).setCommandChain(loginId).setSiloStatus(loginId)
 162                         .setCostCenter(loginId).setFinancialLocCode(loginId).setLoginId(loginId).setLoginPwd(loginId)
 163                         .setLastLoginDate(null).setActive(false).setInternal(false).setSelectedProfileId(null)
 164                         .setTimeZoneId(null).setOnline(false).setChatId(loginId).setUserApps(null).createCentralUser();
 165                 String loginId = "test";
 166                 StringWriter sw = new StringWriter();
 167                 PrintWriter writer = new PrintWriter(sw);
 168                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 169                 EPApp app = mockApp();
 170                 app.setRolesInAAF(true);
 171                 List<EPApp> appList = new ArrayList<>();
 172                 appList.add(app);
 173                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 174                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 175                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 176                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 177                 Mockito.when(externalAccessRolesService.getUserRoles(loginId, mockedRequest.getHeader("uebkey")))
 178                                 .thenReturn(expectedCentralUser);
 179                 CentralUser actualCentralUser = externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 180                 assertEquals(actualCentralUser.isActive(), expectedCentralUser.isActive());
 181         }
 182
 183         @Test
 184         public void getUserExceptionTest() throws Exception {
 185                 String reason = getInvalidKeyJson();
 186                 StringWriter sw = new StringWriter();
 187                 PrintWriter writer = new PrintWriter(sw);
 188                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 189                 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 190                 String result = sw.getBuffer().toString().trim();
 191                 assertEquals(reason, result);
 192         }
 193
 194         @Test
 195         public void getUserXSSTest() throws Exception {
 196                 String loginId = "<script ~~~>alert(0%0)</script ~~~>";
 197                 String expected = getXSSKeyJson();
 198                 StringWriter sw = new StringWriter();
 199                 PrintWriter writer = new PrintWriter(sw);
 200                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 201                 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 202                 String actual = sw.getBuffer().toString().trim();
 203                 assertEquals(expected, actual);
 204                 }
 205
 206         @Test
 207         public void getV2UserListTest() throws Exception {
 208                 String expectedCentralUser = "test";
 209                 String loginId = "test";
 210                 EPApp app = mockApp();
 211                 app.setRolesInAAF(true);
 212                 List<EPApp> appList = new ArrayList<>();
 213                 appList.add(app);
 214                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 215                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 216                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 217                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 218                 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
 219                                 .thenReturn(expectedCentralUser);
 220                 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
 221                 assertEquals(actualString, expectedCentralUser);
 222         }
 223
 224         @Test(expected = NullPointerException.class)
 225         public void getV2UserListExceptionTest() throws Exception {
 226                 String expectedCentralUser = null;
 227                 String loginId = "test";
 228                 EPApp app = mockApp();
 229                 app.setRolesInAAF(true);
 230                 List<EPApp> appList = new ArrayList<>();
 231                 appList.add(app);
 232                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 233                 ResponseEntity<String> response = null;
 234                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 235                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 236                 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
 237                                 .thenReturn(expectedCentralUser);
 238                 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
 239                 assertEquals(actualString, expectedCentralUser);
 240         }
 241
 242         @Test
 243         public void getRolesForAppCentralRoleTest() throws Exception {
 244                 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
 245                 List<EPApp> applicationList = new ArrayList<>();
 246                 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
 247                 List<CentralRole> centralRoleList = new ArrayList<>();
 248                 EPApp app = mockApp();
 249                 app.setRolesInAAF(true);
 250                 applicationList.add(app);
 251                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 252                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 253                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 254                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 255                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 256                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
 257                                 .thenReturn(centralV2RoleList);
 258                 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
 259                                 .thenReturn(centralRoleList);
 260                 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
 261                                 mockedResponse);
 262                 assertEquals(actualCentralRoleList.size(), expectedCentralRoleList.size());
 263         }
 264
 265         @Test(expected = NullPointerException.class)
 266         public void getRolesForAppCentralRoleExceptionTest() throws Exception {
 267                 List<EPApp> applicationList = new ArrayList<>();
 268                 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
 269                 List<CentralRole> centralRoleList = new ArrayList<>();
 270                 EPApp app = mockApp();
 271                 app.setRolesInAAF(true);
 272                 applicationList.add(app);
 273                 ResponseEntity<String> response = null;
 274                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 275                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 276                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 277                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 278                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
 279                                 .thenReturn(centralV2RoleList);
 280                 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
 281                                 .thenReturn(centralRoleList);
 282                 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
 283                                 mockedResponse);
 284                 assertEquals(null, actualCentralRoleList);
 285         }
 286
 287         @Test
 288         public void getV2RolesForAppTest() throws Exception {
 289                 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
 290                 List<EPApp> applicationList = new ArrayList<>();
 291                 List<CentralV2Role> centralV2Role = new ArrayList<>();
 292                 EPApp app = mockApp();
 293                 app.setRolesInAAF(true);
 294                 applicationList.add(app);
 295                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 296                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 297                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 298                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 299                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 300                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
 301                                 .thenReturn(centralV2Role);
 302                 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
 303                                 mockedResponse);
 304                 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
 305         }
 306
 307         @Test(expected = NullPointerException.class)
 308         public void getV2RolesForAppExceptionTest() throws Exception {
 309                 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
 310                 List<EPApp> applicationList = new ArrayList<>();
 311                 List<CentralV2Role> centralV2Role = new ArrayList<>();
 312                 EPApp app = mockApp();
 313                 app.setRolesInAAF(true);
 314                 applicationList.add(app);
 315                 ResponseEntity<String> response = null;
 316                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 317                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 318                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 319                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 320                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
 321                                 .thenReturn(centralV2Role);
 322                 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
 323                                 mockedResponse);
 324                 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
 325         }
 326
 327         @Test(expected = NullPointerException.class)
 328         public void getRolesForAppTest() throws Exception {
 329                 List<EPApp> applicationList = new ArrayList<>();
 330                 List<CentralV2Role> answer = new ArrayList<>();
 331                 EPApp app = mockApp();
 332                 applicationList.add(app);
 333                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 334                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 335                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
 336                 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
 337         }
 338
 339         @Test(expected = NullPointerException.class)
 340         public void getRolesForAppExceptionTest() throws Exception {
 341                 List<EPApp> applicationList = new ArrayList<>();
 342                 EPApp app = mockApp();
 343                 applicationList.add(app);
 344                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 345                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 346                 externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
 347                 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
 348                 assertEquals(null, role);
 349         }
 350
 351         @Test
 352         public void getRoleFunctionsListTest() throws Exception {
 353                 List<CentralRole> expectedCentralRoleList = new ArrayList<>();
 354                 List<CentralRoleFunction> roleFuncList = new ArrayList<>();
 355                 List<EPApp> applicationList = new ArrayList<>();
 356                 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
 357                 EPApp app = mockApp();
 358                 app.setRolesInAAF(true);
 359                 applicationList.add(app);
 360                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 361                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 362                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 363                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 364                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 365                 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
 366                                 .thenReturn(centralV2RoleFunction);
 367                 Mockito.when(externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(centralV2RoleFunction))
 368                                 .thenReturn(roleFuncList);
 369                 List<CentralRoleFunction> actualCentralRoleFunction = externalAccessRolesController
 370                                 .getRoleFunctionsList(mockedRequest, mockedResponse);
 371                 assertEquals(actualCentralRoleFunction.size(), expectedCentralRoleList.size());
 372         }
 373
 374         @Test
 375         public void getRoleFunctionsListExceptionTest() throws Exception {
 376                 String reason = getInvalidKeyJson();
 377                 StringWriter sw = new StringWriter();
 378                 PrintWriter writer = new PrintWriter(sw);
 379                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 380                 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
 381                 String result = sw.getBuffer().toString().trim();
 382                 assertEquals(reason, result);
 383         }
 384
 385         @Test
 386         public void getV2RoleFunctionsListTest() throws Exception {
 387                 List<CentralV2RoleFunction> expectedCentralV2RoleFunctionList = new ArrayList<>();
 388                 List<EPApp> applicationList = new ArrayList<>();
 389                 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
 390                 EPApp app = mockApp();
 391                 app.setRolesInAAF(true);
 392                 applicationList.add(app);
 393                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 394                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 395                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 396                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 397                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 398                 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
 399                                 .thenReturn(centralV2RoleFunction);
 400                 List<CentralV2RoleFunction> actualCentralV2RoleFunctionList = externalAccessRolesController
 401                                 .getV2RoleFunctionsList(mockedRequest, mockedResponse);
 402                 assertEquals(actualCentralV2RoleFunctionList.size(), expectedCentralV2RoleFunctionList.size());
 403         }
 404
 405         @Test
 406         public void getV2RoleFunctionsListExceptionTest() throws Exception {
 407                 String reason = getInvalidKeyJson();
 408                 StringWriter sw = new StringWriter();
 409                 PrintWriter writer = new PrintWriter(sw);
 410                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 411                 externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
 412                 String result = sw.getBuffer().toString().trim();
 413                 assertEquals(reason, result);
 414         }
 415
 416         @Test
 417         public void getRoleInfoValidationTest() throws Exception {
 418                 CentralRole expectedCentralRole = null;
 419                 List<EPApp> applicationList = new ArrayList<>();
 420                 long roleId = 1;
 421                 CentralV2Role centralV2Role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
 422                 EPApp app = mockApp();
 423                 app.setRolesInAAF(true);
 424                 applicationList.add(app);
 425                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 426                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 427                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 428                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 429                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
 430                                 .thenReturn(centralV2Role);
 431                 CentralRole actualCentralRole = externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse,
 432                                 roleId);
 433                 assertEquals(actualCentralRole, expectedCentralRole);
 434         }
 435
 436         @Test
 437         public void getRoleInfoTest() throws Exception {
 438                 String reason = getInvalidKeyJson();
 439                 StringWriter sw = new StringWriter();
 440                 PrintWriter writer = new PrintWriter(sw);
 441                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 442                 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
 443                 long roleId = 1;
 444                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
 445                                 .thenReturn(answer);
 446                 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
 447                 String result = sw.getBuffer().toString().trim();
 448                 assertEquals(reason, result);
 449         }
 450
 451         @Test
 452         public void getRoleInfoExceptionTest() throws Exception {
 453                 String reason = getInvalidKeyJson();
 454                 StringWriter sw = new StringWriter();
 455                 PrintWriter writer = new PrintWriter(sw);
 456                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 457                 long roleId = 1;
 458                 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
 459                 String result = sw.getBuffer().toString().trim();
 460                 assertEquals(reason, result);
 461         }
 462
 463         @Test
 464         public void getV2RoleInfoValidationTest() throws Exception {
 465                 CentralV2Role expectedCentralRole = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
 466                 expectedCentralRole.setActive(false);
 467                 List<EPApp> applicationList = new ArrayList<>();
 468                 long roleId = 1;
 469                 CentralV2Role centralV2Role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
 470                 EPApp app = mockApp();
 471                 app.setRolesInAAF(true);
 472                 applicationList.add(app);
 473                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 474                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 475                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 476                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 477                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
 478                                 .thenReturn(centralV2Role);
 479                 CentralV2Role actualCentralRole = externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse,
 480                                 roleId);
 481                 assertEquals(actualCentralRole.getActive(), expectedCentralRole.getActive());
 482         }
 483
 484         @Test
 485         public void getV2RoleInfoTest() throws Exception {
 486                 String reason = getInvalidKeyJson();
 487                 StringWriter sw = new StringWriter();
 488                 PrintWriter writer = new PrintWriter(sw);
 489                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 490                 CentralV2Role answer = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
 491                 long roleId = 1;
 492                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
 493                                 .thenReturn(answer);
 494                 externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
 495                 String result = sw.getBuffer().toString().trim();
 496                 assertEquals(reason, result);
 497         }
 498
 499         @Test
 500         public void getV2RoleInfoExceptionTest() throws Exception {
 501                 String reason = getInvalidKeyJson();
 502                 StringWriter sw = new StringWriter();
 503                 PrintWriter writer = new PrintWriter(sw);
 504                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 505                 long roleId = 1;
 506                 assertNull(externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId));
 507                 String result = sw.getBuffer().toString().trim();
 508                 assertEquals(reason, result);
 509         }
 510
 511         @Test
 512         public void getV2RoleFunctionTest() throws Exception {
 513                 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
 514                 expectedCentralV2RoleFunction.setCode("test");
 515                 List<EPApp> applicationList = new ArrayList<>();
 516                 String code = "test";
 517                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 518                 centralV2RoleFunction.setCode("test");
 519                 EPApp app = mockApp();
 520                 app.setRolesInAAF(true);
 521                 applicationList.add(app);
 522                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 523                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 524                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 525                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 526                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
 527                                 .thenReturn(centralV2RoleFunction);
 528                 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
 529                                 .getV2RoleFunction(mockedRequest, mockedResponse, code);
 530                 assertEquals(actualCentralV2RoleFunction.getCode(), expectedCentralV2RoleFunction.getCode());
 531         }
 532
 533
 534         @Test
 535         public void getV2RoleFunctionNullCheckTest() throws Exception {
 536                 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
 537                 List<EPApp> applicationList = new ArrayList<>();
 538                 String code = "test";
 539                 CentralV2RoleFunction centralV2RoleFunction = null;
 540                 EPApp app = mockApp();
 541                 app.setRolesInAAF(true);
 542                 applicationList.add(app);
 543                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 544                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 545                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 546                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 547                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
 548                                 .thenReturn(centralV2RoleFunction);
 549                 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
 550                                 .getV2RoleFunction(mockedRequest, mockedResponse, code);
 551                 assertEquals(actualCentralV2RoleFunction.getAction(), expectedCentralV2RoleFunction.getAction());
 552         }
 553
 554         @Test
 555         public void getV2RoleFunctionExceptionTest() throws Exception {
 556                 String reason = getInvalidKeyJson();
 557                 StringWriter sw = new StringWriter();
 558                 PrintWriter writer = new PrintWriter(sw);
 559                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 560                 String code = "test";
 561                 assertNull(externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code));
 562                 String result = sw.getBuffer().toString().trim();
 563                 assertEquals(reason, result);
 564         }
 565
 566         @Test
 567         public void getRoleFunctionTest() throws Exception {
 568                 EPApp mockApp = mockApp();
 569                 mockApp.setRolesInAAF(true);
 570                 List<EPApp> mockAppList = new ArrayList<>();
 571                 mockAppList.add(mockApp);
 572                 StringWriter sw = new StringWriter();
 573                 PrintWriter writer = new PrintWriter(sw);
 574                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 575                 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
 576                 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
 577                 roleFunction1.setCode("test2");
 578                 String code = "test_menu";
 579                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 580                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
 581                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 582                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
 583                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
 584                                 .thenReturn(roleFunction1);
 585                 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
 586                                 code);
 587                 assertEquals(returnedValue, roleFunction2);
 588                 String result = sw.getBuffer().toString().trim();
 589                 assertEquals("", result);
 590         }
 591
 592         @Test
 593         public void getRoleFunctionExceptionTest() throws Exception {
 594                 String reason = getInvalidKeyJson();
 595                 StringWriter sw = new StringWriter();
 596                 PrintWriter writer = new PrintWriter(sw);
 597                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 598                 String code = "test_menu";
 599                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
 600                                 .thenThrow(httpClientErrorException);
 601                 assertEquals(new CentralRoleFunction(),
 602                                 externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
 603                 String result = sw.getBuffer().toString().trim();
 604                 assertEquals(reason, result);
 605         }
 606
 607         @Test
 608         public void getRoleFunctionXSSTest() throws Exception {
 609                 String expected = getXSSKeyJson();
 610                 EPApp mockApp = mockApp();
 611                 mockApp.setRolesInAAF(true);
 612                 List<EPApp> mockAppList = new ArrayList<>();
 613                 mockAppList.add(mockApp);
 614                 StringWriter sw = new StringWriter();
 615                 PrintWriter writer = new PrintWriter(sw);
 616                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 617                 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
 618                 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
 619                 roleFunction1.setCode("test2");
 620                 String code = "<script>alert(‘XSS’)</script>";
 621                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 622                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
 623                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 624                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
 625                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
 626                         .thenReturn(roleFunction1);
 627                 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
 628                         code);
 629                 assertEquals(returnedValue, roleFunction2);
 630                 String result = sw.getBuffer().toString().trim();
 631                 assertEquals(expected, result);
 632         }
 633
 634         @Test
 635         public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
 636                 List<EPApp> applicationList = new ArrayList<>();
 637                 EPApp app = mockApp();
 638                 applicationList.add(app);
 639                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 640                 PortalRestResponse<String> portalRestResponse = null;
 641                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 642                 expectedportalRestResponse.setMessage(null);
 643                 expectedportalRestResponse.setResponse("Failed");
 644                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 645                 String data = null;
 646                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 647                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 648                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 649                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 650                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 651                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
 652                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 653                 assertEquals(portalRestResponse, expectedportalRestResponse);
 654         }
 655
 656         @Test
 657         public void saveRoleFunctionExceptionTest() throws Exception {
 658                 List<EPApp> applicationList = new ArrayList<>();
 659                 EPApp app = mockApp();
 660                 app.setRolesInAAF(true);
 661                 applicationList.add(app);
 662                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 663                 PortalRestResponse<String> portalRestResponse = null;
 664                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 665                 expectedportalRestResponse.setMessage("argument \"content\" is null");
 666                 expectedportalRestResponse.setResponse("Failed");
 667                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 668                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 669                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 670                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 671                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 672                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
 673                 assertEquals(portalRestResponse, expectedportalRestResponse);
 674         }
 675
 676         @Test
 677         public void saveRoleFunctionTest() throws Exception {
 678                 List<EPApp> applicationList = new ArrayList<>();
 679                 EPUser user = mockUser.mockEPUser();
 680                 List<EPUser> userList = new ArrayList<>();
 681                 userList.add(user);
 682                 EPApp app = mockApp();
 683                 app.setRolesInAAF(true);
 684                 applicationList.add(app);
 685                 JSONObject roleFunc = new JSONObject();
 686                 roleFunc.put("type", "test_type");
 687                 roleFunc.put("code", "test_instance");
 688                 roleFunc.put("action", "test_action");
 689                 roleFunc.put("name", "test_name");
 690                 ObjectMapper mapper = new ObjectMapper();
 691                 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 692                 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
 693                 saveRoleFunc.setAppId(app.getId());
 694                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 695                 PortalRestResponse<String> portalRestResponse = null;
 696                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 697                 expectedportalRestResponse.setMessage("Successfully saved!");
 698                 expectedportalRestResponse.setResponse("Success");
 699                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
 700                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 701                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 702                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 703                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 704                 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
 705                                 .thenReturn(null);
 706                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
 707                                 Matchers.any(EPApp.class))).thenReturn(true);
 708                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
 709                                 .thenReturn(userList);
 710                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
 711                                 .thenReturn(applicationList);
 712                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
 713                                 roleFunc.toString());
 714                 assertEquals(portalRestResponse, expectedportalRestResponse);
 715         }
 716
 717         @Test
 718         public void saveRoleFunctionXSSTest() throws Exception {
 719                 List<EPApp> applicationList = new ArrayList<>();
 720                 EPUser user = mockUser.mockEPUser();
 721                 List<EPUser> userList = new ArrayList<>();
 722                 userList.add(user);
 723                 EPApp app = mockApp();
 724                 app.setRolesInAAF(true);
 725                 applicationList.add(app);
 726                 JSONObject roleFunc = new JSONObject();
 727                 roleFunc.put("type", "<script>alert(“XSS”)</script> ");
 728                 roleFunc.put("code", "test_instance");
 729                 roleFunc.put("action", "test_action");
 730                 roleFunc.put("name", "test_name");
 731                 ObjectMapper mapper = new ObjectMapper();
 732                 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 733                 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
 734                 saveRoleFunc.setAppId(app.getId());
 735                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 736                 PortalRestResponse<String> portalRestResponse = null;
 737                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 738                 expectedportalRestResponse.setMessage("Failed to roleFunc, not valid data.");
 739                 expectedportalRestResponse.setResponse("Failed");
 740                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 741                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 742                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 743                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 744                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 745                 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
 746                         .thenReturn(null);
 747                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
 748                         Matchers.any(EPApp.class))).thenReturn(true);
 749                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
 750                         .thenReturn(userList);
 751                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
 752                         .thenReturn(applicationList);
 753                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
 754                         roleFunc.toString());
 755                 assertEquals(expectedportalRestResponse, portalRestResponse);
 756         }
 757
 758         @Test
 759         public void deleteRoleFunctionTest() throws Exception {
 760                 PowerMockito.mockStatic(EcompPortalUtils.class);
 761                 PowerMockito.mockStatic(SystemProperties.class);
 762                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 763                 PowerMockito.mockStatic(PortalConstants.class);
 764                 PortalRestResponse<String> portalRestResponse = null;
 765                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 766                 expectedportalRestResponse.setMessage("Successfully Deleted");
 767                 expectedportalRestResponse.setResponse("Success");
 768                 EPUser user = mockUser.mockEPUser();
 769                 List<EPUser> userList = new ArrayList<>();
 770                 userList.add(user);
 771                 EPApp app = mockApp();
 772                 app.setRolesInAAF(true);
 773                 List<EPApp> appList = new ArrayList<>();
 774                 appList.add(app);
 775                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
 776                 String code = "testNew";
 777                 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
 778                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 779                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 780                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 781                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 782                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
 783                 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
 784                 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
 785                 assertEquals(portalRestResponse, expectedportalRestResponse);
 786         }
 787
 788         @Test
 789         public void deleteRoleFunctionXSSTest() throws Exception {
 790                 PowerMockito.mockStatic(EcompPortalUtils.class);
 791                 PowerMockito.mockStatic(SystemProperties.class);
 792                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 793                 PowerMockito.mockStatic(PortalConstants.class);
 794                 PortalRestResponse<String> portalRestResponse = null;
 795                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 796                 expectedportalRestResponse.setMessage("Failed to deleteRoleFunction, not valid data.");
 797                 expectedportalRestResponse.setResponse("Failed");
 798                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 799                 EPUser user = mockUser.mockEPUser();
 800                 List<EPUser> userList = new ArrayList<>();
 801                 userList.add(user);
 802                 EPApp app = mockApp();
 803                 app.setRolesInAAF(true);
 804                 List<EPApp> appList = new ArrayList<>();
 805                 appList.add(app);
 806                 String code = "<script>alert(‘XSS’)</script>";
 807                 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
 808                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 809                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 810                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 811                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 812                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
 813                 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
 814                 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
 815                 assertEquals(portalRestResponse, expectedportalRestResponse);
 816         }
 817
 818         @Test
 819         public void getActiveRolesTest() throws Exception {
 820                 String reason = getInvalidKeyJson();
 821                 StringWriter sw = new StringWriter();
 822                 PrintWriter writer = new PrintWriter(sw);
 823                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 824                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
 825                 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 826                 assertNull(expectedCenRole);
 827                 String result = sw.getBuffer().toString().trim();
 828                 assertEquals(reason, result);
 829         }
 830
 831         @Test
 832         public void getActiveRolesValidationTest() throws Exception {
 833                 List<CentralRole> expectedRolesList = null;
 834                 EPApp app = mockApp();
 835                 app.setRolesInAAF(true);
 836                 List<EPApp> appList = new ArrayList<>();
 837                 appList.add(app);
 838                 List<CentralV2Role> cenRoles = new ArrayList<>();
 839                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 840                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 841                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 842                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 843                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader("uebkey"))).thenReturn(cenRoles);
 844                 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles))
 845                                 .thenReturn(expectedRolesList);
 846                 List<CentralRole> actualRolesList = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 847                 assertEquals(actualRolesList, expectedRolesList);
 848         }
 849
 850         @Test
 851         public void getActiveRolesExceptionTest() throws Exception {
 852                 String reason = getInvalidKeyJson();
 853                 StringWriter sw = new StringWriter();
 854                 PrintWriter writer = new PrintWriter(sw);
 855                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 856                 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 857                 String result = sw.getBuffer().toString().trim();
 858                 assertEquals(reason, result);
 859         }
 860
 861         /**
 862          * It return JSON string which has error information
 863          *
 864          * @return JSON String
 865          * @throws JsonProcessingException
 866          */
 867         private String getInvalidKeyJson() throws JsonProcessingException {
 868                 final Map<String, String> uebkeyResponse = new HashMap<>();
 869                 String reason = "";
 870                 ObjectMapper mapper = new ObjectMapper();
 871                 uebkeyResponse.put("error", "Invalid credentials!");
 872                 reason = mapper.writeValueAsString(uebkeyResponse);
 873                 return reason;
 874         }
 875
 876         private String getXSSKeyJson() throws JsonProcessingException {
 877                 final Map<String, String> uebkeyResponse = new HashMap<>();
 878                 String reason = "";
 879                 ObjectMapper mapper = new ObjectMapper();
 880                 uebkeyResponse.put("error", "Data is not valid");
 881                 reason = mapper.writeValueAsString(uebkeyResponse);
 882                 return reason;
 883         }
 884
 885         @Test
 886         public void deleteDependcyRoleRecordExceptionTest() {
 887                 PortalRestResponse<String> portalRestResponse = null;
 888                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 889                 expectedportalRestResponse.setMessage("Invalid credentials!");
 890                 expectedportalRestResponse.setResponse("Failed");
 891                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 892                 long roleId = 123;
 893                 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
 894                                 roleId);
 895                 assertEquals(expectedportalRestResponse, portalRestResponse);
 896         }
 897
 898         @Test
 899         public void bulkUploadFunctionsTest() throws Exception {
 900                 Integer result = 0;
 901                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 902                                 .thenReturn(result);
 903                 PortalRestResponse<String> portalRestResponse = null;
 904                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 905                 expectedportalRestResponse.setMessage("Successfully added: 0");
 906                 expectedportalRestResponse.setResponse("Success");
 907                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
 908                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 909                 assertEquals(portalRestResponse, expectedportalRestResponse);
 910         }
 911
 912         @Test
 913         public void bulkUploadFunctionsExceptionTest() throws Exception {
 914                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 915                                 .thenThrow(httpClientErrorException);
 916                 PortalRestResponse<String> portalRestResponse = null;
 917                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 918                 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
 919                 expectedportalRestResponse.setResponse("Failed");
 920                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 921                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 922                 assertEquals(portalRestResponse, expectedportalRestResponse);
 923         }
 924
 925         @Test
 926         public void bulkUploadRolesTest() throws Exception {
 927                 Integer result = 0;
 928                 PortalRestResponse<String> portalRestResponse = null;
 929                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 930                 expectedportalRestResponse.setMessage("Successfully added: 0");
 931                 expectedportalRestResponse.setResponse("Success");
 932                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
 933                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
 934                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 935                 assertEquals(portalRestResponse, expectedportalRestResponse);
 936         }
 937
 938         @Test
 939         public void bulkUploadRolesTestException() throws Exception {
 940                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
 941                                 .thenThrow(httpClientErrorException);
 942                 PortalRestResponse<String> portalRestResponse = null;
 943                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 944                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
 945                 expectedportalRestResponse.setResponse("Failed");
 946                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 947                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 948                 assertEquals(portalRestResponse, expectedportalRestResponse);
 949         }
 950
 951         @Test
 952         public void bulkUploadRoleFunctionsTest() throws Exception {
 953                 Integer result = 0;
 954                 PortalRestResponse<String> portalRestResponse = null;
 955                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 956                 expectedportalRestResponse.setMessage("Successfully added: 0");
 957                 expectedportalRestResponse.setResponse("Success");
 958                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
 959                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 960                                 .thenReturn(result);
 961                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 962                 assertEquals(portalRestResponse, expectedportalRestResponse);
 963         }
 964
 965         @Test
 966         public void bulkUploadRoleFunctionsException() throws Exception {
 967                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 968                                 .thenThrow(httpClientErrorException);
 969                 PortalRestResponse<String> portalRestResponse = null;
 970                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 971                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
 972                 expectedportalRestResponse.setResponse("Failed");
 973                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 974                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 975                 assertEquals(portalRestResponse, expectedportalRestResponse);
 976         }
 977
 978         @Test
 979         public void bulkUploadUserRolesTest() throws Exception {
 980                 Integer result = 0;
 981                 PortalRestResponse<String> portalRestResponse = null;
 982                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 983                 expectedportalRestResponse.setMessage("Successfully added: 0");
 984                 expectedportalRestResponse.setResponse("Success");
 985                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
 986                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 987                                 .thenReturn(result);
 988                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 989                 assertEquals(portalRestResponse, expectedportalRestResponse);
 990         }
 991
 992         @Test
 993         public void bulkUploadUserRolesExceptionTest() throws Exception {
 994                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 995                                 .thenThrow(httpClientErrorException);
 996                 PortalRestResponse<String> portalRestResponse = null;
 997                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
 998                 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
 999                 expectedportalRestResponse.setResponse("Failed");
1000                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1001                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
1002                 assertEquals(portalRestResponse, expectedportalRestResponse);
1003         }
1004
1005         @Test
1006         public void bulkUploadPartnerFunctionsTest() {
1007                 PortalRestResponse<String> portalRestResponse = null;
1008                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1009                 expectedportalRestResponse.setMessage("Successfully added: '0' functions");
1010                 expectedportalRestResponse.setResponse("Success");
1011                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1012                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
1013                 assertEquals(portalRestResponse, expectedportalRestResponse);
1014         }
1015
1016         @Test
1017         public void bulkUploadPartnerRolesTest() {
1018                 PortalRestResponse<String> portalRestResponse = null;
1019                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1020                 expectedportalRestResponse.setMessage("Successfully added");
1021                 expectedportalRestResponse.setResponse("Success");
1022                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1023                 List<Role> upload = new ArrayList<>();
1024                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
1025                                 upload);
1026                 assertEquals(portalRestResponse, expectedportalRestResponse);
1027         }
1028
1029         @Test
1030         public void bulkUploadPartnerRolesExceptionTest() {
1031                 PortalRestResponse<String> portalRestResponse = null;
1032                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1033                 expectedportalRestResponse.setMessage("Successfully added");
1034                 expectedportalRestResponse.setResponse("Success");
1035                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1036                 List<Role> upload = new ArrayList<>();
1037                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
1038                                 upload);
1039                 assertEquals(portalRestResponse, expectedportalRestResponse);
1040         }
1041
1042         @Test
1043         public void getMenuFunctionsTest() throws Exception {
1044                 String reason = getInvalidKeyJson();
1045                 StringWriter sw = new StringWriter();
1046                 PrintWriter writer = new PrintWriter(sw);
1047                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1048                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey))).thenReturn(null);
1049                 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
1050                                 mockedResponse);
1051                 assertNull(expectedFunctionsList);
1052                 String result = sw.getBuffer().toString().trim();
1053                 assertEquals(reason, result);
1054         }
1055
1056         @Test
1057         public void getMenuFunctionsExceptionTest() throws Exception {
1058                 String reason = getInvalidKeyJson();
1059                 StringWriter sw = new StringWriter();
1060                 PrintWriter writer = new PrintWriter(sw);
1061                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1062                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
1063                                 .thenThrow(httpClientErrorException);
1064                 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
1065                 String result = sw.getBuffer().toString().trim();
1066                 assertEquals(reason, result);
1067         }
1068
1069         @Test
1070         public void saveRoleExceptionTest() {
1071                 Role role = new Role();
1072                 PortalRestResponse<String> portalRestResponse = null;
1073                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1074                 expectedportalRestResponse.setMessage("Invalid credentials!");
1075                 expectedportalRestResponse.setResponse("Failed");
1076                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1077                 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1078                 assertEquals(portalRestResponse, expectedportalRestResponse);
1079         }
1080
1081         @Test
1082         public void deleteRoleExceptionTest() {
1083                 String role = "TestNew";
1084                 PortalRestResponse<String> portalRestResponse = null;
1085                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1086                 expectedportalRestResponse.setMessage("Invalid credentials!");
1087                 expectedportalRestResponse.setResponse("Failed");
1088                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1089                 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, role);
1090                 assertEquals(portalRestResponse, expectedportalRestResponse);
1091         }
1092
1093         @Test
1094         public void bulkUploadPartnerRoleFunctionsTest() {
1095                 PortalRestResponse<String> portalRestResponse = null;
1096                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1097                 expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
1098                 expectedportalRestResponse.setResponse("Success");
1099                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1100                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest,
1101                                 mockedResponse);
1102                 assertEquals(portalRestResponse, expectedportalRestResponse);
1103         }
1104
1105         @Test
1106         public void getUsersOfApplicationTest() throws Exception {
1107                 List<EcompUser> users = new ArrayList<>();
1108                 EcompUser user = new EcompUser();
1109                 user.setOrgUserId("guestT");
1110                 users.add(user);
1111                 StringWriter sw = new StringWriter();
1112                 PrintWriter writer = new PrintWriter(sw);
1113                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1114                 List<EPApp> applicationList = new ArrayList<>();
1115                 EPApp app = mockApp();
1116                 app.setRolesInAAF(true);
1117                 applicationList.add(app);
1118                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1119                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
1120                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1121                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1122                 List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest,
1123                                 mockedResponse);
1124                 assertEquals(expectedUsers, users);
1125         }
1126
1127         @Test(expected = Exception.class)
1128         public void getUsersOfApplicationExceptionTest() throws Exception {
1129                 List<EcompUser> users = new ArrayList<>();
1130                 EcompUser user = new EcompUser();
1131                 user.setOrgUserId("guestT");
1132                 users.add(user);
1133                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey)))
1134                                 .thenThrow(nullPointerException);
1135                 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
1136         }
1137
1138         @Test(expected = NullPointerException.class)
1139         public void deleteRoleV2Test() throws Exception {
1140                 List<EPApp> applicationList = new ArrayList<>();
1141                 EPApp app = mockApp();
1142                 applicationList.add(app);
1143                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1144                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1145                                 "Success");
1146                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1147                                 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1148                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1149                 expectedportalRestResponse.setMessage("Successfully Deleted");
1150                 expectedportalRestResponse.setResponse("Success");
1151                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1152                 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1153                                 mockedResponse, (long) 1);
1154                 assertNull(actualResponse);
1155         }
1156
1157         @Test
1158         public void deleteRoleV2InvalidUebKeyTest() throws Exception {
1159                 List<EPApp> applicationList = new ArrayList<>();
1160                 EPApp app = mockApp();
1161                 applicationList.add(app);
1162                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1163                                 .thenThrow(new Exception("Invalid credentials!"));
1164                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1165                 expectedportalRestResponse.setMessage("Invalid credentials!");
1166                 expectedportalRestResponse.setResponse("Failed");
1167                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1168                 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1169                                 mockedResponse, (long) 1);
1170                 assertEquals(actualResponse, expectedportalRestResponse);
1171         }
1172
1173         @Test
1174         public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception {
1175                 List<EPApp> applicationList = new ArrayList<>();
1176                 EPApp app = mockApp();
1177                 applicationList.add(app);
1178                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
1179                                 .thenThrow(new Exception("test"));
1180                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1181                 expectedportalRestResponse.setMessage("test");
1182                 expectedportalRestResponse.setResponse("Failed");
1183                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1184                 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1185                                 mockedResponse, (long) 1);
1186                 assertEquals(actualResponse, expectedportalRestResponse);
1187         }
1188
1189         @Test(expected = NullPointerException.class)
1190         public void deleteRoleV2ExceptionTest() throws Exception {
1191                 List<EPApp> applicationList = new ArrayList<>();
1192                 EPApp app = mockApp();
1193                 applicationList.add(app);
1194                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1195                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1196                                 "failed");
1197                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1198                                 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1199                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1200                 expectedportalRestResponse.setMessage("Failed to deleteRole");
1201                 expectedportalRestResponse.setResponse("Failed");
1202                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1203                 PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
1204                                 mockedResponse, (long) 1);
1205                 assertEquals(actualResponse, null);
1206         }
1207
1208         @Test
1209         public void getEpUserNullTest() throws Exception {
1210                 List<EPApp> applicationList = new ArrayList<>();
1211                 EPApp app = mockApp();
1212                 app.setUebKey("uebKey");
1213                 app.setRolesInAAF(true);
1214                 applicationList.add(app);
1215                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1216                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1217                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1218                 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1219         }
1220
1221         @Test
1222         public void getEpUserTest() throws Exception {
1223                 List<EPApp> applicationList = new ArrayList<>();
1224                 EPApp app = mockApp();
1225                 app.setUebKey("uebKey");
1226                 app.setRolesInAAF(true);
1227                 applicationList.add(app);
1228                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1229                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1230                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1231                 String user = "{\"id\":null,\"created\":null,\"modified\":null,\"createdId\":null,\"modifiedId\":null,\"rowNum\":null,\"auditUserId\":null,\"auditTrail\":null,\"orgId\":null,\"managerId\":null,\"firstName\":\"test\",\"middleInitial\":null,\"lastName\":null,\"phone\":null,\"fax\":null,\"cellular\":null,\"email\":null,\"addressId\":null,\"alertMethodCd\":null,\"hrid\":null,\"orgUserId\":null,\"orgCode\":null,\"address1\":null,\"address2\":null,\"city\":null,\"state\":null,\"zipCode\":null,\"country\":null,\"orgManagerUserId\":null,\"locationClli\":null,\"businessCountryCode\":null,\"businessCountryName\":null,\"businessUnit\":null,\"businessUnitName\":null,\"department\":null,\"departmentName\":null,\"companyCode\":null,\"company\":null,\"zipCodeSuffix\":null,\"jobTitle\":null,\"commandChain\":null,\"siloStatus\":null,\"costCenter\":null,\"financialLocCode\":null,\"loginId\":null,\"loginPwd\":null,\"lastLoginDate\":null,\"active\":false,\"internal\":false,\"selectedProfileId\":null,\"timeZoneId\":null,\"online\":false,\"chatId\":null,\"userApps\":[],\"pseudoRoles\":[],\"roles\":[]}";
1232                 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey)))
1233                                 .thenReturn(user);
1234                 User EPuser = new User();
1235                 EPuser.setFirstName("test");
1236                 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
1237                 String res = "{\"orgId\":null,\"managerId\":null,\"firstName\":\"test\",\"middleInitial\":null,\"lastName\":null,\"phone\":null,\"email\":null,\"hrid\":null,\"orgUserId\":null,\"orgCode\":null,\"orgManagerUserId\":null,\"jobTitle\":null,\"loginId\":null,\"active\":false,\"roles\":[]}";
1238                 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"), res);
1239         }
1240
1241         @Test
1242         public void getEpUserExceptionTest() throws Exception {
1243                 List<EPApp> applicationList = new ArrayList<>();
1244                 EPApp app = mockApp();
1245                 app.setRolesInAAF(true);
1246                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1247                 StringWriter sw = new StringWriter();
1248                 PrintWriter writer = new PrintWriter(sw);
1249                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1250                 externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
1251         }
1252
1253         @Test
1254         public void getEPRolesOfApplicationTest() throws Exception {
1255                 List<EPApp> applicationList = new ArrayList<>();
1256                 EPApp app = mockApp();
1257                 app.setUebKey("uebKey");
1258                 app.setRolesInAAF(true);
1259                 applicationList.add(app);
1260                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1261                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1262                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1263                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1264                 List<CentralV2Role> cenRoleList = new ArrayList<>();
1265                 CentralV2Role role = new CentralV2Role();
1266                 role.setName("test");
1267                 cenRoleList.add(role);
1268                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey)))
1269                                 .thenReturn(cenRoleList);
1270                 List<EcompRole> ecompRoles = new ArrayList<>();
1271                 EcompRole eprole = new EcompRole();
1272                 eprole.setName("test");
1273                 ecompRoles.add(eprole);
1274                 assertEquals(ecompRoles,
1275                                 externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1276         }
1277
1278         @Test
1279         public void getEPRolesOfApplicationNullTest() throws Exception {
1280                 List<EPApp> applicationList = new ArrayList<>();
1281                 EPApp app = mockApp();
1282                 app.setUebKey("uebKey");
1283                 app.setRolesInAAF(true);
1284                 applicationList.add(app);
1285                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1286                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1287                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1288                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1289                 List<CentralV2Role> cenRoleList = new ArrayList<>();
1290                 CentralV2Role role = new CentralV2Role.CentralV2RoleBuilder().createCentralV2Role();
1291                 role.setName("test");
1292                 cenRoleList.add(role);
1293                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
1294                 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1295         }
1296
1297         @Test
1298         public void getEPRolesOfApplicationExceptionTest() throws Exception {
1299                 List<EPApp> applicationList = new ArrayList<>();
1300                 EPApp app = mockApp();
1301                 app.setRolesInAAF(true);
1302                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1303                 StringWriter sw = new StringWriter();
1304                 PrintWriter writer = new PrintWriter(sw);
1305                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1306                 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1307         }
1308
1309         @Test
1310         public void saveRoleTest() throws Exception {
1311                 PowerMockito.mockStatic(EcompPortalUtils.class);
1312                 PowerMockito.mockStatic(SystemProperties.class);
1313                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1314                 PowerMockito.mockStatic(PortalConstants.class);
1315                 PortalRestResponse<String> actualPortalRestResponse = null;
1316                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1317                 expectedportalRestResponse.setMessage("Successfully Saved");
1318                 expectedportalRestResponse.setResponse("Success");
1319                 EPUser user = mockUser.mockEPUser();
1320                 List<EPUser> userList = new ArrayList<>();
1321                 userList.add(user);
1322                 EPApp app = mockApp();
1323                 app.setRolesInAAF(true);
1324                 List<EPApp> appList = new ArrayList<>();
1325                 appList.add(app);
1326                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1327                 Role role = new Role();
1328                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
1329                                 "Success");
1330                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1331                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1332                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1333                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1334                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1335                 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1336                                 .thenReturn(externalRequestFieldsValidator);
1337                 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1338                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1339         }
1340
1341         @Test
1342         public void saveRoleNegativeTest() throws Exception {
1343                 PowerMockito.mockStatic(EcompPortalUtils.class);
1344                 PowerMockito.mockStatic(SystemProperties.class);
1345                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1346                 PowerMockito.mockStatic(PortalConstants.class);
1347                 PortalRestResponse<String> actualPortalRestResponse = null;
1348                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1349                 expectedportalRestResponse.setMessage("Successfully Saved");
1350                 expectedportalRestResponse.setResponse("Success");
1351                 EPUser user = mockUser.mockEPUser();
1352                 List<EPUser> userList = new ArrayList<>();
1353                 userList.add(user);
1354                 EPApp app = mockApp();
1355                 app.setRolesInAAF(true);
1356                 List<EPApp> appList = new ArrayList<>();
1357                 appList.add(app);
1358                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1359                 Role role = new Role();
1360                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1361                                 "Failed");
1362                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1363                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1364                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1365                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1366                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1367                 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1368                                 .thenReturn(externalRequestFieldsValidator);
1369                 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1370                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1371         }
1372
1373         @Test
1374         public void saveRole406Test() throws Exception {
1375                 PowerMockito.mockStatic(EcompPortalUtils.class);
1376                 PowerMockito.mockStatic(SystemProperties.class);
1377                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1378                 PowerMockito.mockStatic(PortalConstants.class);
1379                 PortalRestResponse<String> actualPortalRestResponse = null;
1380                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1381                 expectedportalRestResponse.setMessage("Successfully Saved");
1382                 expectedportalRestResponse.setResponse("Failed");
1383                 EPUser user = mockUser.mockEPUser();
1384                 List<EPUser> userList = new ArrayList<>();
1385                 userList.add(user);
1386                 EPApp app = mockApp();
1387                 app.setRolesInAAF(true);
1388                 List<EPApp> appList = new ArrayList<>();
1389                 appList.add(app);
1390                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1391                 Role role = new Role();
1392                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1393                                 "406");
1394                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1395                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1396                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1397                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1398                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1399                 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
1400                                 .thenReturn(externalRequestFieldsValidator);
1401                 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1402                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1403         }
1404
1405         @Test(expected = NullPointerException.class)
1406         public void saveRoleNullExceptionTest() throws Exception {
1407                 List<EPApp> applicationList = new ArrayList<>();
1408                 EPApp app = mockApp();
1409                 applicationList.add(app);
1410                 Role role = new Role();
1411                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1412                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
1413                                 "failed");
1414                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
1415                                 Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1416                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1417                 expectedportalRestResponse.setMessage("Failed to deleteRole");
1418                 expectedportalRestResponse.setResponse("Failed");
1419                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1420                 PortalRestResponse<String> actualResponse = externalAccessRolesController.saveRole(mockedRequest,
1421                                 mockedResponse, role);
1422                 assertEquals(actualResponse, null);
1423         }
1424
1425         @Test
1426         public void deleteRoleTest() throws Exception {
1427                 PowerMockito.mockStatic(EcompPortalUtils.class);
1428                 PowerMockito.mockStatic(SystemProperties.class);
1429                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1430                 PowerMockito.mockStatic(PortalConstants.class);
1431                 PortalRestResponse<String> actualPortalRestResponse = null;
1432                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1433                 expectedportalRestResponse.setMessage("Successfully Deleted");
1434                 expectedportalRestResponse.setResponse("Success");
1435                 EPUser user = mockUser.mockEPUser();
1436                 List<EPUser> userList = new ArrayList<>();
1437                 userList.add(user);
1438                 EPApp app = mockApp();
1439                 app.setRolesInAAF(true);
1440                 List<EPApp> appList = new ArrayList<>();
1441                 appList.add(app);
1442                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
1443                 String code = "test";
1444                 boolean deleteResponse = true;
1445                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1446                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1447                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1448                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1449                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1450                 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1451                                 .thenReturn(deleteResponse);
1452                 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1453                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1454         }
1455
1456         @Test
1457         public void deleteRoleXSSTest() throws Exception {
1458                 PowerMockito.mockStatic(EcompPortalUtils.class);
1459                 PowerMockito.mockStatic(SystemProperties.class);
1460                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1461                 PowerMockito.mockStatic(PortalConstants.class);
1462                 PortalRestResponse<String> actualPortalRestResponse = null;
1463                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1464                 expectedportalRestResponse.setMessage("Failed to deleteRole, not valid data.");
1465                 expectedportalRestResponse.setResponse("Failed");
1466                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1467                 EPUser user = mockUser.mockEPUser();
1468                 List<EPUser> userList = new ArrayList<>();
1469                 userList.add(user);
1470                 EPApp app = mockApp();
1471                 app.setRolesInAAF(true);
1472                 List<EPApp> appList = new ArrayList<>();
1473                 appList.add(app);
1474                 String code = "<img src=xss onerror=alert(1)>";
1475                 boolean deleteResponse = true;
1476                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1477                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1478                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1479                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1480                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1481                 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1482                         .thenReturn(deleteResponse);
1483                 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1484                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1485         }
1486
1487         @Test
1488         public void deleteRoleNegativeTest() throws Exception {
1489                 PowerMockito.mockStatic(EcompPortalUtils.class);
1490                 PowerMockito.mockStatic(SystemProperties.class);
1491                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1492                 PowerMockito.mockStatic(PortalConstants.class);
1493                 PortalRestResponse<String> actualPortalRestResponse = null;
1494                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1495                 expectedportalRestResponse.setMessage("Failed to delete Role for 'test");
1496                 expectedportalRestResponse.setResponse("Failed");
1497                 EPUser user = mockUser.mockEPUser();
1498                 List<EPUser> userList = new ArrayList<>();
1499                 userList.add(user);
1500                 EPApp app = mockApp();
1501                 app.setRolesInAAF(true);
1502                 List<EPApp> appList = new ArrayList<>();
1503                 appList.add(app);
1504                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1505                 String code = "test";
1506                 boolean deleteResponse = false;
1507                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1508                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1509                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1510                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1511                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1512                 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
1513                                 .thenReturn(deleteResponse);
1514                 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1515                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1516         }
1517
1518         @Test
1519         public void deleteDependcyRoleRecordTest() throws Exception {
1520                 ExternalRequestFieldsValidator removeResult = new ExternalRequestFieldsValidator(true, "success");
1521                 PortalRestResponse<String> portalRestResponse = null;
1522                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
1523                 expectedportalRestResponse.setMessage("Invalid credentials!");
1524                 expectedportalRestResponse.setResponse("Failed");
1525                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
1526                 long roleId = 123;
1527                 String LoginId = "loginId";
1528                 List<EPApp> appList = new ArrayList<>();
1529                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1530                 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn(LoginId);
1531                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1532                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(roleId, mockedRequest.getHeader("uebkey"),
1533                                 mockedRequest.getHeader("LoginId"))).thenReturn(removeResult);
1534                 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
1535                                 roleId);
1536                 assertEquals(expectedportalRestResponse, portalRestResponse);
1537         }
1538
1539 }