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

   1 /*-
   2  * ============LICENSE_START==========================================
   3  * ONAP Portal
   4  * ===================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ===================================================================
   7  *
   8  * Unless otherwise specified, all software contained herein is licensed
   9  * under the Apache License, Version 2.0 (the "License");
  10  * you may not use this software except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *             http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * Unless otherwise specified, all documentation contained herein is licensed
  22  * under the Creative Commons License, Attribution 4.0 Intl. (the "License");
  23  * you may not use this documentation except in compliance with the License.
  24  * You may obtain a copy of the License at
  25  *
  26  *             https://creativecommons.org/licenses/by/4.0/
  27  *
  28  * Unless required by applicable law or agreed to in writing, documentation
  29  * distributed under the License is distributed on an "AS IS" BASIS,
  30  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  31  * See the License for the specific language governing permissions and
  32  * limitations under the License.
  33  *
  34  * ============LICENSE_END============================================
  35  *
  36  *
  37  */
  38 package org.onap.portalapp.portal.controller;
  39
  40 import static org.junit.Assert.assertEquals;
  41
  42 import java.util.ArrayList;
  43 import java.util.List;
  44
  45 import javax.servlet.http.HttpServletRequest;
  46 import javax.servlet.http.HttpServletResponse;
  47
  48 import org.junit.Before;
  49 import org.junit.Test;
  50 import org.mockito.InjectMocks;
  51 import org.mockito.Mock;
  52 import org.mockito.Mockito;
  53 import org.mockito.MockitoAnnotations;
  54 import org.onap.portalapp.portal.core.MockEPUser;
  55 import org.onap.portalapp.portal.domain.EPApp;
  56 import org.onap.portalapp.portal.domain.EPUser;
  57 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
  58 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  59 import org.onap.portalapp.portal.framework.MockitoTestSuite;
  60 import org.onap.portalapp.portal.service.AdminRolesService;
  61 import org.onap.portalapp.portal.service.EPAppService;
  62 import org.onap.portalapp.portal.service.PortalAdminService;
  63 import org.onap.portalapp.portal.service.UserService;
  64 import org.onap.portalapp.portal.service.UserServiceImpl;
  65 import org.onap.portalapp.portal.transport.FieldsValidator;
  66 import org.onap.portalapp.portal.transport.OnboardingApp;
  67 import org.onap.portalapp.util.EPUserUtils;
  68
  69 public class AppsControllerExternalRequestTest extends MockitoTestSuite {
  70
  71         @Mock
  72         AdminRolesService adminRolesService;
  73
  74         @Mock
  75         EPAppService appService;
  76
  77         @Mock
  78         PortalAdminService portalAdminService;
  79
  80         @Mock
  81         UserService userService = new UserServiceImpl();
  82
  83         @InjectMocks
  84         AppsControllerExternalRequest appsControllerExternalRequest;
  85
  86         @Before
  87         public void setup() {
  88                 MockitoAnnotations.initMocks(this);
  89         }
  90
  91         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  92
  93         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  94         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  95         NullPointerException nullPointerException = new NullPointerException();
  96
  97         MockEPUser mockUser = new MockEPUser();
  98         @Mock
  99         EPUserUtils ePUserUtils = new EPUserUtils();
 100
 101         @Test
 102         public void postPortalAdminIfUSerNullTest() {
 103                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 104                 expectedportalRestResponse.setMessage("Missing required field: email, loginId, or loginPwd");
 105                 expectedportalRestResponse.setResponse(null);
 106                 PortalRestStatusEnum portalRestStatusEnum = null;
 107                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 108                 EPUser user = mockUser.mockEPUser();
 109                 user.setEmail("guestT@test.portal.onap.org");
 110                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 111                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 112                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 113                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 114         }
 115
 116         @Test
 117         public void postPortalAdminTest() {
 118                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 119                 expectedportalRestResponse.setMessage("java.lang.NullPointerException");
 120                 expectedportalRestResponse.setResponse(null);
 121                 PortalRestStatusEnum portalRestStatusEnum = null;
 122                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 123                 EPUser user = mockUser.mockEPUser();
 124                 user.setEmail("guestT@test.portal.onap.org");
 125                 user.setLoginPwd("pwd");
 126                 user.setLoginId("Test");
 127                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 128                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenThrow(nullPointerException);
 129                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 130                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 131                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 132         }
 133
 134         @Test
 135         public void postPortalAdminXSSTest() {
 136                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 137                 expectedportalRestResponse.setMessage("Data is not valid");
 138                 expectedportalRestResponse.setResponse(null);
 139                 PortalRestStatusEnum portalRestStatusEnum = null;
 140                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 141                 EPUser user = mockUser.mockEPUser();
 142                 user.setEmail("“><script>alert(“XSS”)</script>");
 143                 user.setLoginPwd("pwd");
 144                 user.setLoginId("Test");
 145                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 146                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenThrow(nullPointerException);
 147                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 148                         .postPortalAdmin(mockedRequest, mockedResponse, user);
 149                 assertEquals(expectedportalRestResponse, actualPortalRestResponse);
 150         }
 151
 152         @Test
 153         public void postPortalAdminCreateUserIfNotFoundTest() throws Exception {
 154                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 155                 expectedportalRestResponse.setMessage(null);
 156                 expectedportalRestResponse.setResponse(null);
 157                 PortalRestStatusEnum portalRestStatusEnum = null;
 158                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 159                 EPUser user = mockUser.mockEPUser();
 160                 user.setEmail("guestT@test.portal.onap.org");
 161                 user.setLoginPwd("pwd");
 162                 user.setLoginId("Test");
 163                 List<EPUser> expectedList = null;
 164                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 165                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 166                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 167                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 168                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 169                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 170         }
 171
 172         @Test
 173         public void postPortalAdminCreateUserIfFoundTest() throws Exception {
 174                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 175                 expectedportalRestResponse.setMessage(null);
 176                 expectedportalRestResponse.setResponse(null);
 177                 PortalRestStatusEnum portalRestStatusEnum = null;
 178                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 179                 EPUser user = mockUser.mockEPUser();
 180                 user.setEmail("guestT@test.portal.onap.org");
 181                 user.setLoginPwd("pwd");
 182                 user.setLoginId("Test");
 183                 List<EPUser> expectedList = new ArrayList<EPUser>();
 184                 expectedList.add(user);
 185                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 186                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 187                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 188                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 189                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 190                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 191                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 192         }
 193 /*reference*/
 194         @Test
 195         public void postPortalAdminCreateUserIfNotSuperAdminTest() throws Exception {
 196                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 197                 expectedportalRestResponse.setMessage(null);
 198                 expectedportalRestResponse.setResponse(null);
 199                 PortalRestStatusEnum portalRestStatusEnum = null;
 200                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 201                 EPUser user = mockUser.mockEPUser();
 202                 user.setEmail("guestT@test.portal.onap.org");
 203                 user.setLoginPwd("pwd");
 204                 user.setLoginId("Test");
 205                 List<EPUser> expectedList = new ArrayList<EPUser>();
 206                 expectedList.add(user);
 207                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 208                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 209                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 210                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 211
 212                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 213                 expectedFieldValidator.setHttpStatusCode((long) 200);
 214                 expectedFieldValidator.setFields(null);
 215                 expectedFieldValidator.setErrorCode(null);
 216                 Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 217
 218                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 219                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 220                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 221         }
 222
 223         @Test
 224         public void postPortalAdminCreateUserIfFieldValidatorErrorTest() throws Exception {
 225                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 226                 expectedFieldValidator.setHttpStatusCode((long) 500);
 227                 expectedFieldValidator.setFields(null);
 228                 expectedFieldValidator.setErrorCode(null);
 229                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 230                 expectedportalRestResponse.setMessage("FieldsValidator [httpStatusCode=500, errorCode=null, fields=null]");
 231                 expectedportalRestResponse.setResponse(null);
 232                 PortalRestStatusEnum portalRestStatusEnum = null;
 233                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 234                 EPUser user = mockUser.mockEPUser();
 235                 user.setEmail("guestT@test.portal.onap.org");
 236                 user.setLoginPwd("pwd");
 237                 user.setLoginId("Test");
 238                 List<EPUser> expectedList = new ArrayList<EPUser>();
 239                 expectedList.add(user);
 240                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 241                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 242                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 243                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 244                 Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 245                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 246                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 247                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 248         }
 249
 250         @Test
 251         public void getOnboardAppExternalTest() {
 252                 EPApp epApp = new EPApp();
 253                 Long appId = (long) 1;
 254                 Mockito.when(appService.getApp(appId)).thenReturn(epApp);
 255                 OnboardingApp expectedApp = new OnboardingApp();
 256                 Mockito.doNothing().when(appService).createOnboardingFromApp(epApp, expectedApp);
 257                 OnboardingApp actualApp = appsControllerExternalRequest.getOnboardAppExternal(mockedRequest, mockedResponse,
 258                                 appId);
 259                 assertEquals(expectedApp.getClass(), actualApp.getClass());
 260         }
 261
 262         @Test
 263         public void postOnboardAppExternalExceptionTest() {
 264                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 265                 expectedportalRestResponse.setMessage("Unexpected field: id");
 266                 expectedportalRestResponse.setResponse(null);
 267                 PortalRestStatusEnum portalRestStatusEnum = null;
 268                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 269
 270                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 271                 expectedOnboardingApp.setId(1l);
 272
 273                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 274                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 275                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 276         }
 277
 278         @Test
 279         public void postOnboardAppExternalTest() {
 280                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 281                 expectedportalRestResponse.setMessage(
 282                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 283                 expectedportalRestResponse.setResponse(null);
 284                 PortalRestStatusEnum portalRestStatusEnum = null;
 285                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 286
 287                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 288
 289                 expectedOnboardingApp.setId(null);
 290
 291                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 292                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 293                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 294
 295         }
 296
 297         private OnboardingApp createExpectedApp() {
 298
 299                 OnboardingApp expectedOnboardingApp = new OnboardingApp();;
 300                 expectedOnboardingApp.setAppName("test");
 301                 expectedOnboardingApp.setLandingPage("test.com");
 302                 expectedOnboardingApp.setRestUrl("<script>alert(/XSS”)</script>");
 303                 expectedOnboardingApp.setMyLoginsAppOwner("testUser");
 304                 expectedOnboardingApp.setRestrictedApp(false);
 305                 expectedOnboardingApp.setIsOpen(true);
 306                 expectedOnboardingApp.setIsEnabled(true);
 307                 return expectedOnboardingApp;
 308
 309         }
 310
 311
 312         @Test
 313         public void postOnboardAppExternalXSSTest() {
 314                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 315                 expectedportalRestResponse.setMessage(
 316                         "Data is not valid");
 317                 expectedportalRestResponse.setResponse(null);
 318                 PortalRestStatusEnum portalRestStatusEnum = null;
 319                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 320
 321                 OnboardingApp expectedOnboardingApp = createExpectedApp();
 322
 323                 EPUser user = mockUser.mockEPUser();
 324                 user.setEmail("guestT@test.portal.onap.org");
 325                 user.setLoginPwd("pwd");
 326                 user.setLoginId("Test");
 327                 List<EPUser> expectedList = new ArrayList<EPUser>();
 328                 expectedList.add(user);
 329
 330                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 331                         .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 332                 assertEquals(expectedportalRestResponse, actualPortalRestResponse);
 333
 334         }
 335
 336         @Test
 337         public void putOnboardAppExternalifAppNullTest() {
 338                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 339                 expectedportalRestResponse.setMessage("Unexpected value for field: id");
 340                 expectedportalRestResponse.setResponse(null);
 341                 PortalRestStatusEnum portalRestStatusEnum = null;
 342                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 343                 Long appId = null;
 344                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 345
 346                 expectedOnboardingApp.setId(null);
 347
 348                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 349                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 350                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 351         }
 352
 353         @Test
 354         public void putOnboardAppExternalXSSTest() {
 355                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 356                 expectedportalRestResponse.setMessage(
 357                         "Data is not valid");
 358                 expectedportalRestResponse.setResponse(null);
 359                 PortalRestStatusEnum portalRestStatusEnum = null;
 360                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 361
 362                 OnboardingApp expectedOnboardingApp = createExpectedApp();
 363
 364                 EPUser user = mockUser.mockEPUser();
 365                 user.setEmail("guestT@test.portal.onap.org");
 366                 user.setLoginPwd("pwd");
 367                 user.setLoginId("Test");
 368                 List<EPUser> expectedList = new ArrayList<EPUser>();
 369                 expectedList.add(user);
 370
 371                 Long appId = (long) 1;
 372
 373                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 374                         .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 375                 assertEquals(expectedportalRestResponse, actualPortalRestResponse);
 376
 377         }
 378
 379         @Test
 380         public void putOnboardAppExternalIfOnboardingAppDetailsNullTest() {
 381                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 382                 expectedportalRestResponse.setMessage(
 383                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 384                 expectedportalRestResponse.setResponse(null);
 385                 PortalRestStatusEnum portalRestStatusEnum = null;
 386                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 387                 Long appId = (long) 1;
 388                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 389
 390                 expectedOnboardingApp.setId(1l);
 391
 392                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 393                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 394                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 395         }
 396
 397         @Test
 398         public void putOnboardAppExternalIfOnboardingAppDetailsTest() {
 399                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 400                 expectedportalRestResponse.setMessage("Failed to find user: 12");
 401                 expectedportalRestResponse.setResponse(null);
 402                 PortalRestStatusEnum portalRestStatusEnum = null;
 403                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 404                 Long appId = (long) 1;
 405
 406                 OnboardingApp expectedOnboardingApp = createOldOnapApp(1l);
 407
 408                 EPUser user = mockUser.mockEPUser();
 409                 user.setEmail("guestT@test.portal.onap.org");
 410                 user.setLoginPwd("pwd");
 411                 user.setLoginId("Test");
 412                 List<EPUser> expectedList = new ArrayList<EPUser>();
 413                 expectedList.add(user);
 414                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 415                 expectedFieldValidator.setHttpStatusCode((long) 200);
 416                 expectedFieldValidator.setFields(null);
 417                 expectedFieldValidator.setErrorCode(null);
 418                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 419
 420                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 421                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 422                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 423         }
 424
 425         private OnboardingApp createOldOnapApp(Long id) {
 426
 427                 OnboardingApp oldOnboardApp = new OnboardingApp();
 428                 oldOnboardApp.setId(id);
 429                 oldOnboardApp.setAppName("test");
 430                 oldOnboardApp.setLandingPage("test.com");
 431                 oldOnboardApp.setRestUrl("test1.com");
 432                 oldOnboardApp.setMyLoginsAppOwner("12");
 433                 oldOnboardApp.setRestrictedApp(false);
 434                 oldOnboardApp.setIsOpen(true);
 435                 oldOnboardApp.setIsEnabled(true);
 436                 oldOnboardApp.setModeOfIntegration("test");
 437                 oldOnboardApp.setAppAck(false);
 438                 oldOnboardApp.setUsesCadi(false);
 439                 oldOnboardApp.setModeOfIntegration("test");
 440                 oldOnboardApp.setAppAck(false);
 441                 oldOnboardApp.setUsesCadi(false);
 442
 443                 return oldOnboardApp;
 444         }
 445
 446         @Test
 447         public void putOnboardAppExternalIfOnboardingAppDetailsTest2() throws Exception {
 448
 449                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 450                 expectedportalRestResponse.setMessage(null);
 451                 expectedportalRestResponse.setResponse(null);
 452                 PortalRestStatusEnum portalRestStatusEnum = null;
 453                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 454
 455                 Long appId = (long) 1;
 456
 457                 OnboardingApp oldOnboardApp = createOldOnapApp(1l);
 458
 459
 460                 EPUser user = mockUser.mockEPUser();
 461                 user.setEmail("guestT@test.portal.onap.org");
 462                 user.setLoginPwd("pwd");
 463                 user.setLoginId("Test");
 464                 List<EPUser> expectedList = new ArrayList<EPUser>();
 465                 expectedList.add(user);
 466                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 467                 Mockito.when(userService.getUserByUserId(oldOnboardApp.getMyLoginsAppOwner())).thenReturn(expectedList);
 468                 //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 469                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 470
 471
 472                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 473                 expectedFieldValidator.setHttpStatusCode((long) 200);
 474                 expectedFieldValidator.setFields(null);
 475                 expectedFieldValidator.setErrorCode(null);
 476                 Mockito.when(appService.modifyOnboardingApp(oldOnboardApp, user)).thenReturn(expectedFieldValidator);
 477                 //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 478
 479                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 480                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 481                 }
 482
 483
 484         @Test
 485         public void putOnboardAppExternalTest() throws Exception {
 486
 487                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 488                 expectedportalRestResponse.setMessage("FieldsValidator [httpStatusCode=500, errorCode=null, fields=null]");
 489                 expectedportalRestResponse.setResponse(null);
 490                 PortalRestStatusEnum portalRestStatusEnum = null;
 491                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 492
 493                 Long appId = (long) 1;
 494
 495                 OnboardingApp oldOnboardApp = createOldOnapApp(1l);
 496
 497
 498                 EPUser user = mockUser.mockEPUser();
 499                 user.setEmail("guestT@test.portal.onap.org");
 500                 user.setLoginPwd("pwd");
 501                 user.setLoginId("Test");
 502                 List<EPUser> expectedList = new ArrayList<EPUser>();
 503                 expectedList.add(user);
 504                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 505                 Mockito.when(userService.getUserByUserId(oldOnboardApp.getMyLoginsAppOwner())).thenReturn(expectedList);
 506                 //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 507                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 508
 509
 510                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 511                 expectedFieldValidator.setHttpStatusCode((long) 500);
 512                 expectedFieldValidator.setFields(null);
 513                 expectedFieldValidator.setErrorCode(null);
 514                 Mockito.when(appService.modifyOnboardingApp(oldOnboardApp, user)).thenReturn(expectedFieldValidator);
 515                 //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 516
 517                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 518                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 519                 }
 520
 521         @Test
 522         public void putOnboardAppExternalIsNotSuperAdminTest() throws Exception {
 523
 524         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 525         expectedportalRestResponse.setMessage("User lacks Portal admin role: Test");
 526         expectedportalRestResponse.setResponse(null);
 527         PortalRestStatusEnum portalRestStatusEnum = null;
 528         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 529
 530         Long appId = (long) 1;
 531
 532         OnboardingApp oldOnboardApp = createOldOnapApp(1l);
 533
 534         EPUser user = mockUser.mockEPUser();
 535         user.setEmail("guestT@test.portal.onap.org");
 536         user.setLoginPwd("pwd");
 537         user.setLoginId("Test");
 538         List<EPUser> expectedList = new ArrayList<EPUser>();
 539         expectedList.add(user);
 540         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 541         Mockito.when(userService.getUserByUserId(oldOnboardApp.getMyLoginsAppOwner())).thenReturn(expectedList);
 542         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 543         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 544
 545         FieldsValidator expectedFieldValidator = new FieldsValidator();
 546         expectedFieldValidator.setHttpStatusCode((long) 200);
 547         expectedFieldValidator.setFields(null);
 548         expectedFieldValidator.setErrorCode(null);
 549         //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 550
 551         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 552         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 553         }
 554
 555         @Test
 556         public void putOnboardAppExternalWithExceptionTest() {
 557                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 558                 expectedportalRestResponse.setMessage("java.lang.NullPointerException");
 559                 expectedportalRestResponse.setResponse(null);
 560                 PortalRestStatusEnum portalRestStatusEnum = null;
 561                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 562                 EPUser user = mockUser.mockEPUser();
 563                 user.setEmail("guestT@test.portal.onap.org");
 564                 user.setLoginPwd("pwd");
 565                 user.setLoginId("Test");
 566                 Long appId = (long) 1;
 567
 568                 OnboardingApp oldOnboardApp = createOldOnapApp(1l);
 569
 570                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 571                 Mockito.when(userService.getUserByUserId(oldOnboardApp.getMyLoginsAppOwner())).thenThrow(nullPointerException);
 572                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 573                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId,oldOnboardApp);
 574                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 575         }
 576
 577         @Test
 578         public void postOnboardAppExternalwithExceptionTest() throws Exception {
 579
 580         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 581         expectedportalRestResponse.setMessage("User lacks Portal admin role: Test");
 582         expectedportalRestResponse.setResponse(null);
 583         PortalRestStatusEnum portalRestStatusEnum = null;
 584         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 585
 586         Long appId = (long) 1;
 587
 588         OnboardingApp newOnboardApp = createOldOnapApp(null);
 589
 590         EPUser user = mockUser.mockEPUser();
 591         user.setEmail("guestT@test.portal.onap.org");
 592         user.setLoginPwd("pwd");
 593         user.setLoginId("Test");
 594         List<EPUser> expectedList = new ArrayList<EPUser>();
 595         expectedList.add(user);
 596         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 597         Mockito.when(userService.getUserByUserId(newOnboardApp.getMyLoginsAppOwner())).thenReturn(expectedList);
 598         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 599         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 600
 601         FieldsValidator expectedFieldValidator = new FieldsValidator();
 602         expectedFieldValidator.setHttpStatusCode((long) 200);
 603         expectedFieldValidator.setFields(null);
 604         expectedFieldValidator.setErrorCode(null);
 605         //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 606
 607         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 608         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 609         }
 610
 611         @Test
 612         public void postOnboardAppExternalIsNotSuperAdminTest() throws Exception {
 613
 614         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 615         expectedportalRestResponse.setMessage("Unexpected field: id");
 616         expectedportalRestResponse.setResponse(null);
 617         PortalRestStatusEnum portalRestStatusEnum = null;
 618         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 619
 620         Long appId = (long) 1;
 621
 622         OnboardingApp newOnboardApp = createOldOnapApp(1l);
 623
 624         EPUser user = mockUser.mockEPUser();
 625         user.setEmail("guestT@test.portal.onap.org");
 626         user.setLoginPwd("pwd");
 627         user.setLoginId("Test");
 628         List<EPUser> expectedList = new ArrayList<EPUser>();
 629         expectedList.add(user);
 630         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 631         Mockito.when(userService.getUserByUserId(newOnboardApp.getMyLoginsAppOwner())).thenReturn(expectedList);
 632         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 633         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 634
 635         FieldsValidator expectedFieldValidator = new FieldsValidator();
 636         expectedFieldValidator.setHttpStatusCode((long) 200);
 637         expectedFieldValidator.setFields(null);
 638         expectedFieldValidator.setErrorCode(null);
 639         //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 640
 641         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 642         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 643         }
 644
 645         @Test
 646         public void postOnboardAppExternalIsSuperAdminTest() throws Exception {
 647
 648         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 649         expectedportalRestResponse.setMessage(null);
 650         expectedportalRestResponse.setResponse(null);
 651         PortalRestStatusEnum portalRestStatusEnum = null;
 652         expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 653
 654         Long appId = (long) 1;
 655
 656         OnboardingApp newOnboardApp = createOldOnapApp(null);
 657
 658         EPUser user = mockUser.mockEPUser();
 659         user.setEmail("guestT@test.portal.onap.org");
 660         user.setLoginPwd("pwd");
 661         user.setLoginId("Test");
 662         List<EPUser> expectedList = new ArrayList<EPUser>();
 663         expectedList.add(user);
 664         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 665         Mockito.when(userService.getUserByUserId(newOnboardApp.getMyLoginsAppOwner())).thenReturn(expectedList);
 666         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 667         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 668
 669         FieldsValidator expectedFieldValidator = new FieldsValidator();
 670         expectedFieldValidator.setHttpStatusCode((long) 200);
 671         expectedFieldValidator.setFields(null);
 672         expectedFieldValidator.setErrorCode(null);
 673         Mockito.when(appService.addOnboardingApp(newOnboardApp, user)).thenReturn(expectedFieldValidator);
 674
 675         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 676         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 677         }
 678
 679 }