/*-
 * ============LICENSE_START==========================================
 * ONAP Portal
 * ===================================================================
 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
 * ===================================================================
 *
 * Unless otherwise specified, all software contained herein is licensed
 * under the Apache License, Version 2.0 (the "License");
 * you may not use this software except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *             http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Unless otherwise specified, all documentation contained herein is licensed
 * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
 * you may not use this documentation except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *             https://creativecommons.org/licenses/by/4.0/
 *
 * Unless required by applicable law or agreed to in writing, documentation
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * ============LICENSE_END============================================
 *
 * 
 */
package org.onap.portalapp.portal.controller;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.json.JSONObject;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.onap.portalapp.portal.core.MockEPUser;
import org.onap.portalapp.portal.domain.CentralV2RoleFunction;
import org.onap.portalapp.portal.domain.EPApp;
import org.onap.portalapp.portal.domain.EPUser;
import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
import org.onap.portalapp.portal.framework.MockitoTestSuite;
import org.onap.portalapp.portal.service.ExternalAccessRolesService;
import org.onap.portalapp.portal.service.ExternalAccessRolesServiceImpl;
import org.onap.portalapp.portal.transport.CentralRole;
import org.onap.portalapp.portal.transport.CentralRoleFunction;
import org.onap.portalapp.portal.transport.CentralUser;
import org.onap.portalapp.portal.transport.CentralV2Role;
import org.onap.portalapp.portal.transport.ExternalRequestFieldsValidator;
import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
import org.onap.portalapp.portal.utils.EcompPortalUtils;
import org.onap.portalapp.portal.utils.PortalConstants;
import org.onap.portalsdk.core.domain.AuditLog;
import org.onap.portalsdk.core.domain.Role;
import org.onap.portalsdk.core.domain.User;
import org.onap.portalsdk.core.restful.domain.EcompRole;
import org.onap.portalsdk.core.restful.domain.EcompUser;
import org.onap.portalsdk.core.service.AuditService;
import org.onap.portalsdk.core.service.UserService;
import org.onap.portalsdk.core.service.UserServiceCentalizedImpl;
import org.onap.portalsdk.core.util.SystemProperties;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.HttpClientErrorException;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;

@RunWith(PowerMockRunner.class)
@PrepareForTest({ EcompPortalUtils.class, PortalConstants.class, SystemProperties.class,
		EPCommonSystemProperties.class })
public class ExternalAccessRolesControllerTest {
	@Mock
	ExternalAccessRolesService externalAccessRolesService = new ExternalAccessRolesServiceImpl();
	@InjectMocks
	ExternalAccessRolesController externalAccessRolesController;
	@Mock
	UserService userservice = new UserServiceCentalizedImpl();
	@Mock
	AuditService auditService;

	@Before
	public void setup() {
		MockitoAnnotations.initMocks(this);
	}

	@Mock
	AuditLog auditLog = new AuditLog();
	MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
	HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
	HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
	NullPointerException nullPointerException = new NullPointerException();
	HttpClientErrorException httpClientErrorException = new HttpClientErrorException(HttpStatus.BAD_REQUEST, "Failed");
	MockEPUser mockUser = new MockEPUser();
	String loginId = "guestT";
	String uebKey = "testUebKey";

	public EPApp mockApp() {
		EPApp app = new EPApp();
		app.setName("Test");
		app.setImageUrl("test");
		app.setDescription("test");
		app.setNotes("test");
		app.setUrl("test");
		app.setId((long) 1);
		app.setAppRestEndpoint("test");
		app.setAlternateUrl("test");
		app.setName("test");
		app.setMlAppName("test");
		app.setMlAppAdminId("test");
		app.setUsername("test");
		app.setAppPassword("test");
		app.setOpen(false);
		app.setEnabled(false);
		app.setUebKey("test");
		app.setUebSecret("test");
		app.setUebTopicName("test");
		app.setAppType(1);
		return app;
	}

	@Test
	public void getUserTest() throws Exception {
		CentralUser expectedCentralUser = new CentralUser(null, null, null, null, null, null, null, null, loginId,
				loginId, loginId, loginId, loginId, loginId, loginId, null, loginId, loginId, loginId, loginId, loginId,
				loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId,
				loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId, loginId,
				loginId, null, false, false, null, null, false, loginId, null);
		String loginId = "test";
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		Mockito.when(externalAccessRolesService.getUserRoles(loginId, mockedRequest.getHeader("uebkey")))
				.thenReturn(expectedCentralUser);
		CentralUser actualCentralUser = externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
		assertEquals(actualCentralUser.isActive(), expectedCentralUser.isActive());
	}

	@Test
	public void getUserExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getUserXSSTest() throws Exception {
		String loginId = "<script ~~~>alert(0%0)</script ~~~>";
		String expected = getXSSKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		externalAccessRolesController.getUser(mockedRequest, mockedResponse, loginId);
		String actual = sw.getBuffer().toString().trim();
		assertEquals(expected, actual);
		}

	@Test
	public void getV2UserListTest() throws Exception {
		String expectedCentralUser = "test";
		String loginId = "test";
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
				.thenReturn(expectedCentralUser);
		String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
		assertEquals(actualString, expectedCentralUser);
	}

	@Test(expected = NullPointerException.class)
	public void getV2UserListExceptionTest() throws Exception {
		String expectedCentralUser = null;
		String loginId = "test";
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		ResponseEntity<String> response = null;
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		Mockito.when(externalAccessRolesService.getV2UserWithRoles(loginId, mockedRequest.getHeader("uebkey")))
				.thenReturn(expectedCentralUser);
		String actualString = externalAccessRolesController.getV2UserList(mockedRequest, mockedResponse, loginId);
		assertEquals(actualString, expectedCentralUser);
	}

	@Test
	public void getRolesForAppCentralRoleTest() throws Exception {
		List<CentralRole> expectedCentralRoleList = new ArrayList<>();
		List<EPApp> applicationList = new ArrayList<>();
		List<CentralV2Role> centralV2RoleList = new ArrayList<>();
		List<CentralRole> centralRoleList = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
				.thenReturn(centralV2RoleList);
		Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
				.thenReturn(centralRoleList);
		List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
				mockedResponse);
		assertEquals(actualCentralRoleList.size(), expectedCentralRoleList.size());
	}

	@Test(expected = NullPointerException.class)
	public void getRolesForAppCentralRoleExceptionTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		List<CentralV2Role> centralV2RoleList = new ArrayList<>();
		List<CentralRole> centralRoleList = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		ResponseEntity<String> response = null;
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
				.thenReturn(centralV2RoleList);
		Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(centralV2RoleList))
				.thenReturn(centralRoleList);
		List<CentralRole> actualCentralRoleList = externalAccessRolesController.getRolesForApp(mockedRequest,
				mockedResponse);
		assertEquals(null, actualCentralRoleList);
	}

	@Test
	public void getV2RolesForAppTest() throws Exception {
		List<CentralRole> expectedCentralRoleList = new ArrayList<>();
		List<EPApp> applicationList = new ArrayList<>();
		List<CentralV2Role> centralV2Role = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
				.thenReturn(centralV2Role);
		List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
				mockedResponse);
		assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
	}

	@Test(expected = NullPointerException.class)
	public void getV2RolesForAppExceptionTest() throws Exception {
		List<CentralRole> expectedCentralRoleList = new ArrayList<>();
		List<EPApp> applicationList = new ArrayList<>();
		List<CentralV2Role> centralV2Role = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		ResponseEntity<String> response = null;
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey)))
				.thenReturn(centralV2Role);
		List<CentralV2Role> actualCentralV2Role = externalAccessRolesController.getV2RolesForApp(mockedRequest,
				mockedResponse);
		assertEquals(actualCentralV2Role.size(), expectedCentralRoleList.size());
	}

	@Test(expected = NullPointerException.class)
	public void getRolesForAppTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		List<CentralV2Role> answer = new ArrayList<>();
		EPApp app = mockApp();
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		Mockito.when(externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey))).thenReturn(answer);
		assertEquals(externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse), null);
	}

	@Test(expected = NullPointerException.class)
	public void getRolesForAppExceptionTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		externalAccessRolesController.getRolesForApp(mockedRequest, mockedResponse);
		List<CentralV2Role> role = externalAccessRolesService.getRolesForApp(mockedRequest.getHeader(uebKey));
		assertEquals(null, role);
	}

	@Test
	public void getRoleFunctionsListTest() throws Exception {
		List<CentralRole> expectedCentralRoleList = new ArrayList<>();
		List<CentralRoleFunction> roleFuncList = new ArrayList<>();
		List<EPApp> applicationList = new ArrayList<>();
		List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
				.thenReturn(centralV2RoleFunction);
		Mockito.when(externalAccessRolesService.convertCentralRoleFunctionToRoleFunctionObject(centralV2RoleFunction))
				.thenReturn(roleFuncList);
		List<CentralRoleFunction> actualCentralRoleFunction = externalAccessRolesController
				.getRoleFunctionsList(mockedRequest, mockedResponse);
		assertEquals(actualCentralRoleFunction.size(), expectedCentralRoleList.size());
	}

	@Test
	public void getRoleFunctionsListExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		externalAccessRolesController.getRoleFunctionsList(mockedRequest, mockedResponse);
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getV2RoleFunctionsListTest() throws Exception {
		List<CentralV2RoleFunction> expectedCentralV2RoleFunctionList = new ArrayList<>();
		List<EPApp> applicationList = new ArrayList<>();
		List<CentralV2RoleFunction> centralV2RoleFunction = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		Mockito.when(externalAccessRolesService.getRoleFuncList(mockedRequest.getHeader("uebkey")))
				.thenReturn(centralV2RoleFunction);
		List<CentralV2RoleFunction> actualCentralV2RoleFunctionList = externalAccessRolesController
				.getV2RoleFunctionsList(mockedRequest, mockedResponse);
		assertEquals(actualCentralV2RoleFunctionList.size(), expectedCentralV2RoleFunctionList.size());
	}

	@Test
	public void getV2RoleFunctionsListExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		externalAccessRolesController.getV2RoleFunctionsList(mockedRequest, mockedResponse);
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getRoleInfoValidationTest() throws Exception {
		CentralRole expectedCentralRole = null;
		List<EPApp> applicationList = new ArrayList<>();
		long roleId = 1;
		CentralV2Role centralV2Role = new CentralV2Role();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
				.thenReturn(centralV2Role);
		CentralRole actualCentralRole = externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse,
				roleId);
		assertEquals(actualCentralRole, expectedCentralRole);
	}

	@Test
	public void getRoleInfoTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		CentralV2Role answer = new CentralV2Role();
		long roleId = 1;
		Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
				.thenReturn(answer);
		externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId);
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getRoleInfoExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		long roleId = 1;
		assertNull(externalAccessRolesController.getRoleInfo(mockedRequest, mockedResponse, roleId));
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getV2RoleInfoValidationTest() throws Exception {
		CentralV2Role expectedCentralRole = new CentralV2Role();
		expectedCentralRole.setActive(false);
		List<EPApp> applicationList = new ArrayList<>();
		long roleId = 1;
		CentralV2Role centralV2Role = new CentralV2Role();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader("uebkey")))
				.thenReturn(centralV2Role);
		CentralV2Role actualCentralRole = externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse,
				roleId);
		assertEquals(actualCentralRole.getActive(), expectedCentralRole.getActive());
	}

	@Test
	public void getV2RoleInfoTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		CentralV2Role answer = new CentralV2Role();
		long roleId = 1;
		Mockito.when(externalAccessRolesService.getRoleInfo(roleId, mockedRequest.getHeader(uebKey)))
				.thenReturn(answer);
		externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId);
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getV2RoleInfoExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		long roleId = 1;
		assertNull(externalAccessRolesController.getV2RoleInfo(mockedRequest, mockedResponse, roleId));
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getV2RoleFunctionTest() throws Exception {
		CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
		expectedCentralV2RoleFunction.setCode("test");
		List<EPApp> applicationList = new ArrayList<>();
		String code = "test";
		CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
		centralV2RoleFunction.setCode("test");
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
				.thenReturn(centralV2RoleFunction);
		CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
				.getV2RoleFunction(mockedRequest, mockedResponse, code);
		assertEquals(actualCentralV2RoleFunction.getCode(), expectedCentralV2RoleFunction.getCode());
	}


	@Test
	public void getV2RoleFunctionNullCheckTest() throws Exception {
		CentralV2RoleFunction expectedCentralV2RoleFunction = new CentralV2RoleFunction();
		List<EPApp> applicationList = new ArrayList<>();
		String code = "test";
		CentralV2RoleFunction centralV2RoleFunction = null;
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
				.thenReturn(centralV2RoleFunction);
		CentralV2RoleFunction actualCentralV2RoleFunction = externalAccessRolesController
				.getV2RoleFunction(mockedRequest, mockedResponse, code);
		assertEquals(actualCentralV2RoleFunction.getAction(), expectedCentralV2RoleFunction.getAction());
	}

	@Test
	public void getV2RoleFunctionExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		String code = "test";
		assertNull(externalAccessRolesController.getV2RoleFunction(mockedRequest, mockedResponse, code));
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getRoleFunctionTest() throws Exception {
		EPApp mockApp = mockApp();
		mockApp.setCentralAuth(true);
		List<EPApp> mockAppList = new ArrayList<>();
		mockAppList.add(mockApp);
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
		CentralRoleFunction roleFunction2 = new CentralRoleFunction();
		roleFunction1.setCode("test2");
		String code = "test_menu";
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
				.thenReturn(roleFunction1);
		CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
				code);
		assertEquals(returnedValue, roleFunction2);
		String result = sw.getBuffer().toString().trim();
		assertEquals("", result);
	}

	@Test
	public void getRoleFunctionExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		String code = "test_menu";
		Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader(uebKey)))
				.thenThrow(httpClientErrorException);
		assertEquals(new CentralRoleFunction(),
				externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse, code));
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getRoleFunctionXSSTest() throws Exception {
		String expected = getXSSKeyJson();
		EPApp mockApp = mockApp();
		mockApp.setCentralAuth(true);
		List<EPApp> mockAppList = new ArrayList<>();
		mockAppList.add(mockApp);
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		CentralV2RoleFunction roleFunction1 = new CentralV2RoleFunction();
		CentralRoleFunction roleFunction2 = new CentralRoleFunction();
		roleFunction1.setCode("test2");
		String code = "<script>alert(‘XSS’)</script>";
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(mockAppList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(mockAppList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getRoleFunction(code, mockedRequest.getHeader("uebkey")))
			.thenReturn(roleFunction1);
		CentralRoleFunction returnedValue = externalAccessRolesController.getRoleFunction(mockedRequest, mockedResponse,
			code);
		assertEquals(returnedValue, roleFunction2);
		String result = sw.getBuffer().toString().trim();
		assertEquals(expected, result);
	}

	@Test
	public void saveRoleFunctionIfIsNotDeletedTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage(null);
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		String data = null;
		CentralV2RoleFunction centralV2RoleFunction = new CentralV2RoleFunction();
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.saveCentralRoleFunction(centralV2RoleFunction, app)).thenReturn(false);
		portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, data);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void saveRoleFunctionExceptionTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage(null);
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse, null);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void saveRoleFunctionTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		JSONObject roleFunc = new JSONObject();
		roleFunc.put("type", "test_type");
		roleFunc.put("code", "test_instance");
		roleFunc.put("action", "test_action");
		roleFunc.put("name", "test_name");
		ObjectMapper mapper = new ObjectMapper();
		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
		CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
		saveRoleFunc.setAppId(app.getId());
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully saved!");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
				.thenReturn(null);
		Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
				Matchers.any(EPApp.class))).thenReturn(true);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
				.thenReturn(userList);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
				.thenReturn(applicationList);
		portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
				roleFunc.toString());
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void saveRoleFunctionXSSTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		JSONObject roleFunc = new JSONObject();
		roleFunc.put("type", "<script>alert(“XSS”)</script> ");
		roleFunc.put("code", "test_instance");
		roleFunc.put("action", "test_action");
		roleFunc.put("name", "test_name");
		ObjectMapper mapper = new ObjectMapper();
		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
		CentralV2RoleFunction saveRoleFunc = mapper.readValue(roleFunc.toString(), CentralV2RoleFunction.class);
		saveRoleFunc.setAppId(app.getId());
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to roleFunc, not valid data.");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(applicationList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(applicationList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getRoleFunction("test_type|test_instance|test_action", app.getUebKey()))
			.thenReturn(null);
		Mockito.when(externalAccessRolesService.saveCentralRoleFunction(Matchers.any(CentralV2RoleFunction.class),
			Matchers.any(EPApp.class))).thenReturn(true);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader(Matchers.anyString())))
			.thenReturn(userList);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(Matchers.anyString())))
			.thenReturn(applicationList);
		portalRestResponse = externalAccessRolesController.saveRoleFunction(mockedRequest, mockedResponse,
			roleFunc.toString());
		assertEquals(expectedportalRestResponse, portalRestResponse);
	}

	@Test
	public void deleteRoleFunctionTest() throws Exception {
		PowerMockito.mockStatic(EcompPortalUtils.class);
		PowerMockito.mockStatic(SystemProperties.class);
		PowerMockito.mockStatic(EPCommonSystemProperties.class);
		PowerMockito.mockStatic(PortalConstants.class);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully Deleted");
		expectedportalRestResponse.setResponse("Success");
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		String code = "testNew";
		Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
		Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
		portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void deleteRoleFunctionXSSTest() throws Exception {
		PowerMockito.mockStatic(EcompPortalUtils.class);
		PowerMockito.mockStatic(SystemProperties.class);
		PowerMockito.mockStatic(EPCommonSystemProperties.class);
		PowerMockito.mockStatic(PortalConstants.class);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to deleteRoleFunction, not valid data.");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		String code = "<script>alert(‘XSS’)</script>";
		Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn("guestT");
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
		Mockito.when(externalAccessRolesService.deleteCentralRoleFunction(code, app)).thenReturn(true);
		portalRestResponse = externalAccessRolesController.deleteRoleFunction(mockedRequest, mockedResponse, code);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void getActiveRolesTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
		List<CentralRole> expectedCenRole = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
		assertNull(expectedCenRole);
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getActiveRolesValidationTest() throws Exception {
		List<CentralRole> expectedRolesList = null;
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		List<CentralV2Role> cenRoles = new ArrayList<>();
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader("uebkey"))).thenReturn(cenRoles);
		Mockito.when(externalAccessRolesService.convertV2CentralRoleListToOldVerisonCentralRoleList(cenRoles))
				.thenReturn(expectedRolesList);
		List<CentralRole> actualRolesList = externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
		assertEquals(actualRolesList, expectedRolesList);
	}

	@Test
	public void getActiveRolesExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		externalAccessRolesController.getActiveRoles(mockedRequest, mockedResponse);
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	/**
	 * It return JSON string which has error information
	 * 
	 * @return JSON String
	 * @throws JsonProcessingException
	 */
	private String getInvalidKeyJson() throws JsonProcessingException {
		final Map<String, String> uebkeyResponse = new HashMap<>();
		String reason = "";
		ObjectMapper mapper = new ObjectMapper();
		uebkeyResponse.put("error", "Invalid credentials!");
		reason = mapper.writeValueAsString(uebkeyResponse);
		return reason;
	}

	private String getXSSKeyJson() throws JsonProcessingException {
		final Map<String, String> uebkeyResponse = new HashMap<>();
		String reason = "";
		ObjectMapper mapper = new ObjectMapper();
		uebkeyResponse.put("error", "Data is not valid");
		reason = mapper.writeValueAsString(uebkeyResponse);
		return reason;
	}

	@Test
	public void deleteDependcyRoleRecordExceptionTest() {
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Invalid credentials!");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		long roleId = 123;
		portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
				roleId);
		assertEquals(expectedportalRestResponse, portalRestResponse);
	}

	@Test
	public void bulkUploadFunctionsTest() throws Exception {
		Integer result = 0;
		Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
				.thenReturn(result);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully added: 0");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadFunctionsExceptionTest() throws Exception {
		Mockito.when(externalAccessRolesService.bulkUploadFunctions(mockedRequest.getHeader(uebKey)))
				.thenThrow(httpClientErrorException);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to bulkUploadFunctions");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		portalRestResponse = externalAccessRolesController.bulkUploadFunctions(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadRolesTest() throws Exception {
		Integer result = 0;
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully added: 0");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey))).thenReturn(result);
		portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadRolesTestException() throws Exception {
		Mockito.when(externalAccessRolesService.bulkUploadRoles(mockedRequest.getHeader(uebKey)))
				.thenThrow(httpClientErrorException);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to bulkUploadRoles");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		portalRestResponse = externalAccessRolesController.bulkUploadRoles(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadRoleFunctionsTest() throws Exception {
		Integer result = 0;
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully added: 0");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
				.thenReturn(result);
		portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadRoleFunctionsException() throws Exception {
		Mockito.when(externalAccessRolesService.bulkUploadRolesFunctions(mockedRequest.getHeader(uebKey)))
				.thenThrow(httpClientErrorException);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to bulkUploadRoleFunctions");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		portalRestResponse = externalAccessRolesController.bulkUploadRoleFunctions(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadUserRolesTest() throws Exception {
		Integer result = 0;
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully added: 0");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
				.thenReturn(result);
		portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadUserRolesExceptionTest() throws Exception {
		Mockito.when(externalAccessRolesService.bulkUploadUserRoles(mockedRequest.getHeader(uebKey)))
				.thenThrow(httpClientErrorException);
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to bulkUploadUserRoles");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		portalRestResponse = externalAccessRolesController.bulkUploadUserRoles(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadPartnerFunctionsTest() {
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully added: '0' functions");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		portalRestResponse = externalAccessRolesController.bulkUploadPartnerFunctions(mockedRequest, mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadPartnerRolesTest() {
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully added");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		List<Role> upload = new ArrayList<>();
		portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
				upload);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadPartnerRolesExceptionTest() {
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully added");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		List<Role> upload = new ArrayList<>();
		portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoles(mockedRequest, mockedResponse,
				upload);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void getMenuFunctionsTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey))).thenReturn(null);
		List<String> expectedFunctionsList = externalAccessRolesController.getMenuFunctions(mockedRequest,
				mockedResponse);
		assertNull(expectedFunctionsList);
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void getMenuFunctionsExceptionTest() throws Exception {
		String reason = getInvalidKeyJson();
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		Mockito.when(externalAccessRolesService.getMenuFunctionsList(mockedRequest.getHeader(uebKey)))
				.thenThrow(httpClientErrorException);
		assertNull(externalAccessRolesController.getMenuFunctions(mockedRequest, mockedResponse));
		String result = sw.getBuffer().toString().trim();
		assertEquals(reason, result);
	}

	@Test
	public void saveRoleExceptionTest() {
		Role role = new Role();
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Invalid credentials!");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		portalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void deleteRoleExceptionTest() {
		String role = "TestNew";
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Invalid credentials!");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		portalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, role);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void bulkUploadPartnerRoleFunctionsTest() {
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully added: '0' role functions");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		portalRestResponse = externalAccessRolesController.bulkUploadPartnerRoleFunctions(mockedRequest,
				mockedResponse);
		assertEquals(portalRestResponse, expectedportalRestResponse);
	}

	@Test
	public void getUsersOfApplicationTest() throws Exception {
		List<EcompUser> users = new ArrayList<>();
		EcompUser user = new EcompUser();
		user.setOrgUserId("guestT");
		users.add(user);
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey))).thenReturn(users);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
		List<EcompUser> expectedUsers = externalAccessRolesController.getUsersOfApplication(mockedRequest,
				mockedResponse);
		assertEquals(expectedUsers, users);
	}

	@Test(expected = Exception.class)
	public void getUsersOfApplicationExceptionTest() throws Exception {
		List<EcompUser> users = new ArrayList<>();
		EcompUser user = new EcompUser();
		user.setOrgUserId("guestT");
		users.add(user);
		Mockito.when(externalAccessRolesService.getAllAppUsers(mockedRequest.getHeader(uebKey)))
				.thenThrow(nullPointerException);
		assertNull(externalAccessRolesController.getUsersOfApplication(mockedRequest, mockedResponse));
	}

	@Test(expected = NullPointerException.class)
	public void deleteRoleV2Test() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
				"Success");
		Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
				Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully Deleted");
		expectedportalRestResponse.setResponse("Success");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
				mockedResponse, (long) 1);
		assertNull(actualResponse);
	}

	@Test
	public void deleteRoleV2InvalidUebKeyTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
				.thenThrow(new Exception("Invalid credentials!"));
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Invalid credentials!");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
				mockedResponse, (long) 1);
		assertEquals(actualResponse, expectedportalRestResponse);
	}

	@Test
	public void deleteRoleV2InvalidUebKeyWithDiffErrorTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey)))
				.thenThrow(new Exception("test"));
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("test");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
				mockedResponse, (long) 1);
		assertEquals(actualResponse, expectedportalRestResponse);
	}

	@Test(expected = NullPointerException.class)
	public void deleteRoleV2ExceptionTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
				"failed");
		Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
				Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to deleteRole");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		PortalRestResponse<String> actualResponse = externalAccessRolesController.deleteRole(mockedRequest,
				mockedResponse, (long) 1);
		assertEquals(actualResponse, null);
	}

	@Test
	public void getEpUserNullTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		app.setUebKey("uebKey");
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
		externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
	}

	@Test
	public void getEpUserTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		app.setUebKey("uebKey");
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
		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\":[],\"roles\":[]}";
		Mockito.when(externalAccessRolesService.getV2UserWithRoles("test12", mockedRequest.getHeader(uebKey)))
				.thenReturn(user);
		User EPuser = new User();
		EPuser.setFirstName("test");
		Mockito.when(userservice.userMapper(user)).thenReturn(EPuser);
		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\":[]}";
		assertEquals(externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12"), res);
	}

	@Test
	public void getEpUserExceptionTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		externalAccessRolesController.getEcompUser(mockedRequest, mockedResponse, "test12");
	}

	@Test
	public void getEPRolesOfApplicationTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		app.setUebKey("uebKey");
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		List<CentralV2Role> cenRoleList = new ArrayList<>();
		CentralV2Role role = new CentralV2Role();
		role.setName("test");
		cenRoleList.add(role);
		Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey)))
				.thenReturn(cenRoleList);
		List<EcompRole> ecompRoles = new ArrayList<>();
		EcompRole eprole = new EcompRole();
		eprole.setName("test");
		ecompRoles.add(eprole);
		assertEquals(ecompRoles,
				externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
	}

	@Test
	public void getEPRolesOfApplicationNullTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		app.setUebKey("uebKey");
		app.setCentralAuth(true);
		applicationList.add(app);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.OK);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(app)).thenReturn(response);
		Mockito.doNothing().when(externalAccessRolesService).syncApplicationRolesWithEcompDB(app);
		List<CentralV2Role> cenRoleList = new ArrayList<>();
		CentralV2Role role = new CentralV2Role();
		role.setName("test");
		cenRoleList.add(role);
		Mockito.when(externalAccessRolesService.getActiveRoles(mockedRequest.getHeader(uebKey))).thenReturn(null);
		assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
	}

	@Test
	public void getEPRolesOfApplicationExceptionTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		app.setCentralAuth(true);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		StringWriter sw = new StringWriter();
		PrintWriter writer = new PrintWriter(sw);
		Mockito.when(mockedResponse.getWriter()).thenReturn(writer);
		assertNull(externalAccessRolesController.getEcompRolesOfApplication(mockedRequest, mockedResponse));
	}

	@Test
	public void saveRoleTest() throws Exception {
		PowerMockito.mockStatic(EcompPortalUtils.class);
		PowerMockito.mockStatic(SystemProperties.class);
		PowerMockito.mockStatic(EPCommonSystemProperties.class);
		PowerMockito.mockStatic(PortalConstants.class);
		PortalRestResponse<String> actualPortalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully Saved");
		expectedportalRestResponse.setResponse("Success");
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		Role role = new Role();
		ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(true,
				"Success");
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
		Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
				.thenReturn(externalRequestFieldsValidator);
		actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
		assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
	}

	@Test
	public void saveRoleNegativeTest() throws Exception {
		PowerMockito.mockStatic(EcompPortalUtils.class);
		PowerMockito.mockStatic(SystemProperties.class);
		PowerMockito.mockStatic(EPCommonSystemProperties.class);
		PowerMockito.mockStatic(PortalConstants.class);
		PortalRestResponse<String> actualPortalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully Saved");
		expectedportalRestResponse.setResponse("Success");
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		Role role = new Role();
		ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
				"Failed");
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
		Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
				.thenReturn(externalRequestFieldsValidator);
		actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
		assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
	}

	@Test
	public void saveRole406Test() throws Exception {
		PowerMockito.mockStatic(EcompPortalUtils.class);
		PowerMockito.mockStatic(SystemProperties.class);
		PowerMockito.mockStatic(EPCommonSystemProperties.class);
		PowerMockito.mockStatic(PortalConstants.class);
		PortalRestResponse<String> actualPortalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully Saved");
		expectedportalRestResponse.setResponse("Failed");
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		Role role = new Role();
		ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
				"406");
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
		Mockito.when(externalAccessRolesService.saveRoleForApplication(role, mockedRequest.getHeader("uebkey")))
				.thenReturn(externalRequestFieldsValidator);
		actualPortalRestResponse = externalAccessRolesController.saveRole(mockedRequest, mockedResponse, role);
		assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
	}

	@Test(expected = NullPointerException.class)
	public void saveRoleNullExceptionTest() throws Exception {
		List<EPApp> applicationList = new ArrayList<>();
		EPApp app = mockApp();
		applicationList.add(app);
		Role role = new Role();
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader(uebKey))).thenReturn(applicationList);
		ExternalRequestFieldsValidator externalRequestFieldsValidator = new ExternalRequestFieldsValidator(false,
				"failed");
		Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(Matchers.anyLong(), Matchers.anyString(),
				Matchers.anyString())).thenReturn(externalRequestFieldsValidator);
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to deleteRole");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		PortalRestResponse<String> actualResponse = externalAccessRolesController.saveRole(mockedRequest,
				mockedResponse, role);
		assertEquals(actualResponse, null);
	}

	@Test
	public void deleteRoleTest() throws Exception {
		PowerMockito.mockStatic(EcompPortalUtils.class);
		PowerMockito.mockStatic(SystemProperties.class);
		PowerMockito.mockStatic(EPCommonSystemProperties.class);
		PowerMockito.mockStatic(PortalConstants.class);
		PortalRestResponse<String> actualPortalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Successfully Deleted");
		expectedportalRestResponse.setResponse("Success");
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.OK);
		String code = "test";
		boolean deleteResponse = true;
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
		Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
				.thenReturn(deleteResponse);
		actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
		assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
	}

	@Test
	public void deleteRoleXSSTest() throws Exception {
		PowerMockito.mockStatic(EcompPortalUtils.class);
		PowerMockito.mockStatic(SystemProperties.class);
		PowerMockito.mockStatic(EPCommonSystemProperties.class);
		PowerMockito.mockStatic(PortalConstants.class);
		PortalRestResponse<String> actualPortalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to deleteRole, not valid data.");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		String code = "<img src=xss onerror=alert(1)>";
		boolean deleteResponse = true;
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
		Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
			.thenReturn(deleteResponse);
		actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
		assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
	}

	@Test
	public void deleteRoleNegativeTest() throws Exception {
		PowerMockito.mockStatic(EcompPortalUtils.class);
		PowerMockito.mockStatic(SystemProperties.class);
		PowerMockito.mockStatic(EPCommonSystemProperties.class);
		PowerMockito.mockStatic(PortalConstants.class);
		PortalRestResponse<String> actualPortalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Failed to delete Role for 'test");
		expectedportalRestResponse.setResponse("Failed");
		EPUser user = mockUser.mockEPUser();
		List<EPUser> userList = new ArrayList<>();
		userList.add(user);
		EPApp app = mockApp();
		app.setCentralAuth(true);
		List<EPApp> appList = new ArrayList<>();
		appList.add(app);
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		String code = "test";
		boolean deleteResponse = false;
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		ResponseEntity<String> response = new ResponseEntity<>(HttpStatus.FOUND);
		Mockito.when(externalAccessRolesService.getNameSpaceIfExists(appList.get(0))).thenReturn(response);
		Mockito.when(externalAccessRolesService.getUser(mockedRequest.getHeader("LoginId"))).thenReturn(userList);
		Mockito.when(externalAccessRolesService.deleteRoleForApplication(code, mockedRequest.getHeader("uebkey")))
				.thenReturn(deleteResponse);
		actualPortalRestResponse = externalAccessRolesController.deleteRole(mockedRequest, mockedResponse, code);
		assertEquals(actualPortalRestResponse.getStatus(), expectedportalRestResponse.getStatus());
	}

	@Test
	public void deleteDependcyRoleRecordTest() throws Exception {
		ExternalRequestFieldsValidator removeResult = new ExternalRequestFieldsValidator(true, "success");
		PortalRestResponse<String> portalRestResponse = null;
		PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<>();
		expectedportalRestResponse.setMessage("Invalid credentials!");
		expectedportalRestResponse.setResponse("Failed");
		expectedportalRestResponse.setStatus(PortalRestStatusEnum.ERROR);
		long roleId = 123;
		String LoginId = "loginId";
		List<EPApp> appList = new ArrayList<>();
		Mockito.when(mockedRequest.getHeader("uebkey")).thenReturn(uebKey);
		Mockito.when(mockedRequest.getHeader("LoginId")).thenReturn(LoginId);
		Mockito.when(externalAccessRolesService.getApp(mockedRequest.getHeader("uebkey"))).thenReturn(appList);
		Mockito.when(externalAccessRolesService.deleteDependencyRoleRecord(roleId, mockedRequest.getHeader("uebkey"),
				mockedRequest.getHeader("LoginId"))).thenReturn(removeResult);
		portalRestResponse = externalAccessRolesController.deleteDependencyRoleRecord(mockedRequest, mockedResponse,
				roleId);
		assertEquals(expectedportalRestResponse, portalRestResponse);
	}
	
}