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

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2017 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.Ignore;
  56 import org.junit.Test;
  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.CentralRoleFunction;
  72 import org.onap.portalapp.portal.transport.CentralV2Role;
  73 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
  74 import org.onap.portalsdk.core.domain.AuditLog;
  75 import org.onap.portalsdk.core.domain.Role;
  76 import org.onap.portalsdk.core.restful.domain.EcompUser;
  77 import org.springframework.beans.BeanUtils;
  78 import org.springframework.http.HttpStatus;
  79 import org.springframework.http.ResponseEntity;
  80 import org.springframework.web.client.HttpClientErrorException;
  81
  82 import com.fasterxml.jackson.core.JsonProcessingException;
  83 import com.fasterxml.jackson.databind.ObjectMapper;
  84
  85 public class ExternalAccessRolesControllerTest {
  86
  87         @Mock
  88         ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
  89
  90         @InjectMocks
  91         ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
  92
  93         @Before
  94         public void setup() {
  95                 MockitoAnnotations.initMocks(this);
  96         }
  97         @Mock
  98         AuditLog auditLog = new AuditLog();
  99
 100         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
 101
 102         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
 103         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
 104         NullPointerException nullPointerException = new NullPointerException();
 105         HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
 106
 107         MockEPUser mockUser = new MockEPUser();
 108         String loginId = "guestT";
 109         String uebKey = "testUebKey";
 110
 111         @Test
 112         public void getUserTest() throws Exception {
 113                 String reason = getInvalidKeyJson();
 114                 StringWriter sw = new StringWriter();
 115                 PrintWriter writer = new PrintWriter(sw);
 116                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 117                 List<EPUser> userList = new ArrayList<>();
 118                 Mockito.when(externalAccessRolesService.getUser(loginId)).thenReturn(userList);
 119                 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 120                 String result = sw.getBuffer().toString().trim();
 121                 assertEquals(reason, result);
 122         }
 123
 124         @Test
 125         public void getUserExceptionTest() throws Exception {
 126                 String reason = getInvalidKeyJson();
 127                 StringWriter sw = new StringWriter();
 128                 PrintWriter writer = new PrintWriter(sw);
 129                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 130                 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 131                 String result = sw.getBuffer().toString().trim();
 132                 assertEquals(reason, result);
 133         }
 134
 135         public EPApp mockApp()
 136         {
 137                 EPApp app = new EPApp();
 138                 app.setName("Test");
 139                 app.setImageUrl("test");
 140                 app.setDescription("test");
 141                 app.setNotes("test");
 142                 app.setUrl("test");
 143                 app.setId((long) 1);
 144                 app.setAppRestEndpoint("test");
 145                 app.setAlternateUrl("test");
 146                 app.setName("test");
 147                 app.setMlAppName("test");
 148                 app.setMlAppAdminId("test");
 149                 app.setUsername("test");
 150                 app.setAppPassword("test");
 151                 app.setOpen(false);
 152                 app.setEnabled(false);
 153                 app.setUebKey("test");
 154                 app.setUebSecret("test");
 155                 app.setUebTopicName("test");
 156                 app.setAppType(1);
 157                 return app;
 158         }
 159
 160         @Test(expected = NullPointerException.class)
 161         public void getRolesForAppTest() throws Exception {
 162                 List<EPApp> applicationList = new ArrayList<EPApp>();
 163                 List<CentralV2Role> answer = new ArrayList<>();
 164                 EPApp app = mockApp();
 165                 applicationList.add(app);
 166                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 167                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 168                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
 169                 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
 170         }
 171
 172         @Test(expected = NullPointerException.class)
 173         public void getRolesForAppExceptionTest() throws Exception {
 174                 List<EPApp> applicationList = new ArrayList<EPApp>();
 175                 EPApp app = mockApp();
 176                 applicationList.add(app);
 177                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 178                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 179                 externalAccessRolesController.getRolesForApp(mockedRequest,mockedResponse);
 180                 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
 181                 assertEquals(null,role);
 182         }
 183
 184         @Test
 185         public void getRoleFunctionsListTest() throws Exception {
 186                 String reason = getInvalidKeyJson();
 187                 StringWriter sw = new StringWriter();
 188                 PrintWriter writer = new PrintWriter(sw);
 189                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 190                 List<CentralV2RoleFunction> answer = null;
 191                 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader(uebKey))).thenReturn(null);
 192                 assertEquals(externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse), answer);
 193                 String result = sw.getBuffer().toString().trim();
 194                 assertEquals(reason, result);
 195         }
 196
 197         @Test
 198         public void getRoleFunctionsListExceptionTest() throws Exception {
 199                 String reason = getInvalidKeyJson();
 200                 StringWriter sw = new StringWriter();
 201                 PrintWriter writer = new PrintWriter(sw);
 202                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 203                 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
 204                 String result = sw.getBuffer().toString().trim();
 205                 assertEquals(reason, result);
 206         }
 207
 208         @Test
 209         public void getRoleInfoTest() throws Exception {
 210                 String reason = getInvalidKeyJson();
 211                 StringWriter sw = new StringWriter();
 212                 PrintWriter writer = new PrintWriter(sw);
 213                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 214                 CentralV2Role answer = new CentralV2Role();
 215                 long roleId = 1;
 216                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
 217                                 .thenReturn(answer);
 218                 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
 219                 String result = sw.getBuffer().toString().trim();
 220                 assertEquals(reason, result);
 221         }
 222
 223         @Test
 224         public void getRoleInfoExceptionTest() throws Exception {
 225                 String reason = getInvalidKeyJson();
 226                 StringWriter sw = new StringWriter();
 227                 PrintWriter writer = new PrintWriter(sw);
 228                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 229                 long roleId = 1;
 230                 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
 231                 String result = sw.getBuffer().toString().trim();
 232                 assertEquals(reason, result);
 233         }
 234
 235         @Test
 236         public void getRoleFunctionTest() throws Exception {
 237                 String reason = getInvalidKeyJson();
 238                 StringWriter sw = new StringWriter();
 239                 PrintWriter writer = new PrintWriter(sw);
 240                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 241                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 242                 CentralRoleFunction centralRoleFunction = new CentralRoleFunction();
 243                 String code = "test_menu";
 244                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
 245                                 .thenReturn(centralV2RoleFunction);
 246                 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code);
 247                 BeanUtils.copyProperties(centralV2RoleFunction, centralRoleFunction, "type","action");
 248                 assertEquals(returnedValue,centralRoleFunction);
 249                 String result = sw.getBuffer().toString().trim();
 250                 assertEquals(reason, result);
 251         }
 252
 253         @Test
 254         public void getRoleFunctionExceptionTest() throws Exception {
 255                 String reason = getInvalidKeyJson();
 256                 StringWriter sw = new StringWriter();
 257                 PrintWriter writer = new PrintWriter(sw);
 258                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 259                 String code = "test_menu";
 260                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
 261                                 .thenThrow(httpClientErrorException);
 262                 assertEquals(new CentralRoleFunction(),externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
 263                 String result = sw.getBuffer().toString().trim();
 264                 assertEquals(reason, result);
 265         }
 266
 267         @Test(expected = NullPointerException.class)
 268         public void saveRoleFunctionIfIsIsNotDeletedTest() throws Exception {
 269                 List<EPApp> applicationList = new ArrayList<EPApp>();
 270                 EPApp app = mockApp();
 271                 applicationList.add(app);
 272                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 273                 PortalRestResponse<String> portalRestResponse = null;
 274                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 275                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 276                 expectedportalRestResponse.setResponse("Failed");
 277                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 278                 String data = null;
 279                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 280                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
 281                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 282                 assertEquals(portalRestResponse, expectedportalRestResponse);
 283         }
 284
 285         @Test(expected = NullPointerException.class)
 286         public void saveRoleFunctionExceptionTest() throws Exception {
 287                 List<EPApp> applicationList = new ArrayList<EPApp>();
 288                 EPApp app = mockApp();
 289                 applicationList.add(app);
 290                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 291                 PortalRestResponse<String> portalRestResponse = null;
 292                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 293                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 294                 expectedportalRestResponse.setResponse("Failed");
 295                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 296                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
 297                 System.out.println(portalRestResponse);
 298                 assertEquals(portalRestResponse, expectedportalRestResponse);
 299         }
 300
 301         @Test(expected = NullPointerException.class)
 302         public void saveRoleFunctionTest() throws Exception {
 303                 List<EPApp> applicationList = new ArrayList<EPApp>();
 304                 EPApp app = mockApp();
 305                 applicationList.add(app);
 306                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 307                 PortalRestResponse<String> portalRestResponse = null;
 308                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 309                 expectedportalRestResponse.setMessage(null);
 310                 expectedportalRestResponse.setResponse("Failed");
 311                 PortalRestStatusEnum portalRestStatusEnum = null;
 312                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 313                 String data = null;
 314                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 315                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(true);
 316                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 317                 System.out.println(portalRestResponse);
 318                 assertEquals(portalRestResponse, expectedportalRestResponse);
 319         }
 320
 321         @Test
 322         @Ignore
 323         public void deleteRoleFunctionTest() throws Exception {
 324                 PortalRestResponse<String> portalRestResponse = null;
 325                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 326                 expectedportalRestResponse.setMessage("Successfully Deleted");
 327                 expectedportalRestResponse.setResponse("Success");
 328                 PortalRestStatusEnum portalRestStatusEnum = null;
 329                 EPUser user = mockUser.mockEPUser();
 330                 EPApp app = mockApp();
 331                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 332                 String code ="testNew";
 333                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LOGIN_ID"))).thenReturn((List<EPUser>) user);
 334                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("UEBKEY")).get(0)).thenReturn(app);
 335                 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
 336                 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
 337                 assertEquals(portalRestResponse, expectedportalRestResponse);
 338         }
 339
 340         @Test
 341         public void getActiveRolesTest() throws Exception {
 342                 String reason = getInvalidKeyJson();
 343                 StringWriter sw = new StringWriter();
 344                 PrintWriter writer = new PrintWriter(sw);
 345                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 346                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
 347                 List<CentralV2Role> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 348                 assertNull(expectedCenRole);
 349                 String result = sw.getBuffer().toString().trim();
 350                 assertEquals(reason, result);
 351         }
 352
 353         @Test
 354         public void getActiveRolesExceptionTest() throws Exception {
 355                 String reason = getInvalidKeyJson();
 356                 StringWriter sw = new StringWriter();
 357                 PrintWriter writer = new PrintWriter(sw);
 358                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 359                 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 360                 String result = sw.getBuffer().toString().trim();
 361                 assertEquals(reason, result);
 362         }
 363
 364         /**
 365          * It return JSON string which has error information
 366          *
 367          * @return JSON String
 368          * @throws JsonProcessingException
 369          */
 370         private String getInvalidKeyJson() throws JsonProcessingException {
 371                 final Map<String,String> uebkeyResponse = new HashMap<>();
 372                 String reason = "";
 373                 ObjectMapper mapper = new ObjectMapper();
 374                 uebkeyResponse.put("error","Invalid uebkey!");
 375                 reason = mapper.writeValueAsString(uebkeyResponse);
 376                 return reason;
 377         }
 378
 379         @Test
 380         public void deleteDependcyRoleRecordExceptionTest() throws Exception {
 381                 PortalRestResponse<String> portalRestResponse = null;
 382                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 383                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 384                 expectedportalRestResponse.setResponse("Failed");
 385                 PortalRestStatusEnum portalRestStatusEnum = null;
 386                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 387                 long roleId = 123;
 388                 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
 389                 assertEquals(expectedportalRestResponse, portalRestResponse);
 390         }
 391
 392         @Test
 393         public void bulkUploadFunctionsTest() throws Exception {
 394                 Integer result = 0;
 395                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 396                                 .thenReturn(result);
 397                 PortalRestResponse<String> portalRestResponse = null;
 398                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 399                 expectedportalRestResponse.setMessage("Successfully added: 0");
 400                 expectedportalRestResponse.setResponse("Success");
 401                 PortalRestStatusEnum portalRestStatusEnum = null;
 402                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 403                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 404                 assertEquals(portalRestResponse, expectedportalRestResponse);
 405         }
 406
 407         @Test
 408         public void bulkUploadFunctionsExceptionTest() throws Exception {
 409                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 410                                 .thenThrow(httpClientErrorException);
 411                 PortalRestResponse<String> portalRestResponse = null;
 412                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 413                 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
 414                 expectedportalRestResponse.setResponse("Failed");
 415                 PortalRestStatusEnum portalRestStatusEnum = null;
 416                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 417                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 418                 assertEquals(portalRestResponse, expectedportalRestResponse);
 419         }
 420
 421         @Test
 422         public void bulkUploadRolesTest() throws Exception {
 423                 Integer result = 0;
 424                 PortalRestResponse<String> portalRestResponse = null;
 425                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 426                 expectedportalRestResponse.setMessage("Successfully added: 0");
 427                 expectedportalRestResponse.setResponse("Success");
 428                 PortalRestStatusEnum portalRestStatusEnum = null;
 429                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 430                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
 431                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 432                 assertEquals(portalRestResponse, expectedportalRestResponse);
 433         }
 434
 435         @Test
 436         public void bulkUploadRolesTestException() throws Exception {
 437                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
 438                                 .thenThrow(httpClientErrorException);
 439                 PortalRestResponse<String> portalRestResponse = null;
 440                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 441                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
 442                 expectedportalRestResponse.setResponse("Failed");
 443                 PortalRestStatusEnum portalRestStatusEnum = null;
 444                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 445                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 446                 assertEquals(portalRestResponse, expectedportalRestResponse);
 447         }
 448
 449         @Test
 450         public void bulkUploadRoleFunctionsTest() throws Exception {
 451                 Integer result = 0;
 452                 PortalRestResponse<String> portalRestResponse = null;
 453                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 454                 expectedportalRestResponse.setMessage("Successfully added: 0");
 455                 expectedportalRestResponse.setResponse("Success");
 456                 PortalRestStatusEnum portalRestStatusEnum = null;
 457                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 458                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 459                                 .thenReturn(result);
 460                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 461                 assertEquals(portalRestResponse, expectedportalRestResponse);
 462         }
 463
 464         @Test
 465         public void bulkUploadRoleFunctionsException() throws Exception {
 466                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 467                                 .thenThrow(httpClientErrorException);
 468                 PortalRestResponse<String> portalRestResponse = null;
 469                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 470                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
 471                 expectedportalRestResponse.setResponse("Failed");
 472                 PortalRestStatusEnum portalRestStatusEnum = null;
 473                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 474                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 475                 assertEquals(portalRestResponse, expectedportalRestResponse);
 476         }
 477
 478         @Test
 479         public void bulkUploadUserRolesTest() throws Exception {
 480                 Integer result = 0;
 481                 PortalRestResponse<String> portalRestResponse = null;
 482                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 483                 expectedportalRestResponse.setMessage("Successfully added: 0");
 484                 expectedportalRestResponse.setResponse("Success");
 485                 PortalRestStatusEnum portalRestStatusEnum = null;
 486                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 487                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 488                                 .thenReturn(result);
 489                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 490                 assertEquals(portalRestResponse, expectedportalRestResponse);
 491         }
 492
 493         @Test
 494         public void bulkUploadUserRolesExceptionTest() throws Exception {
 495                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 496                                 .thenThrow(httpClientErrorException);
 497                 PortalRestResponse<String> portalRestResponse = null;
 498                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 499                 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
 500                 expectedportalRestResponse.setResponse("Failed");
 501                 PortalRestStatusEnum portalRestStatusEnum = null;
 502                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 503                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 504                 assertEquals(portalRestResponse, expectedportalRestResponse);
 505         }
 506
 507         @Test
 508         public void bulkUploadPartnerFunctionsTest() throws Exception {
 509                 PortalRestResponse<String> portalRestResponse = null;
 510                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 511                 expectedportalRestResponse.setMessage("Successfully added");
 512                 expectedportalRestResponse.setResponse("Success");
 513                 PortalRestStatusEnum portalRestStatusEnum = null;
 514                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 515                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse, null);
 516                 assertEquals(portalRestResponse, expectedportalRestResponse);
 517         }
 518
 519
 520         @Test
 521         public void bulkUploadPartnerRolesTest() throws Exception {
 522                 PortalRestResponse<String> portalRestResponse = null;
 523                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 524                 expectedportalRestResponse.setMessage("Successfully added");
 525                 expectedportalRestResponse.setResponse("Success");
 526                 PortalRestStatusEnum portalRestStatusEnum = null;
 527                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 528                 List<Role> upload = new ArrayList<>();
 529                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
 530                                 upload);
 531                 assertEquals(portalRestResponse, expectedportalRestResponse);
 532         }
 533
 534          @Test
 535          public void bulkUploadPartnerRolesExceptionTest() throws Exception
 536          {
 537                  ExternalAccessRolesService externalAccessRolesService = null;
 538                 PortalRestResponse<String> portalRestResponse = null;
 539                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 540                 expectedportalRestResponse.setMessage("Successfully added");
 541                 expectedportalRestResponse.setResponse("Success");
 542                 PortalRestStatusEnum portalRestStatusEnum = null;
 543                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 544                 List<Role> upload = new ArrayList<>();
 545                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
 546                                 upload);
 547                 assertEquals(portalRestResponse, expectedportalRestResponse);
 548          }
 549
 550         @Test
 551         public void getMenuFunctionsTest() throws Exception {
 552                 String reason = getInvalidKeyJson();
 553                 StringWriter sw = new StringWriter();
 554                 PrintWriter writer = new PrintWriter(sw);
 555                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 556                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
 557                                 .thenReturn(null);
 558                 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
 559                                 mockedResponse);
 560                 assertNull(expectedFunctionsList);
 561                 String result = sw.getBuffer().toString().trim();
 562                 assertEquals(reason, result);
 563         }
 564
 565         @Test
 566         public void getMenuFunctionsExceptionTest() throws Exception {
 567                 String reason = getInvalidKeyJson();
 568                 StringWriter sw = new StringWriter();
 569                 PrintWriter writer = new PrintWriter(sw);
 570                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 571                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
 572                                 .thenThrow(httpClientErrorException);
 573                 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
 574                 String result = sw.getBuffer().toString().trim();
 575                 assertEquals(reason, result);
 576         }
 577
 578
 579         @Test
 580         public void saveRoleExceptionTest() throws Exception {
 581                 Role role = new Role();
 582                 PortalRestResponse<String> portalRestResponse = null;
 583                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 584                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 585                 expectedportalRestResponse.setResponse("Failed");
 586                 PortalRestStatusEnum portalRestStatusEnum = null;
 587                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 588                 List<Role> upload = new ArrayList<>();
 589                 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
 590
 591                 assertEquals(portalRestResponse, expectedportalRestResponse);
 592         }
 593
 594         @Test
 595         public void deleteRoleExceptionTest() throws Exception {
 596                 String role = "TestNew";
 597                 PortalRestResponse<String> portalRestResponse = null;
 598                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 599                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 600                 expectedportalRestResponse.setResponse("Failed");
 601                 PortalRestStatusEnum portalRestStatusEnum = null;
 602                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 603                 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
 604                 assertEquals(portalRestResponse, expectedportalRestResponse);
 605         }
 606
 607
 608         @Test
 609         public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
 610                 PortalRestResponse<String> portalRestResponse = null;
 611                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 612                 expectedportalRestResponse.setMessage("Successfully added");
 613                 expectedportalRestResponse.setResponse("Success");
 614                 PortalRestStatusEnum portalRestStatusEnum = null;
 615                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 616                 List<Role> upload = new ArrayList<>();
 617                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse,upload);
 618                 assertEquals(portalRestResponse, expectedportalRestResponse);
 619         }
 620
 621         @Test
 622         public void getUsersOfApplicationTest() throws Exception
 623         {
 624                 List<EcompUser> users = new ArrayList<>();
 625                 EcompUser user = new EcompUser();
 626                 user.setOrgUserId("guestT");
 627                 users.add(user);
 628                 StringWriter sw = new StringWriter();
 629                 PrintWriter writer = new PrintWriter(sw);
 630                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 631                 List<EPApp> applicationList = new ArrayList<EPApp>();
 632                 EPApp app = mockApp();
 633                 app.setCentralAuth(true);
 634                 applicationList.add(app);
 635                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 636                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
 637                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
 638                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
 639                 List<EcompUser> expectedUsers =         externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
 640                 assertEquals(expectedUsers, users);
 641         }
 642
 643         @Test(expected = Exception.class)
 644         public void getUsersOfApplicationExceptionTest() throws Exception
 645         {
 646                 List<EcompUser> users = new ArrayList<>();
 647                 EcompUser user = new EcompUser();
 648                 user.setOrgUserId("guestT");
 649                 users.add(user);
 650                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
 651                 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
 652         }
 653
 654         @Test(expected = NullPointerException.class)
 655         public void deleteRoleV2Test() throws Exception
 656         {
 657                 List<EPApp> applicationList = new ArrayList<EPApp>();
 658                 EPApp app = mockApp();
 659                 applicationList.add(app);
 660                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 661                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
 662                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
 663                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 664                 expectedportalRestResponse.setMessage("Successfully Deleted");
 665                 expectedportalRestResponse.setResponse("Success");
 666                 PortalRestStatusEnum portalRestStatusEnum = null;
 667                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 668                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
 669                 assertNull(actualResponse);
 670         }
 671
 672         @Test
 673         public void deleteRoleV2InvalidUebKeyTest() throws Exception
 674         {
 675                 List<EPApp> applicationList = new ArrayList<EPApp>();
 676                 EPApp app = mockApp();
 677                 applicationList.add(app);
 678                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("Invalid uebkey!"));
 679                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 680                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 681                 expectedportalRestResponse.setResponse("Failed");
 682                 PortalRestStatusEnum portalRestStatusEnum = null;
 683                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 684                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
 685                 assertEquals(actualResponse, expectedportalRestResponse);
 686         }
 687
 688         @Test
 689         public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception
 690         {
 691                 List<EPApp> applicationList = new ArrayList<EPApp>();
 692                 EPApp app = mockApp();
 693                 applicationList.add(app);
 694                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("test"));
 695                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 696                 expectedportalRestResponse.setMessage("test");
 697                 expectedportalRestResponse.setResponse("Failed");
 698                 PortalRestStatusEnum portalRestStatusEnum = null;
 699                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 700                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
 701                 assertEquals(actualResponse, expectedportalRestResponse);
 702         }
 703
 704
 705         @Test(expected = NullPointerException.class)
 706         public void deleteRoleV2ExceptionTest() throws Exception
 707         {
 708                 List<EPApp> applicationList = new ArrayList<EPApp>();
 709                 EPApp app = mockApp();
 710                 applicationList.add(app);
 711                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 712                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
 713                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
 714                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 715                 expectedportalRestResponse.setMessage("Failed to deleteRole");
 716                 expectedportalRestResponse.setResponse("Failed");
 717                 PortalRestStatusEnum portalRestStatusEnum = null;
 718                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 719                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
 720                 assertEquals(actualResponse, null);
 721         }
 722 }