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

   1 package org.openecomp.portalapp.portal.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.framework.MockitoTestSuite;
  18 import org.openecomp.portalapp.portal.controller.BasicAuthAccountController;
  19 import org.openecomp.portalapp.portal.core.MockEPUser;
  20 import org.openecomp.portalapp.portal.domain.BasicAuthCredentials;
  21 import org.openecomp.portalapp.portal.domain.EPEndpoint;
  22 import org.openecomp.portalapp.portal.domain.EPUser;
  23 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  24 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  25 import org.openecomp.portalapp.portal.service.AdminRolesService;
  26 import org.openecomp.portalapp.portal.service.AdminRolesServiceImpl;
  27 import org.openecomp.portalapp.portal.service.BasicAuthAccountService;
  28 import org.openecomp.portalapp.portal.service.BasicAuthAccountServiceImpl;
  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                 PortalRestStatusEnum portalRestStatusEnum = null;
  90                 expectedResponse.setStatus(portalRestStatusEnum.OK);
  91                 long accountd = 1;
  92
  93                 Mockito.when(basicAuthAccountService.saveBasicAuthAccount(basicAuthCredentials)).thenReturn(accountd);
  94
  95                 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
  96                                 mockedResponse, basicAuthCredentials);
  97                 assertEquals(actualResponse, expectedResponse);
  98         }
  99
 100         @Test
 101         public void createBasicAuthAccountAdminTest() throws Exception {
 102                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 103                 EPUser user = mockUser.mockEPUser();
 104                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 105                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 106                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 107                 expectedResponse.setMessage("Authorization Required");
 108                 expectedResponse.setResponse("Admin Only Operation! ");
 109                 PortalRestStatusEnum portalRestStatusEnum = null;
 110                 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
 111
 112                 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
 113                                 mockedResponse, basicAuthCredentials);
 114                 assertEquals(actualResponse, expectedResponse);
 115         }
 116
 117         @Test
 118         public void createBasicAuthAccountIfInputNullTest() throws Exception {
 119                 BasicAuthCredentials basicAuthCredentials = null;
 120                 EPUser user = mockUser.mockEPUser();
 121                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 122                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 123                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 124                 expectedResponse.setMessage("FAILURE");
 125                 expectedResponse.setResponse("newBasicAuthAccount cannot be null or empty");
 126                 PortalRestStatusEnum portalRestStatusEnum = null;
 127                 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
 128                 PortalRestResponse<String> actualResponse = basicAuthAccountController.createBasicAuthAccount(mockedRequest,
 129                                 mockedResponse, basicAuthCredentials);
 130                 assertEquals(actualResponse, expectedResponse);
 131         }
 132
 133         @Test
 134         public void getBasicAuthAccountTest() throws Exception {
 135                 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
 136                 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
 137                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 138                 basicAuthCredentialsList.add(basicAuthCredentials);
 139
 140                 expectedPortalResponse.setMessage("Success");
 141                 expectedPortalResponse.setResponse(null);
 142                 PortalRestStatusEnum portalRestStatusEnum = null;
 143                 expectedPortalResponse.setStatus(portalRestStatusEnum.OK);
 144
 145                 EPUser user = mockUser.mockEPUser();
 146                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 147
 148                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 149                 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
 150                 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
 151                                 .getBasicAuthAccount(mockedRequest, mockedResponse);
 152                 assertEquals(expectedPortalResponse, actualResponse);
 153         }
 154
 155         @Test
 156         public void getBasicAuthAccountIfSuperAdminTest() throws Exception {
 157                 PortalRestResponse<List<BasicAuthCredentials>> expectedPortalResponse = new PortalRestResponse<List<BasicAuthCredentials>>();
 158                 List<BasicAuthCredentials> basicAuthCredentialsList = new ArrayList<BasicAuthCredentials>();
 159                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 160                 basicAuthCredentialsList.add(basicAuthCredentials);
 161
 162                 expectedPortalResponse.setMessage("UnAuthorized! Admin Only Operation");
 163                 expectedPortalResponse.setResponse(new ArrayList<>());
 164                 PortalRestStatusEnum portalRestStatusEnum = null;
 165                 expectedPortalResponse.setStatus(portalRestStatusEnum.ERROR);
 166
 167                 EPUser user = mockUser.mockEPUser();
 168                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 169
 170                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 171                 Mockito.when(basicAuthAccountService.getAccountData()).thenReturn(null);
 172                 PortalRestResponse<List<BasicAuthCredentials>> actualResponse = basicAuthAccountController
 173                                 .getBasicAuthAccount(mockedRequest, mockedResponse);
 174                 assertEquals(expectedPortalResponse, actualResponse);
 175         }
 176
 177         @Test
 178         public void updateAccountTest() throws Exception {
 179                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 180                 EPUser user = mockUser.mockEPUser();
 181                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 182                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 183                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 184                 expectedResponse.setMessage("SUCCESS");
 185                 expectedResponse.setResponse("");
 186                 PortalRestStatusEnum portalRestStatusEnum = null;
 187                 expectedResponse.setStatus(portalRestStatusEnum.OK);
 188                 long accountd = 1;
 189                 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
 190                                 mockedResponse, accountd, basicAuthCredentials);
 191                 assertEquals(actualResponse, expectedResponse);
 192         }
 193
 194         @Test
 195         public void updateAccountIfSuperAdminTest() throws Exception {
 196                 BasicAuthCredentials basicAuthCredentials = basicAuthCredentials();
 197
 198                 EPUser user = mockUser.mockEPUser();
 199                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 200                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 201                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 202                 expectedResponse.setMessage("Authorization Required");
 203                 expectedResponse.setResponse("Admin Only Operation! ");
 204                 PortalRestStatusEnum portalRestStatusEnum = null;
 205                 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
 206                 long accountd = 1;
 207                 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
 208                                 mockedResponse, accountd, basicAuthCredentials);
 209                 assertEquals(actualResponse, expectedResponse);
 210         }
 211
 212         @Test
 213         public void updateAccountIfInputNullTest() throws Exception {
 214                 BasicAuthCredentials basicAuthCredentials = null;
 215
 216                 EPUser user = mockUser.mockEPUser();
 217                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 218                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 219                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 220                 expectedResponse.setMessage("FAILURE");
 221                 expectedResponse.setResponse("BasicAuthCredentials cannot be null or empty");
 222                 PortalRestStatusEnum portalRestStatusEnum = null;
 223                 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
 224                 long accountd = 1;
 225                 PortalRestResponse<String> actualResponse = basicAuthAccountController.updateAccount(mockedRequest,
 226                                 mockedResponse, accountd, basicAuthCredentials);
 227                 assertEquals(actualResponse, expectedResponse);
 228         }
 229
 230         @Test
 231         public void deleteAccountTest() throws Exception {
 232                 EPUser user = mockUser.mockEPUser();
 233                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 234
 235                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 236                 expectedResponse.setMessage("SUCCESS");
 237                 expectedResponse.setResponse("");
 238                 PortalRestStatusEnum portalRestStatusEnum = null;
 239                 expectedResponse.setStatus(portalRestStatusEnum.OK);
 240                 long accountd = 1;
 241                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 242                 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
 243                                 mockedResponse, accountd);
 244                 assertEquals(actualResponse, expectedResponse);
 245         }
 246
 247         @Test
 248         public void deleteAccountIfNotSuperAdminTest() throws Exception {
 249                 EPUser user = mockUser.mockEPUser();
 250                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 251
 252                 PortalRestResponse<String> expectedResponse = new PortalRestResponse<String>();
 253                 expectedResponse.setMessage("Authorization Required");
 254                 expectedResponse.setResponse("Admin Only Operation! ");
 255                 PortalRestStatusEnum portalRestStatusEnum = null;
 256                 expectedResponse.setStatus(portalRestStatusEnum.ERROR);
 257                 long accountd = 1;
 258                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 259                 PortalRestResponse<String> actualResponse = basicAuthAccountController.deleteAccount(mockedRequest,
 260                                 mockedResponse, accountd);
 261                 System.out.println(actualResponse);
 262                 assertEquals(actualResponse, expectedResponse);
 263         }
 264 }