gerrit.onap Code Review - portal.git/blob

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2017 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  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  37  */
  38 package org.onap.portalapp.portal.controller;
  39
  40
  41 import static org.junit.Assert.assertEquals;
  42 import static org.junit.Assert.assertNull;
  43
  44 import java.io.PrintWriter;
  45 import java.io.StringWriter;
  46 import java.util.ArrayList;
  47 import java.util.HashMap;
  48 import java.util.List;
  49 import java.util.Map;
  50
  51 import javax.servlet.http.HttpServletRequest;
  52 import javax.servlet.http.HttpServletResponse;
  53
  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.CentralV2Role;
  74 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
  75 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
  76 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  77 import org.onap.portalapp.portal.utils.PortalConstants;
  78 import org.onap.portalsdk.core.domain.AuditLog;
  79 import org.onap.portalsdk.core.domain.Role;
  80 import org.onap.portalsdk.core.domain.User;
  81 import org.onap.portalsdk.core.restful.domain.EcompRole;
  82 import org.onap.portalsdk.core.restful.domain.EcompUser;
  83 import org.onap.portalsdk.core.service.AuditService;
  84 import org.onap.portalsdk.core.service.UserService;
  85 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
  86 import org.onap.portalsdk.core.util.SystemProperties;
  87 import org.powermock.api.mockito.PowerMockito;
  88 import org.powermock.core.classloader.annotations.PrepareForTest;
  89 import org.powermock.modules.junit4.PowerMockRunner;
  90 import org.springframework.http.HttpStatus;
  91 import org.springframework.http.ResponseEntity;
  92 import org.springframework.web.client.HttpClientErrorException;
  93
  94 import com.fasterxml.jackson.core.JsonProcessingException;
  95 import com.fasterxml.jackson.databind.ObjectMapper;
  96
  97 @RunWith(PowerMockRunner.class)
  98 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
  99                 EPCommonSystemProperties.class })
 100 public class ExternalAccessRolesControllerTest {
 101
 102         @Mock
 103         ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
 104
 105         @InjectMocks
 106         ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
 107         @Mock
 108         UserService userservice =  new UserServiceCentalizedImpl();
 109
 110         @Mock
 111         AuditService auditService;
 112
 113         @Before
 114         public void setup() {
 115                 MockitoAnnotations.initMocks(this);
 116         }
 117         @Mock
 118         AuditLog auditLog = new AuditLog();
 119
 120         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
 121
 122         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
 123         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
 124         NullPointerException nullPointerException = new NullPointerException();
 125         HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
 126
 127         MockEPUser mockUser = new MockEPUser();
 128         String loginId = "guestT";
 129         String uebKey = "testUebKey";
 130
 131         @Test
 132         public void getUserTest() throws Exception {
 133                 String reason = getInvalidKeyJson();
 134                 StringWriter sw = new StringWriter();
 135                 PrintWriter writer = new PrintWriter(sw);
 136                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 137                 List<EPUser> userList = new ArrayList<>();
 138                 Mockito.when(externalAccessRolesService.getUser(loginId)).thenReturn(userList);
 139                 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 140                 String result = sw.getBuffer().toString().trim();
 141                 assertEquals(reason, result);
 142         }
 143
 144         @Test
 145         public void getUserExceptionTest() throws Exception {
 146                 String reason = getInvalidKeyJson();
 147                 StringWriter sw = new StringWriter();
 148                 PrintWriter writer = new PrintWriter(sw);
 149                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 150                 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 151                 String result = sw.getBuffer().toString().trim();
 152                 assertEquals(reason, result);
 153         }
 154
 155         public EPApp mockApp()
 156         {
 157                 EPApp app = new EPApp();
 158                 app.setName("Test");
 159                 app.setImageUrl("test");
 160                 app.setDescription("test");
 161                 app.setNotes("test");
 162                 app.setUrl("test");
 163                 app.setId((long) 1);
 164                 app.setAppRestEndpoint("test");
 165                 app.setAlternateUrl("test");
 166                 app.setName("test");
 167                 app.setMlAppName("test");
 168                 app.setMlAppAdminId("test");
 169                 app.setUsername("test");
 170                 app.setAppPassword("test");
 171                 app.setOpen(false);
 172                 app.setEnabled(false);
 173                 app.setUebKey("test");
 174                 app.setUebSecret("test");
 175                 app.setUebTopicName("test");
 176                 app.setAppType(1);
 177                 return app;
 178         }
 179
 180         @Test(expected = NullPointerException.class)
 181         public void getRolesForAppTest() throws Exception {
 182                 List<EPApp> applicationList = new ArrayList<EPApp>();
 183                 List<CentralV2Role> answer = new ArrayList<>();
 184                 EPApp app = mockApp();
 185                 applicationList.add(app);
 186                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 187                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 188                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
 189                 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
 190         }
 191
 192         @Test(expected = NullPointerException.class)
 193         public void getRolesForAppExceptionTest() throws Exception {
 194                 List<EPApp> applicationList = new ArrayList<EPApp>();
 195                 EPApp app = mockApp();
 196                 applicationList.add(app);
 197                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 198                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 199                 externalAccessRolesController.getRolesForApp(mockedRequest,mockedResponse);
 200                 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
 201                 assertEquals(null,role);
 202         }
 203
 204         @Test
 205         public void getRoleFunctionsListTest() throws Exception {
 206                 String reason = getInvalidKeyJson();
 207                 StringWriter sw = new StringWriter();
 208                 PrintWriter writer = new PrintWriter(sw);
 209                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 210                 List<CentralV2RoleFunction> answer = null;
 211                 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey))).thenReturn(null);
 212                 assertEquals(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse), answer);
 213                 String result = sw.getBuffer().toString().trim();
 214                 assertEquals(reason, result);
 215         }
 216
 217         @Test
 218         public void getRoleFunctionsListExceptionTest() throws Exception {
 219                 String reason = getInvalidKeyJson();
 220                 StringWriter sw = new StringWriter();
 221                 PrintWriter writer = new PrintWriter(sw);
 222                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 223                 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
 224                 String result = sw.getBuffer().toString().trim();
 225                 assertEquals(reason, result);
 226         }
 227
 228         @Test
 229         public void getRoleInfoTest() throws Exception {
 230                 String reason = getInvalidKeyJson();
 231                 StringWriter sw = new StringWriter();
 232                 PrintWriter writer = new PrintWriter(sw);
 233                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 234                 CentralV2Role answer = new CentralV2Role();
 235                 long roleId = 1;
 236                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
 237                                 .thenReturn(answer);
 238                 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
 239                 String result = sw.getBuffer().toString().trim();
 240                 assertEquals(reason, result);
 241         }
 242
 243         @Test
 244         public void getRoleInfoExceptionTest() throws Exception {
 245                 String reason = getInvalidKeyJson();
 246                 StringWriter sw = new StringWriter();
 247                 PrintWriter writer = new PrintWriter(sw);
 248                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 249                 long roleId = 1;
 250                 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
 251                 String result = sw.getBuffer().toString().trim();
 252                 assertEquals(reason, result);
 253         }
 254
 255         @Test
 256         public void getRoleFunctionTest() throws Exception {
 257                 EPApp mockApp = mockApp();
 258                 mockApp.setCentralAuth(true);
 259                 List<EPApp> mockAppList = new ArrayList<>();
 260                 mockAppList.add(mockApp);
 261                 StringWriter sw = new StringWriter();
 262                 PrintWriter writer = new PrintWriter(sw);
 263                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 264                 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
 265                 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
 266                 roleFunction1.setCode("test2");
 267                 String code = "test_menu";
 268                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 269                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
 270                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 271                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
 272                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
 273                                 .thenReturn(roleFunction1);
 274                 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code);
 275                 assertEquals(returnedValue, roleFunction2);
 276                 String result = sw.getBuffer().toString().trim();
 277                 assertEquals("", result);
 278         }
 279
 280         @Test
 281         public void getRoleFunctionExceptionTest() throws Exception {
 282                 String reason = getInvalidKeyJson();
 283                 StringWriter sw = new StringWriter();
 284                 PrintWriter writer = new PrintWriter(sw);
 285                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 286                 String code = "test_menu";
 287                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
 288                                 .thenThrow(httpClientErrorException);
 289                 assertEquals(new CentralRoleFunction(),externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
 290                 String result = sw.getBuffer().toString().trim();
 291                 assertEquals(reason, result);
 292         }
 293
 294         @Test(expected = NullPointerException.class)
 295         public void saveRoleFunctionIfIsIsNotDeletedTest() throws Exception {
 296                 List<EPApp> applicationList = new ArrayList<EPApp>();
 297                 EPApp app = mockApp();
 298                 applicationList.add(app);
 299                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 300                 PortalRestResponse<String> portalRestResponse = null;
 301                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 302                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 303                 expectedportalRestResponse.setResponse("Failed");
 304                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 305                 String data = null;
 306                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 307                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
 308                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 309                 assertEquals(portalRestResponse, expectedportalRestResponse);
 310         }
 311
 312         @Test(expected = NullPointerException.class)
 313         public void saveRoleFunctionExceptionTest() throws Exception {
 314                 List<EPApp> applicationList = new ArrayList<EPApp>();
 315                 EPApp app = mockApp();
 316                 applicationList.add(app);
 317                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 318                 PortalRestResponse<String> portalRestResponse = null;
 319                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 320                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 321                 expectedportalRestResponse.setResponse("Failed");
 322                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 323                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
 324                 System.out.println(portalRestResponse);
 325                 assertEquals(portalRestResponse, expectedportalRestResponse);
 326         }
 327
 328         @Test(expected = NullPointerException.class)
 329         public void saveRoleFunctionTest() throws Exception {
 330                 List<EPApp> applicationList = new ArrayList<EPApp>();
 331                 EPApp app = mockApp();
 332                 applicationList.add(app);
 333                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 334                 PortalRestResponse<String> portalRestResponse = null;
 335                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 336                 expectedportalRestResponse.setMessage(null);
 337                 expectedportalRestResponse.setResponse("Failed");
 338                 PortalRestStatusEnum portalRestStatusEnum = null;
 339                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 340                 String data = null;
 341                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 342                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(true);
 343                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 344                 System.out.println(portalRestResponse);
 345                 assertEquals(portalRestResponse, expectedportalRestResponse);
 346         }
 347
 348         @Test
 349         public void deleteRoleFunctionTest() throws Exception {
 350                 PowerMockito.mockStatic(EcompPortalUtils.class);
 351                 PowerMockito.mockStatic(SystemProperties.class);
 352                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 353                 PowerMockito.mockStatic(PortalConstants.class);
 354                 PortalRestResponse<String> portalRestResponse = null;
 355                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 356                 expectedportalRestResponse.setMessage("Successfully Deleted");
 357                 expectedportalRestResponse.setResponse("Success");
 358                 PortalRestStatusEnum portalRestStatusEnum = null;
 359                 EPUser user = mockUser.mockEPUser();
 360                 List<EPUser> userList = new ArrayList<>();
 361                 userList.add(user);
 362                 EPApp app = mockApp();
 363                 app.setCentralAuth(true);
 364                 List<EPApp> appList  = new ArrayList<>();
 365                 appList.add(app);
 366                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 367                 String code ="testNew";
 368                 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
 369                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 370                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 371                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 372                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 373                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
 374                 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
 375                 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
 376                 assertEquals(portalRestResponse, expectedportalRestResponse);
 377         }
 378
 379         @Test
 380         public void getActiveRolesTest() throws Exception {
 381                 String reason = getInvalidKeyJson();
 382                 StringWriter sw = new StringWriter();
 383                 PrintWriter writer = new PrintWriter(sw);
 384                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 385                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
 386                 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 387                 assertNull(expectedCenRole);
 388                 String result = sw.getBuffer().toString().trim();
 389                 assertEquals(reason, result);
 390         }
 391
 392         @Test
 393         public void getActiveRolesExceptionTest() throws Exception {
 394                 String reason = getInvalidKeyJson();
 395                 StringWriter sw = new StringWriter();
 396                 PrintWriter writer = new PrintWriter(sw);
 397                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 398                 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 399                 String result = sw.getBuffer().toString().trim();
 400                 assertEquals(reason, result);
 401         }
 402
 403         /**
 404          * It return JSON string which has error information
 405          *
 406          * @return JSON String
 407          * @throws JsonProcessingException
 408          */
 409         private String getInvalidKeyJson() throws JsonProcessingException {
 410                 final Map<String,String> uebkeyResponse = new HashMap<>();
 411                 String reason = "";
 412                 ObjectMapper mapper = new ObjectMapper();
 413                 uebkeyResponse.put("error","Invalid uebkey!");
 414                 reason = mapper.writeValueAsString(uebkeyResponse);
 415                 return reason;
 416         }
 417
 418         @Test
 419         public void deleteDependcyRoleRecordExceptionTest() throws Exception {
 420                 PortalRestResponse<String> portalRestResponse = null;
 421                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 422                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 423                 expectedportalRestResponse.setResponse("Failed");
 424                 PortalRestStatusEnum portalRestStatusEnum = null;
 425                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 426                 long roleId = 123;
 427                 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
 428                 assertEquals(expectedportalRestResponse, portalRestResponse);
 429         }
 430
 431         @Test
 432         public void bulkUploadFunctionsTest() throws Exception {
 433                 Integer result = 0;
 434                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 435                                 .thenReturn(result);
 436                 PortalRestResponse<String> portalRestResponse = null;
 437                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 438                 expectedportalRestResponse.setMessage("Successfully added: 0");
 439                 expectedportalRestResponse.setResponse("Success");
 440                 PortalRestStatusEnum portalRestStatusEnum = null;
 441                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 442                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 443                 assertEquals(portalRestResponse, expectedportalRestResponse);
 444         }
 445
 446         @Test
 447         public void bulkUploadFunctionsExceptionTest() throws Exception {
 448                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 449                                 .thenThrow(httpClientErrorException);
 450                 PortalRestResponse<String> portalRestResponse = null;
 451                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 452                 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
 453                 expectedportalRestResponse.setResponse("Failed");
 454                 PortalRestStatusEnum portalRestStatusEnum = null;
 455                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 456                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 457                 assertEquals(portalRestResponse, expectedportalRestResponse);
 458         }
 459
 460         @Test
 461         public void bulkUploadRolesTest() throws Exception {
 462                 Integer result = 0;
 463                 PortalRestResponse<String> portalRestResponse = null;
 464                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 465                 expectedportalRestResponse.setMessage("Successfully added: 0");
 466                 expectedportalRestResponse.setResponse("Success");
 467                 PortalRestStatusEnum portalRestStatusEnum = null;
 468                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 469                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
 470                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 471                 assertEquals(portalRestResponse, expectedportalRestResponse);
 472         }
 473
 474         @Test
 475         public void bulkUploadRolesTestException() throws Exception {
 476                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
 477                                 .thenThrow(httpClientErrorException);
 478                 PortalRestResponse<String> portalRestResponse = null;
 479                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 480                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
 481                 expectedportalRestResponse.setResponse("Failed");
 482                 PortalRestStatusEnum portalRestStatusEnum = null;
 483                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 484                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 485                 assertEquals(portalRestResponse, expectedportalRestResponse);
 486         }
 487
 488         @Test
 489         public void bulkUploadRoleFunctionsTest() throws Exception {
 490                 Integer result = 0;
 491                 PortalRestResponse<String> portalRestResponse = null;
 492                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 493                 expectedportalRestResponse.setMessage("Successfully added: 0");
 494                 expectedportalRestResponse.setResponse("Success");
 495                 PortalRestStatusEnum portalRestStatusEnum = null;
 496                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 497                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 498                                 .thenReturn(result);
 499                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 500                 assertEquals(portalRestResponse, expectedportalRestResponse);
 501         }
 502
 503         @Test
 504         public void bulkUploadRoleFunctionsException() throws Exception {
 505                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 506                                 .thenThrow(httpClientErrorException);
 507                 PortalRestResponse<String> portalRestResponse = null;
 508                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 509                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
 510                 expectedportalRestResponse.setResponse("Failed");
 511                 PortalRestStatusEnum portalRestStatusEnum = null;
 512                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 513                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 514                 assertEquals(portalRestResponse, expectedportalRestResponse);
 515         }
 516
 517         @Test
 518         public void bulkUploadUserRolesTest() throws Exception {
 519                 Integer result = 0;
 520                 PortalRestResponse<String> portalRestResponse = null;
 521                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 522                 expectedportalRestResponse.setMessage("Successfully added: 0");
 523                 expectedportalRestResponse.setResponse("Success");
 524                 PortalRestStatusEnum portalRestStatusEnum = null;
 525                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 526                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 527                                 .thenReturn(result);
 528                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 529                 assertEquals(portalRestResponse, expectedportalRestResponse);
 530         }
 531
 532         @Test
 533         public void bulkUploadUserRolesExceptionTest() throws Exception {
 534                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 535                                 .thenThrow(httpClientErrorException);
 536                 PortalRestResponse<String> portalRestResponse = null;
 537                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 538                 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
 539                 expectedportalRestResponse.setResponse("Failed");
 540                 PortalRestStatusEnum portalRestStatusEnum = null;
 541                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 542                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 543                 assertEquals(portalRestResponse, expectedportalRestResponse);
 544         }
 545
 546         @Test
 547         public void bulkUploadPartnerFunctionsTest() throws Exception {
 548                 PortalRestResponse<String> portalRestResponse = null;
 549                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 550                 expectedportalRestResponse.setMessage("Successfully added");
 551                 expectedportalRestResponse.setResponse("Success");
 552                 PortalRestStatusEnum portalRestStatusEnum = null;
 553                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 554                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse, null);
 555                 assertEquals(portalRestResponse, expectedportalRestResponse);
 556         }
 557
 558
 559         @Test
 560         public void bulkUploadPartnerRolesTest() throws Exception {
 561                 PortalRestResponse<String> portalRestResponse = null;
 562                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 563                 expectedportalRestResponse.setMessage("Successfully added");
 564                 expectedportalRestResponse.setResponse("Success");
 565                 PortalRestStatusEnum portalRestStatusEnum = null;
 566                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 567                 List<Role> upload = new ArrayList<>();
 568                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
 569                                 upload);
 570                 assertEquals(portalRestResponse, expectedportalRestResponse);
 571         }
 572
 573          @Test
 574          public void bulkUploadPartnerRolesExceptionTest() throws Exception
 575          {
 576                  ExternalAccessRolesService externalAccessRolesService = null;
 577                 PortalRestResponse<String> portalRestResponse = null;
 578                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 579                 expectedportalRestResponse.setMessage("Successfully added");
 580                 expectedportalRestResponse.setResponse("Success");
 581                 PortalRestStatusEnum portalRestStatusEnum = null;
 582                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 583                 List<Role> upload = new ArrayList<>();
 584                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
 585                                 upload);
 586                 assertEquals(portalRestResponse, expectedportalRestResponse);
 587          }
 588
 589         @Test
 590         public void getMenuFunctionsTest() throws Exception {
 591                 String reason = getInvalidKeyJson();
 592                 StringWriter sw = new StringWriter();
 593                 PrintWriter writer = new PrintWriter(sw);
 594                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 595                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
 596                                 .thenReturn(null);
 597                 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
 598                                 mockedResponse);
 599                 assertNull(expectedFunctionsList);
 600                 String result = sw.getBuffer().toString().trim();
 601                 assertEquals(reason, result);
 602         }
 603
 604         @Test
 605         public void getMenuFunctionsExceptionTest() throws Exception {
 606                 String reason = getInvalidKeyJson();
 607                 StringWriter sw = new StringWriter();
 608                 PrintWriter writer = new PrintWriter(sw);
 609                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 610                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
 611                                 .thenThrow(httpClientErrorException);
 612                 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
 613                 String result = sw.getBuffer().toString().trim();
 614                 assertEquals(reason, result);
 615         }
 616
 617
 618         @Test
 619         public void saveRoleExceptionTest() throws Exception {
 620                 Role role = new Role();
 621                 PortalRestResponse<String> portalRestResponse = null;
 622                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 623                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 624                 expectedportalRestResponse.setResponse("Failed");
 625                 PortalRestStatusEnum portalRestStatusEnum = null;
 626                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 627                 List<Role> upload = new ArrayList<>();
 628                 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
 629
 630                 assertEquals(portalRestResponse, expectedportalRestResponse);
 631         }
 632
 633         @Test
 634         public void deleteRoleExceptionTest() throws Exception {
 635                 String role = "TestNew";
 636                 PortalRestResponse<String> portalRestResponse = null;
 637                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 638                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 639                 expectedportalRestResponse.setResponse("Failed");
 640                 PortalRestStatusEnum portalRestStatusEnum = null;
 641                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 642                 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
 643                 assertEquals(portalRestResponse, expectedportalRestResponse);
 644         }
 645
 646
 647         @Test
 648         public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
 649                 PortalRestResponse<String> portalRestResponse = null;
 650                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 651                 expectedportalRestResponse.setMessage("Successfully added");
 652                 expectedportalRestResponse.setResponse("Success");
 653                 PortalRestStatusEnum portalRestStatusEnum = null;
 654                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 655                 List<Role> upload = new ArrayList<>();
 656                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse,upload);
 657                 assertEquals(portalRestResponse, expectedportalRestResponse);
 658         }
 659
 660         @Test
 661         public void getUsersOfApplicationTest() throws Exception
 662         {
 663                 List<EcompUser> users = new ArrayList<>();
 664                 EcompUser user = new EcompUser();
 665                 user.setOrgUserId("guestT");
 666                 users.add(user);
 667                 StringWriter sw = new StringWriter();
 668                 PrintWriter writer = new PrintWriter(sw);
 669                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 670                 List<EPApp> applicationList = new ArrayList<EPApp>();
 671                 EPApp app = mockApp();
 672                 app.setCentralAuth(true);
 673                 applicationList.add(app);
 674                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 675                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
 676                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
 677                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
 678                 List<EcompUser> expectedUsers =         externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
 679                 assertEquals(expectedUsers, users);
 680         }
 681
 682         @Test(expected = Exception.class)
 683         public void getUsersOfApplicationExceptionTest() throws Exception
 684         {
 685                 List<EcompUser> users = new ArrayList<>();
 686                 EcompUser user = new EcompUser();
 687                 user.setOrgUserId("guestT");
 688                 users.add(user);
 689                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
 690                 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
 691         }
 692
 693         @Test(expected = NullPointerException.class)
 694         public void deleteRoleV2Test() throws Exception
 695         {
 696                 List<EPApp> applicationList = new ArrayList<EPApp>();
 697                 EPApp app = mockApp();
 698                 applicationList.add(app);
 699                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 700                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
 701                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
 702                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 703                 expectedportalRestResponse.setMessage("Successfully Deleted");
 704                 expectedportalRestResponse.setResponse("Success");
 705                 PortalRestStatusEnum portalRestStatusEnum = null;
 706                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 707                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
 708                 assertNull(actualResponse);
 709         }
 710
 711         @Test
 712         public void deleteRoleV2InvalidUebKeyTest() throws Exception
 713         {
 714                 List<EPApp> applicationList = new ArrayList<EPApp>();
 715                 EPApp app = mockApp();
 716                 applicationList.add(app);
 717                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("Invalid uebkey!"));
 718                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 719                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 720                 expectedportalRestResponse.setResponse("Failed");
 721                 PortalRestStatusEnum portalRestStatusEnum = null;
 722                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 723                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
 724                 assertEquals(actualResponse, expectedportalRestResponse);
 725         }
 726
 727         @Test
 728         public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception
 729         {
 730                 List<EPApp> applicationList = new ArrayList<EPApp>();
 731                 EPApp app = mockApp();
 732                 applicationList.add(app);
 733                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("test"));
 734                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 735                 expectedportalRestResponse.setMessage("test");
 736                 expectedportalRestResponse.setResponse("Failed");
 737                 PortalRestStatusEnum portalRestStatusEnum = null;
 738                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 739                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
 740                 assertEquals(actualResponse, expectedportalRestResponse);
 741         }
 742
 743
 744         @Test(expected = NullPointerException.class)
 745         public void deleteRoleV2ExceptionTest() throws Exception
 746         {
 747                 List<EPApp> applicationList = new ArrayList<EPApp>();
 748                 EPApp app = mockApp();
 749                 applicationList.add(app);
 750                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 751                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
 752                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
 753                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 754                 expectedportalRestResponse.setMessage("Failed to deleteRole");
 755                 expectedportalRestResponse.setResponse("Failed");
 756                 PortalRestStatusEnum portalRestStatusEnum = null;
 757                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 758                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
 759                 assertEquals(actualResponse, null);
 760         }
 761
 762         @Test
 763         public void getEpUserNullTest() throws Exception{
 764                 List<EPApp> applicationList = new ArrayList<EPApp>();
 765                 EPApp app = mockApp();
 766                 app.setUebKey("uebKey");
 767                 app.setCentralAuth(true);
 768                 applicationList.add(app);
 769                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 770                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
 771                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
 772                 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
 773         }
 774
 775         @Test
 776         public void getEpUserTest() throws Exception{
 777                 List<EPApp> applicationList = new ArrayList<EPApp>();
 778                 EPApp app = mockApp();
 779                 app.setUebKey("uebKey");
 780                 app.setCentralAuth(true);
 781                 applicationList.add(app);
 782                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 783                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
 784                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
 785        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\":[],\"defaultUserApp\":null,\"roles\":[],\"fullName\":\"test null\"}";
 786                 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey))).thenReturn(user);
 787                 User EPuser = new User();
 788                 EPuser.setFirstName("test");
 789                 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
 790                 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\":[]}";
 791                 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"),res);
 792         }
 793
 794         @Test
 795         public void getEpUserExceptionTest() throws Exception{
 796                 List<EPApp> applicationList = new ArrayList<EPApp>();
 797                 EPApp app = mockApp();
 798                 app.setCentralAuth(true);
 799                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 800                 StringWriter sw = new StringWriter();
 801                 PrintWriter writer = new PrintWriter(sw);
 802                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 803                 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
 804         }
 805
 806         @Test
 807         public void  getEPRolesOfApplicationTest() throws Exception
 808         {
 809                 List<EPApp> applicationList = new ArrayList<EPApp>();
 810                 EPApp app = mockApp();
 811                 app.setUebKey("uebKey");
 812                 app.setCentralAuth(true);
 813                 applicationList.add(app);
 814                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 815                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
 816                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
 817                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 818                 List<CentralV2Role> cenRoleList = new ArrayList<>();
 819                 CentralV2Role role = new CentralV2Role();
 820                 role.setName("test");
 821                 cenRoleList.add(role);
 822                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(cenRoleList);
 823                 List<EcompRole> ecompRoles = new ArrayList<>();
 824                 EcompRole eprole = new EcompRole();
 825                 eprole.setName("test");
 826                 ecompRoles.add(eprole);
 827                 assertEquals(ecompRoles,externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
 828         }
 829         @Test
 830         public void  getEPRolesOfApplicationNullTest() throws Exception
 831         {
 832                 List<EPApp> applicationList = new ArrayList<EPApp>();
 833                 EPApp app = mockApp();
 834                 app.setUebKey("uebKey");
 835                 app.setCentralAuth(true);
 836                 applicationList.add(app);
 837                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 838                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
 839                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
 840                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 841                 List<CentralV2Role> cenRoleList = new ArrayList<>();
 842                 CentralV2Role role = new CentralV2Role();
 843                 role.setName("test");
 844                 cenRoleList.add(role);
 845                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
 846                 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
 847
 848         }
 849
 850         @Test
 851         public void  getEPRolesOfApplicationExceptionTest() throws Exception
 852         {
 853                 List<EPApp> applicationList = new ArrayList<EPApp>();
 854                 EPApp app = mockApp();
 855                 app.setCentralAuth(true);
 856                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 857                 StringWriter sw = new StringWriter();
 858                 PrintWriter writer = new PrintWriter(sw);
 859                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 860                 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
 861
 862         }
 863 }