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