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