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