ecomp-portal-BE-common-test/src/main/java/org/openecomp/portalapp/portal/test/controller/BasicAuthAccountControllerTest.java

   1 package org.openecomp.portalapp.portal.test.controller;
   2
   3 import static org.junit.Assert.assertEquals;
   4
   5 import java.util.ArrayList;
   6 import java.util.List;
   7
   8 import javax.servlet.http.HttpServletRequest;
   9 import javax.servlet.http.HttpServletResponse;
  10
  11 import org.junit.Before;
  12 import org.junit.Test;
  13 import org.mockito.InjectMocks;
  14 import org.mockito.Mock;
  15 import org.mockito.Mockito;
  16 import org.mockito.MockitoAnnotations;
  17 import org.openecomp.portalapp.portal.controller.BasicAuthAccountController;
  18 import org.openecomp.portalapp.portal.domain.BasicAuthCredentials;
  19 import org.openecomp.portalapp.portal.domain.EPEndpoint;
  20 import org.openecomp.portalapp.portal.domain.EPUser;
  21 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  22 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  23 import org.openecomp.portalapp.portal.service.AdminRolesService;
  24 import org.openecomp.portalapp.portal.service.AdminRolesServiceImpl;
  25 import org.openecomp.portalapp.portal.service.BasicAuthAccountService;
  26 import org.openecomp.portalapp.portal.service.BasicAuthAccountServiceImpl;
  27 import org.openecomp.portalapp.portal.test.core.MockEPUser;
  28 import org.openecomp.portalapp.test.framework.MockitoTestSuite;
  29 import org.openecomp.portalapp.util.EPUserUtils;
  30
  31 public class BasicAuthAccountControllerTest extends MockitoTestSuite {
  32
  33         @Mock
  34         BasicAuthAccountService basicAuthAccountService = new BasicAuthAccountServiceImpl();
  35
  36         @Mock
  37         AdminRolesService adminRolesService = new AdminRolesServiceImpl();
  38
  39         @InjectMocks
  40         BasicAuthAccountController basicAuthAccountController = new BasicAuthAccountController();
  41
  42         @Before
  43         public void setup() {
  44                 MockitoAnnotations.initMocks(this);
  45         }
  46
  47         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  48
  49         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  50         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  51         NullPointerException nullPointerException = new NullPointerException();
  52
  53         @Mock
  54         EPUserUtils ePUserUtils = new EPUserUtils();
  55
  56         MockEPUser mockUser = new MockEPUser();
  57
  58         public BasicAuthCredentials basicAuthCredentials() {
  59                 BasicAuthCredentials basicAuthCredentials = new BasicAuthCredentials();
  60
  61                 basicAuthCredentials.setId((long) 1);
  62                 basicAuthCredentials.setApplicationName("test");
  63                 basicAuthCredentials.setUsername("Test");
  64                 basicAuthCredentials.setPassword("Password");
  65                 basicAuthCredentials.setIsActive("YES");
  66
  67                 List<EPEndpoint> endpoints = new ArrayList<EPEndpoint>();
  68
  69                 EPEndpoint ePEndpoint = new EPEndpoint();
  70                 ePEndpoint.setId((long) 1);
  71                 ePEndpoint.setName("Test");
  72                 endpoints.add(ePEndpoint);
  73                 basicAuthCredentials.setEndpoints(endpoints);
  74
  75                 return basicAuthCredentials;
  76
  77         }
  78
  79         @Test
  80         public void createBasicAuthAccountTest() throws Exception {
  81                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
  82
  83                 EPUser user = mockUser.mockEPUser();
  84                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
  85                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
  86                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
  87                 expectedResponse.setMessage("SUCCESS");
  88                 expectedResponse.setResponse("");
  89                 expectedResponse.setStatus(PortalRestStatusEnum.OK);
  90                 long accountd = 1;
  91
  92                 Mockito.when(basicAuthAccountService.saveBasicAuthAccount(basicAuthCredentials)).thenReturn(accountd);
  93
  94                 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
  95                                 mockedResponse, basicAuthCredentials);
  96                 assertEquals(actualResponse, expectedResponse);
  97         }
  98
  99         @Test
 100         public void createBasicAuthAccountAdminTest() throws Exception {
 101                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 102                 EPUser user = mockUser.mockEPUser();
 103                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 104                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 105                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 106                 expectedResponse.setMessage("Authorization Required");
 107                 expectedResponse.setResponse("Admin Only Operation! ");
 108                 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
 109
 110                 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
 111                                 mockedResponse, basicAuthCredentials);
 112                 assertEquals(actualResponse, expectedResponse);
 113         }
 114
 115         @Test
 116         public void createBasicAuthAccountIfInputNullTest() throws Exception {
 117                 BasicAuthCredentials basicAuthCredentials = null;
 118                 EPUser user = mockUser.mockEPUser();
 119                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 120                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 121                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 122                 expectedResponse.setMessage("FAILURE");
 123                 expectedResponse.setResponse("newBasicAuthAccount cannot be null or empty");
 124                 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
 125                 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
 126                                 mockedResponse, basicAuthCredentials);
 127                 assertEquals(actualResponse, expectedResponse);
 128         }
 129
 130         @Test
 131         public void getBasicAuthAccountTest() throws Exception {
 132                 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
 133                 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
 134                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 135                 basicAuthCredentialsList.add(basicAuthCredentials);
 136
 137                 expectedPortalResponse.setMessage("Success");
 138                 expectedPortalResponse.setResponse(null);
 139                 expectedPortalResponse.setStatus(PortalRestStatusEnum.OK);
 140
 141                 EPUser user = mockUser.mockEPUser();
 142                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 143
 144                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 145                 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
 146                 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
 147                                 .getBasicAuthAccount(mockedRequest, mockedResponse);
 148                 assertEquals(expectedPortalResponse, actualResponse);
 149         }
 150
 151         @Test
 152         public void getBasicAuthAccountIfSuperAdminTest() throws Exception {
 153                 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
 154                 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
 155                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 156                 basicAuthCredentialsList.add(basicAuthCredentials);
 157
 158                 expectedPortalResponse.setMessage("UnAuthorized! Admin Only Operation");
 159                 expectedPortalResponse.setResponse(new ArrayList<>());
 160                 expectedPortalResponse.setStatus(PortalRestStatusEnum.ERROR);
 161
 162                 EPUser user = mockUser.mockEPUser();
 163                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 164
 165                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 166                 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
 167                 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
 168                                 .getBasicAuthAccount(mockedRequest, mockedResponse);
 169                 assertEquals(expectedPortalResponse, actualResponse);
 170         }
 171
 172         @Test
 173         public void updateAccountTest() throws Exception {
 174                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 175                 EPUser user = mockUser.mockEPUser();
 176                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 177                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 178                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 179                 expectedResponse.setMessage("SUCCESS");
 180                 expectedResponse.setResponse("");
 181                 expectedResponse.setStatus(PortalRestStatusEnum.OK);
 182                 long accountd = 1;
 183                 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
 184                                 mockedResponse, accountd, basicAuthCredentials);
 185                 assertEquals(actualResponse, expectedResponse);
 186         }
 187
 188         @Test
 189         public void updateAccountIfSuperAdminTest() throws Exception {
 190                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 191
 192                 EPUser user = mockUser.mockEPUser();
 193                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 194                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 195                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 196                 expectedResponse.setMessage("Authorization Required");
 197                 expectedResponse.setResponse("Admin Only Operation! ");
 198                 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
 199                 long accountd = 1;
 200                 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
 201                                 mockedResponse, accountd, basicAuthCredentials);
 202                 assertEquals(actualResponse, expectedResponse);
 203         }
 204
 205         @Test
 206         public void updateAccountIfInputNullTest() throws Exception {
 207                 BasicAuthCredentials basicAuthCredentials = null;
 208
 209                 EPUser user = mockUser.mockEPUser();
 210                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 211                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 212                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 213                 expectedResponse.setMessage("FAILURE");
 214                 expectedResponse.setResponse("BasicAuthCredentials cannot be null or empty");
 215                 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
 216                 long accountd = 1;
 217                 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
 218                                 mockedResponse, accountd, basicAuthCredentials);
 219                 assertEquals(actualResponse, expectedResponse);
 220         }
 221
 222         @Test
 223         public void deleteAccountTest() throws Exception {
 224                 EPUser user = mockUser.mockEPUser();
 225                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 226
 227                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 228                 expectedResponse.setMessage("SUCCESS");
 229                 expectedResponse.setResponse("");
 230                 expectedResponse.setStatus(PortalRestStatusEnum.OK);
 231                 long accountd = 1;
 232                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 233                 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
 234                                 mockedResponse, accountd);
 235                 assertEquals(actualResponse, expectedResponse);
 236         }
 237
 238         @Test
 239         public void deleteAccountIfNotSuperAdminTest() throws Exception {
 240                 EPUser user = mockUser.mockEPUser();
 241                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 242
 243                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 244                 expectedResponse.setMessage("Authorization Required");
 245                 expectedResponse.setResponse("Admin Only Operation! ");
 246                 expectedResponse.setStatus(PortalRestStatusEnum.ERROR);
 247                 long accountd = 1;
 248                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 249                 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
 250                                 mockedResponse, accountd);
 251                 System.out.println(actualResponse);
 252                 assertEquals(actualResponse, expectedResponse);
 253         }
 254 }