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

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