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

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