gerrit.onap Code Review - so.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 Huawei Technologies Co., Ltd. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.mso.apihandlerinfra;
  22
  23 import static org.junit.Assert.*;
  24
  25 import java.io.ByteArrayInputStream;
  26 import java.io.IOException;
  27 import java.io.InputStream;
  28 import java.util.HashMap;
  29
  30 import javax.ws.rs.core.Response;
  31
  32 import org.apache.http.HttpResponse;
  33 import org.apache.http.ProtocolVersion;
  34 import org.apache.http.client.ClientProtocolException;
  35 import org.apache.http.entity.BasicHttpEntity;
  36 import org.apache.http.message.BasicHttpResponse;
  37 import org.hibernate.Session;
  38 import org.junit.BeforeClass;
  39 import org.junit.Test;
  40 import org.openecomp.mso.apihandler.common.CamundaClient;
  41 import org.openecomp.mso.apihandler.common.RequestClient;
  42 import org.openecomp.mso.apihandler.common.RequestClientFactory;
  43 import org.openecomp.mso.apihandler.common.ValidationException;
  44 import org.openecomp.mso.db.AbstractSessionFactoryManager;
  45 import org.openecomp.mso.db.catalog.CatalogDatabase;
  46 import org.openecomp.mso.db.catalog.beans.Service;
  47 import org.openecomp.mso.db.catalog.beans.ServiceRecipe;
  48 import org.openecomp.mso.properties.MsoDatabaseException;
  49 import org.openecomp.mso.properties.MsoJavaProperties;
  50 import org.openecomp.mso.properties.MsoPropertiesFactory;
  51 import org.openecomp.mso.requestsdb.OperationStatus;
  52 import org.openecomp.mso.requestsdb.RequestsDatabase;
  53 import org.openecomp.mso.serviceinstancebeans.ServiceInstancesRequest;
  54
  55 import mockit.Expectations;
  56 import mockit.Mock;
  57 import mockit.MockUp;
  58 import mockit.Mocked;
  59
  60 public class E2EServiceInstancesTest {
  61
  62     private final String compareModelsRequest = "{" +
  63             "\"globalSubscriberId\": \"60c3e96e-0970-4871-b6e0-3b6de7561519\"," +
  64             "\"serviceType\": \"vnf\"," +
  65             "\"modelInvariantIdTarget\": \"60c3e96e-0970-4871-b6e0-3b6de1234567\"," +
  66             "\"modelVersionIdTarget\": \"modelVersionIdTarget\"" +
  67             "}";
  68
  69     private final String scaleRequest = "{\"service\":{\"serviceType\":\"example-service-type\",\"globalSubscriberId\":\"test_custormer\",\"resources\":[{\"resourceInstanceId\":\"ns111\",\"scaleType\":\"SCALE_NS\",\"scaleNsData\":{\"scaleNsByStepsData\":{\"numberOfSteps\":\"4\",\"aspectId\":\"TIC_EDGE_HW\",\"scalingDirection\":\"UP\"}}}],\"serviceInstanceName\":\"XXXX\"}}";
  70
  71         String jsonBody = "{" +
  72                         "\"service\": {" +
  73                         "\"name\": \"so_test4\"," +
  74                         "\"description\": \"so_test2\"," +
  75                         "\"serviceInvariantUuid\": \"60c3e96e-0970-4871-b6e0-3b6de7561519\"," +
  76                         "\"serviceUuid\": \"592f9437-a9c0-4303-b9f6-c445bb7e9814\"," +
  77                         "\"globalSubscriberId\": \"123457\"," +
  78                         "\"serviceType\": \"voLTE\"," +
  79                         "\"parameters\": {" +
  80                         "\"resources\": [" +
  81                         "{" +
  82                         "\"resourceName\": \"vIMS\"," +
  83                         "\"resourceInvariantUuid\": \"60c3e96e-0970-4871-b6e0-3b6de7561516\"," +
  84                         "\"resourceUuid\": \"60c3e96e-0970-4871-b6e0-3b6de7561512\"," +
  85                         "\"parameters\": {" +
  86                         "\"locationConstraints\": [" +
  87                         "{" +
  88                         "\"vnfProfileId\": \"zte-vBAS-1.0\"," +
  89                         "\"locationConstraints\": {" +
  90                         "\"vimId\": \"4050083f-465f-4838-af1e-47a545222ad0\"" +
  91                         "}" +
  92                         "}," +
  93                         "{" +
  94                         "\"vnfProfileId\": \"zte-vMME-1.0\"," +
  95                         "\"locationConstraints\": {" +
  96                         "\"vimId\": \"4050083f-465f-4838-af1e-47a545222ad0\"" +
  97                         "}" +
  98                         "}" +
  99                         "]" +
 100                         "}" +
 101                         "}," +
 102                         "{" +
 103                         "\"resourceName\": \"vEPC\"," +
 104                         "\"resourceInvariantUuid\": \"61c3e96e-0970-4871-b6e0-3b6de7561516\"," +
 105                         "\"resourceUuid\": \"62c3e96e-0970-4871-b6e0-3b6de7561512\"," +
 106                         "\"parameters\": {" +
 107                         "\"locationConstraints\": [" +
 108                         "{" +
 109                         "\"vnfProfileId\": \"zte-CSCF-1.0\"," +
 110                         "\"locationConstraints\": {" +
 111                         "\"vimId\": \"4050083f-465f-4838-af1e-47a545222ad1\"" +
 112                         "}" +
 113                         "}" +
 114                         "]" +
 115                         "}" +
 116                         "}," +
 117                         "{" +
 118                         "\"resourceName\": \"underlayvpn\"," +
 119                         "\"resourceInvariantUuid\": \"60c3e96e-0970-4871-b6e0-3b6de7561513\"," +
 120                         "\"resourceUuid\": \"60c3e96e-0970-4871-b6e0-3b6de7561514\"," +
 121                         "\"parameters\": {" +
 122                         "\"locationConstraints\": []" +
 123                         "}" +
 124                         "}," +
 125                         "{" +
 126                         "\"resourceName\": \"overlayvpn\"," +
 127                         "\"resourceInvariantUuid\": \"60c3e96e-0970-4871-b6e0-3b6de7561517\"," +
 128                         "\"resourceUuid\": \"60c3e96e-0970-4871-b6e0-3b6de7561518\"," +
 129                         "\"parameters\": {" +
 130                         "\"locationConstraints\": []" +
 131                         "}" +
 132                         "}" +
 133                         "]," +
 134                         "\"requestInputs\": {" +
 135                         "\"externalDataNetworkName\": \"Flow_out_net\"," +
 136                         "\"m6000_mng_ip\": \"181.18.20.2\"," +
 137                         "\"externalCompanyFtpDataNetworkName\": \"Flow_out_net\"," +
 138                         "\"externalPluginManageNetworkName\": \"plugin_net_2014\"," +
 139                         "\"externalManageNetworkName\": \"mng_net_2017\"," +
 140                         "\"sfc_data_network\": \"sfc_data_net_2016\"," +
 141                         "\"NatIpRange\": \"210.1.1.10-210.1.1.20\"," +
 142                         "\"location\": \"4050083f-465f-4838-af1e-47a545222ad0\"," +
 143                         "\"sdncontroller\": \"9b9f02c0-298b-458a-bc9c-be3692e4f35e\"" +
 144                         "}" +
 145                         "}" +
 146                         "}" +
 147                         "}";
 148
 149     @BeforeClass
 150     public static void setUp() throws Exception {
 151
 152         MsoPropertiesFactory msoPropertiesFactory = new MsoPropertiesFactory();
 153         msoPropertiesFactory.removeAllMsoProperties();
 154         msoPropertiesFactory.initializeMsoProperties(Constants.MSO_PROP_APIHANDLER_INFRA, "src/test/resources/mso.apihandler-infra.properties");
 155     }
 156
 157         @Test
 158         public void createE2EServiceInstanceTestSuccess() {
 159                 new MockUp<RequestsDatabase>() {
 160                         @Mock
 161                         public OperationStatus getOperationStatusByServiceName(
 162                                         String serviceName) {
 163                                 OperationStatus operationStatus = new OperationStatus();
 164                                 return operationStatus;
 165                         }
 166                 };
 167
 168                 new MockUp<CatalogDatabase>() {
 169                         @Mock
 170                         public Service getServiceByModelName(String modelName) {
 171                                 Service svc = new Service();
 172                                 return svc;
 173                         }
 174                 };
 175
 176                 new MockUp<CatalogDatabase>() {
 177                         @Mock
 178                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 179                                         String action) {
 180                                 ServiceRecipe rec = new ServiceRecipe();
 181                                 return rec;
 182                         }
 183                 };
 184
 185                 new MockUp<RequestClientFactory>() {
 186                         @Mock
 187                         public RequestClient getRequestClient(String orchestrationURI,
 188                                         MsoJavaProperties props) throws IllegalStateException {
 189                                 RequestClient client = new CamundaClient();
 190                                 client.setUrl("/test/url");
 191                                 return client;
 192                         }
 193                 };
 194
 195                 new MockUp<CamundaClient>() {
 196                         @Mock
 197                         public HttpResponse post(String requestId, boolean isBaseVfModule,
 198                                         int recipeTimeout, String requestAction,
 199                                         String serviceInstanceId, String vnfId, String vfModuleId,
 200                                         String volumeGroupId, String networkId, String configurationId, String serviceType,
 201                                         String vnfType, String vfModuleType, String networkType,
 202                                         String requestDetails, String recipeParamXsd) {
 203                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 204                                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 205                                                 "test response");
 206                                 BasicHttpEntity entity = new BasicHttpEntity();
 207                                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
 208                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 209                                 entity.setContent(instream);
 210                                 resp.setEntity(entity);
 211                                 return resp;
 212                         }
 213                 };
 214
 215                 E2EServiceInstances instance = new E2EServiceInstances();
 216                 String request = jsonBody;
 217                 Response resp = instance.createE2EServiceInstance(request, "v3");
 218                 String respStr = resp.getEntity().toString();
 219                 assertTrue(respStr.contains("success"));
 220         }
 221
 222         @Test
 223         public void createE2EServiceInstanceTestBpelHTTPException() {
 224                 new MockUp<RequestsDatabase>() {
 225                         @Mock
 226                         public OperationStatus getOperationStatusByServiceName(
 227                                         String serviceName) {
 228                                 OperationStatus operationStatus = new OperationStatus();
 229                                 return operationStatus;
 230                         }
 231                 };
 232                 new MockUp<CatalogDatabase>() {
 233                         @Mock
 234                         public Service getServiceByModelName(String modelName) {
 235                                 Service svc = new Service();
 236                                 return svc;
 237                         }
 238                 };
 239
 240                 new MockUp<CatalogDatabase>() {
 241                         @Mock
 242                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 243                                         String action) {
 244                                 ServiceRecipe rec = new ServiceRecipe();
 245                                 return rec;
 246                         }
 247                 };
 248
 249                 new MockUp<RequestClientFactory>() {
 250                         @Mock
 251                         public RequestClient getRequestClient(String orchestrationURI,
 252                                         MsoJavaProperties props) throws IllegalStateException {
 253                                 RequestClient client = new CamundaClient();
 254                                 client.setUrl("/test/url");
 255                                 return client;
 256                         }
 257                 };
 258
 259                 new MockUp<CamundaClient>() {
 260                         @Mock
 261                         public HttpResponse post(String requestId, boolean isBaseVfModule,
 262                                         int recipeTimeout, String requestAction,
 263                                         String serviceInstanceId, String vnfId, String vfModuleId,
 264                                         String volumeGroupId, String networkId, String configurationId, String serviceType,
 265                                         String vnfType, String vfModuleType, String networkType,
 266                                         String requestDetails, String recipeParamXsd) {
 267                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 268                                 HttpResponse resp = new BasicHttpResponse(pv, 500,
 269                                                 "test response");
 270                                 BasicHttpEntity entity = new BasicHttpEntity();
 271                                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
 272                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 273                                 entity.setContent(instream);
 274                                 resp.setEntity(entity);
 275                                 return resp;
 276                         }
 277                 };
 278
 279                 E2EServiceInstances instance = new E2EServiceInstances();
 280                 String request = jsonBody;
 281                 Response resp = instance.createE2EServiceInstance(request, "v3");
 282                 String respStr = resp.getEntity().toString();
 283                 assertTrue(respStr.contains("SVC2000"));
 284         }
 285
 286         @Test
 287         public void createE2EServiceInstanceTestBpelHTTPExceptionWithNullREsponseBody() {
 288                 new MockUp<RequestsDatabase>() {
 289                         @Mock
 290                         public OperationStatus getOperationStatusByServiceName(
 291                                         String serviceName) {
 292                                 OperationStatus operationStatus = new OperationStatus();
 293                                 return operationStatus;
 294                         }
 295                 };
 296
 297                 new MockUp<CatalogDatabase>() {
 298                         @Mock
 299                         public Service getServiceByModelName(String modelName) {
 300                                 Service svc = new Service();
 301                                 return svc;
 302                         }
 303                 };
 304
 305                 new MockUp<CatalogDatabase>() {
 306                         @Mock
 307                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 308                                         String action) {
 309                                 ServiceRecipe rec = new ServiceRecipe();
 310                                 return rec;
 311                         }
 312                 };
 313
 314                 new MockUp<RequestClientFactory>() {
 315                         @Mock
 316                         public RequestClient getRequestClient(String orchestrationURI,
 317                                         MsoJavaProperties props) throws IllegalStateException {
 318                                 RequestClient client = new CamundaClient();
 319                                 client.setUrl("/test/url");
 320                                 return client;
 321                         }
 322                 };
 323
 324                 new MockUp<CamundaClient>() {
 325                         @Mock
 326                         public HttpResponse post(String requestId, boolean isBaseVfModule,
 327                                         int recipeTimeout, String requestAction,
 328                                         String serviceInstanceId, String vnfId, String vfModuleId,
 329                                         String volumeGroupId, String networkId, String configurationId, String serviceType,
 330                                         String vnfType, String vfModuleType, String networkType,
 331                                         String requestDetails, String recipeParamXsd) {
 332                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 333                                 HttpResponse resp = new BasicHttpResponse(pv, 500,
 334                                                 "test response");
 335                                 BasicHttpEntity entity = new BasicHttpEntity();
 336                                 String body = "{\"response\":\"\",\"message\":\"success\"}";
 337                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 338                                 entity.setContent(instream);
 339                                 resp.setEntity(entity);
 340                                 return resp;
 341                         }
 342                 };
 343
 344                 E2EServiceInstances instance = new E2EServiceInstances();
 345                 String request = jsonBody;
 346                 Response resp = instance.createE2EServiceInstance(request, "v3");
 347                 String respStr = resp.getEntity().toString();
 348                 assertTrue(respStr.contains("SVC2000"));
 349         }
 350
 351         @Test
 352         public void createE2EServiceInstanceTestNullBPELResponse() {
 353                 new MockUp<RequestsDatabase>() {
 354                         @Mock
 355                         public OperationStatus getOperationStatusByServiceName(
 356                                         String serviceName) {
 357                                 OperationStatus operationStatus = new OperationStatus();
 358                                 return operationStatus;
 359                         }
 360                 };
 361
 362                 new MockUp<CatalogDatabase>() {
 363                         @Mock
 364                         public Service getServiceByModelName(String modelName) {
 365                                 Service svc = new Service();
 366                                 return svc;
 367                         }
 368                 };
 369
 370                 new MockUp<CatalogDatabase>() {
 371                         @Mock
 372                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 373                                         String action) {
 374                                 ServiceRecipe rec = new ServiceRecipe();
 375                                 return rec;
 376                         }
 377                 };
 378
 379                 new MockUp<RequestClientFactory>() {
 380                         @Mock
 381                         public RequestClient getRequestClient(String orchestrationURI,
 382                                         MsoJavaProperties props) throws IllegalStateException {
 383                                 RequestClient client = new CamundaClient();
 384                                 client.setUrl("/test/url");
 385                                 return client;
 386                         }
 387                 };
 388
 389                 new MockUp<CamundaClient>() {
 390                         @Mock
 391                         public HttpResponse post(String requestId, boolean isBaseVfModule,
 392                                         int recipeTimeout, String requestAction,
 393                                         String serviceInstanceId, String vnfId, String vfModuleId,
 394                                         String volumeGroupId, String networkId, String configurationId, String serviceType,
 395                                         String vnfType, String vfModuleType, String networkType,
 396                                         String requestDetails, String recipeParamXsd) {
 397                                 HttpResponse resp = null;
 398                                 return resp;
 399                         }
 400                 };
 401
 402                 E2EServiceInstances instance = new E2EServiceInstances();
 403                 String request = jsonBody;
 404                 Response resp = instance.createE2EServiceInstance(request, "v3");
 405                 String respStr = resp.getEntity().toString();
 406                 assertTrue(respStr.contains("serviceException"));
 407         }
 408
 409         @Test
 410         public void createE2EServiceInstanceTestBPMNNullREsponse() {
 411                 new MockUp<RequestsDatabase>() {
 412                         @Mock
 413                         public OperationStatus getOperationStatusByServiceName(
 414                                         String serviceName) {
 415                                 OperationStatus operationStatus = new OperationStatus();
 416                                 return operationStatus;
 417                         }
 418                 };
 419
 420                 new MockUp<CatalogDatabase>() {
 421                         @Mock
 422                         public Service getServiceByModelName(String modelName) {
 423                                 Service svc = new Service();
 424                                 return svc;
 425                         }
 426                 };
 427
 428                 new MockUp<CatalogDatabase>() {
 429                         @Mock
 430                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 431                                         String action) {
 432                                 ServiceRecipe rec = new ServiceRecipe();
 433                                 return rec;
 434                         }
 435                 };
 436
 437                 new MockUp<RequestClientFactory>() {
 438                         @Mock
 439                         public RequestClient getRequestClient(String orchestrationURI,
 440                                         MsoJavaProperties props) throws IllegalStateException {
 441                                 RequestClient client = new CamundaClient();
 442                                 client.setUrl("/test/url");
 443                                 return client;
 444                         }
 445                 };
 446
 447                 new MockUp<CamundaClient>() {
 448                         @Mock
 449                         public HttpResponse post(String camundaReqXML, String requestId,
 450                                         String requestTimeout, String schemaVersion,
 451                                         String serviceInstanceId, String action) {
 452                                 HttpResponse resp = null;
 453                                 return resp;
 454                         }
 455                 };
 456                 E2EServiceInstances instance = new E2EServiceInstances();
 457                 String request = jsonBody;
 458                 Response resp = instance.createE2EServiceInstance(request, "v3");
 459                 String respStr = resp.getEntity().toString();
 460                 assertTrue(respStr.contains("serviceException"));
 461         }
 462
 463         @Test
 464         public void createE2EServiceInstanceTestNullBpmn() {
 465                 new MockUp<RequestsDatabase>() {
 466                         @Mock
 467                         public OperationStatus getOperationStatusByServiceName(
 468                                         String serviceName) {
 469                                 OperationStatus operationStatus = new OperationStatus();
 470                                 return operationStatus;
 471                         }
 472                 };
 473
 474
 475                 new MockUp<CatalogDatabase>() {
 476                         @Mock
 477                         public Service getServiceByModelName(String modelName) {
 478                                 Service svc = new Service();
 479                                 return svc;
 480                         }
 481                 };
 482
 483                 new MockUp<CatalogDatabase>() {
 484                         @Mock
 485                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 486                                         String action) {
 487                                 ServiceRecipe rec = new ServiceRecipe();
 488                                 return rec;
 489                         }
 490                 };
 491                 E2EServiceInstances instance = new E2EServiceInstances();
 492         String request = jsonBody;
 493         ;
 494                 Response resp = instance.createE2EServiceInstance(request, "v3");
 495                 String respStr = resp.getEntity().toString();
 496                 assertTrue(respStr.contains("serviceException"));
 497         }
 498
 499         @Test
 500         public void createE2EServiceInstanceTestNullReceipe() {
 501                 new MockUp<RequestsDatabase>() {
 502                         @Mock
 503                         public OperationStatus getOperationStatusByServiceName(
 504                                         String serviceName) {
 505                                 OperationStatus operationStatus = new OperationStatus();
 506                                 return operationStatus;
 507                         }
 508                 };
 509
 510                 E2EServiceInstances instance = new E2EServiceInstances();
 511                 String request = jsonBody;
 512                 Response resp = instance.createE2EServiceInstance(request, "v3");
 513                 String respStr = resp.getEntity().toString();
 514                 assertTrue(respStr.contains("serviceException"));
 515         }
 516
 517         @Test
 518         public void createE2EServiceInstanceTestNullDBResponse() {
 519
 520                 new MockUp<RequestsDatabase>() {
 521                         @Mock
 522                         public OperationStatus getOperationStatusByServiceName(
 523                                         String serviceName) {
 524                                 OperationStatus operationStatus = new OperationStatus();
 525                                 return operationStatus;
 526                         }
 527                 };
 528
 529
 530                 E2EServiceInstances instance = new E2EServiceInstances();
 531                 String request = jsonBody;
 532                 Response resp = instance.createE2EServiceInstance(request, "v3");
 533                 String respStr = resp.getEntity().toString();
 534                 assertTrue(respStr.contains("serviceException"));
 535         }
 536
 537         @Test
 538         public void createE2EServiceInstanceTestInvalidRequest() {
 539                 new MockUp<RequestsDatabase>() {
 540                         @Mock
 541                         public OperationStatus getOperationStatusByServiceName(
 542                                         String serviceName) {
 543                                 OperationStatus operationStatus = new OperationStatus();
 544                                 return operationStatus;
 545                         }
 546                 };
 547
 548
 549                 E2EServiceInstances instance = new E2EServiceInstances();
 550                 String request = jsonBody;
 551                 Response resp = instance.createE2EServiceInstance(request, "v3");
 552                 String respStr = resp.getEntity().toString();
 553                 assertTrue(respStr.contains("serviceException"));
 554         }
 555
 556         @Test
 557         public void createE2EServiceInstanceTestEmptyDBQuery() {
 558
 559
 560                 E2EServiceInstances instance = new E2EServiceInstances();
 561                 String request = jsonBody;
 562                 Response resp = instance.createE2EServiceInstance(request, "v3");
 563                 String respStr = resp.getEntity().toString();
 564                 assertTrue(respStr.contains("serviceException"));
 565                 // assertTrue(true);
 566         }
 567
 568         @Test
 569         public void createE2EServiceInstanceTestDBQueryFail() {
 570                 new MockUp<RequestsDatabase>() {
 571                         @Mock
 572                         public OperationStatus getOperationStatusByServiceName(
 573                                         String serviceName) {
 574                                 OperationStatus operationStatus = new OperationStatus();
 575                                 return operationStatus;
 576                         }
 577                 };
 578
 579
 580                 E2EServiceInstances instance = new E2EServiceInstances();
 581                 String request = jsonBody;
 582                 Response resp = instance.createE2EServiceInstance(request, "v3");
 583                 String respStr = resp.getEntity().toString();
 584                 assertTrue(respStr.contains("serviceException"));
 585         }
 586
 587         @Test
 588         public void createE2EServiceInstanceTestForEmptyRequest() {
 589
 590
 591                 E2EServiceInstances instance = new E2EServiceInstances();
 592                 String request = "";
 593                 Response resp = instance.createE2EServiceInstance(request, "v3");
 594                 String respStr = resp.getEntity().toString();
 595                 assertTrue(respStr
 596             .contains("Mapping of request to JSON object failed.  No content to map due to end-of-input"));
 597         }
 598
 599         @Test
 600         public void deleteE2EServiceInstanceTestNormal() {
 601
 602         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
 603             @Mock
 604             public Service getServiceByModelName(String modelName) {
 605                 Service svc = new Service();
 606                 return svc;
 607             }
 608
 609             @Mock
 610             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 611                                                              String action) {
 612                 ServiceRecipe rec = new ServiceRecipe();
 613                 rec.setOrchestrationUri("/test/delE2E");
 614                 rec.setRecipeTimeout(180);
 615                 return rec;
 616             }
 617         };
 618
 619         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
 620             @Mock
 621             public void createRequestRecord(Status status, Action action) {
 622                 return;
 623             }
 624         };
 625
 626         final MockUp<CamundaClient> mockCmaundaClient = new MockUp<CamundaClient>() {
 627             @Mock
 628             public HttpResponse post(String requestId, boolean isBaseVfModule,
 629                                      int recipeTimeout, String requestAction, String serviceInstanceId,
 630                                      String vnfId, String vfModuleId, String volumeGroupId, String networkId, String configurationId,
 631                                      String serviceType, String vnfType, String vfModuleType, String networkType,
 632                                      String requestDetails, String recipeParamXsd)
 633                     throws ClientProtocolException, IOException {
 634                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 635                 HttpResponse resp = new BasicHttpResponse(pv, 200, "test response");
 636                 BasicHttpEntity entity = new BasicHttpEntity();
 637                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
 638                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 639                 entity.setContent(instream);
 640                 resp.setEntity(entity);
 641                 return resp;
 642             }
 643         };
 644
 645
 646                 E2EServiceInstances instance = new E2EServiceInstances();
 647                 String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 648
 649         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 650         mockCDB.tearDown();
 651         mockMsoRequest.tearDown();
 652         mockCmaundaClient.tearDown();
 653
 654     }
 655
 656     @Test
 657     public void deleteE2EServiceInstanceTestFail() {
 658         E2EServiceInstances instance = new E2EServiceInstances();
 659         String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 660         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 661     }
 662
 663     @Test
 664     public void deleteE2EServiceInstanceTestFailClient(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
 665                                                        @Mocked Session session) {
 666         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
 667             @Mock
 668             public Service getServiceByModelName(String modelName) {
 669                 Service svc = new Service();
 670                 return svc;
 671             }
 672
 673             @Mock
 674             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 675                                                              String action) {
 676                 ServiceRecipe rec = new ServiceRecipe();
 677                 rec.setOrchestrationUri("/test/delE2E");
 678                 rec.setRecipeTimeout(180);
 679                 return rec;
 680             }
 681         };
 682
 683         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
 684             @Mock
 685             public void createRequestRecord(Status status, Action action) {
 686                 return;
 687             }
 688         };
 689
 690         E2EServiceInstances instance = new E2EServiceInstances();
 691         String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 692
 693         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 694         mockCDB.tearDown();
 695         mockMsoRequest.tearDown();
 696
 697     }
 698
 699     @Test
 700     public void deleteE2EServiceInstanceTestFailRecipe(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
 701                                                        @Mocked Session session) {
 702         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
 703             @Mock
 704             public Service getServiceByModelName(String modelName) {
 705                 Service svc = new Service();
 706                 return svc;
 707             }
 708
 709             @Mock
 710             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 711                                                              String action) {
 712                 ServiceRecipe rec = new ServiceRecipe();
 713                 return rec;
 714             }
 715         };
 716
 717         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
 718             @Mock
 719             public void createRequestRecord(Status status, Action action) {
 720                 return;
 721             }
 722         };
 723
 724         E2EServiceInstances instance = new E2EServiceInstances();
 725         String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 726
 727         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 728         mockCDB.tearDown();
 729         mockMsoRequest.tearDown();
 730
 731     }
 732
 733     @Test
 734     public void deleteE2EServiceInstanceTestFailModelName(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
 735                                                           @Mocked Session session) {
 736         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
 737             @Mock
 738             public void createRequestRecord(Status status, Action action) {
 739                 return;
 740             }
 741         };
 742
 743         new Expectations() {{
 744             sessionFactoryManager.getSessionFactory().openSession();
 745             result = session;
 746         }};
 747
 748         E2EServiceInstances instance = new E2EServiceInstances();
 749         String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 750
 751         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 752         mockMsoRequest.tearDown();
 753
 754         }
 755
 756         @Test
 757         public void getE2EServiceInstanceTest() {
 758
 759                 new MockUp<RequestsDatabase>() {
 760                         @Mock
 761                         public OperationStatus getOperationStatus(String serviceId,
 762                                         String operationId) {
 763                                 OperationStatus os = new OperationStatus();
 764                                 os.setOperation("");
 765                                 os.setOperationContent("");
 766                                 os.setOperationId("123456");
 767                                 os.setProgress("");
 768                                 os.setServiceId("12345");
 769                                 os.setServiceName("VoLTE");
 770                                 os.setReason("");
 771                                 os.setResult("");
 772                                 os.setUserId("");
 773                                 return os;
 774                         }
 775                 };
 776
 777                 E2EServiceInstances instance = new E2EServiceInstances();
 778                 Response resp = instance
 779                                 .getE2EServiceInstances("12345", "v3", "123456");
 780
 781         }
 782
 783         @Test
 784         public void updateE2EServiceInstanceTestNormal() {
 785                 new MockUp<RequestsDatabase>() {
 786                         @Mock
 787                         public OperationStatus getOperationStatusByServiceId(
 788                                         String serviceID) {
 789                                 OperationStatus operationStatus = new OperationStatus();
 790                                 operationStatus.setProgress("100");
 791                                 operationStatus.setResult("finish");
 792                                 return operationStatus;
 793                         }
 794                 };
 795
 796                 new MockUp<CatalogDatabase>() {
 797                         @Mock
 798                         public Service getServiceByModelName(String modelName) {
 799                                 Service svc = new Service();
 800                                 return svc;
 801                         }
 802                 };
 803
 804                 new MockUp<CatalogDatabase>() {
 805                         @Mock
 806                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 807                                         String action) {
 808                                 ServiceRecipe rec = new ServiceRecipe();
 809                                 return rec;
 810                         }
 811                 };
 812
 813                 new MockUp<RequestClientFactory>() {
 814                         @Mock
 815                         public RequestClient getRequestClient(String orchestrationURI,
 816                                         MsoJavaProperties props) throws IllegalStateException {
 817                                 RequestClient client = new CamundaClient();
 818                                 client.setUrl("/test/url");
 819                                 return client;
 820                         }
 821                 };
 822
 823                 new MockUp<CamundaClient>() {
 824                         @Mock
 825                         public HttpResponse post(String requestId, boolean isBaseVfModule,
 826                                         int recipeTimeout, String requestAction,
 827                                         String serviceInstanceId, String vnfId, String vfModuleId,
 828                                         String volumeGroupId, String networkId, String configurationId, String serviceType,
 829                                         String vnfType, String vfModuleType, String networkType,
 830                                         String requestDetails, String recipeParamXsd) {
 831                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 832                                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 833                                                 "test response");
 834                                 BasicHttpEntity entity = new BasicHttpEntity();
 835                                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
 836                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 837                                 entity.setContent(instream);
 838                                 resp.setEntity(entity);
 839                                 return resp;
 840                         }
 841                 };
 842
 843                 E2EServiceInstances instance = new E2EServiceInstances();
 844                 String request = jsonBody;
 845                 Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
 846                 String respStr = resp.getEntity().toString();
 847                 assertTrue(respStr.contains("success"));
 848         }
 849
 850         @Test
 851         public void updateE2EServiceInstanceTestChkStatusFalse() {
 852                 new MockUp<RequestsDatabase>() {
 853                         @Mock
 854                         public OperationStatus getOperationStatusByServiceId(
 855                                         String serviceID) {
 856                                 OperationStatus operationStatus = new OperationStatus();
 857                                 operationStatus.setResult("processing");
 858                                 return operationStatus;
 859                         }
 860                 };
 861
 862                 new MockUp<CatalogDatabase>() {
 863                         @Mock
 864                         public Service getServiceByModelName(String modelName) {
 865                                 Service svc = new Service();
 866                                 return svc;
 867                         }
 868                 };
 869
 870                 new MockUp<CatalogDatabase>() {
 871                         @Mock
 872                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 873                                         String action) {
 874                                 ServiceRecipe rec = new ServiceRecipe();
 875                                 return rec;
 876                         }
 877                 };
 878
 879                 new MockUp<RequestClientFactory>() {
 880                         @Mock
 881                         public RequestClient getRequestClient(String orchestrationURI,
 882                                         MsoJavaProperties props) throws IllegalStateException {
 883                                 RequestClient client = new CamundaClient();
 884                                 client.setUrl("/test/url");
 885                                 return client;
 886                         }
 887                 };
 888
 889                 new MockUp<CamundaClient>() {
 890                         @Mock
 891                         public HttpResponse post(String requestId, boolean isBaseVfModule,
 892                                         int recipeTimeout, String requestAction,
 893                                         String serviceInstanceId, String vnfId, String vfModuleId,
 894                                         String volumeGroupId, String networkId, String configurationId, String serviceType,
 895                                         String vnfType, String vfModuleType, String networkType,
 896                                         String requestDetails, String recipeParamXsd) {
 897                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 898                                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 899                                                 "test response");
 900                                 BasicHttpEntity entity = new BasicHttpEntity();
 901                                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
 902                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 903                                 entity.setContent(instream);
 904                                 resp.setEntity(entity);
 905                                 return resp;
 906                         }
 907                 };
 908
 909                 E2EServiceInstances instance = new E2EServiceInstances();
 910                 String request = jsonBody;
 911                 Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
 912                 String respStr = resp.getEntity().toString();
 913                 assertTrue(!respStr.contains("SVC2000"));
 914         }
 915
 916     @Test
 917     public void updateE2EServiceInstanceExceptionMsoRequestTest() {
 918         new MockUp<RequestsDatabase>() {
 919             @Mock
 920             public OperationStatus getOperationStatusByServiceId(
 921                     String serviceID) {
 922                 OperationStatus operationStatus = new OperationStatus();
 923                 operationStatus.setProgress("100");
 924                 operationStatus.setResult("finish");
 925                 return operationStatus;
 926             }
 927         };
 928
 929         new MockUp<CatalogDatabase>() {
 930             @Mock
 931             public Service getServiceByModelName(String modelName) {
 932                 Service svc = new Service();
 933                 return svc;
 934             }
 935         };
 936
 937         new MockUp<CatalogDatabase>() {
 938             @Mock
 939             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 940                                                              String action) {
 941                 ServiceRecipe rec = new ServiceRecipe();
 942                 return rec;
 943             }
 944         };
 945
 946         new MockUp<RequestClientFactory>() {
 947             @Mock
 948             public RequestClient getRequestClient(String orchestrationURI,
 949                                                   MsoJavaProperties props) throws IllegalStateException {
 950                 RequestClient client = new CamundaClient();
 951                 client.setUrl("/test/url");
 952                 return client;
 953             }
 954         };
 955
 956         new MockUp<CamundaClient>() {
 957             @Mock
 958             public HttpResponse post(String requestId, boolean isBaseVfModule,
 959                                      int recipeTimeout, String requestAction,
 960                                      String serviceInstanceId, String vnfId, String vfModuleId,
 961                                      String volumeGroupId, String networkId, String configurationId, String serviceType,
 962                                      String vnfType, String vfModuleType, String networkType,
 963                                      String requestDetails, String recipeParamXsd) {
 964                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 965                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 966                         "test response");
 967                 BasicHttpEntity entity = new BasicHttpEntity();
 968                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
 969                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 970                 entity.setContent(instream);
 971                 resp.setEntity(entity);
 972                 return resp;
 973             }
 974         };
 975         MockUp<MsoRequest> msoRequest = new MockUp<MsoRequest>() {
 976                 @Mock
 977             void parse (ServiceInstancesRequest sir, HashMap<String,String> instanceIdMap, Action action, String version, String originalRequestJSON) throws ValidationException {
 978
 979                         throw new ValidationException("mock failure");
 980                 }
 981         };
 982         E2EServiceInstances instance = new E2EServiceInstances();
 983         String request = jsonBody;
 984         Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
 985         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 986         msoRequest.tearDown();
 987     }
 988
 989     @Test
 990     public void updateE2EServiceInstanceExceptionCatalogDbTest() {
 991         new MockUp<RequestsDatabase>() {
 992             @Mock
 993             public OperationStatus getOperationStatusByServiceId(
 994                     String serviceID) {
 995                 OperationStatus operationStatus = new OperationStatus();
 996                 operationStatus.setProgress("100");
 997                 operationStatus.setResult("finish");
 998                 return operationStatus;
 999             }
1000         };
1001
1002         MockUp<CatalogDatabase> catalog = new MockUp<CatalogDatabase>() {
1003             @Mock
1004             public Service getServiceByModelName(String modelName) throws Exception {
1005                 throw new Exception();
1006             }
1007         };
1008
1009         new MockUp<CatalogDatabase>() {
1010             @Mock
1011             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1012                                                              String action) {
1013                 ServiceRecipe rec = new ServiceRecipe();
1014                 return rec;
1015             }
1016         };
1017
1018         new MockUp<RequestClientFactory>() {
1019             @Mock
1020             public RequestClient getRequestClient(String orchestrationURI,
1021                                                   MsoJavaProperties props) throws IllegalStateException {
1022                 RequestClient client = new CamundaClient();
1023                 client.setUrl("/test/url");
1024                 return client;
1025             }
1026         };
1027
1028         new MockUp<CamundaClient>() {
1029             @Mock
1030             public HttpResponse post(String requestId, boolean isBaseVfModule,
1031                                      int recipeTimeout, String requestAction,
1032                                      String serviceInstanceId, String vnfId, String vfModuleId,
1033                                      String volumeGroupId, String networkId, String configurationId, String serviceType,
1034                                      String vnfType, String vfModuleType, String networkType,
1035                                      String requestDetails, String recipeParamXsd) {
1036                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
1037                 HttpResponse resp = new BasicHttpResponse(pv, 202,
1038                         "test response");
1039                 BasicHttpEntity entity = new BasicHttpEntity();
1040                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
1041                 InputStream instream = new ByteArrayInputStream(body.getBytes());
1042                 entity.setContent(instream);
1043                 resp.setEntity(entity);
1044                 return resp;
1045             }
1046         };
1047
1048         E2EServiceInstances instance = new E2EServiceInstances();
1049         String request = jsonBody;
1050         Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
1051         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
1052         catalog.tearDown();
1053     }
1054
1055     @Test
1056     public void updateE2EServiceInstanceNullServiceTest() {
1057         new MockUp<RequestsDatabase>() {
1058             @Mock
1059             public OperationStatus getOperationStatusByServiceId(
1060                     String serviceID) {
1061                 OperationStatus operationStatus = new OperationStatus();
1062                 operationStatus.setProgress("100");
1063                 operationStatus.setResult("finish");
1064                 return operationStatus;
1065             }
1066         };
1067
1068         new MockUp<CatalogDatabase>() {
1069             @Mock
1070             public Service getServiceByModelName(String modelName) {
1071                 Service svc = new Service();
1072                 return svc;
1073             }
1074         };
1075
1076         MockUp<CatalogDatabase> catalog = new MockUp<CatalogDatabase>() {
1077             @Mock
1078             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1079                                                              String action) {
1080                 return null;
1081             }
1082         };
1083
1084         new MockUp<RequestClientFactory>() {
1085             @Mock
1086             public RequestClient getRequestClient(String orchestrationURI,
1087                                                   MsoJavaProperties props) throws IllegalStateException {
1088                 RequestClient client = new CamundaClient();
1089                 client.setUrl("/test/url");
1090                 return client;
1091             }
1092         };
1093
1094         new MockUp<CamundaClient>() {
1095             @Mock
1096             public HttpResponse post(String requestId, boolean isBaseVfModule,
1097                                      int recipeTimeout, String requestAction,
1098                                      String serviceInstanceId, String vnfId, String vfModuleId,
1099                                      String volumeGroupId, String networkId, String configurationId, String serviceType,
1100                                      String vnfType, String vfModuleType, String networkType,
1101                                      String requestDetails, String recipeParamXsd) {
1102                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
1103                 HttpResponse resp = new BasicHttpResponse(pv, 202,
1104                         "test response");
1105                 BasicHttpEntity entity = new BasicHttpEntity();
1106                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
1107                 InputStream instream = new ByteArrayInputStream(body.getBytes());
1108                 entity.setContent(instream);
1109                 resp.setEntity(entity);
1110                 return resp;
1111             }
1112         };
1113
1114         E2EServiceInstances instance = new E2EServiceInstances();
1115         String request = jsonBody;
1116         Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
1117         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
1118         catalog.tearDown();
1119     }
1120
1121     @Test
1122     public void updateE2EServiceInstanceRequestClientExceptionTest() {
1123         new MockUp<RequestsDatabase>() {
1124             @Mock
1125             public OperationStatus getOperationStatusByServiceId(
1126                     String serviceID) {
1127                 OperationStatus operationStatus = new OperationStatus();
1128                 operationStatus.setProgress("100");
1129                 operationStatus.setResult("finish");
1130                 return operationStatus;
1131             }
1132         };
1133
1134         new MockUp<CatalogDatabase>() {
1135             @Mock
1136             public Service getServiceByModelName(String modelName) {
1137                 Service svc = new Service();
1138                 return svc;
1139             }
1140         };
1141
1142         new MockUp<CatalogDatabase>() {
1143             @Mock
1144             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1145                                                              String action) {
1146                 ServiceRecipe rec = new ServiceRecipe();
1147                 return rec;
1148             }
1149         };
1150
1151         new MockUp<RequestClientFactory>() {
1152             @Mock
1153             public RequestClient getRequestClient(String orchestrationURI,
1154                                                   MsoJavaProperties props) throws IllegalStateException {
1155                 RequestClient client = new CamundaClient();
1156                 client.setUrl("/test/url");
1157                 return client;
1158             }
1159         };
1160
1161         MockUp<CamundaClient> client = new MockUp<CamundaClient>() {
1162             @Mock
1163             public HttpResponse post(String requestId, boolean isBaseVfModule,
1164                                      int recipeTimeout, String requestAction,
1165                                      String serviceInstanceId, String vnfId, String vfModuleId,
1166                                      String volumeGroupId, String networkId, String configurationId, String serviceType,
1167                                      String vnfType, String vfModuleType, String networkType,
1168                                      String requestDetails, String recipeParamXsd) throws Exception {
1169                 throw new Exception();
1170             }
1171         };
1172
1173         E2EServiceInstances instance = new E2EServiceInstances();
1174         String request = jsonBody;
1175         Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
1176         assertEquals(Response.Status.BAD_GATEWAY.getStatusCode(), resp.getStatus());
1177         client.tearDown();
1178     }
1179
1180     @Test
1181     public void compareModelwithTargetVersionBadRequest(){
1182
1183         E2EServiceInstances instance = new E2EServiceInstances();
1184         Response response = instance.compareModelwithTargetVersion("", "12345", "v3");
1185
1186         assertNotNull(response);
1187         assertTrue(response.getEntity().toString().contains("Mapping of request to JSON object failed."));
1188
1189     }
1190     @Test
1191     public void compareModelwithTargetVersionFailedBPMNCall(){
1192
1193         new MockUp<CamundaClient>() {
1194             @Mock
1195             public HttpResponse post(String requestId, boolean isBaseVfModule,
1196                  int recipeTimeout, String requestAction, String serviceInstanceId,
1197                  String vnfId, String vfModuleId, String volumeGroupId, String networkId, String configurationId,
1198                  String serviceType, String vnfType, String vfModuleType, String networkType,
1199                  String requestDetails, String recipeParamXsd)
1200                     throws ClientProtocolException, IOException {
1201
1202                 throw new ClientProtocolException();
1203             }
1204         };
1205
1206         E2EServiceInstances instance = new E2EServiceInstances();
1207         Response response = instance.compareModelwithTargetVersion(compareModelsRequest, "12345", "v3");
1208
1209         assertNotNull(response);
1210         assertTrue(response.getEntity().toString().contains("Failed calling bpmn"));
1211
1212     }
1213
1214     @Test
1215     public void compareModelwithTargetVersionSuccess(){
1216
1217         new MockUp<CamundaClient>() {
1218             @Mock
1219             public HttpResponse post(String requestId, boolean isBaseVfModule,
1220                                      int recipeTimeout, String requestAction, String serviceInstanceId,
1221                                      String vnfId, String vfModuleId, String volumeGroupId, String networkId, String configurationId,
1222                                      String serviceType, String vnfType, String vfModuleType, String networkType,
1223                                      String requestDetails, String recipeParamXsd)
1224                     throws ClientProtocolException, IOException {
1225
1226                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
1227                 HttpResponse resp = new BasicHttpResponse(pv, 202,
1228                         "compareModelwithTargetVersion, test response");
1229                 BasicHttpEntity entity = new BasicHttpEntity();
1230                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
1231                 InputStream instream = new ByteArrayInputStream(body.getBytes());
1232                 entity.setContent(instream);
1233                 resp.setEntity(entity);
1234
1235                 return resp;
1236             }
1237         };
1238
1239         E2EServiceInstances instance = new E2EServiceInstances();
1240         Response response = instance.compareModelwithTargetVersion(compareModelsRequest, "12345", "v3");
1241
1242         assertNotNull(response);
1243         assertTrue(response.getStatus()==202);
1244
1245     }
1246
1247     @Test
1248     public void scaleE2EserviceInstancesTestFailInvalidRequest(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
1249                                                                @Mocked Session session ) {
1250
1251         E2EServiceInstances instance = new E2EServiceInstances();
1252         Response response = instance.scaleE2EServiceInstance(jsonBody, "v3", "12345");
1253     }
1254
1255     @Test
1256     public void scaleE2EserviceInstancesTestNormal() {
1257
1258         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
1259             @Mock
1260             public void createRequestRecord(Status status, Action action) {
1261                 return;
1262             }
1263         };
1264
1265         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
1266             @Mock
1267             public Service getServiceByModelName(String modelName) {
1268                 Service svc = new Service();
1269                 return svc;
1270             }
1271
1272             @Mock
1273             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1274                                                              String action) {
1275                 ServiceRecipe rec = new ServiceRecipe();
1276                 rec.setOrchestrationUri("/test/delE2E");
1277                 rec.setRecipeTimeout(180);
1278                 return rec;
1279             }
1280         };
1281
1282         final MockUp<RequestClientFactory> mockRequestClient = new MockUp<RequestClientFactory>() {
1283             @Mock
1284             public RequestClient getRequestClient(String orchestrationURI,
1285                                                   MsoJavaProperties props) throws IllegalStateException {
1286                 RequestClient client = new CamundaClient();
1287                 client.setUrl("/test/url");
1288                 return client;
1289             }
1290         };
1291
1292         final MockUp<CamundaClient> mockCamundaClient = new MockUp<CamundaClient>() {
1293             @Mock
1294             public HttpResponse post(String requestId, boolean isBaseVfModule,
1295                                      int recipeTimeout, String requestAction,
1296                                      String serviceInstanceId, String vnfId, String vfModuleId,
1297                                      String volumeGroupId, String networkId, String configurationId, String serviceType,
1298                                      String vnfType, String vfModuleType, String networkType,
1299                                      String requestDetails, String recipeParamXsd) {
1300                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
1301                 HttpResponse resp = new BasicHttpResponse(pv, 202,
1302                         "test response");
1303                 BasicHttpEntity entity = new BasicHttpEntity();
1304                 String body = "{\"response\":\"success\",\"message\":\"success\"}";
1305                 InputStream instream = new ByteArrayInputStream(body.getBytes());
1306                 entity.setContent(instream);
1307                 resp.setEntity(entity);
1308                 return resp;
1309             }
1310         };
1311
1312         E2EServiceInstances instance = new E2EServiceInstances();
1313         Response response = instance.scaleE2EServiceInstance(scaleRequest, "v3", "12345");
1314         mockMsoRequest.tearDown();
1315         mockCDB.tearDown();
1316         mockRequestClient.tearDown();
1317         mockCamundaClient.tearDown();
1318     }
1319
1320     @Test
1321     public void scaleE2EserviceInstancesTestFailCamundaClient(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
1322                                                               @Mocked Session session) {
1323
1324         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
1325             @Mock
1326             public void createRequestRecord(Status status, Action action) {
1327                 return;
1328             }
1329         };
1330
1331         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
1332             @Mock
1333             public Service getServiceByModelName(String modelName) {
1334                 Service svc = new Service();
1335                 return svc;
1336             }
1337
1338             @Mock
1339             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1340                                                              String action) {
1341                 ServiceRecipe rec = new ServiceRecipe();
1342                 rec.setOrchestrationUri("/test/delE2E");
1343                 rec.setRecipeTimeout(180);
1344                 return rec;
1345             }
1346         };
1347
1348         final MockUp<RequestClientFactory> mockRequestClient = new MockUp<RequestClientFactory>() {
1349             @Mock
1350             public RequestClient getRequestClient(String orchestrationURI,
1351                                                   MsoJavaProperties props) throws IllegalStateException {
1352                 RequestClient client = new CamundaClient();
1353                 client.setUrl("/test/url");
1354                 return client;
1355             }
1356         };
1357
1358         E2EServiceInstances instance = new E2EServiceInstances();
1359         Response response = instance.scaleE2EServiceInstance(scaleRequest, "v3", "12345");
1360         mockMsoRequest.tearDown();
1361         mockCDB.tearDown();
1362         mockRequestClient.tearDown();
1363     }
1364
1365     @Test
1366     public void scaleE2EserviceInstancesTestFailRequestClient(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
1367                                                               @Mocked Session session) {
1368
1369         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
1370             @Mock
1371             public void createRequestRecord(Status status, Action action) {
1372                 return;
1373             }
1374         };
1375
1376         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
1377             @Mock
1378             public Service getServiceByModelName(String modelName) {
1379                 Service svc = new Service();
1380                 return svc;
1381             }
1382
1383             @Mock
1384             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1385                                                              String action) {
1386                 ServiceRecipe rec = new ServiceRecipe();
1387                 rec.setOrchestrationUri("/test/delE2E");
1388                 rec.setRecipeTimeout(180);
1389                 return rec;
1390             }
1391         };
1392
1393         E2EServiceInstances instance = new E2EServiceInstances();
1394         Response response = instance.scaleE2EServiceInstance(scaleRequest, "v3", "12345");
1395         mockMsoRequest.tearDown();
1396         mockCDB.tearDown();
1397     }
1398
1399 }