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.CentralUser;
  75 import org.onap.portalapp.portal.transport.CentralV2Role;
  76 import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
  77 import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
  78 import org.onap.portalapp.portal.utils.EcompPortalUtils;
  79 import org.onap.portalapp.portal.utils.PortalConstants;
  80 import org.onap.portalsdk.core.domain.AuditLog;
  81 import org.onap.portalsdk.core.domain.Role;
  82 import org.onap.portalsdk.core.domain.User;
  83 import org.onap.portalsdk.core.restful.domain.EcompRole;
  84 import org.onap.portalsdk.core.restful.domain.EcompUser;
  85 import org.onap.portalsdk.core.service.AuditService;
  86 import org.onap.portalsdk.core.service.UserService;
  87 import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
  88 import org.onap.portalsdk.core.util.SystemProperties;
  89 import org.powermock.api.mockito.PowerMockito;
  90 import org.powermock.core.classloader.annotations.PrepareForTest;
  91 import org.powermock.modules.junit4.PowerMockRunner;
  92 import org.springframework.http.HttpStatus;
  93 import org.springframework.http.ResponseEntity;
  94 import org.springframework.test.util.MatcherAssertionErrors;
  95 import org.springframework.web.client.HttpClientErrorException;
  96
  97 import com.fasterxml.jackson.core.JsonProcessingException;
  98 import com.fasterxml.jackson.databind.DeserializationFeature;
  99 import com.fasterxml.jackson.databind.ObjectMapper;
 100
 101 @RunWith(PowerMockRunner.class)
 102 @PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
 103                 EPCommonSystemProperties.class })
 104 public class ExternalAccessRolesControllerTest {
 105
 106         @Mock
 107         ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
 108
 109         @InjectMocks
 110         ExternalAccessRolesController externalAccessRolesController = new ExternalAccessRolesController();
 111         @Mock
 112         UserService userservice =  new UserServiceCentalizedImpl();
 113
 114         @Mock
 115         AuditService auditService;
 116
 117         @Before
 118         public void setup() {
 119                 MockitoAnnotations.initMocks(this);
 120         }
 121         @Mock
 122         AuditLog auditLog = new AuditLog();
 123
 124         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
 125
 126         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
 127         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
 128         NullPointerException nullPointerException = new NullPointerException();
 129         HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
 130
 131         MockEPUser mockUser = new MockEPUser();
 132         String loginId = "guestT";
 133         String uebKey = "testUebKey";
 134
 135         public EPApp mockApp()
 136         {
 137                 EPApp app = new EPApp();
 138                 app.setName("Test");
 139                 app.setImageUrl("test");
 140                 app.setDescription("test");
 141                 app.setNotes("test");
 142                 app.setUrl("test");
 143                 app.setId((long) 1);
 144                 app.setAppRestEndpoint("test");
 145                 app.setAlternateUrl("test");
 146                 app.setName("test");
 147                 app.setMlAppName("test");
 148                 app.setMlAppAdminId("test");
 149                 app.setUsername("test");
 150                 app.setAppPassword("test");
 151                 app.setOpen(false);
 152                 app.setEnabled(false);
 153                 app.setUebKey("test");
 154                 app.setUebSecret("test");
 155                 app.setUebTopicName("test");
 156                 app.setAppType(1);
 157                 return app;
 158         }
 159
 160         @Test
 161         public void getUserTest() throws Exception {
 162                 CentralUser expectedCentralUser = new CentralUser(null, null, null, null, null, null, null, null, loginId, loginId, loginId, loginId, loginId, loginId, loginId, null, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, null, false, false, null, null, false, loginId, null);
 163                 String loginId = "test";
 164                 StringWriter sw = new StringWriter();
 165                 PrintWriter writer = new PrintWriter(sw);
 166                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 167                 EPApp app = mockApp();
 168                 app.setCentralAuth(true);
 169                 List<EPApp> appList = new ArrayList<>();
 170                 appList.add(app);
 171                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 172                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 173                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 174                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 175                 Mockito.when(externalAccessRolesService.getUserRoles(loginId, mockedRequest.getHeader("uebkey"))).thenReturn(expectedCentralUser);
 176                 CentralUser actualCentralUser = externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 177                 assertEquals(actualCentralUser.isActive(), expectedCentralUser.isActive());
 178         }
 179
 180         @Test
 181         public void getUserExceptionTest() throws Exception {
 182                 String reason = getInvalidKeyJson();
 183                 StringWriter sw = new StringWriter();
 184                 PrintWriter writer = new PrintWriter(sw);
 185                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 186                 externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
 187                 String result = sw.getBuffer().toString().trim();
 188                 assertEquals(reason, result);
 189         }
 190
 191         @Test
 192         public void getV2UserListTest() throws Exception {
 193                 String expectedCentralUser = "test";
 194                 String loginId = "test";
 195                 EPApp app = mockApp();
 196                 app.setCentralAuth(true);
 197                 List<EPApp> appList = new ArrayList<>();
 198                 appList.add(app);
 199                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 200                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 201                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 202                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 203                 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey"))).thenReturn(expectedCentralUser);
 204                 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
 205                 assertEquals(actualString, expectedCentralUser);
 206         }
 207
 208         @Test(expected = NullPointerException.class)
 209         public void getV2UserListExceptionTest() throws Exception {
 210                 String expectedCentralUser = null;
 211                 String loginId = "test";
 212                 EPApp app = mockApp();
 213                 app.setCentralAuth(true);
 214                 List<EPApp> appList = new ArrayList<>();
 215                 appList.add(app);
 216                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 217                 ResponseEntity<String> response = null;
 218                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 219                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 220                 Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey"))).thenReturn(expectedCentralUser);
 221                 String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
 222                 assertEquals(actualString, expectedCentralUser);
 223         }
 224
 225         @Test
 226         public void getRolesForAppCentralRoleTest() throws Exception {
 227                 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
 228                 List<EPApp> applicationList = new ArrayList<EPApp>();
 229                 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
 230                 List<CentralRole> centralRoleList = new ArrayList<>();
 231                 EPApp app = mockApp();
 232                 app.setCentralAuth(true);
 233                 applicationList.add(app);
 234                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 235                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 236                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 237                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 238                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 239                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(centralV2RoleList);
 240                 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList)).thenReturn(centralRoleList);
 241                 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
 242                 assertEquals(actualCentralRoleList.size(), expectedCentralRoleList.size());
 243         }
 244
 245         @Test(expected = NullPointerException.class)
 246         public void getRolesForAppCentralRoleExceptionTest() throws Exception {
 247                 List<EPApp> applicationList = new ArrayList<EPApp>();
 248                 List<CentralV2Role> centralV2RoleList = new ArrayList<>();
 249                 List<CentralRole> centralRoleList = new ArrayList<>();
 250                 EPApp app = mockApp();
 251                 app.setCentralAuth(true);
 252                 applicationList.add(app);
 253                 ResponseEntity<String> response = null;
 254                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 255                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 256                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 257                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 258                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(centralV2RoleList);
 259                 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList)).thenReturn(centralRoleList);
 260                 List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
 261                 assertEquals(null,actualCentralRoleList);
 262         }
 263
 264         @Test
 265         public void getV2RolesForAppTest() throws Exception {
 266                 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
 267                 List<EPApp> applicationList = new ArrayList<EPApp>();
 268                 List<CentralV2Role> centralV2Role = new ArrayList<>();
 269                 EPApp app = mockApp();
 270                 app.setCentralAuth(true);
 271                 applicationList.add(app);
 272                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 273                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 274                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 275                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 276                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 277                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(centralV2Role);
 278                 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest, mockedResponse);
 279                 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
 280         }
 281
 282         @Test(expected = NullPointerException.class)
 283         public void getV2RolesForAppExceptionTest() throws Exception {
 284                 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
 285                 List<EPApp> applicationList = new ArrayList<EPApp>();
 286                 List<CentralV2Role> centralV2Role = new ArrayList<>();
 287                 EPApp app = mockApp();
 288                 app.setCentralAuth(true);
 289                 applicationList.add(app);
 290                 ResponseEntity<String> response = null;
 291                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 292                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 293                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 294                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 295                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(centralV2Role);
 296                 List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest, mockedResponse);
 297                 assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
 298         }
 299
 300         @Test(expected = NullPointerException.class)
 301         public void getRolesForAppTest() throws Exception {
 302                 List<EPApp> applicationList = new ArrayList<EPApp>();
 303                 List<CentralV2Role> answer = new ArrayList<>();
 304                 EPApp app = mockApp();
 305                 applicationList.add(app);
 306                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 307                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 308                 Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
 309                 assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
 310         }
 311
 312         @Test(expected = NullPointerException.class)
 313         public void getRolesForAppExceptionTest() throws Exception {
 314                 List<EPApp> applicationList = new ArrayList<EPApp>();
 315                 EPApp app = mockApp();
 316                 applicationList.add(app);
 317                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 318                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 319                 externalAccessRolesController.getRolesForApp(mockedRequest,mockedResponse);
 320                 List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
 321                 assertEquals(null,role);
 322         }
 323
 324         @Test
 325         public void getRoleFunctionsListTest() throws Exception {
 326                 List<CentralRole> expectedCentralRoleList = new ArrayList<CentralRole>();
 327                 List<CentralRoleFunction> roleFuncList = new ArrayList<CentralRoleFunction>();
 328                 List<EPApp> applicationList = new ArrayList<EPApp>();
 329                 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
 330                 EPApp app = mockApp();
 331                 app.setCentralAuth(true);
 332                 applicationList.add(app);
 333                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 334                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 335                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 336                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 337                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 338                 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey"))).thenReturn(centralV2RoleFunction);
 339                 Mockito.when(externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(centralV2RoleFunction)).thenReturn(roleFuncList);
 340                 List<CentralRoleFunction> actualCentralRoleFunction = externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
 341                 assertEquals(actualCentralRoleFunction.size(), expectedCentralRoleList.size());
 342         }
 343
 344         @Test
 345         public void getRoleFunctionsListExceptionTest() throws Exception {
 346                 String reason = getInvalidKeyJson();
 347                 StringWriter sw = new StringWriter();
 348                 PrintWriter writer = new PrintWriter(sw);
 349                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 350                 externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
 351                 String result = sw.getBuffer().toString().trim();
 352                 assertEquals(reason, result);
 353         }
 354
 355         @Test
 356         public void getV2RoleFunctionsListTest() throws Exception {
 357                 List<CentralV2RoleFunction> expectedCentralV2RoleFunctionList = new ArrayList<CentralV2RoleFunction>();
 358                 List<EPApp> applicationList = new ArrayList<EPApp>();
 359                 List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
 360                 EPApp app = mockApp();
 361                 app.setCentralAuth(true);
 362                 applicationList.add(app);
 363                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 364                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 365                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 366                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 367                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
 368                 Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey"))).thenReturn(centralV2RoleFunction);
 369                 List<CentralV2RoleFunction> actualCentralV2RoleFunctionList = externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
 370                 assertEquals(actualCentralV2RoleFunctionList.size(), expectedCentralV2RoleFunctionList.size());
 371         }
 372
 373         @Test
 374         public void getV2RoleFunctionsListExceptionTest() throws Exception {
 375                 String reason = getInvalidKeyJson();
 376                 StringWriter sw = new StringWriter();
 377                 PrintWriter writer = new PrintWriter(sw);
 378                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 379                 externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
 380                 String result = sw.getBuffer().toString().trim();
 381                 assertEquals(reason, result);
 382         }
 383
 384         @Test
 385         public void getRoleInfoValidationTest() throws Exception {
 386                 CentralRole expectedCentralRole = null;
 387                 List<EPApp> applicationList = new ArrayList<EPApp>();
 388                 long roleId = 1;
 389                 CentralV2Role centralV2Role = new CentralV2Role();
 390                 EPApp app = mockApp();
 391                 app.setCentralAuth(true);
 392                 applicationList.add(app);
 393                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 394                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 395                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 396                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 397                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey"))).thenReturn(centralV2Role);
 398                 CentralRole actualCentralRole = externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
 399                 assertEquals(actualCentralRole, expectedCentralRole);
 400         }
 401
 402         @Test
 403         public void getRoleInfoTest() throws Exception {
 404                 String reason = getInvalidKeyJson();
 405                 StringWriter sw = new StringWriter();
 406                 PrintWriter writer = new PrintWriter(sw);
 407                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 408                 CentralV2Role answer = new CentralV2Role();
 409                 long roleId = 1;
 410                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
 411                                 .thenReturn(answer);
 412                 externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
 413                 String result = sw.getBuffer().toString().trim();
 414                 assertEquals(reason, result);
 415         }
 416
 417         @Test
 418         public void getRoleInfoExceptionTest() throws Exception {
 419                 String reason = getInvalidKeyJson();
 420                 StringWriter sw = new StringWriter();
 421                 PrintWriter writer = new PrintWriter(sw);
 422                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 423                 long roleId = 1;
 424                 assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
 425                 String result = sw.getBuffer().toString().trim();
 426                 assertEquals(reason, result);
 427         }
 428
 429         @Test
 430         public void getV2RoleInfoValidationTest() throws Exception {
 431                 CentralV2Role  expectedCentralRole = new CentralV2Role();
 432                 expectedCentralRole.setActive(false);
 433                 List<EPApp> applicationList = new ArrayList<EPApp>();
 434                 long roleId = 1;
 435                 CentralV2Role centralV2Role = new CentralV2Role();
 436                 EPApp app = mockApp();
 437                 app.setCentralAuth(true);
 438                 applicationList.add(app);
 439                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 440                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 441                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 442                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 443                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey"))).thenReturn(centralV2Role);
 444                 CentralV2Role actualCentralRole = externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
 445                 assertEquals(actualCentralRole.getActive(), expectedCentralRole.getActive());
 446         }
 447
 448         @Test
 449         public void getV2RoleInfoTest() throws Exception {
 450                 String reason = getInvalidKeyJson();
 451                 StringWriter sw = new StringWriter();
 452                 PrintWriter writer = new PrintWriter(sw);
 453                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 454                 CentralV2Role answer = new CentralV2Role();
 455                 long roleId = 1;
 456                 Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
 457                                 .thenReturn(answer);
 458                 externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
 459                 String result = sw.getBuffer().toString().trim();
 460                 assertEquals(reason, result);
 461         }
 462
 463         @Test
 464         public void getV2RoleInfoExceptionTest() throws Exception {
 465                 String reason = getInvalidKeyJson();
 466                 StringWriter sw = new StringWriter();
 467                 PrintWriter writer = new PrintWriter(sw);
 468                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 469                 long roleId = 1;
 470                 assertNull(externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId));
 471                 String result = sw.getBuffer().toString().trim();
 472                 assertEquals(reason, result);
 473         }
 474
 475         @Test
 476         public void getV2RoleFunctionTest() throws HttpClientErrorException, Exception{
 477                 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
 478                 expectedCentralV2RoleFunction.setCode("test");
 479                 List<EPApp> applicationList = new ArrayList<EPApp>();
 480                 String code = "test";
 481                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 482                 centralV2RoleFunction.setCode("test");
 483                 EPApp app = mockApp();
 484                 app.setCentralAuth(true);
 485                 applicationList.add(app);
 486                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 487                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 488                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 489                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 490                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey"))).thenReturn(centralV2RoleFunction);
 491                 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code);
 492                 assertEquals(actualCentralV2RoleFunction.getCode(), expectedCentralV2RoleFunction.getCode());
 493         }
 494
 495         @Test
 496         public void getV2RoleFunctionNullCheckTest() throws HttpClientErrorException, Exception{
 497                 CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
 498                 List<EPApp> applicationList = new ArrayList<EPApp>();
 499                 String code = "test";
 500                 CentralV2RoleFunction centralV2RoleFunction = null;
 501                 EPApp app = mockApp();
 502                 app.setCentralAuth(true);
 503                 applicationList.add(app);
 504                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 505                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 506                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 507                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 508                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey"))).thenReturn(centralV2RoleFunction);
 509                 CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code);
 510                 assertEquals(actualCentralV2RoleFunction.getAction(), expectedCentralV2RoleFunction.getAction());
 511         }
 512
 513         @Test
 514         public void getV2RoleFunctionExceptionTest() throws Exception {
 515                 String reason = getInvalidKeyJson();
 516                 StringWriter sw = new StringWriter();
 517                 PrintWriter writer = new PrintWriter(sw);
 518                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 519                 String code = "test";
 520                 assertNull(externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code));
 521                 String result = sw.getBuffer().toString().trim();
 522                 assertEquals(reason, result);
 523         }
 524
 525         @Test
 526         public void getRoleFunctionTest() throws Exception {
 527                 EPApp mockApp = mockApp();
 528                 mockApp.setCentralAuth(true);
 529                 List<EPApp> mockAppList = new ArrayList<>();
 530                 mockAppList.add(mockApp);
 531                 StringWriter sw = new StringWriter();
 532                 PrintWriter writer = new PrintWriter(sw);
 533                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 534                 CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
 535                 CentralRoleFunction roleFunction2 = new CentralRoleFunction();
 536                 roleFunction1.setCode("test2");
 537                 String code = "test_menu";
 538                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 539                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
 540                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 541                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
 542                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
 543                                 .thenReturn(roleFunction1);
 544                 CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code);
 545                 assertEquals(returnedValue, roleFunction2);
 546                 String result = sw.getBuffer().toString().trim();
 547                 assertEquals("", result);
 548         }
 549
 550         @Test
 551         public void getRoleFunctionExceptionTest() throws Exception {
 552                 String reason = getInvalidKeyJson();
 553                 StringWriter sw = new StringWriter();
 554                 PrintWriter writer = new PrintWriter(sw);
 555                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 556                 String code = "test_menu";
 557                 Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
 558                                 .thenThrow(httpClientErrorException);
 559                 assertEquals(new CentralRoleFunction(),externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
 560                 String result = sw.getBuffer().toString().trim();
 561                 assertEquals(reason, result);
 562         }
 563
 564         @Test
 565         public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
 566                 List<EPApp> applicationList = new ArrayList<EPApp>();
 567                 EPApp app = mockApp();
 568                 applicationList.add(app);
 569                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 570                 PortalRestResponse<String> portalRestResponse = null;
 571                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 572                 expectedportalRestResponse.setMessage(null);
 573                 expectedportalRestResponse.setResponse("Failed");
 574                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 575                 String data = null;
 576                 CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
 577                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 578                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 579                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 580                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 581                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
 582                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
 583                 assertEquals(portalRestResponse, expectedportalRestResponse);
 584         }
 585
 586         @Test
 587         public void saveRoleFunctionExceptionTest() throws Exception {
 588                 List<EPApp> applicationList = new ArrayList<EPApp>();
 589                 EPApp app = mockApp();
 590                 app.setCentralAuth(true);
 591                 applicationList.add(app);
 592                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 593                 PortalRestResponse<String> portalRestResponse = null;
 594                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 595                 expectedportalRestResponse.setMessage(null);
 596                 expectedportalRestResponse.setResponse("Failed");
 597                 expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
 598                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 599                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 600                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 601                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 602                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
 603                 assertEquals(portalRestResponse, expectedportalRestResponse);
 604         }
 605
 606         @Test
 607         public void saveRoleFunctionTest() throws Exception {
 608                 List<EPApp> applicationList = new ArrayList<EPApp>();
 609                 EPUser user = mockUser.mockEPUser();
 610                 List<EPUser> userList = new ArrayList<>();
 611                 userList.add(user);
 612                 EPApp app = mockApp();
 613                 app.setCentralAuth(true);
 614                 applicationList.add(app);
 615                 JSONObject roleFunc = new JSONObject();
 616                 roleFunc.put("type", "test_type");
 617                 roleFunc.put("code", "test_instance");
 618                 roleFunc.put("action", "test_action");
 619                 roleFunc.put("name", "test_name");
 620                 ObjectMapper mapper = new ObjectMapper();
 621                 mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 622                 CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
 623                 saveRoleFunc.setAppId(app.getId());
 624                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 625                 PortalRestResponse<String> portalRestResponse = null;
 626                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 627                 expectedportalRestResponse.setMessage("Successfully saved!");
 628                 expectedportalRestResponse.setResponse("Success");
 629                 PortalRestStatusEnum portalRestStatusEnum = null;
 630                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 631                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 632                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
 633                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 634                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
 635                 Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
 636                                 .thenReturn(null);
 637                 Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
 638                                 Matchers.any(EPApp.class))).thenReturn(true);
 639                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
 640                                 .thenReturn(userList);
 641                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
 642                                 .thenReturn(applicationList);
 643                 portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
 644                                 roleFunc.toString());
 645                 assertEquals(portalRestResponse, expectedportalRestResponse);
 646         }
 647
 648         @Test
 649         public void deleteRoleFunctionTest() throws Exception {
 650                 PowerMockito.mockStatic(EcompPortalUtils.class);
 651                 PowerMockito.mockStatic(SystemProperties.class);
 652                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
 653                 PowerMockito.mockStatic(PortalConstants.class);
 654                 PortalRestResponse<String> portalRestResponse = null;
 655                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 656                 expectedportalRestResponse.setMessage("Successfully Deleted");
 657                 expectedportalRestResponse.setResponse("Success");
 658                 PortalRestStatusEnum portalRestStatusEnum = null;
 659                 EPUser user = mockUser.mockEPUser();
 660                 List<EPUser> userList = new ArrayList<>();
 661                 userList.add(user);
 662                 EPApp app = mockApp();
 663                 app.setCentralAuth(true);
 664                 List<EPApp> appList  = new ArrayList<>();
 665                 appList.add(app);
 666                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 667                 String code ="testNew";
 668                 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
 669                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 670                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 671                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 672                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 673                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
 674                 Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
 675                 portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
 676                 assertEquals(portalRestResponse, expectedportalRestResponse);
 677         }
 678
 679         @Test
 680         public void getActiveRolesTest() throws Exception {
 681                 String reason = getInvalidKeyJson();
 682                 StringWriter sw = new StringWriter();
 683                 PrintWriter writer = new PrintWriter(sw);
 684                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 685                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
 686                 List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 687                 assertNull(expectedCenRole);
 688                 String result = sw.getBuffer().toString().trim();
 689                 assertEquals(reason, result);
 690         }
 691
 692         @Test
 693         public void getActiveRolesValidationTest() throws Exception {
 694                 List<CentralRole> expectedRolesList = null;
 695                 EPApp app = mockApp();
 696                 app.setCentralAuth(true);
 697                 List<EPApp> appList = new ArrayList<EPApp>();
 698                 appList.add(app);
 699                 List<CentralV2Role> cenRoles = new ArrayList<CentralV2Role>();
 700                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
 701                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
 702                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
 703                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
 704                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader("uebkey"))).thenReturn(cenRoles);
 705                 Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles)).thenReturn(expectedRolesList);
 706                 List<CentralRole> actualRolesList = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 707                 assertEquals(actualRolesList, expectedRolesList);
 708         }
 709
 710         @Test
 711         public void getActiveRolesExceptionTest() throws Exception {
 712                 String reason = getInvalidKeyJson();
 713                 StringWriter sw = new StringWriter();
 714                 PrintWriter writer = new PrintWriter(sw);
 715                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 716                 externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
 717                 String result = sw.getBuffer().toString().trim();
 718                 assertEquals(reason, result);
 719         }
 720
 721         /**
 722          * It return JSON string which has error information
 723          *
 724          * @return JSON String
 725          * @throws JsonProcessingException
 726          */
 727         private String getInvalidKeyJson() throws JsonProcessingException {
 728                 final Map<String,String> uebkeyResponse = new HashMap<>();
 729                 String reason = "";
 730                 ObjectMapper mapper = new ObjectMapper();
 731                 uebkeyResponse.put("error","Invalid uebkey!");
 732                 reason = mapper.writeValueAsString(uebkeyResponse);
 733                 return reason;
 734         }
 735
 736         @Test
 737         public void deleteDependcyRoleRecordExceptionTest() throws Exception {
 738                 PortalRestResponse<String> portalRestResponse = null;
 739                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 740                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 741                 expectedportalRestResponse.setResponse("Failed");
 742                 PortalRestStatusEnum portalRestStatusEnum = null;
 743                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 744                 long roleId = 123;
 745                 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
 746                 assertEquals(expectedportalRestResponse, portalRestResponse);
 747         }
 748
 749         @Test
 750         public void bulkUploadFunctionsTest() throws Exception {
 751                 Integer result = 0;
 752                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 753                                 .thenReturn(result);
 754                 PortalRestResponse<String> portalRestResponse = null;
 755                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 756                 expectedportalRestResponse.setMessage("Successfully added: 0");
 757                 expectedportalRestResponse.setResponse("Success");
 758                 PortalRestStatusEnum portalRestStatusEnum = null;
 759                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 760                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 761                 assertEquals(portalRestResponse, expectedportalRestResponse);
 762         }
 763
 764         @Test
 765         public void bulkUploadFunctionsExceptionTest() throws Exception {
 766                 Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
 767                                 .thenThrow(httpClientErrorException);
 768                 PortalRestResponse<String> portalRestResponse = null;
 769                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 770                 expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
 771                 expectedportalRestResponse.setResponse("Failed");
 772                 PortalRestStatusEnum portalRestStatusEnum = null;
 773                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 774                 portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
 775                 assertEquals(portalRestResponse, expectedportalRestResponse);
 776         }
 777
 778         @Test
 779         public void bulkUploadRolesTest() throws Exception {
 780                 Integer result = 0;
 781                 PortalRestResponse<String> portalRestResponse = null;
 782                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 783                 expectedportalRestResponse.setMessage("Successfully added: 0");
 784                 expectedportalRestResponse.setResponse("Success");
 785                 PortalRestStatusEnum portalRestStatusEnum = null;
 786                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 787                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
 788                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 789                 assertEquals(portalRestResponse, expectedportalRestResponse);
 790         }
 791
 792         @Test
 793         public void bulkUploadRolesTestException() throws Exception {
 794                 Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
 795                                 .thenThrow(httpClientErrorException);
 796                 PortalRestResponse<String> portalRestResponse = null;
 797                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 798                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
 799                 expectedportalRestResponse.setResponse("Failed");
 800                 PortalRestStatusEnum portalRestStatusEnum = null;
 801                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 802                 portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
 803                 assertEquals(portalRestResponse, expectedportalRestResponse);
 804         }
 805
 806         @Test
 807         public void bulkUploadRoleFunctionsTest() throws Exception {
 808                 Integer result = 0;
 809                 PortalRestResponse<String> portalRestResponse = null;
 810                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 811                 expectedportalRestResponse.setMessage("Successfully added: 0");
 812                 expectedportalRestResponse.setResponse("Success");
 813                 PortalRestStatusEnum portalRestStatusEnum = null;
 814                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 815                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 816                                 .thenReturn(result);
 817                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 818                 assertEquals(portalRestResponse, expectedportalRestResponse);
 819         }
 820
 821         @Test
 822         public void bulkUploadRoleFunctionsException() throws Exception {
 823                 Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
 824                                 .thenThrow(httpClientErrorException);
 825                 PortalRestResponse<String> portalRestResponse = null;
 826                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 827                 expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
 828                 expectedportalRestResponse.setResponse("Failed");
 829                 PortalRestStatusEnum portalRestStatusEnum = null;
 830                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 831                 portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
 832                 assertEquals(portalRestResponse, expectedportalRestResponse);
 833         }
 834
 835         @Test
 836         public void bulkUploadUserRolesTest() throws Exception {
 837                 Integer result = 0;
 838                 PortalRestResponse<String> portalRestResponse = null;
 839                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 840                 expectedportalRestResponse.setMessage("Successfully added: 0");
 841                 expectedportalRestResponse.setResponse("Success");
 842                 PortalRestStatusEnum portalRestStatusEnum = null;
 843                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 844                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 845                                 .thenReturn(result);
 846                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 847                 assertEquals(portalRestResponse, expectedportalRestResponse);
 848         }
 849
 850         @Test
 851         public void bulkUploadUserRolesExceptionTest() throws Exception {
 852                 Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
 853                                 .thenThrow(httpClientErrorException);
 854                 PortalRestResponse<String> portalRestResponse = null;
 855                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 856                 expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
 857                 expectedportalRestResponse.setResponse("Failed");
 858                 PortalRestStatusEnum portalRestStatusEnum = null;
 859                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 860                 portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
 861                 assertEquals(portalRestResponse, expectedportalRestResponse);
 862         }
 863
 864         @Test
 865         public void bulkUploadPartnerFunctionsTest() throws Exception {
 866                 PortalRestResponse<String> portalRestResponse = null;
 867                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 868                 expectedportalRestResponse.setMessage("Successfully added: '0' functions");
 869                 expectedportalRestResponse.setResponse("Success");
 870                 PortalRestStatusEnum portalRestStatusEnum = null;
 871                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 872                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
 873                 assertEquals(portalRestResponse, expectedportalRestResponse);
 874         }
 875
 876
 877         @Test
 878         public void bulkUploadPartnerRolesTest() throws Exception {
 879                 PortalRestResponse<String> portalRestResponse = null;
 880                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 881                 expectedportalRestResponse.setMessage("Successfully added");
 882                 expectedportalRestResponse.setResponse("Success");
 883                 PortalRestStatusEnum portalRestStatusEnum = null;
 884                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 885                 List<Role> upload = new ArrayList<>();
 886                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
 887                                 upload);
 888                 assertEquals(portalRestResponse, expectedportalRestResponse);
 889         }
 890
 891          @Test
 892          public void bulkUploadPartnerRolesExceptionTest() throws Exception
 893          {
 894                  ExternalAccessRolesService externalAccessRolesService = null;
 895                 PortalRestResponse<String> portalRestResponse = null;
 896                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 897                 expectedportalRestResponse.setMessage("Successfully added");
 898                 expectedportalRestResponse.setResponse("Success");
 899                 PortalRestStatusEnum portalRestStatusEnum = null;
 900                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 901                 List<Role> upload = new ArrayList<>();
 902                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
 903                                 upload);
 904                 assertEquals(portalRestResponse, expectedportalRestResponse);
 905          }
 906
 907         @Test
 908         public void getMenuFunctionsTest() throws Exception {
 909                 String reason = getInvalidKeyJson();
 910                 StringWriter sw = new StringWriter();
 911                 PrintWriter writer = new PrintWriter(sw);
 912                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 913                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
 914                                 .thenReturn(null);
 915                 List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
 916                                 mockedResponse);
 917                 assertNull(expectedFunctionsList);
 918                 String result = sw.getBuffer().toString().trim();
 919                 assertEquals(reason, result);
 920         }
 921
 922         @Test
 923         public void getMenuFunctionsExceptionTest() throws Exception {
 924                 String reason = getInvalidKeyJson();
 925                 StringWriter sw = new StringWriter();
 926                 PrintWriter writer = new PrintWriter(sw);
 927                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 928                 Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
 929                                 .thenThrow(httpClientErrorException);
 930                 assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
 931                 String result = sw.getBuffer().toString().trim();
 932                 assertEquals(reason, result);
 933         }
 934
 935
 936         @Test
 937         public void saveRoleExceptionTest() throws Exception {
 938                 Role role = new Role();
 939                 PortalRestResponse<String> portalRestResponse = null;
 940                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 941                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 942                 expectedportalRestResponse.setResponse("Failed");
 943                 PortalRestStatusEnum portalRestStatusEnum = null;
 944                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 945                 List<Role> upload = new ArrayList<>();
 946                 portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse,role);
 947
 948                 assertEquals(portalRestResponse, expectedportalRestResponse);
 949         }
 950
 951         @Test
 952         public void deleteRoleExceptionTest() throws Exception {
 953                 String role = "TestNew";
 954                 PortalRestResponse<String> portalRestResponse = null;
 955                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 956                 expectedportalRestResponse.setMessage("Invalid uebkey!");
 957                 expectedportalRestResponse.setResponse("Failed");
 958                 PortalRestStatusEnum portalRestStatusEnum = null;
 959                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 960                 portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse,role);
 961                 assertEquals(portalRestResponse, expectedportalRestResponse);
 962         }
 963
 964
 965         @Test
 966         public void bulkUploadPartnerRoleFunctionsTest() throws Exception {
 967                 PortalRestResponse<String> portalRestResponse = null;
 968                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 969                 expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
 970                 expectedportalRestResponse.setResponse("Success");
 971                 PortalRestStatusEnum portalRestStatusEnum = null;
 972                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 973                 portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest, mockedResponse);
 974                 assertEquals(portalRestResponse, expectedportalRestResponse);
 975         }
 976
 977         @Test
 978         public void getUsersOfApplicationTest() throws Exception
 979         {
 980                 List<EcompUser> users = new ArrayList<>();
 981                 EcompUser user = new EcompUser();
 982                 user.setOrgUserId("guestT");
 983                 users.add(user);
 984                 StringWriter sw = new StringWriter();
 985                 PrintWriter writer = new PrintWriter(sw);
 986                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
 987                 List<EPApp> applicationList = new ArrayList<EPApp>();
 988                 EPApp app = mockApp();
 989                 app.setCentralAuth(true);
 990                 applicationList.add(app);
 991                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
 992                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
 993                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
 994                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
 995                 List<EcompUser> expectedUsers =         externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse);
 996                 assertEquals(expectedUsers, users);
 997         }
 998
 999         @Test(expected = Exception.class)
1000         public void getUsersOfApplicationExceptionTest() throws Exception
1001         {
1002                 List<EcompUser> users = new ArrayList<>();
1003                 EcompUser user = new EcompUser();
1004                 user.setOrgUserId("guestT");
1005                 users.add(user);
1006                 Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenThrow(nullPointerException);
1007                 assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
1008         }
1009
1010         @Test(expected = NullPointerException.class)
1011         public void deleteRoleV2Test() throws Exception
1012         {
1013                 List<EPApp> applicationList = new ArrayList<EPApp>();
1014                 EPApp app = mockApp();
1015                 applicationList.add(app);
1016                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1017                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
1018                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1019                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1020                 expectedportalRestResponse.setMessage("Successfully Deleted");
1021                 expectedportalRestResponse.setResponse("Success");
1022                 PortalRestStatusEnum portalRestStatusEnum = null;
1023                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
1024                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
1025                 assertNull(actualResponse);
1026         }
1027
1028         @Test
1029         public void deleteRoleV2InvalidUebKeyTest() throws Exception
1030         {
1031                 List<EPApp> applicationList = new ArrayList<EPApp>();
1032                 EPApp app = mockApp();
1033                 applicationList.add(app);
1034                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("Invalid uebkey!"));
1035                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1036                 expectedportalRestResponse.setMessage("Invalid uebkey!");
1037                 expectedportalRestResponse.setResponse("Failed");
1038                 PortalRestStatusEnum portalRestStatusEnum = null;
1039                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1040                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
1041                 assertEquals(actualResponse, expectedportalRestResponse);
1042         }
1043
1044         @Test
1045         public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception
1046         {
1047                 List<EPApp> applicationList = new ArrayList<EPApp>();
1048                 EPApp app = mockApp();
1049                 applicationList.add(app);
1050                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenThrow(new Exception("test"));
1051                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1052                 expectedportalRestResponse.setMessage("test");
1053                 expectedportalRestResponse.setResponse("Failed");
1054                 PortalRestStatusEnum portalRestStatusEnum = null;
1055                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1056                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
1057                 assertEquals(actualResponse, expectedportalRestResponse);
1058         }
1059
1060
1061         @Test(expected = NullPointerException.class)
1062         public void deleteRoleV2ExceptionTest() throws Exception
1063         {
1064                 List<EPApp> applicationList = new ArrayList<EPApp>();
1065                 EPApp app = mockApp();
1066                 applicationList.add(app);
1067                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1068                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
1069                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1070                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1071                 expectedportalRestResponse.setMessage("Failed to deleteRole");
1072                 expectedportalRestResponse.setResponse("Failed");
1073                 PortalRestStatusEnum portalRestStatusEnum = null;
1074                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1075                 PortalRestResponse<String> actualResponse =     externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, (long)1);
1076                 assertEquals(actualResponse, null);
1077         }
1078
1079         @Test
1080         public void getEpUserNullTest() throws Exception{
1081                 List<EPApp> applicationList = new ArrayList<EPApp>();
1082                 EPApp app = mockApp();
1083                 app.setUebKey("uebKey");
1084                 app.setCentralAuth(true);
1085                 applicationList.add(app);
1086                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1087                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1088                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1089                 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
1090         }
1091
1092         @Test
1093         public void getEpUserTest() throws Exception{
1094                 List<EPApp> applicationList = new ArrayList<EPApp>();
1095                 EPApp app = mockApp();
1096                 app.setUebKey("uebKey");
1097                 app.setCentralAuth(true);
1098                 applicationList.add(app);
1099                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1100                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1101                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1102        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\"}";
1103                 Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey))).thenReturn(user);
1104                 User EPuser = new User();
1105                 EPuser.setFirstName("test");
1106                 Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
1107                 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\":[]}";
1108                 assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"),res);
1109         }
1110
1111         @Test
1112         public void getEpUserExceptionTest() throws Exception{
1113                 List<EPApp> applicationList = new ArrayList<EPApp>();
1114                 EPApp app = mockApp();
1115                 app.setCentralAuth(true);
1116                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1117                 StringWriter sw = new StringWriter();
1118                 PrintWriter writer = new PrintWriter(sw);
1119                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1120                 assertNull(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"));
1121         }
1122
1123         @Test
1124         public void  getEPRolesOfApplicationTest() throws Exception
1125         {
1126                 List<EPApp> applicationList = new ArrayList<EPApp>();
1127                 EPApp app = mockApp();
1128                 app.setUebKey("uebKey");
1129                 app.setCentralAuth(true);
1130                 applicationList.add(app);
1131                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1132                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1133                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1134                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1135                 List<CentralV2Role> cenRoleList = new ArrayList<>();
1136                 CentralV2Role role = new CentralV2Role();
1137                 role.setName("test");
1138                 cenRoleList.add(role);
1139                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(cenRoleList);
1140                 List<EcompRole> ecompRoles = new ArrayList<>();
1141                 EcompRole eprole = new EcompRole();
1142                 eprole.setName("test");
1143                 ecompRoles.add(eprole);
1144                 assertEquals(ecompRoles,externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1145         }
1146         @Test
1147         public void  getEPRolesOfApplicationNullTest() throws Exception
1148         {
1149                 List<EPApp> applicationList = new ArrayList<EPApp>();
1150                 EPApp app = mockApp();
1151                 app.setUebKey("uebKey");
1152                 app.setCentralAuth(true);
1153                 applicationList.add(app);
1154                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1155                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
1156                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
1157                 Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
1158                 List<CentralV2Role> cenRoleList = new ArrayList<>();
1159                 CentralV2Role role = new CentralV2Role();
1160                 role.setName("test");
1161                 cenRoleList.add(role);
1162                 Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
1163                 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1164
1165         }
1166
1167         @Test
1168         public void  getEPRolesOfApplicationExceptionTest() throws Exception
1169         {
1170                 List<EPApp> applicationList = new ArrayList<EPApp>();
1171                 EPApp app = mockApp();
1172                 app.setCentralAuth(true);
1173                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1174                 StringWriter sw = new StringWriter();
1175                 PrintWriter writer = new PrintWriter(sw);
1176                 Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
1177                 assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
1178
1179         }
1180
1181         @Test
1182         public void saveRoleTest() throws Exception{
1183                 PowerMockito.mockStatic(EcompPortalUtils.class);
1184                 PowerMockito.mockStatic(SystemProperties.class);
1185                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1186                 PowerMockito.mockStatic(PortalConstants.class);
1187                 PortalRestResponse<String> actualPortalRestResponse = null;
1188                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1189                 expectedportalRestResponse.setMessage("Successfully Saved");
1190                 expectedportalRestResponse.setResponse("Success");
1191                 PortalRestStatusEnum portalRestStatusEnum = null;
1192                 EPUser user = mockUser.mockEPUser();
1193                 List<EPUser> userList = new ArrayList<>();
1194                 userList.add(user);
1195                 EPApp app = mockApp();
1196                 app.setCentralAuth(true);
1197                 List<EPApp> appList  = new ArrayList<>();
1198                 appList.add(app);
1199                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
1200                 Role role = new Role();
1201                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true, "Success");
1202                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1203                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1204                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1205                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1206                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1207                 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey"))).thenReturn(externalRequestFieldsValidator);
1208                 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1209                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1210         }
1211
1212         @Test
1213         public void saveRoleNegativeTest() throws Exception{
1214                 PowerMockito.mockStatic(EcompPortalUtils.class);
1215                 PowerMockito.mockStatic(SystemProperties.class);
1216                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1217                 PowerMockito.mockStatic(PortalConstants.class);
1218                 PortalRestResponse<String> actualPortalRestResponse = null;
1219                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1220                 expectedportalRestResponse.setMessage("Successfully Saved");
1221                 expectedportalRestResponse.setResponse("Success");
1222                 PortalRestStatusEnum portalRestStatusEnum = null;
1223                 EPUser user = mockUser.mockEPUser();
1224                 List<EPUser> userList = new ArrayList<>();
1225                 userList.add(user);
1226                 EPApp app = mockApp();
1227                 app.setCentralAuth(true);
1228                 List<EPApp> appList  = new ArrayList<>();
1229                 appList.add(app);
1230                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1231                 Role role = new Role();
1232                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "Failed");
1233                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1234                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1235                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1236                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1237                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1238                 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey"))).thenReturn(externalRequestFieldsValidator);
1239                 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1240                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1241         }
1242
1243         @Test
1244         public void saveRole406Test() throws Exception{
1245                 PowerMockito.mockStatic(EcompPortalUtils.class);
1246                 PowerMockito.mockStatic(SystemProperties.class);
1247                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1248                 PowerMockito.mockStatic(PortalConstants.class);
1249                 PortalRestResponse<String> actualPortalRestResponse = null;
1250                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1251                 expectedportalRestResponse.setMessage("Successfully Saved");
1252                 expectedportalRestResponse.setResponse("Failed");
1253                 PortalRestStatusEnum portalRestStatusEnum = null;
1254                 EPUser user = mockUser.mockEPUser();
1255                 List<EPUser> userList = new ArrayList<>();
1256                 userList.add(user);
1257                 EPApp app = mockApp();
1258                 app.setCentralAuth(true);
1259                 List<EPApp> appList  = new ArrayList<>();
1260                 appList.add(app);
1261                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1262                 Role role = new Role();
1263                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "406");
1264                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1265                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1266                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1267                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1268                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1269                 Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey"))).thenReturn(externalRequestFieldsValidator);
1270                 actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1271                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1272         }
1273
1274         @Test(expected = NullPointerException.class)
1275         public void saveRoleNullExceptionTest() throws Exception
1276         {
1277                 List<EPApp> applicationList = new ArrayList<EPApp>();
1278                 EPApp app = mockApp();
1279                 applicationList.add(app);
1280                 Role role = new Role();
1281                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
1282                 ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false, "failed");
1283                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(),Matchers.anyString(),Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
1284                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1285                 expectedportalRestResponse.setMessage("Failed to deleteRole");
1286                 expectedportalRestResponse.setResponse("Failed");
1287                 PortalRestStatusEnum portalRestStatusEnum = null;
1288                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1289                 PortalRestResponse<String> actualResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
1290                 assertEquals(actualResponse, null);
1291         }
1292
1293         @Test
1294         public void deleteRoleTest() throws Exception{
1295                 PowerMockito.mockStatic(EcompPortalUtils.class);
1296                 PowerMockito.mockStatic(SystemProperties.class);
1297                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1298                 PowerMockito.mockStatic(PortalConstants.class);
1299                 PortalRestResponse<String> actualPortalRestResponse = null;
1300                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1301                 expectedportalRestResponse.setMessage("Successfully Deleted");
1302                 expectedportalRestResponse.setResponse("Success");
1303                 PortalRestStatusEnum portalRestStatusEnum = null;
1304                 EPUser user = mockUser.mockEPUser();
1305                 List<EPUser> userList = new ArrayList<>();
1306                 userList.add(user);
1307                 EPApp app = mockApp();
1308                 app.setCentralAuth(true);
1309                 List<EPApp> appList  = new ArrayList<>();
1310                 appList.add(app);
1311                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
1312                 String code ="test";
1313                 boolean deleteResponse = true;
1314                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1315                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1316                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1317                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1318                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1319                 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey"))).thenReturn(deleteResponse);
1320                 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1321                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1322         }
1323
1324         @Test
1325         public void deleteRoleNegativeTest() throws Exception{
1326                 PowerMockito.mockStatic(EcompPortalUtils.class);
1327                 PowerMockito.mockStatic(SystemProperties.class);
1328                 PowerMockito.mockStatic(EPCommonSystemProperties.class);
1329                 PowerMockito.mockStatic(PortalConstants.class);
1330                 PortalRestResponse<String> actualPortalRestResponse = null;
1331                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1332                 expectedportalRestResponse.setMessage("Failed to delete Role for 'test");
1333                 expectedportalRestResponse.setResponse("Failed");
1334                 PortalRestStatusEnum portalRestStatusEnum = null;
1335                 EPUser user = mockUser.mockEPUser();
1336                 List<EPUser> userList = new ArrayList<>();
1337                 userList.add(user);
1338                 EPApp app = mockApp();
1339                 app.setCentralAuth(true);
1340                 List<EPApp> appList  = new ArrayList<>();
1341                 appList.add(app);
1342                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1343                 String code ="test";
1344                 boolean deleteResponse = false;
1345                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1346                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1347                 ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
1348                 Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
1349                 Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
1350                 Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey"))).thenReturn(deleteResponse);
1351                 actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
1352                 assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
1353         }
1354
1355         @Test
1356         public void deleteDependcyRoleRecordTest() throws Exception {
1357                 ExternalRequestFieldsValidator removeResult = new ExternalRequestFieldsValidator(true, "success");
1358                 PortalRestResponse<String> portalRestResponse = null;
1359                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
1360                 expectedportalRestResponse.setMessage("Invalid uebkey!");
1361                 expectedportalRestResponse.setResponse("Failed");
1362                 PortalRestStatusEnum portalRestStatusEnum = null;
1363                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
1364                 long roleId = 123;
1365                 String LoginId = "loginId";
1366                 List<EPApp> appList = new ArrayList<EPApp>();
1367                 Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
1368                 Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn(LoginId);
1369                 Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
1370                 Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(roleId, mockedRequest.getHeader("uebkey"), mockedRequest.getHeader("LoginId"))).thenReturn(removeResult);
1371                 portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse, roleId);
1372                 assertEquals(expectedportalRestResponse, portalRestResponse);
1373         }
1374 }