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.id = (long) 1;
 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                 expectedOnboardingApp.id = null;
 289
 290                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 291                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 292                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 293
 294         }
 295
 296         @Test
 297         public void postOnboardAppExternalXSSTest() {
 298                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 299                 expectedportalRestResponse.setMessage(
 300                         "Data is not valid");
 301                 expectedportalRestResponse.setResponse(null);
 302                 PortalRestStatusEnum portalRestStatusEnum = null;
 303                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 304
 305                 OnboardingApp expectedOnboardingApp = new OnboardingApp();;
 306                 expectedOnboardingApp.name = "test";
 307                 expectedOnboardingApp.url="test.com";
 308                 expectedOnboardingApp.restUrl="<script>alert(/XSS”)</script>";
 309                 expectedOnboardingApp.myLoginsAppOwner="testUser";
 310                 expectedOnboardingApp.restrictedApp=false;
 311                 expectedOnboardingApp.isOpen=true;
 312                 expectedOnboardingApp.isEnabled=true;
 313                 EPUser user = mockUser.mockEPUser();
 314                 user.setEmail("guestT@test.portal.onap.org");
 315                 user.setLoginPwd("pwd");
 316                 user.setLoginId("Test");
 317                 List<EPUser> expectedList = new ArrayList<EPUser>();
 318                 expectedList.add(user);
 319
 320                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 321                         .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 322                 assertEquals(expectedportalRestResponse, actualPortalRestResponse);
 323
 324         }
 325
 326         @Test
 327         public void putOnboardAppExternalifAppNullTest() {
 328                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 329                 expectedportalRestResponse.setMessage("Unexpected value for field: id");
 330                 expectedportalRestResponse.setResponse(null);
 331                 PortalRestStatusEnum portalRestStatusEnum = null;
 332                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 333                 Long appId = null;
 334                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 335                 expectedOnboardingApp.id = null;
 336
 337                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 338                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 339                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 340         }
 341
 342         @Test
 343         public void putOnboardAppExternalXSSTest() {
 344                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 345                 expectedportalRestResponse.setMessage(
 346                         "Data is not valid");
 347                 expectedportalRestResponse.setResponse(null);
 348                 PortalRestStatusEnum portalRestStatusEnum = null;
 349                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 350
 351                 OnboardingApp expectedOnboardingApp = new OnboardingApp();;
 352                 expectedOnboardingApp.name = "test";
 353                 expectedOnboardingApp.url="test.com";
 354                 expectedOnboardingApp.restUrl="<script>alert(/XSS”)</script>";
 355                 expectedOnboardingApp.myLoginsAppOwner="testUser";
 356                 expectedOnboardingApp.restrictedApp=false;
 357                 expectedOnboardingApp.isOpen=true;
 358                 expectedOnboardingApp.isEnabled=true;
 359                 EPUser user = mockUser.mockEPUser();
 360                 user.setEmail("guestT@test.portal.onap.org");
 361                 user.setLoginPwd("pwd");
 362                 user.setLoginId("Test");
 363                 List<EPUser> expectedList = new ArrayList<EPUser>();
 364                 expectedList.add(user);
 365
 366                 Long appId = (long) 1;
 367
 368                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 369                         .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 370                 assertEquals(expectedportalRestResponse, actualPortalRestResponse);
 371
 372         }
 373
 374         @Test
 375         public void putOnboardAppExternalIfOnboardingAppDetailsNullTest() {
 376                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 377                 expectedportalRestResponse.setMessage(
 378                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 379                 expectedportalRestResponse.setResponse(null);
 380                 PortalRestStatusEnum portalRestStatusEnum = null;
 381                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 382                 Long appId = (long) 1;
 383                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 384                 expectedOnboardingApp.id = (long) 1;
 385                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 386                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 387                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 388         }
 389
 390         @Test
 391         public void putOnboardAppExternalIfOnboardingAppDetailsTest() {
 392                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 393                 expectedportalRestResponse.setMessage("Failed to find user: testUser");
 394                 expectedportalRestResponse.setResponse(null);
 395                 PortalRestStatusEnum portalRestStatusEnum = null;
 396                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 397                 Long appId = (long) 1;
 398
 399                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 400                 expectedOnboardingApp.id = (long) 1;
 401                 expectedOnboardingApp.name = "test";
 402                 expectedOnboardingApp.url="test.com";
 403                 expectedOnboardingApp.restUrl="test1.com";
 404                 expectedOnboardingApp.myLoginsAppOwner="testUser";
 405                 expectedOnboardingApp.restrictedApp=false;
 406                 expectedOnboardingApp.isOpen=true;
 407                 expectedOnboardingApp.isEnabled=true;
 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         @Test
 426         public void putOnboardAppExternalIfOnboardingAppDetailsTest2() throws Exception {
 427
 428                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 429                 expectedportalRestResponse.setMessage(null);
 430                 expectedportalRestResponse.setResponse(null);
 431                 PortalRestStatusEnum portalRestStatusEnum = null;
 432                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 433
 434                 Long appId = (long) 1;
 435
 436                 OnboardingApp oldOnboardApp = new OnboardingApp();
 437                 oldOnboardApp.id = (long) 1;
 438                 oldOnboardApp.name = "test";
 439                 oldOnboardApp.url="test.com";
 440                 oldOnboardApp.restUrl="test1.com";
 441                 oldOnboardApp.myLoginsAppOwner="12";
 442                 oldOnboardApp.restrictedApp=false;
 443                 oldOnboardApp.isOpen=true;
 444                 oldOnboardApp.isEnabled=true;
 445
 446
 447                 EPUser user = mockUser.mockEPUser();
 448                 user.setEmail("guestT@test.portal.onap.org");
 449                 user.setLoginPwd("pwd");
 450                 user.setLoginId("Test");
 451                 List<EPUser> expectedList = new ArrayList<EPUser>();
 452                 expectedList.add(user);
 453                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 454                 Mockito.when(userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 455                 //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 456                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 457
 458
 459                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 460                 expectedFieldValidator.setHttpStatusCode((long) 200);
 461                 expectedFieldValidator.setFields(null);
 462                 expectedFieldValidator.setErrorCode(null);
 463                 Mockito.when(appService.modifyOnboardingApp(oldOnboardApp, user)).thenReturn(expectedFieldValidator);
 464                 //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 465
 466                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 467                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 468                 }
 469
 470
 471         @Test
 472         public void putOnboardAppExternalTest() throws Exception {
 473
 474                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 475                 expectedportalRestResponse.setMessage("FieldsValidator [httpStatusCode=500, errorCode=null, fields=null]");
 476                 expectedportalRestResponse.setResponse(null);
 477                 PortalRestStatusEnum portalRestStatusEnum = null;
 478                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 479
 480                 Long appId = (long) 1;
 481
 482                 OnboardingApp oldOnboardApp = new OnboardingApp();
 483                 oldOnboardApp.id = (long) 1;
 484                 oldOnboardApp.name = "test";
 485                 oldOnboardApp.url="test.com";
 486                 oldOnboardApp.restUrl="test1.com";
 487                 oldOnboardApp.myLoginsAppOwner="12";
 488                 oldOnboardApp.restrictedApp=false;
 489                 oldOnboardApp.isOpen=true;
 490                 oldOnboardApp.isEnabled=true;
 491
 492
 493                 EPUser user = mockUser.mockEPUser();
 494                 user.setEmail("guestT@test.portal.onap.org");
 495                 user.setLoginPwd("pwd");
 496                 user.setLoginId("Test");
 497                 List<EPUser> expectedList = new ArrayList<EPUser>();
 498                 expectedList.add(user);
 499                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 500                 Mockito.when(userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 501                 //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 502                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 503
 504
 505                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 506                 expectedFieldValidator.setHttpStatusCode((long) 500);
 507                 expectedFieldValidator.setFields(null);
 508                 expectedFieldValidator.setErrorCode(null);
 509                 Mockito.when(appService.modifyOnboardingApp(oldOnboardApp, user)).thenReturn(expectedFieldValidator);
 510                 //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 511
 512                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 513                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 514                 }
 515
 516         @Test
 517         public void putOnboardAppExternalIsNotSuperAdminTest() throws Exception {
 518
 519         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 520         expectedportalRestResponse.setMessage("User lacks Portal admin role: Test");
 521         expectedportalRestResponse.setResponse(null);
 522         PortalRestStatusEnum portalRestStatusEnum = null;
 523         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 524
 525         Long appId = (long) 1;
 526
 527         OnboardingApp oldOnboardApp = new OnboardingApp();
 528         oldOnboardApp.id = (long) 1;
 529         oldOnboardApp.name = "test";
 530         oldOnboardApp.url="test.com";
 531         oldOnboardApp.restUrl="test1.com";
 532         oldOnboardApp.myLoginsAppOwner="12";
 533         oldOnboardApp.restrictedApp=false;
 534         oldOnboardApp.isOpen=true;
 535         oldOnboardApp.isEnabled=true;
 536
 537
 538         EPUser user = mockUser.mockEPUser();
 539         user.setEmail("guestT@test.portal.onap.org");
 540         user.setLoginPwd("pwd");
 541         user.setLoginId("Test");
 542         List<EPUser> expectedList = new ArrayList<EPUser>();
 543         expectedList.add(user);
 544         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 545         Mockito.when(userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 546         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 547         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 548
 549         FieldsValidator expectedFieldValidator = new FieldsValidator();
 550         expectedFieldValidator.setHttpStatusCode((long) 200);
 551         expectedFieldValidator.setFields(null);
 552         expectedFieldValidator.setErrorCode(null);
 553         //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 554
 555         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 556         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 557         }
 558
 559         @Test
 560         public void putOnboardAppExternalWithExceptionTest() {
 561                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 562                 expectedportalRestResponse.setMessage("java.lang.NullPointerException");
 563                 expectedportalRestResponse.setResponse(null);
 564                 PortalRestStatusEnum portalRestStatusEnum = null;
 565                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 566                 EPUser user = mockUser.mockEPUser();
 567                 user.setEmail("guestT@test.portal.onap.org");
 568                 user.setLoginPwd("pwd");
 569                 user.setLoginId("Test");
 570                 Long appId = (long) 1;
 571
 572                 OnboardingApp oldOnboardApp = new OnboardingApp();
 573                 oldOnboardApp.id = (long) 1;
 574                 oldOnboardApp.name = "test";
 575                 oldOnboardApp.url="test.com";
 576                 oldOnboardApp.restUrl="test1.com";
 577                 oldOnboardApp.myLoginsAppOwner="12";
 578                 oldOnboardApp.restrictedApp=false;
 579                 oldOnboardApp.isOpen=true;
 580                 oldOnboardApp.isEnabled=true;
 581                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 582                 Mockito.when(userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner)).thenThrow(nullPointerException);
 583                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 584                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId,oldOnboardApp);
 585                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 586         }
 587
 588         @Test
 589         public void postOnboardAppExternalwithExceptionTest() throws Exception {
 590
 591         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 592         expectedportalRestResponse.setMessage("User lacks Portal admin role: Test");
 593         expectedportalRestResponse.setResponse(null);
 594         PortalRestStatusEnum portalRestStatusEnum = null;
 595         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 596
 597         Long appId = (long) 1;
 598
 599
 600
 601         OnboardingApp newOnboardApp = new OnboardingApp();
 602         //newOnboardApp.id = (long) 1;
 603         newOnboardApp.name = "test";
 604         newOnboardApp.url="test.com";
 605         newOnboardApp.restUrl="test1.com";
 606         newOnboardApp.myLoginsAppOwner="12";
 607         newOnboardApp.restrictedApp=false;
 608         newOnboardApp.isOpen=true;
 609         newOnboardApp.isEnabled=true;
 610
 611
 612         EPUser user = mockUser.mockEPUser();
 613         user.setEmail("guestT@test.portal.onap.org");
 614         user.setLoginPwd("pwd");
 615         user.setLoginId("Test");
 616         List<EPUser> expectedList = new ArrayList<EPUser>();
 617         expectedList.add(user);
 618         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 619         Mockito.when(userService.getUserByUserId(newOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 620         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 621         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 622
 623         FieldsValidator expectedFieldValidator = new FieldsValidator();
 624         expectedFieldValidator.setHttpStatusCode((long) 200);
 625         expectedFieldValidator.setFields(null);
 626         expectedFieldValidator.setErrorCode(null);
 627         //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 628
 629         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 630         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 631         }
 632
 633         @Test
 634         public void postOnboardAppExternalIsNotSuperAdminTest() throws Exception {
 635
 636         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 637         expectedportalRestResponse.setMessage("java.lang.NullPointerException");
 638         expectedportalRestResponse.setResponse(null);
 639         PortalRestStatusEnum portalRestStatusEnum = null;
 640         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 641
 642         Long appId = (long) 1;
 643
 644
 645
 646         OnboardingApp newOnboardApp = new OnboardingApp();
 647         //newOnboardApp.id = (long) 1;
 648         newOnboardApp.name = "test";
 649         newOnboardApp.url="test.com";
 650         newOnboardApp.restUrl="test1.com";
 651         newOnboardApp.myLoginsAppOwner="12";
 652         newOnboardApp.restrictedApp=false;
 653         newOnboardApp.isOpen=true;
 654         newOnboardApp.isEnabled=true;
 655
 656
 657         EPUser user = mockUser.mockEPUser();
 658         user.setEmail("guestT@test.portal.onap.org");
 659         user.setLoginPwd("pwd");
 660         user.setLoginId("Test");
 661         List<EPUser> expectedList = new ArrayList<EPUser>();
 662         expectedList.add(user);
 663         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 664         Mockito.when(userService.getUserByUserId(newOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 665         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 666         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 667
 668         FieldsValidator expectedFieldValidator = new FieldsValidator();
 669         expectedFieldValidator.setHttpStatusCode((long) 200);
 670         expectedFieldValidator.setFields(null);
 671         expectedFieldValidator.setErrorCode(null);
 672         //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 673
 674         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 675         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 676         }
 677
 678         @Test
 679         public void postOnboardAppExternalIsSuperAdminTest() throws Exception {
 680
 681         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 682         expectedportalRestResponse.setMessage(null);
 683         expectedportalRestResponse.setResponse(null);
 684         PortalRestStatusEnum portalRestStatusEnum = null;
 685         expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 686
 687         Long appId = (long) 1;
 688
 689
 690
 691         OnboardingApp newOnboardApp = new OnboardingApp();
 692         //newOnboardApp.id = (long) 1;
 693         newOnboardApp.name = "test";
 694         newOnboardApp.url="test.com";
 695         newOnboardApp.restUrl="test1.com";
 696         newOnboardApp.myLoginsAppOwner="12";
 697         newOnboardApp.restrictedApp=false;
 698         newOnboardApp.isOpen=true;
 699         newOnboardApp.isEnabled=true;
 700
 701
 702         EPUser user = mockUser.mockEPUser();
 703         user.setEmail("guestT@test.portal.onap.org");
 704         user.setLoginPwd("pwd");
 705         user.setLoginId("Test");
 706         List<EPUser> expectedList = new ArrayList<EPUser>();
 707         expectedList.add(user);
 708         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 709         Mockito.when(userService.getUserByUserId(newOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 710         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 711         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 712
 713         FieldsValidator expectedFieldValidator = new FieldsValidator();
 714         expectedFieldValidator.setHttpStatusCode((long) 200);
 715         expectedFieldValidator.setFields(null);
 716         expectedFieldValidator.setErrorCode(null);
 717         Mockito.when(appService.addOnboardingApp(newOnboardApp, user)).thenReturn(expectedFieldValidator);
 718
 719         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 720         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 721         }
 722
 723 }