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

   1 package org.openecomp.portalapp.portal.controller;
   2
   3
   4 import static org.junit.Assert.assertEquals;
   5 import static org.junit.Assert.assertNull;
   6
   7 import java.util.ArrayList;
   8 import java.util.List;
   9
  10 import javax.servlet.http.HttpServletRequest;
  11 import javax.servlet.http.HttpServletResponse;
  12
  13 import org.junit.Before;
  14 import org.junit.Test;
  15 import org.mockito.InjectMocks;
  16 import org.mockito.Mock;
  17 import org.mockito.Mockito;
  18 import org.mockito.MockitoAnnotations;
  19 import org.openecomp.portalapp.portal.core.MockEPUser;
  20 import org.openecomp.portalapp.portal.domain.CentralRoleFunction;
  21 import org.openecomp.portalapp.portal.domain.EPApp;
  22 import org.openecomp.portalapp.portal.domain.EPUser;
  23 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  24 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  25 import org.openecomp.portalapp.portal.framework.MockitoTestSuite;
  26 import org.openecomp.portalapp.portal.service.ExternalAccessRolesService;
  27 import org.openecomp.portalapp.portal.service.ExternalAccessRolesServiceImpl;
  28 import org.openecomp.portalapp.portal.transport.CentralRole;
  29 import org.openecomp.portalsdk.core.domain.AuditLog;
  30 import org.openecomp.portalsdk.core.domain.Role;
  31 import org.openecomp.portalsdk.core.restful.domain.EcompUser;
  32 import org.springframework.http.HttpStatus;
  33 import org.springframework.web.client.HttpClientErrorException;
  34 public class ExternalAccessRolesControllerTest {
  35
  36         @Mock
  37         ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
  38
  39         @InjectMocks
  40         ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
  41
  42         @Before
  43         public void setup() {
  44                 MockitoAnnotations.initMocks(this);
  45         }
  46         @Mock
  47         AuditLog auditLog = new AuditLog();
  48
  49         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  50
  51         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  52         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  53         NullPointerException nullPointerException = new NullPointerException();
  54         HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
  55
  56         MockEPUser mockUser = new MockEPUser();
  57         String loginId = "guestT";
  58         String uebKey = "testUebKey";
  59
  60         @Test
  61         public void getUserTest() throws Exception {
  62                  List<EPUser> userList = new ArrayList<>();
  63                 Mockito.when(externalAccessRolesService.getUser(loginId)).thenReturn(userList);
  64                 assertNull(externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId));
  65         }
  66
  67         @Test
  68         public void getUserExceptionTest() throws Exception {
  69                 Mockito.when(externalAccessRolesService.getUser(loginId))
  70                                 .thenThrow(nullPointerException);
  71                 assertNull(externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId));
  72         }
  73
  74         public EPApp mockApp()
  75         {
  76                 EPApp app = new EPApp();
  77                 app.setName("Test");
  78                 app.setImageUrl("test");
  79                 app.setDescription("test");
  80                 app.setNotes("test");
  81                 app.setUrl("test");
  82                 app.setId((long) 1);
  83                 app.setAppRestEndpoint("test");
  84                 app.setAlternateUrl("test");
  85                 app.setName("test");
  86                 app.setMlAppName("test");
  87                 app.setMlAppAdminId("test");
  88                 app.setUsername("test");
  89                 app.setAppPassword("test");
  90                 app.setOpen(false);
  91                 app.setEnabled(false);
  92                 app.setUebKey("test");
  93                 app.setUebSecret("test");
  94                 app.setUebTopicName("test");
  95                 app.setAppType(1);
  96                 return app;
  97         }
  98
  99         @Test
 100         public void getRolesForAppTest() throws Exception {
 101                 List<EPApp> applicationList = new ArrayList<EPApp>();
 102                 List<CentralRole> answer = new ArrayList<>();
 103                 EPApp app = mockApp();
 104                 applicationList.add(app);
 105                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 106                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 107                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
 108                 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), answer);
 109         }
 110
 111         @Test
 112         public void getRolesForAppExceptionTest() throws Exception {
 113                 List<EPApp> applicationList = new ArrayList<EPApp>();
 114                 List<CentralRole> answer = new ArrayList<>();
 115                 EPApp app = mockApp();
 116                 applicationList.add(app);
 117                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 118                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 119                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
 120                                 .thenThrow(httpClientErrorException);
 121                 assertNull(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse));
 122         }
 123
 124         @Test
 125         public void getRoleFunctionsListTest() throws Exception {
 126                 List<CentralRoleFunction> answer = new ArrayList<>();
 127                 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey))).thenReturn(answer);
 128                 assertEquals(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse), answer);
 129         }
 130
 131         @Test
 132         public void getRoleFunctionsListExceptionTest() throws Exception {
 133                 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey)))
 134                                 .thenThrow(httpClientErrorException);
 135                 assertNull(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse));
 136         }
 137
 138         @Test
 139         public void getRoleInfoTest() throws Exception {
 140                 CentralRole answer = new CentralRole();
 141                 long roleId = 1;
 142                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
 143                                 .thenReturn(answer);
 144                 assertEquals(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId), answer);
 145         }
 146
 147         @Test
 148         public void getRoleInfoExceptionTest() throws Exception {
 149                 long roleId = 1;
 150                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
 151                                 .thenThrow(httpClientErrorException);
 152                 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
 153         }
 154
 155         @Test
 156         public void getRoleFunctionTest() throws Exception {
 157                 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
 158                 String code = "test_menu";
 159                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
 160                                 .thenReturn(centralRoleFunction);
 161                 assertEquals(externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code),
 162                                 centralRoleFunction);
 163         }
 164
 165         @Test
 166         public void getRoleFunctionExceptionTest() throws Exception {
 167                 String code = "test_menu";
 168                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
 169                                 .thenThrow(httpClientErrorException);
 170                 assertNull(externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
 171         }
 172
 173         @Test
 174         public void saveRoleFunctionIfIsIsNotDeletedTest() throws Exception {
 175                 List<EPApp> applicationList = new ArrayList<EPApp>();
 176                 EPApp app = mockApp();
 177                 applicationList.add(app);
 178                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 179                 PortalRestResponse<String> portalRestResponse = null;
 180                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 181                 expectedportalRestResponse.setMessage(null);
 182                 expectedportalRestResponse.setResponse("Failed");
 183                 PortalRestStatusEnum portalRestStatusEnum = null;
 184                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 185                 String data = null;
 186                 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
 187                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralRoleFunction, app)).thenReturn(false);
 188                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 189                 assertEquals(portalRestResponse, expectedportalRestResponse);
 190         }
 191
 192         @Test
 193         public void saveRoleFunctionExceptionTest() 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                 PortalRestResponse<String> portalRestResponse = null;
 199                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 200                 expectedportalRestResponse.setMessage(null);
 201                 expectedportalRestResponse.setResponse("Failed");
 202                 PortalRestStatusEnum portalRestStatusEnum = null;
 203                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 204                 String data = null;
 205                 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
 206                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralRoleFunction, app)).thenThrow(nullPointerException);
 207                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 208                 System.out.println(portalRestResponse);
 209                 assertEquals(portalRestResponse, expectedportalRestResponse);
 210         }
 211
 212         @Test
 213         public void saveRoleFunctionTest() throws Exception {
 214                 List<EPApp> applicationList = new ArrayList<EPApp>();
 215                 List<CentralRole> answer = new ArrayList<>();
 216                 EPApp app = mockApp();
 217                 applicationList.add(app);
 218                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 219                 PortalRestResponse<String> portalRestResponse = null;
 220                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 221                 expectedportalRestResponse.setMessage(null);
 222                 expectedportalRestResponse.setResponse("Failed");
 223                 PortalRestStatusEnum portalRestStatusEnum = null;
 224                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 225                 String data = null;
 226                 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
 227                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralRoleFunction, app)).thenReturn(true);
 228                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 229                 System.out.println(portalRestResponse);
 230                 assertEquals(portalRestResponse, expectedportalRestResponse);
 231         }
 232
 233 //      @Test
 234 //      public void deleteRoleFunctionTest() throws Exception {
 235 //              PortalRestResponse<String> portalRestResponse = null;
 236 //              PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 237 //              expectedportalRestResponse.setMessage("Successfully Deleted");
 238 //              expectedportalRestResponse.setResponse("Success");
 239 //              PortalRestStatusEnum portalRestStatusEnum = null;
 240 //              EPUser user = mockUser.mockEPUser();
 241 //              EPApp app = mockApp();
 242 //              expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 243 //              String code ="testNew";
 244 //              Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LOGIN_ID"))).thenReturn((List<EPUser>) user);
 245 //              Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("UEBKEY")).get(0)).thenReturn(app);
 246 //              Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
 247 //              portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
 248 //              assertEquals(portalRestResponse, expectedportalRestResponse);
 249 //      }
 250
 251         @Test
 252         public void getActiveRolesTest() throws Exception {
 253                 List<CentralRole> cenRole = new ArrayList<>();
 254                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(cenRole);
 255                 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 256                 assertEquals(expectedCenRole, cenRole);
 257         }
 258
 259         @Test
 260         public void getActiveRolesExceptionTest() throws Exception {
 261                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey)))
 262                                 .thenThrow(httpClientErrorException);
 263                 assertNull(externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse));
 264         }
 265
 266         @Test
 267         public void deleteDependcyRoleRecordExceptionTest() throws Exception {
 268                 PortalRestResponse<String> portalRestResponse = null;
 269                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 270                 expectedportalRestResponse.setMessage("Failed to deleteDependencyRoleRecord");
 271                 expectedportalRestResponse.setResponse("Failed");
 272                 PortalRestStatusEnum portalRestStatusEnum = null;
 273                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 274                 long roleId = 123;
 275                 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
 276                 assertEquals(expectedportalRestResponse, portalRestResponse);
 277         }
 278
 279         @Test
 280         public void bulkUploadFunctionsTest() throws Exception {
 281                 Integer result = 0;
 282                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 283                                 .thenReturn(result);
 284                 PortalRestResponse<String> portalRestResponse = null;
 285                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 286                 expectedportalRestResponse.setMessage("Successfully added: 0");
 287                 expectedportalRestResponse.setResponse("Success");
 288                 PortalRestStatusEnum portalRestStatusEnum = null;
 289                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 290                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 291                 assertEquals(portalRestResponse, expectedportalRestResponse);
 292         }
 293
 294         @Test
 295         public void bulkUploadFunctionsExceptionTest() throws Exception {
 296                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 297                                 .thenThrow(httpClientErrorException);
 298                 PortalRestResponse<String> portalRestResponse = null;
 299                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 300                 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
 301                 expectedportalRestResponse.setResponse("Failed");
 302                 PortalRestStatusEnum portalRestStatusEnum = null;
 303                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 304                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 305                 assertEquals(portalRestResponse, expectedportalRestResponse);
 306         }
 307
 308         @Test
 309         public void bulkUploadRolesTest() throws Exception {
 310                 Integer result = 0;
 311                 PortalRestResponse<String> portalRestResponse = null;
 312                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 313                 expectedportalRestResponse.setMessage("Successfully added: 0");
 314                 expectedportalRestResponse.setResponse("Success");
 315                 PortalRestStatusEnum portalRestStatusEnum = null;
 316                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 317                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
 318                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 319                 assertEquals(portalRestResponse, expectedportalRestResponse);
 320         }
 321
 322         @Test
 323         public void bulkUploadRolesTestException() throws Exception {
 324                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
 325                                 .thenThrow(httpClientErrorException);
 326                 PortalRestResponse<String> portalRestResponse = null;
 327                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 328                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
 329                 expectedportalRestResponse.setResponse("Failed");
 330                 PortalRestStatusEnum portalRestStatusEnum = null;
 331                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 332                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 333                 assertEquals(portalRestResponse, expectedportalRestResponse);
 334         }
 335
 336         @Test
 337         public void bulkUploadRoleFunctionsTest() throws Exception {
 338                 Integer result = 0;
 339                 PortalRestResponse<String> portalRestResponse = null;
 340                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 341                 expectedportalRestResponse.setMessage("Successfully added: 0");
 342                 expectedportalRestResponse.setResponse("Success");
 343                 PortalRestStatusEnum portalRestStatusEnum = null;
 344                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 345                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 346                                 .thenReturn(result);
 347                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 348                 assertEquals(portalRestResponse, expectedportalRestResponse);
 349         }
 350
 351         @Test
 352         public void bulkUploadRoleFunctionsException() throws Exception {
 353                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 354                                 .thenThrow(httpClientErrorException);
 355                 PortalRestResponse<String> portalRestResponse = null;
 356                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 357                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
 358                 expectedportalRestResponse.setResponse("Failed");
 359                 PortalRestStatusEnum portalRestStatusEnum = null;
 360                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 361                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 362                 assertEquals(portalRestResponse, expectedportalRestResponse);
 363         }
 364
 365         @Test
 366         public void bulkUploadUserRolesTest() throws Exception {
 367                 Integer result = 0;
 368                 PortalRestResponse<String> portalRestResponse = null;
 369                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 370                 expectedportalRestResponse.setMessage("Successfully added: 0");
 371                 expectedportalRestResponse.setResponse("Success");
 372                 PortalRestStatusEnum portalRestStatusEnum = null;
 373                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 374                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 375                                 .thenReturn(result);
 376                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 377                 assertEquals(portalRestResponse, expectedportalRestResponse);
 378         }
 379
 380         @Test
 381         public void bulkUploadUserRolesExceptionTest() throws Exception {
 382                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 383                                 .thenThrow(httpClientErrorException);
 384                 PortalRestResponse<String> portalRestResponse = null;
 385                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 386                 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
 387                 expectedportalRestResponse.setResponse("Failed");
 388                 PortalRestStatusEnum portalRestStatusEnum = null;
 389                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 390                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 391                 assertEquals(portalRestResponse, expectedportalRestResponse);
 392         }
 393
 394         @Test
 395         public void bulkUploadPartnerFunctionsTest() throws Exception {
 396                 PortalRestResponse<String> portalRestResponse = null;
 397                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 398                 expectedportalRestResponse.setMessage("Successfully added");
 399                 expectedportalRestResponse.setResponse("Success");
 400                 PortalRestStatusEnum portalRestStatusEnum = null;
 401                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 402                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse, null);
 403                 assertEquals(portalRestResponse, expectedportalRestResponse);
 404         }
 405
 406
 407         @Test
 408         public void bulkUploadPartnerRolesTest() throws Exception {
 409                 PortalRestResponse<String> portalRestResponse = null;
 410                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 411                 expectedportalRestResponse.setMessage("Successfully added");
 412                 expectedportalRestResponse.setResponse("Success");
 413                 PortalRestStatusEnum portalRestStatusEnum = null;
 414                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 415                 List<Role> upload = new ArrayList<>();
 416                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
 417                                 upload);
 418                 assertEquals(portalRestResponse, expectedportalRestResponse);
 419         }
 420
 421          @Test
 422          public void bulkUploadPartnerRolesExceptionTest() throws Exception
 423          {
 424                  ExternalAccessRolesService externalAccessRolesService = null;
 425                 PortalRestResponse<String> portalRestResponse = null;
 426                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 427                 expectedportalRestResponse.setMessage("Successfully added");
 428                 expectedportalRestResponse.setResponse("Success");
 429                 PortalRestStatusEnum portalRestStatusEnum = null;
 430                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 431                 List<Role> upload = new ArrayList<>();
 432                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
 433                                 upload);
 434                 assertEquals(portalRestResponse, expectedportalRestResponse);
 435          }
 436
 437         @Test
 438         public void getMenuFunctionsTest() throws Exception {
 439                 List<String> functionsList = new ArrayList<>();
 440                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
 441                                 .thenReturn(functionsList);
 442                 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
 443                                 mockedResponse);
 444                 assertEquals(functionsList, expectedFunctionsList);
 445         }
 446
 447         @Test
 448         public void getMenuFunctionsExceptionTest() throws Exception {
 449                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
 450                                 .thenThrow(httpClientErrorException);
 451                 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
 452         }
 453
 454 //      @Test
 455 //      public void getUsersOfApplicationTest() throws Exception {
 456 //              List<String> users = new ArrayList<>();
 457 //              Mockito.when(externalAccessRolesService.getAllUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
 458 //              List<String> expectedusers = externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
 459 //              assertEquals(users, expectedusers);
 460 //      }
 461
 462 //      @Test
 463 //      public void getUsersOfApplicationExceptionTest() throws Exception {
 464 //              Mockito.when(externalAccessRolesService.getAllUsers(mockedRequest.getHeader(uebKey)))
 465 //                              .thenThrow(httpClientErrorException);
 466 //              assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
 467 //      }
 468
 469         @Test
 470         public void saveRoleExceptionTest() throws Exception {
 471                 Role role = new Role();
 472                 PortalRestResponse<String> portalRestResponse = null;
 473                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 474                 expectedportalRestResponse.setMessage("Failed to saveRole");
 475                 expectedportalRestResponse.setResponse("Failed");
 476                 PortalRestStatusEnum portalRestStatusEnum = null;
 477                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 478                 List<Role> upload = new ArrayList<>();
 479                 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
 480                 assertEquals(portalRestResponse, expectedportalRestResponse);
 481         }
 482
 483         @Test
 484         public void deleteRoleExceptionTest() throws Exception {
 485                 String role = "TestNew";
 486                 PortalRestResponse<String> portalRestResponse = null;
 487                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 488                 expectedportalRestResponse.setMessage("Failed to deleteRole for 'TestNew'");
 489                 expectedportalRestResponse.setResponse("Failed");
 490                 PortalRestStatusEnum portalRestStatusEnum = null;
 491                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 492                 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
 493                 assertEquals(portalRestResponse, expectedportalRestResponse);
 494         }
 495
 496
 497         @Test
 498         public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
 499                 PortalRestResponse<String> portalRestResponse = null;
 500                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 501                 expectedportalRestResponse.setMessage("Successfully added");
 502                 expectedportalRestResponse.setResponse("Success");
 503                 PortalRestStatusEnum portalRestStatusEnum = null;
 504                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 505                 List<Role> upload = new ArrayList<>();
 506                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse,upload);
 507                 assertEquals(portalRestResponse, expectedportalRestResponse);
 508         }
 509
 510         @Test
 511         public void getUsersOfApplicationTest() throws Exception
 512         {
 513                 List<EcompUser> users = new ArrayList<>();
 514                 EcompUser user = new EcompUser();
 515                 user.setOrgUserId("guestT");
 516                 users.add(user);
 517                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
 518                 List<EcompUser> expectedUsers =         externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
 519                 assertEquals(expectedUsers, users);
 520         }
 521
 522         @Test(expected = Exception.class)
 523         public void getUsersOfApplicationExceptionTest() throws Exception
 524         {
 525                 List<EcompUser> users = new ArrayList<>();
 526                 EcompUser user = new EcompUser();
 527                 user.setOrgUserId("guestT");
 528                 users.add(user);
 529                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
 530                 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
 531         }
 532 }