mso-api-handlers/mso-api-handler-infra/src/test/java/org/openecomp/mso/apihandlerinfra/E2EServiceInstancesTest.java

   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.RequestClientParamater;
  44 import org.openecomp.mso.apihandler.common.ValidationException;
  45 import org.openecomp.mso.db.AbstractSessionFactoryManager;
  46 import org.openecomp.mso.db.catalog.CatalogDatabase;
  47 import org.openecomp.mso.db.catalog.beans.Service;
  48 import org.openecomp.mso.db.catalog.beans.ServiceRecipe;
  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(RequestClientParamater requestClientParamater) {
 198                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 199                                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 200                                                 "test response");
 201                                 BasicHttpEntity entity = new BasicHttpEntity();
 202                                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
 203                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 204                                 entity.setContent(instream);
 205                                 resp.setEntity(entity);
 206                                 return resp;
 207                         }
 208                 };
 209
 210                 E2EServiceInstances instance = new E2EServiceInstances();
 211                 String request = jsonBody;
 212                 Response resp = instance.createE2EServiceInstance(request, "v3");
 213                 String respStr = resp.getEntity().toString();
 214                 assertTrue(respStr.contains("success"));
 215         }
 216
 217         @Test
 218         public void createE2EServiceInstanceTestBpelHTTPException() {
 219                 new MockUp<RequestsDatabase>() {
 220                         @Mock
 221                         public OperationStatus getOperationStatusByServiceName(
 222                                         String serviceName) {
 223                                 OperationStatus operationStatus = new OperationStatus();
 224                                 return operationStatus;
 225                         }
 226                 };
 227                 new MockUp<CatalogDatabase>() {
 228                         @Mock
 229                         public Service getServiceByModelName(String modelName) {
 230                                 Service svc = new Service();
 231                                 return svc;
 232                         }
 233                 };
 234
 235                 new MockUp<CatalogDatabase>() {
 236                         @Mock
 237                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 238                                         String action) {
 239                                 ServiceRecipe rec = new ServiceRecipe();
 240                                 return rec;
 241                         }
 242                 };
 243
 244                 new MockUp<RequestClientFactory>() {
 245                         @Mock
 246                         public RequestClient getRequestClient(String orchestrationURI,
 247                                         MsoJavaProperties props) throws IllegalStateException {
 248                                 RequestClient client = new CamundaClient();
 249                                 client.setUrl("/test/url");
 250                                 return client;
 251                         }
 252                 };
 253
 254                 new MockUp<CamundaClient>() {
 255                         @Mock
 256                         public HttpResponse post(RequestClientParamater requestClientParamater) {
 257                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 258                                 HttpResponse resp = new BasicHttpResponse(pv, 500,
 259                                                 "test response");
 260                                 BasicHttpEntity entity = new BasicHttpEntity();
 261                                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
 262                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 263                                 entity.setContent(instream);
 264                                 resp.setEntity(entity);
 265                                 return resp;
 266                         }
 267                 };
 268
 269                 E2EServiceInstances instance = new E2EServiceInstances();
 270                 String request = jsonBody;
 271                 Response resp = instance.createE2EServiceInstance(request, "v3");
 272                 String respStr = resp.getEntity().toString();
 273                 assertTrue(respStr.contains("SVC2000"));
 274         }
 275
 276         @Test
 277         public void createE2EServiceInstanceTestBpelHTTPExceptionWithNullREsponseBody() {
 278                 new MockUp<RequestsDatabase>() {
 279                         @Mock
 280                         public OperationStatus getOperationStatusByServiceName(
 281                                         String serviceName) {
 282                                 OperationStatus operationStatus = new OperationStatus();
 283                                 return operationStatus;
 284                         }
 285                 };
 286
 287                 new MockUp<CatalogDatabase>() {
 288                         @Mock
 289                         public Service getServiceByModelName(String modelName) {
 290                                 Service svc = new Service();
 291                                 return svc;
 292                         }
 293                 };
 294
 295                 new MockUp<CatalogDatabase>() {
 296                         @Mock
 297                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 298                                         String action) {
 299                                 ServiceRecipe rec = new ServiceRecipe();
 300                                 return rec;
 301                         }
 302                 };
 303
 304                 new MockUp<RequestClientFactory>() {
 305                         @Mock
 306                         public RequestClient getRequestClient(String orchestrationURI,
 307                                         MsoJavaProperties props) throws IllegalStateException {
 308                                 RequestClient client = new CamundaClient();
 309                                 client.setUrl("/test/url");
 310                                 return client;
 311                         }
 312                 };
 313
 314                 new MockUp<CamundaClient>() {
 315                         @Mock
 316                         public HttpResponse post(RequestClientParamater requestClientParamater) {
 317                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 318                                 HttpResponse resp = new BasicHttpResponse(pv, 500,
 319                                                 "test response");
 320                                 BasicHttpEntity entity = new BasicHttpEntity();
 321                                 String body = "{\"content\":\"\",\"message\":\"success\"}";
 322                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 323                                 entity.setContent(instream);
 324                                 resp.setEntity(entity);
 325                                 return resp;
 326                         }
 327                 };
 328
 329                 E2EServiceInstances instance = new E2EServiceInstances();
 330                 String request = jsonBody;
 331                 Response resp = instance.createE2EServiceInstance(request, "v3");
 332                 String respStr = resp.getEntity().toString();
 333                 assertTrue(respStr.contains("SVC2000"));
 334         }
 335
 336         @Test
 337         public void createE2EServiceInstanceTestNullBPELResponse() {
 338                 new MockUp<RequestsDatabase>() {
 339                         @Mock
 340                         public OperationStatus getOperationStatusByServiceName(
 341                                         String serviceName) {
 342                                 OperationStatus operationStatus = new OperationStatus();
 343                                 return operationStatus;
 344                         }
 345                 };
 346
 347                 new MockUp<CatalogDatabase>() {
 348                         @Mock
 349                         public Service getServiceByModelName(String modelName) {
 350                                 Service svc = new Service();
 351                                 return svc;
 352                         }
 353                 };
 354
 355                 new MockUp<CatalogDatabase>() {
 356                         @Mock
 357                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 358                                         String action) {
 359                                 ServiceRecipe rec = new ServiceRecipe();
 360                                 return rec;
 361                         }
 362                 };
 363
 364                 new MockUp<RequestClientFactory>() {
 365                         @Mock
 366                         public RequestClient getRequestClient(String orchestrationURI,
 367                                         MsoJavaProperties props) throws IllegalStateException {
 368                                 RequestClient client = new CamundaClient();
 369                                 client.setUrl("/test/url");
 370                                 return client;
 371                         }
 372                 };
 373
 374                 new MockUp<CamundaClient>() {
 375                         @Mock
 376                         public HttpResponse post(RequestClientParamater requestClientParamater) {
 377                                 HttpResponse resp = null;
 378                                 return resp;
 379                         }
 380                 };
 381
 382                 E2EServiceInstances instance = new E2EServiceInstances();
 383                 String request = jsonBody;
 384                 Response resp = instance.createE2EServiceInstance(request, "v3");
 385                 String respStr = resp.getEntity().toString();
 386                 assertTrue(respStr.contains("serviceException"));
 387         }
 388
 389         @Test
 390         public void createE2EServiceInstanceTestBPMNNullREsponse() {
 391                 new MockUp<RequestsDatabase>() {
 392                         @Mock
 393                         public OperationStatus getOperationStatusByServiceName(
 394                                         String serviceName) {
 395                                 OperationStatus operationStatus = new OperationStatus();
 396                                 return operationStatus;
 397                         }
 398                 };
 399
 400                 new MockUp<CatalogDatabase>() {
 401                         @Mock
 402                         public Service getServiceByModelName(String modelName) {
 403                                 Service svc = new Service();
 404                                 return svc;
 405                         }
 406                 };
 407
 408                 new MockUp<CatalogDatabase>() {
 409                         @Mock
 410                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 411                                         String action) {
 412                                 ServiceRecipe rec = new ServiceRecipe();
 413                                 return rec;
 414                         }
 415                 };
 416
 417                 new MockUp<RequestClientFactory>() {
 418                         @Mock
 419                         public RequestClient getRequestClient(String orchestrationURI,
 420                                         MsoJavaProperties props) throws IllegalStateException {
 421                                 RequestClient client = new CamundaClient();
 422                                 client.setUrl("/test/url");
 423                                 return client;
 424                         }
 425                 };
 426
 427                 new MockUp<CamundaClient>() {
 428                         @Mock
 429                         public HttpResponse post(String camundaReqXML, String requestId,
 430                                         String requestTimeout, String schemaVersion,
 431                                         String serviceInstanceId, String action) {
 432                                 HttpResponse resp = null;
 433                                 return resp;
 434                         }
 435                 };
 436                 E2EServiceInstances instance = new E2EServiceInstances();
 437                 String request = jsonBody;
 438                 Response resp = instance.createE2EServiceInstance(request, "v3");
 439                 String respStr = resp.getEntity().toString();
 440                 assertTrue(respStr.contains("serviceException"));
 441         }
 442
 443         @Test
 444         public void createE2EServiceInstanceTestNullBpmn() {
 445                 new MockUp<RequestsDatabase>() {
 446                         @Mock
 447                         public OperationStatus getOperationStatusByServiceName(
 448                                         String serviceName) {
 449                                 OperationStatus operationStatus = new OperationStatus();
 450                                 return operationStatus;
 451                         }
 452                 };
 453
 454
 455                 new MockUp<CatalogDatabase>() {
 456                         @Mock
 457                         public Service getServiceByModelName(String modelName) {
 458                                 Service svc = new Service();
 459                                 return svc;
 460                         }
 461                 };
 462
 463                 new MockUp<CatalogDatabase>() {
 464                         @Mock
 465                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 466                                         String action) {
 467                                 ServiceRecipe rec = new ServiceRecipe();
 468                                 return rec;
 469                         }
 470                 };
 471                 E2EServiceInstances instance = new E2EServiceInstances();
 472         String request = jsonBody;
 473         ;
 474                 Response resp = instance.createE2EServiceInstance(request, "v3");
 475                 String respStr = resp.getEntity().toString();
 476                 assertTrue(respStr.contains("serviceException"));
 477         }
 478
 479         @Test
 480         public void createE2EServiceInstanceTestNullReceipe() {
 481                 new MockUp<RequestsDatabase>() {
 482                         @Mock
 483                         public OperationStatus getOperationStatusByServiceName(
 484                                         String serviceName) {
 485                                 OperationStatus operationStatus = new OperationStatus();
 486                                 return operationStatus;
 487                         }
 488                 };
 489
 490                 E2EServiceInstances instance = new E2EServiceInstances();
 491                 String request = jsonBody;
 492                 Response resp = instance.createE2EServiceInstance(request, "v3");
 493                 String respStr = resp.getEntity().toString();
 494                 assertTrue(respStr.contains("serviceException"));
 495         }
 496
 497         @Test
 498         public void createE2EServiceInstanceTestNullDBResponse() {
 499
 500                 new MockUp<RequestsDatabase>() {
 501                         @Mock
 502                         public OperationStatus getOperationStatusByServiceName(
 503                                         String serviceName) {
 504                                 OperationStatus operationStatus = new OperationStatus();
 505                                 return operationStatus;
 506                         }
 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 createE2EServiceInstanceTestInvalidRequest() {
 519                 new MockUp<RequestsDatabase>() {
 520                         @Mock
 521                         public OperationStatus getOperationStatusByServiceName(
 522                                         String serviceName) {
 523                                 OperationStatus operationStatus = new OperationStatus();
 524                                 return operationStatus;
 525                         }
 526                 };
 527
 528
 529                 E2EServiceInstances instance = new E2EServiceInstances();
 530                 String request = jsonBody;
 531                 Response resp = instance.createE2EServiceInstance(request, "v3");
 532                 String respStr = resp.getEntity().toString();
 533                 assertTrue(respStr.contains("serviceException"));
 534         }
 535
 536         @Test
 537         public void createE2EServiceInstanceTestEmptyDBQuery() {
 538
 539
 540                 E2EServiceInstances instance = new E2EServiceInstances();
 541                 String request = jsonBody;
 542                 Response resp = instance.createE2EServiceInstance(request, "v3");
 543                 String respStr = resp.getEntity().toString();
 544                 assertTrue(respStr.contains("serviceException"));
 545                 // assertTrue(true);
 546         }
 547
 548         @Test
 549         public void createE2EServiceInstanceTestDBQueryFail() {
 550                 new MockUp<RequestsDatabase>() {
 551                         @Mock
 552                         public OperationStatus getOperationStatusByServiceName(
 553                                         String serviceName) {
 554                                 OperationStatus operationStatus = new OperationStatus();
 555                                 return operationStatus;
 556                         }
 557                 };
 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         }
 566
 567         @Test
 568         public void createE2EServiceInstanceTestForEmptyRequest() {
 569
 570
 571                 E2EServiceInstances instance = new E2EServiceInstances();
 572                 String request = "";
 573                 Response resp = instance.createE2EServiceInstance(request, "v3");
 574                 String respStr = resp.getEntity().toString();
 575                 assertTrue(respStr
 576             .contains("Mapping of request to JSON object failed.  No content to map due to end-of-input"));
 577         }
 578
 579         @Test
 580         public void deleteE2EServiceInstanceTestNormal() {
 581
 582         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
 583             @Mock
 584             public Service getServiceByModelName(String modelName) {
 585                 Service svc = new Service();
 586                 return svc;
 587             }
 588
 589             @Mock
 590             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 591                                                              String action) {
 592                 ServiceRecipe rec = new ServiceRecipe();
 593                 rec.setOrchestrationUri("/test/delE2E");
 594                 rec.setRecipeTimeout(180);
 595                 return rec;
 596             }
 597         };
 598
 599         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
 600             @Mock
 601             public void createRequestRecord(Status status, Action action) {
 602                 return;
 603             }
 604         };
 605
 606         final MockUp<CamundaClient> mockCmaundaClient = new MockUp<CamundaClient>() {
 607             @Mock
 608             public HttpResponse post(RequestClientParamater requestClientParamater) {
 609                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 610                 HttpResponse resp = new BasicHttpResponse(pv, 200, "test response");
 611                 BasicHttpEntity entity = new BasicHttpEntity();
 612                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
 613                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 614                 entity.setContent(instream);
 615                 resp.setEntity(entity);
 616                 return resp;
 617             }
 618         };
 619
 620
 621                 E2EServiceInstances instance = new E2EServiceInstances();
 622                 String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 623
 624         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 625         mockCDB.tearDown();
 626         mockMsoRequest.tearDown();
 627         mockCmaundaClient.tearDown();
 628
 629     }
 630
 631     @Test
 632     public void deleteE2EServiceInstanceTestFail() {
 633         E2EServiceInstances instance = new E2EServiceInstances();
 634         String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 635         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 636     }
 637
 638     @Test
 639     public void deleteE2EServiceInstanceTestFailClient(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
 640                                                        @Mocked Session session) {
 641         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
 642             @Mock
 643             public Service getServiceByModelName(String modelName) {
 644                 Service svc = new Service();
 645                 return svc;
 646             }
 647
 648             @Mock
 649             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 650                                                              String action) {
 651                 ServiceRecipe rec = new ServiceRecipe();
 652                 rec.setOrchestrationUri("/test/delE2E");
 653                 rec.setRecipeTimeout(180);
 654                 return rec;
 655             }
 656         };
 657
 658         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
 659             @Mock
 660             public void createRequestRecord(Status status, Action action) {
 661                 return;
 662             }
 663         };
 664
 665         E2EServiceInstances instance = new E2EServiceInstances();
 666         String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 667
 668         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 669         mockCDB.tearDown();
 670         mockMsoRequest.tearDown();
 671
 672     }
 673
 674     @Test
 675     public void deleteE2EServiceInstanceTestFailRecipe(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
 676                                                        @Mocked Session session) {
 677         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
 678             @Mock
 679             public Service getServiceByModelName(String modelName) {
 680                 Service svc = new Service();
 681                 return svc;
 682             }
 683
 684             @Mock
 685             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 686                                                              String action) {
 687                 ServiceRecipe rec = new ServiceRecipe();
 688                 return rec;
 689             }
 690         };
 691
 692         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
 693             @Mock
 694             public void createRequestRecord(Status status, Action action) {
 695                 return;
 696             }
 697         };
 698
 699         E2EServiceInstances instance = new E2EServiceInstances();
 700         String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 701
 702         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 703         mockCDB.tearDown();
 704         mockMsoRequest.tearDown();
 705
 706     }
 707
 708     @Test
 709     public void deleteE2EServiceInstanceTestFailModelName(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
 710                                                           @Mocked Session session) {
 711         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
 712             @Mock
 713             public void createRequestRecord(Status status, Action action) {
 714                 return;
 715             }
 716         };
 717
 718         new Expectations() {{
 719             sessionFactoryManager.getSessionFactory().openSession();
 720             result = session;
 721         }};
 722
 723         E2EServiceInstances instance = new E2EServiceInstances();
 724         String request = "{\"globalSubscriberId\":\"299392392\",\"serviceType\":\"VoLTE\"}";
 725
 726         instance.deleteE2EServiceInstance(request, "v3", "12345678");
 727         mockMsoRequest.tearDown();
 728
 729         }
 730
 731         @Test
 732         public void getE2EServiceInstanceTest() {
 733
 734                 new MockUp<RequestsDatabase>() {
 735                         @Mock
 736                         public OperationStatus getOperationStatus(String serviceId,
 737                                         String operationId) {
 738                                 OperationStatus os = new OperationStatus();
 739                                 os.setOperation("");
 740                                 os.setOperationContent("");
 741                                 os.setOperationId("123456");
 742                                 os.setProgress("");
 743                                 os.setServiceId("12345");
 744                                 os.setServiceName("VoLTE");
 745                                 os.setReason("");
 746                                 os.setResult("");
 747                                 os.setUserId("");
 748                                 return os;
 749                         }
 750                 };
 751
 752                 E2EServiceInstances instance = new E2EServiceInstances();
 753                 Response resp = instance
 754                                 .getE2EServiceInstances("12345", "v3", "123456");
 755
 756         }
 757
 758         @Test
 759         public void updateE2EServiceInstanceTestNormal() {
 760                 new MockUp<RequestsDatabase>() {
 761                         @Mock
 762                         public OperationStatus getOperationStatusByServiceId(
 763                                         String serviceID) {
 764                                 OperationStatus operationStatus = new OperationStatus();
 765                                 operationStatus.setProgress("100");
 766                                 operationStatus.setResult("finish");
 767                                 return operationStatus;
 768                         }
 769                 };
 770
 771                 new MockUp<CatalogDatabase>() {
 772                         @Mock
 773                         public Service getServiceByModelName(String modelName) {
 774                                 Service svc = new Service();
 775                                 return svc;
 776                         }
 777                 };
 778
 779                 new MockUp<CatalogDatabase>() {
 780                         @Mock
 781                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 782                                         String action) {
 783                                 ServiceRecipe rec = new ServiceRecipe();
 784                                 return rec;
 785                         }
 786                 };
 787
 788                 new MockUp<RequestClientFactory>() {
 789                         @Mock
 790                         public RequestClient getRequestClient(String orchestrationURI,
 791                                         MsoJavaProperties props) throws IllegalStateException {
 792                                 RequestClient client = new CamundaClient();
 793                                 client.setUrl("/test/url");
 794                                 return client;
 795                         }
 796                 };
 797
 798                 new MockUp<CamundaClient>() {
 799                         @Mock
 800                         public HttpResponse post(RequestClientParamater requestClientParamater) {
 801                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 802                                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 803                                                 "test response");
 804                                 BasicHttpEntity entity = new BasicHttpEntity();
 805                                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
 806                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 807                                 entity.setContent(instream);
 808                                 resp.setEntity(entity);
 809                                 return resp;
 810                         }
 811                 };
 812
 813                 E2EServiceInstances instance = new E2EServiceInstances();
 814                 String request = jsonBody;
 815                 Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
 816                 String respStr = resp.getEntity().toString();
 817                 assertTrue(respStr.contains("success"));
 818         }
 819
 820         @Test
 821         public void updateE2EServiceInstanceTestChkStatusFalse() {
 822                 new MockUp<RequestsDatabase>() {
 823                         @Mock
 824                         public OperationStatus getOperationStatusByServiceId(
 825                                         String serviceID) {
 826                                 OperationStatus operationStatus = new OperationStatus();
 827                                 operationStatus.setResult("processing");
 828                                 return operationStatus;
 829                         }
 830                 };
 831
 832                 new MockUp<CatalogDatabase>() {
 833                         @Mock
 834                         public Service getServiceByModelName(String modelName) {
 835                                 Service svc = new Service();
 836                                 return svc;
 837                         }
 838                 };
 839
 840                 new MockUp<CatalogDatabase>() {
 841                         @Mock
 842                         public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 843                                         String action) {
 844                                 ServiceRecipe rec = new ServiceRecipe();
 845                                 return rec;
 846                         }
 847                 };
 848
 849                 new MockUp<RequestClientFactory>() {
 850                         @Mock
 851                         public RequestClient getRequestClient(String orchestrationURI,
 852                                         MsoJavaProperties props) throws IllegalStateException {
 853                                 RequestClient client = new CamundaClient();
 854                                 client.setUrl("/test/url");
 855                                 return client;
 856                         }
 857                 };
 858
 859                 new MockUp<CamundaClient>() {
 860                         @Mock
 861                         public HttpResponse post(RequestClientParamater requestClientParamater) {
 862                                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 863                                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 864                                                 "test response");
 865                                 BasicHttpEntity entity = new BasicHttpEntity();
 866                                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
 867                                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 868                                 entity.setContent(instream);
 869                                 resp.setEntity(entity);
 870                                 return resp;
 871                         }
 872                 };
 873
 874                 E2EServiceInstances instance = new E2EServiceInstances();
 875                 String request = jsonBody;
 876                 Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
 877                 String respStr = resp.getEntity().toString();
 878                 assertTrue(!respStr.contains("SVC2000"));
 879         }
 880
 881     @Test
 882     public void updateE2EServiceInstanceExceptionMsoRequestTest() {
 883         new MockUp<RequestsDatabase>() {
 884             @Mock
 885             public OperationStatus getOperationStatusByServiceId(
 886                     String serviceID) {
 887                 OperationStatus operationStatus = new OperationStatus();
 888                 operationStatus.setProgress("100");
 889                 operationStatus.setResult("finish");
 890                 return operationStatus;
 891             }
 892         };
 893
 894         new MockUp<CatalogDatabase>() {
 895             @Mock
 896             public Service getServiceByModelName(String modelName) {
 897                 Service svc = new Service();
 898                 return svc;
 899             }
 900         };
 901
 902         new MockUp<CatalogDatabase>() {
 903             @Mock
 904             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 905                                                              String action) {
 906                 ServiceRecipe rec = new ServiceRecipe();
 907                 return rec;
 908             }
 909         };
 910
 911         new MockUp<RequestClientFactory>() {
 912             @Mock
 913             public RequestClient getRequestClient(String orchestrationURI,
 914                                                   MsoJavaProperties props) throws IllegalStateException {
 915                 RequestClient client = new CamundaClient();
 916                 client.setUrl("/test/url");
 917                 return client;
 918             }
 919         };
 920
 921         new MockUp<CamundaClient>() {
 922             @Mock
 923             public HttpResponse post(RequestClientParamater requestClientParamater) {
 924                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 925                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 926                         "test response");
 927                 BasicHttpEntity entity = new BasicHttpEntity();
 928                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
 929                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 930                 entity.setContent(instream);
 931                 resp.setEntity(entity);
 932                 return resp;
 933             }
 934         };
 935         MockUp<MsoRequest> msoRequest = new MockUp<MsoRequest>() {
 936                 @Mock
 937             void parse (ServiceInstancesRequest sir, HashMap<String,String> instanceIdMap, Action action, String version, String originalRequestJSON) throws ValidationException {
 938
 939                         throw new ValidationException("mock failure");
 940                 }
 941         };
 942         E2EServiceInstances instance = new E2EServiceInstances();
 943         String request = jsonBody;
 944         Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
 945         assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), resp.getStatus());
 946         msoRequest.tearDown();
 947     }
 948
 949     @Test
 950     public void updateE2EServiceInstanceExceptionCatalogDbTest() {
 951         new MockUp<RequestsDatabase>() {
 952             @Mock
 953             public OperationStatus getOperationStatusByServiceId(
 954                     String serviceID) {
 955                 OperationStatus operationStatus = new OperationStatus();
 956                 operationStatus.setProgress("100");
 957                 operationStatus.setResult("finish");
 958                 return operationStatus;
 959             }
 960         };
 961
 962         MockUp<CatalogDatabase> catalog = new MockUp<CatalogDatabase>() {
 963             @Mock
 964             public Service getServiceByModelName(String modelName) throws Exception {
 965                 throw new Exception();
 966             }
 967         };
 968
 969         new MockUp<CatalogDatabase>() {
 970             @Mock
 971             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
 972                                                              String action) {
 973                 ServiceRecipe rec = new ServiceRecipe();
 974                 return rec;
 975             }
 976         };
 977
 978         new MockUp<RequestClientFactory>() {
 979             @Mock
 980             public RequestClient getRequestClient(String orchestrationURI,
 981                                                   MsoJavaProperties props) throws IllegalStateException {
 982                 RequestClient client = new CamundaClient();
 983                 client.setUrl("/test/url");
 984                 return client;
 985             }
 986         };
 987
 988         new MockUp<CamundaClient>() {
 989             @Mock
 990             public HttpResponse post(RequestClientParamater requestClientParamater) {
 991                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
 992                 HttpResponse resp = new BasicHttpResponse(pv, 202,
 993                         "test response");
 994                 BasicHttpEntity entity = new BasicHttpEntity();
 995                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
 996                 InputStream instream = new ByteArrayInputStream(body.getBytes());
 997                 entity.setContent(instream);
 998                 resp.setEntity(entity);
 999                 return resp;
1000             }
1001         };
1002
1003         E2EServiceInstances instance = new E2EServiceInstances();
1004         String request = jsonBody;
1005         Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
1006         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
1007         catalog.tearDown();
1008     }
1009
1010     @Test
1011     public void updateE2EServiceInstanceNullServiceTest() {
1012         new MockUp<RequestsDatabase>() {
1013             @Mock
1014             public OperationStatus getOperationStatusByServiceId(
1015                     String serviceID) {
1016                 OperationStatus operationStatus = new OperationStatus();
1017                 operationStatus.setProgress("100");
1018                 operationStatus.setResult("finish");
1019                 return operationStatus;
1020             }
1021         };
1022
1023         new MockUp<CatalogDatabase>() {
1024             @Mock
1025             public Service getServiceByModelName(String modelName) {
1026                 Service svc = new Service();
1027                 return svc;
1028             }
1029         };
1030
1031         MockUp<CatalogDatabase> catalog = new MockUp<CatalogDatabase>() {
1032             @Mock
1033             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1034                                                              String action) {
1035                 return null;
1036             }
1037         };
1038
1039         new MockUp<RequestClientFactory>() {
1040             @Mock
1041             public RequestClient getRequestClient(String orchestrationURI,
1042                                                   MsoJavaProperties props) throws IllegalStateException {
1043                 RequestClient client = new CamundaClient();
1044                 client.setUrl("/test/url");
1045                 return client;
1046             }
1047         };
1048
1049         new MockUp<CamundaClient>() {
1050             @Mock
1051             public HttpResponse post(RequestClientParamater requestClientParamater) {
1052                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
1053                 HttpResponse resp = new BasicHttpResponse(pv, 202,
1054                         "test response");
1055                 BasicHttpEntity entity = new BasicHttpEntity();
1056                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
1057                 InputStream instream = new ByteArrayInputStream(body.getBytes());
1058                 entity.setContent(instream);
1059                 resp.setEntity(entity);
1060                 return resp;
1061             }
1062         };
1063
1064         E2EServiceInstances instance = new E2EServiceInstances();
1065         String request = jsonBody;
1066         Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
1067         assertEquals(Response.Status.NOT_FOUND.getStatusCode(), resp.getStatus());
1068         catalog.tearDown();
1069     }
1070
1071     @Test
1072     public void updateE2EServiceInstanceRequestClientExceptionTest() {
1073         new MockUp<RequestsDatabase>() {
1074             @Mock
1075             public OperationStatus getOperationStatusByServiceId(
1076                     String serviceID) {
1077                 OperationStatus operationStatus = new OperationStatus();
1078                 operationStatus.setProgress("100");
1079                 operationStatus.setResult("finish");
1080                 return operationStatus;
1081             }
1082         };
1083
1084         new MockUp<CatalogDatabase>() {
1085             @Mock
1086             public Service getServiceByModelName(String modelName) {
1087                 Service svc = new Service();
1088                 return svc;
1089             }
1090         };
1091
1092         new MockUp<CatalogDatabase>() {
1093             @Mock
1094             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1095                                                              String action) {
1096                 ServiceRecipe rec = new ServiceRecipe();
1097                 return rec;
1098             }
1099         };
1100
1101         new MockUp<RequestClientFactory>() {
1102             @Mock
1103             public RequestClient getRequestClient(String orchestrationURI,
1104                                                   MsoJavaProperties props) throws IllegalStateException {
1105                 RequestClient client = new CamundaClient();
1106                 client.setUrl("/test/url");
1107                 return client;
1108             }
1109         };
1110
1111         MockUp<CamundaClient> client = new MockUp<CamundaClient>() {
1112             @Mock
1113             public HttpResponse post(RequestClientParamater requestClientParamater) throws Exception {
1114                 throw new Exception();
1115             }
1116         };
1117
1118         E2EServiceInstances instance = new E2EServiceInstances();
1119         String request = jsonBody;
1120         Response resp = instance.updateE2EServiceInstance(request, "v3", "12345");
1121         assertEquals(Response.Status.BAD_GATEWAY.getStatusCode(), resp.getStatus());
1122         client.tearDown();
1123     }
1124
1125     @Test
1126     public void compareModelwithTargetVersionBadRequest(){
1127
1128         E2EServiceInstances instance = new E2EServiceInstances();
1129         Response response = instance.compareModelwithTargetVersion("", "12345", "v3");
1130
1131         assertNotNull(response);
1132         assertTrue(response.getEntity().toString().contains("Mapping of request to JSON object failed."));
1133
1134     }
1135     @Test
1136     public void compareModelwithTargetVersionFailedBPMNCall(){
1137
1138         new MockUp<CamundaClient>() {
1139             @Mock
1140             public HttpResponse post(RequestClientParamater requestClientParamater) throws IOException {
1141                 throw new ClientProtocolException();
1142             }
1143         };
1144
1145         E2EServiceInstances instance = new E2EServiceInstances();
1146         Response response = instance.compareModelwithTargetVersion(compareModelsRequest, "12345", "v3");
1147
1148         assertNotNull(response);
1149         assertTrue(response.getEntity().toString().contains("Failed calling bpmn"));
1150
1151     }
1152
1153     @Test
1154     public void compareModelwithTargetVersionSuccess(){
1155
1156         new MockUp<CamundaClient>() {
1157             @Mock
1158             public HttpResponse post(RequestClientParamater requestClientParamater) {
1159                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
1160                 HttpResponse resp = new BasicHttpResponse(pv, 202,
1161                         "compareModelwithTargetVersion, test response");
1162                 BasicHttpEntity entity = new BasicHttpEntity();
1163                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
1164                 InputStream instream = new ByteArrayInputStream(body.getBytes());
1165                 entity.setContent(instream);
1166                 resp.setEntity(entity);
1167
1168                 return resp;
1169             }
1170         };
1171
1172         E2EServiceInstances instance = new E2EServiceInstances();
1173         Response response = instance.compareModelwithTargetVersion(compareModelsRequest, "12345", "v3");
1174
1175         assertNotNull(response);
1176         assertTrue(response.getStatus()==202);
1177
1178     }
1179
1180     @Test
1181     public void scaleE2EserviceInstancesTestFailInvalidRequest(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
1182                                                                @Mocked Session session ) {
1183
1184         E2EServiceInstances instance = new E2EServiceInstances();
1185         Response response = instance.scaleE2EServiceInstance(jsonBody, "v3", "12345");
1186     }
1187
1188     @Test
1189     public void scaleE2EserviceInstancesTestNormal() {
1190
1191         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
1192             @Mock
1193             public void createRequestRecord(Status status, Action action) {
1194                 return;
1195             }
1196         };
1197
1198         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
1199             @Mock
1200             public Service getServiceByModelName(String modelName) {
1201                 Service svc = new Service();
1202                 return svc;
1203             }
1204
1205             @Mock
1206             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1207                                                              String action) {
1208                 ServiceRecipe rec = new ServiceRecipe();
1209                 rec.setOrchestrationUri("/test/delE2E");
1210                 rec.setRecipeTimeout(180);
1211                 return rec;
1212             }
1213         };
1214
1215         final MockUp<RequestClientFactory> mockRequestClient = new MockUp<RequestClientFactory>() {
1216             @Mock
1217             public RequestClient getRequestClient(String orchestrationURI,
1218                                                   MsoJavaProperties props) throws IllegalStateException {
1219                 RequestClient client = new CamundaClient();
1220                 client.setUrl("/test/url");
1221                 return client;
1222             }
1223         };
1224
1225         final MockUp<CamundaClient> mockCamundaClient = new MockUp<CamundaClient>() {
1226             @Mock
1227             public HttpResponse post(RequestClientParamater requestClientParamater) {
1228                 ProtocolVersion pv = new ProtocolVersion("HTTP", 1, 1);
1229                 HttpResponse resp = new BasicHttpResponse(pv, 202,
1230                         "test response");
1231                 BasicHttpEntity entity = new BasicHttpEntity();
1232                 String body = "{\"content\":\"success\",\"message\":\"success\"}";
1233                 InputStream instream = new ByteArrayInputStream(body.getBytes());
1234                 entity.setContent(instream);
1235                 resp.setEntity(entity);
1236                 return resp;
1237             }
1238         };
1239
1240         E2EServiceInstances instance = new E2EServiceInstances();
1241         Response response = instance.scaleE2EServiceInstance(scaleRequest, "v3", "12345");
1242         mockMsoRequest.tearDown();
1243         mockCDB.tearDown();
1244         mockRequestClient.tearDown();
1245         mockCamundaClient.tearDown();
1246     }
1247
1248     @Test
1249     public void scaleE2EserviceInstancesTestFailCamundaClient(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
1250                                                               @Mocked Session session) {
1251
1252         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
1253             @Mock
1254             public void createRequestRecord(Status status, Action action) {
1255                 return;
1256             }
1257         };
1258
1259         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
1260             @Mock
1261             public Service getServiceByModelName(String modelName) {
1262                 Service svc = new Service();
1263                 return svc;
1264             }
1265
1266             @Mock
1267             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1268                                                              String action) {
1269                 ServiceRecipe rec = new ServiceRecipe();
1270                 rec.setOrchestrationUri("/test/delE2E");
1271                 rec.setRecipeTimeout(180);
1272                 return rec;
1273             }
1274         };
1275
1276         final MockUp<RequestClientFactory> mockRequestClient = new MockUp<RequestClientFactory>() {
1277             @Mock
1278             public RequestClient getRequestClient(String orchestrationURI,
1279                                                   MsoJavaProperties props) throws IllegalStateException {
1280                 RequestClient client = new CamundaClient();
1281                 client.setUrl("/test/url");
1282                 return client;
1283             }
1284         };
1285
1286         E2EServiceInstances instance = new E2EServiceInstances();
1287         Response response = instance.scaleE2EServiceInstance(scaleRequest, "v3", "12345");
1288         mockMsoRequest.tearDown();
1289         mockCDB.tearDown();
1290         mockRequestClient.tearDown();
1291     }
1292
1293     @Test
1294     public void scaleE2EserviceInstancesTestFailRequestClient(@Mocked AbstractSessionFactoryManager sessionFactoryManager,
1295                                                               @Mocked Session session) {
1296
1297         final MockUp<MsoRequest> mockMsoRequest = new MockUp<MsoRequest>() {
1298             @Mock
1299             public void createRequestRecord(Status status, Action action) {
1300                 return;
1301             }
1302         };
1303
1304         final MockUp<CatalogDatabase> mockCDB = new MockUp<CatalogDatabase>() {
1305             @Mock
1306             public Service getServiceByModelName(String modelName) {
1307                 Service svc = new Service();
1308                 return svc;
1309             }
1310
1311             @Mock
1312             public ServiceRecipe getServiceRecipeByModelUUID(String modelUUID,
1313                                                              String action) {
1314                 ServiceRecipe rec = new ServiceRecipe();
1315                 rec.setOrchestrationUri("/test/delE2E");
1316                 rec.setRecipeTimeout(180);
1317                 return rec;
1318             }
1319         };
1320
1321         E2EServiceInstances instance = new E2EServiceInstances();
1322         Response response = instance.scaleE2EServiceInstance(scaleRequest, "v3", "12345");
1323         mockMsoRequest.tearDown();
1324         mockCDB.tearDown();
1325     }
1326
1327 }