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.controller.AppsControllerExternalRequest;
  55 import org.onap.portalapp.portal.core.MockEPUser;
  56 import org.onap.portalapp.portal.domain.EPApp;
  57 import org.onap.portalapp.portal.domain.EPUser;
  58 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
  59 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
  60 import org.onap.portalapp.portal.framework.MockitoTestSuite;
  61 import org.onap.portalapp.portal.service.AdminRolesService;
  62 import org.onap.portalapp.portal.service.EPAppService;
  63 import org.onap.portalapp.portal.service.PortalAdminService;
  64 import org.onap.portalapp.portal.service.UserService;
  65 import org.onap.portalapp.portal.service.UserServiceImpl;
  66 import org.onap.portalapp.portal.transport.FieldsValidator;
  67 import org.onap.portalapp.portal.transport.OnboardingApp;
  68 import org.onap.portalapp.util.EPUserUtils;
  69
  70 public class AppsControllerExternalRequestTest extends MockitoTestSuite {
  71
  72         @Mock
  73         AdminRolesService adminRolesService;
  74
  75         @Mock
  76         EPAppService appService;
  77
  78         @Mock
  79         PortalAdminService portalAdminService;
  80
  81         @Mock
  82         UserService userService = new UserServiceImpl();
  83
  84         @InjectMocks
  85         AppsControllerExternalRequest appsControllerExternalRequest = new AppsControllerExternalRequest();
  86
  87         @Before
  88         public void setup() {
  89                 MockitoAnnotations.initMocks(this);
  90         }
  91
  92         MockitoTestSuite mockitoTestSuite = new MockitoTestSuite();
  93
  94         HttpServletRequest mockedRequest = mockitoTestSuite.getMockedRequest();
  95         HttpServletResponse mockedResponse = mockitoTestSuite.getMockedResponse();
  96         NullPointerException nullPointerException = new NullPointerException();
  97
  98         MockEPUser mockUser = new MockEPUser();
  99         @Mock
 100         EPUserUtils ePUserUtils = new EPUserUtils();
 101
 102         @Test
 103         public void postPortalAdminIfUSerNullTest() {
 104                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 105                 expectedportalRestResponse.setMessage("Missing required field: email, loginId, or loginPwd");
 106                 expectedportalRestResponse.setResponse(null);
 107                 PortalRestStatusEnum portalRestStatusEnum = null;
 108                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 109                 EPUser user = mockUser.mockEPUser();
 110                 user.setEmail("guestT@test.portal.onap.org");
 111                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 112                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 113                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 114                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 115         }
 116
 117         @Test
 118         public void postPortalAdminTest() {
 119                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 120                 expectedportalRestResponse.setMessage("java.lang.NullPointerException");
 121                 expectedportalRestResponse.setResponse(null);
 122                 PortalRestStatusEnum portalRestStatusEnum = null;
 123                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 124                 EPUser user = mockUser.mockEPUser();
 125                 user.setEmail("guestT@test.portal.onap.org");
 126                 user.setLoginPwd("pwd");
 127                 user.setLoginId("Test");
 128                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 129                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenThrow(nullPointerException);
 130                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 131                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 132                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 133         }
 134
 135         @Test
 136         public void postPortalAdminXSSTest() {
 137                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 138                 expectedportalRestResponse.setMessage("Data is not valid");
 139                 expectedportalRestResponse.setResponse(null);
 140                 PortalRestStatusEnum portalRestStatusEnum = null;
 141                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 142                 EPUser user = mockUser.mockEPUser();
 143                 user.setEmail("“><script>alert(“XSS”)</script>");
 144                 user.setLoginPwd("pwd");
 145                 user.setLoginId("Test");
 146                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 147                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenThrow(nullPointerException);
 148                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 149                         .postPortalAdmin(mockedRequest, mockedResponse, user);
 150                 assertEquals(expectedportalRestResponse, actualPortalRestResponse);
 151         }
 152
 153         @Test
 154         public void postPortalAdminCreateUserIfNotFoundTest() throws Exception {
 155                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 156                 expectedportalRestResponse.setMessage(null);
 157                 expectedportalRestResponse.setResponse(null);
 158                 PortalRestStatusEnum portalRestStatusEnum = null;
 159                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 160                 EPUser user = mockUser.mockEPUser();
 161                 user.setEmail("guestT@test.portal.onap.org");
 162                 user.setLoginPwd("pwd");
 163                 user.setLoginId("Test");
 164                 List<EPUser> expectedList = null;
 165                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 166                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 167                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 168                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 169                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 170                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 171         }
 172
 173         @Test
 174         public void postPortalAdminCreateUserIfFoundTest() throws Exception {
 175                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 176                 expectedportalRestResponse.setMessage(null);
 177                 expectedportalRestResponse.setResponse(null);
 178                 PortalRestStatusEnum portalRestStatusEnum = null;
 179                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 180                 EPUser user = mockUser.mockEPUser();
 181                 user.setEmail("guestT@test.portal.onap.org");
 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(true);
 190                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 191                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 192                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 193         }
 194 /*reference*/
 195         @Test
 196         public void postPortalAdminCreateUserIfNotSuperAdminTest() throws Exception {
 197                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 198                 expectedportalRestResponse.setMessage(null);
 199                 expectedportalRestResponse.setResponse(null);
 200                 PortalRestStatusEnum portalRestStatusEnum = null;
 201                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 202                 EPUser user = mockUser.mockEPUser();
 203                 user.setEmail("guestT@test.portal.onap.org");
 204                 user.setLoginPwd("pwd");
 205                 user.setLoginId("Test");
 206                 List<EPUser> expectedList = new ArrayList<EPUser>();
 207                 expectedList.add(user);
 208                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 209                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 210                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 211                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 212
 213                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 214                 expectedFieldValidator.setHttpStatusCode((long) 200);
 215                 expectedFieldValidator.setFields(null);
 216                 expectedFieldValidator.setErrorCode(null);
 217                 Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 218
 219                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 220                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 221                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 222         }
 223
 224         @Test
 225         public void postPortalAdminCreateUserIfFieldValidatorErrorTest() throws Exception {
 226                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 227                 expectedFieldValidator.setHttpStatusCode((long) 500);
 228                 expectedFieldValidator.setFields(null);
 229                 expectedFieldValidator.setErrorCode(null);
 230                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 231                 expectedportalRestResponse.setMessage("FieldsValidator [httpStatusCode=500, errorCode=null, fields=null]");
 232                 expectedportalRestResponse.setResponse(null);
 233                 PortalRestStatusEnum portalRestStatusEnum = null;
 234                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 235                 EPUser user = mockUser.mockEPUser();
 236                 user.setEmail("guestT@test.portal.onap.org");
 237                 user.setLoginPwd("pwd");
 238                 user.setLoginId("Test");
 239                 List<EPUser> expectedList = new ArrayList<EPUser>();
 240                 expectedList.add(user);
 241                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 242                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 243                 Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 244                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 245                 Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 246                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 247                                 .postPortalAdmin(mockedRequest, mockedResponse, user);
 248                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 249         }
 250
 251         @Test
 252         public void getOnboardAppExternalTest() {
 253                 EPApp epApp = new EPApp();
 254                 Long appId = (long) 1;
 255                 Mockito.when(appService.getApp(appId)).thenReturn(epApp);
 256                 OnboardingApp expectedApp = new OnboardingApp();
 257                 Mockito.doNothing().when(appService).createOnboardingFromApp(epApp, expectedApp);
 258                 OnboardingApp actualApp = appsControllerExternalRequest.getOnboardAppExternal(mockedRequest, mockedResponse,
 259                                 appId);
 260                 assertEquals(expectedApp.getClass(), actualApp.getClass());
 261         }
 262
 263         @Test
 264         public void postOnboardAppExternalExceptionTest() {
 265                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 266                 expectedportalRestResponse.setMessage("Unexpected field: id");
 267                 expectedportalRestResponse.setResponse(null);
 268                 PortalRestStatusEnum portalRestStatusEnum = null;
 269                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 270
 271                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 272                 expectedOnboardingApp.id = (long) 1;
 273
 274                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 275                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 276                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 277         }
 278
 279         @Test
 280         public void postOnboardAppExternalTest() {
 281                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 282                 expectedportalRestResponse.setMessage(
 283                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 284                 expectedportalRestResponse.setResponse(null);
 285                 PortalRestStatusEnum portalRestStatusEnum = null;
 286                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 287
 288                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 289                 expectedOnboardingApp.id = null;
 290
 291                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 292                                 .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 293                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 294
 295         }
 296
 297         @Test
 298         public void postOnboardAppExternalXSSTest() {
 299                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 300                 expectedportalRestResponse.setMessage(
 301                         "Data is not valid");
 302                 expectedportalRestResponse.setResponse(null);
 303                 PortalRestStatusEnum portalRestStatusEnum = null;
 304                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 305
 306                 OnboardingApp expectedOnboardingApp = new OnboardingApp();;
 307                 expectedOnboardingApp.name = "test";
 308                 expectedOnboardingApp.url="test.com";
 309                 expectedOnboardingApp.restUrl="<script>alert(/XSS”)</script>";
 310                 expectedOnboardingApp.myLoginsAppOwner="testUser";
 311                 expectedOnboardingApp.restrictedApp=false;
 312                 expectedOnboardingApp.isOpen=true;
 313                 expectedOnboardingApp.isEnabled=true;
 314                 EPUser user = mockUser.mockEPUser();
 315                 user.setEmail("guestT@test.portal.onap.org");
 316                 user.setLoginPwd("pwd");
 317                 user.setLoginId("Test");
 318                 List<EPUser> expectedList = new ArrayList<EPUser>();
 319                 expectedList.add(user);
 320
 321                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 322                         .postOnboardAppExternal(mockedRequest, mockedResponse, expectedOnboardingApp);
 323                 assertEquals(expectedportalRestResponse, actualPortalRestResponse);
 324
 325         }
 326
 327         @Test
 328         public void putOnboardAppExternalifAppNullTest() {
 329                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 330                 expectedportalRestResponse.setMessage("Unexpected value for field: id");
 331                 expectedportalRestResponse.setResponse(null);
 332                 PortalRestStatusEnum portalRestStatusEnum = null;
 333                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 334                 Long appId = null;
 335                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 336                 expectedOnboardingApp.id = null;
 337
 338                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 339                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 340                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 341         }
 342
 343         @Test
 344         public void putOnboardAppExternalXSSTest() {
 345                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 346                 expectedportalRestResponse.setMessage(
 347                         "Data is not valid");
 348                 expectedportalRestResponse.setResponse(null);
 349                 PortalRestStatusEnum portalRestStatusEnum = null;
 350                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 351
 352                 OnboardingApp expectedOnboardingApp = new OnboardingApp();;
 353                 expectedOnboardingApp.name = "test";
 354                 expectedOnboardingApp.url="test.com";
 355                 expectedOnboardingApp.restUrl="<script>alert(/XSS”)</script>";
 356                 expectedOnboardingApp.myLoginsAppOwner="testUser";
 357                 expectedOnboardingApp.restrictedApp=false;
 358                 expectedOnboardingApp.isOpen=true;
 359                 expectedOnboardingApp.isEnabled=true;
 360                 EPUser user = mockUser.mockEPUser();
 361                 user.setEmail("guestT@test.portal.onap.org");
 362                 user.setLoginPwd("pwd");
 363                 user.setLoginId("Test");
 364                 List<EPUser> expectedList = new ArrayList<EPUser>();
 365                 expectedList.add(user);
 366
 367                 Long appId = (long) 1;
 368
 369                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 370                         .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 371                 assertEquals(expectedportalRestResponse, actualPortalRestResponse);
 372
 373         }
 374
 375         @Test
 376         public void putOnboardAppExternalIfOnboardingAppDetailsNullTest() {
 377                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 378                 expectedportalRestResponse.setMessage(
 379                                 "Missing required field: name, url, restUrl, restrictedApp, isOpen, isEnabled, myLoginsAppOwner");
 380                 expectedportalRestResponse.setResponse(null);
 381                 PortalRestStatusEnum portalRestStatusEnum = null;
 382                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 383                 Long appId = (long) 1;
 384                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 385                 expectedOnboardingApp.id = (long) 1;
 386                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 387                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 388                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 389         }
 390
 391         @Test
 392         public void putOnboardAppExternalIfOnboardingAppDetailsTest() {
 393                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 394                 expectedportalRestResponse.setMessage("Failed to find user: testUser");
 395                 expectedportalRestResponse.setResponse(null);
 396                 PortalRestStatusEnum portalRestStatusEnum = null;
 397                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 398                 Long appId = (long) 1;
 399
 400                 OnboardingApp expectedOnboardingApp = new OnboardingApp();
 401                 expectedOnboardingApp.id = (long) 1;
 402                 expectedOnboardingApp.name = "test";
 403                 expectedOnboardingApp.url="test.com";
 404                 expectedOnboardingApp.restUrl="test1.com";
 405                 expectedOnboardingApp.myLoginsAppOwner="testUser";
 406                 expectedOnboardingApp.restrictedApp=false;
 407                 expectedOnboardingApp.isOpen=true;
 408                 expectedOnboardingApp.isEnabled=true;
 409                 EPUser user = mockUser.mockEPUser();
 410                 user.setEmail("guestT@test.portal.onap.org");
 411                 user.setLoginPwd("pwd");
 412                 user.setLoginId("Test");
 413                 List<EPUser> expectedList = new ArrayList<EPUser>();
 414                 expectedList.add(user);
 415                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 416                 expectedFieldValidator.setHttpStatusCode((long) 200);
 417                 expectedFieldValidator.setFields(null);
 418                 expectedFieldValidator.setErrorCode(null);
 419                 Mockito.when(userService.getUserByUserId(user.getOrgUserId())).thenReturn(expectedList);
 420
 421                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 422                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId, expectedOnboardingApp);
 423                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 424         }
 425
 426         @Test
 427         public void putOnboardAppExternalIfOnboardingAppDetailsTest2() throws Exception {
 428
 429                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 430                 expectedportalRestResponse.setMessage(null);
 431                 expectedportalRestResponse.setResponse(null);
 432                 PortalRestStatusEnum portalRestStatusEnum = null;
 433                 expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 434
 435                 Long appId = (long) 1;
 436
 437                 OnboardingApp oldOnboardApp = new OnboardingApp();
 438                 oldOnboardApp.id = (long) 1;
 439                 oldOnboardApp.name = "test";
 440                 oldOnboardApp.url="test.com";
 441                 oldOnboardApp.restUrl="test1.com";
 442                 oldOnboardApp.myLoginsAppOwner="12";
 443                 oldOnboardApp.restrictedApp=false;
 444                 oldOnboardApp.isOpen=true;
 445                 oldOnboardApp.isEnabled=true;
 446
 447
 448                 EPUser user = mockUser.mockEPUser();
 449                 user.setEmail("guestT@test.portal.onap.org");
 450                 user.setLoginPwd("pwd");
 451                 user.setLoginId("Test");
 452                 List<EPUser> expectedList = new ArrayList<EPUser>();
 453                 expectedList.add(user);
 454                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 455                 Mockito.when(userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 456                 //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 457                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 458
 459
 460                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 461                 expectedFieldValidator.setHttpStatusCode((long) 200);
 462                 expectedFieldValidator.setFields(null);
 463                 expectedFieldValidator.setErrorCode(null);
 464                 Mockito.when(appService.modifyOnboardingApp(oldOnboardApp, user)).thenReturn(expectedFieldValidator);
 465                 //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 466
 467                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 468                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 469                 }
 470
 471
 472         @Test
 473         public void putOnboardAppExternalTest() throws Exception {
 474
 475                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 476                 expectedportalRestResponse.setMessage("FieldsValidator [httpStatusCode=500, errorCode=null, fields=null]");
 477                 expectedportalRestResponse.setResponse(null);
 478                 PortalRestStatusEnum portalRestStatusEnum = null;
 479                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 480
 481                 Long appId = (long) 1;
 482
 483                 OnboardingApp oldOnboardApp = new OnboardingApp();
 484                 oldOnboardApp.id = (long) 1;
 485                 oldOnboardApp.name = "test";
 486                 oldOnboardApp.url="test.com";
 487                 oldOnboardApp.restUrl="test1.com";
 488                 oldOnboardApp.myLoginsAppOwner="12";
 489                 oldOnboardApp.restrictedApp=false;
 490                 oldOnboardApp.isOpen=true;
 491                 oldOnboardApp.isEnabled=true;
 492
 493
 494                 EPUser user = mockUser.mockEPUser();
 495                 user.setEmail("guestT@test.portal.onap.org");
 496                 user.setLoginPwd("pwd");
 497                 user.setLoginId("Test");
 498                 List<EPUser> expectedList = new ArrayList<EPUser>();
 499                 expectedList.add(user);
 500                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 501                 Mockito.when(userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 502                 //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 503                 Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 504
 505
 506                 FieldsValidator expectedFieldValidator = new FieldsValidator();
 507                 expectedFieldValidator.setHttpStatusCode((long) 500);
 508                 expectedFieldValidator.setFields(null);
 509                 expectedFieldValidator.setErrorCode(null);
 510                 Mockito.when(appService.modifyOnboardingApp(oldOnboardApp, user)).thenReturn(expectedFieldValidator);
 511                 //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 512
 513                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 514                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 515                 }
 516
 517         @Test
 518         public void putOnboardAppExternalIsNotSuperAdminTest() throws Exception {
 519
 520         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 521         expectedportalRestResponse.setMessage("User lacks Portal admin role: Test");
 522         expectedportalRestResponse.setResponse(null);
 523         PortalRestStatusEnum portalRestStatusEnum = null;
 524         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 525
 526         Long appId = (long) 1;
 527
 528         OnboardingApp oldOnboardApp = new OnboardingApp();
 529         oldOnboardApp.id = (long) 1;
 530         oldOnboardApp.name = "test";
 531         oldOnboardApp.url="test.com";
 532         oldOnboardApp.restUrl="test1.com";
 533         oldOnboardApp.myLoginsAppOwner="12";
 534         oldOnboardApp.restrictedApp=false;
 535         oldOnboardApp.isOpen=true;
 536         oldOnboardApp.isEnabled=true;
 537
 538
 539         EPUser user = mockUser.mockEPUser();
 540         user.setEmail("guestT@test.portal.onap.org");
 541         user.setLoginPwd("pwd");
 542         user.setLoginId("Test");
 543         List<EPUser> expectedList = new ArrayList<EPUser>();
 544         expectedList.add(user);
 545         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 546         Mockito.when(userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 547         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 548         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 549
 550         FieldsValidator expectedFieldValidator = new FieldsValidator();
 551         expectedFieldValidator.setHttpStatusCode((long) 200);
 552         expectedFieldValidator.setFields(null);
 553         expectedFieldValidator.setErrorCode(null);
 554         //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 555
 556         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.putOnboardAppExternal(mockedRequest, mockedResponse, appId, oldOnboardApp);
 557         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 558         }
 559
 560         @Test
 561         public void putOnboardAppExternalWithExceptionTest() {
 562                 PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 563                 expectedportalRestResponse.setMessage("java.lang.NullPointerException");
 564                 expectedportalRestResponse.setResponse(null);
 565                 PortalRestStatusEnum portalRestStatusEnum = null;
 566                 expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 567                 EPUser user = mockUser.mockEPUser();
 568                 user.setEmail("guestT@test.portal.onap.org");
 569                 user.setLoginPwd("pwd");
 570                 user.setLoginId("Test");
 571                 Long appId = (long) 1;
 572
 573                 OnboardingApp oldOnboardApp = new OnboardingApp();
 574                 oldOnboardApp.id = (long) 1;
 575                 oldOnboardApp.name = "test";
 576                 oldOnboardApp.url="test.com";
 577                 oldOnboardApp.restUrl="test1.com";
 578                 oldOnboardApp.myLoginsAppOwner="12";
 579                 oldOnboardApp.restrictedApp=false;
 580                 oldOnboardApp.isOpen=true;
 581                 oldOnboardApp.isEnabled=true;
 582                 Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 583                 Mockito.when(userService.getUserByUserId(oldOnboardApp.myLoginsAppOwner)).thenThrow(nullPointerException);
 584                 PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest
 585                                 .putOnboardAppExternal(mockedRequest, mockedResponse, appId,oldOnboardApp);
 586                 assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 587         }
 588
 589         @Test
 590         public void postOnboardAppExternalwithExceptionTest() throws Exception {
 591
 592         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 593         expectedportalRestResponse.setMessage("User lacks Portal admin role: Test");
 594         expectedportalRestResponse.setResponse(null);
 595         PortalRestStatusEnum portalRestStatusEnum = null;
 596         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 597
 598         Long appId = (long) 1;
 599
 600
 601
 602         OnboardingApp newOnboardApp = new OnboardingApp();
 603         //newOnboardApp.id = (long) 1;
 604         newOnboardApp.name = "test";
 605         newOnboardApp.url="test.com";
 606         newOnboardApp.restUrl="test1.com";
 607         newOnboardApp.myLoginsAppOwner="12";
 608         newOnboardApp.restrictedApp=false;
 609         newOnboardApp.isOpen=true;
 610         newOnboardApp.isEnabled=true;
 611
 612
 613         EPUser user = mockUser.mockEPUser();
 614         user.setEmail("guestT@test.portal.onap.org");
 615         user.setLoginPwd("pwd");
 616         user.setLoginId("Test");
 617         List<EPUser> expectedList = new ArrayList<EPUser>();
 618         expectedList.add(user);
 619         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 620         Mockito.when(userService.getUserByUserId(newOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 621         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 622         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(false);
 623
 624         FieldsValidator expectedFieldValidator = new FieldsValidator();
 625         expectedFieldValidator.setHttpStatusCode((long) 200);
 626         expectedFieldValidator.setFields(null);
 627         expectedFieldValidator.setErrorCode(null);
 628         //Mockito.when(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 629
 630         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 631         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 632         }
 633
 634         @Test
 635         public void postOnboardAppExternalIsNotSuperAdminTest() throws Exception {
 636
 637         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 638         expectedportalRestResponse.setMessage("java.lang.NullPointerException");
 639         expectedportalRestResponse.setResponse(null);
 640         PortalRestStatusEnum portalRestStatusEnum = null;
 641         expectedportalRestResponse.setStatus(portalRestStatusEnum.ERROR);
 642
 643         Long appId = (long) 1;
 644
 645
 646
 647         OnboardingApp newOnboardApp = new OnboardingApp();
 648         //newOnboardApp.id = (long) 1;
 649         newOnboardApp.name = "test";
 650         newOnboardApp.url="test.com";
 651         newOnboardApp.restUrl="test1.com";
 652         newOnboardApp.myLoginsAppOwner="12";
 653         newOnboardApp.restrictedApp=false;
 654         newOnboardApp.isOpen=true;
 655         newOnboardApp.isEnabled=true;
 656
 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.myLoginsAppOwner)).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(portalAdminService.createPortalAdmin(user.getOrgUserId())).thenReturn(expectedFieldValidator);
 674
 675         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 676         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 677         }
 678
 679         @Test
 680         public void postOnboardAppExternalIsSuperAdminTest() throws Exception {
 681
 682         PortalRestResponse<String> expectedportalRestResponse = new PortalRestResponse<String>();
 683         expectedportalRestResponse.setMessage(null);
 684         expectedportalRestResponse.setResponse(null);
 685         PortalRestStatusEnum portalRestStatusEnum = null;
 686         expectedportalRestResponse.setStatus(portalRestStatusEnum.OK);
 687
 688         Long appId = (long) 1;
 689
 690
 691
 692         OnboardingApp newOnboardApp = new OnboardingApp();
 693         //newOnboardApp.id = (long) 1;
 694         newOnboardApp.name = "test";
 695         newOnboardApp.url="test.com";
 696         newOnboardApp.restUrl="test1.com";
 697         newOnboardApp.myLoginsAppOwner="12";
 698         newOnboardApp.restrictedApp=false;
 699         newOnboardApp.isOpen=true;
 700         newOnboardApp.isEnabled=true;
 701
 702
 703         EPUser user = mockUser.mockEPUser();
 704         user.setEmail("guestT@test.portal.onap.org");
 705         user.setLoginPwd("pwd");
 706         user.setLoginId("Test");
 707         List<EPUser> expectedList = new ArrayList<EPUser>();
 708         expectedList.add(user);
 709         Mockito.when(EPUserUtils.getUserSession(mockedRequest)).thenReturn(user);
 710         Mockito.when(userService.getUserByUserId(newOnboardApp.myLoginsAppOwner)).thenReturn(expectedList);
 711         //Mockito.when(userService.saveNewUser(user, "Yes")).thenReturn(null);
 712         Mockito.when(adminRolesService.isSuperAdmin(user)).thenReturn(true);
 713
 714         FieldsValidator expectedFieldValidator = new FieldsValidator();
 715         expectedFieldValidator.setHttpStatusCode((long) 200);
 716         expectedFieldValidator.setFields(null);
 717         expectedFieldValidator.setErrorCode(null);
 718         Mockito.when(appService.addOnboardingApp(newOnboardApp, user)).thenReturn(expectedFieldValidator);
 719
 720         PortalRestResponse<String> actualPortalRestResponse = appsControllerExternalRequest.postOnboardAppExternal(mockedRequest, mockedResponse,newOnboardApp);
 721         assertEquals(actualPortalRestResponse, expectedportalRestResponse);
 722         }
 723
 724 }