gerrit.onap Code Review - portal.git/blob

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