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