gerrit.onap Code Review - portal.git/blob

   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.AppsControllerExternalRequest;
  18 import org.openecomp.portalapp.portal.domain.EPApp;
  19 import org.openecomp.portalapp.portal.domain.EPUser;
  20 import org.openecomp.portalapp.portal.ecomp.model.PortalRestResponse;
  21 import org.openecomp.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  22 import org.openecomp.portalapp.portal.service.AdminRolesService;
  23 import org.openecomp.portalapp.portal.service.EPAppService;
  24 import org.openecomp.portalapp.portal.service.PortalAdminService;
  25 import org.openecomp.portalapp.portal.service.UserService;
  26 import org.openecomp.portalapp.portal.service.UserServiceImpl;
  27 import org.openecomp.portalapp.portal.test.core.MockEPUser;
  28 import org.openecomp.portalapp.portal.transport.FieldsValidator;
  29 import org.openecomp.portalapp.portal.transport.OnboardingApp;
  30 import org.openecomp.portalapp.test.framework.MockitoTestSuite;
  31 import org.openecomp.portalapp.util.EPUserUtils;
  32
  33 public class AppsControllerExternalRequestTest extends MockitoTestSuite {
  34
  35         @Mock
  36         AdminRolesService adminRolesService;
  37
  38         @Mock
  39         EPAppService appService;
  40
  41         @Mock
  42         PortalAdminService portalAdminService;
  43
  44         @Mock
  45         UserService userService = new UserServiceImpl();
  46
  47         @InjectMocks
  48         AppsControllerExternalRequest appsControllerExternalRequest = new AppsControllerExternalRequest();
  49
  50         @Before
  51         public void setup() {
  52                 MockitoAnnotations.initMocks(this);
  53         }
  54
  55         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  56
  57         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  58         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  59         NullPointerException nullPointerException = new NullPointerException();
  60
  61         MockEPUser mockUser = new MockEPUser();
  62         @Mock
  63         EPUserUtils ePUserUtils = new EPUserUtils();
  64
  65         @Test
  66         public void postPortalAdminIfUSerNullTest() {
  67                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
  68                 expectedportalRestResponse.setMessage("Missing required field: email, loginId, or loginPwd");
  69                 expectedportalRestResponse.setResponse(null);
  70                 PortalRestStatusEnum portalRestStatusEnum = null;
  71                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
  72                 EPUser user = mockUser.mockEPUser();
  73                 user.setEmail("guestT@Research.att.com");
  74                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
  75                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
  76                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
  77                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
  78         }
  79
  80         @Test
  81         public void postPortalAdminTest() {
  82                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
  83                 expectedportalRestResponse.setMessage("java.lang.NullPointerException");
  84                 expectedportalRestResponse.setResponse(null);
  85                 PortalRestStatusEnum portalRestStatusEnum = null;
  86                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
  87                 EPUser user = mockUser.mockEPUser();
  88                 user.setEmail("guestT@Research.att.com");
  89                 user.setLoginPwd("pwd");
  90                 user.setLoginId("Test");
  91                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
  92                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenThrow(nullPointerException);
  93                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
  94                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
  95                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
  96         }
  97
  98         @Test
  99         public void postPortalAdminCreateUserIfNotFoundTest() throws Exception {
 100                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 101                 expectedportalRestResponse.setMessage(null);
 102                 expectedportalRestResponse.setResponse(null);
 103                 PortalRestStatusEnum portalRestStatusEnum = null;
 104                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 105                 EPUser user = mockUser.mockEPUser();
 106                 user.setEmail("guestT@Research.att.com");
 107                 user.setLoginPwd("pwd");
 108                 user.setLoginId("Test");
 109                 List<EPUser> expectedList = null;
 110                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 111                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 112                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 113                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 114                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 115                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 116         }
 117
 118         @Test
 119         public void postPortalAdminCreateUserIfFoundTest() throws Exception {
 120                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 121                 expectedportalRestResponse.setMessage(null);
 122                 expectedportalRestResponse.setResponse(null);
 123                 PortalRestStatusEnum portalRestStatusEnum = null;
 124                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 125                 EPUser user = mockUser.mockEPUser();
 126                 user.setEmail("guestT@Research.att.com");
 127                 user.setLoginPwd("pwd");
 128                 user.setLoginId("Test");
 129                 List<EPUser> expectedList = new ArrayList<EPUser>();
 130                 expectedList.add(user);
 131                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 132                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 133                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 134                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 135                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 136                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 137                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 138         }
 139
 140         @Test
 141         public void postPortalAdminCreateUserIfNotSuperAdminTest() throws Exception {
 142                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 143                 expectedportalRestResponse.setMessage(null);
 144                 expectedportalRestResponse.setResponse(null);
 145                 PortalRestStatusEnum portalRestStatusEnum = null;
 146                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 147                 EPUser user = mockUser.mockEPUser();
 148                 user.setEmail("guestT@Research.att.com");
 149                 user.setLoginPwd("pwd");
 150                 user.setLoginId("Test");
 151                 List<EPUser> expectedList = new ArrayList<EPUser>();
 152                 expectedList.add(user);
 153                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 154                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 155                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 156                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 157
 158                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 159                 expectedFieldValidator.setHttpStatusCode((long) 200);
 160                 expectedFieldValidator.setFields(null);
 161                 expectedFieldValidator.setErrorCode(null);
 162                 Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 163
 164                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 165                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 166                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 167         }
 168
 169         @Test
 170         public void postPortalAdminCreateUserIfFieldValidatorErrorTest() throws Exception {
 171                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 172                 expectedFieldValidator.setHttpStatusCode((long) 500);
 173                 expectedFieldValidator.setFields(null);
 174                 expectedFieldValidator.setErrorCode(null);
 175                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 176                 expectedportalRestResponse.setMessage("FieldsValidator [httpStatusCode=500, errorCode=null, fields=null]");
 177                 expectedportalRestResponse.setResponse(null);
 178                 PortalRestStatusEnum portalRestStatusEnum = null;
 179                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 180                 EPUser user = mockUser.mockEPUser();
 181                 user.setEmail("guestT@Research.att.com");
 182                 user.setLoginPwd("pwd");
 183                 user.setLoginId("Test");
 184                 List<EPUser> expectedList = new ArrayList<EPUser>();
 185                 expectedList.add(user);
 186                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 187                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 188                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 189                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 190                 Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 191                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 192                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 193                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 194         }
 195
 196         @Test
 197         public void getOnboardAppExternalTest() {
 198                 EPApp epApp = new EPApp();
 199                 Long appId = (long) 1;
 200                 Mockito.when(appService.getApp(appId)).thenReturn(epApp);
 201                 OnboardingApp expectedApp = new OnboardingApp();
 202                 Mockito.doNothing().when(appService).createOnboardingFromApp(epApp, expectedApp);
 203                 OnboardingApp actualApp = appsControllerExternalRequest.getOnboardAppExternal(mockedRequest, mockedResponse,
 204                                 appId);
 205                 assertEquals(expectedApp.getClass(), actualApp.getClass());
 206         }
 207
 208         @Test
 209         public void postOnboardAppExternalExceptionTest() {
 210                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 211                 expectedportalRestResponse.setMessage("Unexpected field: id");
 212                 expectedportalRestResponse.setResponse(null);
 213                 PortalRestStatusEnum portalRestStatusEnum = null;
 214                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 215
 216                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 217                 expectedOnboardingApp.id = (long) 1;
 218
 219                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 220                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 221                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 222         }
 223
 224         @Test
 225         public void postOnboardAppExternalTest() {
 226                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 227                 expectedportalRestResponse.setMessage(
 228                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 229                 expectedportalRestResponse.setResponse(null);
 230                 PortalRestStatusEnum portalRestStatusEnum = null;
 231                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 232
 233                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 234                 expectedOnboardingApp.id = null;
 235
 236                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 237                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 238                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 239
 240         }
 241
 242         @Test
 243         public void postOnboardAppExternalNotNullTest() {
 244                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 245                 expectedportalRestResponse.setMessage("Failed to find user: Test_Owener");
 246                 expectedportalRestResponse.setResponse(null);
 247                 PortalRestStatusEnum portalRestStatusEnum = null;
 248                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 249                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 250                 expectedOnboardingApp.id = null;
 251                 expectedOnboardingApp.name = "Test";
 252                 expectedOnboardingApp.url = "Test";
 253                 expectedOnboardingApp.restUrl = "Test";
 254                 expectedOnboardingApp.myLoginsAppOwner = "Test_Owener";
 255                 expectedOnboardingApp.restrictedApp = false;
 256                 expectedOnboardingApp.isOpen = false;
 257                 expectedOnboardingApp.isEnabled = false;
 258                 Mockito.when(userService.getUserByUserId(expectedOnboardingApp.myLoginsAppOwner)).thenReturn(null);
 259                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 260                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 261                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 262
 263         }
 264
 265         @Test
 266         public void postOnboardAppExternalIfUSerListNotNullTest() {
 267                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 268                 expectedportalRestResponse.setMessage("User lacks Portal admin role: null");
 269                 expectedportalRestResponse.setResponse(null);
 270                 PortalRestStatusEnum portalRestStatusEnum = null;
 271                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 272                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 273                 expectedOnboardingApp.id = null;
 274                 expectedOnboardingApp.name = "Test";
 275                 expectedOnboardingApp.url = "Test";
 276                 expectedOnboardingApp.restUrl = "Test";
 277                 expectedOnboardingApp.myLoginsAppOwner = "Test_Owener";
 278                 expectedOnboardingApp.restrictedApp = false;
 279                 expectedOnboardingApp.isOpen = false;
 280                 expectedOnboardingApp.isEnabled = false;
 281                 List<EPUser> userList = new ArrayList<EPUser>();
 282                 EPUser user = mockUser.mockEPUser();
 283                 userList.add(user);
 284                 Mockito.when(userService.getUserByUserId(expectedOnboardingApp.myLoginsAppOwner)).thenReturn(userList);
 285                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 286                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 287                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 288
 289         }
 290
 291         @Test
 292         public void postOnboardAppExternalIfSuperAdminTest() {
 293                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 294                 expectedportalRestResponse.setMessage(null);
 295                 expectedportalRestResponse.setResponse(null);
 296                 PortalRestStatusEnum portalRestStatusEnum = null;
 297                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 298                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 299                 expectedOnboardingApp.id = null;
 300                 expectedOnboardingApp.name = "Test";
 301                 expectedOnboardingApp.url = "Test";
 302                 expectedOnboardingApp.restUrl = "Test";
 303                 expectedOnboardingApp.myLoginsAppOwner = "Test_Owener";
 304                 expectedOnboardingApp.restrictedApp = false;
 305                 expectedOnboardingApp.isOpen = false;
 306                 expectedOnboardingApp.isEnabled = false;
 307                 List<EPUser> userList = new ArrayList<EPUser>();
 308                 EPUser user = mockUser.mockEPUser();
 309                 userList.add(user);
 310                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 311                 expectedFieldValidator.setHttpStatusCode((long) 200);
 312                 expectedFieldValidator.setFields(null);
 313                 expectedFieldValidator.setErrorCode(null);
 314                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 315                 Mockito.when(userService.getUserByUserId(expectedOnboardingApp.myLoginsAppOwner)).thenReturn(userList);
 316                 Mockito.when(appService.addOnboardingApp(expectedOnboardingApp, user)).thenReturn(expectedFieldValidator);
 317                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 318                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 319                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 320
 321         }
 322
 323         @Test
 324         public void postOnboardAppExternalFieldValidatorTestTest() {
 325                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 326                 expectedportalRestResponse.setMessage("FieldsValidator [httpStatusCode=500, errorCode=null, fields=null]");
 327                 expectedportalRestResponse.setResponse(null);
 328                 PortalRestStatusEnum portalRestStatusEnum = null;
 329                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 330                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 331                 expectedOnboardingApp.id = null;
 332                 expectedOnboardingApp.name = "Test";
 333                 expectedOnboardingApp.url = "Test";
 334                 expectedOnboardingApp.restUrl = "Test";
 335                 expectedOnboardingApp.myLoginsAppOwner = "Test_Owener";
 336                 expectedOnboardingApp.restrictedApp = false;
 337                 expectedOnboardingApp.isOpen = false;
 338                 expectedOnboardingApp.isEnabled = false;
 339                 List<EPUser> userList = new ArrayList<EPUser>();
 340                 EPUser user = mockUser.mockEPUser();
 341                 userList.add(user);
 342                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 343                 expectedFieldValidator.setHttpStatusCode((long) 500);
 344                 expectedFieldValidator.setFields(null);
 345                 expectedFieldValidator.setErrorCode(null);
 346                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 347                 Mockito.when(userService.getUserByUserId(expectedOnboardingApp.myLoginsAppOwner)).thenReturn(userList);
 348                 Mockito.when(appService.addOnboardingApp(expectedOnboardingApp, user)).thenReturn(expectedFieldValidator);
 349                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 350                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 351                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 352
 353         }
 354
 355         @Test
 356         public void putOnboardAppExternalifAppNullTest() {
 357                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 358                 expectedportalRestResponse.setMessage("Unexpected value for field: id");
 359                 expectedportalRestResponse.setResponse(null);
 360                 PortalRestStatusEnum portalRestStatusEnum = null;
 361                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 362                 Long appId = null;
 363                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 364                 expectedOnboardingApp.id = null;
 365
 366                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 367                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 368                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 369         }
 370
 371         @Test
 372         public void putOnboardAppExternalIfOnboardingAppDetailsNullTest() {
 373                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 374                 expectedportalRestResponse.setMessage(
 375                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 376                 expectedportalRestResponse.setResponse(null);
 377                 PortalRestStatusEnum portalRestStatusEnum = null;
 378                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 379                 Long appId = (long) 1;
 380                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 381                 expectedOnboardingApp.id = (long) 1;
 382                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 383                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 384                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 385         }
 386
 387         @Test
 388         public void putOnboardAppExternalIfOnboardingIfUserListNullTest() {
 389                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 390                 expectedportalRestResponse.setMessage("Failed to find user: Test_Owener");
 391                 expectedportalRestResponse.setResponse(null);
 392                 PortalRestStatusEnum portalRestStatusEnum = null;
 393                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 394                 Long appId = (long) 1;
 395                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 396                 expectedOnboardingApp.id = (long) 1;
 397                 expectedOnboardingApp.name = "Test";
 398                 expectedOnboardingApp.url = "Test";
 399                 expectedOnboardingApp.restUrl = "Test";
 400                 expectedOnboardingApp.myLoginsAppOwner = "Test_Owener";
 401                 expectedOnboardingApp.restrictedApp = false;
 402                 expectedOnboardingApp.isOpen = false;
 403                 expectedOnboardingApp.isEnabled = false;
 404                 Mockito.when(userService.getUserByUserId(expectedOnboardingApp.myLoginsAppOwner)).thenReturn(null);
 405
 406                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 407                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 408                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 409         }
 410
 411         @Test
 412         public void putOnboardAppExternalIfOnboardingIfUserListNotNullTest() {
 413                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 414                 expectedportalRestResponse.setMessage("User lacks Portal admin role: null");
 415                 expectedportalRestResponse.setResponse(null);
 416                 PortalRestStatusEnum portalRestStatusEnum = null;
 417                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 418                 Long appId = (long) 1;
 419                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 420                 expectedOnboardingApp.id = (long) 1;
 421                 expectedOnboardingApp.name = "Test";
 422                 expectedOnboardingApp.url = "Test";
 423                 expectedOnboardingApp.restUrl = "Test";
 424                 expectedOnboardingApp.myLoginsAppOwner = "Test_Owener";
 425                 expectedOnboardingApp.restrictedApp = false;
 426                 expectedOnboardingApp.isOpen = false;
 427                 expectedOnboardingApp.isEnabled = false;
 428                 List<EPUser> userList = new ArrayList<EPUser>();
 429                 EPUser user = mockUser.mockEPUser();
 430                 userList.add(user);
 431                 Mockito.when(userService.getUserByUserId(expectedOnboardingApp.myLoginsAppOwner)).thenReturn(userList);
 432                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 433                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 434                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 435                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 436         }
 437
 438         @Test
 439         public void putOnboardAppExternalIfOnboardingIfSuperAdminTest() {
 440                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 441                 expectedportalRestResponse.setMessage(null);
 442                 expectedportalRestResponse.setResponse(null);
 443                 PortalRestStatusEnum portalRestStatusEnum = null;
 444                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 445                 Long appId = (long) 1;
 446                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 447                 expectedOnboardingApp.id = (long) 1;
 448                 expectedOnboardingApp.name = "Test";
 449                 expectedOnboardingApp.url = "Test";
 450                 expectedOnboardingApp.restUrl = "Test";
 451                 expectedOnboardingApp.myLoginsAppOwner = "Test_Owener";
 452                 expectedOnboardingApp.restrictedApp = false;
 453                 expectedOnboardingApp.isOpen = false;
 454                 expectedOnboardingApp.isEnabled = false;
 455                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 456                 expectedFieldValidator.setHttpStatusCode((long) 200);
 457                 expectedFieldValidator.setFields(null);
 458                 expectedFieldValidator.setErrorCode(null);
 459                 List<EPUser> userList = new ArrayList<EPUser>();
 460                 EPUser user = mockUser.mockEPUser();
 461                 userList.add(user);
 462                 Mockito.when(appService.modifyOnboardingApp(expectedOnboardingApp, user)).thenReturn(expectedFieldValidator);
 463                 Mockito.when(userService.getUserByUserId(expectedOnboardingApp.myLoginsAppOwner)).thenReturn(userList);
 464                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 465                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 466                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 467                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 468         }
 469
 470         @Test
 471         public void putOnboardAppExternalIfOnboardingIfStatusNotSuccessTest() {
 472                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 473                 expectedportalRestResponse.setMessage("FieldsValidator [httpStatusCode=500, errorCode=null, fields=null]");
 474                 expectedportalRestResponse.setResponse(null);
 475                 PortalRestStatusEnum portalRestStatusEnum = null;
 476                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 477                 Long appId = (long) 1;
 478                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 479                 expectedOnboardingApp.id = (long) 1;
 480                 expectedOnboardingApp.name = "Test";
 481                 expectedOnboardingApp.url = "Test";
 482                 expectedOnboardingApp.restUrl = "Test";
 483                 expectedOnboardingApp.myLoginsAppOwner = "Test_Owener";
 484                 expectedOnboardingApp.restrictedApp = false;
 485                 expectedOnboardingApp.isOpen = false;
 486                 expectedOnboardingApp.isEnabled = false;
 487
 488                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 489                 expectedFieldValidator.setHttpStatusCode((long) 500);
 490                 expectedFieldValidator.setFields(null);
 491                 expectedFieldValidator.setErrorCode(null);
 492
 493                 List<EPUser> userList = new ArrayList<EPUser>();
 494                 EPUser user = mockUser.mockEPUser();
 495                 userList.add(user);
 496                 Mockito.when(appService.modifyOnboardingApp(expectedOnboardingApp, user)).thenReturn(expectedFieldValidator);
 497                 Mockito.when(userService.getUserByUserId(expectedOnboardingApp.myLoginsAppOwner)).thenReturn(userList);
 498                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 499                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 500                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 501                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 502         }
 503 }